feat(contract)!: stricter implementation for contracts (#97)

* contract: procedure

* contract: builder & router

* update old tests

* improve

* route tests

* 100% test coverage for contract

* server

* fix

* fix types

* improve

* fix

* fix

* fix

* fix tests

* strict route

* strict error map

* strict contract when implement

* remove hidden contract when implement

Author: dinwwwh

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

@@ -1,10 +1,13 @@
+import type { ReadonlyDeep } from '@orpc/shared'
+import type { ContractBuilder, GetInitialRoute, MergeContractBuilderConfig } from './builder'
+import type { StrictErrorMap } from './error-map'
 import type { ContractProcedure } from './procedure'
 import type { ContractProcedureBuilder } from './procedure-builder'
 import type { ContractProcedureBuilderWithInput } from './procedure-builder-with-input'
 import type { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output'
+import type { MergeRoute, StrictRoute } from './route'
 import type { AdaptedContractRouter, ContractRouterBuilder } from './router-builder'
 import { z } from 'zod'
-import { ContractBuilder } from './builder'
 
 const schema = z.object({ value: z.string() })
 
@@ -16,24 +19,24 @@ const baseErrorMap = {
   },
 }
 
-const builder = new ContractBuilder({
-  errorMap: baseErrorMap,
-  OutputSchema: undefined,
-  InputSchema: undefined,
-  config: {
-    initialRoute: {
-      description: 'from initial',
-    },
-  },
-})
+type BaseErrorMap = StrictErrorMap<typeof baseErrorMap>
+
+type Config = ReadonlyDeep<{ initialRoute: { description: 'from initial' } }>
+
+const builder = {} as ContractBuilder<Config, BaseErrorMap>
 
 describe('ContractBuilder', () => {
   it('is a contract procedure', () => {
-    expectTypeOf(builder).toMatchTypeOf<ContractProcedure<undefined, undefined, typeof baseErrorMap>>()
+    expectTypeOf(builder).toMatchTypeOf<ContractProcedure<undefined, undefined, BaseErrorMap, { description: string }>>()
   })
 
   it('.config', () => {
-    expectTypeOf(builder.config({ initialRoute: { description: 'from config' } })).toEqualTypeOf<typeof builder>()
+    expectTypeOf(builder.config({ initialRoute: { description: 'from config' } })).toEqualTypeOf<
+      ContractBuilder<
+        MergeContractBuilderConfig<Config, ReadonlyDeep<{ initialRoute: { description: 'from config' } }>>,
+        BaseErrorMap
+      >
+    >()
 
     // @ts-expect-error - invalid method
     builder.config({ initialRoute: { method: 'HI' } })
@@ -43,52 +46,61 @@ describe('ContractBuilder', () => {
     const errors = { BAD_GATEWAY: { data: schema } } as const
 
     expectTypeOf(builder.errors(errors))
-      .toEqualTypeOf<ContractBuilder<typeof baseErrorMap & typeof errors>>()
+      .toEqualTypeOf < ContractBuilder<Config, BaseErrorMap & StrictErrorMap<typeof errors>>>()
 
     // @ts-expect-error - not allow redefine error map
     builder.errors({ BASE: baseErrorMap.BASE })
   })
 
   it('.route', () => {
-    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<ContractProcedureBuilder<typeof baseErrorMap>>()
+    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<
+      ContractProcedureBuilder<
+        BaseErrorMap,
+        MergeRoute<StrictRoute<GetInitialRoute<Config>>, ReadonlyDeep<{ method: 'GET' }>>
+      >
+    >()
 
     // @ts-expect-error - invalid method
     builder.route({ method: 'HE' })
   })
 
   it('.input', () => {
     expectTypeOf(builder.input(schema)).toEqualTypeOf<
-      ContractProcedureBuilderWithInput<typeof schema, typeof baseErrorMap >
+      ContractProcedureBuilderWithInput<
+      typeof schema,
+        BaseErrorMap,
+        StrictRoute<GetInitialRoute<Config>>
+      >
     >()
   })
 
   it('.output', () => {
     expectTypeOf(builder.output(schema)).toEqualTypeOf<
-      ContractProcedureBuilderWithOutput<typeof schema, typeof baseErrorMap >
+      ContractProcedureBuilderWithOutput<typeof schema, BaseErrorMap, StrictRoute<GetInitialRoute<Config>>>
     >()
   })
 
   it('.prefix', () => {
-    expectTypeOf(builder.prefix('/api')).toEqualTypeOf<ContractRouterBuilder<typeof baseErrorMap>>()
+    expectTypeOf(builder.prefix('/api')).toEqualTypeOf<ContractRouterBuilder<BaseErrorMap, '/api', undefined>>()
 
     // @ts-expect-error - invalid prefix
     builder.prefix(1)
   })
 
   it('.tag', () => {
-    expectTypeOf(builder.tag('tag1', 'tag2')).toEqualTypeOf<ContractRouterBuilder<typeof baseErrorMap>>()
+    expectTypeOf(builder.tag('tag1', 'tag2')).toEqualTypeOf<ContractRouterBuilder<BaseErrorMap, undefined, ['tag1', 'tag2']>>()
 
     // @ts-expect-error - invalid tag
     builder.tag(1)
   })
 
   it('.router', () => {
     const router = {
-      ping: {} as ContractProcedure<undefined, typeof schema, typeof baseErrorMap>,
-      pong: {} as ContractProcedure<typeof schema, undefined, Record<never, never>>,
+      ping: {} as ContractProcedure<undefined, typeof schema, BaseErrorMap, { description: string }>,
+      pong: {} as ContractProcedure<typeof schema, undefined, Record<never, never>, Record<never, never>>,
     }
 
-    expectTypeOf(builder.router(router)).toEqualTypeOf<AdaptedContractRouter<typeof router, typeof baseErrorMap>>()
+    expectTypeOf(builder.router(router)).toEqualTypeOf<AdaptedContractRouter<typeof router, BaseErrorMap, undefined, undefined>>()
 
     const invalidErrorMap = {
       BASE: {
@@ -99,7 +111,7 @@ describe('ContractBuilder', () => {
 
     builder.router({
       // @ts-expect-error - error map is not match
-      ping: {} as ContractProcedure<undefined, typeof schema, typeof invalidErrorMap>,
+      ping: {} as ContractProcedure<undefined, typeof schema, typeof invalidErrorMap, Record<never, never>>,
     })
   })
 })

packages/contract/src/builder.test.ts

@@ -36,6 +36,9 @@ const builder = new ContractBuilder({
       description: 'from initial',
     },
   },
+  route: {
+    description: 'from initial',
+  },
 })
 
 beforeEach(() => {

packages/contract/src/builder.ts

@@ -1,40 +1,53 @@
 import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map'
-import type { ContractProcedureDef, RouteOptions } from './procedure'
+import type { ContractProcedureDef } from './procedure'
+import type { HTTPPath, MergeRoute, Route, StrictRoute } from './route'
 import type { ContractRouter } from './router'
 import type { AdaptedContractRouter } from './router-builder'
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types'
+import type { Schema, SchemaInput, SchemaOutput } from './types'
 import { ContractProcedure } from './procedure'
 import { ContractProcedureBuilder } from './procedure-builder'
 import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input'
 import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output'
+import { mergeRoute } from './route'
 import { ContractRouterBuilder } from './router-builder'
 
 export interface ContractBuilderConfig {
-  initialRoute?: RouteOptions
+  initialRoute?: Route
 }
 
-export interface ContractBuilderDef<TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap> {
-  config: ContractBuilderConfig
+export type MergeContractBuilderConfig<A extends ContractBuilderConfig, B extends ContractBuilderConfig> = Omit<A, keyof B> & B
+
+export type GetInitialRoute<T extends ContractBuilderConfig> = T['initialRoute'] extends Route
+  ? T['initialRoute']
+  : Record<never, never>
+
+export interface ContractBuilderDef<TConfig extends ContractBuilderConfig, TErrorMap extends ErrorMap>
+  extends ContractProcedureDef<undefined, undefined, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>> {
+  config: TConfig
 }
 
-export class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
-  declare '~orpc': ContractBuilderDef<TErrorMap>
+export class ContractBuilder<TConfig extends ContractBuilderConfig, TErrorMap extends ErrorMap>
+  extends ContractProcedure<undefined, undefined, TErrorMap, GetInitialRoute<TConfig>> {
+  declare '~orpc': ContractBuilderDef<TConfig, TErrorMap>
 
-  constructor(def: ContractBuilderDef<TErrorMap>) {
+  constructor(def: ContractBuilderDef<TConfig, TErrorMap>) {
     super(def)
+    this['~orpc'].config = def.config
   }
 
-  config(config: ContractBuilderConfig): ContractBuilder<TErrorMap> {
+  config<const U extends ContractBuilderConfig>(config: U): ContractBuilder<MergeContractBuilderConfig<TConfig, U>, TErrorMap> {
     return new ContractBuilder({
       ...this['~orpc'],
       config: {
         ...this['~orpc'].config,
         ...config,
-      },
+      } as any,
     })
   }
 
-  errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap> {
+  errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(
+    errors: U,
+  ): ContractBuilder<TConfig, StrictErrorMap<U> & TErrorMap> {
     return new ContractBuilder({
       ...this['~orpc'],
       errorMap: {
@@ -44,55 +57,58 @@ export class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedu
     })
   }
 
-  route(route: RouteOptions): ContractProcedureBuilder<TErrorMap> {
+  route<const U extends Route>(route: U): ContractProcedureBuilder<TErrorMap, MergeRoute<StrictRoute<GetInitialRoute<TConfig>>, U>> {
     return new ContractProcedureBuilder({
-      route: {
-        ...this['~orpc'].config.initialRoute,
-        ...route,
-      },
+      route: mergeRoute(this['~orpc'].route, route),
       InputSchema: undefined,
       OutputSchema: undefined,
       errorMap: this['~orpc'].errorMap,
     })
   }
 
-  input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap> {
+  input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>> {
     return new ContractProcedureBuilderWithInput({
-      route: this['~orpc'].config.initialRoute,
+      route: this['~orpc'].route,
       InputSchema: schema,
       inputExample: example,
       OutputSchema: undefined,
       errorMap: this['~orpc'].errorMap,
     })
   }
 
-  output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap> {
+  output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>> {
     return new ContractProcedureBuilderWithOutput({
-      route: this['~orpc'].config.initialRoute,
+      route: this['~orpc'].route,
       OutputSchema: schema,
       outputExample: example,
       InputSchema: undefined,
       errorMap: this['~orpc'].errorMap,
     })
   }
 
-  prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap> {
+  prefix<U extends HTTPPath>(prefix: U): ContractRouterBuilder<TErrorMap, U, undefined> {
     return new ContractRouterBuilder({
       prefix,
       errorMap: this['~orpc'].errorMap,
+      tags: undefined,
     })
   }
 
-  tag(...tags: string[]): ContractRouterBuilder<TErrorMap> {
+  tag<U extends string[]>(...tags: U): ContractRouterBuilder<TErrorMap, undefined, U> {
     return new ContractRouterBuilder({
       tags,
       errorMap: this['~orpc'].errorMap,
+      prefix: undefined,
     })
   }
 
-  router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap> {
+  router<T extends ContractRouter<ErrorMap & Partial<TErrorMap>>>(
+    router: T,
+  ): AdaptedContractRouter<T, TErrorMap, undefined, undefined> {
     return new ContractRouterBuilder({
       errorMap: this['~orpc'].errorMap,
+      prefix: undefined,
+      tags: undefined,
     }).router(router)
   }
 }

packages/contract/src/config.ts

@@ -1,11 +1,12 @@
-import type { HTTPMethod, InputStructure } from './types'
+import type { HTTPMethod, InputStructure, Route } from './route'
 
 export interface ContractConfig {
   defaultMethod: HTTPMethod
   defaultSuccessStatus: number
   defaultSuccessDescription: string
   defaultInputStructure: InputStructure
   defaultOutputStructure: InputStructure
+  defaultInitialRoute: Route
 }
 
 const DEFAULT_CONFIG: ContractConfig = {
@@ -14,6 +15,7 @@ const DEFAULT_CONFIG: ContractConfig = {
   defaultSuccessDescription: 'OK',
   defaultInputStructure: 'compact',
   defaultOutputStructure: 'compact',
+  defaultInitialRoute: {},
 }
 
 export function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T] {

packages/contract/src/index.ts

@@ -15,15 +15,17 @@ export * from './procedure-builder-with-input'
 export * from './procedure-builder-with-output'
 export * from './procedure-client'
 export * from './procedure-decorated'
+export * from './route'
 export * from './router'
 export * from './router-builder'
 export * from './router-client'
 export * from './schema-utils'
 export * from './types'
 
-export const oc = new ContractBuilder<Record<never, never>>({
+export const oc = new ContractBuilder({
+  config: {},
+  route: {},
   errorMap: {},
   InputSchema: undefined,
   OutputSchema: undefined,
-  config: {},
 })