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

package/index.js

@@ -0,0 +1,168 @@
+import { AbortController } from 'node-abort-controller';
+
+const defaultBaseHandler = () => {};
+
+const defaultPlugin = {
+  timeoutEarlyInMillis: 5,
+  timeoutEarlyResponse: () => {
+    throw new Error('Timeout');
+  }
+};
+
+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 = [];
+
+  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], baseHandler, [...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 = replaceBaseHandler => {
+    baseHandler = replaceBaseHandler;
+  };
+
+  return middy;
+};
+
+const runRequest = async (request, beforeMiddlewares, baseHandler, afterMiddlewares, onErrorMiddlewares, 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();
+      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);
+    }
+  } 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 setTimeoutPromise = (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);
+  });
+};
+
+export default middy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@middy/core",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.1",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
@@ -13,6 +13,7 @@
   "exports": "./index.js",
   "types": "index.d.ts",
   "files": [
+    "index.js",
     "index.d.ts"
   ],
   "scripts": {
@@ -45,7 +46,7 @@
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^17.0.0"
   },
-  "gitHead": "c533f62841c8a39d061d7b94f30ba178f002c8db",
+  "gitHead": "a14125c6b2e21b181824f9985a919a47f1e4711f",
   "dependencies": {
     "node-abort-controller": "3.0.1"
   }