@middy/core 6.1.6 → 6.2.0

package/index.d.ts

@@ -1,169 +1,174 @@
-import { Context as LambdaContext, Handler as LambdaHandler } from 'aws-lambda'
+import type {
+	Context as LambdaContext,
+	Handler as LambdaHandler,
+} from "aws-lambda";
 
-declare type PluginHook = () => void
-declare type PluginHookWithMiddlewareName = (middlewareName: string) => void
+declare type PluginHook = () => undefined;
+declare type PluginHookWithMiddlewareName = (
+	middlewareName: string,
+) => undefined;
 declare type PluginHookPromise = (
-  request: Request
-) => Promise<unknown> | unknown
+	request: Request,
+) => Promise<unknown> | unknown;
 
 interface PluginObject {
-  internal?: any
-  beforePrefetch?: PluginHook
-  requestStart?: PluginHook
-  beforeMiddleware?: PluginHookWithMiddlewareName
-  afterMiddleware?: PluginHookWithMiddlewareName
-  beforeHandler?: PluginHook
-  timeoutEarlyInMillis?: number
-  timeoutEarlyResponse?: PluginHook
-  afterHandler?: PluginHook
-  requestEnd?: PluginHookPromise
-  streamifyResponse?: Boolean
+	internal?: any;
+	beforePrefetch?: PluginHook;
+	requestStart?: PluginHook;
+	beforeMiddleware?: PluginHookWithMiddlewareName;
+	afterMiddleware?: PluginHookWithMiddlewareName;
+	beforeHandler?: PluginHook;
+	timeoutEarlyInMillis?: number;
+	timeoutEarlyResponse?: PluginHook;
+	afterHandler?: PluginHook;
+	requestEnd?: PluginHookPromise;
+	streamifyResponse?: boolean;
 }
 
 export interface Request<
-  TEvent = any,
-  TResult = any,
-  TErr = Error,
-  TContext extends LambdaContext = LambdaContext,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > {
-  event: TEvent
-  context: TContext
-  response: TResult | null
-  earlyResponse?: TResult | null | undefined
-  error: TErr | null
-  internal: TInternal
+	event: TEvent;
+	context: TContext;
+	response: TResult | null;
+	earlyResponse?: TResult | null | undefined;
+	error: TErr | null;
+	internal: TInternal;
 }
 
 declare type MiddlewareFn<
-  TEvent = any,
-  TResult = any,
-  TErr = Error,
-  TContext extends LambdaContext = LambdaContext,
-  TInternal extends Record<string, unknown> = {}
-> = (request: Request<TEvent, TResult, TErr, TContext, TInternal>) => any
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	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,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = unknown,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > {
-  before?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
-  after?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
-  onError?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
-  name?: string
+	before?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>;
+	after?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>;
+	onError?: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>;
+	name?: string;
 }
 
 export interface MiddyHandlerObject {
-  /**
-   * An abort signal that will be canceled just before the lambda times out.
-   * @see timeoutEarlyInMillis
-   */
-  signal: AbortSignal
+	/**
+	 * An abort signal that will be canceled just before the lambda times out.
+	 * @see timeoutEarlyInMillis
+	 */
+	signal: AbortSignal;
 }
 
 // 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
+	TEvent,
+	TResult,
+	TContext extends LambdaContext = LambdaContext,
 > = (
-  event: TEvent,
-  context: TContext,
-  opts: MiddyHandlerObject
-) => // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-void | Promise<TResult> | TResult
+	event: TEvent,
+	context: TContext,
+	opts: MiddyHandlerObject,
+) => undefined | Promise<TResult> | TResult; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type MiddyInputPromiseHandler<
-  TEvent,
-  TResult,
-  TContext extends LambdaContext = LambdaContext
-> = (event: TEvent, context: TContext) => Promise<TResult>
+	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,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > extends MiddyInputHandler<TEvent, TResult, TContext>,
-  MiddyInputPromiseHandler<TEvent, TResult, 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: <
-    TInputHandlerEventProps = TEvent,
-    TInputHandlerResultProps = TResult
-  >(
-    handler: MiddlewareHandler<
-    LambdaHandler<TInputHandlerEventProps, TInputHandlerResultProps>,
-    TContext,
-    TResult
-    >
-  ) => MiddyfiedHandler<
-  TInputHandlerEventProps,
-  TInputHandlerResultProps,
-  TErr,
-  TContext,
-  TInternal
-  >
+		MiddyInputPromiseHandler<TEvent, TResult, 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: <
+		TInputHandlerEventProps = TEvent,
+		TInputHandlerResultProps = TResult,
+	>(
+		handler: MiddlewareHandler<
+			LambdaHandler<TInputHandlerEventProps, TInputHandlerResultProps>,
+			TContext,
+			TResult,
+			TEvent
+		>,
+	) => MiddyfiedHandler<
+		TInputHandlerEventProps,
+		TInputHandlerResultProps,
+		TErr,
+		TContext,
+		TInternal
+	>;
 }
 
 declare type AttachMiddlewareFn<
-  TEvent = any,
-  TResult = any,
-  TErr = Error,
-  TContext extends LambdaContext = LambdaContext,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > = (
-  middleware: MiddlewareFn<TEvent, TResult, TErr, TContext, TInternal>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
+	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,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > = (
-  middleware: MiddlewareObj<TEvent, TResult, TErr, TContext, TInternal>
-) => MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
+	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,
-  TInternal extends Record<string, unknown> = {}
+	TEvent = any,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
 > = <TMiddleware extends MiddlewareObj<any, any, Error, any, any>>(
-  middlewares: TMiddleware | TMiddleware[]
+	middlewares: TMiddleware | TMiddleware[],
 ) => TMiddleware extends MiddlewareObj<
-infer TMiddlewareEvent,
-any,
-Error,
-infer TMiddlewareContext,
-infer TMiddlewareInternal
+	infer TMiddlewareEvent,
+	any,
+	Error,
+	infer TMiddlewareContext,
+	infer TMiddlewareInternal
 >
-  ? MiddyfiedHandler<
-  TMiddlewareEvent & TEvent,
-  TResult,
-  TErr,
-  TMiddlewareContext & TContext,
-  TMiddlewareInternal & TInternal
-  > // always true
-  : never
+	? MiddyfiedHandler<
+			TMiddlewareEvent & TEvent,
+			TResult,
+			TErr,
+			TMiddlewareContext & TContext,
+			TMiddlewareInternal & TInternal
+		> // always true
+	: never;
 
 declare type MiddlewareHandler<
-  THandler extends LambdaHandler<any, any>,
-  TContext extends LambdaContext = LambdaContext,
-  TResult = any
-> =
-  THandler extends LambdaHandler<infer TEvent, TResult> // always true
-    ? MiddyInputHandler<TEvent, TResult, TContext>
-    : never
+	THandler extends LambdaHandler<any, any>,
+	TContext extends LambdaContext = LambdaContext,
+	TResult = any,
+	TEvent = any,
+> = THandler extends LambdaHandler<TEvent, TResult> // always true
+	? MiddyInputHandler<TEvent, TResult, TContext>
+	: never;
 
 /**
  * Middy factory function. Use it to wrap your existing handler to enable middlewares on it.
@@ -171,29 +176,34 @@ declare type MiddlewareHandler<
  * @param plugin wraps around each middleware and handler to add custom lifecycle behaviours (e.g. to profile performance)
  */
 declare function middy<
-  TEvent = unknown,
-  TResult = any,
-  TErr = Error,
-  TContext extends LambdaContext = LambdaContext,
-  TInternal extends Record<string, unknown> = {}
-> (
-  handler?:
-  | LambdaHandler<TEvent, TResult>
-  | MiddlewareHandler<LambdaHandler<TEvent, TResult>, TContext, TResult>
-  | PluginObject,
-  plugin?: PluginObject
-): MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>
+	TEvent = unknown,
+	TResult = any,
+	TErr = Error,
+	TContext extends LambdaContext = LambdaContext,
+	TInternal extends Record<string, unknown> = {},
+>(
+	handler?:
+		| LambdaHandler<TEvent, TResult>
+		| MiddlewareHandler<
+				LambdaHandler<TEvent, TResult>,
+				TContext,
+				TResult,
+				TEvent
+		  >
+		| PluginObject,
+	plugin?: PluginObject,
+): MiddyfiedHandler<TEvent, TResult, TErr, TContext, TInternal>;
 
 declare namespace middy {
-  export {
-    Request,
-    PluginHook,
-    PluginHookWithMiddlewareName,
-    PluginObject,
-    MiddlewareFn,
-    MiddlewareObj,
-    MiddyfiedHandler
-  }
+	export type {
+		Request,
+		PluginHook,
+		PluginHookWithMiddlewareName,
+		PluginObject,
+		MiddlewareFn,
+		MiddlewareObj,
+		MiddyfiedHandler,
+	};
 }
 
-export default middy
+export default middy;

package/index.js

@@ -1,244 +1,253 @@
 /* global awslambda */
-import { Readable } from 'node:stream'
-import { ReadableStream } from 'node:stream/web'
-import { pipeline } from 'node:stream/promises'
-import { setTimeout } from 'node:timers'
-
-const defaultLambdaHandler = () => {}
-const defaultPlugin = {
-  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 ?? {}
-    }
-
-    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 ?? ''
-        delete handlerResponse.body // #1137
-        responseStream = awslambda.HttpResponseStream.from(
-          responseStream,
-          handlerResponse
-        )
-      }
-
-      let handlerStream
-      if (handlerBody._readableState || handlerBody instanceof ReadableStream) {
-        handlerStream = handlerBody
-      } else if (typeof handlerBody === 'string') {
-        // #1189
-        handlerStream = Readable.from(
-          handlerBody.length < stringIteratorSize
-            ? handlerBody
-            : stringIterator(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) {
-        if (before) middy.before(before)
-        if (after) middy.after(after)
-        if (onError) middy.onError(onError)
-      } else {
-        throw new Error(
-          'Middleware must be an object containing at least one key among "before", "after", "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 stringIteratorSize = 16384 // 16 * 1024 // Node.js default
-function * stringIterator (input) {
-  let position = 0
-  const length = input.length
-  while (position < length) {
-    yield input.substring(position, position + stringIteratorSize)
-    position += stringIteratorSize
-  }
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { ReadableStream } from "node:stream/web";
+import { setTimeout } from "node:timers";
+
+const defaultLambdaHandler = () => {};
+const defaultPluginConfig = {
+	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 = (setupLambdaHandler, pluginConfig) => {
+	let lambdaHandler;
+	let plugin;
+	// Allow base handler to be set using .handler()
+	if (typeof setupLambdaHandler === "function") {
+		lambdaHandler = setupLambdaHandler;
+		plugin = { ...defaultPluginConfig, ...pluginConfig };
+	} else {
+		lambdaHandler = defaultLambdaHandler;
+		plugin = { ...defaultPluginConfig, ...setupLambdaHandler };
+	}
+	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, lambdaResponseStream, context) => {
+					const handlerResponse = await middyHandler(event, context);
+					let responseStream = lambdaResponseStream;
+					let handlerBody = handlerResponse;
+					if (handlerResponse.statusCode) {
+						const { body, ...restResponse } = handlerResponse;
+						handlerBody = body ?? ""; // #1137
+						responseStream = awslambda.HttpResponseStream.from(
+							responseStream,
+							restResponse,
+						);
+					}
+
+					let handlerStream;
+					if (
+						handlerBody._readableState ||
+						handlerBody instanceof ReadableStream
+					) {
+						handlerStream = handlerBody;
+					} else if (typeof handlerBody === "string") {
+						// #1189
+						handlerStream = Readable.from(
+							handlerBody.length < stringIteratorSize
+								? handlerBody
+								: stringIterator(handlerBody),
+						);
+					}
+
+					if (!handlerStream) {
+						throw new Error("handler response not a ReadableStream");
+					}
+
+					await pipeline(handlerStream, responseStream);
+				},
+			)
+		: middyHandler;
+
+	middy.use = (inputMiddleware) => {
+		const middlewares = Array.isArray(inputMiddleware)
+			? inputMiddleware
+			: [inputMiddleware];
+		for (const middleware of middlewares) {
+			const { before, after, onError } = middleware;
+
+			if (before || after || onError) {
+				if (before) middy.before(before);
+				if (after) middy.after(after);
+				if (onError) middy.onError(onError);
+			} else {
+				throw new Error(
+					'Middleware must be an object containing at least one key among "before", "after", "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 stringIteratorSize = 16384; // 16 * 1024 // Node.js default
+function* stringIterator(input) {
+	let position = 0;
+	const length = input.length;
+	while (position < length) {
+		yield input.substring(position, position + stringIteratorSize);
+		position += stringIteratorSize;
+	}
 }
 
 // shared AbortController, because it's slow
-let handlerAbort = new AbortController()
+let handlerAbort = new AbortController();
 const runRequest = async (
-  request,
-  beforeMiddlewares,
-  lambdaHandler,
-  afterMiddlewares,
-  onErrorMiddlewares,
-  plugin
+	request,
+	beforeMiddlewares,
+	lambdaHandler,
+	afterMiddlewares,
+	onErrorMiddlewares,
+	plugin,
 ) => {
-  let timeoutID
-  // context.getRemainingTimeInMillis checked for when AWS context missing (tests, containers)
-  const timeoutEarly =
-    plugin.timeoutEarly && request.context.getRemainingTimeInMillis
-
-  try {
-    await runMiddlewares(request, beforeMiddlewares, plugin)
-
-    // Check if before stack hasn't exit early
-    if (!Object.prototype.hasOwnProperty.call(request, 'earlyResponse')) {
-      plugin.beforeHandler?.()
-
-      // Can't manually abort and timeout with same AbortSignal
-      // https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
-      if (handlerAbort.signal.aborted) {
-        handlerAbort = new AbortController()
-      }
-      const promises = [
-        lambdaHandler(request.event, request.context, {
-          signal: handlerAbort.signal
-        })
-      ]
-
-      // clearTimeout pattern is 10x faster than using AbortController
-      // Note: signal.abort is slow ~6000ns
-      if (timeoutEarly) {
-        let timeoutResolve
-        const timeoutPromise = new Promise((resolve, reject) => {
-          timeoutResolve = () => {
-            handlerAbort.abort()
-            try {
-              resolve(plugin.timeoutEarlyResponse())
-            } catch (e) {
-              reject(e)
-            }
-          }
-        })
-        timeoutID = setTimeout(
-          timeoutResolve,
-          request.context.getRemainingTimeInMillis() -
-            plugin.timeoutEarlyInMillis
-        )
-        promises.push(timeoutPromise)
-      }
-      request.response = await Promise.race(promises)
-      if (timeoutID) {
-        clearTimeout(timeoutID)
-      }
-
-      plugin.afterHandler?.()
-      await runMiddlewares(request, afterMiddlewares, plugin)
-    }
-  } catch (e) {
-    // timeout should be aborted when errors happen in handler
-    if (timeoutID) {
-      clearTimeout(timeoutID)
-    }
-
-    // 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
-}
+	let timeoutID;
+	// context.getRemainingTimeInMillis checked for when AWS context missing (tests, containers)
+	const timeoutEarly =
+		plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
+
+	try {
+		await runMiddlewares(request, beforeMiddlewares, plugin);
+
+		// Check if before stack hasn't exit early
+		if (!Object.prototype.hasOwnProperty.call(request, "earlyResponse")) {
+			plugin.beforeHandler?.();
+
+			// Can't manually abort and timeout with same AbortSignal
+			// https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
+			if (handlerAbort.signal.aborted) {
+				handlerAbort = new AbortController();
+			}
+			const promises = [
+				lambdaHandler(request.event, request.context, {
+					signal: handlerAbort.signal,
+				}),
+			];
+
+			// clearTimeout pattern is 10x faster than using AbortController
+			// Note: signal.abort is slow ~6000ns
+			if (timeoutEarly) {
+				let timeoutResolve;
+				const timeoutPromise = new Promise((resolve, reject) => {
+					timeoutResolve = () => {
+						handlerAbort.abort();
+						try {
+							resolve(plugin.timeoutEarlyResponse());
+						} catch (e) {
+							reject(e);
+						}
+					};
+				});
+				timeoutID = setTimeout(
+					timeoutResolve,
+					request.context.getRemainingTimeInMillis() -
+						plugin.timeoutEarlyInMillis,
+				);
+				promises.push(timeoutPromise);
+			}
+			request.response = await Promise.race(promises);
+			if (timeoutID) {
+				clearTimeout(timeoutID);
+			}
+
+			plugin.afterHandler?.();
+			await runMiddlewares(request, afterMiddlewares, plugin);
+		}
+	} catch (e) {
+		// timeout should be aborted when errors happen in handler
+		if (timeoutID) {
+			clearTimeout(timeoutID);
+		}
+
+		// 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.earlyResponse = res
-    }
-    // earlyResponse pattern added in 6.0.0 to handle undefined values
-    if (Object.prototype.hasOwnProperty.call(request, 'earlyResponse')) {
-      request.response = request.earlyResponse
-      return
-    }
-  }
-}
-
-export default middy
+	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.earlyResponse = res;
+		}
+		// earlyResponse pattern added in 6.0.0 to handle undefined values
+		if (Object.prototype.hasOwnProperty.call(request, "earlyResponse")) {
+			request.response = request.earlyResponse;
+			return;
+		}
+	}
+};
+
+export default middy;

package/package.json

@@ -1,69 +1,66 @@
 {
-  "name": "@middy/core",
-  "version": "6.1.6",
-  "description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
-  "type": "module",
-  "engines": {
-    "node": ">=20"
-  },
-  "engineStrict": true,
-  "publishConfig": {
-    "access": "public"
-  },
-  "module": "./index.js",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "default": "./index.js"
-      }
-    }
-  },
-  "types": "index.d.ts",
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "scripts": {
-    "test": "npm run test:unit && npm run test:fuzz",
-    "test:unit": "node --test __tests__/index.js",
-    "test:fuzz": "node --test __tests__/fuzz.js",
-    "test:benchmark": "node __benchmarks__/index.js",
-    "test:profile": "node --prof __benchmarks__/index.js && node --prof-process --preprocess -j isolate*.log | speedscope -"
-  },
-  "license": "MIT",
-  "keywords": [
-    "Lambda",
-    "Middleware",
-    "Serverless",
-    "Framework",
-    "AWS",
-    "AWS Lambda"
-  ],
-  "author": {
-    "name": "Middy contributors",
-    "url": "https://github.com/middyjs/middy/graphs/contributors"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/middyjs/middy.git",
-    "directory": "packages/core"
-  },
-  "bugs": {
-    "url": "https://github.com/middyjs/middy/issues"
-  },
-  "homepage": "https://middy.js.org",
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/willfarrell"
-  },
-  "devDependencies": {
-    "@datastream/core": "0.0.40",
-    "@types/aws-lambda": "^8.10.76",
-    "@types/node": "^20.0.0"
-  },
-  "gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
+	"name": "@middy/core",
+	"version": "6.2.0",
+	"description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
+	"type": "module",
+	"engines": {
+		"node": ">=20"
+	},
+	"engineStrict": true,
+	"publishConfig": {
+		"access": "public"
+	},
+	"module": "./index.js",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./index.d.ts",
+				"default": "./index.js"
+			},
+			"require": {
+				"default": "./index.js"
+			}
+		}
+	},
+	"types": "index.d.ts",
+	"files": ["index.js", "index.d.ts"],
+	"scripts": {
+		"test": "npm run test:unit && npm run test:fuzz",
+		"test:unit": "node --test",
+		"test:fuzz": "node --test index.fuzz.js",
+		"test:perf": "node --test index.perf.js",
+		"test:profile": "node --prof __benchmarks__/index.js && node --prof-process --preprocess -j isolate*.log | speedscope -"
+	},
+	"license": "MIT",
+	"keywords": [
+		"Lambda",
+		"Middleware",
+		"Serverless",
+		"Framework",
+		"AWS",
+		"AWS Lambda"
+	],
+	"author": {
+		"name": "Middy contributors",
+		"url": "https://github.com/middyjs/middy/graphs/contributors"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/middyjs/middy.git",
+		"directory": "packages/core"
+	},
+	"bugs": {
+		"url": "https://github.com/middyjs/middy/issues"
+	},
+	"homepage": "https://middy.js.org",
+	"funding": {
+		"type": "github",
+		"url": "https://github.com/sponsors/willfarrell"
+	},
+	"devDependencies": {
+		"@datastream/core": "0.0.40",
+		"@types/aws-lambda": "^8.10.76",
+		"@types/node": "^20.0.0"
+	},
+	"gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431"
 }