@middy/http-content-encoding 3.0.0-alpha.0 → 3.0.0-alpha.1

package/index.js

@@ -0,0 +1,90 @@
+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),
+  gzip: (opts = {}) => createGzip(opts),
+  deflate: (opts = {}) => createDeflate(opts)
+};
+const defaults = {
+  br: 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 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 (bodyIsString) {
+      const readStream = Readable.from(response.body, {
+        objectMode: false
+      });
+      const chunks = [];
+      const writeStream = new Writable({
+        write(chunk, encoding, callback) {
+          chunks.push(chunk);
+          callback();
+        }
+
+      });
+      await pipeline(readStream, contentEncodingStream, writeStream);
+      const body = Buffer.concat(chunks).toString('base64');
+
+      if (body.length < response.body.length) {
+        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;
+    }
+
+    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';
+
+export default httpContentEncodingMiddleware;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/http-content-encoding",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.1",
   "description": "Http content encoding middleware for the middy framework",
   "type": "module",
   "engines": {
@@ -13,6 +13,7 @@
   "exports": "./index.js",
   "types": "index.d.ts",
   "files": [
+    "index.js",
     "index.d.ts"
   ],
   "scripts": {
@@ -49,10 +50,10 @@
   },
   "homepage": "https://github.com/middyjs/middy#readme",
   "dependencies": {
-    "@middy/util": "^3.0.0-alpha.0"
+    "@middy/util": "^3.0.0-alpha.1"
   },
   "devDependencies": {
-    "@middy/core": "^3.0.0-alpha.0"
+    "@middy/core": "^3.0.0-alpha.1"
   },
-  "gitHead": "c533f62841c8a39d061d7b94f30ba178f002c8db"
+  "gitHead": "a14125c6b2e21b181824f9985a919a47f1e4711f"
 }