@orpc/server 0.0.0

package/src/procedure.test.ts

@@ -0,0 +1,312 @@
+import { ContractProcedure, DecoratedContractProcedure } from '@orpc/contract'
+import { z } from 'zod'
+import { os, type Meta } from '.'
+import {
+  type DecoratedProcedure,
+  Procedure,
+  decorateProcedure,
+  isProcedure,
+} from './procedure'
+
+it('isProcedure', () => {
+  expect(
+    isProcedure(
+      decorateProcedure(
+        new Procedure({
+          contract: new ContractProcedure({
+            InputSchema: undefined,
+            OutputSchema: undefined,
+          }),
+          handler: () => {},
+        }),
+      ),
+    ),
+  ).toBe(true)
+  expect({
+    zz$p: {
+      contract: new DecoratedContractProcedure({
+        InputSchema: undefined,
+        OutputSchema: undefined,
+      }),
+      handler: () => {},
+    },
+  }).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 }>().handler(() => {
+      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 }>().handler(handler)
+
+    const p2 = p.route({ path: '/test' })
+
+    expect(p2.zz$p.handler).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' })
+      .handler(() => '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 = vi.fn(() => ({ context: { userId: '1' } }))
+
+    const p = os
+      .context<{ auth: boolean }>()
+      .route({ path: '/test' })
+      .use(mid)
+      .handler((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' })
+      .handler(() => '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' })
+      .handler((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
+      >
+    >()
+  })
+})
+
+test('prefix method', () => {
+  const p = os.context<{ auth: boolean }>().handler(() => {
+    return 'dinwwwh'
+  })
+
+  const p2 = p.prefix('/test')
+
+  expect(p2.zz$p.contract.zz$cp.path).toBe(undefined)
+
+  const p3 = os
+    .context<{ auth: boolean }>()
+    .route({ path: '/test1' })
+    .handler(() => {
+      return 'dinwwwh'
+    })
+
+  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(() => {
+        return { context: { postId: 'string' } }
+      })
+      .handler(() => {
+        return 'dinwwwh'
+      })
+
+    const p2 = p1
+      .use((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<
+          { auth: boolean } & { postId: string }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<string>>()
+
+        return {
+          context: {
+            userId: '1',
+          },
+        }
+      })
+      .use((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<
+          { userId: string } & { postId: string } & { auth: boolean }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<string>>()
+      })
+
+    expectTypeOf(p2).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        { postId: string } & { userId: string },
+        undefined,
+        undefined,
+        string
+      >
+    >()
+  })
+
+  it('can map input', () => {
+    const mid = (input: { id: number }) => {}
+
+    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).handler(() => 'dinwwwh')
+    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.handler(() => {})).toMatchTypeOf<(...args: any[]) => any>()
+    expectTypeOf(
+      os.context<{ auth: boolean } | undefined>().handler(() => {}),
+    ).toMatchTypeOf<(...args: any[]) => any>()
+    expectTypeOf(
+      os.context<{ auth: boolean }>().handler(() => {}),
+    ).not.toMatchTypeOf<(...args: any[]) => any>()
+  })
+
+  it('infer types', () => {
+    const p = os
+      .input(z.object({ id: z.number() }))
+      .output(z.string())
+      .handler(() => 'string')
+
+    expectTypeOf(p).toMatchTypeOf<
+      (input: { id: number } | FormData) => Promise<string>
+    >()
+
+    const p2 = os.input(z.object({ id: z.number() })).handler(() => 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() }))
+      .handler(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() }) }))
+      .handler(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') },
+    })
+  })
+})

package/src/procedure.ts

@@ -0,0 +1,251 @@
+import {
+  type ContractProcedure,
+  DecoratedContractProcedure,
+  type HTTPPath,
+  type SchemaInput,
+  type SchemaOutput,
+  isContractProcedure,
+} from '@orpc/contract'
+import type { RouteOptions, Schema } from '@orpc/contract'
+import { OpenAPIDeserializer } from '@orpc/transformer'
+import {
+  type MapInputMiddleware,
+  type Middleware,
+  decorateMiddleware,
+} from './middleware'
+import { createProcedureCaller } from './procedure-caller'
+import type { Context, MergeContext, Meta, Promisable } from './types'
+
+export class Procedure<
+  TContext extends Context,
+  TExtraContext extends Context,
+  TInputSchema extends Schema,
+  TOutputSchema extends Schema,
+  THandlerOutput extends SchemaOutput<TOutputSchema>,
+> {
+  constructor(
+    public zz$p: {
+      middlewares?: Middleware<any, any, any, any>[]
+      contract: ContractProcedure<TInputSchema, TOutputSchema>
+      handler: ProcedureHandler<
+        TContext,
+        TExtraContext,
+        TInputSchema,
+        TOutputSchema,
+        THandlerOutput
+      >
+    },
+  ) {}
+}
+
+export type DecoratedProcedure<
+  TContext extends Context,
+  TExtraContext extends Context,
+  TInputSchema extends Schema,
+  TOutputSchema extends Schema,
+  THandlerOutput extends SchemaOutput<TOutputSchema>,
+> = Procedure<
+  TContext,
+  TExtraContext,
+  TInputSchema,
+  TOutputSchema,
+  THandlerOutput
+> & {
+  prefix(
+    prefix: HTTPPath,
+  ): DecoratedProcedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  >
+
+  route(
+    opts: RouteOptions,
+  ): DecoratedProcedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  >
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      SchemaOutput<TInputSchema>,
+      SchemaOutput<TOutputSchema, THandlerOutput>
+    >,
+  ): DecoratedProcedure<
+    TContext,
+    MergeContext<TExtraContext, UExtraContext>,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  >
+
+  use<
+    UExtraContext extends
+      | Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>>
+      | undefined = undefined,
+    UMappedInput = unknown,
+  >(
+    middleware: Middleware<
+      MergeContext<TContext, TExtraContext>,
+      UExtraContext,
+      UMappedInput,
+      SchemaOutput<TOutputSchema, THandlerOutput>
+    >,
+    mapInput: MapInputMiddleware<
+      SchemaOutput<TInputSchema, THandlerOutput>,
+      UMappedInput
+    >,
+  ): DecoratedProcedure<
+    TContext,
+    MergeContext<TExtraContext, UExtraContext>,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  >
+} & (undefined extends TContext
+    ? (
+        input: SchemaInput<TInputSchema> | FormData,
+      ) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>
+    : // biome-ignore lint/complexity/noBannedTypes: {} seem has no side-effect on this case
+      {})
+
+export interface ProcedureHandler<
+  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<unknown>,
+  ): 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,
+  THandlerOutput extends SchemaOutput<TOutputSchema>,
+>(
+  procedure: Procedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    THandlerOutput
+  >,
+): DecoratedProcedure<
+  TContext,
+  TExtraContext,
+  TInputSchema,
+  TOutputSchema,
+  THandlerOutput
+> {
+  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
+    return procedure as any
+  }
+
+  const serverAction = async (input: 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 procedureCaller = createProcedureCaller({
+      procedure,
+      context: undefined as any,
+      internal: false,
+      validate: true,
+    })
+
+    return await procedureCaller(input_ as any)
+  }
+
+  return Object.assign(serverAction, {
+    [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) &&
+    'handler' in item.zz$p &&
+    typeof item.zz$p.handler === 'function'
+  )
+}

package/src/router-builder.test.ts

@@ -0,0 +1,106 @@
+import { ContractProcedure } from '@orpc/contract'
+import { z } from 'zod'
+import { os, Procedure, decorateProcedure, isProcedure } from '.'
+import { RouterBuilder } from './router-builder'
+
+const builder = new RouterBuilder<undefined, undefined>({})
+const ping = os
+  .route({ method: 'GET', path: '/ping', tags: ['ping'] })
+  .handler(() => 'ping')
+const pong = os
+  .output(z.object({ id: z.string() }))
+  .handler(() => ({ 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: 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: 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: 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,
+      }),
+      handler: () => {},
+    })
+
+    const decorated = decorateProcedure({
+      zz$p: {
+        contract: new ContractProcedure({
+          InputSchema: undefined,
+          OutputSchema: undefined,
+        }),
+        handler: () => {},
+      },
+    })
+
+    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)
+  })
+})