@orpc/server 0.0.0

package/src/procedure-builder.test.ts

@@ -0,0 +1,219 @@
+import { ContractProcedure } from '@orpc/contract'
+import { z } from 'zod'
+import { type DecoratedProcedure, isProcedure } from './procedure'
+import { ProcedureBuilder } from './procedure-builder'
+import type { ProcedureImplementer } from './procedure-implementer'
+import type { Meta } from './types'
+
+const schema1 = z.object({ id: z.string() })
+const example1 = { id: '1' }
+const schema2 = z.object({ name: z.string() })
+const example2 = { name: 'dinwwwh' }
+
+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<Meta<unknown>>()
+
+        return {
+          context: {
+            userId: '1',
+          },
+        }
+      })
+      .use((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<
+          { userId: string } & { auth: boolean }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+      })
+
+    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 }) => {
+        return { context: { a: 'a' } }
+      },
+      // @ts-expect-error mismatch input
+      (input) => ({ postId: 12455 }),
+    )
+
+    builder.use(
+      (input: { postId: string }) => {},
+      (input) => ({ postId: '12455' }),
+    )
+
+    const implementer = builder.input(schema1).use(
+      (input: { id: number }) => {
+        return {
+          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.handler((input, context, meta) => {
+      expectTypeOf(input).toEqualTypeOf<unknown>()
+      expectTypeOf(context).toEqualTypeOf<{ auth: boolean }>()
+      expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+    })
+
+    expectTypeOf(handler).toEqualTypeOf<
+      DecoratedProcedure<
+        { auth: boolean },
+        undefined,
+        undefined,
+        undefined,
+        void
+      >
+    >()
+
+    expect(isProcedure(handler)).toBe(true)
+  })
+
+  it('combine middlewares', () => {
+    const mid1 = () => {
+      return {
+        context: {
+          userId: '1',
+        },
+      }
+    }
+
+    const mid2 = () => {}
+
+    const handler = builder
+      .use(mid1)
+      .use(mid2)
+      .handler((input, context, meta) => {
+        expectTypeOf(input).toEqualTypeOf<unknown>()
+        expectTypeOf(context).toEqualTypeOf<
+          { userId: string } & { auth: boolean }
+        >()
+        expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
+
+        return {
+          name: 'dinwwwh',
+        }
+      })
+
+    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

@@ -0,0 +1,158 @@
+import {
+  type ContractProcedure,
+  DecoratedContractProcedure,
+  type RouteOptions,
+  type Schema,
+  type SchemaInput,
+  type SchemaOutput,
+} from '@orpc/contract'
+import type { MapInputMiddleware, Middleware } from './middleware'
+import {
+  type DecoratedProcedure,
+  type ProcedureHandler,
+  decorateProcedure,
+} from './procedure'
+import { ProcedureImplementer } from './procedure-implementer'
+import type { Context, MergeContext } from './types'
+
+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>,
+      SchemaOutput<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,
+      SchemaOutput<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
+   */
+
+  handler<UHandlerOutput extends SchemaOutput<TOutputSchema>>(
+    handler: ProcedureHandler<
+      TContext,
+      TExtraContext,
+      TInputSchema,
+      TOutputSchema,
+      UHandlerOutput
+    >,
+  ): DecoratedProcedure<
+    TContext,
+    TExtraContext,
+    TInputSchema,
+    TOutputSchema,
+    UHandlerOutput
+  > {
+    return decorateProcedure({
+      zz$p: {
+        middlewares: this.zz$pb.middlewares,
+        contract: this.zz$pb.contract,
+        handler,
+      },
+    })
+  }
+}

package/src/procedure-caller.test.ts

@@ -0,0 +1,210 @@
+import { z } from 'zod'
+import { os, createProcedureCaller } from '.'
+
+describe('createProcedureCaller', () => {
+  let internal = false
+  let path = ['ping']
+  let 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()) }))
+    .handler((input, context, meta) => {
+      expect(context).toEqual(context)
+      expect(meta.internal).toBe(internal)
+      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,
+      internal,
+      path,
+    })
+
+    expectTypeOf(caller).toMatchTypeOf<
+      (input: { value: string }) => Promise<{
+        value: string
+      }>
+    >()
+
+    expect(await caller({ value: '123' })).toEqual({ value: '123' })
+
+    // @ts-expect-error
+    expect(caller({ value: {} })).rejects.toThrowError(
+      'Validation input failed',
+    )
+  })
+
+  it('without validate', async () => {
+    internal = true
+    path = []
+    context = { auth: false }
+
+    const caller = createProcedureCaller({
+      procedure,
+      context,
+      internal,
+      path,
+      validate: false,
+    })
+
+    expectTypeOf(caller).toMatchTypeOf<
+      (input: { value: number }) => Promise<{
+        value: number
+      }>
+    >()
+
+    expect(await caller({ value: 123 })).toEqual({ value: 123 })
+
+    // @ts-expect-error it's not validate so bellow still works
+    expect(await caller({ value: '123' })).toEqual({ value: '123' })
+  })
+
+  it('without validate and schema', () => {
+    const procedure = osw.handler(() => {
+      return { value: true }
+    })
+
+    const caller = createProcedureCaller({
+      procedure,
+      context,
+      internal,
+      validate: false,
+    })
+
+    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((input: { id: string }, context, meta) => {
+        expect(input).toEqual({ id: '1' })
+
+        expect(ref.value).toBe(0)
+        ref.value++
+
+        meta.onSuccess(() => {
+          expect(ref.value).toBe(7)
+          ref.value++
+        })
+
+        meta.onFinish(() => {
+          expect(ref.value).toBe(8)
+          ref.value++
+        })
+
+        return {
+          context: {
+            userId: '1',
+          },
+        }
+      }),
+    )
+
+    const mid2 = vi.fn(
+      osw.middleware((input, context, meta) => {
+        expect(ref.value).toBe(1)
+        ref.value++
+
+        meta.onSuccess(() => {
+          expect(ref.value).toBe(5)
+          ref.value++
+        })
+
+        meta.onFinish(() => {
+          expect(ref.value).toBe(6)
+          ref.value++
+        })
+      }),
+    )
+
+    const ping = osw
+      .input(z.object({ id: z.string() }))
+      .use(mid1)
+      .use(mid2)
+      .handler((input, context, meta) => {
+        expect(context).toEqual({ userId: '1', auth: false })
+
+        expect(ref.value).toBe(2)
+        ref.value++
+
+        meta.onSuccess(() => {
+          expect(ref.value).toBe(3)
+          ref.value++
+        })
+
+        meta.onFinish(() => {
+          expect(ref.value).toBe(4)
+          ref.value++
+        })
+
+        return 'pong'
+      })
+
+    const caller = createProcedureCaller({
+      procedure: ping,
+      context: { auth: false },
+    })
+
+    expect(caller({ id: '1' })).resolves.toEqual('pong')
+  })
+
+  it('hooks', async () => {
+    const ref = { value: 0 }
+
+    const caller = createProcedureCaller({
+      procedure: procedure,
+      context: context,
+      internal: internal,
+      path: path,
+      hooks: (context, meta) => {
+        expect(context).toEqual(context)
+        expect(meta.internal).toBe(internal)
+        expect(meta.path).toBe(path)
+        expect(meta.procedure).toBe(procedure)
+
+        expect(ref.value).toBe(0)
+        ref.value++
+
+        meta.onSuccess(() => {
+          expect(ref.value).toBe(1)
+          ref.value++
+        })
+
+        meta.onFinish(() => {
+          expect(ref.value).toBe(2)
+          ref.value++
+
+          throw new Error('foo')
+        })
+      },
+    })
+
+    await expect(caller({ value: '1243' })).rejects.toThrow('foo')
+    expect(ref.value).toBe(3)
+  })
+})