refactor(client, server): reduce link and handler options

packages/client/src/adapters/fetch/index.ts

@@ -1,2 +1,3 @@
+export * from './link-fetch-client'
 export * from './rpc-link'
 export * from './types'

packages/client/src/adapters/fetch/rpc-link.ts

@@ -1,21 +1,20 @@
 import type { ClientContext, ClientLink, ClientOptionsOut } from '../../types'
 import type { StandardLinkOptions, StandardRPCLinkCodecOptions } from '../standard'
 import type { LinkFetchClientOptions } from './link-fetch-client'
-import { StandardLink, StandardRPCLinkCodec } from '../standard'
+import { RPCSerializer, StandardLink, StandardRPCLinkCodec } from '../standard'
 import { LinkFetchClient } from './link-fetch-client'
 
 export interface RPCLinkOptions<T extends ClientContext>
-  extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {
-  linkCodec?: StandardRPCLinkCodec<T>
-  linkClient?: LinkFetchClient<T>
-}
+  extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {}
 
 export class RPCLink<T extends ClientContext> implements ClientLink<T> {
   private readonly standardLink: StandardLink<T>
 
   constructor(options: RPCLinkOptions<T>) {
-    const linkCodec = options.linkCodec ?? new StandardRPCLinkCodec(options)
-    const linkClient = options.linkClient ?? new LinkFetchClient(options)
+    const serializer = new RPCSerializer()
+    const linkCodec = new StandardRPCLinkCodec(serializer, options)
+    const linkClient = new LinkFetchClient(options)
+
     this.standardLink = new StandardLink(linkCodec, linkClient, options)
   }
 

packages/client/src/adapters/standard/rpc-link-codec.test.ts

@@ -14,9 +14,8 @@ describe('standardRPCLinkCodec', () => {
 
   describe('encode', () => {
     const method = vi.fn()
-    const codec = new StandardRPCLinkCodec({
+    const codec = new StandardRPCLinkCodec(serializer, {
       url: 'http://localhost:3000',
-      rpcSerializer: serializer,
       method,
       headers: () => ({ 'x-custom-header': 'custom-value' }),
     })
@@ -78,9 +77,8 @@ describe('standardRPCLinkCodec', () => {
       ['blob inside', { blob: new Blob(['blob'], { type: 'text/plain' }) }],
       ['event-iterator', (async function* () { })()],
     ])('fallback method when method=GET: %s', async (_, input) => {
-      const codec = new StandardRPCLinkCodec({
+      const codec = new StandardRPCLinkCodec(serializer, {
         url: 'http://localhost:3000',
-        rpcSerializer: serializer,
         method: 'GET',
         maxUrlLength: 100,
         fallbackMethod: 'PATCH',
@@ -101,9 +99,8 @@ describe('standardRPCLinkCodec', () => {
   })
 
   describe('decode', () => {
-    const codec = new StandardRPCLinkCodec({
+    const codec = new StandardRPCLinkCodec(serializer, {
       url: 'http://localhost:3000',
-      rpcSerializer: serializer,
     })
 
     it('should decode output', async () => {

packages/client/src/adapters/standard/rpc-link-codec.ts

@@ -1,9 +1,9 @@
 import type { StandardHeaders, StandardLazyResponse, StandardRequest } from '@orpc/standard-server'
 import type { ClientContext, ClientOptionsOut } from '../../types'
+import type { RPCSerializer } from './rpc-serializer'
 import type { StandardLinkCodec } from './types'
 import { isAsyncIteratorObject, stringifyJSON, trim, value, type Value } from '@orpc/shared'
 import { ORPCError } from '../../error'
-import { RPCSerializer } from './rpc-serializer'
 
 type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
 
@@ -55,8 +55,6 @@ export interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     path: readonly string[],
     input: unknown,
   ]>
-
-  rpcSerializer?: RPCSerializer
 }
 
 export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
@@ -65,15 +63,16 @@ export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLi
   private readonly fallbackMethod: Exclude<StandardRPCLinkCodecOptions<T>['fallbackMethod'], undefined>
   private readonly expectedMethod: Exclude<StandardRPCLinkCodecOptions<T>['method'], undefined>
   private readonly headers: Exclude<StandardRPCLinkCodecOptions<T>['headers'], undefined>
-  private readonly rpcSerializer: Exclude<StandardRPCLinkCodecOptions<T>['rpcSerializer'], undefined>
 
-  constructor(options: StandardRPCLinkCodecOptions<T>) {
+  constructor(
+    private readonly serializer: RPCSerializer,
+    options: StandardRPCLinkCodecOptions<T>,
+  ) {
     this.baseUrl = options.url
     this.maxUrlLength = options.maxUrlLength ?? 2083
     this.fallbackMethod = options.fallbackMethod ?? 'POST'
     this.expectedMethod = options.method ?? this.fallbackMethod
     this.headers = options.headers ?? {}
-    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer()
   }
 
   async encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest> {
@@ -82,7 +81,7 @@ export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLi
     const baseUrl = await value(this.baseUrl, options, path, input)
     const url = new URL(`${trim(baseUrl.toString(), '/')}/${path.map(encodeURIComponent).join('/')}`)
 
-    const serialized = this.rpcSerializer.serialize(input)
+    const serialized = this.serializer.serialize(input)
 
     if (
       expectedMethod === 'GET'
@@ -126,7 +125,7 @@ export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLi
 
         isBodyOk = true
 
-        return this.rpcSerializer.deserialize(body)
+        return this.serializer.deserialize(body)
       }
       catch (error) {
         if (!isBodyOk) {

packages/openapi/src/adapters/fetch/openapi-handler.test.ts

@@ -2,7 +2,6 @@ import { StandardHandler } from '@orpc/server/standard'
 import { toFetchResponse, toStandardLazyRequest } from '@orpc/standard-server-fetch'
 import { describe, expect, it, vi } from 'vitest'
 import { router } from '../../../../server/tests/shared'
-import { OpenAPICodec, OpenAPIMatcher } from '../standard'
 import { OpenAPIHandler } from './openapi-handler'
 
 vi.mock('@orpc/server/standard', async origin => ({
@@ -93,22 +92,4 @@ describe('openAPIHandler', () => {
 
     expect(vi.mocked(toFetchResponse)).not.toHaveBeenCalled()
   })
-
-  it('standardHandler constructor', async () => {
-    const options = {
-      codec: new OpenAPICodec(),
-      matcher: new OpenAPIMatcher(),
-      interceptors: [vi.fn()],
-    }
-
-    const handler = new OpenAPIHandler(router, options)
-
-    expect(StandardHandler).toHaveBeenCalledOnce()
-    expect(StandardHandler).toHaveBeenCalledWith(
-      router,
-      options.matcher,
-      options.codec,
-      options,
-    )
-  })
 })

packages/openapi/src/adapters/fetch/openapi-handler.ts

@@ -1,19 +1,20 @@
 import type { Context, Router } from '@orpc/server'
 import type { FetchHandler, FetchHandleResult } from '@orpc/server/fetch'
-import type { StandardHandleOptions } from '@orpc/server/standard'
+import type { StandardHandleOptions, StandardHandlerOptions } from '@orpc/server/standard'
 import type { MaybeOptionalOptions } from '@orpc/shared'
 import type { ToFetchResponseOptions } from '@orpc/standard-server-fetch'
-import type { OpenAPIHandlerOptions } from '../standard'
+import { OpenAPISerializer } from '@orpc/openapi-client/standard'
 import { StandardHandler } from '@orpc/server/standard'
 import { toFetchResponse, toStandardLazyRequest } from '@orpc/standard-server-fetch'
 import { OpenAPICodec, OpenAPIMatcher } from '../standard'
 
 export class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
   private readonly standardHandler: StandardHandler<T>
 
-  constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher()
-    const codec = options?.codec ?? new OpenAPICodec()
+  constructor(router: Router<T, any>, options: NoInfer<StandardHandlerOptions<T>> = {}) {
+    const serializer = new OpenAPISerializer()
+    const matcher = new OpenAPIMatcher()
+    const codec = new OpenAPICodec(serializer)
 
     this.standardHandler = new StandardHandler(router, matcher, codec, options)
   }

packages/openapi/src/adapters/node/openapi-handler.test.ts

@@ -2,7 +2,6 @@ import { StandardHandler } from '@orpc/server/standard'
 import { sendStandardResponse, toStandardLazyRequest } from '@orpc/standard-server-node'
 import inject from 'light-my-request'
 import { router } from '../../../../server/tests/shared'
-import { OpenAPICodec, OpenAPIMatcher } from '../standard'
 import { OpenAPIHandler } from './openapi-handler'
 
 vi.mock('@orpc/standard-server-node', () => ({
@@ -110,22 +109,4 @@ describe('openapiHandler', async () => {
 
     expect(sendStandardResponse).not.toHaveBeenCalled()
   })
-
-  it('standardHandler constructor', async () => {
-    const options = {
-      codec: new OpenAPICodec(),
-      matcher: new OpenAPIMatcher(),
-      interceptors: [vi.fn()],
-    }
-
-    const handler = new OpenAPIHandler(router, options)
-
-    expect(StandardHandler).toHaveBeenCalledOnce()
-    expect(StandardHandler).toHaveBeenCalledWith(
-      router,
-      options.matcher,
-      options.codec,
-      options,
-    )
-  })
 })

packages/openapi/src/adapters/node/openapi-handler.ts

@@ -1,21 +1,22 @@
 import type { Context, Router } from '@orpc/server'
 import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from '@orpc/server/node'
-import type { StandardHandleOptions } from '@orpc/server/standard'
+import type { StandardHandleOptions, StandardHandlerOptions } from '@orpc/server/standard'
 import type { MaybeOptionalOptions } from '@orpc/shared'
 import type { SendStandardResponseOptions } from '@orpc/standard-server-node'
-import type { OpenAPIHandlerOptions } from '../standard'
+import { OpenAPISerializer } from '@orpc/openapi-client/standard'
 import { StandardHandler } from '@orpc/server/standard'
 import { sendStandardResponse, toStandardLazyRequest } from '@orpc/standard-server-node'
 import { OpenAPICodec, OpenAPIMatcher } from '../standard'
 
 export class OpenAPIHandler<T extends Context> implements NodeHttpHandler<T> {
   private readonly standardHandler: StandardHandler<T>
 
-  constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher()
-    const codec = options?.codec ?? new OpenAPICodec()
+  constructor(router: Router<T, any>, options: NoInfer<StandardHandlerOptions<T>> = {}) {
+    const serializer = new OpenAPISerializer()
+    const matcher = new OpenAPIMatcher()
+    const codec = new OpenAPICodec(serializer)
 
-    this.standardHandler = new StandardHandler(router, matcher, codec, { ...options })
+    this.standardHandler = new StandardHandler(router, matcher, codec, options)
   }
 
   async handle(

packages/openapi/src/adapters/standard/index.ts

@@ -1,3 +1,2 @@
 export * from './openapi-codec'
-export * from './openapi-handler'
 export * from './openapi-matcher'

packages/openapi/src/adapters/standard/openapi-codec.test.ts

@@ -209,8 +209,4 @@ describe('openAPICodec', () => {
     expect(serializer.serialize).toHaveBeenCalledOnce()
     expect(serializer.serialize).toHaveBeenCalledWith(error.toJSON())
   })
-
-  it('work without arguments', async () => {
-    const codec = new OpenAPICodec()
-  })
 })

packages/openapi/src/adapters/standard/openapi-codec.ts

@@ -1,14 +1,14 @@
 import type { ORPCError } from '@orpc/client'
+import type { OpenAPISerializer } from '@orpc/openapi-client/standard'
 import type { AnyProcedure } from '@orpc/server'
 import type { StandardCodec, StandardParams } from '@orpc/server/standard'
 import type { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@orpc/standard-server'
 import { fallbackContractConfig } from '@orpc/contract'
-import { OpenAPISerializer } from '@orpc/openapi-client/standard'
 import { isObject } from '@orpc/shared'
 
 export class OpenAPICodec implements StandardCodec {
   constructor(
-    private readonly serializer: OpenAPISerializer = new OpenAPISerializer(),
+    private readonly serializer: OpenAPISerializer,
   ) {
   }
 

packages/server/src/adapters/fetch/rpc-handler.test.ts

@@ -1,3 +1,4 @@
+import { RPCSerializer } from '@orpc/client/standard'
 import { toFetchResponse, toStandardLazyRequest } from '@orpc/standard-server-fetch'
 import { router } from '../../../tests/shared'
 import { RPCCodec, RPCMatcher, StandardHandler } from '../standard'
@@ -91,7 +92,7 @@ describe('rpcHandler', () => {
 
   it('standardHandler constructor', async () => {
     const options = {
-      codec: new RPCCodec(),
+      codec: new RPCCodec(new RPCSerializer()),
       matcher: new RPCMatcher(),
       interceptors: [vi.fn()],
     }

packages/server/src/adapters/fetch/rpc-handler.ts

@@ -2,17 +2,20 @@ import type { MaybeOptionalOptions } from '@orpc/shared'
 import type { ToFetchResponseOptions } from '@orpc/standard-server-fetch'
 import type { Context } from '../../context'
 import type { Router } from '../../router'
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard'
+import type { StandardHandleOptions, StandardHandlerOptions } from '../standard'
 import type { FetchHandler, FetchHandleResult } from './types'
+import { RPCSerializer } from '@orpc/client/standard'
 import { toFetchResponse, toStandardLazyRequest } from '@orpc/standard-server-fetch'
 import { RPCCodec, RPCMatcher, StandardHandler } from '../standard'
 
 export class RPCHandler<T extends Context> implements FetchHandler<T> {
   private readonly standardHandler: StandardHandler<T>
 
-  constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>) {
-    const matcher = options?.matcher ?? new RPCMatcher()
-    const codec = options?.codec ?? new RPCCodec()
+  constructor(router: Router<T, any>, options: NoInfer<StandardHandlerOptions<T>> = {}) {
+    const serializer = new RPCSerializer()
+    const matcher = new RPCMatcher()
+    const codec = new RPCCodec(serializer)
+
     this.standardHandler = new StandardHandler(router, matcher, codec, options)
   }
 

packages/server/src/adapters/node/rpc-handler.test.ts

@@ -1,3 +1,4 @@
+import { RPCSerializer } from '@orpc/client/standard'
 import { sendStandardResponse, toStandardLazyRequest } from '@orpc/standard-server-node'
 import inject from 'light-my-request'
 import { router } from '../../../tests/shared'
@@ -112,7 +113,7 @@ describe('rpcHandler', async () => {
 
   it('standardHandler constructor', async () => {
     const options = {
-      codec: new RPCCodec(),
+      codec: new RPCCodec(new RPCSerializer()),
       matcher: new RPCMatcher(),
       interceptors: [vi.fn()],
     }

packages/server/src/adapters/node/rpc-handler.ts

@@ -2,17 +2,19 @@ import type { MaybeOptionalOptions } from '@orpc/shared'
 import type { SendStandardResponseOptions } from '@orpc/standard-server-node'
 import type { Context } from '../../context'
 import type { Router } from '../../router'
-import type { RPCHandlerOptions, StandardHandleOptions } from '../standard'
+import type { StandardHandleOptions, StandardHandlerOptions } from '../standard'
 import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types'
+import { RPCSerializer } from '@orpc/client/standard'
 import { sendStandardResponse, toStandardLazyRequest } from '@orpc/standard-server-node'
 import { RPCCodec, RPCMatcher, StandardHandler } from '../standard'
 
 export class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
   private readonly standardHandler: StandardHandler<T>
 
-  constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>) {
-    const codec = options?.codec ?? new RPCCodec()
-    const matcher = options?.matcher ?? new RPCMatcher()
+  constructor(router: Router<T, any>, options: NoInfer<StandardHandlerOptions<T>> = {}) {
+    const serializer = new RPCSerializer()
+    const matcher = new RPCMatcher()
+    const codec = new RPCCodec(serializer)
 
     this.standardHandler = new StandardHandler(router, matcher, codec, options)
   }

packages/server/src/adapters/standard/handler.test.ts

@@ -53,7 +53,7 @@ describe('standardHandler', () => {
   }
 
   it('should call matcher.init once', async () => {
-    const handler = new StandardHandler(router, matcher, codec)
+    const handler = new StandardHandler(router, matcher, codec, {})
     expect(matcher.init).toHaveBeenCalledOnce()
     expect(matcher.init).toHaveBeenCalledWith(router)
   })
@@ -319,7 +319,7 @@ describe('standardHandler', () => {
       params: { id: '__id__' },
     })
 
-    const handler = new StandardHandler(router, matcher, codec)
+    const handler = new StandardHandler(router, matcher, codec, {})
 
     expect(await handler.handle(request, { context: { db: 'postgres' } })).toEqual({
       matched: true,
@@ -337,7 +337,7 @@ describe('standardHandler', () => {
       params: { id: '__id__' },
     })
 
-    const handler = new StandardHandler(router, matcher, codec)
+    const handler = new StandardHandler(router, matcher, codec, {})
     const client = vi.fn().mockReturnValueOnce('__output__')
     vi.mocked(createProcedureClient).mockReturnValueOnce(client)
 

packages/server/src/adapters/standard/handler.ts

@@ -52,7 +52,7 @@ export class StandardHandler<T extends Context> {
     router: Router<T, any>,
     private readonly matcher: StandardMatcher,
     private readonly codec: StandardCodec,
-    private readonly options: NoInfer<StandardHandlerOptions<T>> = {},
+    private readonly options: NoInfer<StandardHandlerOptions<T>>,
   ) {
     this.plugin = new CompositePlugin(options.plugins)
 

packages/server/src/adapters/standard/index.ts

@@ -1,5 +1,4 @@
 export * from './handler'
 export * from './rpc-codec'
-export * from './rpc-handler'
 export * from './rpc-matcher'
 export * from './types'