@orpc/server 2.0.0-beta.47 → 2.0.0-beta.49

package/dist/shared/server.1ExWFMze.mjs

@@ -1,69 +0,0 @@
-import { ORPCError } from '@orpc/client';
-import { toArray } from '@orpc/shared';
-import { flattenStandardHeader } from '@standard-server/core';
-import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
-
-class RequestLimitHandlerPlugin {
-  name = "~request-limit";
-  /**
-   * Should limit the original batch request body instead of sub-requests.
-   */
-  after = ["~batch"];
-  /**
-   * Should limit the final body size instead of the compressed one.
-   */
-  before = ["~request-compression"];
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  init(options) {
-    const maxBodySize = this.maxBodySize;
-    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
-      return next({
-        ...interceptorOptions,
-        request: {
-          ...interceptorOptions.request,
-          async resolveBody(hint) {
-            const contentLength = Number(
-              flattenStandardHeader(interceptorOptions.request.headers["content-length"])
-            );
-            if (Number.isFinite(contentLength) && contentLength > maxBodySize) {
-              throw new ORPCError("PAYLOAD_TOO_LARGE");
-            }
-            const stream = await interceptorOptions.request.resolveBody("octet-stream");
-            if (!(stream instanceof ReadableStream)) {
-              return stream;
-            }
-            let currentBodySize = 0;
-            const limitedStream = stream.pipeThrough(
-              new TransformStream({
-                transform(chunk, controller) {
-                  currentBodySize += chunk.byteLength;
-                  if (currentBodySize > maxBodySize) {
-                    controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
-                    return;
-                  }
-                  controller.enqueue(chunk);
-                }
-              })
-            );
-            const response = new Response(limitedStream, {
-              headers: toFetchHeaders(interceptorOptions.request.headers)
-            });
-            return toStandardBody(response, { hint });
-          }
-        }
-      });
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        routingInterceptor,
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-export { RequestLimitHandlerPlugin as R };

package/dist/shared/server.9B1jEm5a.d.mts

@@ -1,105 +0,0 @@
-import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.DFPxP2v3.mjs';
-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>;
-}
-
-interface StandardHandlerHandleOptions<T extends Context> {
-    prefix?: `/${string}` | undefined;
-    /**
-     * The initial context, or a function (sync or async) that receives the request and returns it.
-     * The function only runs once the request passes the prefix check.
-     */
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-}
-/**
- * `StandardHandlerHandleOptions` after the context has been resolved,
- * this is what interceptors and codecs receive.
- */
-interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
-    context: T;
-}
-type StandardHandlerHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
-    request: StandardLazyRequest;
-}
-type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<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>[] | undefined;
-    /**
-     * interceptor run after routing and before error handler,
-     * useful for error handling, logging, metrics, etc.
-     */
-    interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
-    /**
-     *
-     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
-     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
-     */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
-    plugins?: StandardHandlerPlugin<TContext>[] | undefined;
-}
-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, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
-}
-
-interface StandardHandlerCodecResolvedProcedure {
-    path: string[];
-    procedure: AnyProcedure;
-    decodeInput: () => Promise<unknown>;
-}
-interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { StandardHandler as S };
-export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/server.BB464y-6.mjs

@@ -1,207 +0,0 @@
-import { wrapAsyncIteratorPreservingEventMeta, ORPCError } from '@orpc/client';
-import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
-import { getConstructor, isTypescriptObject, resolveMaybeOptionalOptions, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, getTracer, traceAsyncIterator, traceReadableStream, mergeTwoLevels } from '@orpc/shared';
-
-class Lazy {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@link Lazy} class/interface.
-   */
-  static [Symbol.hasInstance](instance) {
-    if (this !== Lazy) {
-      return Function.prototype[Symbol.hasInstance].call(this, instance);
-    }
-    const constructor = getConstructor(instance);
-    if (constructor === Lazy) {
-      return true;
-    }
-    return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === void 0 || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
-  }
-}
-function unlazy(maybeLazy) {
-  return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
-}
-
-function createProcedureClient(lazyableProcedure, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  return async (...[input, callerOptions]) => {
-    const path = toArray(options.path);
-    const { default: procedure } = await unlazy(lazyableProcedure);
-    const clientContext = callerOptions?.context ?? {};
-    const context = await value(options.context, clientContext) ?? {};
-    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
-    const reconcileError = async (e) => {
-      if (e instanceof ORPCError) {
-        return await reconcileORPCError(procedure["~orpc"].errorMap, e);
-      }
-      return e;
-    };
-    try {
-      const output = await runWithSpan("call_procedure", (span) => {
-        span?.setAttribute("procedure.path", path);
-        return intercept(
-          options.interceptors,
-          {
-            context,
-            // input can be optional if it is undefinable
-            input,
-            errors,
-            path,
-            procedure,
-            signal: callerOptions?.signal,
-            lastEventId: callerOptions?.lastEventId
-          },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
-        );
-      });
-      if (isAsyncIteratorObject(output)) {
-        return override(output, wrapAsyncIteratorPreservingEventMeta(
-          getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output,
-          { mapError: reconcileError }
-        ));
-      } else if (getTracer() && output instanceof ReadableStream) {
-        return override(output, traceReadableStream("consume_octet_stream_output", output));
-      }
-      return output;
-    } catch (e) {
-      throw await reconcileError(e);
-    }
-  };
-}
-async function validateInput(i, schema, input) {
-  return runWithSpan(`validate_input.${i}`, async (span) => {
-    span?.setAttribute("input_schema.index", i);
-    const result = await schema["~standard"].validate(input);
-    if (result.issues) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Input validation failed",
-        data: {
-          issues: result.issues
-        },
-        cause: new ValidationError({
-          message: "Input validation failed",
-          issues: result.issues,
-          invalidData: input
-        })
-      });
-    }
-    return result.value;
-  });
-}
-async function validateOutput(i, schema, output) {
-  return runWithSpan(`validate_output.${i}`, async (span) => {
-    span?.setAttribute("output_schema.index", i);
-    const result = await schema["~standard"].validate(output);
-    if (result.issues) {
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Output validation failed",
-        cause: new ValidationError({
-          message: "Output validation failed",
-          issues: result.issues,
-          invalidData: output
-        })
-      });
-    }
-    return result.value;
-  });
-}
-const middlewareDone = (...rest) => {
-  const options = resolveMaybeOptionalOptions(rest);
-  return {
-    output: options.output,
-    // context can be undefined when all field is optional
-    context: options.context ?? {}
-  };
-};
-async function executeProcedureInternal(procedure, options) {
-  const inputSchemas = toArray(procedure["~orpc"].inputSchemas);
-  const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
-  const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
-  const next = async (midIndex, context, input, signal) => {
-    let currentInput = input;
-    let middlewareInput = input;
-    const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
-    const endInputIndex = midIndex === orderedMiddlewares.length ? inputSchemas.length : orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0;
-    if (!procedure["~orpc"].disableInputValidation) {
-      for (let i = startInputIndex; i < endInputIndex; i++) {
-        const validated = await validateInput(
-          i,
-          inputSchemas[i],
-          i !== 0 ? mergeTwoLevels(options.input, currentInput) : currentInput
-        );
-        currentInput = i !== 0 ? mergeTwoLevels(currentInput, validated) : validated;
-      }
-      middlewareInput = endInputIndex > 0 && endInputIndex < inputSchemas.length ? mergeTwoLevels(options.input, currentInput) : currentInput;
-    }
-    let currentOutput;
-    let currentContext = context;
-    if (midIndex < orderedMiddlewares.length) {
-      const { middleware } = orderedMiddlewares[midIndex];
-      const result = await runWithSpan(`middleware.${middleware.name}`, async (span) => {
-        span?.setAttribute("middleware.index", midIndex);
-        return await middleware(
-          {
-            ...options,
-            context,
-            signal,
-            next: (...rest) => {
-              const nextOptions = resolveMaybeOptionalOptions(rest);
-              const nextContext = nextOptions.context ?? {};
-              return next(
-                midIndex + 1,
-                { ...context, ...nextContext },
-                currentInput,
-                nextOptions.signal ?? signal
-              );
-            },
-            lastEventId: options.lastEventId
-          },
-          middlewareInput,
-          middlewareDone
-        );
-      });
-      currentOutput = result.output;
-      currentContext = { ...context, ...result.context };
-    } else {
-      currentOutput = await runWithSpan(
-        "handler",
-        () => procedure["~orpc"].handler({ ...options, context, input: currentInput, signal }, currentInput)
-      );
-    }
-    const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
-    const endOutputIndex = midIndex === orderedMiddlewares.length ? outputSchemas.length : orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0;
-    if (!procedure["~orpc"].disableOutputValidation) {
-      for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
-        currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
-      }
-    }
-    return { output: currentOutput, context: currentContext };
-  };
-  const { output } = await next(0, options.context, options.input, options.signal);
-  return output;
-}
-
-class Procedure {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@link Procedure} class/interface.
-   */
-  static [Symbol.hasInstance](instance) {
-    if (this !== Procedure) {
-      return Function.prototype[Symbol.hasInstance].call(this, instance);
-    }
-    const constructor = getConstructor(instance);
-    if (constructor === Procedure) {
-      return true;
-    }
-    return instance instanceof ProcedureContract && Array.isArray(instance["~orpc"].orderedMiddlewares) && typeof instance["~orpc"].handler === "function";
-  }
-}
-
-export { Lazy as L, Procedure as P, createProcedureClient as c, unlazy as u };

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

@@ -1,73 +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.DFPxP2v3.mjs';
-
-type Router<TInitialContext extends Context> = Procedure<TInitialContext, 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> : {
-    [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.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
- */
-type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, 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.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
- */
-type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, 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.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
- */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
-};
-/**
- * Infer all router outputs.
- *
- * @remarks
- * **Note**: A procedure is a router too.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
- */
-type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, 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.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
- */
-type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | 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.
- *
- * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
- */
-type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | 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, InferRouterFinalContexts as a, InferRouterError as b, InferRouterErrors as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

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

@@ -1,14 +0,0 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.DFPxP2v3.js';
-import { a as StandardHandlerHandleOptions } from './server.DOg7ke6y.js';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { resolveFriendlyStandardHandlerHandleOptions as r };
-export type { FriendlyStandardHandlerHandleOptions as F };

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

@@ -1,14 +0,0 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest } from '@standard-server/core';
-import { C as Context } from './server.DFPxP2v3.mjs';
-import { a as StandardHandlerHandleOptions } from './server.9B1jEm5a.mjs';
-
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
-
-export { resolveFriendlyStandardHandlerHandleOptions as r };
-export type { FriendlyStandardHandlerHandleOptions as F };

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

@@ -1,34 +0,0 @@
-import { C as Context } from './server.DFPxP2v3.mjs';
-import { b as StandardHandlerPlugin, c as StandardHandlerOptions } from './server.9B1jEm5a.mjs';
-
-interface RequestLimitHandlerPluginOptions {
-    /**
-     * The maximum allowed request body size in bytes.
-     */
-    maxBodySize: number;
-}
-/**
- * Rejects requests whose body exceeds `maxBodySize`.
- *
- * When used with the request compression plugin, the limit applies to the
- * decompressed payload rather than the compressed wire size.
- *
- * @see {@link https://orpc.dev/docs/plugins/request-limit | Request Limit Plugin}
- */
-declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Should limit the original batch request body instead of sub-requests.
-     */
-    after: string[];
-    /**
-     * Should limit the final body size instead of the compressed one.
-     */
-    before: string[];
-    private readonly maxBodySize;
-    constructor(options: RequestLimitHandlerPluginOptions);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-export { RequestLimitHandlerPlugin as R };
-export type { RequestLimitHandlerPluginOptions as a };