feat(contract): implement .errors in every builder (#86)

* remove undefine value from ErrorMap

* errors now can define multiple time, and merged

* guard error map

* contract: .errors for router builder

* improve error map

* server: procedure allow define .errors multiple time

* router builder

* router implementer

* fixed

Author: dinwwwh

packages/client/src/client.ts

@@ -9,10 +9,10 @@ export interface createORPCClientOptions {
   path?: string[]
 }
 
-export function createORPCClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext = unknown>(
+export function createORPCClient<TRouter extends ANY_ROUTER | ContractRouter<any>, TClientContext = unknown>(
   link: ClientLink<TClientContext>,
   options?: createORPCClientOptions,
-): TRouter extends ContractRouter
+): TRouter extends ContractRouter<any>
     ? ContractRouterClient<TRouter, TClientContext>
     : TRouter extends ANY_ROUTER // put this in lower priority than ContractRouter, will make createORPCClient can work without @orpc/server
       ? RouterClient<TRouter, TClientContext>

packages/contract/src/builder.test-d.ts

@@ -1,15 +1,56 @@
 import type { DecoratedContractProcedure } from './procedure-decorated'
-import type { ContractRouterBuilder } from './router-builder'
+import type { AdaptedContractRouter, ContractRouterBuilder } from './router-builder'
 import { z } from 'zod'
 import { ContractBuilder } from './builder'
 import { ContractProcedure } from './procedure'
 
-const builder = new ContractBuilder()
+const schema = z.object({
+  value: z.string(),
+})
+
+const baseErrorMap = {
+  BASE: {
+    status: 500,
+    data: z.object({
+      message: z.string(),
+    }),
+  },
+}
+
+const builder = new ContractBuilder({ errorMap: baseErrorMap })
+
+describe('self chainable', () => {
+  describe('errors', () => {
+    const errors = {
+      BAD: {
+        status: 500,
+        data: schema,
+      },
+      ERROR2: {
+        status: 401,
+        data: schema,
+      },
+    } as const
+
+    it('should merge and strict with old one', () => {
+      expectTypeOf(builder.errors(errors)).toEqualTypeOf<
+        ContractBuilder<typeof errors & typeof baseErrorMap>
+      >()
+    })
+
+    it('should prevent redefine errorMap', () => {
+      // @ts-expect-error - not allow redefine errorMap
+      builder.errors({ BASE: baseErrorMap.BASE })
+      // @ts-expect-error - not allow redefine errorMap - even with undefined
+      builder.errors({ BASE: undefined })
+    })
+  })
+})
 
 describe('to ContractRouterBuilder', () => {
   it('prefix', () => {
     expectTypeOf(builder.prefix('/prefix')).toEqualTypeOf<
-      ContractRouterBuilder
+      ContractRouterBuilder<typeof baseErrorMap>
     >()
 
     // @ts-expect-error - invalid prefix
@@ -20,7 +61,7 @@ describe('to ContractRouterBuilder', () => {
 
   it('tags', () => {
     expectTypeOf(builder.tag('tag1', 'tag2')).toEqualTypeOf<
-      ContractRouterBuilder
+      ContractRouterBuilder<typeof baseErrorMap>
     >()
 
     // @ts-expect-error - invalid tag
@@ -33,11 +74,11 @@ describe('to ContractRouterBuilder', () => {
 describe('to DecoratedContractProcedure', () => {
   it('route', () => {
     expectTypeOf(builder.route({ method: 'GET', path: '/path' })).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, undefined, undefined>
+      DecoratedContractProcedure<undefined, undefined, typeof baseErrorMap>
     >()
 
     expectTypeOf(builder.route({ })).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, undefined, undefined>
+      DecoratedContractProcedure<undefined, undefined, typeof baseErrorMap>
     >()
 
     // @ts-expect-error - invalid method
@@ -46,17 +87,13 @@ describe('to DecoratedContractProcedure', () => {
     builder.route({ method: 'GET', path: '' })
   })
 
-  const schema = z.object({
-    value: z.string(),
-  })
-
   it('input', () => {
     expectTypeOf(builder.input(schema)).toEqualTypeOf<
-      DecoratedContractProcedure<typeof schema, undefined, undefined>
+      DecoratedContractProcedure<typeof schema, undefined, typeof baseErrorMap>
     >()
 
     expectTypeOf(builder.input(schema, { value: 'example' })).toEqualTypeOf<
-      DecoratedContractProcedure<typeof schema, undefined, undefined>
+      DecoratedContractProcedure<typeof schema, undefined, typeof baseErrorMap>
     >()
 
     // @ts-expect-error - invalid schema
@@ -68,11 +105,11 @@ describe('to DecoratedContractProcedure', () => {
 
   it('output', () => {
     expectTypeOf(builder.output(schema)).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, typeof schema, undefined>
+      DecoratedContractProcedure<undefined, typeof schema, typeof baseErrorMap>
     >()
 
     expectTypeOf(builder.output(schema, { value: 'example' })).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, typeof schema, undefined>
+      DecoratedContractProcedure<undefined, typeof schema, typeof baseErrorMap>
     >()
 
     // @ts-expect-error - invalid schema
@@ -81,54 +118,39 @@ describe('to DecoratedContractProcedure', () => {
     // @ts-expect-error - invalid example
     builder.output(schema, {})
   })
-
-  it('errors', () => {
-    const errors = {
-      BAD: {
-        status: 500,
-        data: schema,
-      },
-      ERROR2: {
-        status: 401,
-        data: schema,
-      },
-    } as const
-
-    expectTypeOf(builder.errors(errors)).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, undefined, typeof errors>
-    >()
-
-    expectTypeOf(builder.output(schema, { value: 'example' })).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, typeof schema, undefined>
-    >()
-
-    // @ts-expect-error - invalid schema
-    builder.errors({ UNAUTHORIZED: { data: {} } })
-  })
 })
 
 describe('to router', () => {
-  const router = {
-    a: {
-      b: {
-        c: new ContractProcedure({ InputSchema: undefined, OutputSchema: undefined, errorMap: undefined }),
-      },
+  const errors = {
+    CONFLICT: {
+      status: 400,
+      data: z.object({
+        message: z.string(),
+      }),
     },
   }
 
-  const emptyRouter = {
+  const router = { a: { b: {
+    c: new ContractProcedure({ InputSchema: undefined, OutputSchema: undefined, errorMap: errors }),
+  } } }
 
-  }
+  it('adapt all procedures', () => {
+    expectTypeOf(builder.router(router)).toEqualTypeOf<AdaptedContractRouter<typeof router, typeof baseErrorMap>>()
+    expectTypeOf(builder.router({})).toEqualTypeOf<Record<never, never>>()
 
-  const invalidRouter = {
-    a: 1,
-  }
+    // @ts-expect-error - invalid router
+    builder.router({ a: 1 })
+  })
 
-  it('router', () => {
-    expectTypeOf(builder.router(router)).toEqualTypeOf<typeof router>()
-    expectTypeOf(builder.router(emptyRouter)).toEqualTypeOf<typeof emptyRouter>()
+  it('throw on conflict error map', () => {
+    builder.router({ ping: {} as ContractProcedure<any, any, { BASE: typeof baseErrorMap['BASE'] }> })
+    // @ts-expect-error conflict
+    builder.router({ ping: {} as ContractProcedure<any, any, { BASE: { message: string } }> })
+  })
 
-    // @ts-expect-error - invalid router
-    builder.router(invalidRouter)
+  it('only required partial match error map', () => {
+    expectTypeOf(builder.router({ ping: {} as ContractProcedure<any, any, { OTHER: { status: number } }> })).toEqualTypeOf<{
+      ping: DecoratedContractProcedure<any, any, { OTHER: { status: number } } & typeof baseErrorMap>
+    }>()
   })
 })

packages/contract/src/builder.test.ts

@@ -16,14 +16,48 @@ beforeEach(() => {
   vi.clearAllMocks()
 })
 
-describe('to ContractRouterBuilder', () => {
-  const builder = new ContractBuilder()
+const baseErrorMap = {
+  BASE: {
+    status: 500,
+    data: z.object({
+      message: z.string(),
+    }),
+  },
+}
+
+const builder = new ContractBuilder({ errorMap: baseErrorMap })
+
+const schema = z.object({ val: z.string().transform(val => Number(val)) })
+
+describe('self chainable', () => {
+  it('errors', () => {
+    const errors = {
+      BAD: {
+        status: 500,
+        data: schema,
+      },
+    }
+
+    const applied = builder.errors(errors)
+
+    expect(applied).not.toBe(builder)
+    expect(applied).toBeInstanceOf(ContractBuilder)
+    expect(applied['~orpc']).toEqual({
+      errorMap: {
+        ...baseErrorMap,
+        ...errors,
+      },
+    })
+  })
+})
 
+describe('to ContractRouterBuilder', () => {
   it('prefix', () => {
     expect(builder.prefix('/prefix')).toBeInstanceOf(ContractRouterBuilder)
 
     expect(ContractRouterBuilder).toHaveBeenCalledWith({
       prefix: '/prefix',
+      errorMap: baseErrorMap,
     })
   })
 
@@ -32,19 +66,18 @@ describe('to ContractRouterBuilder', () => {
 
     expect(ContractRouterBuilder).toHaveBeenCalledWith({
       tags: ['tag1', 'tag2'],
+      errorMap: baseErrorMap,
     })
   })
 })
 
 describe('to DecoratedContractProcedure', () => {
-  const builder = new ContractBuilder()
-
   it('route', () => {
     const route = { method: 'GET', path: '/path' } as const
     const procedure = builder.route(route)
 
     expect(procedure).toBeInstanceOf(DecoratedContractProcedure)
-    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ route })
+    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ route, errorMap: baseErrorMap })
   })
 
   const schema = z.object({
@@ -56,48 +89,41 @@ describe('to DecoratedContractProcedure', () => {
     const procedure = builder.input(schema, example)
 
     expect(procedure).toBeInstanceOf(DecoratedContractProcedure)
-    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ InputSchema: schema, inputExample: example })
+    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ InputSchema: schema, inputExample: example, errorMap: baseErrorMap })
   })
 
   it('output', () => {
     const procedure = builder.output(schema, example)
 
     expect(procedure).toBeInstanceOf(DecoratedContractProcedure)
-    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ OutputSchema: schema, outputExample: example })
-  })
-
-  it('errors', () => {
-    const errors = {
-      BAD: {
-        status: 500,
-        data: schema,
-      },
-    }
-
-    const procedure = builder.errors(errors)
-
-    expect(procedure).toBeInstanceOf(DecoratedContractProcedure)
-    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ errorMap: errors })
+    expect(DecoratedContractProcedure).toHaveBeenCalledWith({ OutputSchema: schema, outputExample: example, errorMap: baseErrorMap })
   })
 })
 
 describe('to router', () => {
-  const builder = new ContractBuilder()
-
   const router = {
     a: {
       b: {
-        c: new ContractProcedure({ InputSchema: undefined, OutputSchema: undefined, errorMap: undefined }),
+        c: new ContractProcedure({ InputSchema: undefined, OutputSchema: undefined, errorMap: baseErrorMap }),
       },
     },
   }
 
-  const emptyRouter = {
+  it('adapt all routers', () => {
+    const routerFn = vi.fn()
+    vi.mocked(ContractRouterBuilder).mockReturnValue({
+      router: routerFn,
+    } as any)
 
-  }
+    const mockedValue = { __mocked__: true }
+    routerFn.mockReturnValue(mockedValue)
 
-  it('router', () => {
-    expect(builder.router(router)).toBe(router)
-    expect(builder.router(emptyRouter)).toBe(emptyRouter)
+    expect(builder.router(router)).toBe(mockedValue)
+    expect(ContractRouterBuilder).toBeCalledTimes(1)
+    expect(ContractRouterBuilder).toBeCalledWith({
+      errorMap: baseErrorMap,
+    })
+    expect(routerFn).toBeCalledTimes(1)
+    expect(routerFn).toBeCalledWith(router)
   })
 })