@middy/core 4.6.5 → 5.0.0-alpha.1

package/index.d.ts

@@ -28,33 +28,34 @@ export interface Request<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > {
   event: TEvent
   context: TContext
   response: TResult | null
   error: TErr | null
-  internal: {
-    [key: string]: any
-  }
+  internal: TInternal
 }
 
 declare type MiddlewareFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
-> = (request: Request<TEvent, TResult, TErr, TContext>) => any
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = (request: Request<TEvent, TResult, TErr, TContext, TInternal>) => any
 
 export interface MiddlewareObj<
   TEvent = unknown,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > {
-  before?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  after?: MiddlewareFn<TEvent, TResult, TErr, TContext>
-  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext>
+  before?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
 }
 
 // The AWS provided Handler type uses void | Promise<TResult> so we have no choice but to follow and suppress the linter warning
@@ -79,57 +80,63 @@ export interface MiddyfiedHandler<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > 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>
-  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext>
+  use: UseFn<TEvent, TResult, TErr, TContext, TInternal>
+  before: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  after: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+  onError: AttachMiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
   handler: <TAdditional>(
     handler: MiddlewareHandler<
     LambdaHandler<TEvent & TAdditional, TResult>,
     TContext
     >
-  ) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  ) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 }
 
 declare type AttachMiddlewareFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > = (
-  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare type AttachMiddlewareObj<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > = (
-  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext, TInternal>
+) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare type UseFn<
   TEvent = any,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
-> = <TMiddleware extends MiddlewareObj<any, any, Error, any>>(
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
+> = <TMiddleware extends MiddlewareObj<any, any, Error, any, any>>(
   middlewares: TMiddleware | TMiddleware[]
 ) => TMiddleware extends MiddlewareObj<
 infer TMiddlewareEvent,
 any,
 Error,
-infer TMiddlewareContext
+infer TMiddlewareContext,
+infer TMiddlewareInternal
 >
   ? MiddyfiedHandler<
   TMiddlewareEvent & TEvent,
   TResult,
   TErr,
-  TMiddlewareContext & TContext
+  TMiddlewareContext & TContext,
+  TMiddlewareInternal & TInternal
   > // always true
   : never
 
@@ -149,11 +156,14 @@ declare function middy<
   TEvent = unknown,
   TResult = any,
   TErr = Error,
-  TContext extends LambdaContext = LambdaContext
+  TContext extends LambdaContext = LambdaContext,
+  TInternal extends Record<string, unknown> = {}
 > (
-  handler?: MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext> | PluginObject,
+  handler?:
+  | MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext>
+  | PluginObject,
   plugin?: PluginObject
-): MiddyfiedHandler<TEvent, TResult, TErr, TContext>
+): MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
 
 declare namespace middy {
   export {

package/index.js

@@ -1,170 +1,209 @@
-/* global awslambda */ import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { setTimeout } from 'node:timers/promises';
-const defaultLambdaHandler = ()=>{};
+/* global awslambda */
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { setTimeout } from 'node:timers/promises'
+
+const defaultLambdaHandler = () => {}
 const defaultPlugin = {
-    timeoutEarlyInMillis: 5,
-    timeoutEarlyResponse: ()=>{
-        throw new Error('Timeout');
-    },
-    streamifyResponse: false // Deprecate need for this when AWS provides a flag for when it's looking for it
-};
-const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
-    // Allow base handler to be set using .handler()
-    if (typeof lambdaHandler !== 'function') {
-        plugin = lambdaHandler;
-        lambdaHandler = defaultLambdaHandler;
+  timeoutEarlyInMillis: 5,
+  timeoutEarlyResponse: () => {
+    const err = new Error('[AbortError]: The operation was aborted.', {
+      cause: { package: '@middy/core' }
+    })
+    err.name = 'TimeoutError'
+    throw err
+  },
+  streamifyResponse: false // Deprecate need for this when AWS provides a flag for when it's looking for it
+}
+
+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
+
+  plugin.beforePrefetch?.()
+  const beforeMiddlewares = []
+  const afterMiddlewares = []
+  const onErrorMiddlewares = []
+
+  const middyHandler = (event = {}, context = {}) => {
+    plugin.requestStart?.()
+    const request = {
+      event,
+      context,
+      response: undefined,
+      error: undefined,
+      internal: plugin.internal ?? {}
     }
-    plugin = {
-        ...defaultPlugin,
-        ...plugin
-    };
-    plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
-    plugin.beforePrefetch?.();
-    const beforeMiddlewares = [];
-    const afterMiddlewares = [];
-    const onErrorMiddlewares = [];
-    const middyHandler = (event = {}, context = {})=>{
-        plugin.requestStart?.();
-        const request = {
-            event,
-            context,
-            response: undefined,
-            error: undefined,
-            internal: plugin.internal ?? {}
-        };
-        return runRequest(request, [
-            ...beforeMiddlewares
-        ], lambdaHandler, [
-            ...afterMiddlewares
-        ], [
-            ...onErrorMiddlewares
-        ], plugin);
-    };
-    const middy = plugin.streamifyResponse ? awslambda.streamifyResponse(async (event, responseStream, context)=>{
-        const handlerResponse = await middyHandler(event, context);
-        let handlerBody = handlerResponse;
-        if (handlerResponse.statusCode) {
-            handlerBody = handlerResponse.body ?? '';
-            responseStream = awslambda.HttpResponseStream.from(responseStream, handlerResponse);
-        }
-        // Source @datastream/core (MIT)
-        let handlerStream;
-        if (handlerBody._readableState) {
-            handlerStream = handlerBody;
-        } else if (typeof handlerBody === 'string') {
-            function* iterator(input) {
-                const size = 16384 // 16 * 1024 // Node.js default
-                ;
-                let position = 0;
-                const length = input.length;
-                while(position < length){
-                    yield input.substring(position, position + size);
-                    position += size;
-                }
-            }
-            handlerStream = Readable.from(iterator(handlerBody));
-        }
-        if (!handlerStream) {
-            throw new Error('handler response not a ReadableStream');
-        }
-        await pipeline(handlerStream, responseStream);
-    }) : middyHandler;
-    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 runRequest(
+      request,
+      [...beforeMiddlewares],
+      lambdaHandler,
+      [...afterMiddlewares],
+      [...onErrorMiddlewares],
+      plugin
+    )
+  }
+  const middy = plugin.streamifyResponse
+    ? awslambda.streamifyResponse(async (event, responseStream, context) => {
+      const handlerResponse = await middyHandler(event, context)
+
+      let handlerBody = handlerResponse
+      if (handlerResponse.statusCode) {
+        handlerBody = handlerResponse.body ?? ''
+        responseStream = awslambda.HttpResponseStream.from(
+          responseStream,
+          handlerResponse
+        )
+      }
+
+      // Source @datastream/core (MIT)
+      let handlerStream
+      if (handlerBody._readableState) {
+        handlerStream = handlerBody
+      } else if (typeof handlerBody === 'string') {
+        function * iterator (input) {
+          const size = 16384 // 16 * 1024 // Node.js default
+          let position = 0
+          const length = input.length
+          while (position < length) {
+            yield input.substring(position, position + size)
+            position += size
+          }
         }
-        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;
-    };
-    return middy;
-};
-const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
-    let timeoutAbort;
-    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis // disable when AWS context missing (tests, containers)
-    ;
+        handlerStream = Readable.from(iterator(handlerBody))
+      }
+
+      if (!handlerStream) {
+        throw new Error('handler response not a ReadableStream')
+      }
+
+      await pipeline(handlerStream, responseStream)
+    })
+    : middyHandler
+
+  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
+  }
+
+  // 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
+  }
+
+  return middy
+}
+
+const runRequest = async (
+  request,
+  beforeMiddlewares,
+  lambdaHandler,
+  afterMiddlewares,
+  onErrorMiddlewares,
+  plugin
+) => {
+  let timeoutAbort
+  const timeoutEarly =
+    plugin.timeoutEarly && request.context.getRemainingTimeInMillis // disable when AWS context missing (tests, containers)
+  try {
+    await runMiddlewares(request, beforeMiddlewares, plugin)
+    // Check if before stack hasn't exit early
+    if (typeof request.response === 'undefined') {
+      plugin.beforeHandler?.()
+
+      const handlerAbort = new AbortController()
+
+      if (timeoutEarly) timeoutAbort = new AbortController()
+      request.response = await Promise.race([
+        lambdaHandler(request.event, request.context, {
+          signal: handlerAbort.signal
+        }),
+        timeoutEarly
+          ? setTimeout(
+            request.context.getRemainingTimeInMillis() -
+                plugin.timeoutEarlyInMillis,
+            undefined,
+            { signal: timeoutAbort.signal }
+          ).then(() => {
+            handlerAbort.abort()
+            return plugin.timeoutEarlyResponse()
+          })
+          : Promise.race([])
+      ])
+      timeoutAbort?.abort() // lambdaHandler may not be a promise
+
+      plugin.afterHandler?.()
+      await runMiddlewares(request, afterMiddlewares, plugin)
+    }
+  } catch (e) {
+    timeoutAbort?.abort() // timeout should be aborted on errors
+
+    // Reset response changes made by after stack before error thrown
+    request.response = undefined
+    request.error = e
     try {
-        await runMiddlewares(request, beforeMiddlewares, plugin);
-        // Check if before stack hasn't exit early
-        if (typeof request.response === 'undefined') {
-            plugin.beforeHandler?.();
-            const handlerAbort = new AbortController();
-            if (timeoutEarly) timeoutAbort = new AbortController();
-            request.response = await Promise.race([
-                lambdaHandler(request.event, request.context, {
-                    signal: handlerAbort.signal
-                }),
-                timeoutEarly ? setTimeout(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, undefined, {
-                    signal: timeoutAbort.signal
-                }).then(()=>{
-                    handlerAbort.abort();
-                    return plugin.timeoutEarlyResponse();
-                }) : Promise.race([])
-            ]);
-            timeoutAbort?.abort() // lambdaHandler may not be a promise
-            ;
-            plugin.afterHandler?.();
-            await runMiddlewares(request, afterMiddlewares, plugin);
-        }
+      await runMiddlewares(request, onErrorMiddlewares, plugin)
     } catch (e) {
-        timeoutAbort?.abort() // timeout should be aborted on errors
-        ;
-        // Reset response changes made by after stack before error thrown
-        request.response = undefined;
-        request.error = e;
-        try {
-            await runMiddlewares(request, onErrorMiddlewares, plugin);
-        } catch (e) {
-            // Save error that wasn't handled
-            e.originalError = request.error;
-            request.error = e;
-            throw request.error;
-        }
-        // Catch if onError stack hasn't handled the error
-        if (typeof request.response === 'undefined') throw request.error;
-    } finally{
-        await plugin.requestEnd?.(request);
+      // Save error that wasn't handled
+      e.originalError = request.error
+      request.error = e
+
+      throw request.error
     }
-    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
-        if (typeof res !== 'undefined') {
-            request.response = res;
-            return;
-        }
+    // Catch if onError stack hasn't handled the error
+    if (typeof request.response === 'undefined') throw request.error
+  } finally {
+    await plugin.requestEnd?.(request)
+  }
+
+  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
+    if (typeof res !== 'undefined') {
+      request.response = res
+      return
     }
-};
-export default middy;
+  }
+}
 
+export default middy

package/package.json

@@ -1,33 +1,27 @@
 {
   "name": "@middy/core",
-  "version": "4.6.5",
+  "version": "5.0.0-alpha.1",
   "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
   "type": "module",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "engineStrict": true,
   "publishConfig": {
     "access": "public"
   },
-  "main": "./index.cjs",
   "module": "./index.js",
   "exports": {
     ".": {
       "import": {
         "types": "./index.d.ts",
         "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.cjs"
       }
     }
   },
   "types": "index.d.ts",
   "files": [
     "index.js",
-    "index.cjs",
     "index.d.ts"
   ],
   "scripts": {
@@ -62,9 +56,11 @@
     "url": "https://github.com/sponsors/willfarrell"
   },
   "devDependencies": {
-    "@datastream/core": "0.0.35",
     "@types/aws-lambda": "^8.10.76",
     "@types/node": "^20.0.0"
   },
-  "gitHead": "573d7b0bb243d8c5a9bcb00cf29d031aa7a0c606"
+  "gitHead": "ebce8d5df8783077fa49ba62ee9be20e8486a7f1",
+  "dependencies": {
+    "@datastream/core": "0.0.35"
+  }
 }

package/index.cjs

@@ -1,180 +0,0 @@
-/* global awslambda */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(module, "exports", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-const _nodestream = require("node:stream");
-const _promises = require("node:stream/promises");
-const _promises1 = require("node:timers/promises");
-const defaultLambdaHandler = ()=>{};
-const defaultPlugin = {
-    timeoutEarlyInMillis: 5,
-    timeoutEarlyResponse: ()=>{
-        throw new Error('Timeout');
-    },
-    streamifyResponse: false // Deprecate need for this when AWS provides a flag for when it's looking for it
-};
-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;
-    plugin.beforePrefetch?.();
-    const beforeMiddlewares = [];
-    const afterMiddlewares = [];
-    const onErrorMiddlewares = [];
-    const middyHandler = (event = {}, context = {})=>{
-        plugin.requestStart?.();
-        const request = {
-            event,
-            context,
-            response: undefined,
-            error: undefined,
-            internal: plugin.internal ?? {}
-        };
-        return runRequest(request, [
-            ...beforeMiddlewares
-        ], lambdaHandler, [
-            ...afterMiddlewares
-        ], [
-            ...onErrorMiddlewares
-        ], plugin);
-    };
-    const middy = plugin.streamifyResponse ? awslambda.streamifyResponse(async (event, responseStream, context)=>{
-        const handlerResponse = await middyHandler(event, context);
-        let handlerBody = handlerResponse;
-        if (handlerResponse.statusCode) {
-            handlerBody = handlerResponse.body ?? '';
-            responseStream = awslambda.HttpResponseStream.from(responseStream, handlerResponse);
-        }
-        // Source @datastream/core (MIT)
-        let handlerStream;
-        if (handlerBody._readableState) {
-            handlerStream = handlerBody;
-        } else if (typeof handlerBody === 'string') {
-            function* iterator(input) {
-                const size = 16384 // 16 * 1024 // Node.js default
-                ;
-                let position = 0;
-                const length = input.length;
-                while(position < length){
-                    yield input.substring(position, position + size);
-                    position += size;
-                }
-            }
-            handlerStream = _nodestream.Readable.from(iterator(handlerBody));
-        }
-        if (!handlerStream) {
-            throw new Error('handler response not a ReadableStream');
-        }
-        await (0, _promises.pipeline)(handlerStream, responseStream);
-    }) : middyHandler;
-    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;
-    };
-    // 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;
-    };
-    return middy;
-};
-const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
-    let timeoutAbort;
-    const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis // disable when AWS context missing (tests, containers)
-    ;
-    try {
-        await runMiddlewares(request, beforeMiddlewares, plugin);
-        // Check if before stack hasn't exit early
-        if (typeof request.response === 'undefined') {
-            plugin.beforeHandler?.();
-            const handlerAbort = new AbortController();
-            if (timeoutEarly) timeoutAbort = new AbortController();
-            request.response = await Promise.race([
-                lambdaHandler(request.event, request.context, {
-                    signal: handlerAbort.signal
-                }),
-                timeoutEarly ? (0, _promises1.setTimeout)(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, undefined, {
-                    signal: timeoutAbort.signal
-                }).then(()=>{
-                    handlerAbort.abort();
-                    return plugin.timeoutEarlyResponse();
-                }) : Promise.race([])
-            ]);
-            timeoutAbort?.abort() // lambdaHandler may not be a promise
-            ;
-            plugin.afterHandler?.();
-            await runMiddlewares(request, afterMiddlewares, plugin);
-        }
-    } catch (e) {
-        timeoutAbort?.abort() // timeout should be aborted on errors
-        ;
-        // Reset response changes made by after stack before error thrown
-        request.response = undefined;
-        request.error = e;
-        try {
-            await runMiddlewares(request, onErrorMiddlewares, plugin);
-        } catch (e) {
-            // Save error that wasn't handled
-            e.originalError = request.error;
-            request.error = e;
-            throw request.error;
-        }
-        // Catch if onError stack hasn't handled the error
-        if (typeof request.response === 'undefined') throw request.error;
-    } finally{
-        await plugin.requestEnd?.(request);
-    }
-    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
-        if (typeof res !== 'undefined') {
-            request.response = res;
-            return;
-        }
-    }
-};
-const _default = middy;
-