@fastify/compress 8.0.3 → 8.2.0

package/.github/workflows/ci.yml

@@ -14,6 +14,11 @@ on:
       - 'docs/**'
       - '*.md'
 
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+    group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+    cancel-in-progress: true
+
 permissions:
   contents: read
 

package/LICENSE

@@ -1,6 +1,8 @@
 MIT License
 
-Copyright (c) 2017 Fastify
+Copyright (c) 2017-present The Fastify team
+
+The Fastify team members are listed at https://github.com/fastify/fastify#team.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -5,7 +5,7 @@
 [![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
 
 Adds compression utils to [the Fastify `reply` object](https://fastify.dev/docs/latest/Reference/Reply/#reply) and a hook to decompress requests payloads.
-Supports `gzip`, `deflate`, and `brotli`.
+Supports `gzip`, `deflate`, `brotli`, and `zstd` (Node.js 22.15+/23.8+).
 
 > ℹ️ Note: In large-scale scenarios, use a proxy like Nginx to handle response compression.
 
@@ -37,11 +37,12 @@ This plugin adds two functionalities to Fastify: a compress utility and a global
 
 Currently, the following encoding tokens are supported, using the first acceptable token in this order:
 
-1. `br`
-2. `gzip`
-3. `deflate`
-4. `*` (no preference — `@fastify/compress` will use `gzip`)
-5. `identity` (no compression)
+1. `zstd` (Node.js 22.15+/23.8+)
+2. `br`
+3. `gzip`
+4. `deflate`
+5. `*` (no preference — `@fastify/compress` will use `gzip`)
+6. `identity` (no compression)
 
 If an unsupported encoding is received or the `'accept-encoding'` header is missing, the payload will not be compressed.
 To return an error for unsupported encoding, use the `onUnsupportedEncoding` option.
@@ -105,6 +106,40 @@ app.get('/', (req, reply) => {
 await app.listen({ port: 3000 })
 ```
 
+It's also possible to pass a Fetch API `Response` object or a Web `ReadableStream`. The plugin will automatically extract the body stream from the `Response` or convert the Web stream to a Node.js `Readable` behind the scenes.
+
+```js
+import fastify from 'fastify'
+
+const app = fastify()
+await app.register(import('@fastify/compress'), { global: true })
+
+app.get('/', async (req, reply) => {
+  const resp = new Response('Hello from Fetch Response')
+  reply.compress(resp)
+})
+```
+
+```js
+app.get('/', async (req, reply) => {
+  return new Response('Hello from Fetch Response')
+})
+```
+
+```js
+app.get('/', (req, reply) => {
+  const stream = new ReadableStream({
+    start (controller) {
+      controller.enqueue(new TextEncoder().encode('Hello from Web ReadableStream'))
+      controller.close()
+    }
+  })
+
+  reply.header('content-type', 'text/plain')
+  reply.compress(stream)
+})
+```
+
 ## Compress Options
 
 ### threshold
@@ -175,6 +210,13 @@ await fastify.register(
   // Only support gzip and deflate, and prefer deflate to gzip
   { encodings: ['deflate', 'gzip'] }
 )
+
+// Example with zstd support (Node.js 22.15+/23.8+)
+await fastify.register(
+  import('@fastify/compress'),
+  // Prefer zstd, fallback to brotli, then gzip
+  { encodings: ['zstd', 'br', 'gzip'] }
+)
 ```
 
 ### brotliOptions and zlibOptions
@@ -214,14 +256,24 @@ This plugin adds a `preParsing` hook to decompress the request payload based on
 
 Currently, the following encoding tokens are supported:
 
-1. `br`
-2. `gzip`
-3. `deflate`
+- `zstd` (Node.js 22.15+/23.8+)
+- `br`
+- `gzip`
+- `deflate`
 
 If an unsupported encoding or invalid payload is received, the plugin throws an error.
 
 If the request header is missing, the plugin yields to the next hook.
 
+### Supported payload types
+
+The plugin supports compressing the following payload types:
+
+- Strings and Buffers
+- Node.js streams
+- Response objects (from the Fetch API)
+- ReadableStream objects (from the Web Streams API)
+
 ### Global hook
 
 The global request decompression hook is enabled by default. To disable it, pass `{ global: false }`:
@@ -268,6 +320,13 @@ await fastify.register(
   // Only support gzip
   { requestEncodings: ['gzip'] }
 )
+
+// Example with zstd support for request decompression (Node.js 22.15+/23.8+)
+await fastify.register(
+  import('@fastify/compress'),
+  // Support zstd, brotli and gzip for request decompression
+  { requestEncodings: ['zstd', 'br', 'gzip'] }
+)
 ```
 
 ### forceRequestEncoding

package/index.js

@@ -12,7 +12,7 @@ const { Minipass } = require('minipass')
 const pumpify = require('pumpify')
 const { Readable } = require('readable-stream')
 
-const { isStream, isGzip, isDeflate, intoAsyncIterator } = require('./lib/utils')
+const { isStream, isGzip, isDeflate, intoAsyncIterator, isWebReadableStream, isFetchResponse, webStreamToNodeReadable } = require('./lib/utils')
 
 const InvalidRequestEncodingError = createError('FST_CP_ERR_INVALID_CONTENT_ENCODING', 'Unsupported Content-Encoding: %s', 415)
 const InvalidRequestCompressedPayloadError = createError('FST_CP_ERR_INVALID_CONTENT', 'Could not decompress the request payload using the provided encoding', 400)
@@ -145,6 +145,9 @@ function processCompressParams (opts) {
     gzip: () => ((opts.zlib || zlib).createGzip || zlib.createGzip)(params.zlibOptions),
     deflate: () => ((opts.zlib || zlib).createDeflate || zlib.createDeflate)(params.zlibOptions)
   }
+  if (typeof ((opts.zlib || zlib).createZstdCompress || zlib.createZstdCompress) === 'function') {
+    params.compressStream.zstd = () => ((opts.zlib || zlib).createZstdCompress || zlib.createZstdCompress)(params.zlibOptions)
+  }
   params.uncompressStream = {
     // Currently params.uncompressStream.br() is never called as we do not have any way to autodetect brotli compression in `fastify-compress`
     // Brotli documentation reference: [RFC 7932](https://www.rfc-editor.org/rfc/rfc7932)
@@ -152,8 +155,16 @@ function processCompressParams (opts) {
     gzip: () => ((opts.zlib || zlib).createGunzip || zlib.createGunzip)(params.zlibOptions),
     deflate: () => ((opts.zlib || zlib).createInflate || zlib.createInflate)(params.zlibOptions)
   }
+  if (typeof ((opts.zlib || zlib).createZstdDecompress || zlib.createZstdDecompress) === 'function') {
+    // Currently params.uncompressStream.zstd() is never called as we do not have any way to autodetect zstd compression in `fastify-compress`
+    // Zstd documentation reference: [RFC 8878](https://www.rfc-editor.org/rfc/rfc8878)
+    params.uncompressStream.zstd = /* c8 ignore next */ () => ((opts.zlib || zlib).createZstdDecompress || zlib.createZstdDecompress)(params.zlibOptions)
+  }
 
   const supportedEncodings = ['br', 'gzip', 'deflate', 'identity']
+  if (typeof zlib.createZstdCompress === 'function') {
+    supportedEncodings.unshift('zstd')
+  }
 
   params.encodings = Array.isArray(opts.encodings)
     ? supportedEncodings
@@ -184,8 +195,14 @@ function processDecompressParams (opts) {
     encodings: [],
     forceEncoding: null
   }
+  if (typeof (customZlib.createZstdDecompress || zlib.createZstdDecompress) === 'function') {
+    params.decompressStream.zstd = customZlib.createZstdDecompress || zlib.createZstdDecompress
+  }
 
   const supportedEncodings = ['br', 'gzip', 'deflate', 'identity']
+  if (typeof zlib.createZstdCompress === 'function') {
+    supportedEncodings.unshift('zstd')
+  }
 
   params.encodings = Array.isArray(opts.requestEncodings)
     ? supportedEncodings
@@ -237,6 +254,7 @@ function buildRouteCompress (_fastify, params, routeOptions, decorateOnly) {
     if (payload == null) {
       return next()
     }
+
     const responseEncoding = reply.getHeader('Content-Encoding')
     if (responseEncoding && responseEncoding !== 'identity') {
       // response is already compressed
@@ -273,10 +291,18 @@ function buildRouteCompress (_fastify, params, routeOptions, decorateOnly) {
     }
 
     if (typeof payload.pipe !== 'function') {
-      if (Buffer.byteLength(payload) < params.threshold) {
-        return next()
+      if (isFetchResponse(payload)) {
+        payload = payload.body
+      }
+
+      if (isWebReadableStream(payload)) {
+        payload = webStreamToNodeReadable(payload)
+      } else {
+        if (Buffer.byteLength(payload) < params.threshold) {
+          return next()
+        }
+        payload = Readable.from(intoAsyncIterator(payload))
       }
-      payload = Readable.from(intoAsyncIterator(payload))
     }
 
     setVaryHeader(reply)
@@ -391,7 +417,13 @@ function compress (params) {
     }
 
     if (typeof payload.pipe !== 'function') {
-      if (!Buffer.isBuffer(payload) && typeof payload !== 'string') {
+      if (isFetchResponse(payload)) {
+        payload = payload.body
+      }
+
+      if (isWebReadableStream(payload)) {
+        payload = webStreamToNodeReadable(payload)
+      } else if (!Buffer.isBuffer(payload) && typeof payload !== 'string') {
         payload = this.serialize(payload)
       }
     }

package/lib/utils.js

@@ -1,5 +1,21 @@
 'use strict'
 
+const { Readable: NodeReadable } = require('node:stream')
+
+// https://datatracker.ietf.org/doc/html/rfc8878#section-3.1.1
+function isZstd (buffer) {
+  return (
+    typeof buffer === 'object' &&
+    buffer !== null &&
+    buffer.length > 3 &&
+    // Zstd magic number: 0xFD2FB528 (little-endian)
+    buffer[0] === 0x28 &&
+    buffer[1] === 0xb5 &&
+    buffer[2] === 0x2f &&
+    buffer[3] === 0xfd
+  )
+}
+
 // https://datatracker.ietf.org/doc/html/rfc1950#section-2
 function isDeflate (buffer) {
   return (
@@ -35,6 +51,18 @@ function isStream (stream) {
   return stream !== null && typeof stream === 'object' && typeof stream.pipe === 'function'
 }
 
+function isWebReadableStream (obj) {
+  return obj instanceof ReadableStream
+}
+
+function isFetchResponse (obj) {
+  return obj instanceof Response
+}
+
+function webStreamToNodeReadable (webStream) {
+  return NodeReadable.fromWeb(webStream)
+}
+
 /**
  * Provide a async iteratable for Readable.from
  */
@@ -76,4 +104,4 @@ async function * intoAsyncIterator (payload) {
   yield payload
 }
 
-module.exports = { isGzip, isDeflate, isStream, intoAsyncIterator }
+module.exports = { isZstd, isGzip, isDeflate, isStream, intoAsyncIterator, isWebReadableStream, isFetchResponse, webStreamToNodeReadable }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/compress",
-  "version": "8.0.3",
+  "version": "8.2.0",
   "description": "Fastify compression utils",
   "main": "index.js",
   "type": "commonjs",
@@ -16,16 +16,15 @@
     "readable-stream": "^4.5.2"
   },
   "devDependencies": {
-    "@fastify/pre-commit": "^2.1.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^24.0.8",
     "adm-zip": "^0.5.12",
     "c8": "^10.1.2",
     "eslint": "^9.17.0",
     "fastify": "^5.0.0",
     "jsonstream": "^1.0.3",
     "neostandard": "^0.12.0",
-    "tsd": "^0.31.0",
-    "typescript": "~5.7.2"
+    "tsd": "^0.33.0",
+    "typescript": "~5.9.2"
   },
   "scripts": {
     "lint": "eslint",
@@ -41,7 +40,8 @@
     "compression",
     "deflate",
     "gzip",
-    "brotli"
+    "brotli",
+    "zstd"
   ],
   "author": "Tomas Della Vedova - @delvedor (http://delved.org)",
   "contributors": [
@@ -83,7 +83,7 @@
     "url": "git+https://github.com/fastify/fastify-compress.git"
   },
   "tsd": {
-    "directory": "test/types"
+    "directory": "types"
   },
   "publishConfig": {
     "access": "public"

package/test/global-compress.test.js

@@ -9,6 +9,7 @@ const JSONStream = require('jsonstream')
 const Fastify = require('fastify')
 const compressPlugin = require('../index')
 const { once } = require('node:events')
+const { ReadableStream: WebReadableStream, Response } = globalThis
 
 describe('When `global` is not set, it is `true` by default :', async () => {
   test('it should compress Buffer data using brotli when `Accept-Encoding` request header is `br`', async (t) => {
@@ -33,6 +34,32 @@ describe('When `global` is not set, it is `true` by default :', async () => {
     t.assert.equal(payload.toString('utf-8'), buf.toString())
   })
 
+  test('it should compress Buffer data using zstd when `Accept-Encoding` request header is `zstd`', async (t) => {
+    if (typeof zlib.createZstdCompress !== 'function') {
+      t.skip('zstd not supported in this Node.js version')
+      return
+    }
+    t.plan(1)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    const buf = Buffer.from('hello world')
+    fastify.get('/', (_request, reply) => {
+      reply.send(buf)
+    })
+
+    const response = await fastify.inject({
+      url: '/',
+      method: 'GET',
+      headers: {
+        'accept-encoding': 'zstd'
+      }
+    })
+    const payload = zlib.zstdDecompressSync(response.rawPayload)
+    t.assert.equal(payload.toString('utf-8'), buf.toString())
+  })
+
   test('it should compress Buffer data using deflate when `Accept-Encoding` request header is `deflate`', async (t) => {
     t.plan(1)
 
@@ -100,6 +127,32 @@ describe('When `global` is not set, it is `true` by default :', async () => {
     t.assert.equal(payload.toString('utf-8'), JSON.stringify(json))
   })
 
+  test('it should compress JSON data using zstd when `Accept-Encoding` request header is `zstd`', async (t) => {
+    if (typeof zlib.createZstdCompress !== 'function') {
+      t.skip('zstd not supported in this Node.js version')
+      return
+    }
+    t.plan(1)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    const json = { hello: 'world' }
+    fastify.get('/', (_request, reply) => {
+      reply.send(json)
+    })
+
+    const response = await fastify.inject({
+      url: '/',
+      method: 'GET',
+      headers: {
+        'accept-encoding': 'zstd'
+      }
+    })
+    const payload = zlib.zstdDecompressSync(response.rawPayload)
+    t.assert.equal(payload.toString('utf-8'), JSON.stringify(json))
+  })
+
   test('it should compress JSON data using deflate when `Accept-Encoding` request header is `deflate`', async (t) => {
     t.plan(1)
 
@@ -213,6 +266,54 @@ describe('When `global` is not set, it is `true` by default :', async () => {
     const payload = zlib.gunzipSync(response.rawPayload)
     t.assert.equal(payload.toString('utf-8'), 'hello')
   })
+
+  test('it should compress a Fetch API Response body', async (t) => {
+    t.plan(1)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    const body = 'hello from fetch response'
+    fastify.get('/fetch-resp', (_request, reply) => {
+      const resp = new Response(body, { headers: { 'content-type': 'text/plain' } })
+      reply.send(resp)
+    })
+
+    const response = await fastify.inject({
+      url: '/fetch-resp',
+      method: 'GET',
+      headers: { 'accept-encoding': 'gzip' }
+    })
+    const payload = zlib.gunzipSync(response.rawPayload)
+    t.assert.equal(payload.toString('utf-8'), body)
+  })
+
+  test('it should compress a Web ReadableStream body', async (t) => {
+    t.plan(1)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    const body = 'hello from web stream'
+    fastify.get('/web-stream', (_request, reply) => {
+      const stream = new WebReadableStream({
+        start (controller) {
+          controller.enqueue(Buffer.from(body))
+          controller.close()
+        }
+      })
+      reply.header('content-type', 'text/plain')
+      reply.send(stream)
+    })
+
+    const response = await fastify.inject({
+      url: '/web-stream',
+      method: 'GET',
+      headers: { 'accept-encoding': 'gzip' }
+    })
+    const payload = zlib.gunzipSync(response.rawPayload)
+    t.assert.equal(payload.toString('utf-8'), body)
+  })
 })
 
 describe('It should send compressed Stream data when `global` is `true` :', async () => {

package/test/global-decompress.test.js

@@ -42,6 +42,33 @@ describe('It should decompress the request payload :', async () => {
     t.assert.equal(response.body, '@fastify/compress')
   })
 
+  test('using zstd algorithm when `Content-Encoding` request header value is set to `zstd`', async (t) => {
+    if (typeof zlib.createZstdCompress !== 'function') {
+      t.skip('zstd not supported in this Node.js version')
+      return
+    }
+    t.plan(2)
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin)
+
+    fastify.post('/', (request, reply) => {
+      reply.send(request.body.name)
+    })
+
+    const response = await fastify.inject({
+      url: '/',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-encoding': 'zstd'
+      },
+      payload: createPayload(zlib.createZstdCompress)
+    })
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.body, '@fastify/compress')
+  })
+
   test('using deflate algorithm when `Content-Encoding` request header value is set to `deflate`', async (t) => {
     t.plan(2)
 

package/test/routes-compress.test.js

@@ -440,3 +440,33 @@ test('It should avoid to trigger `onSend` hook twice', async (t) => {
   })
   t.assert.deepEqual(JSON.parse(zlib.brotliDecompressSync(response.rawPayload)), { hi: true })
 })
+
+test('reply.compress should handle Fetch Response', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, { global: true, threshold: 0 })
+  fastify.get('/', (_req, reply) => {
+    const r = new Response('from reply.compress', { headers: { 'content-type': 'text/plain' } })
+    reply.compress(r)
+  })
+  const res = await fastify.inject({ url: '/', method: 'GET', headers: { 'accept-encoding': 'gzip' } })
+  t.assert.equal(zlib.gunzipSync(res.rawPayload).toString('utf8'), 'from reply.compress')
+})
+
+test('reply.compress should handle Web ReadableStream', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, { global: true, threshold: 0 })
+  fastify.get('/', (_req, reply) => {
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.enqueue(Buffer.from('from webstream'))
+        controller.close()
+      }
+    })
+    reply.header('content-type', 'text/plain')
+    reply.compress(stream)
+  })
+  const res = await fastify.inject({ url: '/', method: 'GET', headers: { 'accept-encoding': 'gzip' } })
+  t.assert.equal(zlib.gunzipSync(res.rawPayload).toString('utf8'), 'from webstream')
+})

package/test/utils.test.js

@@ -4,7 +4,7 @@ const { createReadStream } = require('node:fs')
 const { Socket } = require('node:net')
 const { Duplex, PassThrough, Readable, Stream, Transform, Writable } = require('node:stream')
 const { test } = require('node:test')
-const { isStream, isDeflate, isGzip, intoAsyncIterator } = require('../lib/utils')
+const { isStream, isZstd, isDeflate, isGzip, intoAsyncIterator } = require('../lib/utils')
 
 test('isStream() utility should be able to detect Streams', async (t) => {
   t.plan(12)
@@ -48,6 +48,23 @@ test('isDeflate() utility should be able to detect deflate compressed Buffer', a
   equal(isDeflate(''), false)
 })
 
+test('isZstd() utility should be able to detect zstd compressed Buffer', async (t) => {
+  t.plan(10)
+  const equal = t.assert.equal
+
+  equal(isZstd(Buffer.alloc(0)), false)
+  equal(isZstd(Buffer.alloc(1)), false)
+  equal(isZstd(Buffer.alloc(2)), false)
+  equal(isZstd(Buffer.alloc(3)), false)
+  equal(isZstd(Buffer.from([0x28, 0xb5, 0x2f])), false)
+  equal(isZstd(Buffer.from([0x28, 0xb5, 0x2f, 0xfd])), true)
+
+  equal(isZstd({}), false)
+  equal(isZstd(null), false)
+  equal(isZstd(undefined), false)
+  equal(isZstd(''), false)
+})
+
 test('isGzip() utility should be able to detect gzip compressed Buffer', async (t) => {
   t.plan(10)
   const equal = t.assert.equal

package/types/index.d.ts

@@ -26,7 +26,7 @@ declare module 'fastify' {
   }
 
   interface FastifyReply {
-    compress(input: Stream | Input): void;
+    compress(input: Stream | Input | Response | ReadableStream): void;
   }
 
   export interface RouteOptions {
@@ -57,7 +57,7 @@ type RouteDecompressOptions = Pick<fastifyCompress.FastifyCompressOptions,
   | 'zlib'
 >
 
-type EncodingToken = 'br' | 'deflate' | 'gzip' | 'identity'
+type EncodingToken = 'zstd' | 'br' | 'deflate' | 'gzip' | 'identity'
 
 type CompressibleContentTypeFunction = (contentType: string) => boolean
 

package/types/index.test-d.ts

@@ -25,8 +25,14 @@ const withGlobalOptions: FastifyCompressOptions = {
   removeContentLengthHeader: true
 }
 
+const withZstdOptions: FastifyCompressOptions = {
+  encodings: ['zstd', 'br', 'gzip', 'deflate', 'identity'],
+  requestEncodings: ['zstd', 'br', 'gzip', 'deflate', 'identity']
+}
+
 const app: FastifyInstance = fastify()
 app.register(fastifyCompress, withGlobalOptions)
+app.register(fastifyCompress, withZstdOptions)
 
 app.register(fastifyCompress, {
   customTypes: value => value === 'application/json'
@@ -111,9 +117,33 @@ appWithoutGlobal.inject(
   }
 )
 
+// Test that invalid encoding values trigger TypeScript errors
+expectError(fastify().register(fastifyCompress, {
+  encodings: ['invalid-encoding']
+}))
+
+expectError(fastify().register(fastifyCompress, {
+  requestEncodings: ['another-invalid-encoding']
+}))
+
 // Instantiation of an app that should trigger a typescript error
 const appThatTriggerAnError = fastify()
 expectError(appThatTriggerAnError.register(fastifyCompress, {
   global: true,
   thisOptionDoesNotExist: 'trigger a typescript error'
 }))
+
+app.get('/ts-fetch-response', async (_request, reply) => {
+  const resp = new Response('ok', { headers: { 'content-type': 'text/plain' } })
+  expectType<void>(reply.compress(resp))
+})
+
+app.get('/ts-web-readable-stream', async (_request, reply) => {
+  const stream = new ReadableStream({
+    start (controller) {
+      controller.enqueue(new Uint8Array([1, 2, 3]))
+      controller.close()
+    }
+  })
+  expectType<void>(reply.compress(stream))
+})