@middy/core 3.0.0-alpha.1 → 3.0.0-alpha.5

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,6 +1,6 @@
-import { AbortController } from 'node-abort-controller';
+import { EventEmitter } from 'events';
 
-const defaultBaseHandler = () => {};
+const defaultLambdaHandler = () => {};
 
 const defaultPlugin = {
   timeoutEarlyInMillis: 5,
@@ -9,17 +9,18 @@ const defaultPlugin = {
   }
 };
 
-const middy = (baseHandler = defaultBaseHandler, plugin = {}) => {
+const middy = (lambdaHandler = defaultLambdaHandler, plugin = {}) => {
   var _plugin$beforePrefetc, _plugin;
 
-  if (typeof baseHandler !== 'function') {
-    plugin = baseHandler;
-    baseHandler = defaultBaseHandler;
+  if (typeof lambdaHandler !== 'function') {
+    plugin = lambdaHandler;
+    lambdaHandler = defaultLambdaHandler;
   }
 
   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 = [];
@@ -36,7 +37,7 @@ const middy = (baseHandler = defaultBaseHandler, plugin = {}) => {
       error: undefined,
       internal: plugin.internal ?? {}
     };
-    return runRequest(request, [...beforeMiddlewares], baseHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
+    return runRequest(request, [...beforeMiddlewares], lambdaHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
   };
 
   middy.use = middlewares => {
@@ -78,14 +79,18 @@ const middy = (baseHandler = defaultBaseHandler, plugin = {}) => {
     return middy;
   };
 
-  middy.handler = replaceBaseHandler => {
-    baseHandler = replaceBaseHandler;
+  middy.handler = replaceLambdaHandler => {
+    lambdaHandler = replaceLambdaHandler;
   };
 
   return middy;
 };
 
-const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
+const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
+  const {
+    timeoutEarly
+  } = plugin;
+
   try {
     await runMiddlewares(request, beforeMiddlewares, plugin);
 
@@ -94,16 +99,17 @@ const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewa
 
       (_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, {
+      let timeoutAbort;
+      if (timeoutEarly) timeoutAbort = new AbortController();
+      request.response = await Promise.race([lambdaHandler(request.event, request.context, {
         signal: handlerAbort.signal
-      }), plugin.timeoutEarlyInMillis > 0 ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
+      }), timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
         signal: timeoutAbort.signal
       }).then(() => {
         handlerAbort.abort();
         return plugin.timeoutEarlyResponse();
       }) : Promise.race([])]);
-      timeoutAbort.abort();
+      if (timeoutEarly) timeoutAbort.abort();
       (_plugin$afterHandler = plugin.afterHandler) === null || _plugin$afterHandler === void 0 ? void 0 : _plugin$afterHandler.call(plugin);
       await runMiddlewares(request, afterMiddlewares, plugin);
     }
@@ -144,25 +150,92 @@ const runMiddlewares = async (request, middlewares, plugin) => {
   }
 };
 
-const setTimeoutPromise = (ms, {
-  signal
-}) => {
-  if (signal.aborted) {
-    return Promise.reject(new Error('Aborted', 'AbortError'));
-  }
+const polyfillAbortController = () => {
+  if (process.version < 'v15.0.0') {
+    class AbortSignal {
+      constructor() {
+        this.eventEmitter = new EventEmitter();
+        this.onabort = null;
+        this.aborted = false;
+      }
+
+      toString() {
+        return '[object AbortSignal]';
+      }
+
+      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';
+      }
 
-  return new Promise((resolve, reject) => {
-    const abortHandler = () => {
-      clearTimeout(timeout);
-      reject(new Error('Aborted', 'AbortError'));
     };
+  } else {
+    return AbortController;
+  }
+};
+
+global.AbortController = polyfillAbortController();
 
-    const timeout = setTimeout(() => {
-      resolve();
-      signal.removeEventListener('abort', abortHandler);
-    }, ms);
-    signal.addEventListener('abort', abortHandler);
-  });
+const polyfillSetTimeoutPromise = () => {
+  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'));
+      };
+
+      const timeout = setTimeout(() => {
+        resolve();
+        signal.removeEventListener('abort', abortHandler);
+      }, ms);
+      signal.addEventListener('abort', abortHandler);
+    });
+  };
 };
 
+const setTimeoutPromise = polyfillSetTimeoutPromise();
 export default middy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.5",
   "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": "a14125c6b2e21b181824f9985a919a47f1e4711f",
-  "dependencies": {
-    "node-abort-controller": "3.0.1"
-  }
+  "gitHead": "cf6a1b02a2e163bea353b10146d67e0d95ef8072"
 }