@zudojs/rpc 1.0.0 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # @zudojs/rpc
 
-Type-safe RPC — define procedures, apply middleware, dispatch calls, and serve over HTTP or your own transport.
+Type-safe RPC — define procedures, apply middleware, dispatch calls, and serve them over your own transport.
 
 ## When to use
 
@@ -8,9 +8,14 @@ Import this when you need:
 
 - a typed RPC layer between services (gateway ↔ microservice, frontend ↔ backend)
 - procedure-level middleware (auth, tracing, rate limit)
-- a dispatcher that picks the right transport
+- a server that validates frames and maps every failure to a wire code
 - structured RPC errors
 
+The package is transport-agnostic: `RPCServer.handle` takes a request frame
+and returns a response frame, and `RPCClient` sends through any object
+implementing `RPCTransport`. It ships no HTTP or WebSocket transport of its
+own.
+
 For request/response inside one process, prefer `@zudojs/api`.
 
 ## Installation
@@ -24,8 +29,11 @@ npm install @zudojs/rpc
 ```typescript
 import {
   createRPCProcedure,
-  RPCDispatcher,
+  createRPCRequest,
   RPCServer,
+  RPCClient,
+  RPCDispatcher,
+  RPCProcedureRegistry,
   RPCMiddlewareStack,
   createRPCContext,
   type RPCContext,
@@ -33,24 +41,108 @@ import {
   type RPCProcedure,
   type RPCRequest,
   type RPCResponse,
+  type RPCTransport,
   type RPCErrorOptions,
 } from "@zudojs/rpc";
 ```
 
 ## Usage
 
+A procedure is `createRPCProcedure(name, handler, options?)`. Names are
+dot-separated identifiers (`"math.sum"`); the handler is positional,
+`(input, context)`; `options.input` / `options.output` are `@zudojs/schema`
+schemas (anything with `safeParse`) the payload and result are checked
+against.
+
 ```typescript
-import { createRPCProcedure, RPCDispatcher } from "@zudojs/rpc";
+import { createRPCProcedure, createRPCRequest, RPCServer } from "@zudojs/rpc";
+import { schema } from "@zudojs/schema";
 
-const sum = createRPCProcedure({
-  name: "sum",
-  input: { a: "number", b: "number" },
-  handler: ({ input }) => input.a + input.b,
-});
+const sum = createRPCProcedure(
+  "math.sum",
+  async (input: { a: number; b: number }) => input.a + input.b,
+  { input: schema.object({ a: schema.number(), b: schema.number() }) },
+);
+
+const server = new RPCServer();
+server.register(sum);
+
+const response = await server.handle(
+  createRPCRequest({ id: "req-1", procedure: "math.sum", payload: { a: 1, b: 2 } }),
+);
+// { id: "req-1", success: true, result: 3 }
+```
 
-const dispatcher = new RPCDispatcher();
-dispatcher.register(sum);
-const result = await dispatcher.call("sum", { a: 1, b: 2 });
+`handle` never throws for a bad request: a malformed frame, an unknown
+procedure, a payload the input schema rejects, a timeout or a handler error
+each come back as `{ success: false, error: { code, message, details? } }`.
+The frame's `metadata` is optional.
+
+### Calling through a transport
+
+`RPCClient` needs an `RPCTransport` — an object whose `send(request, options)`
+delivers the frame and resolves with the response. `options.signal` aborts the
+call and `options.timeout` is the deadline in milliseconds, so a transport can
+set its own socket timeout. The in-process transport below is the smallest
+possible one:
+
+```typescript
+import { RPCClient, type RPCTransport } from "@zudojs/rpc";
+
+const transport: RPCTransport = { send: (request) => server.handle(request) };
+const client = new RPCClient(transport, { timeout: 5_000 });
+
+const total = await client.call<{ a: number; b: number }, number>("math.sum", { a: 1, b: 2 });
+// 3
+```
+
+A failed call rejects with a typed error rebuilt from the wire code
+(`RPCTimeoutError`, `RPCCancelledError`, `RPCUnavailableError`, or an
+`RPCError` carrying the server's `code` and `details`).
+
+### Middleware
+
+```typescript
+import { RPCMiddlewareStack, RPCAuthenticationError } from "@zudojs/rpc";
+
+const stack = new RPCMiddlewareStack([
+  async (context, next) => {
+    if (context.metadata.userId === undefined) {
+      throw new RPCAuthenticationError("Sign in first.");
+    }
+    return next();
+  },
+]);
+
+const server = new RPCServer(undefined, stack);
+```
+
+Each middleware may call `next()` once. Input validation runs before the
+stack, so middleware sees a payload the procedure's schema has accepted.
+
+## Errors
+
+Every error class from `@zudojs/errors`' RPC family is re-exported. The
+server maps them to wire codes (`RPC_PROCEDURE_NOT_FOUND`,
+`RPC_VALIDATION_ERROR`, `RPC_UNAUTHENTICATED`, `RPC_FORBIDDEN`,
+`RPC_RATE_LIMITED`, `RPC_TIMEOUT`, …). A custom `RPCError` subclass keeps its
+own `code`.
+
+What reaches the caller follows the error's `expose` flag. Anything thrown
+with `expose: false` — an `RPCInternalError`, an `RPCSerializationError`, a
+plain `new RPCError(...)` (whose default is `expose: false`), or any
+non-RPC error — is answered with the fixed `INTERNAL_ERROR_MESSAGE`; the
+original error is handed to `onInternalError(error, requestId)` so it can be
+logged against the request id. A handler result that fails the procedure's
+`output` schema is treated the same way: it is the server's fault, not the
+caller's.
+
+```typescript
+const server = new RPCServer(undefined, undefined, {
+  limits: { maxPayloadBytes: 256 * 1024 },
+  dispatch: { defaultTimeout: 10_000 },
+  onInternalError: (error, requestId) => logger.error({ requestId, error }),
+});
 ```
 
 ## License

package/dist/rpc/client/rpcClient.core.js

@@ -64,8 +64,14 @@ export class RPCClient {
                 payload: input,
                 metadata: options.metadata,
             });
+            // The transport is told the deadline as well as given the signal:
+            // `RPCTransportRequestOptions.timeout` exists so a transport can set
+            // its own socket or request timeout, and it was never populated.
             const races = [
-                this.transport.send(request, { signal: controller.signal }),
+                this.transport.send(request, {
+                    signal: controller.signal,
+                    ...(timeoutMs > 0 ? { timeout: timeoutMs } : {}),
+                }),
                 this.abortPromise(controller.signal, procedure),
             ];
             if (timeout) {
@@ -170,8 +176,19 @@ export class RPCClient {
         const message = response.error?.message ?? "RPC call failed.";
         const code = response.error?.code;
         switch (code) {
-            case "RPC_TIMEOUT":
-                return new RPCTimeoutError(0, procedure);
+            case "RPC_TIMEOUT": {
+                // The constructor derives its message from a duration the wire
+                // does not carry; keep the type and restore the server's message
+                // rather than reporting "timed out after 0ms".
+                const timeout = new RPCTimeoutError(0, procedure);
+                Object.defineProperty(timeout, "message", {
+                    value: message,
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+                return timeout;
+            }
             case "RPC_CANCELLED":
                 return new RPCCancelledError(message, procedure);
             case "RPC_UNAVAILABLE":

package/dist/rpc/context/rpcContext.type.js

@@ -5,7 +5,9 @@ export function createRPCContext(request, signal) {
     const state = new Map();
     const context = {
         request,
-        metadata: request.metadata,
+        // A frame decoded from JSON may omit `metadata`; middleware reads
+        // `context.metadata.userId` and the like without guarding.
+        metadata: request.metadata ?? {},
         signal,
         state,
         get(key) {

package/dist/rpc/dispatcher/rpcDispatcher.core.d.ts

@@ -47,7 +47,7 @@ export declare class RPCDispatcher {
     /**
      * Dispatches an RPC request.
      */
-    dispatch(request: RPCRequest): Promise<RPCResponse>;
+    dispatch(input: RPCRequest): Promise<RPCResponse>;
     /**
      * Runs the interceptor chain around the dispatch.
      *

package/dist/rpc/dispatcher/rpcDispatcher.core.js

@@ -27,7 +27,11 @@ export class RPCDispatcher {
     /**
      * Dispatches an RPC request.
      */
-    async dispatch(request) {
+    async dispatch(input) {
+        // Tolerate a frame without `metadata`: the field is optional when a
+        // request is built by hand or decoded from JSON, and everything below
+        // — deadline reading, the context's `metadata` — reads it as an object.
+        const request = input.metadata === undefined ? { ...input, metadata: {} } : input;
         const procedure = this.registry.require(request.procedure);
         const controller = new AbortController();
         const context = createRPCContext(request, controller.signal);

package/dist/rpc/server/rpcServer.core.js

@@ -2,7 +2,7 @@ import { RPCProcedureRegistry } from "../procedure/rpcProcedureRegistry.core.js"
 import { RPCMiddlewareStack } from "../middleware/rpcMiddleware.core.js";
 import { RPCDispatcher } from "../dispatcher/rpcDispatcher.core.js";
 import { createRPCErrorResponse } from "../types/rpcResponse.type.js";
-import { isRPCError, RPCAuthenticationError, RPCCancelledError, RPCDeadlineExceededError, RPCDeserializationError, RPCForbiddenError, RPCInvalidRequestError, RPCProcedureNotFoundError, RPCRateLimitedError, RPCSerializationError, RPCTimeoutError, RPCUnavailableError, RPCValidationError, } from "../errors/rpc.errors.js";
+import { isRPCError, RPCAuthenticationError, RPCCancelledError, RPCDeadlineExceededError, RPCDeserializationError, RPCForbiddenError, RPCInternalError, RPCInvalidRequestError, RPCProcedureNotFoundError, RPCRateLimitedError, RPCSerializationError, RPCTimeoutError, RPCUnavailableError, RPCValidationError, } from "../errors/rpc.errors.js";
 import { INTERNAL_ERROR_MESSAGE } from "../constants/rpcConstants.core.js";
 import { assertValidRequest } from "../validation/rpcValidation.core.js";
 /**
@@ -23,7 +23,10 @@ const ERROR_CODES = [
     [RPCTimeoutError, "RPC_TIMEOUT"],
     [RPCCancelledError, "RPC_CANCELLED"],
     [RPCUnavailableError, "RPC_UNAVAILABLE"],
-    [RPCSerializationError, "RPC_SERIALIZATION_ERROR"],
+    // A serialization failure is a server fault (500, `expose: false`) whose
+    // message names what could not be encoded; the code travels, the
+    // message goes to `onInternalError`.
+    [RPCSerializationError, "RPC_SERIALIZATION_ERROR", true],
     [RPCDeserializationError, "RPC_DESERIALIZATION_ERROR"],
 ];
 /**
@@ -69,7 +72,12 @@ export class RPCServer {
             : "";
         try {
             assertValidRequest(request, this.options.limits);
-            return await this.dispatcher.dispatch(request);
+            // `metadata` is optional on the wire (`createRPCRequest` fills it in,
+            // a hand-built or JSON-decoded frame need not). Every consumer below
+            // reads it as an object, so a frame without it used to fail with a
+            // TypeError reported as an internal error.
+            const frame = request.metadata === undefined ? { ...request, metadata: {} } : request;
+            return await this.dispatcher.dispatch(frame);
         }
         catch (error) {
             const mapped = this.mapError(error);
@@ -80,7 +88,21 @@ export class RPCServer {
                     message: INTERNAL_ERROR_MESSAGE,
                 });
             }
-            return createRPCErrorResponse(requestId, mapped);
+            if (mapped.internal) {
+                // The error is typed, so the caller keeps its code, but it was
+                // constructed with `expose: false`: its message is server detail
+                // and goes to the log, not the wire.
+                this.options.onInternalError?.(error, requestId);
+                return createRPCErrorResponse(requestId, {
+                    code: mapped.code,
+                    message: INTERNAL_ERROR_MESSAGE,
+                });
+            }
+            return createRPCErrorResponse(requestId, {
+                code: mapped.code,
+                message: mapped.message,
+                ...(mapped.details !== undefined ? { details: mapped.details } : {}),
+            });
         }
     }
     /**
@@ -96,13 +118,22 @@ export class RPCServer {
      * answers with a generic internal error.
      */
     mapError(error) {
-        for (const [type, code] of ERROR_CODES) {
+        // An RPCInternalError *is* the generic internal failure: it carries
+        // `expose: false` and a message written for the log. Mapping it like
+        // any other RPCError put that message on the wire.
+        if (error instanceof RPCInternalError) {
+            return undefined;
+        }
+        for (const [type, code, internal] of ERROR_CODES) {
             if (error instanceof type) {
                 const payload = {
                     code,
                     message: error.message,
+                    ...(internal ? { internal: true } : {}),
                 };
-                if (error instanceof RPCValidationError && error.issues !== undefined) {
+                if (error instanceof RPCValidationError &&
+                    error.issues !== undefined &&
+                    error.issues.length > 0) {
                     payload.details = error.issues;
                 }
                 if (error instanceof RPCRateLimitedError &&
@@ -113,9 +144,15 @@ export class RPCServer {
             }
         }
         // A custom RPCError subclass is still a deliberate, caller-facing
-        // error; honour its own code rather than hiding it.
+        // error; honour its own code rather than hiding it. Its message only
+        // travels when the error was built to be exposed — `RPCError`
+        // defaults to `expose: false`.
         if (isRPCError(error)) {
-            return { code: error.code, message: error.message };
+            return {
+                code: error.code,
+                message: error.message,
+                internal: error.expose === false,
+            };
         }
         return undefined;
     }

package/dist/rpc/validation/rpcValidation.core.d.ts

@@ -74,8 +74,13 @@ export declare function parseInput<T>(schema: RPCSchema<T>, value: unknown, proc
  * Parses a handler's result against its output schema.
  *
  * An invalid output is a server defect rather than a caller mistake, so
- * the issues describe internal shape and stay server-side: the thrown
- * error carries no issue detail.
+ * it is thrown as an `RPCInternalError` (`expose: false`): the server
+ * answers with the generic internal error and hands the detail — the
+ * failing paths and codes — to `onInternalError`. Throwing a validation
+ * error here told the caller *its* request was invalid, with an empty
+ * issue list, for a fault that is entirely the handler's.
+ *
+ * @throws {RPCInternalError}
  */
 export declare function parseOutput<T>(schema: RPCSchema<T>, value: unknown, procedureName: string): T;
 //# sourceMappingURL=rpcValidation.core.d.ts.map

package/dist/rpc/validation/rpcValidation.core.js

@@ -6,7 +6,7 @@
  * Requests arrive from an untrusted peer over a transport, so these are
  * the first checks the server runs, not the last.
  */
-import { RPCInvalidRequestError, RPCValidationError, } from "../errors/rpc.errors.js";
+import { RPCInternalError, RPCInvalidRequestError, RPCValidationError, } from "../errors/rpc.errors.js";
 import { MAX_PROCEDURE_NAME_LENGTH, MAX_RPC_PAYLOAD_SIZE, PROCEDURE_NAME_PATTERN, } from "../constants/rpcConstants.core.js";
 /**
  * Validates a procedure name.
@@ -112,14 +112,22 @@ export function parseInput(schema, value, procedureName) {
  * Parses a handler's result against its output schema.
  *
  * An invalid output is a server defect rather than a caller mistake, so
- * the issues describe internal shape and stay server-side: the thrown
- * error carries no issue detail.
+ * it is thrown as an `RPCInternalError` (`expose: false`): the server
+ * answers with the generic internal error and hands the detail — the
+ * failing paths and codes — to `onInternalError`. Throwing a validation
+ * error here told the caller *its* request was invalid, with an empty
+ * issue list, for a fault that is entirely the handler's.
+ *
+ * @throws {RPCInternalError}
  */
 export function parseOutput(schema, value, procedureName) {
     const result = schema.safeParse(value);
     if (result.success) {
         return result.data;
     }
-    throw new RPCValidationError(`Procedure "${procedureName}" produced a response that does not match its output schema.`, undefined, procedureName);
+    const where = toValidationIssues(result.issues)
+        .map((issue) => `${issue.path || "(root)"}: ${issue.code}`)
+        .join(", ");
+    throw new RPCInternalError(`Procedure "${procedureName}" produced a response that does not match its output schema at ${where}.`, procedureName);
 }
 //# sourceMappingURL=rpcValidation.core.js.map

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/rpc",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Remote procedure call infrastructure for Zudojs applications.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -23,10 +27,10 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/constants": "1.0.0",
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1",
     "@zudojs/types": "1.0.0",
-    "@zudojs/schema": "1.0.0"
+    "@zudojs/schema": "1.0.1"
   },
   "devDependencies": {
     "typescript": "7.0.2",