@orpc/server 0.0.0-unsafe-pr-2-20241118033608

package/src/router-builder.ts

@@ -0,0 +1,120 @@
+import { DecoratedContractProcedure, type HTTPPath } from '@orpc/contract'
+import {
+  type MapInputMiddleware,
+  type Middleware,
+  decorateMiddleware,
+} from './middleware'
+import { decorateProcedure, isProcedure } from './procedure'
+import type { HandledRouter, Router } from './router'
+import type { Context, MergeContext } from './types'
+
+export class RouterBuilder<
+  TContext extends Context,
+  TExtraContext extends Context,
+> {
+  constructor(
+    public zz$rb: {
+      prefix?: HTTPPath
+      tags?: string[]
+      middlewares?: Middleware<any, any, any, any>[]
+    },
+  ) {}
+
+  prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext> {
+    return new RouterBuilder({
+      ...this.zz$rb,
+      prefix: `${this.zz$rb.prefix ?? ''}${prefix}`,
+    })
+  }
+
+  tags(...tags: string[]): RouterBuilder<TContext, TExtraContext> {
+    if (!tags.length) return this
+
+    return new RouterBuilder({
+      ...this.zz$rb,
+      tags: [...(this.zz$rb.tags ?? []), ...tags],
+    })
+  }
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      unknown,
+      unknown
+    >,
+  ): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+    UMappedInput = unknown,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      UMappedInput,
+      unknown
+    >,
+    mapInput: MapInputMiddleware<unknown, UMappedInput>,
+  ): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>
+
+  use(
+    middleware: Middleware<any, any, any, any>,
+    mapInput?: MapInputMiddleware<any, any>,
+  ): RouterBuilder<any, any> {
+    const middleware_ = mapInput
+      ? decorateMiddleware(middleware).mapInput(mapInput)
+      : middleware
+
+    return new RouterBuilder({
+      ...this.zz$rb,
+      middlewares: [...(this.zz$rb.middlewares || []), middleware_],
+    })
+  }
+
+  router<URouter extends Router<TContext>>(
+    router: URouter,
+  ): HandledRouter<URouter> {
+    const handled: Router<TContext> = {}
+
+    for (const key in router) {
+      const item = router[key]
+
+      if (isProcedure(item)) {
+        const builderMiddlewares = this.zz$rb.middlewares ?? []
+        const itemMiddlewares = item.zz$p.middlewares ?? []
+
+        const middlewares = [
+          ...builderMiddlewares,
+          ...itemMiddlewares.filter(
+            (item) => !builderMiddlewares.includes(item),
+          ),
+        ]
+
+        const contract = DecoratedContractProcedure.decorate(
+          item.zz$p.contract,
+        ).addTags(...(this.zz$rb.tags ?? []))
+
+        handled[key] = decorateProcedure({
+          zz$p: {
+            ...item.zz$p,
+            contract: this.zz$rb.prefix
+              ? contract.prefix(this.zz$rb.prefix)
+              : contract,
+            middlewares,
+          },
+        })
+      } else {
+        handled[key] = this.router(item as any)
+      }
+    }
+
+    return handled as HandledRouter<URouter>
+  }
+}

package/src/router-caller.test.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod'
+import { os, createRouterCaller } from '.'
+
+describe('createRouterCaller', () => {
+  let internal = false
+  let context = { auth: true }
+
+  const osw = os.context<{ auth?: boolean }>()
+
+  const ping = osw
+    .input(z.object({ value: z.string().transform((v) => Number(v)) }))
+    .output(z.object({ value: z.number().transform((v) => v.toString()) }))
+    .handler((input, context, meta) => {
+      expect(context).toEqual(context)
+      expect(meta.internal).toEqual(internal)
+
+      return input
+    })
+
+  const pong = osw.handler((_, context, meta) => {
+    expect(context).toEqual(context)
+    expect(meta.internal).toBe(internal)
+
+    return { value: true }
+  })
+
+  const router = osw.router({
+    ping,
+    pong,
+    nested: {
+      ping,
+      pong,
+    },
+  })
+
+  it('infer context', () => {
+    createRouterCaller({
+      router,
+      // @ts-expect-error invalid context
+      context: { auth: 123 },
+    })
+
+    createRouterCaller({
+      router,
+      context,
+    })
+  })
+
+  it('with validate', () => {
+    const caller = createRouterCaller({
+      router,
+      context,
+      internal,
+    })
+
+    expectTypeOf(caller.ping).toMatchTypeOf<
+      (input: { value: string }) => Promise<{
+        value: string
+      }>
+    >()
+
+    expectTypeOf(caller.pong).toMatchTypeOf<
+      (input: unknown) => Promise<{
+        value: boolean
+      }>
+    >()
+
+    expectTypeOf(caller.nested.ping).toMatchTypeOf<
+      (input: { value: string }) => Promise<{
+        value: string
+      }>
+    >()
+
+    expectTypeOf(caller.nested.pong).toMatchTypeOf<
+      (input: unknown) => Promise<{
+        value: boolean
+      }>
+    >()
+
+    expect(caller.ping({ value: '123' })).resolves.toEqual({ value: '123' })
+    expect(caller.pong({ value: '123' })).resolves.toEqual({ value: true })
+
+    expect(caller.nested.ping({ value: '123' })).resolves.toEqual({
+      value: '123',
+    })
+    expect(caller.nested.pong({ value: '123' })).resolves.toEqual({
+      value: true,
+    })
+
+    // @ts-expect-error
+    expect(caller.ping({ value: new Date('2023-01-01') })).rejects.toThrowError(
+      'Validation input failed',
+    )
+
+    // @ts-expect-error
+    expect(caller.nested.ping({ value: true })).rejects.toThrowError(
+      'Validation input failed',
+    )
+  })
+
+  it('without validate', () => {
+    internal = true
+    context = { auth: false }
+
+    const caller = createRouterCaller({
+      router,
+      context,
+      internal,
+      validate: false,
+    })
+
+    expectTypeOf(caller.ping).toMatchTypeOf<
+      (input: { value: number }) => Promise<{
+        value: number
+      }>
+    >()
+
+    expectTypeOf(caller.pong).toMatchTypeOf<
+      (input: unknown) => Promise<{
+        value: boolean
+      }>
+    >()
+
+    expectTypeOf(caller.nested.ping).toMatchTypeOf<
+      (input: { value: number }) => Promise<{
+        value: number
+      }>
+    >()
+
+    expectTypeOf(caller.nested.pong).toMatchTypeOf<
+      (input: unknown) => Promise<{
+        value: boolean
+      }>
+    >()
+
+    expect(caller.ping({ value: 123 })).resolves.toEqual({ value: 123 })
+    expect(caller.pong({ value: 123 })).resolves.toEqual({ value: true })
+    expect(caller.nested.ping({ value: 123 })).resolves.toEqual({ value: 123 })
+    expect(caller.nested.pong({ value: 123 })).resolves.toEqual({ value: true })
+
+    // @ts-expect-error it's not validate so bellow still works
+    expect(caller.ping({ value: '123' })).resolves.toEqual({ value: '123' })
+  })
+
+  it('path', () => {
+    const ping = osw.handler((_, __, { path }) => {
+      return path
+    })
+
+    const router = osw.router({
+      ping,
+      nested: {
+        ping,
+        child: {
+          ping,
+        },
+      },
+    })
+
+    const caller = createRouterCaller({
+      router: router,
+      context,
+    })
+
+    expect(caller.ping('')).resolves.toEqual(['ping'])
+    expect(caller.nested.ping('')).resolves.toEqual(['nested', 'ping'])
+    expect(caller.nested.child.ping('')).resolves.toEqual([
+      'nested',
+      'child',
+      'ping',
+    ])
+  })
+})

package/src/router-caller.ts

@@ -0,0 +1,95 @@
+import type {} from '@orpc/contract'
+import { type Procedure, isProcedure } from './procedure'
+import { type ProcedureCaller, createProcedureCaller } from './procedure-caller'
+import type { Router } from './router'
+import type { Meta, Promisable } from './types'
+import {} from './utils'
+
+export interface CreateRouterCallerOptions<
+  TRouter extends Router<any>,
+  TValidate extends boolean,
+> {
+  router: TRouter
+
+  /**
+   * The context used when calling the procedure.
+   */
+  context: TRouter extends Router<infer UContext> ? UContext : never
+
+  /**
+   * Helpful hooks to do some logics on specific time.
+   */
+  hooks?: (
+    context: TRouter extends Router<infer UContext> ? UContext : never,
+    meta: Meta<unknown>,
+  ) => Promisable<void>
+
+  /**
+   * This is helpful for logging and analytics.
+   */
+  basePath?: string[]
+
+  /**
+   * This flag helpful when you want bypass some logics not necessary to internal server calls.
+   *
+   * @default true
+   */
+  internal?: boolean
+
+  /**
+   * Indicate whether validate input and output.
+   *
+   * @default true
+   */
+  validate?: TValidate
+}
+
+export type RouterCaller<
+  TRouter extends Router<any>,
+  TValidate extends boolean,
+> = {
+  [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any>
+    ? ProcedureCaller<TRouter[K], TValidate>
+    : TRouter[K] extends Router<any>
+      ? RouterCaller<TRouter[K], TValidate>
+      : never
+}
+
+export function createRouterCaller<
+  TRouter extends Router<any>,
+  TValidate extends boolean = true,
+>(
+  options: CreateRouterCallerOptions<TRouter, TValidate>,
+): RouterCaller<TRouter, TValidate> {
+  const internal = options.internal ?? true
+  const validate = options.validate ?? true
+
+  const caller: Record<string, unknown> = {}
+
+  for (const key in options.router) {
+    const path = [...(options.basePath ?? []), key]
+    const item = options.router[key]
+
+    if (isProcedure(item)) {
+      caller[key] = createProcedureCaller({
+        procedure: item,
+        context: options.context as any,
+        hooks: options.hooks as any,
+        path: path,
+        internal,
+        validate,
+      })
+    } else {
+      caller[key] = createRouterCaller({
+        router: item as any,
+        context: options.context,
+        hooks: options.hooks,
+        basePath: path,
+        internal,
+        validate,
+      })
+    }
+  }
+
+  return caller as RouterCaller<TRouter, TValidate>
+}

package/src/router-implementer.test.ts

@@ -0,0 +1,116 @@
+import { oc } from '@orpc/contract'
+import { z } from 'zod'
+import { os, RouterImplementer } from '.'
+
+const cp1 = oc.input(z.string()).output(z.string())
+const cp2 = oc.output(z.string())
+const cp3 = oc.route({ method: 'GET', path: '/test' })
+const cr = oc.router({
+  p1: cp1,
+  nested: oc.router({
+    p2: cp2,
+  }),
+  nested2: {
+    p3: cp3,
+  },
+})
+
+const osw = os.context<{ auth: boolean }>().contract(cr)
+
+const p1 = osw.p1.handler(() => {
+  return 'unnoq'
+})
+
+const p2 = osw.nested.p2.handler(() => {
+  return 'unnoq'
+})
+
+const p3 = osw.nested2.p3.handler(() => {
+  return 'unnoq'
+})
+
+it('required all procedure match', () => {
+  const implementer = new RouterImplementer<{ auth: boolean }, typeof cr>({
+    contract: cr,
+  })
+
+  implementer.router({
+    p1: p1,
+    nested: {
+      p2: os.contract(cp2).handler(() => ''),
+    },
+    nested2: {
+      p3: p3,
+    },
+  })
+
+  expect(() => {
+    implementer.router({
+      // @ts-expect-error p1 is mismatch
+      p1: os.handler(() => {}),
+      nested: {
+        p2: p2,
+      },
+      nested2: {
+        p3: p3,
+      },
+    })
+  }).toThrowError('Mismatch implementation for procedure at [p1]')
+
+  expect(() => {
+    implementer.router({
+      // @ts-expect-error p1 is mismatch
+      p1: osw,
+      nested: {
+        p2: p2,
+      },
+      nested2: {
+        p3: p3,
+      },
+    })
+  }).toThrowError('Mismatch implementation for procedure at [p1]')
+
+  expect(() => {
+    implementer.router({
+      // Not allow manual specification
+      p1: os
+        .input(z.string())
+        .output(z.string())
+        .handler(() => 'unnoq'),
+      nested: {
+        p2: p2,
+      },
+      nested2: {
+        p3: p3,
+      },
+    })
+  }).toThrowError('Mismatch implementation for procedure at [p1]')
+
+  expect(() => {
+    // @ts-expect-error required all procedure match
+    implementer.router({})
+  }).toThrowError('Missing implementation for procedure at [p1]')
+
+  expect(() => {
+    implementer.router({
+      p1: p1,
+      nested: {
+        p2: p2,
+      },
+      // @ts-expect-error missing p3
+      nested2: {},
+    })
+  }).toThrowError('Missing implementation for procedure at [nested2.p3]')
+
+  expect(() => {
+    implementer.router({
+      p1: p1,
+      nested: {
+        p2: p2,
+      },
+      nested2: {
+        p3: p3.prefix('/test'),
+      },
+    })
+  }).toThrowError('Mismatch implementation for procedure at [nested2.p3]')
+})

package/src/router-implementer.ts

@@ -0,0 +1,110 @@
+import {
+  type ContractProcedure,
+  type ContractRouter,
+  isContractProcedure,
+} from '@orpc/contract'
+import type { Middleware } from './middleware'
+import { isProcedure } from './procedure'
+import { ProcedureImplementer } from './procedure-implementer'
+import type { RouterWithContract } from './router'
+import type { Context } from './types'
+
+export class RouterImplementer<
+  TContext extends Context,
+  TContract extends ContractRouter,
+> {
+  constructor(
+    public zz$ri: {
+      contract: TContract
+    },
+  ) {}
+
+  router(
+    router: RouterWithContract<TContext, TContract>,
+  ): RouterWithContract<TContext, TContract> {
+    assertRouterImplementation(this.zz$ri.contract, router)
+
+    return router
+  }
+}
+
+export type ChainedRouterImplementer<
+  TContext extends Context,
+  TContract extends ContractRouter,
+  TExtraContext extends Context,
+> = {
+  [K in keyof TContract]: TContract[K] extends ContractProcedure<
+    infer UInputSchema,
+    infer UOutputSchema
+  >
+    ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema>
+    : TContract[K] extends ContractRouter
+      ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext>
+      : never
+} & RouterImplementer<TContext, TContract>
+
+export function chainRouterImplementer<
+  TContext extends Context,
+  TContract extends ContractRouter,
+  TExtraContext extends Context,
+>(
+  contract: TContract,
+  middlewares?: Middleware<any, any, any, any>[],
+): ChainedRouterImplementer<TContext, TContract, TExtraContext> {
+  const result: Record<string, unknown> = {}
+
+  for (const key in contract) {
+    const item = contract[key]
+
+    if (isContractProcedure(item)) {
+      result[key] = new ProcedureImplementer({
+        contract: item,
+        middlewares,
+      })
+    } else {
+      result[key] = chainRouterImplementer(item as ContractRouter, middlewares)
+    }
+  }
+
+  const implementer = new RouterImplementer({ contract })
+
+  return Object.assign(implementer, result) as any
+}
+
+export function assertRouterImplementation(
+  contract: ContractRouter,
+  router: RouterWithContract<any, any>,
+  path: string[] = [],
+): void {
+  for (const key in contract) {
+    const currentPath = [...path, key]
+    const contractItem = contract[key]
+    const routerItem = router[key]
+
+    if (!routerItem) {
+      throw new Error(
+        `Missing implementation for procedure at [${currentPath.join('.')}]`,
+      )
+    }
+
+    if (isContractProcedure(contractItem)) {
+      if (isProcedure(routerItem)) {
+        if (routerItem.zz$p.contract !== contractItem) {
+          throw new Error(
+            `Mismatch implementation for procedure at [${currentPath.join('.')}]`,
+          )
+        }
+      } else {
+        throw new Error(
+          `Mismatch implementation for procedure at [${currentPath.join('.')}]`,
+        )
+      }
+    } else {
+      assertRouterImplementation(
+        contractItem as ContractRouter,
+        routerItem as any,
+        currentPath,
+      )
+    }
+  }
+}