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

package/src/builder.ts

@@ -0,0 +1,236 @@
+import {
+  ContractProcedure,
+  type ContractRouter,
+  type HTTPPath,
+  type RouteOptions,
+  type Schema,
+  type SchemaInput,
+  type SchemaOutput,
+  isContractProcedure,
+} from '@orpc/contract'
+import type { IsEqual } from '@orpc/shared'
+import {
+  type DecoratedMiddleware,
+  type MapInputMiddleware,
+  type Middleware,
+  decorateMiddleware,
+} from './middleware'
+import {
+  type DecoratedProcedure,
+  type ProcedureHandler,
+  decorateProcedure,
+} from './procedure'
+import { ProcedureBuilder } from './procedure-builder'
+import { ProcedureImplementer } from './procedure-implementer'
+import type { HandledRouter, Router } from './router'
+import { RouterBuilder } from './router-builder'
+import {
+  type ChainedRouterImplementer,
+  chainRouterImplementer,
+} from './router-implementer'
+import type { Context, MergeContext } from './types'
+
+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
+   */
+  handler<UHandlerOutput = undefined>(
+    handler: ProcedureHandler<
+      TContext,
+      TExtraContext,
+      undefined,
+      undefined,
+      UHandlerOutput
+    >,
+  ): DecoratedProcedure<
+    TContext,
+    TExtraContext,
+    undefined,
+    undefined,
+    UHandlerOutput
+  > {
+    return decorateProcedure({
+      zz$p: {
+        middlewares: this.zz$b.middlewares,
+        contract: new ContractProcedure({
+          InputSchema: undefined,
+          OutputSchema: undefined,
+        }),
+        handler,
+      },
+    })
+  }
+
+  /**
+   * 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
+   */
+
+  middleware<UExtraContext extends Context = undefined, TInput = unknown>(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      TInput,
+      unknown
+    >,
+  ): DecoratedMiddleware<
+    MergeContext<TContext, TExtraContext>,
+    UExtraContext,
+    TInput,
+    unknown
+  > {
+    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

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

package/src/middleware.test.ts

@@ -0,0 +1,279 @@
+import {
+  type DecoratedMiddleware,
+  type Middleware,
+  decorateMiddleware,
+} from './middleware'
+import type { Meta } from './types'
+
+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<Meta<unknown>>()
+
+      return {
+        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<Meta<unknown>>()
+
+      return {
+        context: {
+          userId: '1',
+        },
+      }
+    }
+
+    // @ts-expect-error mid is not return extra context
+    const mid2: Middleware<
+      { auth: boolean },
+      { userId: string },
+      unknown,
+      unknown
+    > = (input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<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<Meta<unknown>>()
+
+      return {
+        context: {
+          valid: false,
+        },
+      }
+    }
+  })
+
+  it('not allow return if has no extra context', () => {
+    const mid: Middleware<{ auth: boolean }, undefined, unknown, unknown> = (
+      input,
+      context,
+      meta,
+    ) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+    }
+
+    // @ts-expect-error mid2 is not return extra context
+    const mid2: Middleware<{ auth: boolean }, undefined, unknown, unknown> = (
+      input,
+      context,
+      meta,
+    ) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+      return {
+        context: {
+          userId: '1',
+        },
+      }
+    }
+  })
+})
+
+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<Meta<{ name: string }>>()
+
+      return {
+        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 }
+    >(() => {}).concat((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<{ id: string }>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<{ name: string }>>()
+
+      return {
+        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
+    >(() => {})
+      .concat((input: { id: string }) => {})
+      .concat((input: { status: string }) => {})
+
+    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 }) => {})
+    expectTypeOf(mid2).toMatchTypeOf<
+      DecoratedMiddleware<
+        { auth: boolean },
+        undefined,
+        { id: never; status: string },
+        unknown
+      >
+    >()
+  })
+
+  it('concat: deep copy', () => {
+    const middleware = decorateMiddleware(() => {})
+    const mid2 = middleware.concat(() => {})
+    expect(mid2).not.toBe(middleware)
+  })
+
+  it('concat: can map input', async () => {
+    const middleware = decorateMiddleware<
+      { auth: boolean },
+      undefined,
+      unknown,
+      unknown
+    >(() => {})
+
+    const mid2 = middleware.concat(
+      (input: { postId: number }) => {
+        return { 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 }) => {
+        fn()
+        expect(input).toEqual({ postId: '123' })
+      },
+      (input: { postId: number }) => {
+        fn()
+        expect(input).toEqual({ postId: 123 })
+        return {
+          postId: `${input.postId}`,
+        }
+      },
+    )
+
+    await mid3({ postId: 123 }, {} as any, {} 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, {})
+  })
+})

package/src/middleware.ts

@@ -0,0 +1,119 @@
+import type { Context, MergeContext, Meta, Promisable } from './types'
+import { mergeContext } from './utils'
+
+export interface Middleware<
+  TContext extends Context,
+  TExtraContext extends Context,
+  TInput,
+  TOutput,
+> {
+  (
+    input: TInput,
+    context: TContext,
+    meta: Meta<TOutput>,
+  ): Promisable<
+    TExtraContext extends undefined ? void : { context: TExtraContext }
+  >
+}
+
+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 Context = undefined, UInput = TInput>(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      UInput & TInput,
+      TOutput
+    >,
+  ): DecoratedMiddleware<
+    TContext,
+    MergeContext<TExtraContext, UExtraContext>,
+    TInput & UInput,
+    TOutput
+  >
+
+  concat<
+    UExtraContext extends Context = 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>,
+  ) => {
+    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 m1 = await middleware(input_, context_, meta_, ...rest)
+      const m2 = await concatMiddleware_(
+        input_,
+        mergeContext(context_, m1?.context),
+        meta_,
+        ...rest,
+      )
+
+      return { context: mergeContext(m1?.context, m2?.context) }
+    })
+  }
+
+  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,
+  })
+}