@orpc/server 0.10.0 → 0.11.0

package/src/builder.ts

@@ -1,238 +0,0 @@
-import type { IsEqual } from '@orpc/shared'
-import type { HandledRouter, Router } from './router'
-import type { Context, MergeContext } from './types'
-import {
-  ContractProcedure,
-  type ContractRouter,
-  type HTTPPath,
-  isContractProcedure,
-  type RouteOptions,
-  type Schema,
-  type SchemaInput,
-  type SchemaOutput,
-} from '@orpc/contract'
-import {
-  type DecoratedMiddleware,
-  decorateMiddleware,
-  type MapInputMiddleware,
-  type Middleware,
-} from './middleware'
-import {
-  type DecoratedProcedure,
-  decorateProcedure,
-  type ProcedureFunc,
-} from './procedure'
-import { ProcedureBuilder } from './procedure-builder'
-import { ProcedureImplementer } from './procedure-implementer'
-import { RouterBuilder } from './router-builder'
-import {
-  type ChainedRouterImplementer,
-  chainRouterImplementer,
-} from './router-implementer'
-
-export class Builder<TContext extends Context, TExtraContext extends Context> {
-  constructor(
-    public zz$b: {
-      middlewares?: Middleware<any, any, any, any>[]
-    } = {},
-  ) {}
-
-  /**
-   * Self chainable
-   */
-
-  context<UContext extends Context>(): IsEqual<UContext, Context> extends true
-    ? Builder<TContext, TExtraContext>
-    : Builder<UContext, TExtraContext> {
-    return this as any
-  }
-
-  use<
-    UExtraContext extends
-    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-    | undefined = undefined,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      unknown,
-      unknown
-    >,
-  ): Builder<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>,
-  ): Builder<TContext, MergeContext<TExtraContext, UExtraContext>>
-
-  use(
-    middleware: Middleware<any, any, any, any>,
-    mapInput?: MapInputMiddleware<any, any>,
-  ): Builder<any, any> {
-    const middleware_ = mapInput
-      ? decorateMiddleware(middleware).mapInput(mapInput)
-      : middleware
-
-    return new Builder({
-      ...this.zz$b,
-      middlewares: [...(this.zz$b.middlewares || []), middleware_],
-    })
-  }
-
-  /**
-   * Convert to ContractProcedureBuilder
-   */
-
-  route(
-    opts: RouteOptions,
-  ): ProcedureBuilder<TContext, TExtraContext, undefined, undefined> {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        ...opts,
-        InputSchema: undefined,
-        OutputSchema: undefined,
-      }),
-    })
-  }
-
-  input<USchema extends Schema = undefined>(
-    schema: USchema,
-    example?: SchemaInput<USchema>,
-  ): ProcedureBuilder<TContext, TExtraContext, USchema, undefined> {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: undefined,
-        InputSchema: schema,
-        inputExample: example,
-      }),
-    })
-  }
-
-  output<USchema extends Schema = undefined>(
-    schema: USchema,
-    example?: SchemaOutput<USchema>,
-  ): ProcedureBuilder<TContext, TExtraContext, undefined, USchema> {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        InputSchema: undefined,
-        OutputSchema: schema,
-        outputExample: example,
-      }),
-    })
-  }
-
-  /**
-   * Convert to Procedure
-   */
-  func<UFuncOutput = undefined>(
-    func: ProcedureFunc<
-      TContext,
-      TExtraContext,
-      undefined,
-      undefined,
-      UFuncOutput
-    >,
-  ): DecoratedProcedure<
-      TContext,
-      TExtraContext,
-      undefined,
-      undefined,
-      UFuncOutput
-    > {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: undefined,
-          OutputSchema: undefined,
-        }),
-        func,
-      },
-    })
-  }
-
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
-
-  contract<UContract extends ContractProcedure<any, any> | ContractRouter>(
-    contract: UContract,
-  ): UContract extends ContractProcedure<
-      infer UInputSchema,
-      infer UOutputSchema
-    >
-      ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema>
-      : UContract extends ContractRouter
-        ? ChainedRouterImplementer<TContext, UContract, TExtraContext>
-        : never {
-    if (isContractProcedure(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares,
-      }) as any
-    }
-
-    return chainRouterImplementer(
-      contract as ContractRouter,
-      this.zz$b.middlewares,
-    ) as any
-  }
-
-  /**
-   * Create ExtendedMiddleware
-   */
-
-  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
-  // solution (maybe): create new generic for .output() method
-  middleware<UExtraContext extends Context = undefined, TInput = unknown, TOutput = any>(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      TInput,
-      TOutput
-    >,
-  ): DecoratedMiddleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      TInput,
-      TOutput
-    > {
-    return decorateMiddleware(middleware)
-  }
-
-  prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext> {
-    return new RouterBuilder({
-      ...this.zz$b,
-      prefix,
-    })
-  }
-
-  tags(...tags: string[]): RouterBuilder<TContext, TExtraContext> {
-    return new RouterBuilder({
-      ...this.zz$b,
-      tags,
-    })
-  }
-
-  /**
-   * Create DecoratedRouter
-   */
-  router<URouter extends Router<TContext>>(
-    router: URouter,
-  ): HandledRouter<URouter> {
-    return new RouterBuilder<TContext, TExtraContext>(this.zz$b).router(router)
-  }
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-import { Builder } from './builder'
-
-export * from './builder'
-export * from './middleware'
-export * from './procedure'
-export * from './procedure-builder'
-export * from './procedure-caller'
-export * from './procedure-implementer'
-export * from './router'
-export * from './router-caller'
-export * from './router-implementer'
-export * from './types'
-export * from './utils'
-export * from '@orpc/shared/error'
-
-export const os = new Builder<undefined | Record<string, unknown>, undefined>()

package/src/middleware.test.ts

@@ -1,260 +0,0 @@
-import type { DecoratedMiddleware, Middleware, MiddlewareMeta } from './middleware'
-import { os } from '.'
-import { decorateMiddleware } from './middleware'
-
-describe('middleware', () => {
-  it('just a function', () => {
-    const mid: Middleware<
-      { auth: boolean },
-      { userId: string },
-      unknown,
-      unknown
-    > = (input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
-
-      return meta.next({ context: { userId: '1' } })
-    }
-  })
-
-  it('expect required return if has extra context', () => {
-    const mid: Middleware<
-      { auth: boolean },
-      { userId: string },
-      unknown,
-      unknown
-    > = (input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
-
-      return meta.next({ context: { userId: '1' } })
-    }
-
-    // @ts-expect-error mid must call next
-    const mid2: Middleware<
-      { auth: boolean },
-      { userId: string },
-      unknown,
-      unknown
-    > = (input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta< unknown>>()
-    }
-
-    // @ts-expect-error mid return invalid context
-    const mid3: Middleware<
-      { auth: boolean },
-      { userId: string },
-      unknown,
-      unknown
-    > = (input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
-
-      return meta.next({
-        context: {
-          valid: false,
-        },
-      })
-    }
-  })
-})
-
-describe('decorateMiddleware', () => {
-  it('infer types', () => {
-    const mid = decorateMiddleware<
-      { auth: boolean },
-      { userId: string },
-      { id: string },
-      { name: string }
-    >((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<{ id: string }>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<{ name: string }>>()
-
-      return meta.next({
-        context: {
-          userId: '1',
-        },
-      })
-    })
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        { userId: string },
-        { id: string },
-        { name: string }
-      >
-    >()
-
-    expectTypeOf(mid).toMatchTypeOf<
-      Middleware<
-        { auth: boolean },
-        { userId: string },
-        { id: string },
-        { name: string }
-      >
-    >()
-  })
-
-  it('concat: infer types', () => {
-    const mid = decorateMiddleware<
-      { auth: boolean },
-      undefined,
-      { id: string },
-      { name: string }
-    >((_, __, meta) => meta.next({})).concat(async (input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<{ id: string }>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<{ name: string }>>()
-
-      return meta.next({
-        context: {
-          userId: '1',
-        },
-      })
-    })
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        { userId: string },
-        { id: string },
-        { name: string }
-      >
-    >()
-  })
-
-  it('concat: can expect input', () => {
-    const mid = decorateMiddleware<
-      { auth: boolean },
-      undefined,
-      unknown,
-      unknown
-    >((_, __, meta) => meta.next({}))
-      .concat((input: { id: string }, _, meta) => meta.next({}))
-      .concat((input: { status: string }, _, meta) => meta.next({}))
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        undefined,
-        { id: string } & { status: string },
-        unknown
-      >
-    >()
-
-    // MID2 isn't usable because input type is wrong
-    const mid2 = mid.concat((input: { id: number }, _, meta) => meta.next({}))
-    expectTypeOf(mid2).toMatchTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        undefined,
-        { id: never, status: string },
-        unknown
-      >
-    >()
-  })
-
-  it('concat: deep copy', () => {
-    const middleware = decorateMiddleware((_, __, meta) => meta.next({}))
-    const mid2 = middleware.concat((_, __, meta) => meta.next({}))
-    expect(mid2).not.toBe(middleware)
-  })
-
-  it('concat: can map input', async () => {
-    const middleware = decorateMiddleware<
-      { auth: boolean },
-      undefined,
-      unknown,
-      unknown
-    >((_, __, meta) => meta.next({}))
-
-    const mid2 = middleware.concat(
-      (input: { postId: number }, _, meta) => meta.next({ context: { a: 'a' } }),
-      input => ({ postId: 12455 }),
-    )
-
-    // mid2 input is unknown, because it's map input does not expect anything
-    expectTypeOf(mid2).toEqualTypeOf<
-      DecoratedMiddleware<{ auth: boolean }, { a: string }, unknown, unknown>
-    >()
-
-    const fn = vi.fn()
-    const mid3 = middleware.concat(
-      (input: { postId: string }, _, meta) => {
-        fn()
-        expect(input).toEqual({ postId: '123' })
-
-        return meta.next({})
-      },
-      (input: { postId: number }) => {
-        fn()
-        expect(input).toEqual({ postId: 123 })
-        return {
-          postId: `${input.postId}`,
-        }
-      },
-    )
-
-    await mid3({ postId: 123 }, {} as any, { next: () => {} } as any)
-    expect(fn).toHaveBeenCalledTimes(2)
-
-    // INPUT now follow expect types from map not from middleware
-    expectTypeOf(mid3).toMatchTypeOf<
-      DecoratedMiddleware<
-        { auth: boolean },
-        undefined,
-        { postId: number },
-        unknown
-      >
-    >()
-  })
-
-  it('mapInput', async () => {
-    const fn = vi.fn()
-
-    const mid = decorateMiddleware<
-      undefined,
-      undefined,
-      { id: string },
-      unknown
-    >(fn).mapInput((input: { postId: string }) => {
-      return { id: input.postId }
-    })
-
-    expectTypeOf(mid).toEqualTypeOf<
-      DecoratedMiddleware<undefined, undefined, { postId: string }, unknown>
-    >()
-
-    await mid({ postId: '1' }, undefined, {} as any)
-
-    expect(fn).toHaveBeenCalledWith({ id: '1' }, undefined, {})
-  })
-})
-
-it('middleware can output', async () => {
-  let mid2Called = false
-  let handlerCalled = false
-  const ping = os
-    .use((input, ctx, meta) => {
-      return meta.output('from middleware')
-    })
-    .use((input, ctx, meta) => {
-      mid2Called = true
-      return meta.output('from middleware 2')
-    })
-    .func(() => {
-      handlerCalled = true
-      return 'from handler'
-    })
-
-  expect(await ping(undefined)).toBe('from middleware')
-  expect(mid2Called).toBeFalsy()
-  expect(handlerCalled).toBeFalsy()
-})

package/src/middleware.ts

@@ -1,136 +0,0 @@
-import type { Promisable } from '@orpc/shared'
-import type { Context, MergeContext, Meta } from './types'
-import { mergeContext } from './utils'
-
-export type MiddlewareResult<TExtraContext extends Context, TOutput> = Promisable<{
-  output: TOutput
-  context: TExtraContext
-}>
-
-export interface MiddlewareMeta<
-  TOutput,
-> extends Meta {
-  next: <UExtraContext extends Context = undefined>(
-    options: UExtraContext extends undefined ? { context?: UExtraContext } : { context: UExtraContext }
-  ) => MiddlewareResult<UExtraContext, TOutput>
-  output: <UOutput>(output: UOutput) => MiddlewareResult<undefined, UOutput>
-}
-
-export interface Middleware<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInput,
-  TOutput,
-> {
-  (
-    input: TInput,
-    context: TContext,
-    meta: MiddlewareMeta<TOutput>,
-  ): Promisable<
-    MiddlewareResult<TExtraContext, TOutput>
-  >
-}
-
-export interface MapInputMiddleware<TInput, TMappedInput> {
-  (input: TInput): TMappedInput
-}
-
-export interface DecoratedMiddleware<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInput,
-  TOutput,
-> extends Middleware<TContext, TExtraContext, TInput, TOutput> {
-  concat: (<
-    UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined,
-    UInput = TInput,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      UInput & TInput,
-      TOutput
-    >,
-  ) => DecoratedMiddleware<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInput & UInput,
-    TOutput
-  >) & (<
-    UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined,
-    UInput = TInput,
-    UMappedInput = unknown,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      UMappedInput,
-      TOutput
-    >,
-    mapInput: MapInputMiddleware<UInput, UMappedInput>,
-  ) => DecoratedMiddleware<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInput & UInput,
-    TOutput
-  >)
-
-  mapInput: <UInput = unknown>(
-    map: MapInputMiddleware<UInput, TInput>,
-  ) => DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>
-}
-
-const decoratedMiddlewareSymbol = Symbol('🔒decoratedMiddleware')
-
-export function decorateMiddleware<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInput,
-  TOutput,
->(
-  middleware: Middleware<TContext, TExtraContext, TInput, TOutput>,
-): DecoratedMiddleware<TContext, TExtraContext, TInput, TOutput> {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware as any
-  }
-
-  const concat = (
-    concatMiddleware: Middleware<any, any, any, any>,
-    mapInput?: MapInputMiddleware<any, any>,
-  ): Middleware<any, any, any, any> => {
-    const concatMiddleware_ = mapInput
-      ? decorateMiddleware(concatMiddleware).mapInput(mapInput)
-      : concatMiddleware
-
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input as any
-      const context_ = context as any
-      const meta_ = meta as any
-
-      const next: MiddlewareMeta<any>['next'] = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest)
-      }
-
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next,
-      }, ...rest)
-
-      return m1
-    })
-  }
-
-  const mapInput = <UInput = unknown>(
-    map: MapInputMiddleware<UInput, TInput>,
-  ): DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput> => {
-    return decorateMiddleware((input, ...rest) =>
-      middleware(map(input), ...rest),
-    )
-  }
-
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat: concat as any,
-    mapInput,
-  })
-}