fix: hide the error stack properly

Author: himself65

src/endpoint.test.ts

@@ -639,7 +639,7 @@ describe("creator", () => {
 
 describe("onAPIError", () => {
 	it("should call onAPIError", async () => {
-		let error: APIError | undefined;
+		let error: InstanceType<typeof APIError> | undefined;
 		const endpoint = createEndpoint(
 			"/path",
 			{

src/endpoint.ts

@@ -14,7 +14,7 @@ import {
 	type Method,
 } from "./context";
 import type { CookieOptions, CookiePrefixOptions } from "./cookies";
-import { APIError, type _statusCode, type Status } from "./error";
+import type { APIError, _statusCode, Status } from "./error";
 import type { OpenAPIParameter, OpenAPISchemaType } from "./openapi";
 import type { StandardSchemaV1 } from "./standard-schema";
 import { isAPIError } from "./utils";
@@ -154,7 +154,7 @@ export interface EndpointOptions {
 	 * @param e - The API error
 	 * @returns - The response to return
 	 */
-	onAPIError?: (e: APIError) => void | Promise<void>;
+	onAPIError?: (e: InstanceType<typeof APIError>) => void | Promise<void>;
 }
 
 export type EndpointContext<Path extends string, Options extends EndpointOptions, Context = {}> = {
@@ -300,7 +300,7 @@ export type EndpointContext<Path extends string, Options extends EndpointOptions
 	/**
 	 * Redirect to a new URL
 	 */
-	redirect: (url: string) => APIError;
+	redirect: (url: string) => InstanceType<typeof APIError>;
 	/**
 	 * Return error
 	 */
@@ -311,7 +311,7 @@ export type EndpointContext<Path extends string, Options extends EndpointOptions
 			code?: string;
 		} & Record<string, any>,
 		headers?: HeadersInit,
-	) => APIError;
+	) => InstanceType<typeof APIError>;
 };
 
 export const createEndpoint = <Path extends string, Options extends EndpointOptions, R>(

src/error.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { APIError } from "./error";
+import { inspect } from "node:util";
+
+describe("APIError", () => {
+	it("should throw correct stack", () => {
+		const error = new APIError("INTERNAL_SERVER_ERROR", {
+			message: "Test error",
+		});
+		expect(error.stack).toMatchInlineSnapshot(`"APIError: Test error"`);
+
+		function testError() {
+			throw new APIError("INTERNAL_SERVER_ERROR", {
+				message: "Test error in function",
+			});
+		}
+
+		function deepTestError() {
+			testError();
+		}
+
+		expect(() => deepTestError()).toThrowErrorMatchingInlineSnapshot(
+			`[APIError: Test error in function]`,
+		);
+
+		try {
+			deepTestError();
+		} catch (e: unknown) {
+			const loggedString = inspect(e, {
+				depth: Number.MAX_SAFE_INTEGER,
+			});
+			expect(loggedString).toMatchInlineSnapshot(`
+				"[InternalAPIError: Test error in function] {
+				  status: 'INTERNAL_SERVER_ERROR',
+				  body: { code: 'TEST_ERROR_IN_FUNCTION', message: 'Test error in function' },
+				  headers: {},
+				  statusCode: 500
+				}"
+			`);
+			const stack = (e as InstanceType<typeof APIError>).errorWithStack.stack;
+			expect(stack).toMatch(
+				new RegExp(
+					"ErrorWithStack:\\s*\\n" +
+						"\\s+at testError \\(.*/error\\.test\\.ts:\\d+:\\d+\\)\\n" +
+						"\\s+at deepTestError \\(.*/error\\.test\\.ts:\\d+:\\d+\\)",
+					"s",
+				),
+			);
+		}
+	});
+});

src/error.ts

@@ -1,3 +1,72 @@
+// https://github.com/nodejs/node/blob/360f7cc7867b43344aac00564286b895e15f21d7/lib/internal/errors.js#L246C1-L261C2
+function isErrorStackTraceLimitWritable() {
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === undefined) {
+		return Object.isExtensible(Error);
+	}
+
+	return Object.prototype.hasOwnProperty.call(desc, "writable")
+		? desc.writable
+		: desc.set !== undefined;
+}
+
+class ErrorWithStack extends Error {
+	constructor() {
+		super();
+		this.name = "ErrorWithStack";
+	}
+}
+
+/**
+ * Hide internal stack frames from the error stack trace.
+ */
+function hideInternalStackFrames(stack: string): string {
+	const lines = stack.split("\n    at ");
+	if (lines.length <= 1) {
+		return stack;
+	}
+	lines.splice(1, 1);
+	return lines.join("\n    at ");
+}
+
+// https://github.com/nodejs/node/blob/360f7cc7867b43344aac00564286b895e15f21d7/lib/internal/errors.js#L411-L432
+function makeErrorForHideStackFrame<B extends new (...args: any[]) => Error>(
+	Base: B,
+	clazz: any,
+): {
+	new (...args: ConstructorParameters<B>): InstanceType<B> & { errorWithStack: ErrorWithStack };
+} {
+	class HideStackFramesError extends Base {
+		#errorWithStack: ErrorWithStack;
+
+		constructor(...args: any[]) {
+			if (isErrorStackTraceLimitWritable()) {
+				const limit = Error.stackTraceLimit;
+				Error.stackTraceLimit = 0;
+				super(...args);
+				Error.stackTraceLimit = limit;
+			} else {
+				super(...args);
+			}
+			this.#errorWithStack = new ErrorWithStack();
+			this.#errorWithStack.stack = hideInternalStackFrames(this.#errorWithStack.stack ?? "");
+		}
+
+		// use `getter` here to avoid the stack trace being captured by loggers
+		get errorWithStack() {
+			return this.#errorWithStack;
+		}
+
+		// This is a workaround for wpt tests that expect that the error
+		// constructor has a `name` property of the base class.
+		get ["constructor"]() {
+			return clazz;
+		}
+	}
+
+	return HideStackFramesError as any;
+}
+
 export const _statusCode = {
 	OK: 200,
 	CREATED: 201,
@@ -116,19 +185,27 @@ export type Status =
 	| 510
 	| 511;
 
-export class APIError extends Error {
+class InternalAPIError extends Error {
 	constructor(
 		public status: keyof typeof _statusCode | Status = "INTERNAL_SERVER_ERROR",
 		public body:
 			| ({
 					message?: string;
 					code?: string;
+					cause?: unknown;
 			  } & Record<string, any>)
 			| undefined = undefined,
 		public headers: HeadersInit = {},
 		public statusCode = typeof status === "number" ? status : _statusCode[status],
 	) {
-		super(body?.message);
+		super(
+			body?.message,
+			body?.cause
+				? {
+						cause: body.cause,
+					}
+				: undefined,
+		);
 		this.name = "APIError";
 		this.status = status;
 		this.headers = headers;
@@ -142,6 +219,7 @@ export class APIError extends Error {
 					...body,
 				}
 			: undefined;
-		this.stack = "";
 	}
 }
+
+export const APIError = makeErrorForHideStackFrame(InternalAPIError, Error);

src/router.ts

@@ -3,7 +3,6 @@ import { createEndpoint, type Endpoint } from "./endpoint";
 import { generator, getHTML } from "./openapi";
 import type { Middleware } from "./middleware";
 import { getBody, isAPIError } from "./utils";
-import { APIError } from "./error";
 import { toResponse } from "./to-response";
 
 export interface RouterConfig {