@orpc/server 0.10.0 → 0.11.0

package/src/procedure.ts

@@ -1,237 +0,0 @@
-import type { Promisable } from '@orpc/shared'
-import type { ProcedureCaller } from './procedure-caller'
-import type { Context, MergeContext, Meta } from './types'
-import {
-  type ContractProcedure,
-  DecoratedContractProcedure,
-  type HTTPPath,
-  isContractProcedure,
-  type RouteOptions,
-  type Schema,
-  type SchemaInput,
-  type SchemaOutput,
-} from '@orpc/contract'
-import {
-  decorateMiddleware,
-  type MapInputMiddleware,
-  type Middleware,
-} from './middleware'
-import { createProcedureCaller } from './procedure-caller'
-
-export class Procedure<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
-> {
-  constructor(
-    public zz$p: {
-      middlewares?: Middleware<any, any, any, any>[]
-      contract: ContractProcedure<TInputSchema, TOutputSchema>
-      func: ProcedureFunc<
-        TContext,
-        TExtraContext,
-        TInputSchema,
-        TOutputSchema,
-        TFuncOutput
-      >
-    },
-  ) {}
-}
-
-export type DecoratedProcedure<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
-> = Procedure<
-  TContext,
-  TExtraContext,
-  TInputSchema,
-  TOutputSchema,
-  TFuncOutput
-> & {
-  prefix: (
-    prefix: HTTPPath,
-  ) => DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >
-
-  route: (
-    opts: RouteOptions,
-  ) => DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >
-
-  use: (<
-    UExtraContext extends
-    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-    | undefined = undefined,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      SchemaOutput<TInputSchema>,
-      SchemaInput<TOutputSchema, TFuncOutput>
-    >,
-  ) => DecoratedProcedure<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >) & (<
-    UExtraContext extends
-    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-    | undefined = undefined,
-    UMappedInput = unknown,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      UMappedInput,
-      SchemaInput<TOutputSchema, TFuncOutput>
-    >,
-    mapInput: MapInputMiddleware<
-      SchemaOutput<TInputSchema, TFuncOutput>,
-      UMappedInput
-    >,
-  ) => DecoratedProcedure<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >)
-} & (undefined extends TContext
-  ? ProcedureCaller<Procedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >>
-  : unknown)
-
-export interface ProcedureFunc<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TOutput extends SchemaOutput<TOutputSchema>,
-> {
-  (
-    input: SchemaOutput<TInputSchema>,
-    context: MergeContext<TContext, TExtraContext>,
-    meta: Meta,
-  ): Promisable<SchemaInput<TOutputSchema, TOutput>>
-}
-
-const DECORATED_PROCEDURE_SYMBOL = Symbol('DECORATED_PROCEDURE')
-
-export function decorateProcedure<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-  TFuncOutput extends SchemaOutput<TOutputSchema>,
->(
-  procedure: Procedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  >,
-): DecoratedProcedure<
-    TContext,
-    TExtraContext,
-    TInputSchema,
-    TOutputSchema,
-    TFuncOutput
-  > {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure as any
-  }
-
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: undefined as any,
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-
-    prefix(prefix: HTTPPath) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract,
-          ).prefix(prefix),
-        },
-      })
-    },
-
-    route(opts: RouteOptions) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract,
-          ).route(opts),
-        },
-      })
-    },
-
-    use(
-      middleware: Middleware<any, any, any, any>,
-      mapInput?: MapInputMiddleware<any, any>,
-    ) {
-      const middleware_ = mapInput
-        ? decorateMiddleware(middleware).mapInput(mapInput)
-        : middleware
-
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...(procedure.zz$p.middlewares ?? [])],
-        },
-      })
-    },
-  }) as any
-}
-
-export type WELL_DEFINED_PROCEDURE = Procedure<
-  Context,
-  Context,
-  Schema,
-  Schema,
-  unknown
->
-
-export function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE {
-  if (item instanceof Procedure)
-    return true
-
-  return (
-    (typeof item === 'object' || typeof item === 'function')
-    && item !== null
-    && 'zz$p' in item
-    && typeof item.zz$p === 'object'
-    && item.zz$p !== null
-    && 'contract' in item.zz$p
-    && isContractProcedure(item.zz$p.contract)
-    && 'func' in item.zz$p
-    && typeof item.zz$p.func === 'function'
-  )
-}

package/src/router-builder.test.ts

@@ -1,106 +0,0 @@
-import { ContractProcedure } from '@orpc/contract'
-import { z } from 'zod'
-import { decorateProcedure, isProcedure, os, Procedure } from '.'
-import { RouterBuilder } from './router-builder'
-
-const builder = new RouterBuilder<undefined, undefined>({})
-const ping = os
-  .route({ method: 'GET', path: '/ping', tags: ['ping'] })
-  .func(() => 'ping')
-const pong = os
-  .output(z.object({ id: z.string() }))
-  .func(() => ({ id: '123' }))
-
-describe('prefix', () => {
-  it('chainable prefix', () => {
-    expect(builder.prefix('/1').prefix('/2').prefix('/3').zz$rb.prefix).toEqual(
-      '/1/2/3',
-    )
-  })
-
-  it('router', () => {
-    const router = builder
-      .prefix('/api')
-      .prefix('/users')
-      .router({ ping, pong })
-
-    expect(router.ping.zz$p.contract.zz$cp.path).toEqual('/api/users/ping')
-    expect(router.pong.zz$p.contract.zz$cp.path).toEqual(undefined)
-  })
-})
-
-describe('tags', () => {
-  it('chainable tags', () => {
-    expect(builder.tags('1', '2').tags('3').tags('4').zz$rb.tags).toEqual([
-      '1',
-      '2',
-      '3',
-      '4',
-    ])
-  })
-
-  it('router', () => {
-    const router = builder
-      .tags('api')
-      .tags('users')
-      .router({ ping, pong })
-
-    expect(router.ping.zz$p.contract.zz$cp.tags).toEqual([
-      'ping',
-      'api',
-      'users',
-    ])
-    expect(router.pong.zz$p.contract.zz$cp.tags).toEqual(['api', 'users'])
-  })
-})
-
-describe('middleware', () => {
-  const mid1 = vi.fn()
-  const mid2 = vi.fn()
-  const mid3 = vi.fn()
-
-  it('chainable middleware', () => {
-    expect(builder.use(mid1).use(mid2).use(mid3).zz$rb.middlewares).toEqual([
-      mid1,
-      mid2,
-      mid3,
-    ])
-  })
-
-  it('router', () => {
-    const router = builder.use(mid1).use(mid2).router({ ping, pong })
-
-    expect(router.ping.zz$p.middlewares).toEqual([mid1, mid2])
-    expect(router.pong.zz$p.middlewares).toEqual([mid1, mid2])
-  })
-
-  it('decorate items', () => {
-    const ping = new Procedure({
-      contract: new ContractProcedure({
-        InputSchema: undefined,
-        OutputSchema: undefined,
-      }),
-      func: () => {},
-    })
-
-    const decorated = decorateProcedure({
-      zz$p: {
-        contract: new ContractProcedure({
-          InputSchema: undefined,
-          OutputSchema: undefined,
-        }),
-        func: () => {},
-      },
-    })
-
-    const router = builder.router({ ping, nested: { ping } })
-
-    expectTypeOf(router).toEqualTypeOf<{
-      ping: typeof decorated
-      nested: { ping: typeof decorated }
-    }>()
-
-    expect(router.ping).satisfies(isProcedure)
-    expect(router.nested.ping).satisfies(isProcedure)
-  })
-})

package/src/router-builder.ts

@@ -1,122 +0,0 @@
-import type { HandledRouter, Router } from './router'
-import type { Context, MergeContext } from './types'
-import { DecoratedContractProcedure, type HTTPPath } from '@orpc/contract'
-import {
-  decorateMiddleware,
-  type MapInputMiddleware,
-  type Middleware,
-} from './middleware'
-import { decorateProcedure, isProcedure } from './procedure'
-
-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

@@ -1,126 +0,0 @@
-import { z } from 'zod'
-import { createRouterCaller, os } from '.'
-
-describe('createRouterCaller', () => {
-  const internal = false
-  const 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()) }))
-    .func((input, context, meta) => {
-      expect(context).toEqual(context)
-
-      return input
-    })
-
-  const pong = osw.func((_, context, meta) => {
-    expect(context).toEqual(context)
-
-    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,
-    })
-
-    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 - invalid input
-    expect(caller.ping({ value: new Date('2023-01-01') })).rejects.toThrowError(
-      'Validation input failed',
-    )
-
-    // @ts-expect-error - invalid input
-    expect(caller.nested.ping({ value: true })).rejects.toThrowError(
-      'Validation input failed',
-    )
-  })
-
-  it('path', () => {
-    const ping = osw.func((_, __, { path }) => {
-      return path
-    })
-
-    const router = osw.router({
-      ping,
-      nested: {
-        ping,
-        child: {
-          ping,
-        },
-      },
-    })
-
-    const caller = createRouterCaller({
-      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

@@ -1,64 +0,0 @@
-import type { Value } from '@orpc/shared'
-import type { Router } from './router'
-import { isProcedure, type Procedure } from './procedure'
-import { createProcedureCaller, type ProcedureCaller } from './procedure-caller'
-
-export interface CreateRouterCallerOptions<
-  TRouter extends Router<any>,
-> {
-  router: TRouter
-
-  /**
-   * The context used when calling the procedure.
-   */
-  context: Value<
-    TRouter extends Router<infer UContext> ? UContext : never
-  >
-
-  /**
-   * This is helpful for logging and analytics.
-   *
-   * @internal
-   */
-  basePath?: string[]
-}
-
-export type RouterCaller<
-  TRouter extends Router<any>,
-> = {
-  [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, any, any, any>
-    ? ProcedureCaller<TRouter[K]>
-    : TRouter[K] extends Router<any>
-      ? RouterCaller<TRouter[K]>
-      : never
-}
-
-export function createRouterCaller<
-  TRouter extends Router<any>,
->(
-  options: CreateRouterCallerOptions<TRouter>,
-): RouterCaller<TRouter> {
-  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,
-        path,
-      })
-    }
-    else {
-      caller[key] = createRouterCaller({
-        router: item as any,
-        context: options.context,
-        basePath: path,
-      })
-    }
-  }
-
-  return caller as RouterCaller<TRouter>
-}