acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-router/src/core/middleware/compress/index.test.ts

@@ -0,0 +1,535 @@
+import { compress } from './index.ts'
+import { stream, streamSSE } from '../../helper/streaming/index.ts'
+import { App } from '../../app.ts'
+
+describe('Compress Middleware', () => {
+  const app = new App()
+
+  // Apply compress middleware to all routes
+  app.use('*', compress())
+
+  // Test routes
+  app.get('/small', (c) => {
+    c.header('Content-Type', 'text/plain')
+    c.header('Content-Length', '5')
+    return c.text('small')
+  })
+  app.get('/large', (c) => {
+    c.header('Content-Type', 'text/plain')
+    c.header('Content-Length', '1024')
+    return c.text('a'.repeat(1024))
+  })
+  app.get('/small-json', (c) => {
+    c.header('Content-Type', 'application/json')
+    c.header('Content-Length', '26')
+    return c.json({ message: 'Hello, World!' })
+  })
+  app.get('/large-json', (c) => {
+    c.header('Content-Type', 'application/json')
+    c.header('Content-Length', '1024')
+    return c.json({ data: 'a'.repeat(1024), message: 'Large JSON' })
+  })
+  app.get('/no-transform', (c) => {
+    c.header('Content-Type', 'text/plain')
+    c.header('Content-Length', '1024')
+    c.header('Cache-Control', 'no-transform')
+    return c.text('a'.repeat(1024))
+  })
+  app.get('/jpeg-image', (c) => {
+    c.header('Content-Type', 'image/jpeg')
+    c.header('Content-Length', '1024')
+    return c.body(new Uint8Array(1024)) // Simulated JPEG data
+  })
+  app.get('/already-compressed', (c) => {
+    c.header('Content-Type', 'application/octet-stream')
+    c.header('Content-Encoding', 'br')
+    c.header('Content-Length', '1024')
+    return c.body(new Uint8Array(1024)) // Simulated compressed data
+  })
+  app.get('/transfer-encoding-deflate', (c) => {
+    c.header('Content-Type', 'application/octet-stream')
+    c.header('Transfer-Encoding', 'deflate')
+    c.header('Content-Length', '1024')
+    return c.body(new Uint8Array(1024)) // Simulated deflate data
+  })
+  app.get('/chunked', (c) => {
+    c.header('Content-Type', 'application/octet-stream')
+    c.header('Transfer-Encoding', 'chunked')
+    c.header('Content-Length', '1024')
+    return c.body(new Uint8Array(1024)) // Simulated chunked data
+  })
+  app.get('/partial', (c) => {
+    c.header('Content-Type', 'text/plain')
+    c.header('Content-Length', '1024')
+    c.header('Content-Range', 'bytes 0-1023/2048')
+    return c.body('a'.repeat(1024), 206)
+  })
+  app.get('/stream', (c) =>
+    stream(c, async (stream) => {
+      c.header('Content-Type', 'text/plain')
+      // 60000 bytes
+      for (let i = 0; i < 10000; i++) {
+        await stream.write('chunk ')
+      }
+    })
+  )
+  app.get('/already-compressed-stream', (c) =>
+    stream(c, async (stream) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Encoding', 'br')
+      // 60000 bytes
+      for (let i = 0; i < 10000; i++) {
+        await stream.write(new Uint8Array([0, 1, 2, 3, 4, 5])) // Simulated compressed data
+      }
+    })
+  )
+  app.get('/sse', (c) =>
+    streamSSE(c, async (stream) => {
+      for (let i = 0; i < 1000; i++) {
+        await stream.writeSSE({ data: 'chunk' })
+      }
+    })
+  )
+  app.notFound((c) => c.text('Custom NotFound', 404))
+
+  const testCompression = async (
+    path: string,
+    acceptEncoding: string,
+    expectedEncoding: string | null
+  ) => {
+    const req = new Request(`http://localhost${path}`, {
+      method: 'GET',
+      headers: new Headers({ 'Accept-Encoding': acceptEncoding }),
+    })
+    const res = await app.request(req)
+    expect(res.headers.get('Content-Encoding')).toBe(expectedEncoding)
+    return res
+  }
+
+  describe('Compression Behavior', () => {
+    it('should compress large responses with gzip', async () => {
+      const res = await testCompression('/large', 'gzip', 'gzip')
+      expect(res.headers.get('Content-Length')).toBeNull()
+      expect((await res.arrayBuffer()).byteLength).toBeLessThan(1024)
+    })
+
+    it('should compress large responses with deflate', async () => {
+      const res = await testCompression('/large', 'deflate', 'deflate')
+      expect((await res.arrayBuffer()).byteLength).toBeLessThan(1024)
+    })
+
+    it('should prioritize gzip over deflate when both are accepted', async () => {
+      await testCompression('/large', 'gzip, deflate', 'gzip')
+    })
+
+    it('should not compress small responses', async () => {
+      const res = await testCompression('/small', 'gzip, deflate', null)
+      expect(res.headers.get('Content-Length')).toBe('5')
+    })
+
+    it('should not compress when no Accept-Encoding is provided', async () => {
+      await testCompression('/large', '', null)
+    })
+
+    it('should not compress images', async () => {
+      const res = await testCompression('/jpeg-image', 'gzip', null)
+      expect(res.headers.get('Content-Type')).toBe('image/jpeg')
+      expect(res.headers.get('Content-Length')).toBe('1024')
+    })
+
+    it('should not compress already compressed responses', async () => {
+      const res = await testCompression('/already-compressed', 'gzip', 'br')
+      expect(res.headers.get('Content-Length')).toBe('1024')
+    })
+
+    it('should remove Content-Length when compressing', async () => {
+      const res = await testCompression('/large', 'gzip', 'gzip')
+      expect(res.headers.get('Content-Length')).toBeNull()
+    })
+
+    it('should not remove Content-Length when not compressing', async () => {
+      const res = await testCompression('/jpeg-image', 'gzip', null)
+      expect(res.headers.get('Content-Length')).toBeDefined()
+    })
+
+    it('should not compress transfer-encoding: deflate', async () => {
+      const res = await testCompression('/transfer-encoding-deflate', 'gzip', null)
+      expect(res.headers.get('Content-Length')).toBe('1024')
+      expect(res.headers.get('Transfer-Encoding')).toBe('deflate')
+    })
+
+    it('should not compress transfer-encoding: chunked', async () => {
+      const res = await testCompression('/chunked', 'gzip', null)
+      expect(res.headers.get('Content-Length')).toBe('1024')
+      expect(res.headers.get('Transfer-Encoding')).toBe('chunked')
+    })
+
+    it('should not compress 206 Partial Content responses', async () => {
+      const res = await testCompression('/partial', 'gzip', null)
+      expect(res.status).toBe(206)
+      expect(res.headers.get('Content-Length')).toBe('1024')
+      expect(res.headers.get('Content-Range')).toBe('bytes 0-1023/2048')
+      expect(await res.text()).toBe('a'.repeat(1024))
+    })
+  })
+
+  describe('JSON Handling', () => {
+    it('should not compress small JSON responses', async () => {
+      const res = await testCompression('/small-json', 'gzip', null)
+      expect(res.headers.get('Content-Length')).toBe('26')
+    })
+
+    it('should compress large JSON responses', async () => {
+      const res = await testCompression('/large-json', 'gzip', 'gzip')
+      expect(res.headers.get('Content-Length')).toBeNull()
+      const decompressed = await decompressResponse(res)
+      const json = JSON.parse(decompressed)
+      expect(json.data.length).toBe(1024)
+      expect(json.message).toBe('Large JSON')
+    })
+  })
+
+  describe('Streaming Responses', () => {
+    it('should compress streaming responses written in multiple chunks', async () => {
+      const res = await testCompression('/stream', 'gzip', 'gzip')
+      const decompressed = await decompressResponse(res)
+      expect(decompressed.length).toBe(60000)
+    })
+
+    it('should not compress already compressed streaming responses', async () => {
+      const res = await testCompression('/already-compressed-stream', 'gzip', 'br')
+      expect((await res.arrayBuffer()).byteLength).toBe(60000)
+    })
+
+    it('should not compress server-sent events', async () => {
+      const res = await testCompression('/sse', 'gzip', null)
+      expect((await res.arrayBuffer()).byteLength).toBe(13000)
+    })
+  })
+
+  describe('ETag Handling', () => {
+    const app = new App()
+    app.use('*', compress())
+    app.get('/strong-etag', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      c.header('ETag', '"strong-etag"')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/weak-etag', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      c.header('ETag', 'W/"weak-etag"')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/no-etag', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      return c.text('a'.repeat(1024))
+    })
+
+    it('should convert strong ETag to weak ETag when compressing', async () => {
+      const res = await app.request('/strong-etag', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('ETag')).toBe('W/"strong-etag"')
+    })
+
+    it('should keep strong ETag when not compressing', async () => {
+      const res = await app.request('/strong-etag')
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+      expect(res.headers.get('ETag')).toBe('"strong-etag"')
+    })
+
+    it('should not modify weak ETag when compressing', async () => {
+      const res = await app.request('/weak-etag', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('ETag')).toBe('W/"weak-etag"')
+    })
+
+    it('should not add ETag when none exists', async () => {
+      const res = await app.request('/no-etag', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('ETag')).toBeNull()
+    })
+  })
+
+  describe('Vary Header', () => {
+    const app = new App()
+    app.use('*', compress())
+    app.get('/no-vary', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/existing-vary', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      c.header('Vary', 'Cookie')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/already-accept-encoding', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      c.header('Vary', 'Accept-Encoding')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/wildcard-vary', (c) => {
+      c.header('Content-Type', 'text/plain')
+      c.header('Content-Length', '1024')
+      c.header('Vary', '*')
+      return c.text('a'.repeat(1024))
+    })
+    app.get('/not-compressible', (c) => {
+      c.header('Content-Type', 'image/png')
+      c.header('Content-Length', '1024')
+      return c.body('a'.repeat(1024))
+    })
+
+    it('should set Vary: Accept-Encoding when compressing', async () => {
+      const res = await app.request('/no-vary', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('Vary')).toBe('Accept-Encoding')
+    })
+
+    it('should append Accept-Encoding to an existing Vary header', async () => {
+      const res = await app.request('/existing-vary', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('Vary')).toBe('Cookie, Accept-Encoding')
+    })
+
+    it('should not duplicate Accept-Encoding when Vary already lists it', async () => {
+      const res = await app.request('/already-accept-encoding', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('Vary')).toBe('Accept-Encoding')
+    })
+
+    it('should leave Vary: * unchanged', async () => {
+      const res = await app.request('/wildcard-vary', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      expect(res.headers.get('Vary')).toBe('*')
+    })
+
+    it('should set Vary on an identity response when Accept-Encoding is absent', async () => {
+      const res = await app.request('/no-vary')
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+      expect(res.headers.get('Vary')).toBe('Accept-Encoding')
+    })
+
+    it('should set Vary on an identity response when no offered encoding is accepted', async () => {
+      const res = await app.request('/no-vary', {
+        headers: { 'Accept-Encoding': 'br' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+      expect(res.headers.get('Vary')).toBe('Accept-Encoding')
+    })
+
+    it('should not add a Vary header when the response is not eligible for compression', async () => {
+      const res = await app.request('/not-compressible', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+      expect(res.headers.get('Vary')).toBeNull()
+    })
+  })
+
+  describe('contentTypeFilter', () => {
+    describe('RegExp', () => {
+      const app = new App()
+      app.use('*', compress({ contentTypeFilter: /^application\/json/, threshold: 0 }))
+      app.get('/json', (c) => c.json({ data: 'a'.repeat(1024) }))
+      app.get('/text', (c) => c.text('a'.repeat(1024)))
+
+      it('should compress when Content-Type matches', async () => {
+        const res = await app.request('/json', {
+          headers: { 'Accept-Encoding': 'gzip' },
+        })
+        expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      })
+
+      it('should not compress when Content-Type does not match', async () => {
+        const res = await app.request('/text', {
+          headers: { 'Accept-Encoding': 'gzip' },
+        })
+        expect(res.headers.get('Content-Encoding')).toBeNull()
+      })
+    })
+
+    describe('function', () => {
+      const app = new App()
+      app.use('*', compress({ contentTypeFilter: (type) => type.includes('json'), threshold: 0 }))
+      app.get('/json', (c) => c.json({ data: 'a'.repeat(1024) }))
+      app.get('/text', (c) => c.text('a'.repeat(1024)))
+
+      it('should compress when Content-Type matches', async () => {
+        const res = await app.request('/json', {
+          headers: { 'Accept-Encoding': 'gzip' },
+        })
+        expect(res.headers.get('Content-Encoding')).toBe('gzip')
+      })
+
+      it('should not compress when Content-Type does not match', async () => {
+        const res = await app.request('/text', {
+          headers: { 'Accept-Encoding': 'gzip' },
+        })
+        expect(res.headers.get('Content-Encoding')).toBeNull()
+      })
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should not compress responses with Cache-Control: no-transform', async () => {
+      await testCompression('/no-transform', 'gzip', null)
+    })
+
+    it('should handle HEAD requests without compression', async () => {
+      const req = new Request('http://localhost/large', {
+        method: 'HEAD',
+        headers: new Headers({ 'Accept-Encoding': 'gzip' }),
+      })
+      const res = await app.request(req)
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+    })
+
+    it('should compress custom 404 Not Found responses', async () => {
+      const res = await testCompression('/not-found', 'gzip', 'gzip')
+      expect(res.status).toBe(404)
+      const decompressed = await decompressResponse(res)
+      expect(decompressed).toBe('Custom NotFound')
+    })
+  })
+
+  describe('Encoding Option', () => {
+    const buildApp = (encoding: 'gzip' | 'deflate') => {
+      const app = new App()
+      app.use('*', compress({ encoding }))
+      app.get('/large', (c) => {
+        c.header('Content-Type', 'text/plain')
+        c.header('Content-Length', '1024')
+        return c.text('a'.repeat(1024))
+      })
+      return app
+    }
+
+    it('should compress when configured encoding is accepted by the client', async () => {
+      const app = buildApp('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+    })
+
+    it('should not compress when configured encoding is not in Accept-Encoding', async () => {
+      const app = buildApp('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'deflate' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+    })
+
+    it('should not compress when Accept-Encoding header is absent', async () => {
+      const app = buildApp('gzip')
+      const res = await app.request('/large')
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+    })
+  })
+
+  describe('Accept-Encoding parsing', () => {
+    const buildAppDefault = () => {
+      const app = new App()
+      app.use('*', compress())
+      app.get('/large', (c) => {
+        c.header('Content-Type', 'text/plain')
+        c.header('Content-Length', '1024')
+        return c.text('a'.repeat(1024))
+      })
+      return app
+    }
+
+    const buildAppWithEncoding = (encoding: 'gzip' | 'deflate') => {
+      const app = new App()
+      app.use('*', compress({ encoding }))
+      app.get('/large', (c) => {
+        c.header('Content-Type', 'text/plain')
+        c.header('Content-Length', '1024')
+        return c.text('a'.repeat(1024))
+      })
+      return app
+    }
+
+    it('should not compress when configured encoding has q=0', async () => {
+      const app = buildAppWithEncoding('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'gzip;q=0' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+    })
+
+    it('should fall back to another encoding when the preferred one has q=0', async () => {
+      const app = buildAppDefault()
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'gzip;q=0, deflate' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('deflate')
+    })
+
+    it('should compress when Accept-Encoding is the wildcard *', async () => {
+      const app = buildAppWithEncoding('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': '*' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+    })
+
+    it('should compress when Accept-Encoding token differs only in case', async () => {
+      const app = buildAppWithEncoding('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'GZIP' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+    })
+
+    it('should not treat x-gzip as gzip', async () => {
+      const app = buildAppWithEncoding('gzip')
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'x-gzip' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+    })
+
+    it('should pick the encoding with the highest q value', async () => {
+      const app = buildAppDefault()
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'gzip;q=0.5, deflate;q=0.9' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('deflate')
+    })
+
+    it('should prefer gzip over deflate when q values are equal', async () => {
+      const app = buildAppDefault()
+      const res = await app.request('/large', {
+        headers: { 'Accept-Encoding': 'gzip;q=0.5, deflate;q=0.5' },
+      })
+      expect(res.headers.get('Content-Encoding')).toBe('gzip')
+    })
+  })
+})
+
+async function decompressResponse(res: Response): Promise<string> {
+  const decompressedStream = res.body!.pipeThrough(new DecompressionStream('gzip'))
+  const decompressedResponse = new Response(decompressedStream)
+  return await decompressedResponse.text()
+}

package/plugins/acryl-router/src/core/middleware/compress/index.ts

@@ -0,0 +1,142 @@
+/**
+ * @module
+ * Compress Middleware for App.
+ */
+
+import type { MiddlewareHandler } from '../../types.ts'
+import { parseAccept } from '../../utils/accept.ts'
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from '../../utils/compress.ts'
+
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX }
+
+const ENCODING_TYPES = ['gzip', 'deflate'] as const
+type Encoding = (typeof ENCODING_TYPES)[number]
+const cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i
+
+type ContentTypeFilter = RegExp | ((contentType: string) => boolean)
+
+interface CompressionOptions {
+  encoding?: Encoding
+  threshold?: number
+  contentTypeFilter?: ContentTypeFilter
+}
+
+const selectEncoding = (
+  header: string | undefined,
+  candidates: readonly Encoding[]
+): Encoding | undefined => {
+  if (header === undefined) {
+    return undefined
+  }
+  const accepts = parseAccept(header)
+  const wildcardQ = accepts.find((a) => a.type === '*')?.q
+  let best: { encoding: Encoding; q: number } | undefined
+  for (const enc of candidates) {
+    const explicit = accepts.find((a) => a.type.toLowerCase() === enc)
+    const q = explicit ? explicit.q : (wildcardQ ?? 0)
+    if (q === 1) {
+      return enc
+    } else if (q > 0 && (!best || q > best.q)) {
+      best = { encoding: enc, q }
+    }
+  }
+  return best?.encoding
+}
+
+const varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i
+
+/**
+ * Compress Middleware for App.
+ *
+ *
+ * @param {CompressionOptions} [options] - The options for the compress middleware.
+ * @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+ * @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+ * @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new App()
+ *
+ * app.use(compress())
+ *
+ * // Compress only JSON responses
+ * app.use(compress({ contentTypeFilter: /^application\/json/ }))
+ *
+ * // Compress based on custom Content-Type logic
+ * app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
+ * ```
+ */
+export const compress = (options?: CompressionOptions): MiddlewareHandler => {
+  const threshold = options?.threshold ?? 1024
+  const candidates: readonly Encoding[] = options?.encoding ? [options.encoding] : ENCODING_TYPES
+
+  const contentTypeFilter = options?.contentTypeFilter ?? COMPRESSIBLE_CONTENT_TYPE_REGEX
+  const shouldCompress =
+    typeof contentTypeFilter === 'function'
+      ? (res: Response) => {
+          const type = res.headers.get('Content-Type')
+          return type && contentTypeFilter(type)
+        }
+      : (res: Response) => {
+          const type = res.headers.get('Content-Type')
+          return type && contentTypeFilter.test(type)
+        }
+
+  return async function compress(ctx, next) {
+    await next()
+
+    const contentLength = ctx.res.headers.get('Content-Length')
+
+    // Check if response should be compressed
+    if (
+      ctx.res.status === 206 || // partial content, Content-Range refers to the uncompressed bytes
+      ctx.res.headers.has('Content-Encoding') || // already encoded
+      ctx.res.headers.has('Transfer-Encoding') || // already encoded or chunked
+      ctx.req.method === 'HEAD' || // HEAD request
+      (contentLength && Number(contentLength) < threshold) || // content-length below threshold
+      !shouldCompress(ctx.res) || // not compressible type
+      !shouldTransform(ctx.res) // cache-control: no-transform
+    ) {
+      return
+    }
+
+    // From here on the representation is selected from the request's Accept-Encoding,
+    // so caches must key on that header. This is done before the negotiation result is
+    // known, because an identity response served for a missing or unsupported
+    // Accept-Encoding is just as much a negotiated representation: RFC 9110 lists
+    // Accept-Encoding "or lack thereof" as a determining factor. Without this, a shared
+    // cache could reuse the identity response for a client that does accept gzip.
+    // https://www.rfc-editor.org/rfc/rfc9110#field.vary
+    const current = ctx.res.headers.get('Vary')
+    if (current !== '*' && !(current && varyAcceptEncodingRegExp.test(current))) {
+      ctx.header('Vary', current ? `${current}, Accept-Encoding` : 'Accept-Encoding')
+    }
+
+    const accepted = ctx.req.header('Accept-Encoding')
+    const encoding = selectEncoding(accepted, candidates)
+    if (!encoding || !ctx.res.body) {
+      return
+    }
+
+    // Compress the response
+    const stream = new CompressionStream(encoding)
+    ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res)
+    ctx.res.headers.delete('Content-Length')
+    ctx.res.headers.set('Content-Encoding', encoding)
+
+    // Convert strong ETag to weak ETag since compressed content is not byte-identical
+    const etag = ctx.res.headers.get('ETag')
+    if (etag && !etag.startsWith('W/')) {
+      ctx.res.headers.set('ETag', `W/${etag}`)
+    }
+  }
+}
+
+const shouldTransform = (res: Response) => {
+  const cacheControl = res.headers.get('Cache-Control')
+  // Don't compress for Cache-Control: no-transform
+  // https://tools.ietf.org/html/rfc7234#section-5.2.2.4
+  return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl)
+}