@procedures/client 0.0.0-stage → 0.2.0

package/dist/client/client.d.ts

@@ -0,0 +1,525 @@
+/**
+ * Universal Client
+ *
+ * Protocol-agnostic RPC client with middleware composition.
+ * Works with any transport: HTTP, gRPC, WebSocket, or local.
+ *
+ * The Client class is generic over its accumulated context type, enabling
+ * compile-time validation of middleware chains. Each call to `use()` returns
+ * a new type that includes the middleware's provided context.
+ *
+ * @example
+ * ```typescript
+ * // Type accumulates as middleware is added
+ * const client = new Client(transport)
+ *   .use(createRetryMiddleware())     // Client<BaseContext & RetryContext>
+ *   .use(createCacheMiddleware({ methods: ["users.get"] }))     // Client<... & CacheContext>
+ *   .use(createAuthMiddleware(...))   // Client<... & AuthContext>
+ *
+ * // Middleware requiring context validates at compile time
+ * client.use(middlewareThatRequiresAuth); // OK if AuthContext is in chain
+ *
+ * // Context passing via withContext() and per-call options
+ * const authedClient = client.withContext({ auth: { token: "user-token" } });
+ * await authedClient.call(method, payload, { context: { retry: { maxAttempts: 5 } } });
+ * ```
+ */
+import type { Transport, Method, Metadata, ClientMiddleware, ClientOptions, TypedClientMiddleware } from "./types.js";
+import type { CallOptions, ClientContextInput } from "./context.js";
+import type { ZodLike } from "./validation/types.js";
+import type { Route, CallRequest, CallResponse, StreamingCallResponse } from "./call-types.js";
+import type { ProcedureRegistry } from "../procedures/registry.js";
+import type { EventBus } from "../events/types.js";
+import type { ProcedurePath } from "../procedures/types.js";
+import { type AnyProcedureRef, type HydrationEvent } from "../procedures/ref.js";
+/** The options of `exec()` and `execStream()`. */
+export interface ExecOptions {
+    /**
+     * This function gets the hydration events of this program only: the refs that hydration runs,
+     * also inside control flow and runners, with the call that gets each result. A trace uses it.
+     * (`observeHydration()` gets the events of every program in the process.)
+     */
+    onRef?: ((event: HydrationEvent) => void) | undefined;
+}
+/**
+ * Universal Client for protocol-agnostic RPC.
+ *
+ * Features:
+ * - Works with any transport (HTTP, gRPC, WebSocket, local)
+ * - Middleware composition (retry, cache, timeout, custom)
+ * - Stream-first API (single response = stream with 1 item)
+ * - Type-safe request/response handling
+ * - **Type-accumulating middleware**: Context types build through `use()` calls
+ *
+ * @typeParam TContext - Accumulated context type from applied middleware.
+ *   Starts as `{}` and grows as middleware is added via `use()`.
+ *
+ * @example
+ * ```typescript
+ * // HTTP client with type-accumulating middleware
+ * const client = new Client({ transport: new HttpTransport({ baseUrl: "/api" }) })
+ *   .use(createRetryMiddleware())    // Client<{} & RetryContext>
+ *   .use(createCacheMiddleware({ methods: ["users.get"] }))    // Client<{} & RetryContext & CacheContext>
+ *   .use(createAuthMiddleware({      // Client<... & AuthContext>
+ *     token: "abc123"
+ *   }));
+ *
+ * // The client type now carries all middleware context
+ * const user = await client.call(
+ *   { service: "users", operation: "get" },
+ *   { id: 123 }
+ * );
+ *
+ * // Streaming
+ * for await (const event of client.stream(
+ *   { service: "events", operation: "watch" },
+ *   { topic: "orders" }
+ * )) {
+ *   console.log(event);
+ * }
+ * ```
+ */
+export declare class Client<TContext = {}> {
+    private readonly transport;
+    private readonly middleware;
+    private readonly defaultMetadata;
+    private readonly throwOnError;
+    /** The bus of the local procedures. Undefined: the global bus. */
+    private bus;
+    /** The interceptors of the local invocations (roadmap 1.2) */
+    private interceptors;
+    /** The capability of the local invocations (CAPABILITIES-2026-10). Undefined: no limits. */
+    private capability;
+    /** The order of the clearance values. */
+    private clearanceOrder;
+    /**
+     * Context values set via withContext().
+     * Merged with parent context when creating child clients.
+     */
+    private readonly clientContext;
+    /**
+     * Parent client reference (for context inheritance).
+     * When set, middleware and transport are shared, only context differs.
+     */
+    private readonly parent?;
+    constructor(options: ClientOptions | Transport);
+    /**
+     * Create a child client from this client (private, for withContext).
+     */
+    private static createChild;
+    /**
+     * Create a child client with additional context.
+     *
+     * Child clients:
+     * - Share the middleware chain (cheap to create)
+     * - Inherit parent context (merged recursively)
+     * - Can override specific context fields
+     *
+     * Context priority (lowest to highest):
+     * 1. Middleware defaults (e.g., maxRetries: 3 from createRetryMiddleware)
+     * 2. Parent client context (full inheritance chain)
+     * 3. This client's context
+     * 4. Per-call context override
+     *
+     * @param context - Context to set/override on the child client
+     * @returns New client with accumulated context
+     *
+     * @example
+     * ```typescript
+     * // Create authenticated child client
+     * const authedClient = client.withContext({
+     *   auth: { token: "user-token" },
+     *   timeout: { overall: 5000 }
+     * });
+     *
+     * // Nested children inherit and can override
+     * const adminClient = authedClient.withContext({
+     *   auth: { token: "admin-token" },  // Overrides parent token
+     *   // timeout inherited from parent
+     * });
+     * ```
+     */
+    withContext<TAdditional extends object = {}>(context: TAdditional & ClientContextInput<TContext>): Client<TContext & TAdditional>;
+    /**
+     * Get effective context by merging entire parent chain.
+     *
+     * @returns Merged context from all ancestors plus this client
+     */
+    private getEffectiveContext;
+    /**
+     * Add middleware to the client.
+     *
+     * Middleware is composed in the order added (onion model):
+     * - First added = outermost layer
+     * - Last added = innermost layer (closest to transport)
+     *
+     * **Type Accumulation**: When using `TypedClientMiddleware`, the return type
+     * accumulates the middleware's provided context. This enables compile-time
+     * validation of middleware chains.
+     *
+     * @typeParam TProvides - Context type this middleware provides
+     * @typeParam TRequires - Context type this middleware requires (must be subset of TContext)
+     * @param middleware - Middleware function (typed or untyped)
+     * @returns Client with accumulated context type
+     *
+     * @example
+     * ```typescript
+     * // Type accumulation example
+     * const client = new Client(transport)
+     *   .use(createTimeoutMiddleware({ overall: 5000 }))  // Client<TimeoutContext>
+     *   .use(createRetryMiddleware())                     // Client<TimeoutContext & RetryContext>
+     *   .use(createCacheMiddleware({ methods: ["users.get"] }));                    // Client<... & CacheContext>
+     *
+     * // Middleware ordering (onion model)
+     * client
+     *   .use(timeoutMiddleware())   // Outer: handles timeouts
+     *   .use(retryMiddleware())     // Middle: handles retries
+     *   .use(cacheMiddleware());    // Inner: handles caching
+     * ```
+     */
+    use<TProvides = {}, TRequires extends TContext = TContext>(middleware: TypedClientMiddleware<TProvides, TRequires> | ClientMiddleware): Client<TContext & TProvides>;
+    /**
+     * Make a single RPC call (request/response).
+     *
+     * The result is the last item of the response stream: the one item of a request/response
+     * call, or the final item of a streaming procedure. To read each item, use `stream()`.
+     *
+     * @param method - Method to invoke
+     * @param payload - Request payload
+     * @param options - Call options (context override, metadata, signal, schema)
+     *                  OR legacy Metadata object for backward compatibility
+     * @returns Response payload
+     * @throws {ClientError} if response has error status (when throwOnError=true)
+     *
+     * @example
+     * ```typescript
+     * // Simple call
+     * const user = await client.call(
+     *   { service: "users", operation: "get" },
+     *   { id: 123 }
+     * );
+     *
+     * // With context override
+     * const user = await client.call(
+     *   { service: "users", operation: "get" },
+     *   { id: 123 },
+     *   { context: { timeout: { overall: 10000 } } }
+     * );
+     * ```
+     */
+    call<TReq, TRes>(method: Method, payload: TReq, options?: CallOptions<TContext> | Metadata): Promise<TRes>;
+    /**
+     * Execute a procedure reference with automatic input hydration.
+     *
+     * This method supports procedure-as-data: procedures can be passed as inputs
+     * to other procedures, composed declaratively via JSON, or imperatively via TypeScript.
+     *
+     * **Input Hydration**: Any ProcedureRef or `$proc` objects in the input tree
+     * are automatically executed and replaced with their results before the
+     * main procedure runs.
+     *
+     * @param refOrPath - Procedure reference, JSON procedure ref, or procedure path
+     * @param input - Input for the procedure. With a reference, its fields go over the fields of the reference's input.
+     * @returns Output of the procedure
+     *
+     * @example
+     * ```typescript
+     * import { proc } from "@procedures/client";
+     *
+     * // Using proc() builder
+     * const result = await client.exec(
+     *   proc(["git", "add"]).input({ all: true }).build()
+     * );
+     *
+     * // Using JSON format
+     * const result = await client.exec({
+     *   $proc: ["git", "add"],
+     *   input: { all: true },
+     * });
+     *
+     * // Using path + input (simple form)
+     * const result = await client.exec(["git", "add"], { all: true });
+     *
+     * // Nested procedure refs (hydrated automatically)
+     * const result = await client.exec(
+     *   proc(["dag", "traverse"]).input({
+     *     visit: proc(["client", "chain"]).input({
+     *       steps: [
+     *         proc(["git", "add"]).input({ all: true }).ref,
+     *         proc(["git", "commit"]).input({ message: "auto" }).ref,
+     *       ],
+     *     }).ref,
+     *   }).build()
+     * );
+     * ```
+     */
+    exec<TOutput = unknown>(refOrPath: AnyProcedureRef | ProcedurePath, input?: unknown, options?: ExecOptions): Promise<TOutput>;
+    /**
+     * Execute a procedure reference and read each output: each item of a streaming procedure, or
+     * the one value of another procedure. The input refs run as in `exec()`. Nothing runs until
+     * the caller reads the first item.
+     *
+     * @example
+     * ```typescript
+     * for await (const line of client.execStream(["logs", "tail"], { file: "app.log" })) {
+     *   console.log(line);
+     * }
+     * ```
+     */
+    execStream<TOutput = unknown>(refOrPath: AnyProcedureRef | ProcedurePath, input?: unknown, options?: ExecOptions): AsyncIterable<TOutput>;
+    /**
+     * The path and the input of a reference, with the refs of the input run (hydrated).
+     */
+    private prepareRef;
+    /**
+     * The options of a local invocation. The nested calls of the procedure go through this
+     * client, so a path without a local handler goes to the transport. The nested calls get the
+     * metadata and the signal of the caller: when the caller aborts, its nested work stops. (Before,
+     * each nested call started again with no metadata and no signal: deep dive CORE-10.)
+     */
+    private invokeOptions;
+    /**
+     * The call options of a remote call for a caller: its metadata as context, and its signal. A
+     * deadline goes as the remaining time (`procedure-timeout`, in milliseconds): the server
+     * calculates its own deadline, so a difference between two clocks has no effect.
+     */
+    private remoteCallOptions;
+    /**
+     * The input for a procedure without a local handler: validated with the local schema when
+     * the registry has the procedure, then sent to the transport.
+     */
+    private remoteInput;
+    /**
+     * Internal procedure execution (no hydration of the top-level input).
+     */
+    private execInternal;
+    /**
+     * Internal streaming execution (no hydration of the top-level input).
+     */
+    private execStreamInternal;
+    /**
+     * Make a streaming RPC call.
+     *
+     * Returns an async iterable that yields response payloads.
+     * For single request/response, yields exactly one item.
+     *
+     * @param method - Method to invoke
+     * @param payload - Request payload
+     * @param options - Call options (context override, metadata, signal, schema)
+     *                  OR legacy Metadata object for backward compatibility
+     * @returns Async iterable of response payloads
+     * @throws {ClientError} if any response item has error status (when throwOnError=true)
+     *
+     * @example
+     * ```typescript
+     * // Streaming response
+     * for await (const event of client.stream(
+     *   { service: "events", operation: "watch" },
+     *   { topic: "orders" }
+     * )) {
+     *   console.log(event);
+     * }
+     *
+     * // With context and signal
+     * const controller = new AbortController();
+     * for await (const event of client.stream(
+     *   { service: "events", operation: "watch" },
+     *   { topic: "orders" },
+     *   { context: { timeout: { overall: 30000 } }, signal: controller.signal }
+     * )) {
+     *   console.log(event);
+     * }
+     * ```
+     */
+    stream<TReq, TRes>(method: Method, payload: TReq, options?: CallOptions<TContext> | Metadata): AsyncIterable<TRes>;
+    /**
+     * Compose middleware chain using universal middleware composition.
+     *
+     * @returns Composed runner function
+     * @private
+     */
+    private composeMiddleware;
+    /**
+     * Get transport name.
+     */
+    get transportName(): string;
+    /**
+     * Close client and cleanup transport resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Cached reference to Zod middleware for schema registration.
+     */
+    private zodMiddleware;
+    /**
+     * Register a validation schema for a specific method.
+     *
+     * Requires `createZodMiddleware()` to be added via `.use()` first.
+     * Schemas are used to validate request payloads before sending and
+     * response payloads after receiving.
+     *
+     * @param method - Method to register schema for
+     * @param schemas - Input and/or output Zod schemas
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * import { z } from "zod";
+     *
+     * const client = new Client({ transport })
+     *   .use(createZodMiddleware())
+     *   .schema({ service: "users", operation: "get" }, {
+     *     input: z.object({ id: z.string() }),
+     *     output: z.object({ id: z.string(), name: z.string() }),
+     *   })
+     *   .schema({ service: "users", operation: "create" }, {
+     *     input: UserCreateSchema,
+     *     output: UserSchema,
+     *   });
+     *
+     * // Validation happens automatically on call
+     * const user = await client.call(
+     *   { service: "users", operation: "get" },
+     *   { id: "123" }  // Validated against input schema
+     * );
+     * // Response validated against output schema
+     * ```
+     */
+    schema<TInput extends ZodLike = ZodLike, TOutput extends ZodLike = ZodLike>(method: Method, schemas: {
+        input?: TInput;
+        output?: TOutput;
+    }): this;
+    /**
+     * Find Zod middleware in the middleware chain.
+     */
+    private findZodMiddleware;
+    /**
+     * Procedure registry for route resolution.
+     * Uses global registry by default.
+     */
+    private procedureRegistry;
+    /**
+     * Route resolver instance (lazy initialized).
+     */
+    private routeResolver;
+    /**
+     * Batch executor instance (lazy initialized).
+     */
+    private batchExecutor;
+    /**
+     * Set a custom procedure registry for this client.
+     *
+     * @param registry - Procedure registry to use
+     * @returns this (for chaining)
+     */
+    useRegistry(registry: ProcedureRegistry): this;
+    /**
+     * Set the event bus of the local procedures of this client (`ctx.bus`).
+     *
+     * @param bus - Event bus for the procedures
+     * @returns this (for chaining)
+     */
+    useBus(bus: EventBus): this;
+    /**
+     * Make a call using the nested route API.
+     *
+     * This method supports:
+     * - Per-call middleware overrides
+     * - Batch execution with configurable strategies
+     * - Type-safe nested route structures
+     *
+     * @param request - Call request with route and options
+     * @returns Response mirroring the route structure
+     *
+     * @example
+     * ```typescript
+     * // Single route call
+     * const result = await client.route({
+     *   route: {
+     *     collections: {
+     *       users: {
+     *         get: { id: "123" }
+     *       }
+     *     }
+     *   }
+     * });
+     * // result.collections.users.get.data = { id: "123", name: "John" }
+     *
+     * // Batched call with middleware overrides
+     * const results = await client.route({
+     *   middlewares: {
+     *     retry: { attempts: 3 },
+     *     timeout: { ms: 5000 }
+     *   },
+     *   batch: { strategy: 'all' },
+     *   route: {
+     *     collections: {
+     *       users: { get: { id: "123" } },
+     *       orders: { list: { userId: "123" } }
+     *     },
+     *     weather: {
+     *       forecast: { city: "NYC", days: 5 }
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    route<TRoute extends Route>(request: CallRequest<TRoute>): Promise<CallResponse<TRoute>>;
+    /**
+     * Make a streaming call using the nested route API.
+     *
+     * Returns an async iterator that yields results as they complete,
+     * plus a promise for the final complete response.
+     *
+     * @param request - Call request (batch.strategy should be 'stream')
+     * @returns Streaming response with iterator and completion promise
+     */
+    routeStream<TRoute extends Route>(request: CallRequest<TRoute>): StreamingCallResponse<TRoute>;
+    /**
+     * The results of a route that did not resolve: an error for each leaf that failed, and
+     * `SKIPPED` for every other leaf, also the leaves after a validation error. (Before, the leaves
+     * after a validation error were missing: deep dive CORE-14.)
+     */
+    private resolutionFailure;
+    /**
+     * Get the route resolver (lazy initialization).
+     */
+    private getRouteResolver;
+    /**
+     * Get the batch executor (lazy initialization).
+     */
+    private getBatchExecutor;
+    /**
+     * Create execution context from call request.
+     */
+    private createExecutionContext;
+    /**
+     * Execute a single procedure call.
+     * Used by BatchExecutor.
+     *
+     * The `out` config of the route leaf chooses the result (BUGS-2026-07 H8):
+     * - sponge (the default): the value, or the last item of a stream (or `accumulate` of all items);
+     * - stream: `data` is an AsyncIterable of the items. The procedure starts when the reader reads.
+     *   With `bufferSize`, that many items are read ahead of the reader;
+     * - handlers: `progress` gets each item but the last, `complete` gets the last, `error` gets the error.
+     *
+     * A procedure with `outputMode: "batch"` returns an array: sponge gives the array, and stream
+     * gives each element.
+     */
+    private executeProcedure;
+    /**
+     * The output items of a resolved route: from the local handler, or from the transport.
+     */
+    private routeItems;
+    /** The sponge mode: the last item, or `accumulate` of all items. */
+    private sponge;
+    /** The handlers mode: `progress` for each item but the last, then `complete`, or `error`. */
+    private consumeWithHandlers;
+    /** A handler callback gets the data: a function, or a procedure path (the data is its input). */
+    private deliver;
+    /**
+     * Convert procedure path to Method object.
+     */
+    private pathToMethod;
+}
+//# sourceMappingURL=client.d.ts.map

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

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