fix: prevents fastify-compress from trying to work with something it cannot

Sending something other than buffers of strings in the `payload` happens, but this would break the later `Buffer.byteLength(payload)`

Signed-off-by: Bart Riepe <[email protected]>

Author: Aeolun

.gitignore

@@ -147,6 +147,7 @@ yarn.lock
 # editor files
 .vscode
 .idea
+.zed
 
 #tap files
 .tap/

index.js

@@ -161,6 +161,10 @@ function processCompressParams (opts) {
       .sort((a, b) => opts.encodings.indexOf(a) - opts.encodings.indexOf(b))
     : supportedEncodings
 
+  params.isCompressiblePayload = typeof opts.isCompressiblePayload === 'function'
+    ? opts.isCompressiblePayload
+    : isCompressiblePayload
+
   return params
 }
 
@@ -273,6 +277,11 @@ function buildRouteCompress (_fastify, params, routeOptions, decorateOnly) {
     }
 
     if (typeof payload.pipe !== 'function') {
+      // Payload is not a stream, ensure we don't try to compress something we cannot get the length of.
+      if (!params.isCompressiblePayload(payload)) {
+        return next(null, payload)
+      }
+
       if (Buffer.byteLength(payload) < params.threshold) {
         return next()
       }
@@ -391,7 +400,7 @@ function compress (params) {
     }
 
     if (typeof payload.pipe !== 'function') {
-      if (!Buffer.isBuffer(payload) && typeof payload !== 'string') {
+      if (!params.isCompressiblePayload(payload)) {
         payload = this.serialize(payload)
       }
     }
@@ -477,6 +486,13 @@ function getEncodingHeader (encodings, request) {
   }
 }
 
+function isCompressiblePayload (payload) {
+  // By the time payloads reach this point, Fastify has already serialized
+  // objects/arrays/etc to strings, so we only need to check for the actual
+  // types that make it through: Buffer and string
+  return Buffer.isBuffer(payload) || typeof payload === 'string'
+}
+
 function shouldCompress (type, compressibleTypes) {
   if (compressibleTypes(type)) return true
   const data = mimedb[type.split(';', 1)[0].trim().toLowerCase()]

test/global-compress.test.js

@@ -3298,3 +3298,87 @@ for (const contentType of notByDefaultSupportedContentTypes) {
     t.assert.equal(response.rawPayload.toString('utf-8'), file)
   })
 }
+
+test('It should not compress non-buffer/non-string payloads', async (t) => {
+  t.plan(4)
+
+  let payloadTypeChecked = null
+  let payloadReceived = null
+  const testIsCompressiblePayload = (payload) => {
+    payloadTypeChecked = typeof payload
+    payloadReceived = payload
+    // Return false for objects, true for strings/buffers like the original
+    return Buffer.isBuffer(payload) || typeof payload === 'string'
+  }
+
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, {
+    isCompressiblePayload: testIsCompressiblePayload
+  })
+
+  // Create a Response-like object that might come from another plugin
+  const responseObject = new Response('{"message": "test"}', {
+    status: 200,
+    headers: { 'content-type': 'application/json' }
+  })
+
+  fastify.get('/', (_request, reply) => {
+    // Simulate a scenario where another plugin sets a Response object as the payload
+    // We use an onSend hook to intercept and replace the payload before compression to simulate that behavior
+    reply.header('content-type', 'application/json')
+    reply.send('{"message": "test"}')
+  })
+
+  // Add the onSend hook that replaces the payload with a Response object
+  fastify.addHook('onSend', async () => {
+    return responseObject
+  })
+
+  const response = await fastify.inject({
+    url: '/',
+    method: 'GET',
+    headers: {
+      'accept-encoding': 'gzip, deflate, br'
+    }
+  })
+
+  t.assert.equal(response.statusCode, 200)
+  // The response should not be compressed since the payload is a Response object
+  t.assert.equal(response.headers['content-encoding'], undefined)
+  // Verify that the payload was a Response object when isCompressiblePayload was called
+  t.assert.equal(payloadTypeChecked, 'object')
+  t.assert.equal(payloadReceived instanceof Response, true)
+})
+
+test('It should serialize and compress objects when reply.compress() receives non-compressible objects', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, {
+    threshold: 0 // Ensure even small payloads get compressed
+  })
+
+  // Create a larger object to ensure it exceeds any default threshold
+  const objectPayload = {
+    message: 'test data'.repeat(100),
+    value: 42,
+    description: 'A test object that should be large enough to trigger compression after serialization'.repeat(10)
+  }
+
+  fastify.get('/', (_request, reply) => {
+    reply.header('content-type', 'application/json')
+    // The compress function should now serialize the object and then compress it
+    reply.compress(objectPayload)
+  })
+
+  const response = await fastify.inject({
+    url: '/',
+    method: 'GET',
+    headers: {
+      'accept-encoding': 'gzip, deflate, br'
+    }
+  })
+
+  t.assert.equal(response.statusCode, 200)
+  t.assert.ok(['gzip', 'deflate', 'br'].includes(response.headers['content-encoding']))
+})