@orpc/server 0.0.0-next.9b3a030 → 0.0.0-next.9dfcee8

package/dist/plugins/index.d.mts

@@ -0,0 +1,31 @@
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.BeJithK4.mjs';
+export { C as CompositePlugin } from '../shared/server.BeJithK4.mjs';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.BYTulgUc.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -0,0 +1,31 @@
+import { b as StandardHandlerInterceptorOptions, H as HandlerPlugin, a as StandardHandlerOptions } from '../shared/server.B3Tm0IXY.js';
+export { C as CompositePlugin } from '../shared/server.B3Tm0IXY.js';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.BYTulgUc.js';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.mjs

@@ -0,0 +1,103 @@
+export { C as CompositePlugin } from '../shared/server.Q6ZmnTgO.mjs';
+import { value } from '@orpc/shared';
+
+class CORSPlugin {
+  options;
+  constructor(options = {}) {
+    const defaults = {
+      origin: (origin) => origin,
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
+    };
+    this.options = {
+      ...defaults,
+      ...options
+    };
+  }
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
+      if (interceptorOptions.request.method === "OPTIONS") {
+        const resHeaders = {};
+        if (this.options.maxAge !== void 0) {
+          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
+        }
+        if (this.options.allowMethods?.length) {
+          resHeaders["access-control-allow-methods"] = this.options.allowMethods.join(",");
+        }
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
+        if (Array.isArray(allowHeaders) && allowHeaders.length) {
+          resHeaders["access-control-allow-headers"] = allowHeaders.join(",");
+        } else if (typeof allowHeaders === "string") {
+          resHeaders["access-control-allow-headers"] = allowHeaders;
+        }
+        return {
+          matched: true,
+          response: {
+            status: 204,
+            headers: resHeaders,
+            body: void 0
+          }
+        };
+      }
+      return interceptorOptions.next();
+    });
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
+      const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
+      const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
+        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+      }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
+      if (this.options.credentials) {
+        result.response.headers["access-control-allow-credentials"] = "true";
+      }
+      if (this.options.exposeHeaders?.length) {
+        result.response.headers["access-control-expose-headers"] = this.options.exposeHeaders.join(",");
+      }
+      return result;
+    });
+  }
+}
+
+class ResponseHeadersPlugin {
+  init(options) {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push(async (interceptorOptions) => {
+      const headers = new Headers();
+      interceptorOptions.context.resHeaders = headers;
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const responseHeaders = result.response.headers;
+      for (const [key, value] of headers) {
+        if (Array.isArray(responseHeaders[key])) {
+          responseHeaders[key].push(value);
+        } else if (responseHeaders[key] !== void 0) {
+          responseHeaders[key] = [responseHeaders[key], value];
+        } else {
+          responseHeaders[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+}
+
+export { CORSPlugin, ResponseHeadersPlugin };

package/dist/shared/server.B3Tm0IXY.d.ts

@@ -0,0 +1,75 @@
+import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.BYTulgUc.js';
+import { ORPCError } from '@orpc/client';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+    request: StandardLazyRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: HandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface HandlerPlugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: HandlerPlugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerOptions as a, type StandardHandlerInterceptorOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/dist/shared/server.BYTulgUc.d.mts

@@ -0,0 +1,144 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+type ContextExtendsGuard<T extends Context, U extends Context> = T extends U ? unknown : never;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: InferSchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+export { type AnyProcedure as A, type MiddlewareOptions as B, type Context as C, middlewareOutputFn as D, type ProcedureHandlerOptions as E, type ProcedureDef as F, isProcedure as G, createProcedureClient as H, type InferRouterInitialContext as I, type InferRouterInitialContexts as J, type InferRouterCurrentContexts as K, type Lazyable as L, type Middleware as M, type InferRouterInputs as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type InferRouterOutputs as Q, type Router as R, type AnyRouter as a, Procedure as b, type ContextExtendsGuard as c, type MergedCurrentContext as d, type MergedInitialContext as e, type MapInputMiddleware as f, type CreateProcedureClientOptions as g, type ProcedureClient as h, type AnyMiddleware as i, type Lazy as j, type ProcedureHandler as k, type ORPCErrorConstructorMapItemOptions as l, mergeCurrentContext as m, type ORPCErrorConstructorMapItem as n, createORPCErrorConstructorMap as o, LAZY_SYMBOL as p, type LazyMeta as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u, validateORPCError as v, type MiddlewareResult as w, type MiddlewareNextFnOptions as x, type MiddlewareNextFn as y, type MiddlewareOutputFn as z };

package/dist/shared/server.BYTulgUc.d.ts

@@ -0,0 +1,144 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, ClientContext, Client } from '@orpc/client';
+import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, HTTPPath, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
+
+type Context = Record<string, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+type ContextExtendsGuard<T extends Context, U extends Context> = T extends U ? unknown : never;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function lazy<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    input: TInput;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TInContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+    next: MiddlewareNextFn<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    context: TInitialContext;
+    input: InferSchemaInput<TInputSchema>;
+    errors: ORPCErrorConstructorMap<TErrorMap>;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    lastEventId: string | undefined;
+}
+/**
+ * Options for creating a procedure caller with comprehensive type safety
+ */
+type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TInputSchema, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+} : {
+    context: Value<TInitialContext, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+export { type AnyProcedure as A, type MiddlewareOptions as B, type Context as C, middlewareOutputFn as D, type ProcedureHandlerOptions as E, type ProcedureDef as F, isProcedure as G, createProcedureClient as H, type InferRouterInitialContext as I, type InferRouterInitialContexts as J, type InferRouterCurrentContexts as K, type Lazyable as L, type Middleware as M, type InferRouterInputs as N, type ORPCErrorConstructorMap as O, type ProcedureClientInterceptorOptions as P, type InferRouterOutputs as Q, type Router as R, type AnyRouter as a, Procedure as b, type ContextExtendsGuard as c, type MergedCurrentContext as d, type MergedInitialContext as e, type MapInputMiddleware as f, type CreateProcedureClientOptions as g, type ProcedureClient as h, type AnyMiddleware as i, type Lazy as j, type ProcedureHandler as k, type ORPCErrorConstructorMapItemOptions as l, mergeCurrentContext as m, type ORPCErrorConstructorMapItem as n, createORPCErrorConstructorMap as o, LAZY_SYMBOL as p, type LazyMeta as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u, validateORPCError as v, type MiddlewareResult as w, type MiddlewareNextFnOptions as x, type MiddlewareNextFn as y, type MiddlewareOutputFn as z };

package/dist/shared/server.BeJithK4.d.mts

@@ -0,0 +1,75 @@
+import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.BYTulgUc.mjs';
+import { ORPCError } from '@orpc/client';
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+    request: StandardLazyRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: HandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface HandlerPlugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: HandlerPlugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerOptions as a, type StandardHandlerInterceptorOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };