koa-compress 5.0.1 → 5.1.1

package/HISTORY.md

@@ -1,3 +1,4 @@
+SEE https://github.com/koajs/compress/releases
 
 4.0.1 / 2020-04-29
 ==================

package/README.md

@@ -27,6 +27,11 @@ app.use(compress({
 }))
 ```
 
+## Maintainers
+
+- Lead: @jonathanong [@jongleberry](https://twitter.com/jongleberry)
+- Team: @koajs/compress
+
 ## Options
 
 ### filter\<Function\>
@@ -54,12 +59,13 @@ Setting `options[encoding] = false` will disable that encoding.
 #### options<span></span>.br
 
 [Brotli compression](https://en.wikipedia.org/wiki/Brotli) is supported in node v11.7.0+, which includes it natively.
+As of v5.1.0, the default quality level is 4 for performance reasons.
 
 ### options.defaultEncoding\<String\>
 
 An optional string, which specifies what encoders to use for requests without
 [Accept-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding).
-Default `idenity`.
+Default `identity`.
 
 The standard dictates to treat such requests as `*` meaning that all compressions are permissible,
 yet it causes very practical problems when debugging servers with manual tools like `curl`, `wget`, and so on.

package/lib/encodings.js

@@ -3,92 +3,102 @@
 const errors = require('http-errors')
 const zlib = require('zlib')
 
-module.exports = Encodings
-
-// TODO: convert this to a Class when we drop node@10 support
-// because node@10 does not support class fields.
-function Encodings (options = {}) {
-  this.wildcardAcceptEncoding = options.wildcardAcceptEncoding || Encodings.wildcardAcceptEncoding
-  this.preferredEncodings = options.preferredEncodings || Encodings.preferredEncodings
-  this.reDirective = options.reDirective || Encodings.reDirective
+class Encodings {
+  constructor (options = {}) {
+    this.wildcardAcceptEncoding = options.wildcardAcceptEncoding || Encodings.wildcardAcceptEncoding
+    this.preferredEncodings = options.preferredEncodings || Encodings.preferredEncodings
+    this.reDirective = options.reDirective || Encodings.reDirective
 
-  this.encodingWeights = new Map()
-}
+    this.encodingWeights = new Map()
+  }
 
-Encodings.encodingMethods = {
-  gzip: zlib.createGzip,
-  deflate: zlib.createDeflate,
-  br: zlib.createBrotliCompress
-}
+  parseAcceptEncoding (acceptEncoding = '*') {
+    const { encodingWeights, reDirective } = this
 
-// how we treat `Accept-Encoding: *`
-Encodings.wildcardAcceptEncoding = ['gzip', 'deflate']
-// our preferred encodings
-Encodings.preferredEncodings = ['br', 'gzip', 'deflate']
-Encodings.reDirective = /^\s*(gzip|compress|deflate|br|identity|\*)\s*(?:;\s*q\s*=\s*(\d(?:\.\d)?))?\s*$/
+    acceptEncoding.split(',').forEach((directive) => {
+      const match = reDirective.exec(directive)
+      if (!match) return // not a supported encoding above
 
-Encodings.prototype.parseAcceptEncoding = function (acceptEncoding = '*') {
-  const { encodingWeights, reDirective } = this
+      const encoding = match[1]
 
-  acceptEncoding.split(',').forEach((directive) => {
-    const match = reDirective.exec(directive)
-    if (!match) return // not a supported encoding above
+      // weight must be in [0, 1]
+      let weight = match[2] && !isNaN(match[2]) ? parseFloat(match[2], 10) : 1
+      weight = Math.max(weight, 0)
+      weight = Math.min(weight, 1)
 
-    const encoding = match[1]
+      if (encoding === '*') {
+        // set the weights for the default encodings
+        this.wildcardAcceptEncoding.forEach((enc) => {
+          if (!encodingWeights.has(enc)) encodingWeights.set(enc, weight)
+        })
+        return
+      }
 
-    // weight must be in [0, 1]
-    let weight = match[2] && !isNaN(match[2]) ? parseFloat(match[2], 10) : 1
-    weight = Math.max(weight, 0)
-    weight = Math.min(weight, 1)
+      encodingWeights.set(encoding, weight)
+    })
+  }
 
-    if (encoding === '*') {
-      // set the weights for the default encodings
-      this.wildcardAcceptEncoding.forEach((enc) => {
-        if (!encodingWeights.has(enc)) encodingWeights.set(enc, weight)
-      })
-      return
+  getPreferredContentEncoding () {
+    const {
+      encodingWeights,
+      preferredEncodings
+    } = this
+
+    // get ordered list of accepted encodings
+    const acceptedEncodings = Array.from(encodingWeights.keys())
+      // sort by weight
+      .sort((a, b) => encodingWeights.get(b) - encodingWeights.get(a))
+      // filter by supported encodings
+      .filter((encoding) => encoding === 'identity' || typeof Encodings.encodingMethods[encoding] === 'function')
+
+    // group them by weights
+    const weightClasses = new Map()
+    acceptedEncodings.forEach((encoding) => {
+      const weight = encodingWeights.get(encoding)
+      if (!weightClasses.has(weight)) weightClasses.set(weight, new Set())
+      weightClasses.get(weight).add(encoding)
+    })
+
+    // search by weight, descending
+    const weights = Array.from(weightClasses.keys()).sort((a, b) => b - a)
+    for (let i = 0; i < weights.length; i++) {
+      // encodings at this weight
+      const encodings = weightClasses.get(weights[i])
+      // return the first encoding in the preferred list
+      for (let j = 0; j < preferredEncodings.length; j++) {
+        const preferredEncoding = preferredEncodings[j]
+        if (encodings.has(preferredEncoding)) return preferredEncoding
+      }
     }
 
-    encodingWeights.set(encoding, weight)
-  })
+    // no encoding matches, check to see if the client set identity, q=0
+    if (encodingWeights.get('identity') === 0) throw errors(406, 'Please accept br, gzip, deflate, or identity.')
+
+    // by default, return nothing
+    return 'identity'
+  }
+}
+
+Encodings.encodingMethods = {
+  gzip: zlib.createGzip,
+  deflate: zlib.createDeflate,
+  br: zlib.createBrotliCompress
 }
 
-Encodings.prototype.getPreferredContentEncoding = function () {
-  const {
-    encodingWeights,
-    preferredEncodings
-  } = this
-
-  // get ordered list of accepted encodings
-  const acceptedEncodings = Array.from(encodingWeights.keys())
-    // sort by weight
-    .sort((a, b) => encodingWeights.get(b) - encodingWeights.get(a))
-    // filter by supported encodings
-    .filter((encoding) => encoding === 'identity' || typeof Encodings.encodingMethods[encoding] === 'function')
-
-  // group them by weights
-  const weightClasses = new Map()
-  acceptedEncodings.forEach((encoding) => {
-    const weight = encodingWeights.get(encoding)
-    if (!weightClasses.has(weight)) weightClasses.set(weight, new Set())
-    weightClasses.get(weight).add(encoding)
-  })
-
-  // search by weight, descending
-  const weights = Array.from(weightClasses.keys()).sort((a, b) => b - a)
-  for (let i = 0; i < weights.length; i++) {
-    // encodings at this weight
-    const encodings = weightClasses.get(weights[i])
-    // return the first encoding in the preferred list
-    for (let j = 0; j < preferredEncodings.length; j++) {
-      const preferredEncoding = preferredEncodings[j]
-      if (encodings.has(preferredEncoding)) return preferredEncoding
+Encodings.encodingMethodDefaultOptions = {
+  gzip: {},
+  deflate: {},
+  br: {
+    params: {
+      [zlib.constants.BROTLI_PARAM_QUALITY]: 4
     }
   }
+}
 
-  // no encoding matches, check to see if the client set identity, q=0
-  if (encodingWeights.get('identity') === 0) throw errors(406, 'Please accept br, gzip, deflate, or identity.')
+// how we treat `Accept-Encoding: *`
+Encodings.wildcardAcceptEncoding = ['gzip', 'deflate']
+// our preferred encodings
+Encodings.preferredEncodings = ['br', 'gzip', 'deflate']
+Encodings.reDirective = /^\s*(gzip|compress|deflate|br|identity|\*)\s*(?:;\s*q\s*=\s*(\d(?:\.\d)?))?\s*$/
 
-  // by default, return nothing
-  return 'identity'
-}
+module.exports = Encodings

package/lib/index.js

@@ -6,7 +6,6 @@
 
 const compressible = require('compressible')
 const isJSON = require('koa-is-json')
-const status = require('statuses')
 const Stream = require('stream')
 const bytes = require('bytes')
 
@@ -17,6 +16,11 @@ const Encodings = require('./encodings')
 */
 const NO_TRANSFORM_REGEX = /(?:^|,)\s*?no-transform\s*?(?:,|$)/
 
+/**
+ * empty body statues.
+ */
+const emptyBodyStatues = new Set([204, 205, 304])
+
 /**
  * Compress middleware.
  *
@@ -31,36 +35,46 @@ module.exports = (options = {}) => {
 
   // `options.br = false` would remove it as a preferred encoding
   const preferredEncodings = Encodings.preferredEncodings.filter((encoding) => options[encoding] !== false && options[encoding] !== null)
+  const encodingOptions = {}
+  preferredEncodings.forEach((encoding) => {
+    encodingOptions[encoding] = {
+      ...Encodings.encodingMethodDefaultOptions[encoding],
+      ...(options[encoding] || {})
+    }
+  })
+
+  Object.assign(compressMiddleware, {
+    preferredEncodings,
+    encodingOptions
+  })
 
-  return async (ctx, next) => {
+  return compressMiddleware
+
+  async function compressMiddleware (ctx, next) {
     ctx.vary('Accept-Encoding')
 
     await next()
 
-    // early exit if there's no content body or the body is already encoded
     let { body } = ctx
-    if (!body) return
-    if (ctx.res.headersSent || !ctx.writable) return
-    if (ctx.compress === false) return
-    if (ctx.request.method === 'HEAD') return
-    if (status.empty[ctx.response.status]) return
-    if (ctx.response.get('Content-Encoding')) return
-
-    // forced compression or implied
-    if (!(ctx.compress === true || filter(ctx.response.type))) return
-
-    // don't compress for Cache-Control: no-transform
-    // https://tools.ietf.org/html/rfc7234#section-5.2.1.6
-    const cacheControl = ctx.response.get('Cache-Control')
-    if (cacheControl && NO_TRANSFORM_REGEX.test(cacheControl)) return
-
-    // don't compress if the current response is below the threshold
-    if (threshold && ctx.response.length < threshold) return
+    if (
+      // early exit if there's no content body or the body is already encoded
+      !body ||
+      ctx.res.headersSent || !ctx.writable ||
+      ctx.compress === false ||
+      ctx.request.method === 'HEAD' ||
+      emptyBodyStatues.has(+ctx.response.status) ||
+      ctx.response.get('Content-Encoding') ||
+      // forced compression or implied
+      !(ctx.compress === true || filter(ctx.response.type)) ||
+      // don't compress for Cache-Control: no-transform
+      // https://tools.ietf.org/html/rfc7234#section-5.2.1.6
+      NO_TRANSFORM_REGEX.test(ctx.response.get('Cache-Control')) ||
+      // don't compress if the current response is below the threshold
+      (threshold && ctx.response.length < threshold)
+    ) return
 
     // get the preferred content encoding
-    const encodings = new Encodings({
-      preferredEncodings
-    })
+    const encodings = new Encodings({ preferredEncodings })
     encodings.parseAcceptEncoding(ctx.request.headers['accept-encoding'] || defaultEncoding)
     const encoding = encodings.getPreferredContentEncoding()
 
@@ -76,12 +90,9 @@ module.exports = (options = {}) => {
     ctx.res.removeHeader('Content-Length')
 
     const compress = Encodings.encodingMethods[encoding]
-    const stream = ctx.body = compress(options[encoding])
+    const stream = ctx.body = compress(encodingOptions[encoding])
 
-    if (body instanceof Stream) {
-      body.pipe(stream)
-    } else {
-      stream.end(body)
-    }
+    if (body instanceof Stream) return body.pipe(stream)
+    stream.end(body)
   }
 }

package/package.json

@@ -1,32 +1,38 @@
 {
   "name": "koa-compress",
   "description": "Compress middleware for koa",
-  "version": "5.0.1",
+  "version": "5.1.1",
   "author": {
     "name": "Jonathan Ong",
     "email": "me@jongleberry.com",
     "url": "http://jongleberry.com",
     "twitter": "https://twitter.com/jongleberry"
   },
+  "contributors": [
+    {
+      "name": "Imed Jaberi",
+      "email": "imed-jaberi@outlook.com",
+      "url": "https://www.3imed-jaberi.com/"
+    }
+  ],
   "license": "MIT",
   "repository": "koajs/compress",
   "dependencies": {
-    "bytes": "^3.0.0",
-    "compressible": "^2.0.0",
-    "http-errors": "^1.7.3",
-    "koa-is-json": "^1.0.0",
-    "statuses": "^2.0.0"
+    "bytes": "^3.1.2",
+    "compressible": "^2.0.18",
+    "http-errors": "^1.8.1",
+    "koa-is-json": "^1.0.0"
   },
   "devDependencies": {
-    "eslint": "^6.0.0",
-    "eslint-config-standard": "^14.1.1",
-    "eslint-plugin-import": "^2.9.0",
-    "eslint-plugin-node": "^11.0.0",
-    "eslint-plugin-promise": "^4.0.0",
-    "eslint-plugin-standard": "^4.0.1",
-    "jest": "^25.3.0",
-    "koa": "^2.0.1",
-    "supertest": "^4.0.2"
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.2.0",
+    "eslint-plugin-standard": "^5.0.0",
+    "jest": "^27.5.1",
+    "koa": "^2.13.4",
+    "supertest": "^6.2.4"
   },
   "scripts": {
     "eslint": "eslint --ignore-path .gitignore .",
@@ -38,10 +44,7 @@
     "HISTORY.md"
   ],
   "main": "lib",
-  "jest": {
-    "testEnvironment": "node"
-  },
   "engines": {
-    "node": ">= 8.0.0"
+    "node": ">= 12"
   }
 }