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

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

@@ -0,0 +1,249 @@
+const defaultLambdaHandler = () => {};
+
+const defaultPlugin = {
+  timeoutEarlyInMillis: 5,
+  timeoutEarlyResponse: () => {
+    throw new Error('Timeout');
+  }
+};
+
+const middy = (lambdaHandler = defaultLambdaHandler, plugin = {}) => {
+  var _plugin$beforePrefetc, _plugin;
+
+  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 = [];
+  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);
+    const request = {
+      event,
+      context,
+      response: undefined,
+      error: undefined,
+      internal: plugin.internal ?? {}
+    };
+    return runRequest(request, [...beforeMiddlewares], lambdaHandler, [...afterMiddlewares], [...onErrorMiddlewares], plugin);
+  };
+
+  middy.use = middlewares => {
+    if (!Array.isArray(middlewares)) {
+      middlewares = [middlewares];
+    }
+
+    for (const middleware of middlewares) {
+      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"');
+      }
+
+      if (before) middy.before(before);
+      if (after) middy.after(after);
+      if (onError) middy.onError(onError);
+    }
+
+    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;
+
+  try {
+    await runMiddlewares(request, beforeMiddlewares, plugin);
+
+    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();
+      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) {
+    request.response = undefined;
+    request.error = e;
+
+    try {
+      await runMiddlewares(request, onErrorMiddlewares, plugin);
+    } catch (e) {
+      e.originalError = request.error;
+      request.error = e;
+      throw request.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));
+  }
+
+  return request.response;
+};
+
+const runMiddlewares = async (request, middlewares, plugin) => {
+  for (const nextMiddleware of middlewares) {
+    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;
+    }
+  }
+};
+
+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;
+      }
+
+      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';
+      }
+
+    };
+  } else {
+    return AbortController;
+  }
+};
+
+global.AbortController = await polyfillAbortController();
+
+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'));
+        };
+
+        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();
+export default middy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.4",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
@@ -13,11 +13,13 @@
   "exports": "./index.js",
   "types": "index.d.ts",
   "files": [
+    "index.js",
     "index.d.ts"
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "ava",
+    "test:benchmark": "node __benchmarks__/index.js"
   },
   "license": "MIT",
   "keywords": [
@@ -45,8 +47,5 @@
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^17.0.0"
   },
-  "gitHead": "c533f62841c8a39d061d7b94f30ba178f002c8db",
-  "dependencies": {
-    "node-abort-controller": "3.0.1"
-  }
+  "gitHead": "d4bea7f4e21f6a9bbb1f6f6908361169598b9e53"
 }