@middy/http-content-encoding 3.0.0-alpha.2 → 3.0.0-alpha.3

package/index.js

@@ -1,90 +1,119 @@
-import { Readable, Writable, pipeline as pipelineCallback } from 'stream';
-import { promisify } from 'util';
-import { createBrotliCompress, createGzip, createDeflate } from 'zlib';
-import { normalizeHttpResponse } from '@middy/util';
-const pipeline = promisify(pipelineCallback);
+/*
+ * `zstd` disabled due to lack of support in browsers
+ * https://github.com/Fyrd/caniuse/issues/4065
+ * https://github.com/andrew-aladev/brotli-vs-zstd
+ */
+
+import { Readable, Writable, pipeline as pipelineCallback } from 'stream'
+// import {pipeline} from 'stream/promises'  // available in node >=15
+import { promisify } from 'util'
+
+import { createBrotliCompress, createGzip, createDeflate } from 'zlib'
+// import {ZSTDCompress as createZstdCompress} from 'simple-zstd'
+
+import { normalizeHttpResponse } from '@middy/util'
+const pipeline = promisify(pipelineCallback)
+
 const contentEncodingStreams = {
   br: (opts = {}) => createBrotliCompress(opts),
+  // zstd: (opt = {}) => createZstdCompress(opts),
   gzip: (opts = {}) => createGzip(opts),
   deflate: (opts = {}) => createDeflate(opts)
-};
+}
+
 const defaults = {
   br: undefined,
+  // zstd: undefined,
   gzip: undefined,
   deflate: undefined,
   overridePreferredEncoding: []
-};
-
-const httpContentEncodingMiddleware = opts => {
-  const options = { ...defaults,
-    ...opts
-  };
-
-  const httpContentEncodingMiddlewareAfter = async request => {
-    normalizeHttpResponse(request);
-    const {
-      event: {
-        preferredEncoding,
-        preferredEncodings
-      },
-      response
-    } = request;
-
-    if (!preferredEncoding || response.isBase64Encoded) {
-      return;
-    }
+}
+
+const httpContentEncodingMiddleware = (opts) => {
+  const options = { ...defaults, ...opts }
 
-    const bodyIsString = typeof response.body === 'string';
-    let contentEncodingStream = contentEncodingStreams[preferredEncoding](options[preferredEncoding]);
-    let contentEncoding = preferredEncoding;
+  const supportedContentEncodings = Object.keys(contentEncodingStreams)
 
+  const httpContentEncodingMiddlewareAfter = async (request) => {
+    normalizeHttpResponse(request)
+    const { event: { preferredEncoding, preferredEncodings }, response } = request
+
+    // Encoding not supported OR already encoded
+    if (response.isBase64Encoded || !preferredEncoding || !supportedContentEncodings.includes(preferredEncoding)) { return }
+
+    const bodyIsString = typeof response.body === 'string'
+
+    let contentEncodingStream = contentEncodingStreams[preferredEncoding](options[preferredEncoding])
+    let contentEncoding = preferredEncoding
     for (const encoding of options.overridePreferredEncoding) {
-      if (!preferredEncodings.includes(encoding)) continue;
-      contentEncodingStream = contentEncodingStreams[encoding](options[encoding]);
-      contentEncoding = encoding;
-      break;
+      if (!preferredEncodings.includes(encoding)) continue
+      contentEncodingStream = contentEncodingStreams[encoding](options[encoding])
+      contentEncoding = encoding
+      break
     }
 
     if (bodyIsString) {
-      const readStream = Readable.from(response.body, {
-        objectMode: false
-      });
-      const chunks = [];
+      const readStream = Readable.from(response.body, { objectMode: false })
+
+      const chunks = []
       const writeStream = new Writable({
-        write(chunk, encoding, callback) {
-          chunks.push(chunk);
-          callback();
+        write (chunk, encoding, callback) {
+          chunks.push(chunk)
+          callback()
         }
+      })
 
-      });
-      await pipeline(readStream, contentEncodingStream, writeStream);
-      const body = Buffer.concat(chunks).toString('base64');
+      await pipeline(
+        readStream,
+        contentEncodingStream,
+        writeStream
+      )
 
+      const body = Buffer.concat(chunks).toString('base64')
+
+      // Only apply encoding if it's smaller
       if (body.length < response.body.length) {
-        response.headers['Content-Encoding'] = contentEncoding;
-        response.body = body;
-        response.isBase64Encoded = true;
+        response.headers['Content-Encoding'] = contentEncoding
+        response.body = body
+        response.isBase64Encoded = true
       }
     } else if (isReadableStream(response.body)) {
-      response.headers['Content-Encoding'] = contentEncoding;
-      response.body = response.body.pipe(contentEncodingStream);
-      response.isBase64Encoded = true;
+      // Note: body to not cast to string to allow stream chaining
+      response.headers['Content-Encoding'] = contentEncoding
+      response.body = response.body.pipe(contentEncodingStream)
+      response.isBase64Encoded = true
     }
+    request.response = response
+  }
 
-    request.response = response;
-  };
-
-  const httpContentEncodingMiddlewareOnError = async request => {
-    if (request.response === undefined) return;
-    return httpContentEncodingMiddlewareAfter(request);
-  };
+  const httpContentEncodingMiddlewareOnError = async (request) => {
+    if (request.response === undefined) return
+    return httpContentEncodingMiddlewareAfter(request)
+  }
 
   return {
     after: httpContentEncodingMiddlewareAfter,
     onError: httpContentEncodingMiddlewareOnError
-  };
-};
+  }
+}
+
+const isReadableStream = (stream) =>
+  typeof stream?.pipe === 'function' &&
+  stream?.readable !== false &&
+  typeof stream?._read === 'function' &&
+  typeof stream?._readableState === 'object'
 
-const isReadableStream = stream => typeof stream.pipe === 'function' && stream.readable !== false && typeof stream._read === 'function' && typeof stream._readableState === 'object';
+const polyfillPipelinePromise = async () => {
+  if (process.version < 'v15.0.0') {
+    const stream = await import('stream');
+    const util = await import('util');
+    return util.promisify(stream.pipeline);
+  } else {
+    const stream = await import('stream/promises')
+    return stream.pipeline
+  }
+}
+global.pipeline = await polyfillPipelinePromise()
+// import {pipeline} from 'stream/promises'
 
-export default httpContentEncodingMiddleware;
+export default httpContentEncodingMiddleware

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/http-content-encoding",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.3",
   "description": "Http content encoding middleware for the middy framework",
   "type": "module",
   "engines": {
@@ -18,7 +18,8 @@
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
   },
   "license": "MIT",
   "keywords": [
@@ -50,10 +51,10 @@
   },
   "homepage": "https://github.com/middyjs/middy#readme",
   "dependencies": {
-    "@middy/util": "^3.0.0-alpha.2"
+    "@middy/util": "^3.0.0-alpha.3"
   },
   "devDependencies": {
-    "@middy/core": "^3.0.0-alpha.2"
+    "@middy/core": "^3.0.0-alpha.3"
   },
-  "gitHead": "de30419273ecbff08f367f47c7e320ec981cf145"
+  "gitHead": "1441158711580313765e6d156046ef0fade0d156"
 }