feat: add onError event handler

src/createRPCMiddleware.ts

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { IncomingMessage, ServerResponse } from "node:http";
 
-import { Procedures } from "./types";
+import { OnErrorEventHandler, Procedures } from "./types";
 import { handleRPCRequest } from "./handleRPCRequest";
 
 export type RPCMiddleware<TProcedures extends Procedures> = {
@@ -12,6 +12,7 @@ export type RPCMiddleware<TProcedures extends Procedures> = {
 
 export type CreateRPCMiddlewareArgs<TProcedures extends Procedures> = {
 	procedures: TProcedures;
+	onError?: OnErrorEventHandler;
 };
 
 export const createRPCMiddleware = <TProcedures extends Procedures>(
@@ -36,6 +37,7 @@ export const createRPCMiddleware = <TProcedures extends Procedures>(
 			const { body, headers, statusCode } = await handleRPCRequest({
 				procedures: args.procedures,
 				body: Buffer.concat(requestBodyChunks),
+				onError: args.onError,
 			});
 
 			if (statusCode) {

src/handleRPCRequest.ts

@@ -4,7 +4,12 @@ import { decode, encode } from "@msgpack/msgpack";
 import { isErrorLike } from "./lib/isErrorLike";
 import { replaceLeaves } from "./lib/replaceLeaves";
 
-import { Procedure, Procedures, ProcedureCallServerArgs } from "./types";
+import {
+	Procedure,
+	Procedures,
+	ProcedureCallServerArgs,
+	OnErrorEventHandler,
+} from "./types";
 
 const findProcedure = (
 	procedures: Procedures,
@@ -35,6 +40,7 @@ const findProcedure = (
 type HandleRPCRequestArgs<TProcedures extends Procedures> = {
 	procedures: TProcedures;
 	body: ArrayBuffer | Buffer | undefined;
+	onError?: OnErrorEventHandler;
 };
 
 type HandleRPCRequestReturnType = {
@@ -60,13 +66,15 @@ export const handleRPCRequest = async <TProcedures extends Procedures>(
 	};
 
 	if (!procedure) {
-		const body = encode({
-			error: {
-				name: "RPCError",
-				message: `Invalid procedure name: ${clientArgs.procedurePath.join(
-					".",
-				)}`,
-			},
+		const rawBody = {
+			name: "RPCError",
+			message: `Invalid procedure name: ${clientArgs.procedurePath.join(".")}`,
+		};
+		const body = encode(rawBody);
+
+		args.onError?.({
+			error: new Error(`${rawBody.name}: ${rawBody.message}`),
+			...clientArgs,
 		});
 
 		return {
@@ -94,6 +102,8 @@ export const handleRPCRequest = async <TProcedures extends Procedures>(
 
 		res = await replaceLeaves(res, async (value) => {
 			if (isErrorLike(value)) {
+				args.onError?.({ error: value, ...clientArgs });
+
 				return {
 					name: value.name,
 					message: value.message,
@@ -122,6 +132,8 @@ export const handleRPCRequest = async <TProcedures extends Procedures>(
 				{ ignoreUndefined: true },
 			);
 
+			args.onError?.({ error, ...clientArgs });
+
 			return {
 				body,
 				headers,
@@ -156,6 +168,8 @@ export const handleRPCRequest = async <TProcedures extends Procedures>(
 				},
 			});
 
+			args.onError?.({ error, ...clientArgs });
+
 			return {
 				body,
 				headers,

src/index.ts

@@ -12,4 +12,9 @@ export {
 
 export { handleRPCRequest } from "./handleRPCRequest";
 
-export { Procedure, Procedures, ExtractProcedures } from "./types";
+export {
+	Procedure,
+	Procedures,
+	ExtractProcedures,
+	OnErrorEventHandler,
+} from "./types";

src/types.ts

@@ -1,4 +1,5 @@
 import { RPCMiddleware } from "./createRPCMiddleware";
+import { ErrorLike } from "./lib/isErrorLike";
 
 export type Procedures = Record<
 	string,
@@ -45,3 +46,9 @@ export type ExtractProcedures<
 > = TRPCMiddleware extends RPCMiddleware<infer TProcedures>
 	? TProcedures
 	: never;
+
+export type OnErrorEventHandler = (
+	args: {
+		error: ErrorLike;
+	} & ProcedureCallServerArgs,
+) => Promise<void> | void;

test/index.test.ts

@@ -4,17 +4,24 @@ import { AddressInfo } from "node:net";
 import express from "express";
 import fetch from "node-fetch";
 
-import { createRPCMiddleware, proceduresFromInstance } from "../src";
+import {
+	createRPCMiddleware,
+	proceduresFromInstance,
+	OnErrorEventHandler,
+} from "../src";
 import { createRPCClient } from "../src/client";
 
 type StartRPCTestServerArgs = {
 	procedures: Parameters<typeof createRPCMiddleware>[0]["procedures"];
+	onError?: OnErrorEventHandler;
 };
 
 const startRPCTestServer = (args: StartRPCTestServerArgs) => {
 	const app = express();
 
-	app.use(createRPCMiddleware({ procedures: args.procedures }));
+	app.use(
+		createRPCMiddleware({ procedures: args.procedures, onError: args.onError }),
+	);
 
 	const server = app.listen();
 
@@ -263,6 +270,35 @@ it("does not support class return values with methods", async () => {
 	expect(res).toStrictEqual({});
 });
 
+it("supports `onError` event handler", async () => {
+	const procedures = {
+		throw: (args: { input: string }) => {
+			throw new Error(args.input);
+		},
+	};
+	const onError = vi.fn();
+	const server = startRPCTestServer({ procedures, onError });
+
+	const client = createRPCClient<typeof procedures>({
+		serverURL: server.url,
+		fetch,
+	});
+
+	await expect(client.throw({ input: "foo" })).rejects.toMatchInlineSnapshot(
+		"[Error: foo]",
+	);
+
+	server.close();
+
+	expect(onError).toHaveBeenLastCalledWith({
+		error: expect.any(Error),
+		procedureArgs: {
+			input: "foo",
+		},
+		procedurePath: ["throw"],
+	});
+});
+
 it("returns 405 if POST method is not used", async () => {
 	const procedures = {
 		ping: (args: { input: string }) => ({ pong: args.input }),