refactor(client)!: new StandardLink (#193)

* LazyStandardRequest & LazyStandardResponse

* toFetchRequest & toLazyStandardResponse

* improve naming

* sync tests

* wip

* improve

* tests: standard link

* StandardRPCLinkCodec

* linkFetchClient

* RPCLink

* docs

* sync

* improve

* improve

* sync

Author: dinwwwh

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

@@ -82,38 +82,40 @@ const link = new RPCLink({
 
     return 'POST'
   },
-  fetch: (url, init, { context }) =>
-    globalThis.fetch(url, { ...init, cache: context?.cache }),
+  fetch: (request, init, { context }) => globalThis.fetch(request, {
+    ...init,
+    cache: context?.cache,
+  }),
 })
 ```
 
-## Event Source Configuration
+## Event Iterator Configuration
 
-Customize the retry logic for event sources (the mechanism behind [Event Iterator](/docs/event-iterator)) using these options:
+Customize the retry logic for [Event Iterator](/docs/event-iterator) using these options:
 
-- **eventSourceMaxNumberOfRetries:** Maximum retry attempts.
-- **eventSourceRetryDelay:** Delay between retries.
-- **eventSourceRetry:** Function to determine if a retry should occur.
+- **eventIteratorMaxRetries:** Maximum retry attempts.
+- **eventIteratorRetryDelay:** Delay between retries.
+- **eventIteratorShouldRetry:** Function to determine if a retry should occur.
 
 ```ts twoslash
 import { RPCLink } from '@orpc/client/fetch'
 
 interface ClientContext {
-  eventSourceRetry?: boolean
+  eventIteratorShouldRetry?: boolean
 }
 
 const link = new RPCLink<ClientContext>({
   url: 'http://localhost:3000/rpc',
-  eventSourceRetry(reconnectOptions, options, path, input) {
+  eventIteratorShouldRetry(reconnectOptions, options, path, input) {
     console.log(reconnectOptions.error)
 
-    return !options.context?.eventSourceRetry
+    return !options.context?.eventIteratorShouldRetry
   }
 })
 ```
 
 :::tip
-You should disable event source retries when streaming results from a chatbot AI.
+You should disable event iterator retries when streaming results from a chatbot AI.
 :::
 
 ## Event-Source Ping Interval

apps/content/examples/openai-streaming.md

@@ -33,25 +33,25 @@ const complete = os
 
 const router = { complete }
 
-type ClientContext = { disableESRetry?: boolean }
+type ClientContext = { disableEIRetry?: boolean }
 
 const link = new RPCLink<ClientContext>({
   url: 'https://example.com/rpc',
-  eventSourceRetry: (_, { context }) => !context?.disableESRetry,
+  eventIteratorShouldRetry: (_, { context }) => !context?.disableEIRetry,
 })
 
 const client: RouterClient<typeof router, ClientContext> = createORPCClient(link)
 
 const stream = await client.complete(
   { content: 'Hello, world!' },
-  { context: { disableESRetry: true } }
+  { context: { disableEIRetry: true } }
 )
 
 for await (const chunk of stream) {
   console.log(chunk.choices[0]?.delta?.content || '')
 }
 ```
 
-**Note:** Disable event source retries when streaming chatbot responses.
+**Note:** Disable event iterator retries when streaming chatbot responses.
 
 Learn more about [RPCLink](/docs/client/rpc-link) and [Event Iterator](/docs/client/event-iterator).

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

@@ -0,0 +1,49 @@
+import type { StandardRequest } from '@orpc/standard-server'
+import * as StandardServerFetch from '@orpc/standard-server-fetch'
+import { LinkFetchClient } from './link-fetch-client'
+
+const toFetchRequestSpy = vi.spyOn(StandardServerFetch, 'toFetchRequest')
+const toStandardLazyResponseSpy = vi.spyOn(StandardServerFetch, 'toStandardLazyResponse')
+
+describe('linkFetchClient', () => {
+  it('call', async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(new Response('body'))
+    const client = new LinkFetchClient({
+      fetch,
+    })
+
+    const standardRequest: StandardRequest = {
+      url: new URL('http://localhost:300/example'),
+      body: { body: true },
+      headers: {
+        'x-custom': 'value',
+      },
+      method: 'POST',
+      signal: AbortSignal.timeout(100),
+    }
+
+    const options = {
+      context: { context: true },
+      lastEventId: 'last-event-id',
+      signal: AbortSignal.timeout(100),
+    }
+
+    const response = await client.call(standardRequest, options, ['example'], { body: true })
+
+    expect(response).toBe(toStandardLazyResponseSpy.mock.results[0]!.value)
+    expect(toStandardLazyResponseSpy).toBeCalledTimes(1)
+    expect(toStandardLazyResponseSpy).toBeCalledWith(await fetch.mock.results[0]!.value)
+
+    expect(toFetchRequestSpy).toBeCalledTimes(1)
+    expect(toFetchRequestSpy).toBeCalledWith(standardRequest)
+
+    expect(fetch).toBeCalledTimes(1)
+    expect(fetch).toBeCalledWith(
+      toFetchRequestSpy.mock.results[0]!.value,
+      {},
+      options,
+      ['example'],
+      { body: true },
+    )
+  })
+})

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

@@ -0,0 +1,32 @@
+import type { StandardLazyResponse, StandardRequest } from '@orpc/standard-server'
+import type { ClientContext, ClientOptionsOut } from '../../types'
+import type { StandardLinkClient } from '../standard'
+import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch'
+
+export interface LinkFetchClientOptions<T extends ClientContext> {
+  fetch?: (
+    request: Request,
+    init: Record<never, never>,
+    options: ClientOptionsOut<T>,
+    path: readonly string[],
+    input: unknown
+  ) => Promise<Response>
+}
+
+export class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+  private readonly fetch: Exclude<LinkFetchClientOptions<T>['fetch'], undefined>
+
+  constructor(options: LinkFetchClientOptions<T>) {
+    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis)
+  }
+
+  async call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse> {
+    const fetchRequest = toFetchRequest(request)
+
+    const fetchResponse = await this.fetch(fetchRequest, {}, options, path, input)
+
+    const lazyResponse = toStandardLazyResponse(fetchResponse)
+
+    return lazyResponse
+  }
+}