@orpc/server 1.14.9 → 1.14.11

package/dist/shared/server.15O7oC1p.d.mts

@@ -0,0 +1,61 @@
+import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.CcR4kgje.mjs';
+
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+    [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+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;
+};
+/**
+ * Infer the union of throwable errors for entire router.
+ */
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure, preserving the router shape.
+ */
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
+};
+
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

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

@@ -0,0 +1,67 @@
+import { RPCSerializer, AnyORPCError } from '@orpc/client';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { A as AnyProcedure, C as Context } from './server.CcR4kgje.mjs';
+import { A as AnyRouter } from './server.15O7oC1p.mjs';
+import { AnyProcedureContract } from '@orpc/contract';
+import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.DDFizwfU.mjs';
+
+interface RPCMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
+}
+declare class RPCMatcher {
+    private readonly filter;
+    private readonly rootRouter;
+    private readonly tree;
+    private pendingLazyRouters;
+    constructor(router: AnyRouter, options?: RPCMatcherOptions);
+    private index;
+    match(_method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+    private matchPathname;
+    private resolvePendingLazyRouters;
+    private resolveProcedure;
+}
+
+interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+    /**
+     * Override the default RPC serializer.
+     */
+    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
+    /**
+     * Resolve HTTP status for encoded successful outputs.
+     *
+     * Value should be in the `2xx` range and must be less than `400`.
+     * Return `undefined` or `null` to fallback to default
+     *
+     * @default DEFAULT_SUCCESS_STATUS (200)
+     */
+    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
+     *
+     * @default COMMON_ERROR_STATUS_MAP
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly outputStatus;
+    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { RPCHandlerCodec as a, RPCMatcher as b };
+export type { RPCHandlerCodecOptions as R, RPCMatcherOptions as c };

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

@@ -0,0 +1,104 @@
+import { AnyORPCError } from '@orpc/client';
+import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.CcR4kgje.js';
+import { Schema, ErrorMap } from '@orpc/contract';
+
+interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
+    /**
+     * Initializes the plugin and returns new handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform handler options
+     * such as interceptors, or configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * init(options) {
+     *   return {
+     *     ...options,
+     *     interceptors: [...(options.interceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    readonly name = "~composite";
+    protected readonly plugins: StandardHandlerPlugin<T>[];
+    constructor(plugins?: StandardHandlerPlugin<T>[]);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+interface StandardHandlerHandleOptions<T extends Context> {
+    prefix?: `/${string}` | undefined;
+    context: T;
+}
+type StandardHandlerHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response?: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
+interface StandardHandlerOptions<TContext extends Context> {
+    /**
+     * Fired on every request before routing, useful when you want
+     * to intercept all requests regardless of whether they match a procedure or not.
+     *
+     * @examples
+     * - batch plugins - separate one request into multiple and call multiple next
+     * - openapi spec plugin - to intercept a request and early response
+     */
+    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[];
+    /**
+     * interceptor run after routing and before error handler,
+     * useful for error handling, logging, metrics, etc.
+     */
+    interceptors?: StandardHandlerInterceptor<TContext>[];
+    /**
+     *
+     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
+     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
+     */
+    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap, any>[];
+    plugins?: StandardHandlerPlugin<TContext>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly codec;
+    private readonly routingInterceptors;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
+    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+}
+declare class OtelHandlerPlugin implements StandardHandlerPlugin<any> {
+    name: string;
+    init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
+}
+
+interface StandardHandlerCodecResolvedProcedure {
+    path: string[];
+    procedure: AnyProcedure;
+    decodeInput: () => Promise<unknown>;
+}
+interface StandardHandlerCodec<T extends Context> {
+    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
+export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/server.BoiFpNT7.mjs

@@ -0,0 +1,224 @@
+import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.DofEOwf-.mjs';
+import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
+import { getOrBind, omit, isTypescriptObject } from '@orpc/shared';
+
+const DEFAULT_SUCCESS_STATUS = 200;
+const DEFAULT_ERROR_STATUS = 500;
+
+function createGuardedProcedureLazy(lazy) {
+  const guarded = new Lazy({
+    ...lazy["~orpc"],
+    async loader() {
+      const { default: maybeProcedure } = await unlazy(lazy);
+      if (!(maybeProcedure instanceof Procedure)) {
+        throw new TypeError(`
+          Expected a lazy<procedure> but got lazy<unknown>.
+          This should be caught by TypeScript compilation.
+          Please report this issue if you think this is a bug.
+        `);
+      }
+      return { default: maybeProcedure };
+    }
+  });
+  return guarded;
+}
+function createContractProcedure(procedure, contract) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    meta: contract["~orpc"].meta,
+    metaPlugins: contract["~orpc"].metaPlugins
+  });
+}
+function call(lazyableProcedure, ...[
+  input = void 0,
+  options = {}
+]) {
+  return createProcedureClient(lazyableProcedure, options)(input, options);
+}
+
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
+function withHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return getOrBind(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function augmentRouter(router, options) {
+  if (router instanceof Lazy) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Lazy({
+      meta,
+      metaPlugins,
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
+      ...router["~orpc"],
+      meta,
+      metaPlugins,
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentRouter(router[key], options);
+  }
+  return enhanced;
+}
+function augmentImplementedRouter(router, options) {
+  if (router instanceof Lazy) {
+    const enhanced2 = new Lazy({
+      ...router["~orpc"],
+      async loader() {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = augmentImplementedRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      }
+    });
+    return enhanced2;
+  }
+  if (router instanceof Procedure) {
+    const enhanced2 = new Procedure({
+      ...omit(options, ["middlewares"]),
+      ...router["~orpc"],
+      orderedMiddlewares: [
+        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
+        ...router["~orpc"].orderedMiddlewares
+      ]
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentImplementedRouter(router[key], options);
+  }
+  return enhanced;
+}
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!isTypescriptObject(current)) {
+      return void 0;
+    }
+    if (current instanceof Procedure) {
+      return void 0;
+    }
+    if (!(current instanceof Lazy)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return new Lazy({
+      ...lazied["~orpc"],
+      async loader() {
+        const unwrapped = await unlazy(lazied);
+        const next = getRouter(unwrapped.default, rest);
+        return await unlazy(next);
+      }
+    });
+  }
+  if (!isTypescriptObject(current)) {
+    return void 0;
+  }
+  return current;
+}
+function walkProcedureContractsSync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    callback(router, path);
+    return [];
+  }
+  if (!isTypescriptObject(router)) {
+    return [];
+  }
+  const lazyResults = [];
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      lazyResults.push({ router: value, path: [...path, key] });
+    } else {
+      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
+    }
+  }
+  return lazyResults;
+}
+async function walkProcedureContractsAsync(router, callback, path = []) {
+  const hiddenContract = getHiddenRouterContract(router);
+  if (hiddenContract !== void 0) {
+    router = hiddenContract;
+  }
+  if (router instanceof ProcedureContract) {
+    await callback(router, path);
+    return;
+  }
+  if (!isTypescriptObject(router)) {
+    return;
+  }
+  for (const key in router) {
+    const value = router[key];
+    if (value instanceof Lazy) {
+      const { default: router2 } = await unlazy(value);
+      await walkProcedureContractsAsync(router2, callback, [...path, key]);
+    } else {
+      await walkProcedureContractsAsync(value, callback, [...path, key]);
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (router instanceof Procedure) {
+    return router;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, createContractProcedure as c, augmentImplementedRouter as d, withHiddenRouterContract as e, createGuardedProcedureLazy as f, getRouter as g, call as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, unlazyRouter as u, walkProcedureContractsSync as w };