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

package/index.js

@@ -1,107 +1,92 @@
-/*
- * `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)
-
+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);
 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 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 httpContentEncodingMiddleware = opts => {
+  const options = { ...defaults,
+    ...opts
+  };
+  const supportedContentEncodings = Object.keys(contentEncodingStreams);
+
+  const httpContentEncodingMiddlewareAfter = async request => {
+    normalizeHttpResponse(request);
+    const {
+      event: {
+        preferredEncoding,
+        preferredEncodings
+      },
+      response
+    } = request;
+
+    if (response.isBase64Encoded || !preferredEncoding || !supportedContentEncodings.includes(preferredEncoding)) {
+      return;
+    }
 
-    const bodyIsString = typeof response.body === 'string'
+    const bodyIsString = typeof response.body === 'string';
+    let contentEncodingStream = contentEncodingStreams[preferredEncoding](options[preferredEncoding]);
+    let contentEncoding = preferredEncoding;
 
-    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)) {
-      // 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
+      response.headers['Content-Encoding'] = contentEncoding;
+      response.body = response.body.pipe(contentEncodingStream);
+      response.isBase64Encoded = true;
     }
-    request.response = response
-  }
 
-  const httpContentEncodingMiddlewareOnError = async (request) => {
-    if (request.response === undefined) return
-    return httpContentEncodingMiddlewareAfter(request)
-  }
+    request.response = response;
+  };
+
+  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 === null || stream === void 0 ? void 0 : stream.pipe) === 'function' && (stream === null || stream === void 0 ? void 0 : stream.readable) !== false && typeof (stream === null || stream === void 0 ? void 0 : stream._read) === 'function' && typeof (stream === null || stream === void 0 ? void 0 : stream._readableState) === 'object';
 
 const polyfillPipelinePromise = async () => {
   if (process.version < 'v15.0.0') {
@@ -109,11 +94,10 @@ const polyfillPipelinePromise = async () => {
     const util = await import('util');
     return util.promisify(stream.pipeline);
   } else {
-    const stream = await import('stream/promises')
-    return stream.pipeline
+    const stream = await import('stream/promises');
+    return stream.pipeline;
   }
-}
-global.pipeline = await polyfillPipelinePromise()
-// import {pipeline} from 'stream/promises'
+};
 
-export default httpContentEncodingMiddleware
+global.pipeline = await polyfillPipelinePromise();
+export default httpContentEncodingMiddleware;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/http-content-encoding",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "description": "Http content encoding middleware for the middy framework",
   "type": "module",
   "engines": {
@@ -51,10 +51,10 @@
   },
   "homepage": "https://github.com/middyjs/middy#readme",
   "dependencies": {
-    "@middy/util": "^3.0.0-alpha.3"
+    "@middy/util": "^3.0.0-alpha.4"
   },
   "devDependencies": {
-    "@middy/core": "^3.0.0-alpha.3"
+    "@middy/core": "^3.0.0-alpha.4"
   },
-  "gitHead": "1441158711580313765e6d156046ef0fade0d156"
+  "gitHead": "d4bea7f4e21f6a9bbb1f6f6908361169598b9e53"
 }