@middy/core 2.5.5 → 2.5.6

package/index.d.ts

@@ -39,8 +39,10 @@ export interface MiddlewareObj<TEvent = any, TResult = any, TErr = Error, TConte
 // The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type MiddyInputHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext, callback: LambdaCallback<TResult>) => void | Promise<TResult>
+type MiddyInputPromiseHandler<TEvent, TResult, TContext extends LambdaContext = LambdaContext> = (event: TEvent, context: TContext,) => Promise<TResult>
 
-export interface MiddyfiedHandler<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> extends MiddyInputHandler<TEvent, TResult, TContext> {
+export interface MiddyfiedHandler<TEvent = any, TResult = any, TErr = Error, TContext extends LambdaContext = LambdaContext> extends MiddyInputHandler<TEvent, TResult, TContext>,
+  MiddyInputPromiseHandler<TEvent, TResult, TContext> {
   use: UseFn<TEvent, TResult, TErr, TContext>
   applyMiddleware: AttachMiddlewareObj<TEvent, TResult, TErr, TContext>
   before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>

package/index.js

@@ -1,130 +1,128 @@
-"use strict";
-
 const middy = (baseHandler = () => {}, plugin) => {
-  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 = [];
+  plugin?.beforePrefetch?.()
+  const beforeMiddlewares = []
+  const afterMiddlewares = []
+  const onErrorMiddlewares = []
 
   const instance = (event = {}, context = {}) => {
-    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);
+    plugin?.requestStart?.()
     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)
+  }
 
-    return instance.applyMiddleware(middlewares);
-  };
-
-  instance.applyMiddleware = middleware => {
-    const {
-      before,
-      after,
-      onError
-    } = middleware;
+  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);
-    return instance;
-  }; // Inline Middlewares
+    if (before) instance.before(before)
+    if (after) instance.after(after)
+    if (onError) instance.onError(onError)
 
+    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;
-  };
+  // 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.__middlewares = {
     before: beforeMiddlewares,
     after: afterMiddlewares,
     onError: onErrorMiddlewares
-  };
-  return instance;
-};
+  }
 
-const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
+  return instance
+}
+
+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) {
-      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);
+      plugin?.beforeHandler?.()
+      request.response = await baseHandler(request.event, request.context)
+      plugin?.afterHandler?.()
+      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;
-      throw request.error;
-    } // Catch if onError stack hasn't handled the error
-
+      e.originalError = request.error
+      request.error = e
 
-    if (request.response === undefined) throw request.error;
+      throw request.error
+    }
+    // Catch if onError stack hasn't handled the error
+    if (request.response === undefined) throw request.error
   } finally {
-    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));
+    await plugin?.requestEnd?.(request)
   }
 
-  return request.response;
-};
+  return request.response
+}
 
 const runMiddlewares = async (request, middlewares, plugin) => {
   for (const nextMiddleware of middlewares) {
-    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
-
+    plugin?.beforeMiddleware?.(nextMiddleware?.name)
+    const res = await nextMiddleware?.(request)
+    plugin?.afterMiddleware?.(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.5",
+  "version": "2.5.6",
   "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": "b84840ec8afd289f6decfd0d645be4899051792d"
+  "gitHead": "0c789f55b4adf691f977b0d9904d1a805bb3bb2b"
 }