@orpc/server 0.10.0-beta.1 → 0.11.0

package/src/router-implementer.test.ts

@@ -1,116 +0,0 @@
-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.func(() => {
-  return 'unnoq'
-})
-
-const p2 = osw.nested.p2.func(() => {
-  return 'unnoq'
-})
-
-const p3 = osw.nested2.p3.func(() => {
-  return 'unnoq'
-})
-
-it('required all procedure match', () => {
-  const implementer = new RouterImplementer<{ auth: boolean }, typeof cr>({
-    contract: cr,
-  })
-
-  implementer.router({
-    p1,
-    nested: {
-      p2: os.contract(cp2).func(() => ''),
-    },
-    nested2: {
-      p3,
-    },
-  })
-
-  expect(() => {
-    implementer.router({
-      // @ts-expect-error p1 is mismatch
-      p1: os.func(() => {}),
-      nested: {
-        p2,
-      },
-      nested2: {
-        p3,
-      },
-    })
-  }).toThrowError('Mismatch implementation for procedure at [p1]')
-
-  expect(() => {
-    implementer.router({
-      // @ts-expect-error p1 is mismatch
-      p1: osw,
-      nested: {
-        p2,
-      },
-      nested2: {
-        p3,
-      },
-    })
-  }).toThrowError('Mismatch implementation for procedure at [p1]')
-
-  expect(() => {
-    implementer.router({
-      // Not allow manual specification
-      p1: os
-        .input(z.string())
-        .output(z.string())
-        .func(() => 'unnoq'),
-      nested: {
-        p2,
-      },
-      nested2: {
-        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,
-      nested: {
-        p2,
-      },
-      // @ts-expect-error missing p3
-      nested2: {},
-    })
-  }).toThrowError('Missing implementation for procedure at [nested2.p3]')
-
-  expect(() => {
-    implementer.router({
-      p1,
-      nested: {
-        p2,
-      },
-      nested2: {
-        p3: p3.prefix('/test'),
-      },
-    })
-  }).toThrowError('Mismatch implementation for procedure at [nested2.p3]')
-})

package/src/router-implementer.ts

@@ -1,113 +0,0 @@
-import type { Middleware } from './middleware'
-import type { RouterWithContract } from './router'
-import type { Context } from './types'
-import {
-  type ContractProcedure,
-  type ContractRouter,
-  isContractProcedure,
-} from '@orpc/contract'
-import { isProcedure } from './procedure'
-import { ProcedureImplementer } from './procedure-implementer'
-
-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,
-      )
-    }
-  }
-}

package/src/router.test-d.ts

@@ -1,48 +0,0 @@
-import type { InferRouterInputs, InferRouterOutputs } from '.'
-import { z } from 'zod'
-import { os } from '.'
-
-const router = os.router({
-  ping: os
-    .input(z.object({ ping: z.string().transform(() => 1) }))
-    .output(z.object({ pong: z.number().transform(() => '1') }))
-    .func(() => ({ pong: 1 })),
-  user: {
-    find: os
-      .input(z.object({ find: z.number().transform(() => '1') }))
-      .func(() => ({ user: { id: 1 } }))
-    ,
-  },
-})
-
-it('InferRouterInputs', () => {
-    type Inputs = InferRouterInputs<typeof router>
-
-    expectTypeOf<Inputs>().toEqualTypeOf<{
-      ping: {
-        ping: string
-      }
-      user: {
-        find: {
-          find: number
-        }
-      }
-    }>()
-})
-
-it('InferRouterOutputs', () => {
-    type Outputs = InferRouterOutputs<typeof router>
-
-    expectTypeOf<Outputs>().toEqualTypeOf<{
-      ping: {
-        pong: string
-      }
-      user: {
-        find: {
-          user: {
-            id: number
-          }
-        }
-      }
-    }>()
-})

package/src/router.test.ts

@@ -1,142 +0,0 @@
-import { oc } from '@orpc/contract'
-import { z } from 'zod'
-import { os, type RouterWithContract, toContractRouter } from '.'
-
-it('require procedure match context', () => {
-  const osw = os.context<{ auth: boolean, userId: string }>()
-
-  osw.router({
-    ping: osw.context<{ auth: boolean }>().func(() => {
-      return { pong: 'ping' }
-    }),
-
-    // @ts-expect-error userId is not match
-    ping2: osw.context<{ userId: number }>().func(() => {
-      return { name: 'unnoq' }
-    }),
-
-    nested: {
-      ping: osw.context<{ auth: boolean }>().func(() => {
-        return { pong: 'ping' }
-      }),
-
-      // @ts-expect-error userId is not match
-      ping2: osw.context<{ userId: number }>().func(() => {
-        return { name: 'unnoq' }
-      }),
-    },
-  })
-})
-
-it('require match contract', () => {
-  const pingContract = oc.route({ method: 'GET', path: '/ping' })
-  const pongContract = oc.input(z.string()).output(z.string())
-  const ping = os.contract(pingContract).func(() => {
-    return 'ping'
-  })
-  const pong = os.contract(pongContract).func(() => {
-    return 'pong'
-  })
-
-  const contract = oc.router({
-    ping: pingContract,
-    pong: pongContract,
-
-    nested: oc.router({
-      ping: pingContract,
-      pong: pongContract,
-    }),
-  })
-
-  const _1: RouterWithContract<undefined, typeof contract> = {
-    ping,
-    pong,
-
-    nested: {
-      ping,
-      pong,
-    },
-  }
-
-  const _2: RouterWithContract<undefined, typeof contract> = {
-    ping,
-    pong,
-
-    nested: os.contract(contract.nested).router({
-      ping,
-      pong,
-    }),
-  }
-
-  const _3: RouterWithContract<undefined, typeof contract> = {
-    ping,
-    pong,
-
-    // @ts-expect-error missing nested.ping
-    nested: {
-      pong,
-    },
-  }
-
-  const _4: RouterWithContract<undefined, typeof contract> = {
-    ping,
-    pong,
-
-    nested: {
-      ping,
-      // @ts-expect-error nested.pong is mismatch
-      pong: os.func(() => 'ping'),
-    },
-  }
-
-  // @ts-expect-error missing pong
-  const _5: RouterWithContract<undefined, typeof contract> = {
-    ping,
-
-    nested: {
-      ping,
-      pong,
-    },
-  }
-})
-
-it('toContractRouter', () => {
-  const p1 = oc.input(z.string()).output(z.string())
-  const p2 = oc.output(z.string())
-  const p3 = oc.route({ method: 'GET', path: '/test' })
-
-  const contract = oc.router({
-    p1,
-
-    nested: oc.router({
-      p2,
-    }),
-
-    nested2: {
-      p3,
-    },
-  })
-
-  const osw = os.contract(contract)
-
-  const router = osw.router({
-    p1: osw.p1.func(() => {
-      return 'unnoq'
-    }),
-
-    nested: osw.nested.router({
-      p2: osw.nested.p2.func(() => {
-        return 'unnoq'
-      }),
-    }),
-
-    nested2: {
-      p3: osw.nested2.p3.func(() => {
-        return 'unnoq'
-      }),
-    },
-  })
-
-  expect(toContractRouter(router)).toEqual(contract)
-  expect(toContractRouter(contract)).toEqual(contract)
-})

package/src/router.ts

@@ -1,91 +0,0 @@
-import type {
-  ContractProcedure,
-  ContractRouter,
-  SchemaInput,
-  SchemaOutput,
-} from '@orpc/contract'
-import type { Context } from './types'
-import {
-  isContractProcedure,
-} from '@orpc/contract'
-import {
-  type DecoratedProcedure,
-  isProcedure,
-  type Procedure,
-} from './procedure'
-
-export interface Router<TContext extends Context> {
-  [k: string]: Procedure<TContext, any, any, any, any> | Router<TContext>
-}
-
-export type HandledRouter<TRouter extends Router<any>> = {
-  [K in keyof TRouter]: TRouter[K] extends Procedure<
-    infer UContext,
-    infer UExtraContext,
-    infer UInputSchema,
-    infer UOutputSchema,
-    infer UFuncOutput
-  >
-    ? DecoratedProcedure<
-      UContext,
-      UExtraContext,
-      UInputSchema,
-      UOutputSchema,
-      UFuncOutput
-    >
-    : TRouter[K] extends Router<any>
-      ? HandledRouter<TRouter[K]>
-      : never
-}
-
-export type RouterWithContract<
-  TContext extends Context,
-  TContract extends ContractRouter,
-> = {
-  [K in keyof TContract]: TContract[K] extends ContractProcedure<
-    infer UInputSchema,
-    infer UOutputSchema
-  >
-    ? Procedure<TContext, any, UInputSchema, UOutputSchema, any>
-    : TContract[K] extends ContractRouter
-      ? RouterWithContract<TContext, TContract[K]>
-      : never
-}
-
-export function toContractRouter(
-  router: ContractRouter | Router<any>,
-): ContractRouter {
-  const contract: ContractRouter = {}
-
-  for (const key in router) {
-    const item = router[key]
-
-    if (isContractProcedure(item)) {
-      contract[key] = item
-    }
-    else if (isProcedure(item)) {
-      contract[key] = item.zz$p.contract
-    }
-    else {
-      contract[key] = toContractRouter(item as any)
-    }
-  }
-
-  return contract
-}
-
-export type InferRouterInputs<T extends Router<any>> = {
-  [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any>
-    ? SchemaInput<UInputSchema>
-    : T[K] extends Router<any>
-      ? InferRouterInputs<T[K]>
-      : never
-}
-
-export type InferRouterOutputs<T extends Router<any>> = {
-  [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput>
-    ? SchemaOutput<UOutputSchema, UFuncOutput>
-    : T[K] extends Router<any>
-      ? InferRouterOutputs<T[K]>
-      : never
-}

package/src/types.test.ts

@@ -1,18 +0,0 @@
-import type { MergeContext } from './types'
-
-it('mergeContext', () => {
-  expectTypeOf<MergeContext<undefined, undefined>>().toEqualTypeOf<undefined>()
-  expectTypeOf<MergeContext<undefined, { foo: string }>>().toEqualTypeOf<{
-    foo: string
-  }>()
-  expectTypeOf<MergeContext<{ foo: string }, undefined>>().toEqualTypeOf<{
-    foo: string
-  }>()
-  expectTypeOf<MergeContext<{ foo: string }, { foo: string }>>().toEqualTypeOf<{
-    foo: string
-  }>()
-  expectTypeOf<MergeContext<{ foo: string }, { bar: string }>>().toMatchTypeOf<{
-    foo: string
-    bar: string
-  }>()
-})

package/src/types.ts

@@ -1,13 +0,0 @@
-import type { WELL_DEFINED_PROCEDURE } from './procedure'
-
-export type Context = Record<string, unknown> | undefined
-
-export type MergeContext<
-  TA extends Context,
-  TB extends Context,
-> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB
-
-export interface Meta {
-  path: string[]
-  procedure: WELL_DEFINED_PROCEDURE
-}

package/src/utils.test.ts

@@ -1,16 +0,0 @@
-import { mergeContext } from './utils'
-
-it('mergeContext', () => {
-  expect(mergeContext(undefined, undefined)).toBe(undefined)
-  expect(mergeContext(undefined, { foo: 'bar' })).toEqual({ foo: 'bar' })
-  expect(mergeContext({ foo: 'bar' }, undefined)).toEqual({ foo: 'bar' })
-  expect(mergeContext({ foo: 'bar' }, { foo: 'bar' })).toEqual({ foo: 'bar' })
-  expect(mergeContext({ foo: 'bar' }, { bar: 'bar' })).toEqual({
-    foo: 'bar',
-    bar: 'bar',
-  })
-  expect(mergeContext({ foo: 'bar' }, { bar: 'bar', foo: 'bar1' })).toEqual({
-    foo: 'bar1',
-    bar: 'bar',
-  })
-})

package/src/utils.ts

@@ -1,16 +0,0 @@
-import type { Context, MergeContext } from './types'
-
-export function mergeContext<A extends Context, B extends Context>(
-  a: A,
-  b: B,
-): MergeContext<A, B> {
-  if (!a)
-    return b as any
-  if (!b)
-    return a as any
-
-  return {
-    ...a,
-    ...b,
-  } as any
-}