@middy/core 2.5.6 → 2.5.7

package/index.js

@@ -1,128 +1,130 @@
+"use strict";
+
 const middy = (baseHandler = () => {}, plugin) => {
-  plugin?.beforePrefetch?.()
-  const beforeMiddlewares = []
-  const afterMiddlewares = []
-  const onErrorMiddlewares = []
+  var _plugin$beforePrefetc;
+
+  plugin === null || plugin === void 0 ? void 0 : (_plugin$beforePrefetc = plugin.beforePrefetch) === null || _plugin$beforePrefetc === void 0 ? void 0 : _plugin$beforePrefetc.call(plugin);
+  const beforeMiddlewares = [];
+  const afterMiddlewares = [];
+  const onErrorMiddlewares = [];
 
   const instance = (event = {}, context = {}) => {
-    plugin?.requestStart?.()
+    var _plugin$requestStart;
+
+    plugin === null || plugin === void 0 ? void 0 : (_plugin$requestStart = plugin.requestStart) === null || _plugin$requestStart === void 0 ? void 0 : _plugin$requestStart.call(plugin);
     const request = {
       event,
       context,
       response: undefined,
       error: undefined,
       internal: {}
-    }
-
-    return runRequest(
-      request,
-      [...beforeMiddlewares],
-      baseHandler,
-      [...afterMiddlewares],
-      [...onErrorMiddlewares],
-      plugin
-    )
-  }
+    };
+    return runRequest(request, [...beforeMiddlewares], baseHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
+  };
 
-  instance.use = (middlewares) => {
+  instance.use = middlewares => {
     if (Array.isArray(middlewares)) {
       for (const middleware of middlewares) {
-        instance.applyMiddleware(middleware)
+        instance.applyMiddleware(middleware);
       }
-      return instance
+
+      return instance;
     }
-    return instance.applyMiddleware(middlewares)
-  }
 
-  instance.applyMiddleware = (middleware) => {
-    const { before, after, onError } = middleware
+    return instance.applyMiddleware(middlewares);
+  };
+
+  instance.applyMiddleware = middleware => {
+    const {
+      before,
+      after,
+      onError
+    } = middleware;
 
     if (!before && !after && !onError) {
-      throw new Error(
-        'Middleware must be an object containing at least one key among "before", "after", "onError"'
-      )
+      throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
     }
 
-    if (before) instance.before(before)
-    if (after) instance.after(after)
-    if (onError) instance.onError(onError)
+    if (before) instance.before(before);
+    if (after) instance.after(after);
+    if (onError) instance.onError(onError);
+    return instance;
+  }; // Inline Middlewares
 
-    return instance
-  }
 
-  // Inline Middlewares
-  instance.before = (beforeMiddleware) => {
-    beforeMiddlewares.push(beforeMiddleware)
-    return instance
-  }
-  instance.after = (afterMiddleware) => {
-    afterMiddlewares.unshift(afterMiddleware)
-    return instance
-  }
-  instance.onError = (onErrorMiddleware) => {
-    onErrorMiddlewares.push(onErrorMiddleware)
-    return instance
-  }
+  instance.before = beforeMiddleware => {
+    beforeMiddlewares.push(beforeMiddleware);
+    return instance;
+  };
+
+  instance.after = afterMiddleware => {
+    afterMiddlewares.unshift(afterMiddleware);
+    return instance;
+  };
+
+  instance.onError = onErrorMiddleware => {
+    onErrorMiddlewares.push(onErrorMiddleware);
+    return instance;
+  };
 
   instance.__middlewares = {
     before: beforeMiddlewares,
     after: afterMiddlewares,
     onError: onErrorMiddlewares
-  }
+  };
+  return instance;
+};
 
-  return instance
-}
-
-const runRequest = async (
-  request,
-  beforeMiddlewares,
-  baseHandler,
-  afterMiddlewares,
-  onErrorMiddlewares,
-  plugin
-) => {
+const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
   try {
-    await runMiddlewares(request, beforeMiddlewares, plugin)
-    // Check if before stack hasn't exit early
+    await runMiddlewares(request, beforeMiddlewares, plugin); // Check if before stack hasn't exit early
+
     if (request.response === undefined) {
-      plugin?.beforeHandler?.()
-      request.response = await baseHandler(request.event, request.context)
-      plugin?.afterHandler?.()
-      await runMiddlewares(request, afterMiddlewares, plugin)
+      var _plugin$beforeHandler, _plugin$afterHandler;
+
+      plugin === null || plugin === void 0 ? void 0 : (_plugin$beforeHandler = plugin.beforeHandler) === null || _plugin$beforeHandler === void 0 ? void 0 : _plugin$beforeHandler.call(plugin);
+      request.response = await baseHandler(request.event, request.context);
+      plugin === null || plugin === void 0 ? void 0 : (_plugin$afterHandler = plugin.afterHandler) === null || _plugin$afterHandler === void 0 ? void 0 : _plugin$afterHandler.call(plugin);
+      await runMiddlewares(request, afterMiddlewares, plugin);
     }
   } catch (e) {
     // Reset response changes made by after stack before error thrown
-    request.response = undefined
-    request.error = e
+    request.response = undefined;
+    request.error = e;
+
     try {
-      await runMiddlewares(request, onErrorMiddlewares, plugin)
+      await runMiddlewares(request, onErrorMiddlewares, plugin);
     } catch (e) {
       // Save error that wasn't handled
-      e.originalError = request.error
-      request.error = e
+      e.originalError = request.error;
+      request.error = e;
+      throw request.error;
+    } // Catch if onError stack hasn't handled the error
 
-      throw request.error
-    }
-    // Catch if onError stack hasn't handled the error
-    if (request.response === undefined) throw request.error
+
+    if (request.response === undefined) throw request.error;
   } finally {
-    await plugin?.requestEnd?.(request)
+    var _plugin$requestEnd;
+
+    await (plugin === null || plugin === void 0 ? void 0 : (_plugin$requestEnd = plugin.requestEnd) === null || _plugin$requestEnd === void 0 ? void 0 : _plugin$requestEnd.call(plugin, request));
   }
 
-  return request.response
-}
+  return request.response;
+};
 
 const runMiddlewares = async (request, middlewares, plugin) => {
   for (const nextMiddleware of middlewares) {
-    plugin?.beforeMiddleware?.(nextMiddleware?.name)
-    const res = await nextMiddleware?.(request)
-    plugin?.afterMiddleware?.(nextMiddleware?.name)
-    // short circuit chaining and respond early
+    var _plugin$beforeMiddlew, _plugin$afterMiddlewa;
+
+    plugin === null || plugin === void 0 ? void 0 : (_plugin$beforeMiddlew = plugin.beforeMiddleware) === null || _plugin$beforeMiddlew === void 0 ? void 0 : _plugin$beforeMiddlew.call(plugin, nextMiddleware === null || nextMiddleware === void 0 ? void 0 : nextMiddleware.name);
+    const res = await (nextMiddleware === null || nextMiddleware === void 0 ? void 0 : nextMiddleware(request));
+    plugin === null || plugin === void 0 ? void 0 : (_plugin$afterMiddlewa = plugin.afterMiddleware) === null || _plugin$afterMiddlewa === void 0 ? void 0 : _plugin$afterMiddlewa.call(plugin, nextMiddleware === null || nextMiddleware === void 0 ? void 0 : nextMiddleware.name); // short circuit chaining and respond early
+
     if (res !== undefined) {
-      request.response = res
-      return
+      request.response = res;
+      return;
     }
   }
-}
+};
 
-module.exports = middy
+module.exports = middy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "2.5.6",
+  "version": "2.5.7",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "commonjs",
   "engines": {
@@ -45,5 +45,5 @@
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^16.0.0"
   },
-  "gitHead": "0c789f55b4adf691f977b0d9904d1a805bb3bb2b"
+  "gitHead": "3983c4b138e1a4d7fcb3ed805d3b8832fff06fc1"
 }