@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/shared/server.GDpX6Df8.mjs

@@ -1,271 +0,0 @@
-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.CrlKQucM.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BwHnWUuN.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_event_iterator_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.Pa0F03f_.d.ts

@@ -1,61 +0,0 @@
-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.BL22TloH.js';
-
-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.W91HSRkE.mjs

@@ -1,9 +0,0 @@
-function resolveFriendlyStandardHandlerHandleOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
-
-export { resolveFriendlyStandardHandlerHandleOptions as r };

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

@@ -1,66 +0,0 @@
-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.BL22TloH.js';
-import { A as AnyRouter } from './server.Pa0F03f_.js';
-import { AnyProcedureContract } from '@orpc/contract';
-import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.DBANIheG.js';
-
-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 range `200-299`
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_ERROR_STATUS, DEFAULT_ERROR_STATUS
-     */
-    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
-    /**
-     * Mapping ORPCError Code -> HTTP Status Code
-     *
-     * @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 };