@orpc/server 0.10.0 → 0.11.0

package/src/procedure-implementer.test.ts

@@ -1,220 +0,0 @@
-import type { DecoratedProcedure, Meta, MiddlewareMeta } from '.'
-import { DecoratedContractProcedure } from '@orpc/contract'
-import { z } from 'zod'
-import { isProcedure, os } from '.'
-import { ProcedureImplementer } from './procedure-implementer'
-
-const p1 = new DecoratedContractProcedure({
-  InputSchema: undefined,
-  OutputSchema: undefined,
-  method: undefined,
-  path: undefined,
-})
-const implementer1 = new ProcedureImplementer<
-  { auth: boolean },
-  undefined,
-  undefined,
-  undefined
->({ contract: p1 })
-
-const schema1 = z.object({ id: z.string() })
-const schema2 = z.object({ name: z.string() })
-
-const p2 = new DecoratedContractProcedure({
-  InputSchema: schema1,
-  OutputSchema: schema2,
-  method: 'GET',
-  path: '/test',
-})
-
-const implementer2 = new ProcedureImplementer<
-  { auth: boolean },
-  undefined,
-  typeof schema1,
-  typeof schema2
->({ contract: p2 })
-
-describe('use middleware', () => {
-  it('infer types', () => {
-    const i = implementer1
-      .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(i).toEqualTypeOf<
-      ProcedureImplementer<
-        { auth: boolean },
-        { userId: string },
-        undefined,
-        undefined
-      >
-    >()
-  })
-
-  it('map middleware input', () => {
-    // @ts-expect-error mismatch input
-    implementer2.use((input: { postId: string }) => {
-      return { context: { a: 'a' } }
-    })
-
-    implementer2.use(
-      (input: { postId: string }, _, meta) => {
-        return meta.next({ context: { a: 'a' } })
-      },
-      // @ts-expect-error mismatch input
-      input => ({ postId: 12455 }),
-    )
-
-    implementer2.use(
-      (input: { postId: string }, context, meta) => meta.next({}),
-      input => ({ postId: '12455' }),
-    )
-
-    const i = implementer2.use(
-      (input: { id: number }, _, meta) => {
-        return meta.next({
-          context: {
-            userIdd: '1',
-          },
-        })
-      },
-      input => ({ id: Number.parseInt(input.id) }),
-    )
-
-    expectTypeOf(i).toEqualTypeOf<
-      ProcedureImplementer<
-        { auth: boolean },
-        { userIdd: string },
-        typeof schema1,
-        typeof schema2
-      >
-    >()
-  })
-})
-
-describe('output schema', () => {
-  it('auto infer output schema if output schema is not specified', async () => {
-    const sr = os.func(() => ({ a: 1 }))
-
-    const result = await sr.zz$p.func({}, undefined, {
-      method: 'GET',
-      path: '/',
-    } as any)
-
-    expectTypeOf(result).toEqualTypeOf<{ a: number }>()
-  })
-
-  it('not infer output schema if output schema is specified', async () => {
-    const srb1 = new ProcedureImplementer({
-      contract: new DecoratedContractProcedure({
-        OutputSchema: z.unknown(),
-        InputSchema: undefined,
-      }),
-    })
-
-    const sr = srb1.func(() => ({ b: 1 }))
-
-    const result = await sr.zz$p.func({}, {}, {
-      method: 'GET',
-      path: '/',
-    } as any)
-
-    expectTypeOf(result).toEqualTypeOf<unknown>()
-  })
-})
-
-describe('handler', () => {
-  it('infer types', () => {
-    const handler = implementer1.func((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<unknown>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta>()
-
-      return {
-        name: 'unnoq',
-      }
-    })
-
-    expectTypeOf(handler).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        undefined,
-        undefined,
-        undefined,
-        { name: string }
-      >
-    >()
-    expect(isProcedure(handler)).toBe(true)
-
-    implementer2.func((input, context, meta) => {
-      expectTypeOf(input).toEqualTypeOf<{ id: string }>()
-      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
-      expectTypeOf(meta).toEqualTypeOf<Meta>()
-
-      return {
-        name: 'unnoq',
-      }
-    })
-
-    // @ts-expect-error mismatch output
-    implementer2.func(() => {})
-  })
-
-  it('combine middlewares', () => {
-    const mid1 = os.middleware((input, context, meta) => {
-      return meta.next({
-        context: {
-          userId: '1',
-        },
-      })
-    })
-
-    const mid2 = os.middleware((input, context, meta) => {
-      return meta.next({ })
-    })
-
-    const handler = implementer2
-      .use(mid1)
-      .use(mid2)
-      .func((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<{ id: string }>()
-        expectTypeOf(context).toEqualTypeOf<
-          { auth: boolean } & { userId: string }
-        >()
-        expectTypeOf(meta).toEqualTypeOf<Meta>()
-
-        return {
-          name: 'unnoq',
-        }
-      })
-
-    expectTypeOf(handler).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        { userId: string },
-        typeof schema1,
-        typeof schema2,
-        { name: string }
-      >
-    >()
-
-    expect(handler.zz$p.middlewares).toEqual([mid1, mid2])
-  })
-})

package/src/procedure-implementer.ts

@@ -1,102 +0,0 @@
-import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract'
-import type { Context, MergeContext } from './types'
-import {
-  decorateMiddleware,
-  type MapInputMiddleware,
-  type Middleware,
-} from './middleware'
-import {
-  type DecoratedProcedure,
-  decorateProcedure,
-  type ProcedureFunc,
-} from './procedure'
-
-export class ProcedureImplementer<
-  TContext extends Context,
-  TExtraContext extends Context,
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-> {
-  constructor(
-    public zz$pi: {
-      contract: ContractProcedure<TInputSchema, TOutputSchema>
-      middlewares?: Middleware<any, any, any, any>[]
-    },
-  ) {}
-
-  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> {
-    const middleware_ = mapInput
-      ? decorateMiddleware(middleware).mapInput(mapInput)
-      : middleware
-
-    return new ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...(this.zz$pi.middlewares ?? []), middleware_],
-    })
-  }
-
-  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$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func,
-      },
-    })
-  }
-}

package/src/procedure.test.ts

@@ -1,317 +0,0 @@
-import type { MiddlewareMeta } from '.'
-import { ContractProcedure, DecoratedContractProcedure } from '@orpc/contract'
-import { z } from 'zod'
-import { os } from '.'
-import {
-  type DecoratedProcedure,
-  decorateProcedure,
-  isProcedure,
-  Procedure,
-} from './procedure'
-
-it('isProcedure', () => {
-  expect(
-    isProcedure(
-      decorateProcedure(
-        new Procedure({
-          contract: new ContractProcedure({
-            InputSchema: undefined,
-            OutputSchema: undefined,
-          }),
-          func: () => {},
-        }),
-      ),
-    ),
-  ).toBe(true)
-  expect({
-    zz$p: {
-      contract: new DecoratedContractProcedure({
-        InputSchema: undefined,
-        OutputSchema: undefined,
-      }),
-      func: () => {},
-    },
-  }).toSatisfy(isProcedure)
-
-  expect({
-    zz$p: {
-      contract: new DecoratedContractProcedure({
-        InputSchema: undefined,
-        OutputSchema: undefined,
-      }),
-    },
-  }).not.toSatisfy(isProcedure)
-
-  expect({
-    zz$p: {
-      handler: () => {},
-    },
-  }).not.toSatisfy(isProcedure)
-
-  expect({}).not.toSatisfy(isProcedure)
-  expect(12233).not.toSatisfy(isProcedure)
-  expect('12233').not.toSatisfy(isProcedure)
-  expect(undefined).not.toSatisfy(isProcedure)
-  expect(null).not.toSatisfy(isProcedure)
-})
-
-describe('route method', () => {
-  it('sets route options correctly', () => {
-    const p = os.context<{ auth: boolean }>().func(() => {
-      return 'test'
-    })
-
-    const p2 = p.route({ path: '/test', method: 'GET' })
-
-    expect(p2.zz$p.contract.zz$cp.path).toBe('/test')
-    expect(p2.zz$p.contract.zz$cp.method).toBe('GET')
-  })
-
-  it('preserves existing context and handler', () => {
-    const handler = () => 'test'
-    const p = os.context<{ auth: boolean }>().func(handler)
-
-    const p2 = p.route({ path: '/test' })
-
-    expect(p2.zz$p.func).toBe(handler)
-    // Context type is preserved through the route method
-    expectTypeOf(p2).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        undefined,
-        undefined,
-        undefined,
-        string
-      >
-    >()
-  })
-
-  it('works with prefix method', () => {
-    const p = os
-      .context<{ auth: boolean }>()
-      .route({ path: '/api', method: 'POST' })
-      .func(() => 'test')
-
-    const p2 = p.prefix('/v1')
-
-    expect(p2.zz$p.contract.zz$cp.path).toBe('/v1/api')
-    expect(p2.zz$p.contract.zz$cp.method).toBe('POST')
-  })
-
-  it('works with middleware', () => {
-    const mid = os.middleware((_, __, meta) => meta.next({ context: { userId: '1' } }))
-
-    const p = os
-      .context<{ auth: boolean }>()
-      .route({ path: '/test' })
-      .use(mid)
-      .func((input, context) => {
-        expectTypeOf(context).toEqualTypeOf<
-          { auth: boolean } & { userId: string }
-        >()
-        return 'test'
-      })
-
-    expect(p.zz$p.contract.zz$cp.path).toBe('/test')
-    expect(p.zz$p.middlewares).toEqual([mid])
-  })
-
-  it('overrides existing route options', () => {
-    const p = os
-      .context<{ auth: boolean }>()
-      .route({ path: '/test1', method: 'GET' })
-      .func(() => 'test')
-
-    const p2 = p.route({ path: '/test2', method: 'POST' })
-
-    expect(p2.zz$p.contract.zz$cp.path).toBe('/test2')
-    expect(p2.zz$p.contract.zz$cp.method).toBe('POST')
-  })
-
-  it('preserves input/output schemas', () => {
-    const inputSchema = z.object({ id: z.number() })
-    const outputSchema = z.string()
-    const p = os
-      .context<{ auth: boolean }>()
-      .input(inputSchema)
-      .output(outputSchema)
-      .route({ path: '/test' })
-      .func((input) => {
-        expectTypeOf(input).toEqualTypeOf<{ id: number }>()
-        return 'test'
-      })
-
-    const p2 = p.route({ path: '/test2' })
-
-    // Type checking that schemas are preserved
-    expectTypeOf(p2).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        undefined,
-        typeof inputSchema,
-        typeof outputSchema,
-        string
-      >
-    >()
-  })
-})
-
-it('prefix method', () => {
-  const p = os.context<{ auth: boolean }>().func(() => {
-    return 'unnoq'
-  })
-
-  const p2 = p.prefix('/test')
-
-  expect(p2.zz$p.contract.zz$cp.path).toBe(undefined)
-
-  const p3 = os
-    .context<{ auth: boolean }>()
-    .route({ path: '/test1' })
-    .func(() => {
-      return 'unnoq'
-    })
-
-  const p4 = p3.prefix('/test')
-  expect(p4.zz$p.contract.zz$cp.path).toBe('/test/test1')
-})
-
-describe('use middleware', () => {
-  it('infer types', () => {
-    const p1 = os
-      .context<{ auth: boolean }>()
-      .use((_, __, meta) => {
-        return meta.next({ context: { postId: 'string' } })
-      })
-      .func(() => {
-        return 'unnoq'
-      })
-
-    const p2 = p1
-      .use((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<unknown>()
-        expectTypeOf(context).toEqualTypeOf<
-          { auth: boolean } & { postId: string }
-        >()
-        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<string>>()
-
-        return meta.next({
-          context: {
-            userId: '1',
-          },
-        })
-      })
-      .use((input, context, meta) => {
-        expectTypeOf(input).toEqualTypeOf<unknown>()
-        expectTypeOf(context).toEqualTypeOf<
-          { userId: string } & { postId: string } & { auth: boolean }
-        >()
-        expectTypeOf(meta).toEqualTypeOf<MiddlewareMeta<string>>()
-
-        return meta.next({})
-      })
-
-    expectTypeOf(p2).toEqualTypeOf<
-      DecoratedProcedure<
-        { auth: boolean },
-        { postId: string } & { userId: string },
-        undefined,
-        undefined,
-        string
-      >
-    >()
-  })
-
-  it('can map input', () => {
-    const mid = os.middleware((input: { id: number }, __, meta) => {
-      return meta.next({})
-    })
-
-    os.input(z.object({ postId: z.number() })).use(mid, (input) => {
-      expectTypeOf(input).toEqualTypeOf<{ postId: number }>()
-
-      return {
-        id: input.postId,
-      }
-    })
-
-    // @ts-expect-error mismatch input
-    os.input(z.object({ postId: z.number() })).use(mid)
-
-    // @ts-expect-error mismatch input
-    os.input(z.object({ postId: z.number() })).use(mid, (input) => {
-      return {
-        wrong: input.postId,
-      }
-    })
-  })
-
-  it('add middlewares to beginning', () => {
-    const mid1 = vi.fn()
-    const mid2 = vi.fn()
-    const mid3 = vi.fn()
-
-    const p1 = os.use(mid1).func(() => 'unnoq')
-    const p2 = p1.use(mid2).use(mid3)
-
-    expect(p2.zz$p.middlewares).toEqual([mid3, mid2, mid1])
-  })
-})
-
-describe('server action', () => {
-  it('only accept undefined context', () => {
-    expectTypeOf(os.func(() => {})).toMatchTypeOf<(...args: any[]) => any>()
-    expectTypeOf(
-      os.context<{ auth: boolean } | undefined>().func(() => {}),
-    ).toMatchTypeOf<(...args: any[]) => any>()
-    expectTypeOf(
-      os.context<{ auth: boolean }>().func(() => {}),
-    ).not.toMatchTypeOf<(...args: any[]) => any>()
-  })
-
-  it('infer types', () => {
-    const p = os
-      .input(z.object({ id: z.number() }))
-      .output(z.string())
-      .func(() => 'string')
-
-    expectTypeOf(p).toMatchTypeOf<
-      (input: { id: number } | FormData) => Promise<string>
-    >()
-
-    const p2 = os.input(z.object({ id: z.number() })).func(() => 12333)
-
-    expectTypeOf(p2).toMatchTypeOf<
-      (input: { id: number } | FormData) => Promise<number>
-    >()
-  })
-
-  it('works with input', async () => {
-    const p = os
-      .input(z.object({ id: z.number(), date: z.date() }))
-      .func(async (input, context) => {
-        expect(context).toBe(undefined)
-        return input
-      })
-
-    expect(await p({ id: 123, date: new Date('2022-01-01') })).toEqual({
-      id: 123,
-      date: new Date('2022-01-01'),
-    })
-  })
-
-  it('can deserialize form data', async () => {
-    const p = os
-      .input(z.object({ id: z.number(), nested: z.object({ date: z.date() }) }))
-      .func(async input => input)
-
-    const form = new FormData()
-    form.append('id', '123')
-    form.append('nested[date]', '2022-01-01')
-
-    expect(await p(form)).toEqual({
-      id: 123,
-      nested: { date: new Date('2022-01-01') },
-    })
-  })
-})