@orpc/server 1.14.10 → 1.14.11

package/dist/shared/server.COPVXhDG.mjs

@@ -0,0 +1,271 @@
+import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.DofEOwf-.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BoiFpNT7.mjs';
+
+class CompositeStandardHandlerPlugin {
+  name = "~composite";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+}
+
+class StandardHandler {
+  constructor(codec, options) {
+    this.codec = codec;
+    options = new CompositeStandardHandlerPlugin([
+      new OtelHandlerPlugin(),
+      ...toArray(options.plugins)
+    ]).init(options);
+    this.routingInterceptors = options.routingInterceptors;
+    this.interceptors = options.interceptors;
+    this.clientInterceptors = options.clientInterceptors;
+  }
+  routingInterceptors;
+  interceptors;
+  clientInterceptors;
+  async handle(request, { context, prefix }) {
+    if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
+      return { matched: false, response: void 0 };
+    }
+    return intercept(
+      this.routingInterceptors,
+      { context, prefix, request },
+      async ({ context: context2, prefix: prefix2, request: request2 }) => {
+        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+        let step;
+        const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
+        if (!matchedOrNot) {
+          span?.updateName(`${ORPC_NAME}_no_match`);
+          span?.setAttribute("http.request.method", request2.method);
+          span?.setAttribute("url.path", request2.url);
+          return { matched: false };
+        }
+        const { path, procedure, decodeInput } = matchedOrNot;
+        span?.updateName(`${ORPC_NAME}.${path.join("/")}`);
+        span?.setAttribute("rpc.system", ORPC_NAME);
+        span?.setAttribute("rpc.method", path.join("."));
+        try {
+          const response = await intercept(
+            this.interceptors,
+            { context: context2, prefix: prefix2, request: request2, path, procedure, decodeInput },
+            async ({ context: context3, prefix: prefix3, request: request3, path: path2, procedure: procedure2, decodeInput: decodeInput2 }) => {
+              step = "decode_input";
+              let input = await runWithSpan("decode_input", decodeInput2);
+              step = void 0;
+              if (isAsyncIteratorObject(input)) {
+                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+              }
+              const client = createProcedureClient(procedure2, {
+                context: context3,
+                path: path2,
+                interceptors: this.clientInterceptors
+              });
+              step = "call_procedure";
+              const output = await client(input, {
+                signal: request3.signal,
+                lastEventId: flattenStandardHeader(request3.headers["last-event-id"])
+              });
+              step = void 0;
+              const response2 = await this.codec.encodeOutput(output, procedure2, path2, { context: context3, prefix: prefix3 });
+              return response2;
+            }
+          );
+          return { matched: true, response };
+        } catch (e) {
+          if (step !== "call_procedure") {
+            recordSpanError(span, e);
+          }
+          const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = await this.codec.encodeError(error, procedure, path, { context: context2, prefix: prefix2 });
+          return { matched: true, response };
+        }
+      }
+    );
+  }
+}
+class OtelHandlerPlugin {
+  name = "~opentelemetry";
+  init(options) {
+    return {
+      ...options,
+      routingInterceptors: [
+        // Should be placed before user-provided interceptors to help them access the current active context.
+        async ({ next, request }) => {
+          const otelConfig = getOpenTelemetryConfig();
+          let propagationContext;
+          if (otelConfig?.propagation) {
+            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+          }
+          return runWithSpan(
+            { name: `${request.method} ${request.url}`, context: propagationContext },
+            () => next()
+          );
+        },
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+
+class RPCMatcher {
+  filter;
+  rootRouter;
+  tree = /* @__PURE__ */ new Map();
+  pendingLazyRouters = [];
+  constructor(router, options = {}) {
+    this.filter = options.filter ?? true;
+    this.rootRouter = router;
+    this.index(router);
+  }
+  index(router, path = []) {
+    const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
+      if (!value(this.filter, procedure, procedurePath)) {
+        return;
+      }
+      const httpPath = pathToHttpPath(procedurePath);
+      if (procedure instanceof Procedure) {
+        this.tree.set(httpPath, {
+          path: procedurePath,
+          contract: procedure,
+          procedure
+        });
+      } else {
+        this.tree.set(httpPath, {
+          path: procedurePath,
+          contract: procedure
+        });
+      }
+    }, path);
+    this.pendingLazyRouters.push(
+      ...lazyResults.map((result) => ({
+        ...result,
+        httpPathPrefix: pathToHttpPath(result.path)
+      }))
+    );
+  }
+  async match(_method, pathname, prefix) {
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    if (prefix) {
+      if (!pathname.startsWith(prefix)) {
+        return void 0;
+      }
+      const charAfterPrefix = pathname[prefix.length];
+      if (charAfterPrefix === "/") {
+        pathname = pathname.slice(prefix.length);
+      } else if (charAfterPrefix === void 0) {
+        pathname = "/";
+      } else if (prefix[prefix.length - 1] === "/") {
+        pathname = pathname.slice(prefix.length - 1);
+      } else {
+        return void 0;
+      }
+    }
+    const result = await this.matchPathname(pathname);
+    if (!result && pathname.includes("%")) {
+      return this.matchPathname(normalizeHttpPath(pathname));
+    }
+    return result;
+  }
+  async matchPathname(pathname) {
+    await this.resolvePendingLazyRouters(pathname);
+    const entry = this.tree.get(pathname);
+    if (!entry) {
+      return void 0;
+    }
+    const procedure = await this.resolveProcedure(entry);
+    return { path: entry.path, procedure };
+  }
+  async resolvePendingLazyRouters(pathname) {
+    if (!this.pendingLazyRouters.length) {
+      return;
+    }
+    const stillPending = [];
+    for (const pending of this.pendingLazyRouters) {
+      if (pathname.startsWith(pending.httpPathPrefix)) {
+        const { default: router } = await unlazy(pending.router);
+        this.index(router, pending.path);
+      } else {
+        stillPending.push(pending);
+      }
+    }
+    this.pendingLazyRouters = stillPending;
+  }
+  async resolveProcedure(entry) {
+    if (entry.procedure) {
+      return entry.procedure;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
+    if (!(maybeProcedure instanceof Procedure)) {
+      throw new TypeError(
+        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
+      );
+    }
+    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
+    return entry.procedure;
+  }
+}
+
+class RPCHandlerCodec {
+  matcher;
+  serializer;
+  errorStatusMap;
+  outputStatus;
+  constructor(router, options = {}) {
+    this.matcher = new RPCMatcher(router, options);
+    this.serializer = options.serializer ?? new RPCSerializer();
+    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+    this.outputStatus = options.outputStatus;
+  }
+  async resolveProcedure(request, options) {
+    const [pathname, query] = parseStandardUrl(request.url);
+    const matched = await this.matcher.match(request.method, pathname, options.prefix);
+    if (!matched) {
+      return void 0;
+    }
+    return {
+      procedure: matched.procedure,
+      path: matched.path,
+      decodeInput: async () => {
+        if (request.method === "GET") {
+          const dataString = new URLSearchParams(query).getAll("data").at(-1);
+          return this.serializer.deserialize(parseEmptyableJSON(dataString));
+        }
+        const body = await request.resolveBody();
+        return this.serializer.deserialize(body);
+      }
+    };
+  }
+  encodeOutput(output, procedure, path, options) {
+    return {
+      headers: {},
+      status: value(this.outputStatus, output, procedure, path, options) ?? DEFAULT_SUCCESS_STATUS,
+      body: this.serializer.serialize(output)
+    };
+  }
+  encodeError(error, _procedure, _path, _options) {
+    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    return {
+      headers: {},
+      status,
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };

package/dist/shared/server.CX4vUnDk.mjs

@@ -0,0 +1,11 @@
+import { value } from '@orpc/shared';
+
+function createStandardPeerRequestHandler(handler, options) {
+  return async (request) => {
+    const context = await value(options.context ?? {}, request);
+    const { response } = await handler.handle(request, { ...options, context });
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createStandardPeerRequestHandler as c };

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

@@ -0,0 +1,206 @@
+import { ORPCErrorCode, ORPCErrorOptions, ORPCError, AnyORPCError, ClientContext, Client } from '@orpc/client';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, AnyMetaPlugin, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
+
+interface Context {
+    [key: PropertyKey]: any;
+}
+type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & Omit<TInContext, keyof TInitial | keyof TOutContext>;
+type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : Omit<TCurrent, keyof TOutContext> & TOutContext;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'status'>;
+interface 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;
+};
+/**
+ * Creates a map of ORPC error constructors.
+ *
+ * The returned object is a `Proxy` that allows access to arbitrary error codes:
+ * - If the code exists in the provided `errorMap`, the corresponding constructor
+ *   will create a **defined** `ORPCError`.
+ * - If the code does not exist, a fallback `ORPCError` constructor is returned.
+ *
+ * The `in` operator can be used to check whether an error code is explicitly
+ * defined in the map.
+ *
+ * @example
+ * ```ts
+ * const errorMap = createORPCErrorConstructorMap({
+ *   NOT_FOUND: {
+ *     status: 404,
+ *     message: 'Not Found',
+ *   },
+ * })
+ *
+ * if ('NOT_FOUND' in errorMap) {
+ *   const error = errorMap.NOT_FOUND()
+ * }
+ * ```
+ */
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errorMap: T): ORPCErrorConstructorMap<T>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+type MiddlewareNextOptions<TOutContext extends Context> = object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+};
+interface MiddlewareNext<TOutput> {
+    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+}
+type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
+    context?: TOutContext;
+} : {
+    context: TOutContext;
+}) & {
+    output: TOutput;
+};
+interface MiddlewareDone<TOutput> {
+    /**
+     * Create a successful result and terminate the middleware chain early.
+     */
+    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TInContext;
+    path: string[];
+    procedure: AnyProcedure;
+    signal?: AbortSignal | undefined;
+    lastEventId: string | undefined;
+    /**
+     * Invoke to continue the middleware chain.
+     */
+    next: MiddlewareNext<TOutput>;
+    errors: TErrorConstructorMap;
+}
+interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+    errorMap?: TErrorMap | undefined;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+}
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
+    /** this property should be optional to support inline middleware */
+    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
+    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    context: TCurrentContext;
+    input: TInput;
+    path: string[];
+    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap, any>;
+    signal?: AbortSignal | undefined;
+    lastEventId?: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+interface OrderedMiddleware {
+    /**
+     * Snapshot of `inputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    inputSchemasLengthAtUse?: number | undefined;
+    /**
+     * Snapshot of `outputSchemas.length`
+     * at the time this middleware was used.
+     *
+     * @default 0
+     */
+    outputSchemasLengthAtUse?: number | undefined;
+    middleware: AnyMiddleware;
+}
+interface ProcedureConfig {
+    /**
+     * When enabled, input schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableInputValidation?: boolean | undefined;
+    /**
+     * When enabled, output schemas are not validated at runtime.
+     * Schemas are still used for type inference and OpenAPI generation.
+     *
+     * Useful when output schemas exist only for specification generation.
+     *
+     * @warning Do not disable validation for schemas that transform values.
+     *
+     * @default false
+     */
+    disableOutputValidation?: boolean | undefined;
+}
+interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+    __TInitialContext?: (type: TInitialContext) => unknown;
+    __TInjectedContext?: (type: TInjectedContext) => unknown;
+    __TReturnedError?: () => TReturnedError;
+    /**
+     * When enabled, errors returned (not thrown) by the handler are passed through as-is,
+     * rather than being transformed into inferrable errors.
+     *
+     * This is intended for the contract-first approach, where the procedure adheres to an
+     * external contract and returned errors should not affect the inferred contract types.
+     *
+     * @default false
+     */
+    opaqueReturnedErrors?: boolean | undefined;
+    orderedMiddlewares: OrderedMiddleware[];
+    handler: ProcedureHandler<any, any, any, any>;
+}
+declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>);
+    /**
+     * Checks if the given instance satisfies the {@see Procedure} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AnyProcedure = Procedure<any, any, any, any, any, any>;
+
+interface LazyDefinition<T> {
+    meta: Meta;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    loader: () => Promise<{
+        default: T;
+    }>;
+}
+declare class Lazy<T> {
+    '~orpc': LazyDefinition<T>;
+    constructor(def: LazyDefinition<T>);
+    /**
+     * Checks if the given instance satisfies the {@see Lazy} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type Lazyable<T> = T | Lazy<T>;
+declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedORPCError extends AnyORPCError> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedORPCError | ThrowableError>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
+}
+type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>>;
+type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext> = {
+    path?: string[];
+    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>[];
+} & (object extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+
+export { Procedure as a, Lazy as h, createORPCErrorConstructorMap as x, createProcedureClient as y, unlazy as z };
+export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, ORPCErrorConstructorMap as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureConfig as f, AnyMiddleware as g, ProcedureHandler as i, OrderedMiddleware as j, LazyDefinition as k, MiddlewareDefinition as l, MiddlewareDone as m, MiddlewareDoneOptions as n, MiddlewareNext as o, MiddlewareNextOptions as p, MiddlewareOptions as q, MiddlewareResult as r, ORPCErrorConstructorMapItem as s, ORPCErrorConstructorMapItemOptions as t, ProcedureClientInterceptorOptions as u, ProcedureDefinition as v, ProcedureHandlerOptions as w };