@fastify/compress 5.0.0 → 6.0.0

package/.github/workflows/ci.yml

@@ -14,11 +14,9 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - 10
-          - 12
           - 14
           - 16
-          - 17
+          - 18
         os:
           - macos-latest
           - ubuntu-latest

package/README.md

@@ -1,18 +1,18 @@
-# fastify-compress
+# @fastify/compress
 
 ![CI](https://github.com/fastify/fastify-compress/workflows/CI/badge.svg)
-[![NPM version](https://img.shields.io/npm/v/fastify-compress.svg?style=flat)](https://www.npmjs.com/package/fastify-compress)
+[![NPM version](https://img.shields.io/npm/v/@fastify/compress.svg?style=flat)](https://www.npmjs.com/package/@fastify/compress)
 [![Known Vulnerabilities](https://snyk.io/test/github/fastify/fastify-compress/badge.svg)](https://snyk.io/test/github/fastify/fastify-compress)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
 Adds compression utils to [the Fastify `reply` object](https://www.fastify.io/docs/latest/Reference/Reply/#reply) and a hook to decompress requests payloads.
 Supports `gzip`, `deflate`, and `brotli`.
 
-> **Important note:** since `fastify-compress` version 4.x payloads that are compressed using the `zip` algorithm are not automatically uncompressed anymore. `fastify-compress` main feature is to provide response compression mechanism to your server, however the `zip` format does not appear in the [IANA maintained Table of Content Encodings](https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding) and thus such behavior was out of the scope of this plugin.
+> **Important note:** since `@fastify/compress` version 4.x payloads that are compressed using the `zip` algorithm are not automatically uncompressed anymore. `@fastify/compress` main feature is to provide response compression mechanism to your server, however the `zip` format does not appear in the [IANA maintained Table of Content Encodings](https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding) and thus such behavior was out of the scope of this plugin.
 
 ## Install
 ```
-npm i fastify-compress
+npm i @fastify/compress
 ```
 
 ## Usage - Compress replies
@@ -24,7 +24,7 @@ Currently, the following encoding tokens are supported, using the first acceptab
 1. `br`
 2. `gzip`
 3. `deflate`
-4. `*` (no preference — `fastify-compress` will use `gzip`)
+4. `*` (no preference — `@fastify/compress` will use `gzip`)
 5. `identity` (no compression)
 
 If an unsupported encoding is received or if the `'accept-encoding'` header is missing, it will not compress the payload. If an unsupported encoding is received and you would like to return an error, provide an `onUnsupportedEncoding` option.
@@ -34,20 +34,20 @@ The plugin automatically decides if a payload should be compressed based on its
 ### Global hook
 The global compression hook is enabled by default. To disable it, pass the option `{ global: false }`:
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 ```
 Remember that thanks to the Fastify encapsulation model, you can set a global compression, but run it only in a subset of routes if you wrap them inside a plugin.
 
-Important note! If you are using `fastify-compress` plugin together with `fastify-static` plugin, you must register the `fastify-compress` (with *global hook*) **before** registering `fastify-static`.
+Important note! If you are using `@fastify/compress` plugin together with `@fastify/static` plugin, you must register the `@fastify/compress` (with *global hook*) **before** registering `@fastify/static`.
 
 ### Per Route options
 You can specify different options for compression per route by passing in the `compress` options on the route's configuration.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 
@@ -74,21 +74,19 @@ Note that the compress method is configured with either the per route parameters
 the plugin was defined as global.
 
 ```javascript
-const fs = require('fs')
-const fastify = require('fastify')()
+import fs from 'fs'
+import fastify from 'fastify'
 
-fastify.register(require('fastify-compress'), { global: false })
+const app = fastify()
+await app.register(import('@fastify/compress'), { global: false })
 
-fastify.get('/', (req, reply) => {
+app.get('/', (req, reply) => {
   reply
     .type('text/plain')
     .compress(fs.createReadStream('./package.json'))
 })
 
-fastify.listen(3000, function (err) {
-  if (err) throw err
-  console.log(`server listening on ${fastify.server.address().port}`)
-})
+await app.listen(3000)
 ```
 
 ## Compress Options
@@ -96,16 +94,16 @@ fastify.listen(3000, function (err) {
 ### threshold
 The minimum byte size for a response to be compressed. Defaults to `1024`.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { threshold: 2048 }
 )
 ```
 ### customTypes
 [mime-db](https://github.com/jshttp/mime-db) is used to determine if a `content-type` should be compressed. You can compress additional content types via regular expression.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { customTypes: /x-protobuf$/ }
 )
 ```
@@ -113,8 +111,8 @@ fastify.register(
 ### onUnsupportedEncoding
 When the encoding is not supported, a custom error response can be sent in place of the uncompressed payload by setting the `onUnsupportedEncoding(encoding, request, reply)` option to be a function that can modify the reply and return a `string | Buffer | Stream | Error` payload.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
     onUnsupportedEncoding: (encoding, request, reply) => {
       reply.code(406)
@@ -130,8 +128,8 @@ You can selectively disable response compression by using the `x-no-compression`
 ### Inflate pre-compressed bodies for clients that do not support compression
 Optional feature to inflate pre-compressed data if the client does not include one of the supported compression types in its `accept-encoding` header.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { inflateIfDeflated: true }
 )
 
@@ -143,11 +141,11 @@ fastify.get('/file', (req, reply) =>
 
 ### Customize encoding priority
 
-By default, `fastify-compress` prioritizes compression as described [at the beginning of §Usage - Compress replies](#usage). You can change that by passing an array of compression tokens to the `encodings` option:
+By default, `@fastify/compress` prioritizes compression as described [at the beginning of §Usage - Compress replies](#usage). You can change that by passing an array of compression tokens to the `encodings` option:
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   // Only support gzip and deflate, and prefer deflate to gzip
   { encodings: ['deflate', 'gzip'] }
 )
@@ -172,11 +170,11 @@ You can tune compression by setting the `brotliOptions` and `zlibOptions` proper
 ```
 
 ### Manage `Content-Length` header removal with removeContentLengthHeader
-By default, `fastify-compress` removes the reply `Content-Length` header. You can change that by setting the `removeContentLengthHeader` to `false` either on a global scope or on a route specific scope.
+By default, `@fastify/compress` removes the reply `Content-Length` header. You can change that by setting the `removeContentLengthHeader` to `false` either on a global scope or on a route specific scope.
 
 ```javascript
   // Global plugin scope
-  server.register(fastifyCompress, { global: true, removeContentLengthHeader: false });
+  await server.register(fastifyCompress, { global: true, removeContentLengthHeader: false });
 
   // Route specific scope
   fastify.get('/file', {
@@ -204,8 +202,8 @@ If the request header is missing, the plugin will not do anything and yield to t
 
 The global request decompression hook is enabled by default. To disable it, pass the option `{ global: false }`:
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 ```
@@ -216,8 +214,8 @@ Remember that thanks to the Fastify encapsulation model, you can set a global de
 
 You can specify different options for decompression per route by passing in the `decompress` options on the route's configuration.
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   { global: false }
 )
 
@@ -238,11 +236,11 @@ fastify.get('/custom-route', {
 
 ### requestEncodings
 
-By default, `fastify-compress` accepts all encodings specified [at the beginning of §Usage - Decompress request payloads](#usage). You can change that by passing an array of compression tokens to the `requestEncodings` option:
+By default, `@fastify/compress` accepts all encodings specified [at the beginning of §Usage - Decompress request payloads](#usage). You can change that by passing an array of compression tokens to the `requestEncodings` option:
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   // Only support gzip
   { requestEncodings: ['gzip'] }
 )
@@ -250,19 +248,19 @@ fastify.register(
 
 ### forceRequestEncoding
 
-By default, `fastify-compress` chooses the decompressing algorithm by looking at the `content-encoding` header, if present.
+By default, `@fastify/compress` chooses the decompressing algorithm by looking at the `content-encoding` header, if present.
 
 You can force one algorithm and ignore the header at all by providing the `forceRequestEncoding` option.
 
-Note that if the request payload is not compressed, `fastify-compress` will try to decompress, resulting in an error.
+Note that if the request payload is not compressed, `@fastify/compress` will try to decompress, resulting in an error.
 
 ### onUnsupportedRequestEncoding
 
 When the request payload encoding is not supported, you can customize the response error by setting the `onUnsupportedEncoding(request, encoding)` option to be a function that returns an error.
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
      onUnsupportedRequestEncoding: (request, encoding) => {
       return {
@@ -281,8 +279,8 @@ fastify.register(
 When the request payload cannot be decompressed using the detected algorithm, you can customize the response error setting the `onInvalidRequestPayload(request, encoding)` option to be a function that returns an error.
 
 ```javascript
-fastify.register(
-  require('fastify-compress'),
+await fastify.register(
+  import('@fastify/compress'),
   {
     onInvalidRequestPayload: (request, encoding, error) => {
       return {

package/index.js

@@ -143,8 +143,8 @@ function processCompressParams (opts) {
 
   params.encodings = Array.isArray(opts.encodings)
     ? supportedEncodings
-        .filter(encoding => opts.encodings.includes(encoding))
-        .sort((a, b) => opts.encodings.indexOf(a) - supportedEncodings.indexOf(b))
+      .filter(encoding => opts.encodings.includes(encoding))
+      .sort((a, b) => opts.encodings.indexOf(a) - supportedEncodings.indexOf(b))
     : supportedEncodings
 
   return params
@@ -175,8 +175,8 @@ function processDecompressParams (opts) {
 
   params.encodings = Array.isArray(opts.requestEncodings)
     ? supportedEncodings
-        .filter(encoding => opts.requestEncodings.includes(encoding))
-        .sort((a, b) => opts.requestEncodings.indexOf(a) - supportedEncodings.indexOf(b))
+      .filter(encoding => opts.requestEncodings.includes(encoding))
+      .sort((a, b) => opts.requestEncodings.indexOf(a) - supportedEncodings.indexOf(b))
     : supportedEncodings
 
   if (opts.forceRequestEncoding) {
@@ -268,8 +268,8 @@ function buildRouteCompress (fastify, params, routeOptions, decorateOnly) {
 
     params.removeContentLengthHeader
       ? reply
-          .header('Content-Encoding', encoding)
-          .removeHeader('content-length')
+        .header('Content-Encoding', encoding)
+        .removeHeader('content-length')
       : reply.header('Content-Encoding', encoding)
 
     stream = zipStream(params.compressStream, encoding)
@@ -393,8 +393,8 @@ function compress (params) {
 
     params.removeContentLengthHeader
       ? this
-          .header('Content-Encoding', encoding)
-          .removeHeader('content-length')
+        .header('Content-Encoding', encoding)
+        .removeHeader('content-length')
       : this.header('Content-Encoding', encoding)
 
     stream = zipStream(params.compressStream, encoding)
@@ -551,6 +551,6 @@ function createError (code, message, statusCode) {
 }
 
 module.exports = fp(compressPlugin, {
-  fastify: '3.x',
-  name: 'fastify-compress'
+  fastify: '4.x',
+  name: '@fastify/compress'
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/compress",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "Fastify compression utils",
   "main": "index.js",
   "types": "index.d.ts",
@@ -23,10 +23,10 @@
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
     "adm-zip": "^0.5.9",
-    "fastify": "^3.25.3",
+    "fastify": "^4.0.0-rc.2",
     "jsonstream": "^1.0.3",
     "pre-commit": "^1.2.2",
-    "standard": "^16.0.4",
+    "standard": "^17.0.0",
     "tap": "^16.0.0",
     "tsd": "^0.20.0",
     "typescript": "^4.5.4"

package/test/global-compress.test.js

@@ -8,6 +8,7 @@ const AdmZip = require('adm-zip')
 const JSONStream = require('jsonstream')
 const Fastify = require('fastify')
 const compressPlugin = require('../index')
+const { once } = require('events')
 
 test('When `global` is not set, it is `true` by default :', async (t) => {
   t.test('it should compress Buffer data using brotli when `Accept-Encoding` request header is `br`', async (t) => {
@@ -343,7 +344,7 @@ test('It should send compressed Buffer data when `global` is `true` :', async (t
     t.plan(1)
 
     const fastify = Fastify()
-    fastify.register(compressPlugin, { global: true, threshold: 0 })
+    await fastify.register(compressPlugin, { global: true, threshold: 0 })
 
     const buf = Buffer.from('hello world')
     fastify.get('/', (request, reply) => {
@@ -1639,14 +1640,16 @@ test('It should return a serialized payload when `inflateIfDeflated` is `true` a
   t.equal(two.payload, compressedBufferPayload.toString())
 })
 
-test('It should close the stream', (t) => {
-  t.plan(4)
+test('It should close the stream', async (t) => {
+  t.plan(3)
 
   const fastify = Fastify()
-  fastify.register(compressPlugin, { global: true })
+  await fastify.register(compressPlugin, { global: true })
+
+  const stream = createReadStream('./package.json')
+  const closed = once(stream, 'close')
 
   fastify.get('/', (request, reply) => {
-    const stream = createReadStream('./package.json')
     stream.on('close', () => t.ok('stream closed'))
 
     reply
@@ -1654,16 +1657,15 @@ test('It should close the stream', (t) => {
       .compress(stream)
   })
 
-  fastify.inject({
+  const response = await fastify.inject({
     url: '/',
     method: 'GET'
-  }, (err, response) => {
-    t.error(err)
-
-    const file = readFileSync('./package.json', 'utf8')
-    t.equal(response.statusCode, 200)
-    t.equal(file, response.payload)
   })
+
+  const file = readFileSync('./package.json', 'utf8')
+  t.equal(response.statusCode, 200)
+  t.equal(file, response.payload)
+  await closed
 })
 
 test('It should log an existing error with stream onEnd handler', async (t) => {

package/test/routes-compress.test.js

@@ -225,27 +225,20 @@ test('When using routes `compress` settings :', async (t) => {
   })
 
   t.test('it should throw an error on invalid route `compress` settings', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.get('/', {
-      compress: 'bad config'
-    }, (request, reply) => {
-      reply.send('')
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.get('/', {
+        compress: 'bad config'
+      }, (request, reply) => {
+        reply.send('')
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route compress configuration')
-    })
+    }
   })
 })
 
@@ -385,32 +378,25 @@ test('When using the old routes `{ config: compress }` option :', async (t) => {
   })
 
   t.test('it should use the old routes `{ config: compress }` options over routes `compress` options', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.get('/', {
-      compress: {
-        zlib: { createGzip: () => zlib.createGzip() }
-      },
-      config: {
-        compress: 'bad config'
-      }
-    }, (request, reply) => {
-      reply.send('')
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'GET',
-      headers: {
-        'accept-encoding': 'gzip'
-      }
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.get('/', {
+        compress: {
+          zlib: { createGzip: () => zlib.createGzip() }
+        },
+        config: {
+          compress: 'bad config'
+        }
+      }, (request, reply) => {
+        reply.send('')
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route compress configuration')
-    })
+    }
   })
 })
 

package/test/routes-decompress.test.js

@@ -189,26 +189,18 @@ test('When using routes `decompress` settings :', async (t) => {
   })
 
   t.test('it should throw an error on invalid route `decompress` settings', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.post('/', { decompress: 'bad config' }, (request, reply) => {
-      reply.send(request.body.name)
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'POST',
-      headers: {
-        'content-encoding': 'gzip'
-      },
-      payload: ''
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.post('/', { decompress: 'bad config' }, (request, reply) => {
+        reply.send(request.body.name)
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route decompress configuration')
-    })
+    }
   })
 })
 
@@ -274,32 +266,24 @@ test('When using the old routes `{ config: decompress }` option :', async (t) =>
   })
 
   t.test('it should use the old routes `{ config: decompress }` options over routes `decompress` options', async (t) => {
-    t.plan(2)
+    t.plan(1)
 
     const fastify = Fastify()
     await fastify.register(compressPlugin, { global: false })
 
-    fastify.post('/', {
-      decompress: {
-        zlib: { createGunzip: () => zlib.createGunzip() }
-      },
-      config: {
-        decompress: 'bad config'
-      }
-    }, (request, reply) => {
-      reply.send(request.body.name)
-    })
-
-    await fastify.inject({
-      url: '/',
-      method: 'POST',
-      headers: {
-        'content-encoding': 'gzip'
-      },
-      payload: ''
-    }).catch((err) => {
-      t.type(err, Error)
+    try {
+      fastify.post('/', {
+        decompress: {
+          zlib: { createGunzip: () => zlib.createGunzip() }
+        },
+        config: {
+          decompress: 'bad config'
+        }
+      }, (request, reply) => {
+        reply.send(request.body.name)
+      })
+    } catch (err) {
       t.equal(err.message, 'Unknown value for route decompress configuration')
-    })
+    }
   })
 })