@orpc/server 1.14.11 → 1.14.13

package/dist/shared/server.DofEOwf-.mjs

@@ -1,237 +0,0 @@
-import { ORPCError, wrapAsyncIteratorPreservingEventMeta, cloneORPCError } from '@orpc/client';
-import { reconcileORPCError, ValidationError, ProcedureContract } from '@orpc/contract';
-import { getOrBind, resolveMaybeOptionalOptions, getConstructor, isTypescriptObject, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream } from '@orpc/shared';
-
-function createORPCErrorConstructorMap(errorMap) {
-  const proxy = new Proxy(errorMap, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return getOrBind(target, code);
-      }
-      const item = (...rest) => {
-        const options = resolveMaybeOptionalOptions(rest);
-        const config = errorMap[code];
-        const error = new ORPCError(code, {
-          message: options.message ?? config?.message,
-          data: options.data,
-          cause: options.cause
-        });
-        if (config) {
-          error.defined = true;
-          error.inferable = true;
-        }
-        return error;
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
-
-class Lazy {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@see 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(
-          traceAsyncIterator("consume_async_iterator_object_output", output),
-          { mapError: reconcileError }
-        ));
-      }
-      if (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) => {
-    let currentInput = 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++) {
-        currentInput = await validateInput(i, inputSchemas[i], 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,
-            next: (...rest) => {
-              const nextOptions = resolveMaybeOptionalOptions(rest);
-              const nextContext = nextOptions.context ?? {};
-              return next(
-                midIndex + 1,
-                { ...context, ...nextContext },
-                currentInput
-              );
-            },
-            lastEventId: options.lastEventId
-          },
-          currentInput,
-          middlewareDone
-        );
-      });
-      currentOutput = result.output;
-      currentContext = { ...context, ...result.context };
-    } else {
-      currentOutput = await runWithSpan(
-        "handler",
-        () => procedure["~orpc"].handler({ ...options, context, input: currentInput }, currentInput)
-      );
-      if (currentOutput instanceof ORPCError) {
-        if (procedure["~orpc"].opaqueReturnedErrors) {
-          throw currentOutput;
-        }
-        if (currentOutput.inferable && !currentOutput.defined) {
-          throw currentOutput;
-        }
-        const error = cloneORPCError(currentOutput);
-        error.defined = false;
-        error.inferable = true;
-        throw error;
-      }
-    }
-    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);
-  return output;
-}
-
-class Procedure {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@see 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, createORPCErrorConstructorMap as a, createProcedureClient as c, unlazy as u };

package/dist/shared/server.m3szVJGU.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.CcR4kgje.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 };