koa-compress 2.0.0 → 4.0.1

package/HISTORY.md

@@ -1,9 +1,39 @@
 
+4.0.1 / 2020-04-29
+==================
+
+ * fix issue with state being preserved between requests
+
+4.0.0 / 2020-04-27
+==================
+
+ * drop support for versions of node below 10
+ * add brotli support for versions of node that support it
+ * changed compression options; `options` is no longer passed to each compression function. Use `options.gzip = {}`, `options.br = {}`, etc.
+ * added compression disabling option: set `options.br = false`
+
+3.1.0 / 2020-04-15
+==================
+
+ * support no-transform @Pawda
+
+3.0.0 / 2018-04-14
+==================
+
+ * republish 2.1.0 as it switches to async functions
+
+2.1.0 / 2018-04-13 (unpublished)
+==================
+
+ * do not compress if the response is not writable
+ * switch testing frameworks to jest
+ * implement linting
+
 1.0.8 / 2014-09-14
 ==================
 
  * bump compressible
- 
+
 1.0.7 / 2014-05-13
 ==================
 

package/README.md

@@ -1,41 +1,64 @@
-# Koa Compress [![Build Status](https://travis-ci.org/koajs/compress.png)](https://travis-ci.org/koajs/compress)
+# Koa Compress
+
+[![Node.js CI](https://github.com/koajs/compress/workflows/Node.js%20CI/badge.svg?branch=master)](https://github.com/koajs/compress/actions?query=workflow%3A%22Node.js+CI%22+branch%3Amaster)
+[![codecov](https://codecov.io/gh/koajs/compress/branch/master/graph/badge.svg)](https://codecov.io/gh/koajs/compress)
 
 Compress middleware for Koa
 
 ## Example
 
 ```js
-var compress = require('koa-compress')
-var Koa = require('koa')
+const compress = require('koa-compress')
+const Koa = require('koa')
 
-var app = new Koa()
+const app = new Koa()
 app.use(compress({
-  filter: function (content_type) {
+  filter (content_type) {
   	return /text/i.test(content_type)
   },
   threshold: 2048,
-  flush: require('zlib').Z_SYNC_FLUSH
+  gzip: {
+    flush: require('zlib').Z_SYNC_FLUSH
+  },
+  deflate: {
+    flush: require('zlib').Z_SYNC_FLUSH,
+  },
+  br: false // disable brotli
 }))
 ```
 
 ## Options
 
-The options are passed to `zlib`: http://nodejs.org/api/zlib.html#zlib_options
+### filter\<Function\>
 
-### filter
+```ts
+function (mimeType: string): Boolean {
+
+}
+```
 
 An optional function that checks the response content type to decide whether to compress.
-By default, it uses [compressible](https://github.com/expressjs/compressible).
+By default, it uses [compressible](https://github.com/jshttp/compressible).
 
-### threshold
+### options.threshold\<String|Number\>
 
 Minimum response size in bytes to compress.
 Default `1024` bytes or `1kb`.
 
+### options[encoding]\<Object\>
+
+The current encodings are, in order of preference: `br`, `gzip`, `deflate`.
+Setting `options[encoding] = {}` will pass those options to the encoding function.
+Setting `options[encoding] = false` will disable that encoding.
+
+### options.br
+
+[Brotli compression](https://en.wikipedia.org/wiki/Brotli) is supported in node v11.7.0+, which includes it natively. 
+
 ## Manually turning compression on and off
 
-You can always enable compression by setting `this.compress = true`.
-You can always disable compression by setting `this.compress = false`.
+You can always enable compression by setting `ctx.compress = true`.
+You can always disable compression by setting `ctx.compress = false`.
 This bypasses the filter check.
 
 ```js

package/lib/encodings.js

@@ -0,0 +1,94 @@
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
+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
+
+  this.encodingWeights = new Map()
+}
+
+Encodings.encodingMethods = {
+  gzip: zlib.createGzip,
+  deflate: zlib.createDeflate,
+  br: zlib.createBrotliCompress
+}
+
+// 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*$/
+
+Encodings.prototype.parseAcceptEncoding = function (acceptEncoding = '*') {
+  const { encodingWeights, reDirective } = this
+
+  acceptEncoding.split(',').forEach((directive) => {
+    const match = reDirective.exec(directive)
+    if (!match) return // not a supported encoding above
+
+    const encoding = match[1]
+
+    // 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)
+
+    if (encoding === '*') {
+      // set the weights for the default encodings
+      this.wildcardAcceptEncoding.forEach((enc) => {
+        if (!encodingWeights.has(enc)) encodingWeights.set(enc, weight)
+      })
+      return
+    }
+
+    encodingWeights.set(encoding, weight)
+  })
+}
+
+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
+    }
+  }
+
+  // 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'
+}

package/lib/index.js

@@ -0,0 +1,87 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+const compressible = require('compressible')
+const isJSON = require('koa-is-json')
+const status = require('statuses')
+const Stream = require('stream')
+const bytes = require('bytes')
+
+const Encodings = require('./encodings')
+
+/**
+* Regex to match no-transform directive in a cache-control header
+*/
+const NO_TRANSFORM_REGEX = /(?:^|,)\s*?no-transform\s*?(?:,|$)/
+
+/**
+ * Compress middleware.
+ *
+ * @param {Object} [options]
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = (options = {}) => {
+  let { filter = compressible, threshold = 1024 } = options
+  if (typeof threshold === 'string') threshold = bytes(threshold)
+
+  // `options.br = false` would remove it as a preferred encoding
+  const preferredEncodings = Encodings.preferredEncodings.filter((encoding) => options[encoding] !== false && options[encoding] !== null)
+
+  return async (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
+
+    // get the preferred content encoding
+    const encodings = new Encodings({
+      preferredEncodings
+    })
+    encodings.parseAcceptEncoding(ctx.request.headers['accept-encoding'] || undefined)
+    const encoding = encodings.getPreferredContentEncoding()
+
+    // identity === no compression
+    if (encoding === 'identity') return
+
+    /** begin compression logic **/
+
+    // json
+    if (isJSON(body)) body = ctx.body = JSON.stringify(body)
+
+    ctx.set('Content-Encoding', encoding)
+    ctx.res.removeHeader('Content-Length')
+
+    const compress = Encodings.encodingMethods[encoding]
+    const stream = ctx.body = compress(options[encoding])
+
+    if (body instanceof Stream) {
+      body.pipe(stream)
+    } else {
+      stream.end(body)
+    }
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koa-compress",
   "description": "Compress middleware for koa",
-  "version": "2.0.0",
+  "version": "4.0.1",
   "author": {
     "name": "Jonathan Ong",
     "email": "me@jongleberry.com",
@@ -11,26 +11,37 @@
   "license": "MIT",
   "repository": "koajs/compress",
   "dependencies": {
-    "bytes": "^2.3.0",
+    "bytes": "^3.0.0",
     "compressible": "^2.0.0",
+    "http-errors": "^1.7.3",
     "koa-is-json": "^1.0.0",
-    "statuses": "^1.0.0"
+    "statuses": "^2.0.0"
   },
   "devDependencies": {
-    "istanbul": "^0.4.2",
-    "koa": "^2.0.0-alpha.3",
-    "mocha": "^2.4.1",
-    "should": "^3.0.0",
-    "supertest": "^1.0.0"
+    "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"
   },
   "scripts": {
-    "test": "NODE_ENV=test mocha --require should --reporter spec",
-    "test-cov": "NODE_ENV=test node ./node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha -- --require should",
-    "test-travis": "NODE_ENV=test node ./node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha --report lcovonly -- --require should"
+    "eslint": "eslint --ignore-path .gitignore .",
+    "test": "jest"
   },
   "files": [
-    "index.js",
+    "lib",
     "LICENSE",
     "HISTORY.md"
-  ]
+  ],
+  "main": "lib",
+  "jest": {
+    "testEnvironment": "node"
+  },
+  "engines": {
+    "node": ">= 8.0.0"
+  }
 }

package/index.js

@@ -1,79 +0,0 @@
-'use strict';
-
-/**
- * Module dependencies.
- */
-
-var compressible = require('compressible')
-var isJSON = require('koa-is-json')
-var status = require('statuses')
-var Stream = require('stream')
-var bytes = require('bytes')
-var zlib = require('zlib')
-
-/**
- * Encoding methods supported.
- */
-
-var encodingMethods = {
-  gzip: zlib.createGzip,
-  deflate: zlib.createDeflate
-}
-
-/**
- * Compress middleware.
- *
- * @param {Object} [options]
- * @return {Function}
- * @api public
- */
-
-module.exports = (options) => {
-  options = options || {}
-
-  var filter = options.filter || compressible
-
-  var threshold = !options.threshold ? 1024
-    : typeof options.threshold === 'number' ? options.threshold
-    : typeof options.threshold === 'string' ? bytes(options.threshold)
-    : 1024
-
-  return function compress(ctx, next) {
-    ctx.vary('Accept-Encoding')
-
-    return next().then(() => {
-      var body = ctx.body
-      if (!body) 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
-
-      // identity
-      var encoding = ctx.acceptsEncodings('gzip', 'deflate', 'identity')
-      if (!encoding) ctx.throw(406, 'supported encodings: gzip, deflate, identity')
-      if (encoding === 'identity') return
-
-      // json
-      if (isJSON(body)) body = ctx.body = JSON.stringify(body)
-
-      // threshold
-      if (threshold && ctx.response.length < threshold) return
-
-      ctx.set('Content-Encoding', encoding)
-      ctx.res.removeHeader('Content-Length')
-
-      var stream =
-      ctx.body = encodingMethods[encoding](options)
-
-      if (body instanceof Stream) {
-        body.pipe(stream)
-      } else {
-        stream.end(body)
-      }
-    });
-  };
-}