@procedures/client 0.0.0-stage → 0.1.0

package/dist/client/typed.js

@@ -0,0 +1,52 @@
+/**
+ * Typed Procedure Caller
+ *
+ * Creates a typed wrapper around a procedure caller function.
+ * Provides compile-time autocomplete for procedure paths, inputs, and outputs.
+ *
+ * @example
+ * ```typescript
+ * import { createTypedCaller } from "@procedures/client";
+ * import type { MongoProcedures, ProcedureInput, ProcedureOutput } from "@procedures/mongo";
+ *
+ * // Create typed caller
+ * const call = createTypedCaller<MongoProcedures>(client.call.bind(client));
+ *
+ * // Full autocomplete on path and input!
+ * const result = await call(
+ *   ["mongo", "documents", "find"],
+ *   { query: { status: "active" } },
+ *   { metadata: { collection: "users" } }
+ * );
+ * // result is typed as FindOutput
+ * ```
+ */
+/**
+ * Create a typed procedure caller
+ *
+ * Wraps a base caller function to provide compile-time type safety
+ * for procedure paths, inputs, and outputs.
+ *
+ * @param caller - Base caller function (e.g., client.call.bind(client))
+ * @returns Typed caller with autocomplete
+ *
+ * @example
+ * ```typescript
+ * import type { MongoProcedures } from "@procedures/mongo";
+ *
+ * const typedCall = createTypedCaller<MongoProcedures>(client.call.bind(client));
+ *
+ * // TypeScript knows:
+ * // - path must be a valid procedure path
+ * // - input must match the procedure's input type
+ * // - result is the procedure's output type
+ * const result = await typedCall(
+ *   ["mongo", "documents", "find"],
+ *   { query: {}, page: 1 }
+ * );
+ * ```
+ */
+export function createTypedCaller(caller) {
+    return caller;
+}
+//# sourceMappingURL=typed.js.map

package/dist/client/typed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed.js","sourceRoot":"","sources":["../../src/client/typed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA6EH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAkB;IAElB,OAAO,MAAwB,CAAC;AAClC,CAAC"}

package/dist/client/types.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Universal Client Type System
+ *
+ * Protocol-agnostic abstractions for RPC communication.
+ * These types work across HTTP, gRPC, WebSocket, and local transports.
+ */
+import type { EventBus } from "../events/types.js";
+import type { Interceptor } from "../procedures/invoke.js";
+import type { ErrorMetadata } from "./errors/index.js";
+/**
+ * Method identifier using structured data (no string parsing needed).
+ *
+ * @example
+ * ```typescript
+ * { service: "users", operation: "get" }
+ * { service: "orders", operation: "create", version: "v2" }
+ * ```
+ */
+export interface Method {
+    /** Service name (e.g., "users", "orders", "payments") */
+    service: string;
+    /** Operation name (e.g., "get", "create", "update", "delete", "watch") */
+    operation: string;
+    /** Optional version (e.g., "v1", "v2") */
+    version?: string;
+}
+/**
+ * Protocol-agnostic metadata container.
+ *
+ * Adapters convert this to protocol-specific formats:
+ * - HTTP: Headers
+ * - gRPC: Metadata
+ * - WebSocket: Frames
+ */
+export interface Metadata {
+    /** Distributed tracing context */
+    tracing?: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string;
+    };
+    /** Authentication/authorization context */
+    auth?: {
+        token?: string;
+        apiKey?: string;
+        userId?: string;
+        [key: string]: unknown;
+    };
+    /** Timeout configuration */
+    timeout?: {
+        /** Overall request timeout in milliseconds */
+        overall?: number;
+        /** Per-attempt timeout in milliseconds (for retries) */
+        perAttempt?: number;
+    };
+    /** Retry context (populated by retry middleware) */
+    retry?: {
+        attempt: number;
+        maxAttempts: number;
+    };
+    /** Extensible for custom fields */
+    [key: string]: unknown;
+}
+/**
+ * Universal request message.
+ *
+ * Sent to transport for execution.
+ */
+export interface Message<TPayload = unknown> {
+    /** Unique request correlation ID */
+    id: string;
+    /** Method to invoke */
+    method: Method;
+    /** Request payload (body) */
+    payload: TPayload;
+    /** Request metadata (headers, context, etc.) */
+    metadata: Metadata;
+    /** Cancellation signal */
+    signal?: AbortSignal;
+}
+/**
+ * Universal response status.
+ *
+ * Protocol-agnostic success/error indication with rich error metadata.
+ *
+ * @example
+ * ```typescript
+ * // Success status
+ * const successStatus: Status = {
+ *   type: "success",
+ *   code: 200,
+ * };
+ *
+ * // Error status with rich metadata
+ * const errorStatus: Status = {
+ *   type: "error",
+ *   code: "TIMEOUT",
+ *   message: "Request timed out",
+ *   retryable: true,
+ *   metadata: {
+ *     summary: "Request timed out",
+ *     detail: "The request exceeded the configured timeout duration...",
+ *     userMessage: "The request took too long to complete. Please try again.",
+ *     devMessage: "Request exceeded timeout threshold...",
+ *     suggestions: ["Try again with a longer timeout", ...],
+ *     category: "timeout",
+ *     severity: "warning",
+ *     // ... full ErrorMetadata
+ *   },
+ * };
+ * ```
+ */
+export type Status = {
+    type: "success";
+    code: number;
+} | {
+    type: "error";
+    code: string;
+    message: string;
+    retryable: boolean;
+    /** Rich error metadata (optional but highly recommended) */
+    metadata?: ErrorMetadata;
+};
+/**
+ * Single response item from a stream.
+ *
+ * Streaming responses yield multiple items.
+ * Request/response yields exactly one item.
+ */
+export interface ResponseItem<TPayload = unknown> {
+    /** Correlates with request ID */
+    id: string;
+    /** Response status */
+    status: Status;
+    /** Response payload (body) */
+    payload: TPayload;
+    /** Response metadata (headers, timing, etc.) */
+    metadata: Metadata;
+}
+/**
+ * Transport interface - protocol-specific implementation.
+ *
+ * All responses are streams:
+ * - Single response = stream with 1 item
+ * - Streaming response = stream with N items
+ */
+export interface Transport {
+    /** Transport name (e.g., "http", "grpc", "websocket", "local") */
+    readonly name: string;
+    /**
+     * Send a message and receive response stream.
+     *
+     * @param message - Request message
+     * @returns Async iterable of response items
+     */
+    send<TReq, TRes>(message: Message<TReq>): AsyncIterable<ResponseItem<TRes>>;
+    /**
+     * Close transport and cleanup resources.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Middleware context for universal client.
+ *
+ * Contains the message being sent.
+ */
+export interface ClientContext<TReq = unknown> {
+    message: Message<TReq>;
+}
+/**
+ * Client middleware runner function type.
+ *
+ * Takes context and returns async iterable of response items.
+ */
+export type ClientRunner<TReq = unknown, TRes = unknown> = (context: ClientContext<TReq>) => AsyncIterable<ResponseItem<TRes>>;
+/**
+ * Universal client middleware.
+ *
+ * Uses the universal middleware system from common/src/middleware.
+ * Note: Uses TAsync=false because AsyncIterable is not wrapped in Promise.
+ *
+ * Works across all transport types!
+ *
+ * @example
+ * ```typescript
+ * const myMiddleware: ClientMiddleware = (next) => {
+ *   return async function* (context) {
+ *     // Before
+ *     console.log('Sending:', context.message);
+ *
+ *     // Execute
+ *     yield* next(context);
+ *
+ *     // After
+ *     console.log('Complete');
+ *   };
+ * };
+ * ```
+ */
+export type ClientMiddleware<TReq = unknown, TRes = unknown> = (next: ClientRunner<TReq, TRes>) => ClientRunner<TReq, TRes>;
+/**
+ * Typed client middleware with context tracking.
+ *
+ * This type enables compile-time validation of middleware chains by tracking
+ * what context each middleware provides and requires.
+ *
+ * Type parameters:
+ * - TProvides: The context type this middleware adds to the chain
+ * - TRequires: The context type this middleware requires to be present
+ *
+ * When composing middleware with Client.use():
+ * - TProvides is accumulated into the Client's context type
+ * - TRequires is validated against the accumulated context
+ * - If TRequires is not satisfied, TypeScript reports an error
+ *
+ * @example
+ * ```typescript
+ * // Retry middleware provides retry context, requires nothing
+ * type RetryMiddleware = TypedClientMiddleware<RetryContext, {}>;
+ *
+ * // A logging middleware that requires retry context
+ * type RetryLoggerMiddleware = TypedClientMiddleware<{}, RetryContext>;
+ *
+ * // Valid: retry provides what retryLogger requires
+ * client.use(retryMiddleware).use(retryLoggerMiddleware);
+ *
+ * // Error: retryLogger requires retry context not yet provided
+ * client.use(retryLoggerMiddleware);
+ * ```
+ */
+export type TypedClientMiddleware<TProvides = {}, TRequires = {}, TReq = unknown, TRes = unknown> = ClientMiddleware<TReq, TRes> & {
+    /**
+     * Phantom type brand for context this middleware provides.
+     * This property doesn't exist at runtime, only at compile time.
+     */
+    readonly __provides?: TProvides;
+    /**
+     * Phantom type brand for context this middleware requires.
+     * This property doesn't exist at runtime, only at compile time.
+     */
+    readonly __requires?: TRequires;
+};
+/**
+ * Extract the provides type from a typed middleware.
+ */
+export type MiddlewareProvides<T> = T extends TypedClientMiddleware<infer P, any, any, any> ? P : {};
+/**
+ * Extract the requires type from a typed middleware.
+ */
+export type MiddlewareRequires<T> = T extends TypedClientMiddleware<any, infer R, any, any> ? R : {};
+/**
+ * Validate that a middleware's requirements are satisfied by accumulated context.
+ * Returns the middleware type if valid, `never` if invalid.
+ */
+export type ValidateMiddleware<TMiddleware extends TypedClientMiddleware<any, any, any, any>, TAccumulatedContext> = MiddlewareRequires<TMiddleware> extends TAccumulatedContext ? TMiddleware : never;
+/**
+ * Accumulate context type after applying a middleware.
+ * Combines accumulated context with what the middleware provides.
+ */
+export type AccumulateContext<TMiddleware extends TypedClientMiddleware<any, any, any, any>, TAccumulatedContext> = TAccumulatedContext & MiddlewareProvides<TMiddleware>;
+/**
+ * Client error thrown when response has error status.
+ */
+export declare class ClientError extends Error {
+    readonly status: Extract<Status, {
+        type: "error";
+    }>;
+    readonly responseId: string;
+    constructor(status: Extract<Status, {
+        type: "error";
+    }>, responseId: string);
+    get code(): string;
+    get retryable(): boolean;
+}
+/**
+ * Options for creating a client.
+ */
+export interface ClientOptions {
+    /** Transport implementation */
+    transport: Transport;
+    /** Default metadata applied to all requests */
+    defaultMetadata?: Metadata;
+    /** Whether to throw on error responses (default: true) */
+    throwOnError?: boolean;
+    /**
+     * The event bus of the local procedures (`ctx.bus`). The default is the global bus of
+     * `getGlobalEventBus()`.
+     */
+    bus?: EventBus;
+    /**
+     * The interceptors of each local invocation and its nested calls, the outermost first (see
+     * `procedures/interceptors.ts`). A remote call goes through the middlewares, not these.
+     */
+    interceptors?: readonly Interceptor[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"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"}

package/dist/client/types.js

@@ -0,0 +1,26 @@
+/**
+ * Universal Client Type System
+ *
+ * Protocol-agnostic abstractions for RPC communication.
+ * These types work across HTTP, gRPC, WebSocket, and local transports.
+ */
+/**
+ * Client error thrown when response has error status.
+ */
+export class ClientError extends Error {
+    status;
+    responseId;
+    constructor(status, responseId) {
+        super(status.message);
+        this.status = status;
+        this.responseId = responseId;
+        this.name = "ClientError";
+    }
+    get code() {
+        return this.status.code;
+    }
+    get retryable() {
+        return this.status.retryable;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/client/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAsTH;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAElB,MAAM;IACN,UAAU;IAF5B,YACkB,MAA0C,EAC1C,UAAkB;QAElC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;sBAHN,MAAM;0BACN,UAAU;QAG1B,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;IAC5B,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;IAC/B,CAAC;CACF"}

package/dist/client/validation/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Zod Validation Module
+ *
+ * Type-safe schema validation for RPC requests and responses.
+ * Works with Zod as an optional peer dependency.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { Client } from "client";
+ * import { createZodMiddleware, ValidationError } from "client/client/validation";
+ *
+ * const client = new Client({ transport })
+ *   .use(createZodMiddleware({ mode: "strict" }))
+ *   .schema({ service: "users", operation: "get" }, {
+ *     input: z.object({ id: z.string() }),
+ *     output: z.object({ id: z.string(), name: z.string() }),
+ *   });
+ *
+ * try {
+ *   const user = await client.call(
+ *     { service: "users", operation: "get" },
+ *     { id: "123" }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error(error.details);
+ *   }
+ * }
+ * ```
+ */
+export { type ZodLike, type ZodErrorLike, type SchemaDefinition, type SchemaRegistry, type MethodKey, type ValidationPhase, type ZodValidationContext, methodToKey, keyToMethod, ValidationError, type InferInput, type InferOutput, } from "./types.js";
+export { createZodMiddleware, type ZodMiddlewareOptions, type ValidationMode, type ZodMiddleware, SCHEMA_REGISTRY, } from "./middleware.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,WAAW,EACX,WAAW,EACX,eAAe,EACf,KAAK,UAAU,EACf,KAAK,WAAW,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,eAAe,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/client/validation/index.js

@@ -0,0 +1,36 @@
+/**
+ * Zod Validation Module
+ *
+ * Type-safe schema validation for RPC requests and responses.
+ * Works with Zod as an optional peer dependency.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { Client } from "client";
+ * import { createZodMiddleware, ValidationError } from "client/client/validation";
+ *
+ * const client = new Client({ transport })
+ *   .use(createZodMiddleware({ mode: "strict" }))
+ *   .schema({ service: "users", operation: "get" }, {
+ *     input: z.object({ id: z.string() }),
+ *     output: z.object({ id: z.string(), name: z.string() }),
+ *   });
+ *
+ * try {
+ *   const user = await client.call(
+ *     { service: "users", operation: "get" },
+ *     { id: "123" }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error(error.details);
+ *   }
+ * }
+ * ```
+ */
+// Core types
+export { methodToKey, keyToMethod, ValidationError, } from "./types.js";
+// Middleware
+export { createZodMiddleware, SCHEMA_REGISTRY, } from "./middleware.js";
+//# sourceMappingURL=index.js.map

package/dist/client/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,aAAa;AACb,OAAO,EAQL,WAAW,EACX,WAAW,EACX,eAAe,GAGhB,MAAM,YAAY,CAAC;AAEpB,aAAa;AACb,OAAO,EACL,mBAAmB,EAInB,eAAe,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/client/validation/middleware.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Schema Validation Middleware for transport calls
+ *
+ * Validates the request and response payloads of calls that go to a transport (a remote
+ * service), by method key. Schemas can be registered per-route (`Client.schema()`) or
+ * overridden per-call.
+ *
+ * A procedure of the registry does not need this middleware: `invokeProcedure` validates its
+ * input and output with its own schemas. Both use `validateSchema()` of the core, so any
+ * Standard Schema (zod 4, valibot, arktype) works here too, also an asynchronous one.
+ */
+import type { ClientMiddleware } from "../types.js";
+import type { SchemaRegistry } from "./types.js";
+import { ValidationError } from "./types.js";
+/**
+ * Validation mode determines behavior on validation failure.
+ */
+export type ValidationMode = "strict" | "warn" | "silent";
+/**
+ * Options for Zod validation middleware.
+ */
+export interface ZodMiddlewareOptions {
+    /**
+     * Validation mode:
+     * - "strict": throw ValidationError on failure (default)
+     * - "warn": log warning but continue with unvalidated data
+     * - "silent": validate but don't throw or log
+     */
+    mode?: ValidationMode;
+    /**
+     * Whether to strip unknown keys from validated objects.
+     * Only works if schemas use .strip() or similar.
+     * @default false
+     */
+    transformOutput?: boolean;
+    /**
+     * Custom error handler for validation failures.
+     * Called in addition to mode behavior (not instead of).
+     */
+    onValidationError?: (error: ValidationError) => void;
+}
+/**
+ * Symbol for accessing the schema registry from middleware.
+ */
+export declare const SCHEMA_REGISTRY: unique symbol;
+/**
+ * Middleware with attached schema registry.
+ */
+export type ZodMiddleware = ClientMiddleware & {
+    [SCHEMA_REGISTRY]: SchemaRegistry;
+};
+/**
+ * Create Zod validation middleware.
+ *
+ * This middleware validates request payloads before sending and
+ * response payloads after receiving, using registered schemas.
+ *
+ * Schemas are registered via `Client.schema()` or passed per-call
+ * in the options.
+ *
+ * @param options - Middleware configuration
+ * @returns Middleware with attached schema registry
+ *
+ * @example
+ * ```typescript
+ * const client = new Client({ transport })
+ *   .use(createZodMiddleware())
+ *   .schema({ service: "users", operation: "get" }, {
+ *     input: z.object({ id: z.string() }),
+ *     output: UserSchema,
+ *   });
+ *
+ * // Validation happens automatically
+ * const user = await client.call(
+ *   { service: "users", operation: "get" },
+ *   { id: "123" }
+ * );
+ * ```
+ */
+export declare function createZodMiddleware(options?: ZodMiddlewareOptions): ZodMiddleware;
+export type { ZodValidationContext } from "./types.js";
+//# sourceMappingURL=middleware.d.ts.map

package/dist/client/validation/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/client/validation/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAA6C,MAAM,aAAa,CAAC;AAC/F,OAAO,KAAK,EAEV,cAAc,EAGf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAe,eAAe,EAAE,MAAM,YAAY,CAAC;AAO1D;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;IAEtB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;CACtD;AAMD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAG,OAAO,MAAqD,CAAC;AAE5F;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,gBAAgB,GAAG;IAC7C,CAAC,eAAe,CAAC,EAAE,cAAc,CAAC;CACnC,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,aAAa,CAyErF;AA2ED,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC"}