feat(server)!: rewrite implementer

eslint.config.js

@@ -9,6 +9,7 @@ export default antfu({
     'react-refresh/only-export-components': 'off',
     'react/prefer-destructuring-assignment': 'off',
     'react/no-context-provider': 'off',
+    'ts/method-signature-style': ['error', 'method'],
   },
 }, {
   files: ['**/*.test.ts', '**/*.test.tsx', '**/*.test-d.ts', '**/*.test-d.tsx', 'apps/content/examples/**', 'playgrounds/**'],

packages/contract/package.json

@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "@orpc/shared": "workspace:*",
-    "@standard-schema/spec": "1.0.0-beta.4"
+    "@standard-schema/spec": "1.0.0-rc.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",

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

@@ -0,0 +1,330 @@
+import type { OmitChainMethodDeep } from '@orpc/shared'
+import type { ContractBuilder } from './builder'
+import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithInputOutput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants'
+import type { MergedErrorMap } from './error-map'
+import type { ContractProcedure } from './procedure'
+import type { AdaptedContractRouter } from './router'
+import { type baseErrorMap, type BaseMeta, generalSchema, type inputSchema, type outputSchema, ping, pong } from '../tests/shared'
+
+const generalBuilder = {} as ContractBuilder<typeof inputSchema, typeof outputSchema, typeof baseErrorMap, BaseMeta>
+
+describe('ContractProcedureBuilder', () => {
+  const builder = {} as ContractProcedureBuilder<typeof inputSchema, typeof outputSchema, typeof baseErrorMap, BaseMeta>
+
+  it('backward compatibility', () => {
+    const expected = {} as OmitChainMethodDeep<typeof generalBuilder, '$meta' | '$route' | 'prefix' | 'tag' | 'router'>
+
+    expectTypeOf(builder).toMatchTypeOf(expected)
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
+  })
+
+  it('.errors', () => {
+    expectTypeOf(builder.errors({ INVALID: { message: 'invalid' }, OVERRIDE: { message: 'override' } })).toEqualTypeOf<
+      ContractProcedureBuilder<
+          typeof inputSchema,
+          typeof outputSchema,
+          MergedErrorMap<typeof baseErrorMap, { INVALID: { message: string }, OVERRIDE: { message: string } }>,
+          BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.errors({ TOO_MANY_REQUESTS: { data: {} } })
+  })
+
+  it('.meta', () => {
+    expectTypeOf(builder.meta({ log: true })).toEqualTypeOf<
+      ContractProcedureBuilder<
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid meta
+    builder.meta({ meta: 'INVALID' })
+  })
+
+  it('.route', () => {
+    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<
+      ContractProcedureBuilder<
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid method
+    builder.route({ method: 'INVALID' })
+  })
+
+  it('.input', () => {
+    expectTypeOf(builder.input(generalSchema)).toEqualTypeOf<
+      ContractProcedureBuilderWithInput<
+          typeof generalSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.input({})
+  })
+
+  it('.output', () => {
+    expectTypeOf(builder.output(generalSchema)).toEqualTypeOf<
+      ContractProcedureBuilderWithOutput<
+          typeof inputSchema,
+          typeof generalSchema,
+          typeof baseErrorMap,
+          BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.output({})
+  })
+})
+
+describe('ContractProcedureBuilderWithInput', () => {
+  const builder = {} as ContractProcedureBuilderWithInput<typeof inputSchema, typeof outputSchema, typeof baseErrorMap, BaseMeta>
+
+  it('backward compatibility', () => {
+    const expected = {} as OmitChainMethodDeep<typeof generalBuilder, '$meta' | '$route' | 'prefix' | 'tag' | 'router' | 'input'>
+
+    expectTypeOf(builder).toMatchTypeOf(expected)
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
+  })
+
+  it('.errors', () => {
+    expectTypeOf(builder.errors({ INVALID: { message: 'invalid' }, OVERRIDE: { message: 'override' } })).toEqualTypeOf<
+      ContractProcedureBuilderWithInput<
+        typeof inputSchema,
+        typeof outputSchema,
+        MergedErrorMap<typeof baseErrorMap, { INVALID: { message: string }, OVERRIDE: { message: string } }>,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.errors({ TOO_MANY_REQUESTS: { data: {} } })
+  })
+
+  it('.meta', () => {
+    expectTypeOf(builder.meta({ log: true })).toEqualTypeOf<
+      ContractProcedureBuilderWithInput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid meta
+    builder.meta({ meta: 'INVALID' })
+  })
+
+  it('.route', () => {
+    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<
+      ContractProcedureBuilderWithInput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid method
+    builder.route({ method: 'INVALID' })
+  })
+
+  it('.output', () => {
+    expectTypeOf(builder.output(generalSchema)).toEqualTypeOf<
+      ContractProcedureBuilderWithInputOutput<
+        typeof inputSchema,
+        typeof generalSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.output({})
+  })
+})
+
+describe('ContractProcedureBuilderWithOutput', () => {
+  const builder = {} as ContractProcedureBuilderWithOutput<typeof inputSchema, typeof outputSchema, typeof baseErrorMap, BaseMeta>
+
+  it('backward compatibility', () => {
+    const expected = {} as OmitChainMethodDeep<typeof generalBuilder, '$meta' | '$route' | 'prefix' | 'tag' | 'router' | 'output'>
+
+    expectTypeOf(builder).toMatchTypeOf(expected)
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
+  })
+
+  it('.errors', () => {
+    expectTypeOf(builder.errors({ INVALID: { message: 'invalid' }, OVERRIDE: { message: 'override' } })).toEqualTypeOf<
+      ContractProcedureBuilderWithOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        MergedErrorMap<typeof baseErrorMap, { INVALID: { message: string }, OVERRIDE: { message: string } }>,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.errors({ TOO_MANY_REQUESTS: { data: {} } })
+  })
+
+  it('.meta', () => {
+    expectTypeOf(builder.meta({ log: true })).toEqualTypeOf<
+      ContractProcedureBuilderWithOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid meta
+    builder.meta({ meta: 'INVALID' })
+  })
+
+  it('.route', () => {
+    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<
+      ContractProcedureBuilderWithOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid method
+    builder.route({ method: 'INVALID' })
+  })
+
+  it('.input', () => {
+    expectTypeOf(builder.input(generalSchema)).toEqualTypeOf<
+      ContractProcedureBuilderWithInputOutput<
+        typeof generalSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.input({})
+  })
+})
+
+it('ContractProcedureBuilderWithInputOutput', () => {
+  const builder = {} as ContractProcedureBuilderWithInputOutput<typeof inputSchema, typeof outputSchema, typeof baseErrorMap, BaseMeta>
+
+  it('backward compatibility', () => {
+    const expected = {} as OmitChainMethodDeep<typeof generalBuilder, '$meta' | '$route' | 'prefix' | 'tag' | 'router' | 'input' | 'output'>
+
+    expectTypeOf(builder).toMatchTypeOf(expected)
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
+  })
+
+  it('.errors', () => {
+    expectTypeOf(builder.errors({ INVALID: { message: 'invalid' }, OVERRIDE: { message: 'override' } })).toEqualTypeOf<
+      ContractProcedureBuilderWithInputOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        MergedErrorMap<typeof baseErrorMap, { INVALID: { message: string }, OVERRIDE: { message: string } }>,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - schema is invalid
+    builder.errors({ TOO_MANY_REQUESTS: { data: {} } })
+  })
+
+  it('.meta', () => {
+    expectTypeOf(builder.meta({ log: true })).toEqualTypeOf<
+      ContractProcedureBuilderWithInputOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid meta
+    builder.meta({ meta: 'INVALID' })
+  })
+
+  it('.route', () => {
+    expectTypeOf(builder.route({ method: 'GET' })).toEqualTypeOf<
+      ContractProcedureBuilderWithInputOutput<
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta
+      >
+    >()
+
+    // @ts-expect-error - invalid method
+    builder.route({ method: 'INVALID' })
+  })
+})
+
+describe('ContractRouterBuilder', () => {
+  const builder = {} as ContractRouterBuilder<typeof baseErrorMap, BaseMeta>
+
+  it('backward compatibility', () => {
+    const expected = {} as OmitChainMethodDeep<typeof generalBuilder, '$meta' | '$route' | 'route' | 'meta' | 'input' | 'output'>
+
+    // expectTypeOf(builder).toMatchTypeOf(expected)
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<keyof typeof expected>()
+  })
+
+  it('.prefix', () => {
+    expectTypeOf(builder.prefix('/api')).toEqualTypeOf<
+      ContractRouterBuilder<typeof baseErrorMap, BaseMeta>
+    >()
+
+    // @ts-expect-error - invalid prefix
+    builder.prefix(1)
+  })
+
+  it('.tag', () => {
+    expectTypeOf(builder.tag('tag1', 'tag2')).toEqualTypeOf<
+      ContractRouterBuilder<typeof baseErrorMap, BaseMeta>
+    >()
+
+    // @ts-expect-error - invalid tag
+    builder.tag(1)
+  })
+
+  it('.router', () => {
+    const router = {
+      ping,
+      pong,
+    }
+
+    expectTypeOf(builder.router(router)).toEqualTypeOf<
+      AdaptedContractRouter<typeof router, typeof baseErrorMap>
+    >()
+
+    // @ts-expect-error - invalid router
+    builder.router(123)
+
+    builder.router({
+      // @ts-expect-error - conflict meta def
+      ping: {} as ContractProcedure<
+        undefined,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          { mode?: number }
+      >,
+    })
+  })
+})