Function implementerInternal

packages/server/src/implementer.ts:99–189

(
  contract: T,
  config: BuilderConfig,
  middlewares: AnyMiddleware[],
)

  }

export function implementerInternal<
  T extends AnyContractRouter,
  TInitialContext extends Context,
  TCurrentContext extends Context,
>(
  contract: T,
  config: BuilderConfig,
  middlewares: AnyMiddleware[],
): ImplementerInternal<T, TInitialContext, TCurrentContext> {
  if (isContractProcedure(contract)) {
    const impl = new Builder({
      ...contract['~orpc'],
      config,
      middlewares,
      inputValidationIndex: fallbackConfig('initialInputValidationIndex', config?.initialInputValidationIndex) + middlewares.length,
      outputValidationIndex: fallbackConfig('initialOutputValidationIndex', config?.initialOutputValidationIndex) + middlewares.length,
      dedupeLeadingMiddlewares: fallbackConfig('dedupeLeadingMiddlewares', config.dedupeLeadingMiddlewares),
    })

    return impl as any
  }

  const impl = new Proxy(contract, {
    get: (target, key) => {
      if (typeof key !== 'string') {
        return Reflect.get(target, key)
      }

      let method: AnyFunction | undefined

      if (key === 'middleware') {
        method = (mid: any) => decorateMiddleware(mid)
      }
      else if (key === 'use') {
        method = (mid: any) => {
          return implementerInternal(
            contract,
            config,
            addMiddleware(middlewares, mid),
          )
        }
      }
      else if (key === 'router') {
        method = (router: any) => {
          const adapted = enhanceRouter(router, {
            middlewares,
            errorMap: {},
            prefix: undefined,
            tags: undefined,
            dedupeLeadingMiddlewares: fallbackConfig('dedupeLeadingMiddlewares', config.dedupeLeadingMiddlewares),
          })

          return setHiddenRouterContract(adapted, contract)
        }
      }
      else if (key === 'lazy') {
        method = (loader: () => Promise<{ default: AnyRouter }>) => {
          const adapted = enhanceRouter(lazy(loader) as any, {