@fastify/compress 8.3.1 → 9.1.0

package/test/regression/issue-382.test.js

@@ -0,0 +1,193 @@
+'use strict'
+
+const { test } = require('node:test')
+const { setTimeout: sleep } = require('node:timers/promises')
+const net = require('node:net')
+const { Writable } = require('node:stream')
+const Fastify = require('fastify')
+const fastifyCompress = require('../..')
+
+test('should not log "premature close" errors on client disconnect (global compression)', async (t) => {
+  let prematureCloseCount = 0
+
+  const fastify = Fastify({
+    logger: {
+      level: 'error',
+      stream: new Writable({
+        write (chunk, encoding, callback) {
+          if (/premature close/i.test(chunk.toString())) {
+            prematureCloseCount++
+          }
+          callback()
+        }
+      })
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: true,
+    encodings: ['gzip'],
+    threshold: 1024
+  })
+
+  // Streaming endpoint that takes time to produce data
+  fastify.get('/stream', async (_request, reply) => {
+    let chunks = 0
+    const stream = new (require('node:stream').Readable)({
+      read () {
+        if (chunks >= 20) {
+          this.push(null)
+          return
+        }
+        setTimeout(() => {
+          this.push(JSON.stringify({ id: chunks, data: 'x'.repeat(1000) }) + '\n')
+          chunks++
+        }, 50)
+      }
+    })
+    reply.type('text/plain')
+    return stream
+  })
+
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  // Simulate clients that disconnect before the full response is sent
+  for (let i = 0; i < 10; i++) {
+    await new Promise((_resolve) => {
+      const sock = net.connect(port, '127.0.0.1', () => {
+        sock.write('GET /stream HTTP/1.1\r\nHost: localhost\r\nAccept-Encoding: gzip\r\n\r\n')
+        // Disconnect after receiving partial response (100ms)
+        setTimeout(() => {
+          sock.destroy()
+          _resolve()
+        }, 100)
+      })
+      sock.on('error', () => _resolve())
+    })
+  }
+
+  // Allow pending callbacks to fire
+  await sleep(2000)
+  await fastify.close()
+
+  t.assert.equal(
+    prematureCloseCount,
+    0,
+    `Expected no "premature close" errors, but got ${prematureCloseCount} errors from 10 client disconnects`
+  )
+})
+
+test('should not log "premature close" errors on client disconnect (reply.compress path)', async (t) => {
+  let prematureCloseCount = 0
+
+  const fastify = Fastify({
+    logger: {
+      level: 'error',
+      stream: new Writable({
+        write (chunk, encoding, callback) {
+          if (/premature close/i.test(chunk.toString())) {
+            prematureCloseCount++
+          }
+          callback()
+        }
+      })
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: false,
+    encodings: ['gzip']
+  })
+
+  // Streaming endpoint using reply.compress
+  fastify.get('/stream', async (_request, reply) => {
+    let chunks = 0
+    const stream = new (require('node:stream').Readable)({
+      read () {
+        if (chunks >= 20) {
+          this.push(null)
+          return
+        }
+        setTimeout(() => {
+          this.push(JSON.stringify({ id: chunks, data: 'x'.repeat(1000) }) + '\n')
+          chunks++
+        }, 50)
+      }
+    })
+    reply.type('text/plain')
+    return reply.compress(stream)
+  })
+
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  // Simulate clients that disconnect before the full response is sent
+  for (let i = 0; i < 10; i++) {
+    await new Promise((_resolve) => {
+      const sock = net.connect(port, '127.0.0.1', () => {
+        sock.write('GET /stream HTTP/1.1\r\nHost: localhost\r\nAccept-Encoding: gzip\r\n\r\n')
+        // Disconnect after receiving partial response (100ms)
+        setTimeout(() => {
+          sock.destroy()
+          _resolve()
+        }, 100)
+      })
+      sock.on('error', () => _resolve())
+    })
+  }
+
+  // Allow pending callbacks to fire
+  await sleep(2000)
+  await fastify.close()
+
+  t.assert.equal(
+    prematureCloseCount,
+    0,
+    `Expected no "premature close" errors, but got ${prematureCloseCount} errors from 10 client disconnects`
+  )
+})
+
+test('should still log actual errors (not premature close)', async (t) => {
+  const errors = []
+
+  const fastify = Fastify({
+    logger: {
+      level: 'error',
+      stream: new Writable({
+        write (chunk, encoding, callback) {
+          const msg = chunk.toString()
+          if (/premature close/i.test(msg)) {
+            // Ignore premature close errors
+          } else {
+            errors.push(msg)
+          }
+          callback()
+        }
+      })
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: true,
+    encodings: ['gzip']
+  })
+
+  // Route that throws an error
+  fastify.get('/error', async () => {
+    throw new Error('Test error')
+  })
+
+  await fastify.inject({
+    method: 'GET',
+    url: '/error',
+    headers: { 'accept-encoding': 'gzip' }
+  })
+
+  await sleep(500)
+
+  t.assert.ok(
+    errors.length > 0,
+    'Expected actual errors to still be logged'
+  )
+})

package/test/regression/issue-410.test.js

@@ -0,0 +1,163 @@
+'use strict'
+
+const { test } = require('node:test')
+const { setTimeout: sleep } = require('node:timers/promises')
+const net = require('node:net')
+const { Writable } = require('node:stream')
+const Fastify = require('fastify')
+const fastifyCompress = require('../..')
+
+// Node's native stream.pipeline emits ERR_STREAM_PREMATURE_CLOSE whose message
+// is 'Premature close' (capital P), unlike the legacy pump/end-of-stream
+// message 'premature close'. The onEnd guard must suppress both variants.
+// See: https://github.com/fastify/fastify-compress/issues/410
+
+function buildFastify (onErrorLog) {
+  return Fastify({
+    logger: {
+      level: 'error',
+      stream: new Writable({
+        write (chunk, encoding, callback) {
+          onErrorLog(chunk.toString())
+          callback()
+        }
+      })
+    }
+  })
+}
+
+function streamRoute (reply, ReadableCtor) {
+  let chunks = 0
+  const stream = new ReadableCtor({
+    read () {
+      if (chunks >= 20) {
+        this.push(null)
+        return
+      }
+      setTimeout(() => {
+        this.push(JSON.stringify({ id: chunks, data: 'x'.repeat(1000) }) + '\n')
+        chunks++
+      }, 50)
+    }
+  })
+  reply.type('text/plain')
+  return stream
+}
+
+async function abortClients (port) {
+  // Simulate clients that disconnect before the full response is sent
+  for (let i = 0; i < 10; i++) {
+    await new Promise((_resolve) => {
+      const sock = net.connect(port, '127.0.0.1', () => {
+        sock.write('GET /stream HTTP/1.1\r\nHost: localhost\r\nAccept-Encoding: gzip\r\n\r\n')
+        // Disconnect after receiving partial response (100ms)
+        setTimeout(() => {
+          sock.destroy()
+          _resolve()
+        }, 100)
+      })
+      sock.on('error', () => _resolve())
+    })
+  }
+}
+
+test('should not log native pipeline "Premature close" (ERR_STREAM_PREMATURE_CLOSE) on client disconnect (global compression)', async (t) => {
+  let prematureCloseCount = 0
+
+  const fastify = buildFastify((msg) => {
+    if (/premature close/i.test(msg)) {
+      prematureCloseCount++
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: true,
+    encodings: ['gzip'],
+    threshold: 1024
+  })
+
+  fastify.get('/stream', async (_request, reply) => {
+    return streamRoute(reply, require('node:stream').Readable)
+  })
+
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  await abortClients(port)
+
+  // Allow pending callbacks to fire
+  await sleep(2000)
+  await fastify.close()
+
+  t.assert.equal(
+    prematureCloseCount,
+    0,
+    `Expected no premature close errors (any casing), but got ${prematureCloseCount} errors from 10 client disconnects`
+  )
+})
+
+test('should not log native pipeline "Premature close" (ERR_STREAM_PREMATURE_CLOSE) on client disconnect (reply.compress path)', async (t) => {
+  let prematureCloseCount = 0
+
+  const fastify = buildFastify((msg) => {
+    if (/premature close/i.test(msg)) {
+      prematureCloseCount++
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: false,
+    encodings: ['gzip']
+  })
+
+  fastify.get('/stream', async (_request, reply) => {
+    return reply.compress(streamRoute(reply, require('node:stream').Readable))
+  })
+
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  await abortClients(port)
+
+  // Allow pending callbacks to fire
+  await sleep(2000)
+  await fastify.close()
+
+  t.assert.equal(
+    prematureCloseCount,
+    0,
+    `Expected no premature close errors (any casing), but got ${prematureCloseCount} errors from 10 client disconnects`
+  )
+})
+
+test('should still log errors that are not premature close', async (t) => {
+  const errors = []
+
+  const fastify = buildFastify((msg) => {
+    if (!/premature close/i.test(msg)) {
+      errors.push(msg)
+    }
+  })
+
+  await fastify.register(fastifyCompress, {
+    global: true,
+    encodings: ['gzip']
+  })
+
+  fastify.get('/error', async () => {
+    throw new Error('Test error')
+  })
+
+  await fastify.inject({
+    method: 'GET',
+    url: '/error',
+    headers: { 'accept-encoding': 'gzip' }
+  })
+
+  await sleep(500)
+
+  t.assert.ok(
+    errors.length > 0,
+    'Expected actual errors to still be logged'
+  )
+})

package/test/routes-compress.test.js

@@ -330,95 +330,6 @@ describe('When `compress.removeContentLengthHeader` is `false`, it should not re
   })
 })
 
-describe('When using the old routes `{ config: compress }` option :', async () => {
-  test('it should compress data using the route custom provided `createGzip` method', async (t) => {
-    t.plan(10)
-    const equal = t.assert.equal
-
-    let usedCustomGlobal = false
-    let usedCustom = false
-    const customZlibGlobal = { createGzip: () => (usedCustomGlobal = true) && zlib.createGzip() }
-    const customZlib = { createGzip: () => (usedCustom = true) && zlib.createGzip() }
-
-    const fastify = Fastify()
-    await fastify.register(compressPlugin, { global: false, zlib: customZlibGlobal })
-
-    fastify.get('/', (_request, reply) => {
-      reply
-        .type('text/plain')
-        .compress(createReadStream('./package.json'))
-    })
-
-    fastify.get('/custom', {
-      config: {
-        compress: { zlib: customZlib }
-      }
-    }, (_request, reply) => {
-      reply
-        .type('text/plain')
-        .compress(createReadStream('./package.json'))
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    }).then((response) => {
-      equal(usedCustom, false)
-      equal(usedCustomGlobal, true)
-
-      const file = readFileSync('./package.json', 'utf8')
-      const payload = zlib.gunzipSync(response.rawPayload)
-      equal(response.headers.vary, 'accept-encoding')
-      equal(response.headers['content-encoding'], 'gzip')
-      equal(payload.toString('utf-8'), file)
-
-      usedCustom = false
-      usedCustomGlobal = false
-    })
-
-    const response = await fastify.inject({
-      url: '/custom',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    })
-    equal(usedCustom, true)
-    equal(usedCustomGlobal, false)
-
-    const file = readFileSync('./package.json', 'utf8')
-    const payload = zlib.gunzipSync(response.rawPayload)
-    equal(response.headers.vary, 'accept-encoding')
-    equal(response.headers['content-encoding'], 'gzip')
-    equal(payload.toString('utf-8'), file)
-  })
-
-  test('it should use the old routes `{ config: compress }` options over routes `compress` options', async (t) => {
-    t.plan(1)
-
-    const fastify = Fastify()
-    await fastify.register(compressPlugin, { global: false })
-
-    try {
-      fastify.get('/', {
-        compress: {
-          zlib: { createGzip: () => zlib.createGzip() }
-        },
-        config: {
-          compress: 'bad config'
-        }
-      }, (_request, reply) => {
-        reply.send('')
-      })
-    } catch (err) {
-      t.assert.equal(err.message, 'Unknown value for route compress configuration')
-    }
-  })
-})
-
 test('It should avoid to trigger `onSend` hook twice', async (t) => {
   t.plan(1)
 

package/test/routes-decompress.test.js

@@ -2,9 +2,9 @@
 
 const { test, describe } = require('node:test')
 const { createReadStream } = require('node:fs')
+const { pipeline } = require('node:stream')
 const path = require('node:path')
 const zlib = require('node:zlib')
-const pump = require('pump')
 const Fastify = require('fastify')
 const compressPlugin = require('../index')
 
@@ -12,7 +12,9 @@ function createPayload (compressor) {
   let payload = createReadStream(path.resolve(__dirname, '../package.json'))
 
   if (compressor) {
-    payload = pump(payload, compressor())
+    const compressed = compressor()
+    pipeline(payload, compressed, () => {})
+    payload = compressed
   }
 
   return payload
@@ -231,88 +233,3 @@ describe('When using routes `decompress` settings :', async () => {
     }
   })
 })
-
-describe('When using the old routes `{ config: decompress }` option :', async () => {
-  test('it should decompress data using the route custom provided `createGunzip` method', async (t) => {
-    t.plan(8)
-    const equal = t.assert.equal
-
-    let usedCustomGlobal = false
-    let usedCustom = false
-    const customZlibGlobal = { createGunzip: () => (usedCustomGlobal = true) && zlib.createGunzip() }
-    const customZlib = { createGunzip: () => (usedCustom = true) && zlib.createGunzip() }
-
-    const fastify = Fastify()
-    await fastify.register(compressPlugin, { zlib: customZlibGlobal })
-
-    fastify.post('/', (request, reply) => {
-      reply.send(request.body.name)
-    })
-
-    fastify.post('/custom', {
-      config: {
-        decompress: {
-          zlib: customZlib
-        }
-      }
-    }, (request, reply) => {
-      reply.send(request.body.name)
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'content-encoding': 'gzip'
-      },
-      payload: createPayload(zlib.createGzip)
-    }).then((response) => {
-      equal(usedCustom, false)
-      equal(usedCustomGlobal, true)
-
-      equal(response.statusCode, 200)
-      equal(response.body, '@fastify/compress')
-
-      usedCustom = false
-      usedCustomGlobal = false
-    })
-
-    const response = await fastify.inject({
-      url: '/custom',
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        'content-encoding': 'gzip'
-      },
-      payload: createPayload(zlib.createGzip)
-    })
-    equal(usedCustom, true)
-    equal(usedCustomGlobal, false)
-
-    equal(response.statusCode, 200)
-    equal(response.body, '@fastify/compress')
-  })
-
-  test('it should use the old routes `{ config: decompress }` options over routes `decompress` options', async (t) => {
-    t.plan(1)
-
-    const fastify = Fastify()
-    await fastify.register(compressPlugin, { global: false })
-
-    try {
-      fastify.post('/', {
-        decompress: {
-          zlib: { createGunzip: () => zlib.createGunzip() }
-        },
-        config: {
-          decompress: 'bad config'
-        }
-      }, (request, reply) => {
-        reply.send(request.body.name)
-      })
-    } catch (err) {
-      t.assert.equal(err.message, 'Unknown value for route decompress configuration')
-    }
-  })
-})

package/test/utils.test.js

@@ -3,8 +3,9 @@
 const { createReadStream } = require('node:fs')
 const { Socket } = require('node:net')
 const { Duplex, PassThrough, Readable, Stream, Transform, Writable } = require('node:stream')
+const { finished } = require('node:stream/promises')
 const { test } = require('node:test')
-const { isStream, isZstd, isDeflate, isGzip, intoAsyncIterator } = require('../lib/utils')
+const { isStream, isZstd, isDeflate, isGzip, intoAsyncIterator, createPeekTransform } = require('../lib/utils')
 
 test('isStream() utility should be able to detect Streams', async (t) => {
   t.plan(12)
@@ -124,3 +125,139 @@ test('intoAsyncIterator() utility should handle different data', async (t) => {
     equal(chunk, obj)
   }
 })
+
+test('createPeekTransform', async (t) => {
+  class UpperCaseTransform extends Transform {
+    _transform (chunk, encoding, callback) {
+      callback(null, chunk.toString().toUpperCase())
+    }
+  }
+
+  await t.test('uppercase', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      t.assert.strictEqual(data.toString(), 'hello\nworl')
+      return new UpperCaseTransform()
+    })
+
+    let data = ''
+    transform.on('data', (chunk) => { data += chunk.toString() })
+    transform.write('hello\n')
+    transform.write('world\n')
+    transform.end()
+
+    await finished(transform)
+
+    t.assert.strictEqual(data, 'HELLO\nWORLD\n')
+  })
+
+  await t.test('uppercase no newline', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      t.assert.strictEqual(data.toString(), 'helloworld')
+      return new UpperCaseTransform()
+    })
+
+    let data = ''
+    transform.on('data', (chunk) => { data += chunk.toString() })
+    transform.write('hello')
+    transform.write('world')
+    transform.end()
+
+    await finished(transform)
+
+    t.assert.strictEqual(data, 'HELLOWORLD')
+  })
+
+  await t.test('error', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      throw new Error('boom')
+    })
+
+    transform.on('data', (chunk) => { t.assert.fail('should not reach') })
+    transform.on('error', (error) => { t.assert.ok(error) })
+    transform.write('hello')
+    transform.write('world')
+    transform.end()
+
+    await t.assert.rejects(finished(transform), new Error('boom'))
+  })
+
+  await t.test('peekSize = 5', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      t.assert.strictEqual(data.toString(), 'hello')
+      return new UpperCaseTransform()
+    }, 5)
+
+    let data = ''
+    transform.on('data', (chunk) => { data += chunk.toString() })
+    transform.write('hello\n')
+    transform.write('world\n')
+    transform.end()
+
+    await finished(transform)
+
+    t.assert.strictEqual(data, 'HELLO\nWORLD\n')
+  })
+
+  await t.test('data size < peekSize', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      t.assert.strictEqual(data.toString(), 'helloworld')
+      return new UpperCaseTransform()
+    }, 100)
+
+    let data = ''
+    transform.on('data', (chunk) => { data += chunk.toString() })
+    transform.write('hello')
+    transform.write('world')
+    transform.end()
+
+    await finished(transform)
+
+    t.assert.strictEqual(data, 'HELLOWORLD')
+  })
+
+  await t.test('error when data size < peekSize', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      throw new Error('boom')
+    }, 100)
+
+    transform.on('data', (chunk) => { t.assert.fail('should not reach') })
+    transform.on('error', (error) => { t.assert.ok(error) })
+    transform.write('hello')
+    transform.write('world')
+    transform.end()
+
+    await t.assert.rejects(finished(transform), new Error('boom'))
+  })
+
+  await t.test('error inside downstream', async (t) => {
+    t.plan(2)
+
+    const transform = createPeekTransform(function (data) {
+      return new Transform({
+        transform (chunk, encoding, callback) {
+          callback(new Error('boom'))
+        }
+      })
+    })
+
+    transform.on('data', (chunk) => { t.assert.fail('should not reach') })
+    transform.on('error', (error) => { t.assert.ok(error) })
+    transform.write('hello')
+    transform.write('world')
+    transform.end()
+
+    await t.assert.rejects(finished(transform), new Error('boom'))
+  })
+})