feat(client)!: update standard link interceptors and plugins options (#333)

This update change options related to `RPCLink` and `OpenAPILink` from
receive 3 args like this `options, input, path` to this `{ context,
input, path }`

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **Refactor**
- Consolidated parameters across client calls and interceptors into a
unified object structure.
- Updated options and type definitions to enforce required properties,
enhancing clarity and type safety.
- Streamlined retry operations for clearer error handling and more
consistent behavior.

- **Tests**
- Revised test cases to align with the new parameter structure, ensuring
a reliable and maintainable validation process.
- Updated fetch function signatures in test cases to accept a single
`request` parameter, simplifying the interface.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: dinwwwh

apps/content/docs/client/rpc-link.md

@@ -71,7 +71,7 @@ interface ClientContext {
 
 const link = new RPCLink<ClientContext>({
   url: 'http://localhost:3000/rpc',
-  method: ({ context }, path) => {
+  method: ({ context, path }) => {
     if (context?.cache) {
       return 'GET'
     }

apps/content/docs/plugins/client-retry.md

@@ -26,7 +26,7 @@ const link = new RPCLink<ORPCClientContext>({
   plugins: [
     new ClientRetryPlugin({
       default: { // Optional override for default options
-        retry: (options, path) => {
+        retry: ({ path }) => {
           if (path.join('.') === 'planet.list') {
             return 2
           }

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

@@ -41,9 +41,7 @@ describe('linkFetchClient', () => {
     expect(fetch).toBeCalledWith(
       toFetchRequestSpy.mock.results[0]!.value,
       { redirect: 'manual' },
-      options,
-      ['example'],
-      { body: true },
+      { ...options, path: ['example'], input: { body: true } },
     )
   })
 })

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

@@ -1,16 +1,14 @@
 import type { StandardLazyResponse, StandardRequest } from '@orpc/standard-server'
 import type { ToFetchRequestOptions } from '@orpc/standard-server-fetch'
 import type { ClientContext, ClientOptions } from '../../types'
-import type { StandardLinkClient } from '../standard'
+import type { StandardLinkClient, StandardLinkInterceptorOptions } from '../standard'
 import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch'
 
 export interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
   fetch?: (
     request: Request,
     init: { redirect?: Request['redirect'] },
-    options: ClientOptions<T>,
-    path: readonly string[],
-    input: unknown
+    options: StandardLinkInterceptorOptions<T>,
   ) => Promise<Response>
 }
 
@@ -26,7 +24,7 @@ export class LinkFetchClient<T extends ClientContext> implements StandardLinkCli
   async call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse> {
     const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions)
 
-    const fetchResponse = await this.fetch(fetchRequest, { redirect: 'manual' }, options, path, input)
+    const fetchResponse = await this.fetch(fetchRequest, { redirect: 'manual' }, { ...options, path, input })
 
     const lazyResponse = toStandardLazyResponse(fetchResponse)
 

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

@@ -18,8 +18,7 @@ describe.each(supportedDataTypes)('rpcLink: $name', ({ value, expected }) => {
       const rpcLink = new RPCLink({
         url: 'http://api.example.com',
         method,
-        fetch: async (url, init) => {
-          const request = new Request(url, init)
+        fetch: async (request) => {
           const { matched, response } = await rpcHandler.handle(request)
 
           if (matched) {
@@ -51,8 +50,7 @@ describe.each(supportedDataTypes)('rpcLink: $name', ({ value, expected }) => {
       const rpcLink = new RPCLink({
         url: 'http://api.example.com',
         method,
-        fetch: async (url, init) => {
-          const request = new Request(url, init)
+        fetch: async (request) => {
           const { matched, response } = await rpcHandler.handle(request)
 
           if (matched) {

packages/client/src/adapters/standard/link.test.ts

@@ -43,13 +43,20 @@ describe('standardLink', () => {
       next: expect.any(Function),
       path: ['planet', 'create'],
       input: { name: 'Earth' },
-      options: { context, signal, lastEventId },
+      context,
+      signal,
+      lastEventId,
     })
 
     expect(clientInterceptor).toHaveBeenCalledTimes(1)
     expect(clientInterceptor).toHaveBeenCalledWith({
       next: expect.any(Function),
       request: '__standard_request__',
+      path: ['planet', 'create'],
+      input: { name: 'Earth' },
+      context,
+      signal,
+      lastEventId,
     })
   })
 

packages/client/src/adapters/standard/link.ts

@@ -10,9 +10,18 @@ export interface StandardLinkPlugin<T extends ClientContext> {
   init?(options: StandardLinkOptions<T>): void
 }
 
+export interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+  path: readonly string[]
+  input: unknown
+}
+
+export interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+  request: StandardRequest
+}
+
 export interface StandardLinkOptions<T extends ClientContext> {
-  interceptors?: Interceptor<{ path: readonly string[], input: unknown, options: ClientOptions<T> }, unknown, ThrowableError>[]
-  clientInterceptors?: Interceptor<{ request: StandardRequest }, StandardLazyResponse, ThrowableError>[]
+  interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[]
+  clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[]
   plugins?: StandardLinkPlugin<T>[]
 }
 
@@ -34,7 +43,7 @@ export class StandardLink<T extends ClientContext> implements ClientLink<T> {
   }
 
   call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown> {
-    return intercept(this.interceptors, { path, input, options }, async ({ path, input, options }) => {
+    return intercept(this.interceptors, { ...options, path, input }, async ({ path, input, ...options }) => {
       const output = await this.#call(path, input, options)
 
       return output
@@ -46,8 +55,8 @@ export class StandardLink<T extends ClientContext> implements ClientLink<T> {
 
     const response = await intercept(
       this.clientInterceptors,
-      { request },
-      ({ request }) => this.sender.call(request, options, path, input),
+      { ...options, input, path, request },
+      ({ input, path, request, ...options }) => this.sender.call(request, options, path, input),
     )
 
     const output = await this.codec.decode(response, options, path, input)

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

@@ -1,4 +1,5 @@
 import type { ClientContext, ClientOptions, HTTPMethod } from '../../types'
+import type { StandardLinkInterceptorOptions } from './link'
 import type { StandardRPCSerializer } from './rpc-serializer'
 import type { StandardLinkCodec } from './types'
 import { isAsyncIteratorObject, stringifyJSON, value, type Value } from '@orpc/shared'
@@ -10,33 +11,21 @@ export interface StandardRPCLinkCodecOptions<T extends ClientContext> {
   /**
    * Base url for all requests.
    */
-  url: Value<string | URL, [
-    options: ClientOptions<T>,
-    path: readonly string[],
-    input: unknown,
-  ]>
+  url: Value<string | URL, [StandardLinkInterceptorOptions<T>]>
 
   /**
    * The maximum length of the URL.
    *
    * @default 2083
    */
-  maxUrlLength?: Value<number, [
-    options: ClientOptions<T>,
-    path: readonly string[],
-    input: unknown,
-  ]>
+  maxUrlLength?: Value<number, [StandardLinkInterceptorOptions<T>]>
 
   /**
    * The method used to make the request.
    *
    * @default 'POST'
    */
-  method?: Value<HTTPMethod, [
-    options: ClientOptions<T>,
-    path: readonly string[],
-    input: unknown,
-  ]>
+  method?: Value<HTTPMethod, [StandardLinkInterceptorOptions<T>]>
 
   /**
    * The method to use when the payload cannot safely pass to the server with method return from method function.
@@ -49,11 +38,7 @@ export interface StandardRPCLinkCodecOptions<T extends ClientContext> {
   /**
    * Inject headers to the request.
    */
-  headers?: Value<StandardHeaders, [
-    options: ClientOptions<T>,
-    path: readonly string[],
-    input: unknown,
-  ]>
+  headers?: Value<StandardHeaders, [StandardLinkInterceptorOptions<T>]>
 }
 
 export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
@@ -75,9 +60,11 @@ export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLi
   }
 
   async encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest> {
-    const expectedMethod = await value(this.expectedMethod, options, path, input)
-    let headers = await value(this.headers, options, path, input)
-    const baseUrl = await value(this.baseUrl, options, path, input)
+    const generalOptions = { ...options, path, input }
+
+    const expectedMethod = await value(this.expectedMethod, generalOptions)
+    let headers = await value(this.headers, generalOptions)
+    const baseUrl = await value(this.baseUrl, generalOptions)
     const url = new URL(baseUrl)
     url.pathname = `${url.pathname.replace(/\/$/, '')}${toHttpPath(path)}`
 
@@ -92,7 +79,7 @@ export class StandardRPCLinkCodec<T extends ClientContext> implements StandardLi
       && !(serialized instanceof FormData)
       && !isAsyncIteratorObject(serialized)
     ) {
-      const maxUrlLength = await value(this.maxUrlLength, options, path, input)
+      const maxUrlLength = await value(this.maxUrlLength, generalOptions)
       const getUrl = new URL(url)
 
       getUrl.searchParams.append('data', stringifyJSON(serialized))