Add cached response behavior tests

Add coverage for cached static file responses to ensure ETag,
Cache-Control, 304 revalidation, custom headers, content-type,
and index.html behavior remain consistent after an ElysiaFile is
served from the LRU cache.

Update the cached response path so cached files run through the
same header and conditional request logic as uncached files.

Author: yuriiShmal

bun.lock

@@ -90,73 +90,76 @@ export async function staticPlugin<const Prefix extends string = '/prefix'>({
             for (const [headerName, headerVal] of Object.entries(
                 initialHeaders ?? {}
             )) {
-                set['headers'][headerName] = headerVal
+                set.headers[headerName] = headerVal
             }
         }
 
+        const finalizeFileResponse = async (
+            file: ElysiaFile,
+            filePath: string
+        ) => {
+            setInitialHeaders()
+
+            if (!useETag) return file
+
+            const etag = await generateETag(file)
+
+            if (etag && (await isCached(requestHeaders, etag, filePath)))
+                return new Response(null, {
+                    status: 304
+                })
+
+            set.headers['etag'] = etag
+            set.headers['cache-control'] = maxAge
+                ? `${directive}, max-age=${maxAge}`
+                : directive
+
+            return file
+        }
+
         if (shouldIgnore(relativeFilePath)) throw new NotFoundError()
 
         const cachedFile = fileCache.get(relativeFilePath)
-        if (cachedFile) {
-            setInitialHeaders()
-            return cachedFile
-        }
+        if (cachedFile) return finalizeFileResponse(cachedFile, relativeFilePath)
 
         try {
             const fileStat = await fs.stat(relativeFilePath).catch(() => null)
             if (!fileStat) throw new NotFoundError()
 
             if (!indexHTML && fileStat.isDirectory()) throw new NotFoundError()
 
-            // @ts-ignore
             let file:
                 | NonNullable<Awaited<ReturnType<typeof getFile>>>
                 | undefined
 
+            let cacheKey = relativeFilePath
+
             if (fileStat.isDirectory() && indexHTML) {
                 const htmlPath = path.join(relativeFilePath, 'index.html')
                 const cachedFile = fileCache.get(htmlPath)
-                if (cachedFile) {
-                    setInitialHeaders()
-                    return cachedFile
-                }
+
+                if (cachedFile) return finalizeFileResponse(cachedFile, htmlPath)
 
                 if (await fileExists(htmlPath)) {
+                    cacheKey = htmlPath
+
                     if (bunFullstack) {
-                        file = (await import(htmlPath)).default // TODO: full path needed?
+                        file = (await import(htmlPath)).default
                     } else {
                         file = getFile(htmlPath)
                     }
                 }
             }
+
             if (!fileStat.isDirectory()) {
                 file = getFile(relativeFilePath)
             }
 
             if (!file) throw new NotFoundError()
-            fileCache.set(relativeFilePath, file)
 
-            if (!useETag) {
-                setInitialHeaders()
-                return file
-            }
+            fileCache.set(cacheKey, file)
 
-            const etag = await generateETag(file)
-            if (
-                etag &&
-                (await isCached(requestHeaders, etag, relativeFilePath))
-            )
-                return new Response(null, {
-                    status: 304
-                })
-
-            setInitialHeaders()
-
-            set.headers['etag'] = etag
-            set.headers['cache-control'] = maxAge
-                ? `${directive}, max-age=${maxAge}`
-                : directive
-            return file
+            return finalizeFileResponse(file, cacheKey)
         } catch (error) {
             if (error instanceof NotFoundError) throw error
             if (!silent) console.error(`[@elysiajs/static]`, error)

src/index.ts

@@ -473,4 +473,169 @@ describe('Static Plugin', () => {
         const jsFile = await app.handle(req('/public/js/index.js'))
         expect(jsFile.headers.get('content-type')).toContain('/javascript')
     })
+
+    it('preserves content-type on cached file responses', async () => {
+        const app = new Elysia().use(staticPlugin())
+
+        await app.modules
+
+        const first = await app.handle(req('/public/js/index.js'))
+        expect(first.status).toBe(200)
+        expect(first.headers.get('content-type')).toContain('/javascript')
+
+        const second = await app.handle(req('/public/js/index.js'))
+        expect(second.status).toBe(200)
+        expect(second.headers.get('content-type')).toContain('/javascript')
+    })
+
+    it('preserves custom headers on cached file responses', async () => {
+        const app = new Elysia().use(
+            staticPlugin({
+                headers: {
+                    'x-static-test': 'cached'
+                }
+            })
+        )
+
+        await app.modules
+
+        const first = await app.handle(req('/public/takodachi.png'))
+        expect(first.status).toBe(200)
+        expect(first.headers.get('x-static-test')).toBe('cached')
+
+        const second = await app.handle(req('/public/takodachi.png'))
+        expect(second.status).toBe(200)
+        expect(second.headers.get('x-static-test')).toBe('cached')
+    })
+
+    it('preserves etag and cache-control headers on cached file responses', async () => {
+        const app = new Elysia().use(
+            staticPlugin({
+                maxAge: 3600,
+                directive: 'private'
+            })
+        )
+
+        await app.modules
+
+        const first = await app.handle(req('/public/takodachi.png'))
+        expect(first.status).toBe(200)
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+        expect(first.headers.get('cache-control')).toBe('private, max-age=3600')
+
+        const second = await app.handle(req('/public/takodachi.png'))
+        expect(second.status).toBe(200)
+        expect(second.headers.get('etag')).toBe(etag)
+        expect(second.headers.get('cache-control')).toBe(
+            'private, max-age=3600'
+        )
+    })
+
+    it('returns 304 for if-none-match after the file has been cached', async () => {
+        const app = new Elysia().use(staticPlugin())
+
+        await app.modules
+
+        const first = await app.handle(req('/public/takodachi.png'))
+        expect(first.status).toBe(200)
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+
+        const request = req('/public/takodachi.png')
+        request.headers.set('if-none-match', etag!)
+
+        const second = await app.handle(request)
+
+        expect(second.status).toBe(304)
+        expect(second.body).toBe(null)
+    })
+
+    it('does not return 304 when cache-control no-cache is sent after file is cached', async () => {
+        const app = new Elysia().use(staticPlugin())
+
+        await app.modules
+
+        const first = await app.handle(req('/public/takodachi.png'))
+        expect(first.status).toBe(200)
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+
+        const request = req('/public/takodachi.png')
+        request.headers.set('if-none-match', etag!)
+        request.headers.set('cache-control', 'no-cache')
+
+        const second = await app.handle(request)
+
+        expect(second.status).toBe(200)
+        expect(await second.blob().then((b) => b.text())).toBe(takodachi.toString())
+    })
+
+    it('returns 304 for if-none-match after cached alwaysStatic route response', async () => {
+        const app = new Elysia().use(
+            staticPlugin({
+                alwaysStatic: true,
+                extension: false
+            })
+        )
+
+        await app.modules
+
+        const first = await app.handle(req('/public/takodachi'))
+        expect(first.status).toBe(200)
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+
+        const request = req('/public/takodachi')
+        request.headers.set('if-none-match', etag!)
+
+        const second = await app.handle(request)
+
+        expect(second.status).toBe(304)
+        expect(second.body).toBe(null)
+    })
+
+    it('serves index.html from cache with content-type and cache headers', async () => {
+        const app = new Elysia().use(staticPlugin())
+
+        await app.modules
+
+        const first = await app.handle(req('/public/html'))
+        expect(first.status).toBe(200)
+        expect(first.headers.get('content-type')).toContain('text/html')
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+        expect(first.headers.get('cache-control')).toBe('public, max-age=86400')
+
+        const second = await app.handle(req('/public/html'))
+        expect(second.status).toBe(200)
+        expect(second.headers.get('content-type')).toContain('text/html')
+        expect(second.headers.get('etag')).toBe(etag)
+        expect(second.headers.get('cache-control')).toBe('public, max-age=86400')
+    })
+
+    it('returns 304 for cached index.html default route', async () => {
+        const app = new Elysia().use(staticPlugin())
+
+        await app.modules
+
+        const first = await app.handle(req('/public/html'))
+        expect(first.status).toBe(200)
+
+        const etag = first.headers.get('etag')
+        expect(etag).toBeTruthy()
+
+        const request = req('/public/html')
+        request.headers.set('if-none-match', etag!)
+
+        const second = await app.handle(request)
+
+        expect(second.status).toBe(304)
+        expect(second.body).toBe(null)
+    })
 })