@middy/core 3.0.0-alpha.3 → 3.0.0-alpha.4

package/index.js

@@ -1,250 +1,249 @@
-const defaultLambdaHandler = () => {}
+const defaultLambdaHandler = () => {};
+
 const defaultPlugin = {
   timeoutEarlyInMillis: 5,
-  timeoutEarlyResponse: () => { throw new Error('Timeout') }
-}
+  timeoutEarlyResponse: () => {
+    throw new Error('Timeout');
+  }
+};
 
 const middy = (lambdaHandler = defaultLambdaHandler, plugin = {}) => {
-  // Allow base handler to be set using .handler()
+  var _plugin$beforePrefetc, _plugin;
+
   if (typeof lambdaHandler !== 'function') {
-    plugin = lambdaHandler
-    lambdaHandler = defaultLambdaHandler
+    plugin = lambdaHandler;
+    lambdaHandler = defaultLambdaHandler;
   }
-  plugin = { ...defaultPlugin, ...plugin }
-  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0
 
-  plugin.beforePrefetch?.()
-  const beforeMiddlewares = []
-  const afterMiddlewares = []
-  const onErrorMiddlewares = []
+  plugin = { ...defaultPlugin,
+    ...plugin
+  };
+  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
+  (_plugin$beforePrefetc = (_plugin = plugin).beforePrefetch) === null || _plugin$beforePrefetc === void 0 ? void 0 : _plugin$beforePrefetc.call(_plugin);
+  const beforeMiddlewares = [];
+  const afterMiddlewares = [];
+  const onErrorMiddlewares = [];
 
   const middy = (event = {}, context = {}) => {
-    plugin.requestStart?.()
+    var _plugin$requestStart, _plugin2;
+
+    (_plugin$requestStart = (_plugin2 = plugin).requestStart) === null || _plugin$requestStart === void 0 ? void 0 : _plugin$requestStart.call(_plugin2);
     const request = {
       event,
       context,
       response: undefined,
       error: undefined,
       internal: plugin.internal ?? {}
-    }
+    };
+    return runRequest(request, [...beforeMiddlewares], lambdaHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
+  };
 
-    return runRequest(
-      request,
-      [...beforeMiddlewares],
-      lambdaHandler,
-      [...afterMiddlewares],
-      [...onErrorMiddlewares],
-      plugin
-    )
-  }
-
-  middy.use = (middlewares) => {
+  middy.use = middlewares => {
     if (!Array.isArray(middlewares)) {
-      middlewares = [middlewares]
+      middlewares = [middlewares];
     }
+
     for (const middleware of middlewares) {
-      const { before, after, onError } = 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) middy.before(before)
-      if (after) middy.after(after)
-      if (onError) middy.onError(onError)
+      if (before) middy.before(before);
+      if (after) middy.after(after);
+      if (onError) middy.onError(onError);
     }
-    return middy
-  }
 
-  // Inline Middlewares
-  middy.before = (beforeMiddleware) => {
-    beforeMiddlewares.push(beforeMiddleware)
-    return middy
-  }
-  middy.after = (afterMiddleware) => {
-    afterMiddlewares.unshift(afterMiddleware)
-    return middy
-  }
-  middy.onError = (onErrorMiddleware) => {
-    onErrorMiddlewares.unshift(onErrorMiddleware)
-    return middy
-  }
-  middy.handler = (replaceLambdaHandler) => {
-    lambdaHandler = replaceLambdaHandler
-  }
+    return middy;
+  };
+
+  middy.before = beforeMiddleware => {
+    beforeMiddlewares.push(beforeMiddleware);
+    return middy;
+  };
+
+  middy.after = afterMiddleware => {
+    afterMiddlewares.unshift(afterMiddleware);
+    return middy;
+  };
+
+  middy.onError = onErrorMiddleware => {
+    onErrorMiddlewares.unshift(onErrorMiddleware);
+    return middy;
+  };
+
+  middy.handler = replaceLambdaHandler => {
+    lambdaHandler = replaceLambdaHandler;
+  };
+
+  return middy;
+};
+
+const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
+  const {
+    timeoutEarly
+  } = plugin;
 
-  return middy
-}
-
-const runRequest = async (
-  request,
-  beforeMiddlewares,
-  lambdaHandler,
-  afterMiddlewares,
-  onErrorMiddlewares,
-  plugin
-) => {
-  const { timeoutEarly } = plugin
   try {
-    await runMiddlewares(request, beforeMiddlewares, plugin)
-    // Check if before stack hasn't exit early
+    await runMiddlewares(request, beforeMiddlewares, plugin);
+
     if (request.response === undefined) {
-      plugin.beforeHandler?.()
-
-      const handlerAbort = new AbortController()
-      let timeoutAbort
-      if (timeoutEarly) timeoutAbort = new AbortController()
-      request.response = await Promise.race([
-        lambdaHandler(request.event, request.context, { signal: handlerAbort.signal }),
-        timeoutEarly
-          ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, { signal: timeoutAbort.signal })
-            .then(() => {
-              handlerAbort.abort()
-              return plugin.timeoutEarlyResponse()
-            })
-          : Promise.race([])
-      ])
-      if (timeoutEarly) timeoutAbort.abort() // lambdaHandler may not be a promise
-
-      plugin.afterHandler?.()
-      await runMiddlewares(request, afterMiddlewares, plugin)
+      var _plugin$beforeHandler, _plugin$afterHandler;
+
+      (_plugin$beforeHandler = plugin.beforeHandler) === null || _plugin$beforeHandler === void 0 ? void 0 : _plugin$beforeHandler.call(plugin);
+      const handlerAbort = new AbortController();
+      let timeoutAbort;
+      if (timeoutEarly) timeoutAbort = new AbortController();
+      request.response = await Promise.race([lambdaHandler(request.event, request.context, {
+        signal: handlerAbort.signal
+      }), timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
+        signal: timeoutAbort.signal
+      }).then(() => {
+        handlerAbort.abort();
+        return plugin.timeoutEarlyResponse();
+      }) : Promise.race([])]);
+      if (timeoutEarly) timeoutAbort.abort();
+      (_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
-
-      throw request.error
+      e.originalError = request.error;
+      request.error = e;
+      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$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$beforeMiddlew = plugin.beforeMiddleware) === null || _plugin$beforeMiddlew === void 0 ? void 0 : _plugin$beforeMiddlew.call(plugin, nextMiddleware.name);
+    const res = await nextMiddleware(request);
+    (_plugin$afterMiddlewa = plugin.afterMiddleware) === null || _plugin$afterMiddlewa === void 0 ? void 0 : _plugin$afterMiddlewa.call(plugin, nextMiddleware.name);
+
     if (res !== undefined) {
-      request.response = res
-      return
+      request.response = res;
+      return;
     }
   }
-}
-
-// Start Polyfill (Nodejs v14)
-/*
-MIT License
-
-Copyright (c) 2019 Steve Faulkner
+};
 
-node-abort-controller
- */
 const polyfillAbortController = async () => {
   if (process.version < 'v15.0.0') {
-    const events = await import('events')
-    const { EventEmitter } = events
+    const events = await import('events');
+    const {
+      EventEmitter
+    } = events;
 
     class AbortSignal {
-      constructor () {
-        this.eventEmitter = new EventEmitter()
-        this.onabort = null
-        this.aborted = false
+      constructor() {
+        this.eventEmitter = new EventEmitter();
+        this.onabort = null;
+        this.aborted = false;
       }
 
-      toString () {
-        return '[object AbortSignal]'
+      toString() {
+        return '[object AbortSignal]';
       }
 
-      get [Symbol.toStringTag] () {
-        return 'AbortSignal'
+      get [Symbol.toStringTag]() {
+        return 'AbortSignal';
       }
 
-      removeEventListener (name, handler) {
-        this.eventEmitter.removeListener(name, handler)
+      removeEventListener(name, handler) {
+        this.eventEmitter.removeListener(name, handler);
       }
 
-      addEventListener (name, handler) {
-        this.eventEmitter.on(name, handler)
+      addEventListener(name, handler) {
+        this.eventEmitter.on(name, handler);
       }
 
-      dispatchEvent (type) {
-        const event = { type, target: this }
-        const handlerName = `on${type}`
-
-        if (typeof this[handlerName] === 'function') this[handlerName](event)
-
-        this.eventEmitter.emit(type, event)
+      dispatchEvent(type) {
+        const event = {
+          type,
+          target: this
+        };
+        const handlerName = `on${type}`;
+        if (typeof this[handlerName] === 'function') this[handlerName](event);
+        this.eventEmitter.emit(type, event);
       }
+
     }
 
     return class AbortController {
-      constructor () {
-        this.signal = new AbortSignal()
+      constructor() {
+        this.signal = new AbortSignal();
       }
 
-      abort () {
-        if (this.signal.aborted) return
-
-        this.signal.aborted = true
-        this.signal.dispatchEvent('abort')
+      abort() {
+        if (this.signal.aborted) return;
+        this.signal.aborted = true;
+        this.signal.dispatchEvent('abort');
       }
 
-      toString () {
-        return '[object AbortController]'
+      toString() {
+        return '[object AbortController]';
       }
 
-      get [Symbol.toStringTag] () {
-        return 'AbortController'
+      get [Symbol.toStringTag]() {
+        return 'AbortController';
       }
-    }
+
+    };
   } else {
-    return AbortController
+    return AbortController;
   }
-}
-global.AbortController = await polyfillAbortController()
+};
 
-const polyfillSetTimeoutPromise = async () => {
+global.AbortController = await polyfillAbortController();
 
+const polyfillSetTimeoutPromise = async () => {
   if (process.version < 'v15.0.0') {
-    return (ms, { signal }) => {
+    return (ms, {
+      signal
+    }) => {
       if (signal.aborted) {
-        return Promise.reject(new Error('Aborted', 'AbortError'))
+        return Promise.reject(new Error('Aborted', 'AbortError'));
       }
+
       return new Promise((resolve, reject) => {
         const abortHandler = () => {
-          clearTimeout(timeout)
-          reject(new Error('Aborted', 'AbortError'))
-        }
-        // start async operation
+          clearTimeout(timeout);
+          reject(new Error('Aborted', 'AbortError'));
+        };
+
         const timeout = setTimeout(() => {
-          resolve()
-          signal.removeEventListener('abort', abortHandler)
-        }, ms)
-        signal.addEventListener('abort', abortHandler)
-      })
-    }
+          resolve();
+          signal.removeEventListener('abort', abortHandler);
+        }, ms);
+        signal.addEventListener('abort', abortHandler);
+      });
+    };
   } else {
-    const timers = await import('timers/promises')
-    return timers.setTimeout
+    const timers = await import('timers/promises');
+    return timers.setTimeout;
   }
-}
-global.setTimeoutPromise = await polyfillSetTimeoutPromise()
-// import { setTimeout as setTimeoutPromise } from 'timers/promises'
-// End Polyfill
+};
 
-export default middy
+global.setTimeoutPromise = await polyfillSetTimeoutPromise();
+export default middy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
@@ -47,5 +47,5 @@
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^17.0.0"
   },
-  "gitHead": "1441158711580313765e6d156046ef0fade0d156"
+  "gitHead": "d4bea7f4e21f6a9bbb1f6f6908361169598b9e53"
 }