Function executeProcedureInternal

packages/server/src/procedure-client.ts:226–276

(procedure: AnyProcedure, options: ProcedureHandlerOptions<any, any, any, any>)

}

async function executeProcedureInternal(procedure: AnyProcedure, options: ProcedureHandlerOptions<any, any, any, any>): Promise<any> {
  const middlewares = procedure['~orpc'].middlewares
  const inputValidationIndex = Math.min(Math.max(0, procedure['~orpc'].inputValidationIndex), middlewares.length)
  const outputValidationIndex = Math.min(Math.max(0, procedure['~orpc'].outputValidationIndex), middlewares.length)

  const next = async (index: number, context: Context, input: unknown): Promise<unknown> => {
    let currentInput = input

    if (index === inputValidationIndex) {
      currentInput = await validateInput(procedure, currentInput)
    }

    const mid = middlewares[index]

    const output = mid
      ? await runWithSpan(
          { name: `middleware.${mid.name}`, signal: options.signal },
          async (span) => {
            span?.setAttribute('middleware.index', index)
            span?.setAttribute('middleware.name', mid.name)

            const result = await mid({
              ...options,
              context,
              next: async (...[nextOptions]) => {
                const nextContext: Context = nextOptions?.context ?? {}

                return {
                  output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
                  context: nextContext,
                }
              },
            }, currentInput, middlewareOutputFn)

            return result.output
          },
        )
      : await runWithSpan(
          { name: 'handler', signal: options.signal },
          () => procedure['~orpc'].handler({ ...options, context, input: currentInput }),
        )

    if (index === outputValidationIndex) {
      return await validateOutput(procedure, output)
    }

    return output
  }

  return next(0, options.context, options.input)
}