@orpc/server 0.10.0 → 0.11.0

package/src/procedure-builder.test.ts

@@ -1,223 +0,0 @@
-import type { MiddlewareMeta } from './middleware'
-import type { ProcedureImplementer } from './procedure-implementer'
-import type { Meta } from './types'
-import { ContractProcedure } from '@orpc/contract'
-import { z } from 'zod'
-import { os } from '.'
-import { type DecoratedProcedure, isProcedure } from './procedure'
-import { ProcedureBuilder } from './procedure-builder'
-
-const schema1 = z.object({ id: z.string() })
-const example1 = { id: '1' }
-const schema2 = z.object({ name: z.string() })
-const example2 = { name: 'unnoq' }
-
-const builder = new ProcedureBuilder<
-  { auth: boolean },
-  undefined,
-  undefined,
-  undefined
->({
-  contract: new ContractProcedure({
-    InputSchema: undefined,
-    OutputSchema: undefined,
-  }),
-})
-
-it('input', () => {
-  const builder2 = builder.input(schema1, example1)
-
-  expectTypeOf(builder2).toEqualTypeOf<
-    ProcedureBuilder<{ auth: boolean }, undefined, typeof schema1, undefined>
-  >()
-
-  expect(builder2.zz$pb).toMatchObject({
-    contract: {
-      zz$cp: {
-        InputSchema: schema1,
-        inputExample: example1,
-      },
-    },
-  })
-})
-
-it('output', () => {
-  const builder2 = builder.output(schema2, example2)
-
-  expectTypeOf(builder2).toEqualTypeOf<
-    ProcedureBuilder<{ auth: boolean }, undefined, undefined, typeof schema2>
-  >()
-
-  expect(builder2.zz$pb).toMatchObject({
-    contract: {
-      zz$cp: {
-        OutputSchema: schema2,
-        outputExample: example2,
-      },
-    },
-  })
-})
-
-it('route', () => {
-  const builder2 = builder.route({
-    method: 'GET',
-    path: '/test',
-    deprecated: true,
-    description: 'des',
-    summary: 'sum',
-    tags: ['hi'],
-  })
-
-  expectTypeOf(builder2).toEqualTypeOf<
-    ProcedureBuilder<{ auth: boolean }, undefined, undefined, undefined>
-  >()
-
-  expect(builder2.zz$pb).toMatchObject({
-    contract: {
-      zz$cp: {
-        method: 'GET',
-        path: '/test',
-        deprecated: true,
-        description: 'des',
-        summary: 'sum',
-        tags: ['hi'],
-      },
-    },
-  })
-})
-
-describe('use middleware', () => {
-  it('infer types', () => {
-    const implementer = builder
-      .use((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<unknown>()
-        expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
-
-        return meta.next({
-          context: {
-            userId: '1',
-          },
-        })
-      })
-      .use((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<unknown>()
-        expectTypeOf(context).toEqualTypeOf<
-          { userId: string } & { auth: boolean }
-        >()
-        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<unknown>>()
-
-        return meta.next({})
-      })
-
-    expectTypeOf(implementer).toEqualTypeOf<
-      ProcedureImplementer<
-        { auth: boolean },
-        { userId: string },
-        undefined,
-        undefined
-      >
-    >()
-  })
-
-  it('map middleware input', () => {
-    // @ts-expect-error mismatch input
-    builder.use((input: { postId: string }) => {
-      return { context: { a: 'a' } }
-    })
-
-    builder.use(
-      (input: { postId: string }, _, meta) => {
-        return meta.next({ context: { a: 'a' } })
-      },
-      // @ts-expect-error mismatch input
-      input => ({ postId: 12455 }),
-    )
-
-    builder.use(
-      (input: { postId: string }, context, meta) => meta.next({}),
-      input => ({ postId: '12455' }),
-    )
-
-    const implementer = builder.input(schema1).use(
-      (input: { id: number }, _, meta) => {
-        return meta.next({
-          context: {
-            userId555: '1',
-          },
-        })
-      },
-      input => ({ id: Number.parseInt(input.id) }),
-    )
-
-    expectTypeOf(implementer).toEqualTypeOf<
-      ProcedureImplementer<
-        { auth: boolean },
-        { userId555: string },
-        typeof schema1,
-        undefined
-      >
-    >()
-  })
-})
-
-describe('handler', () => {
-  it('infer types', () => {
-    const handler = builder.func((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta>()
-    })
-
-    expectTypeOf(handler).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        undefined,
-        undefined,
-        undefined,
-        void
-      >
-    >()
-
-    expect(isProcedure(handler)).toBe(true)
-  })
-
-  it('combine middlewares', () => {
-    const mid1 = os.middleware((input, context, meta) => {
-      return meta.next({
-        context: {
-          userId: '1',
-        },
-      })
-    })
-
-    const mid2 = os.middleware((_, __, meta) => meta.next({}))
-
-    const handler = builder
-      .use(mid1)
-      .use(mid2)
-      .func((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<unknown>()
-        expectTypeOf(context).toEqualTypeOf<
-          { userId: string } & { auth: boolean }
-        >()
-        expectTypeOf(meta).toEqualTypeOf<Meta>()
-
-        return {
-          name: 'unnoq',
-        }
-      })
-
-    expectTypeOf(handler).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        { userId: string },
-        undefined,
-        undefined,
-        { name: string }
-      >
-    >()
-
-    expect(handler.zz$p.middlewares).toEqual([mid1, mid2])
-  })
-})

package/src/procedure-builder.ts

@@ -1,158 +0,0 @@
-import type { MapInputMiddleware, Middleware } from './middleware'
-import type { Context, MergeContext } from './types'
-import {
-  type ContractProcedure,
-  DecoratedContractProcedure,
-  type RouteOptions,
-  type Schema,
-  type SchemaInput,
-  type SchemaOutput,
-} from '@orpc/contract'
-import {
-  type DecoratedProcedure,
-  decorateProcedure,
-  type ProcedureFunc,
-} from './procedure'
-import { ProcedureImplementer } from './procedure-implementer'
-
-export class ProcedureBuilder<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-> {
-  constructor(
-    public zz$pb: {
-      contract: ContractProcedure<TInputSchema, TOutputSchema>
-      middlewares?: Middleware<any, any, any, any>[]
-    },
-  ) {}
-
-  /**
-   * Self chainable
-   */
-
-  route(
-    opts: RouteOptions,
-  ): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema> {
-    return new ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
-        opts,
-      ),
-    })
-  }
-
-  input<USchema extends Schema = undefined>(
-    schema: USchema,
-    example?: SchemaInput<USchema>,
-  ): ProcedureBuilder<TContext, TExtraContext, USchema, TOutputSchema> {
-    return new ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
-        schema,
-        example,
-      ),
-    })
-  }
-
-  output<USchema extends Schema = undefined>(
-    schema: USchema,
-    example?: SchemaOutput<USchema>,
-  ): ProcedureBuilder<TContext, TExtraContext, TInputSchema, USchema> {
-    return new ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
-        schema,
-        example,
-      ),
-    })
-  }
-
-  /**
-   * Convert to ProcedureBuilder
-   */
-
-  use<
-    UExtraContext extends
-    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-    | undefined = undefined,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      SchemaOutput<TInputSchema>,
-      SchemaInput<TOutputSchema>
-    >,
-  ): ProcedureImplementer<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInputSchema,
-    TOutputSchema
-  >
-
-  use<
-    UExtraContext extends
-    | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
-    | undefined = undefined,
-    UMappedInput = unknown,
-  >(
-    middleware: Middleware<
-      MergeContext<TContext, TExtraContext>,
-      UExtraContext,
-      UMappedInput,
-      SchemaInput<TOutputSchema>
-    >,
-    mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>,
-  ): ProcedureImplementer<
-    TContext,
-    MergeContext<TExtraContext, UExtraContext>,
-    TInputSchema,
-    TOutputSchema
-  >
-
-  use(
-    middleware: Middleware<any, any, any, any>,
-    mapInput?: MapInputMiddleware<any, any>,
-  ): ProcedureImplementer<any, any, any, any> {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares,
-      }).use(middleware)
-    }
-
-    return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares,
-    }).use(middleware, mapInput)
-  }
-
-  /**
-   * Convert to Procedure
-   */
-
-  func<UFuncOutput extends SchemaOutput<TOutputSchema>>(
-    func: ProcedureFunc<
-      TContext,
-      TExtraContext,
-      TInputSchema,
-      TOutputSchema,
-      UFuncOutput
-    >,
-  ): DecoratedProcedure<
-      TContext,
-      TExtraContext,
-      TInputSchema,
-      TOutputSchema,
-      UFuncOutput
-    > {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func,
-      },
-    })
-  }
-}

package/src/procedure-caller.test.ts

@@ -1,171 +0,0 @@
-import { z } from 'zod'
-import { createProcedureCaller, os } from '.'
-
-describe('createProcedureCaller', () => {
-  const path = ['ping']
-  const context = { auth: true }
-
-  const osw = os.context<{ auth?: boolean }>()
-  const procedure = 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)
-      expect(meta.path).toBe(path)
-
-      return input
-    })
-
-  it('infer context', () => {
-    createProcedureCaller({
-      procedure,
-      // @ts-expect-error invalid context
-      context: { auth: 123 },
-    })
-
-    createProcedureCaller({
-      procedure,
-      context,
-    })
-  })
-
-  it('with validate', async () => {
-    const caller = createProcedureCaller({
-      procedure,
-      context: async () => context,
-      path,
-    })
-
-    expectTypeOf(caller).toMatchTypeOf<
-      (input: { value: string }) => Promise<{
-        value: string
-      }>
-    >()
-
-    expect(await caller({ value: '123' })).toEqual({ value: '123' })
-
-    // @ts-expect-error - invalid input
-    expect(caller({ value: {} })).rejects.toThrowError(
-      'Validation input failed',
-    )
-  })
-
-  it('without validate and schema', () => {
-    const procedure = osw.func(() => {
-      return { value: true }
-    })
-
-    const caller = createProcedureCaller({
-      procedure,
-      context,
-    })
-
-    expectTypeOf(caller).toMatchTypeOf<
-      (value: unknown) => Promise<{ value: boolean }>
-    >()
-
-    expect(caller({ value: 123 })).resolves.toEqual({ value: true })
-  })
-
-  it('middlewares', () => {
-    const ref = { value: 0 }
-
-    const mid1 = vi.fn(
-      osw.middleware(async (input: { id: string }, context, meta) => {
-        expect(input).toEqual({ id: '1' })
-
-        expect(ref.value).toBe(0)
-        ref.value++
-
-        try {
-          const result = await meta.next({
-            context: {
-              userId: '1',
-            },
-          })
-          expect(ref.value).toBe(5)
-          ref.value++
-          return result
-        }
-        finally {
-          expect(ref.value).toBe(6)
-          ref.value++
-        }
-      }),
-    )
-
-    const mid2 = vi.fn(
-      osw.middleware(async (input, context, meta) => {
-        expect(ref.value).toBe(1)
-        ref.value++
-
-        try {
-          const result = await meta.next({})
-          expect(ref.value).toBe(3)
-          ref.value++
-          return result
-        }
-        finally {
-          expect(ref.value).toBe(4)
-          ref.value++
-        }
-      }),
-    )
-
-    const ping = osw
-      .input(z.object({ id: z.string() }))
-      .use(mid1)
-      .use(mid2)
-      .func((input, context, meta) => {
-        expect(context).toEqual({ userId: '1', auth: false })
-
-        expect(ref.value).toBe(2)
-        ref.value++
-
-        return 'pong'
-      })
-
-    const caller = createProcedureCaller({
-      procedure: ping,
-      context: { auth: false },
-    })
-
-    expect(caller({ id: '1' })).resolves.toEqual('pong')
-  })
-
-  it('accept form data', async () => {
-    const ping = osw
-      .input(z.object({ id: z.number() }))
-      .output(z.object({ id: z.number() }))
-      .func((input, context, meta) => {
-        expect(context).toEqual(context)
-
-        return input
-      })
-
-    const caller = createProcedureCaller({
-      procedure: ping,
-      context,
-    })
-
-    const form = new FormData()
-    form.append('id', '1')
-
-    expect(await caller(form)).toEqual({ id: 1 })
-  })
-
-  it('optional input when possible', async () => {
-    os.func(() => { })()
-    os.func(() => { })({})
-    // @ts-expect-error input is required
-    expect(os.input(z.string()).func(() => { })()).rejects.toThrow()
-    os.input(z.string().optional()).func(() => { })()
-    // @ts-expect-error input is required
-    expect(os.input(z.object({})).func(() => { })()).rejects.toThrow()
-    os.input(z.object({}).optional()).func(() => { })()
-    os.input(z.unknown()).func(() => { })()
-    os.input(z.any()).func(() => { })()
-    // @ts-expect-error input is required
-    expect(os.input(z.boolean()).func(() => { })()).rejects.toThrow()
-  })
-})

package/src/procedure-caller.ts

@@ -1,138 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract'
-import type { MiddlewareMeta } from './middleware'
-import type { Procedure } from './procedure'
-import type { Context } from './types'
-import { type Value, value } from '@orpc/shared'
-import { ORPCError } from '@orpc/shared/error'
-import { OpenAPIDeserializer } from '@orpc/transformer'
-import { mergeContext } from './utils'
-
-export interface CreateProcedureCallerOptions<
-  TProcedure extends Procedure<any, any, any, any, any>,
-> {
-  procedure: TProcedure
-
-  /**
-   * The context used when calling the procedure.
-   */
-  context: Value<
-    TProcedure extends Procedure<infer UContext, any, any, any, any>
-      ? UContext
-      : never
-  >
-
-  /**
-   * This is helpful for logging and analytics.
-   *
-   * @internal
-   */
-  path?: string[]
-}
-
-export type ProcedureCaller<
-  TProcedure extends Procedure<any, any, any, any, any>,
-> = TProcedure extends Procedure<
-  any,
-  any,
-  infer UInputSchema,
-  infer UOutputSchema,
-  infer UFuncOutput
->
-  ? (
-      ...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)
-    ) => Promise<
-      SchemaOutput<UOutputSchema, UFuncOutput>
-    >
-  : never
-
-export function createProcedureCaller<
-  TProcedure extends Procedure<any, any, any, any, any>,
->(
-  options: CreateProcedureCallerOptions<TProcedure>,
-): ProcedureCaller<TProcedure> {
-  const path = options.path ?? []
-  const procedure = options.procedure
-
-  const caller = async (input: unknown): Promise<unknown> => {
-    const input_ = (() => {
-      if (!(input instanceof FormData)) {
-        return input
-      }
-
-      const transformer = new OpenAPIDeserializer({
-        schema: procedure.zz$p.contract.zz$cp.InputSchema,
-      })
-
-      return transformer.deserializeAsFormData(input)
-    })()
-
-    const validInput = (() => {
-      const schema = procedure.zz$p.contract.zz$cp.InputSchema
-      if (!schema) {
-        return input_
-      }
-
-      try {
-        return schema.parse(input_)
-      }
-      catch (e) {
-        throw new ORPCError({
-          message: 'Validation input failed',
-          code: 'BAD_REQUEST',
-          cause: e,
-        })
-      }
-    })()
-
-    const middlewares = procedure.zz$p.middlewares ?? []
-    let currentMidIndex = 0
-    let currentContext: Context = await value(options.context)
-
-    const next: MiddlewareMeta<unknown>['next'] = async (nextOptions) => {
-      const mid = middlewares[currentMidIndex]
-      currentMidIndex += 1
-      currentContext = mergeContext(currentContext, nextOptions.context)
-
-      if (mid) {
-        return await mid(validInput, currentContext, {
-          path,
-          procedure,
-          next,
-          output: output => ({ output, context: undefined }),
-        })
-      }
-      else {
-        return {
-          output: await await procedure.zz$p.func(validInput, currentContext, {
-            path,
-            procedure,
-          }),
-          context: currentContext,
-        }
-      }
-    }
-
-    const output = (await next({})).output
-
-    const validOutput = await (async () => {
-      const schema = procedure.zz$p.contract.zz$cp.OutputSchema
-      if (!schema) {
-        return output
-      }
-
-      const result = await schema.safeParseAsync(output)
-      if (result.error) {
-        throw new ORPCError({
-          message: 'Validation output failed',
-          code: 'INTERNAL_SERVER_ERROR',
-          cause: result.error,
-        })
-      }
-      return result.data
-    })()
-
-    return validOutput
-  }
-
-  return caller as ProcedureCaller<TProcedure>
-}