@middy/core 7.2.3 → 7.3.1

package/executionModeDurableContext.js

@@ -25,8 +25,11 @@ export const executionModeDurableContext = (
 		);
 		copyKeys(request.context, request.context.lambdaContext, lambdaContextKeys);
 
+		// See executionModeStandard for the .cause-chaining rationale.
+		let handlerError;
+		let response;
 		try {
-			const response = await runRequest(
+			response = await runRequest(
 				request,
 				beforeMiddlewares,
 				lambdaHandler,
@@ -34,10 +37,20 @@ export const executionModeDurableContext = (
 				onErrorMiddlewares,
 				plugin,
 			);
-			return response;
-		} finally {
+		} catch (err) {
+			handlerError = err;
+		}
+		try {
 			await plugin.requestEnd(request);
+		} catch (hookErr) {
+			if (handlerError) {
+				handlerError.cause ??= hookErr;
+			} else {
+				throw hookErr;
+			}
 		}
+		if (handlerError) throw handlerError;
+		return response;
 	});
 	middy.handler = (replaceLambdaHandler) => {
 		lambdaHandler = replaceLambdaHandler;

package/executionModeStandard.js

@@ -11,8 +11,14 @@ export const executionModeStandard = (
 	const middy = async (event, context) => {
 		const request = middyRequest(event, context);
 		plugin.requestStart(request);
+		// Run requestEnd without letting a throw in the hook replace the
+		// handler's original error. If only requestEnd throws, it propagates
+		// (same as a naive finally). If both throw, the hook error is attached
+		// as `.cause` on the handler error (only if no cause is already set).
+		let handlerError;
+		let response;
 		try {
-			const response = await runRequest(
+			response = await runRequest(
 				request,
 				beforeMiddlewares,
 				lambdaHandler,
@@ -20,10 +26,20 @@ export const executionModeStandard = (
 				onErrorMiddlewares,
 				plugin,
 			);
-			return response;
-		} finally {
+		} catch (err) {
+			handlerError = err;
+		}
+		try {
 			await plugin.requestEnd(request);
+		} catch (hookErr) {
+			if (handlerError) {
+				handlerError.cause ??= hookErr;
+			} else {
+				throw hookErr;
+			}
 		}
+		if (handlerError) throw handlerError;
+		return response;
 	};
 	middy.handler = (replaceLambdaHandler) => {
 		lambdaHandler = replaceLambdaHandler;

package/executionModeStreamifyResponse.js

@@ -54,11 +54,23 @@ export const executionModeStreamifyResponse = (
 				});
 			}
 
+			// See executionModeStandard for the .cause-chaining rationale.
+			let handlerError;
 			try {
 				await pipeline(handlerStream, responseStream);
-			} finally {
+			} catch (err) {
+				handlerError = err;
+			}
+			try {
 				await plugin.requestEnd(request);
+			} catch (hookErr) {
+				if (handlerError) {
+					handlerError.cause ??= hookErr;
+				} else {
+					throw hookErr;
+				}
 			}
+			if (handlerError) throw handlerError;
 		},
 	);
 

package/index.d.ts

@@ -8,9 +8,11 @@ import type { DurableContext as LambdaContextDurable } from "@aws/durable-execut
 
 declare type PluginHook = () => void;
 declare type PluginHookWithMiddlewareName = (middlewareName: string) => void;
+declare type PluginHookWithRequest = (request: Request) => void;
 declare type PluginHookPromise = (
 	request: Request,
 ) => Promise<unknown> | unknown;
+declare type PluginTimeoutEarlyResponse = () => unknown;
 export type PluginExecutionMode = () => void;
 export declare const executionModeStandard: PluginExecutionMode;
 export declare const executionModeDurableContext: PluginExecutionMode;
@@ -19,14 +21,14 @@ export declare const executionModeStreamifyResponse: PluginExecutionMode;
 interface PluginObject {
 	internal?: Record<string, unknown>;
 	beforePrefetch?: PluginHook;
-	requestStart?: PluginHook;
+	requestStart?: PluginHookWithRequest;
 	beforeMiddleware?: PluginHookWithMiddlewareName;
 	afterMiddleware?: PluginHookWithMiddlewareName;
 	beforeHandler?: PluginHook;
-	timeoutEarlyInMillis?: number;
-	timeoutEarlyResponse?: PluginHook;
 	afterHandler?: PluginHook;
 	requestEnd?: PluginHookPromise;
+	timeoutEarlyInMillis?: number;
+	timeoutEarlyResponse?: PluginTimeoutEarlyResponse;
 	executionMode?: PluginExecutionMode;
 }
 
@@ -229,4 +231,8 @@ declare namespace middy {
 	};
 }
 
+export declare function middyValidateOptions(
+	options?: Record<string, unknown>,
+): void;
+
 export default middy;

package/index.js

@@ -1,6 +1,7 @@
 // Copyright 2017 - 2026 will Farrell, Luciano Mammino, and Middy contributors.
 // SPDX-License-Identifier: MIT
 import { setTimeout } from "node:timers";
+import { validateOptions } from "@middy/util";
 import { executionModeStandard } from "./executionModeStandard.js";
 
 const defaultLambdaHandler = () => {};
@@ -17,6 +18,37 @@ const defaultPluginConfig = {
 	executionMode: executionModeStandard,
 };
 
+// JSON-Schema for `pluginConfig` passed to `middy(handler, pluginConfig)`.
+// All options are optional; `additionalProperties: false` catches typos
+// (e.g. `timeoutEarlyMillis` instead of `timeoutEarlyInMillis`).
+// Properties listed in hook execution order.
+const optionSchema = {
+	type: "object",
+	properties: {
+		// Pre-computed request state seeded into `request.internal`.
+		internal: { type: "object", additionalProperties: true },
+		// Lifecycle hooks (see docs/intro/hooks).
+		beforePrefetch: { instanceof: "Function" },
+		requestStart: { instanceof: "Function" },
+		beforeMiddleware: { instanceof: "Function" },
+		afterMiddleware: { instanceof: "Function" },
+		beforeHandler: { instanceof: "Function" },
+		afterHandler: { instanceof: "Function" },
+		requestEnd: { instanceof: "Function" },
+		// Early-timeout configuration. `timeoutEarlyInMillis` reserves N ms
+		// before Lambda timeout for `timeoutEarlyResponse` to run.
+		timeoutEarlyInMillis: { type: "integer", minimum: 0 },
+		timeoutEarlyResponse: { instanceof: "Function" },
+		// Execution mode (standard, durable-context, streamify-response, or custom).
+		executionMode: { instanceof: "Function" },
+	},
+	required: [],
+	additionalProperties: false,
+};
+
+export const middyValidateOptions = (options) =>
+	validateOptions("@middy/core", optionSchema, options);
+
 export const middy = (setupLambdaHandler, pluginConfig) => {
 	let lambdaHandler;
 	let plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@middy/core",
-	"version": "7.2.3",
+	"version": "7.3.1",
 	"description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
 	"type": "module",
 	"engines": {
@@ -17,36 +17,24 @@
 			"import": {
 				"types": "./index.d.ts",
 				"default": "./index.js"
-			},
-			"require": {
-				"default": "./index.js"
 			}
 		},
 		"./Standard": {
 			"import": {
 				"types": "./executionModeStandard.d.ts",
 				"default": "./executionModeStandard.js"
-			},
-			"require": {
-				"default": "./executionModeStandard.js"
 			}
 		},
 		"./DurableContext": {
 			"import": {
 				"types": "./executionModeDurableContext.d.ts",
 				"default": "./executionModeDurableContext.js"
-			},
-			"require": {
-				"default": "./executionModeDurableContext.js"
 			}
 		},
 		"./StreamifyResponse": {
 			"import": {
 				"types": "./executionModeStreamifyResponse.d.ts",
 				"default": "./executionModeStreamifyResponse.js"
-			},
-			"require": {
-				"default": "./executionModeStreamifyResponse.js"
 			}
 		}
 	},
@@ -97,7 +85,7 @@
 		"url": "https://github.com/sponsors/willfarrell"
 	},
 	"dependencies": {
-		"@middy/util": "7.2.3"
+		"@middy/util": "7.3.1"
 	},
 	"peerDependencies": {
 		"@aws/durable-execution-sdk-js": "^1.0.0"
@@ -110,7 +98,7 @@
 	"devDependencies": {
 		"@aws/durable-execution-sdk-js": "^1.0.0",
 		"@aws/durable-execution-sdk-js-testing": "^1.0.0",
-		"@datastream/core": "0.1.6",
+		"@datastream/core": "0.4.0",
 		"@types/aws-lambda": "^8.0.0",
 		"@types/node": "^22.0.0"
 	}