Function createProcedureClient

packages/server/src/procedure-client.ts:72–165

(
  lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>,
  ...rest: MaybeOptionalOptions<
    CreateProcedureClientOptions<
      TInitialContext,
      TOutputSchema,
      TErrorMap,
      TMeta,
      TClientContext
    >
  >
)

 * @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
 */
export function createProcedureClient<
  TInitialContext extends Context,
  TInputSchema extends AnySchema,
  TOutputSchema extends AnySchema,
  TErrorMap extends ErrorMap,
  TMeta extends Meta,
  TClientContext extends ClientContext,
>(
  lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>,
  ...rest: MaybeOptionalOptions<
    CreateProcedureClientOptions<
      TInitialContext,
      TOutputSchema,
      TErrorMap,
      TMeta,
      TClientContext
    >
  >
): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap> {
  const options = resolveMaybeOptionalOptions(rest)

  return async (...[input, callerOptions]) => {
    const path = toArray(options.path)
    const { default: procedure } = await unlazy(lazyableProcedure)

    const clientContext = callerOptions?.context ?? {} as TClientContext // callerOptions.context can be undefined when all field is optional
    const context = await value(options.context ?? {} as TInitialContext, clientContext)
    const errors = createORPCErrorConstructorMap(procedure['~orpc'].errorMap)

    const validateError = async (e: unknown) => {
      if (e instanceof ORPCError) {
        return await validateORPCError(procedure['~orpc'].errorMap, e)
      }

      return e
    }

    try {
      const output = await runWithSpan(
        { name: 'call_procedure', signal: callerOptions?.signal },
        (span) => {
          span?.setAttribute('procedure.path', [...path])

          return intercept(
            toArray(options.interceptors),
            {
              context,
              input: input as InferSchemaInput<TInputSchema>, // input only optional when it undefinable so we can safely cast it
              errors,
              path,
              procedure: procedure as AnyProcedure,
              signal: callerOptions?.signal,
              lastEventId: callerOptions?.lastEventId,
            },
            interceptorOptions => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions),
          )
        },
      )