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

package/index.d.ts

@@ -42,8 +42,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>
   before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
   after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>

package/index.js

@@ -1,168 +1,250 @@
-import { AbortController } from 'node-abort-controller';
-
-const defaultBaseHandler = () => {};
-
+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()
+  if (typeof lambdaHandler !== 'function') {
+    plugin = lambdaHandler
+    lambdaHandler = defaultLambdaHandler
   }
-};
+  plugin = { ...defaultPlugin, ...plugin }
+  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0
 
-const middy = (baseHandler = defaultBaseHandler, plugin = {}) => {
-  var _plugin$beforePrefetc, _plugin;
-
-  if (typeof baseHandler !== 'function') {
-    plugin = baseHandler;
-    baseHandler = defaultBaseHandler;
-  }
-
-  plugin = { ...defaultPlugin,
-    ...plugin
-  };
-  (_plugin$beforePrefetc = (_plugin = 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 middy = (event = {}, context = {}) => {
-    var _plugin$requestStart, _plugin2;
-
-    (_plugin$requestStart = (_plugin2 = plugin).requestStart) === null || _plugin$requestStart === void 0 ? void 0 : _plugin$requestStart.call(_plugin2);
+    plugin.requestStart?.()
     const request = {
       event,
       context,
       response: undefined,
       error: undefined,
       internal: plugin.internal ?? {}
-    };
-    return runRequest(request, [...beforeMiddlewares], baseHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
-  };
+    }
 
-  middy.use = middlewares => {
+    return runRequest(
+      request,
+      [...beforeMiddlewares],
+      lambdaHandler,
+      [...afterMiddlewares],
+      [...onErrorMiddlewares],
+      plugin
+    )
+  }
+
+  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
+  }
 
-    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 = replaceBaseHandler => {
-    baseHandler = replaceBaseHandler;
-  };
-
-  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
+  }
 
-const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
+  return middy
+}
+
+const runRequest = async (
+  request,
+  beforeMiddlewares,
+  lambdaHandler,
+  afterMiddlewares,
+  onErrorMiddlewares,
+  plugin
+) => {
+  const { timeoutEarly } = plugin
   try {
-    await runMiddlewares(request, beforeMiddlewares, plugin);
-
+    await runMiddlewares(request, beforeMiddlewares, plugin)
+    // Check if before stack hasn't exit early
     if (request.response === undefined) {
-      var _plugin$beforeHandler, _plugin$afterHandler;
-
-      (_plugin$beforeHandler = plugin.beforeHandler) === null || _plugin$beforeHandler === void 0 ? void 0 : _plugin$beforeHandler.call(plugin);
-      const handlerAbort = new AbortController();
-      const timeoutAbort = new AbortController();
-      request.response = await Promise.race([baseHandler(request.event, request.context, {
-        signal: handlerAbort.signal
-      }), plugin.timeoutEarlyInMillis > 0 ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
-        signal: timeoutAbort.signal
-      }).then(() => {
-        handlerAbort.abort();
-        return plugin.timeoutEarlyResponse();
-      }) : Promise.race([])]);
-      timeoutAbort.abort();
-      (_plugin$afterHandler = plugin.afterHandler) === null || _plugin$afterHandler === void 0 ? void 0 : _plugin$afterHandler.call(plugin);
-      await runMiddlewares(request, afterMiddlewares, plugin);
+      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)
     }
   } catch (e) {
-    request.response = undefined;
-    request.error = e;
-
+    // Reset response changes made by after stack before error thrown
+    request.response = undefined
+    request.error = e
     try {
-      await runMiddlewares(request, onErrorMiddlewares, plugin);
+      await runMiddlewares(request, onErrorMiddlewares, plugin)
     } catch (e) {
-      e.originalError = request.error;
-      request.error = e;
-      throw request.error;
-    }
+      // Save error that wasn't handled
+      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$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.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
+    }
+  }
+}
+
+// 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
+
+    class AbortSignal {
+      constructor () {
+        this.eventEmitter = new EventEmitter()
+        this.onabort = null
+        this.aborted = false
+      }
 
-    (_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);
+      toString () {
+        return '[object AbortSignal]'
+      }
 
-    if (res !== undefined) {
-      request.response = res;
-      return;
+      get [Symbol.toStringTag] () {
+        return 'AbortSignal'
+      }
+
+      removeEventListener (name, handler) {
+        this.eventEmitter.removeListener(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)
+      }
     }
+
+    return class AbortController {
+      constructor () {
+        this.signal = new AbortSignal()
+      }
+
+      abort () {
+        if (this.signal.aborted) return
+
+        this.signal.aborted = true
+        this.signal.dispatchEvent('abort')
+      }
+
+      toString () {
+        return '[object AbortController]'
+      }
+
+      get [Symbol.toStringTag] () {
+        return 'AbortController'
+      }
+    }
+  } else {
+    return AbortController
   }
-};
+}
+global.AbortController = await polyfillAbortController()
 
-const setTimeoutPromise = (ms, {
-  signal
-}) => {
-  if (signal.aborted) {
-    return Promise.reject(new Error('Aborted', 'AbortError'));
+const polyfillSetTimeoutPromise = async () => {
+
+  if (process.version < 'v15.0.0') {
+    return (ms, { signal }) => {
+      if (signal.aborted) {
+        return Promise.reject(new Error('Aborted', 'AbortError'))
+      }
+      return new Promise((resolve, reject) => {
+        const abortHandler = () => {
+          clearTimeout(timeout)
+          reject(new Error('Aborted', 'AbortError'))
+        }
+        // start async operation
+        const timeout = setTimeout(() => {
+          resolve()
+          signal.removeEventListener('abort', abortHandler)
+        }, ms)
+        signal.addEventListener('abort', abortHandler)
+      })
+    }
+  } else {
+    const timers = await import('timers/promises')
+    return timers.setTimeout
   }
+}
+global.setTimeoutPromise = await polyfillSetTimeoutPromise()
+// import { setTimeout as setTimeoutPromise } from 'timers/promises'
+// End Polyfill
 
-  return new Promise((resolve, reject) => {
-    const abortHandler = () => {
-      clearTimeout(timeout);
-      reject(new Error('Aborted', 'AbortError'));
-    };
-
-    const timeout = setTimeout(() => {
-      resolve();
-      signal.removeEventListener('abort', abortHandler);
-    }, ms);
-    signal.addEventListener('abort', abortHandler);
-  });
-};
-
-export default middy;
+export default middy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.3",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
@@ -18,7 +18,8 @@
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
   },
   "license": "MIT",
   "keywords": [
@@ -46,8 +47,5 @@
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^17.0.0"
   },
-  "gitHead": "de30419273ecbff08f367f47c7e320ec981cf145",
-  "dependencies": {
-    "node-abort-controller": "3.0.1"
-  }
+  "gitHead": "1441158711580313765e6d156046ef0fade0d156"
 }