@fastify/compress 6.2.0 → 6.3.0

package/.github/workflows/ci.yml

@@ -2,6 +2,11 @@ name: CI
 
 on:
   push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
     paths-ignore:
       - 'docs/**'
       - '*.md'

package/README.md

@@ -99,7 +99,8 @@ await fastify.register(
 )
 ```
 ### 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.
+[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 or by providing a function.
+
 ```javascript
 await fastify.register(
   import('@fastify/compress'),
@@ -107,6 +108,15 @@ await fastify.register(
 )
 ```
 
+or
+
+```javascript
+await fastify.register(
+  import('@fastify/compress'),
+  { customTypes: contentType => contentType.endsWith('x-protobuf') }
+)
+```
+
 ### 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

package/index.js

@@ -6,7 +6,7 @@ const pump = require('pump')
 const mimedb = require('mime-db')
 const intoStream = require('into-stream')
 const peek = require('peek-stream')
-const Minipass = require('minipass')
+const { Minipass } = require('minipass')
 const pumpify = require('pumpify')
 const encodingNegotiator = require('@fastify/accept-negotiator')
 const { inherits, format } = require('util')
@@ -107,6 +107,8 @@ function fastifyCompress (fastify, opts, next) {
   next()
 }
 
+const defaultCompressibleTypes = /^text\/(?!event-stream)|\+json$|\+text$|\+xml$|octet-stream$/
+
 function processCompressParams (opts) {
   /* istanbul ignore next */
   if (!opts) {
@@ -123,7 +125,11 @@ function processCompressParams (opts) {
   params.onUnsupportedEncoding = opts.onUnsupportedEncoding
   params.inflateIfDeflated = opts.inflateIfDeflated === true
   params.threshold = typeof opts.threshold === 'number' ? opts.threshold : 1024
-  params.compressibleTypes = opts.customTypes instanceof RegExp ? opts.customTypes : /^text\/(?!event-stream)|\+json$|\+text$|\+xml$|octet-stream$/
+  params.compressibleTypes = opts.customTypes instanceof RegExp
+    ? opts.customTypes.test.bind(opts.customTypes)
+    : typeof opts.customTypes === 'function'
+      ? opts.customTypes
+      : defaultCompressibleTypes.test.bind(defaultCompressibleTypes)
   params.compressStream = {
     br: () => ((opts.zlib || zlib).createBrotliCompress || zlib.createBrotliCompress)(params.brotliOptions),
     gzip: () => ((opts.zlib || zlib).createGzip || zlib.createGzip)(params.zlibOptions),
@@ -142,7 +148,7 @@ 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))
+      .sort((a, b) => opts.encodings.indexOf(a) - opts.encodings.indexOf(b))
     : supportedEncodings
 
   return params
@@ -174,7 +180,7 @@ 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))
+      .sort((a, b) => opts.requestEncodings.indexOf(a) - opts.requestEncodings.indexOf(b))
     : supportedEncodings
 
   if (opts.forceRequestEncoding) {
@@ -461,7 +467,7 @@ function getEncodingHeader (encodings, request) {
 }
 
 function shouldCompress (type, compressibleTypes) {
-  if (compressibleTypes.test(type)) return true
+  if (compressibleTypes(type)) return true
   const data = mimedb[type.split(';', 1)[0].trim().toLowerCase()]
   if (data === undefined) return false
   return data.compressible === true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/compress",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Fastify compression utils",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -9,14 +9,14 @@
     "fastify-plugin": "^4.0.0",
     "into-stream": "^6.0.0",
     "mime-db": "^1.51.0",
-    "minipass": "^3.1.6",
+    "minipass": "^5.0.0",
     "peek-stream": "^1.1.3",
     "pump": "^3.0.0",
     "pumpify": "^2.0.1"
   },
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.1.0",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
     "adm-zip": "^0.5.9",
@@ -24,8 +24,8 @@
     "jsonstream": "^1.0.3",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.24.1",
-    "typescript": "^4.5.4"
+    "tsd": "^0.28.0",
+    "typescript": "^5.0.2"
   },
   "scripts": {
     "coverage": "npm run unit -- --cov",

package/test/global-compress.test.js

@@ -785,6 +785,29 @@ test('It should not compress :', async (t) => {
       t.equal(response.statusCode, 200)
     })
 
+    t.test('when `customTypes` is a function and returns false on the provided `Content-Type` reply header`', async (t) => {
+      t.plan(2)
+
+      const fastify = Fastify()
+      await fastify.register(compressPlugin, { customTypes: value => value === 'application/x-user-header' })
+
+      fastify.get('/', (request, reply) => {
+        reply
+          .type('application/x-other-type')
+          .compress(createReadStream('./package.json'))
+      })
+
+      const response = await fastify.inject({
+        url: '/',
+        method: 'GET',
+        headers: {
+          'accept-encoding': 'gzip'
+        }
+      })
+      t.notOk(response.headers['content-encoding'])
+      t.equal(response.statusCode, 200)
+    })
+
     t.test('when `X-No-Compression` request header is `true`', async (t) => {
       t.plan(3)
 
@@ -2443,7 +2466,31 @@ test('It should compress data if `customTypes` is set and matches `Content-Type`
   t.equal(payload.toString('utf-8'), file)
 })
 
-test('It should not apply `customTypes` option if the passed value is not a RegExp', async (t) => {
+test('It should compress data if `customTypes` is a function and returns true on the provided `Content-Type` reply header value', async (t) => {
+  t.plan(2)
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, { customTypes: value => value === 'application/x-user-header' })
+
+  fastify.get('/', (request, reply) => {
+    reply
+      .type('application/x-user-header')
+      .send(createReadStream('./package.json'))
+  })
+
+  const response = await fastify.inject({
+    url: '/',
+    method: 'GET',
+    headers: {
+      'accept-encoding': 'gzip'
+    }
+  })
+  const file = readFileSync('./package.json', 'utf8')
+  const payload = zlib.gunzipSync(response.rawPayload)
+  t.equal(response.headers['content-encoding'], 'gzip')
+  t.equal(payload.toString('utf-8'), file)
+})
+
+test('It should not apply `customTypes` option if the passed value is not a RegExp or Function', async (t) => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -2703,7 +2750,7 @@ test('It should sort and follow custom `encodings` options', async (t) => {
   const fastify = Fastify()
   await fastify.register(compressPlugin, {
     global: true,
-    encodings: ['gzip', 'br']
+    encodings: ['br', 'gzip']
   })
 
   fastify.get('/', (request, reply) => {
@@ -2725,6 +2772,35 @@ test('It should sort and follow custom `encodings` options', async (t) => {
   t.equal(payload.toString('utf-8'), file)
 })
 
+test('It should sort and prefer the order of custom `encodings` options', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  await fastify.register(compressPlugin, {
+    global: true,
+    encodings: ['gzip', 'deflate', 'br']
+  })
+
+  fastify.get('/', (request, reply) => {
+    reply
+      .type('text/plain')
+      .compress(createReadStream('./package.json'))
+  })
+
+  const response = await fastify.inject({
+    url: '/',
+    method: 'GET',
+    headers: {
+      'accept-encoding': 'hello,gzip,br'
+    }
+  })
+
+  const file = readFileSync('./package.json', 'utf8')
+  const payload = zlib.gunzipSync(response.rawPayload)
+  t.equal(response.headers['content-encoding'], 'gzip')
+  t.equal(payload.toString('utf-8'), file)
+})
+
 test('It should sort and follow custom `requestEncodings` options', async (t) => {
   t.plan(2)
 

package/types/index.d.ts

@@ -59,11 +59,13 @@ type RouteDecompressOptions = Pick<fastifyCompress.FastifyCompressOptions,
 
 type EncodingToken = 'br' | 'deflate' | 'gzip' | 'identity';
 
+type CompressibleContentTypeFunction = (contentType: string) => boolean;
+
 declare namespace fastifyCompress {
 
   export interface FastifyCompressOptions {
     brotliOptions?: BrotliOptions;
-    customTypes?: RegExp;
+    customTypes?: RegExp | CompressibleContentTypeFunction;
     encodings?: EncodingToken[];
     forceRequestEncoding?: EncodingToken;
     global?: boolean;

package/types/index.test-d.ts

@@ -28,6 +28,10 @@ const withGlobalOptions: FastifyCompressOptions = {
 const app: FastifyInstance = fastify()
 app.register(fastifyCompress, withGlobalOptions)
 
+app.register(fastifyCompress, {
+  customTypes: value => value === 'application/json'
+})
+
 app.get('/test-one', async (request, reply) => {
   expectType<void>(reply.compress(stream))
 })