@fastify/compress 9.0.0 → 9.1.0

package/.c8rc

@@ -1,14 +1,10 @@
 {
   "all": true,
-  "exclude": [
-    "test/",
-    "coverage/",
-    "types/"
-  ],
+  "exclude": ["test/", "coverage/", "types/", "eslint.config.js"],
   "clean": true,
   "check-coverage": true,
   "branches": 100,
   "lines": 100,
   "functions": 100,
   "statements": 100
-}
+}

package/.github/dependabot.yml

@@ -2,12 +2,52 @@ version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
     open-pull-requests-limit: 10
 
   - package-ecosystem: "npm"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    versioning-strategy: "increase-if-necessary"
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    ignore:
+      # TODO: remove ignore until neostandard support ESLint 10
+      - dependency-name: "eslint"
+      - dependency-name: "neostandard"
+      - dependency-name: "@stylistic/*"
     open-pull-requests-limit: 10
+    groups:
+      # Production dependencies with breaking changes
+      dependencies:
+        dependency-type: "production"
+      # ESLint related dependencies
+      dev-dependencies-eslint:
+        patterns:
+          - "eslint"
+          - "neostandard"
+          - "@stylistic/*"
+      # TypeScript related dependencies
+      dev-dependencies-typescript:
+        patterns:
+          - "@types/*"
+          - "tstyche"
+          - "typescript"

package/README.md

@@ -396,9 +396,8 @@ await fastify.register(
 
 ## Acknowledgments
 
-Past sponsors:
-
-- [LetzDoIt](http://www.letzdoitapp.com/)
+Past sp
+- LetzDoIt
 
 ## License
 

package/index.js

@@ -7,11 +7,19 @@ const { pipeline, compose } = require('node:stream')
 const fp = require('fastify-plugin')
 const encodingNegotiator = require('@fastify/accept-negotiator')
 const mimedb = require('mime-db')
-const peek = require('peek-stream')
 const { Minipass } = require('minipass')
 const { Readable } = require('readable-stream')
 
-const { isStream, isGzip, isDeflate, intoAsyncIterator, isWebReadableStream, isFetchResponse, webStreamToNodeReadable } = require('./lib/utils')
+const {
+  isStream,
+  isGzip,
+  isDeflate,
+  intoAsyncIterator,
+  isWebReadableStream,
+  isFetchResponse,
+  webStreamToNodeReadable,
+  createPeekTransform
+} = 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)
@@ -258,6 +266,9 @@ function buildRouteCompress (_fastify, params, routeOptions, decorateOnly) {
     const noCompress =
       // don't compress on x-no-compression header
       (req.headers['x-no-compression'] !== undefined) ||
+      // don't compress partial content: Content-Range describes unencoded byte offsets
+      (reply.statusCode === 206) ||
+      (reply.getHeader('Content-Range') !== undefined) ||
       // don't compress if not one of the indicated compressible types
       (shouldCompress(reply.getHeader('Content-Type') || 'application/json', params.compressibleTypes) === false) ||
       // don't compress on missing or identity `accept-encoding` header
@@ -459,8 +470,12 @@ function onEnd (err) {
   // Client disconnection during streaming is expected and handled by Fastify.
   // Do not log "premature close" errors at error level since they are not
   // actual errors - they occur when clients disconnect mid-response.
+  // Node's native stream.pipeline emits ERR_STREAM_PREMATURE_CLOSE with the
+  // message 'Premature close', while the legacy pump/end-of-stream packages
+  // emit 'premature close' without a code, so both variants are checked.
   // See: https://github.com/fastify/fastify-compress/issues/382
-  if (err && err.message !== 'premature close') {
+  // See: https://github.com/fastify/fastify-compress/issues/410
+  if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE' && err.message !== 'premature close') {
     this.log.error(err)
   }
 }
@@ -547,26 +562,26 @@ function maybeUnzip (payload, serialize) {
 }
 
 function zipStream (deflate, encoding) {
-  return peek({ newline: false, maxBuffer: 10 }, function (data, swap) {
+  return createPeekTransform(function (data) {
     switch (isCompressed(data)) {
-      case 1: return swap(null, new Minipass())
-      case 2: return swap(null, new Minipass())
+      case 1: return new Minipass()
+      case 2: return new Minipass()
     }
-    return swap(null, deflate[encoding]())
+    return deflate[encoding]()
   })
 }
 
 function unzipStream (inflate, maxRecursion) {
   if (!(maxRecursion >= 0)) maxRecursion = 3
-  return peek({ newline: false, maxBuffer: 10 }, function (data, swap) {
+  return createPeekTransform(function (data) {
     // This path is never taken, when `maxRecursion` < 0 it is automatically set back to 3
     /* c8 ignore next */
-    if (maxRecursion < 0) return swap(new Error('Maximum recursion reached'))
+    if (maxRecursion < 0) throw new Error('Maximum recursion reached')
     switch (isCompressed(data)) {
-      case 1: return swap(null, compose(inflate.gzip(), unzipStream(inflate, maxRecursion - 1)))
-      case 2: return swap(null, compose(inflate.deflate(), unzipStream(inflate, maxRecursion - 1)))
+      case 1: return compose(inflate.gzip(), unzipStream(inflate, maxRecursion - 1))
+      case 2: return compose(inflate.deflate(), unzipStream(inflate, maxRecursion - 1))
     }
-    return swap(null, new Minipass())
+    return new Minipass()
   })
 }
 

package/lib/utils.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { Readable: NodeReadable } = require('node:stream')
+const { Transform } = require('readable-stream')
 
 // https://datatracker.ietf.org/doc/html/rfc8878#section-3.1.1
 function isZstd (buffer) {
@@ -104,4 +105,92 @@ async function * intoAsyncIterator (payload) {
   yield payload
 }
 
-module.exports = { isZstd, isGzip, isDeflate, isStream, intoAsyncIterator, isWebReadableStream, isFetchResponse, webStreamToNodeReadable }
+function createPeekTransform (swapStream, peekSize = 10) {
+  const buffers = []
+  let bufferSize = 0
+  let downstream = null
+  let flushCallback = null
+
+  const _transform = new Transform({
+    transform (chunk, encoding, callback) {
+      // when downstream already selected, directly passthrough
+      if (downstream !== null) return downstream.write(chunk, encoding, callback)
+
+      bufferSize += chunk.length
+      buffers.push(chunk)
+
+      // read more data when buffer size smaller than peeksize
+      if (bufferSize < peekSize) return callback()
+
+      wireDownStream(callback)
+    },
+    flush (callback) {
+      // used in "end" event to notify the transform finished flush
+      flushCallback = callback
+      if (downstream !== null) {
+        // all data should be flushed to downstream already
+        // we end the stream
+        downstream.end()
+      } else {
+        // flush internal buffers and end the downstream
+        wireDownStream((error) => {
+          if (error) {
+            flushCallback = null
+            callback(error)
+          } else {
+            downstream.end()
+          }
+        })
+      }
+    }
+  })
+
+  function onData (chunk) {
+    _transform.push(chunk)
+  }
+
+  function onError (error) {
+    _transform.destroy(error)
+  }
+
+  function onEnd () {
+    flushCallback && flushCallback()
+    // cleanup
+    downstream.off('data', onData)
+    downstream.off('error', onError)
+    downstream.off('end', onEnd)
+    downstream = null
+    flushCallback = null
+
+    _transform.push(null)
+  }
+
+  function wireDownStream (callback) {
+    const data = Buffer.concat(buffers)
+    try {
+      downstream = swapStream(data.subarray(0, peekSize))
+      downstream.on('data', onData)
+      downstream.on('error', onError)
+      downstream.on('end', onEnd)
+      downstream.write(data, callback)
+      // cleanup
+      buffers.length = 0
+    } catch (error) {
+      callback(error)
+    }
+  }
+
+  return _transform
+}
+
+module.exports = {
+  isZstd,
+  isGzip,
+  isDeflate,
+  isStream,
+  intoAsyncIterator,
+  isWebReadableStream,
+  isFetchResponse,
+  webStreamToNodeReadable,
+  createPeekTransform
+}

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "@fastify/compress",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "Fastify compression utils",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "dependencies": {
     "@fastify/accept-negotiator": "^2.0.0",
-    "fastify-plugin": "^5.0.0",
+    "fastify-plugin": "^6.0.0",
     "mime-db": "^1.52.0",
     "minipass": "^7.0.4",
-    "peek-stream": "^1.1.3",
     "readable-stream": "^4.5.2"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
+    "@types/node": "^26.0.1",
     "adm-zip": "^0.5.12",
     "c8": "^11.0.0",
     "eslint": "^9.17.0",
@@ -41,7 +40,7 @@
     "brotli",
     "zstd"
   ],
-  "author": "Tomas Della Vedova - @delvedor (http://delved.org)",
+  "author": "Tomas Della Vedova - @delvedor (https://delvedor.dev)",
   "contributors": [
     {
       "name": "Matteo Collina",

package/test/global-compress.test.js

@@ -682,6 +682,41 @@ describe('When a custom `zlib` option is provided, it should compress data :`',
     t.assert.equal(response.headers['content-encoding'], 'gzip')
     t.assert.equal(payload.toString('utf-8'), file)
   })
+
+  test('using the custom `createZstdCompress()` method', async (t) => {
+    if (typeof zlib.createZstdCompress !== 'function') {
+      t.skip('zstd not supported in this Node.js version')
+      return
+    }
+    t.plan(4)
+
+    let usedCustom = false
+    const customZlib = { createZstdCompress: () => (usedCustom = true) && zlib.createZstdCompress() }
+
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { global: true, zlib: customZlib })
+
+    fastify.get('/', (_request, reply) => {
+      reply
+        .type('text/plain')
+        .compress(createReadStream('./package.json'))
+    })
+
+    const response = await fastify.inject({
+      url: '/',
+      method: 'GET',
+      headers: {
+        'accept-encoding': 'zstd'
+      }
+    })
+    t.assert.equal(usedCustom, true)
+
+    const file = readFileSync('./package.json', 'utf8')
+    const payload = zlib.zstdDecompressSync(response.rawPayload)
+    t.assert.equal(response.headers.vary, 'accept-encoding')
+    t.assert.equal(response.headers['content-encoding'], 'zstd')
+    t.assert.equal(payload.toString('utf-8'), file)
+  })
 })
 
 describe('When a malformed custom `zlib` option is provided, it should compress data :', async () => {
@@ -765,6 +800,37 @@ describe('When a malformed custom `zlib` option is provided, it should compress
     const payload = zlib.gunzipSync(response.rawPayload)
     t.assert.equal(payload.toString('utf-8'), 'hello')
   })
+
+  test('using the fallback default Node.js core `zlib.createZstdCompress()` method', 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, {
+      global: true,
+      threshold: 0,
+      zlib: true // will trigger a fallback on the default zlib.createZstdCompress
+    })
+
+    fastify.get('/', (_request, reply) => {
+      reply
+        .type('text/plain')
+        .compress('hello')
+    })
+
+    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'), 'hello')
+  })
 })
 
 describe('When `inflateIfDeflated` is `true` and `X-No-Compression` request header is `true` :', async () => {
@@ -3548,3 +3614,56 @@ test('It should demonstrate globalDecompression controls decompression independe
   t.assert.equal(response.statusCode, 400)
   t.assert.ok(response.body.includes('Content-Length') || response.body.includes('Bad Request'))
 })
+
+describe('Range Responses', () => {
+  test('it should not compress 206 Partial Content responses', async (t) => {
+    t.plan(4)
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    fastify.get('/partial', (request, reply) => {
+      reply
+        .status(206)
+        .header('Content-Type', 'text/plain')
+        .header('Content-Range', 'bytes 0-4/12')
+        .header('Content-Length', '5')
+        .send('hello')
+    })
+
+    const response = await fastify.inject({
+      url: '/partial',
+      method: 'GET',
+      headers: { 'accept-encoding': 'gzip' }
+    })
+
+    t.assert.equal(response.statusCode, 206)
+    t.assert.equal(response.headers['content-encoding'], undefined)
+    t.assert.equal(response.headers['content-range'], 'bytes 0-4/12')
+    t.assert.equal(response.body, 'hello')
+  })
+
+  test('it should not compress responses carrying a Content-Range header', async (t) => {
+    t.plan(4)
+    const fastify = Fastify()
+    await fastify.register(compressPlugin, { threshold: 0 })
+
+    fastify.get('/content-range', (request, reply) => {
+      reply
+        .header('Content-Type', 'text/plain')
+        .header('Content-Range', 'bytes 0-4/12')
+        .header('Content-Length', '5')
+        .send('hello')
+    })
+
+    const response = await fastify.inject({
+      url: '/content-range',
+      method: 'GET',
+      headers: { 'accept-encoding': 'gzip' }
+    })
+
+    t.assert.equal(response.statusCode, 200)
+    t.assert.equal(response.headers['content-encoding'], undefined)
+    t.assert.equal(response.headers['content-range'], 'bytes 0-4/12')
+    t.assert.equal(response.body, 'hello')
+  })
+})

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

@@ -15,7 +15,7 @@ test('should not log "premature close" errors on client disconnect (global compr
       level: 'error',
       stream: new Writable({
         write (chunk, encoding, callback) {
-          if (chunk.toString().includes('premature close')) {
+          if (/premature close/i.test(chunk.toString())) {
             prematureCloseCount++
           }
           callback()
@@ -86,7 +86,7 @@ test('should not log "premature close" errors on client disconnect (reply.compre
       level: 'error',
       stream: new Writable({
         write (chunk, encoding, callback) {
-          if (chunk.toString().includes('premature close')) {
+          if (/premature close/i.test(chunk.toString())) {
             prematureCloseCount++
           }
           callback()
@@ -157,7 +157,7 @@ test('should still log actual errors (not premature close)', async (t) => {
       stream: new Writable({
         write (chunk, encoding, callback) {
           const msg = chunk.toString()
-          if (msg.includes('premature close')) {
+          if (/premature close/i.test(msg)) {
             // Ignore premature close errors
           } else {
             errors.push(msg)

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/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'))
+  })
+})