@orpc/client 0.38.0 → 0.40.0

package/dist/chunk-HYT35LXG.js

@@ -0,0 +1,105 @@
+// src/event-iterator-state.ts
+var iteratorStates = /* @__PURE__ */ new WeakMap();
+function registerEventIteratorState(iterator, state) {
+  iteratorStates.set(iterator, state);
+}
+function updateEventIteratorStatus(state, status) {
+  if (state.status !== status) {
+    state.status = status;
+    state.listeners.forEach((cb) => cb(status));
+  }
+}
+function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
+  const state = iteratorStates.get(iterator);
+  if (!state) {
+    throw new Error("Iterator is not registered.");
+  }
+  if (notifyImmediately) {
+    callback(state.status);
+  }
+  state.listeners.push(callback);
+  return () => {
+    const index = state.listeners.indexOf(callback);
+    if (index !== -1) {
+      state.listeners.splice(index, 1);
+    }
+  };
+}
+
+// src/event-iterator.ts
+import { getEventMeta } from "@orpc/server-standard";
+import { retry } from "@orpc/shared";
+var MAX_ALLOWED_RETRY_TIMES = 99;
+function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
+  const state = {
+    status: "connected",
+    listeners: []
+  };
+  const iterator = async function* () {
+    let current = initial;
+    let lastEventId = initialLastEventId;
+    let lastRetry;
+    let retryTimes = 0;
+    try {
+      while (true) {
+        try {
+          updateEventIteratorStatus(state, "connected");
+          const { done, value } = await current.next();
+          const meta = getEventMeta(value);
+          lastEventId = meta?.id ?? lastEventId;
+          lastRetry = meta?.retry ?? lastRetry;
+          retryTimes = 0;
+          if (done) {
+            return value;
+          }
+          yield value;
+        } catch (e) {
+          updateEventIteratorStatus(state, "reconnecting");
+          const meta = getEventMeta(e);
+          lastEventId = meta?.id ?? lastEventId;
+          lastRetry = meta?.retry ?? lastRetry;
+          let currentError = e;
+          current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
+            retryTimes += 1;
+            if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
+              throw exit(new Error(
+                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
+                { cause: currentError }
+              ));
+            }
+            const reconnected = await (async () => {
+              try {
+                return await reconnect({
+                  lastRetry,
+                  lastEventId,
+                  retryTimes,
+                  error: currentError
+                });
+              } catch (e2) {
+                currentError = e2;
+                throw e2;
+              }
+            })();
+            if (!reconnected) {
+              throw exit(currentError);
+            }
+            return reconnected;
+          });
+        }
+      }
+    } finally {
+      updateEventIteratorStatus(state, "closed");
+      await current.return?.();
+    }
+  }();
+  registerEventIteratorState(iterator, state);
+  return iterator;
+}
+
+export {
+  registerEventIteratorState,
+  updateEventIteratorStatus,
+  onEventIteratorStatusChange,
+  createAutoRetryEventIterator
+};
+//# sourceMappingURL=chunk-HYT35LXG.js.map

package/dist/fetch.js

@@ -1,43 +1,73 @@
+import {
+  createAutoRetryEventIterator
+} from "./chunk-HYT35LXG.js";
+
 // src/adapters/fetch/orpc-link.ts
 import { ORPCError } from "@orpc/contract";
-import { fetchReToStandardBody } from "@orpc/server/fetch";
+import { isAsyncIteratorObject } from "@orpc/server-standard";
+import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
 import { RPCSerializer } from "@orpc/server/standard";
-import { isObject, trim } from "@orpc/shared";
-import { contentDisposition } from "@tinyhttp/content-disposition";
+import { trim, value } from "@orpc/shared";
+var InvalidEventSourceRetryResponse = class extends Error {
+};
 var RPCLink = class {
   fetch;
   rpcSerializer;
-  maxURLLength;
+  maxUrlLength;
   fallbackMethod;
-  getMethod;
-  getHeaders;
+  method;
+  headers;
   url;
+  eventSourceMaxNumberOfRetries;
+  eventSourceRetryDelay;
+  eventSourceRetry;
   constructor(options) {
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
-    this.maxURLLength = options.maxURLLength ?? 2083;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
     this.fallbackMethod = options.fallbackMethod ?? "POST";
     this.url = options.url;
-    this.getMethod = async (path, input, context) => {
-      return await options.method?.(path, input, context) ?? this.fallbackMethod;
-    };
-    this.getHeaders = async (path, input, context) => {
-      return new Headers(await options.headers?.(path, input, context));
-    };
+    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
+    this.method = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.eventSourceRetry = options.eventSourceRetry ?? true;
+    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
   }
   async call(path, input, options) {
-    const clientContext = options.context ?? {};
-    const encoded = await this.encode(path, input, options);
-    if (encoded.body instanceof Blob && !encoded.headers.has("content-disposition")) {
-      encoded.headers.set("content-disposition", contentDisposition(encoded.body instanceof File ? encoded.body.name : "blob"));
+    const output = await this.performCall(path, input, options);
+    if (!isAsyncIteratorObject(output)) {
+      return output;
+    }
+    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
+      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
+        return null;
+      }
+      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
+        return null;
+      }
+      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
+      const maybeIterator = await this.performCall(path, input, updatedOptions);
+      if (!isAsyncIteratorObject(maybeIterator)) {
+        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
+      }
+      return maybeIterator;
+    }, void 0);
+  }
+  async performCall(path, input, options) {
+    const encoded = await this.encodeRequest(path, input, options);
+    const fetchBody = toFetchBody(encoded.body, encoded.headers);
+    if (options.lastEventId !== void 0) {
+      encoded.headers.set("last-event-id", options.lastEventId);
     }
     const response = await this.fetch(encoded.url, {
       method: encoded.method,
       headers: encoded.headers,
-      body: encoded.body,
+      body: fetchBody,
       signal: options.signal
-    }, clientContext);
-    const body = await fetchReToStandardBody(response);
+    }, options, path, input);
+    const body = await toStandardBody(response);
     const deserialized = (() => {
       try {
         return this.rpcSerializer.deserialize(body);
@@ -53,59 +83,44 @@ var RPCLink = class {
         });
       }
     })();
-    if (response.ok) {
-      return deserialized;
+    if (!response.ok) {
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Invalid RPC error response",
+        cause: deserialized
+      });
     }
-    throw ORPCError.fromJSON(deserialized);
+    return deserialized;
   }
-  async encode(path, input, options) {
-    const clientContext = options.context;
-    const expectMethod = await this.getMethod(path, input, clientContext);
-    const headers = await this.getHeaders(path, input, clientContext);
+  async encodeRequest(path, input, options) {
+    const expectedMethod = await value(this.method, options, path, input);
+    const headers = new Headers(await value(this.headers, options, path, input));
     const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    headers.append("x-orpc-handler", "rpc");
     const serialized = this.rpcSerializer.serialize(input);
-    if (expectMethod === "GET" && isObject(serialized)) {
-      const tryURL = new URL(url);
-      tryURL.searchParams.append("data", JSON.stringify(serialized));
-      if (tryURL.toString().length <= this.maxURLLength) {
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", JSON.stringify(serialized));
+      if (getUrl.toString().length <= this.maxUrlLength) {
         return {
           body: void 0,
-          method: expectMethod,
+          method: expectedMethod,
           headers,
-          url: tryURL
+          url: getUrl
         };
       }
     }
-    const method = expectMethod === "GET" ? this.fallbackMethod : expectMethod;
-    if (input === void 0) {
-      return {
-        body: void 0,
-        method,
-        headers,
-        url
-      };
-    }
-    if (isObject(serialized)) {
-      if (!headers.has("content-type")) {
-        headers.set("content-type", "application/json");
-      }
-      return {
-        body: JSON.stringify(serialized),
-        method,
-        headers,
-        url
-      };
-    }
     return {
-      body: serialized,
-      method,
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
       headers,
-      url
+      body: serialized
     };
   }
 };
 export {
+  InvalidEventSourceRetryResponse,
   RPCLink
 };
 //# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,8 +1,20 @@
+import {
+  createAutoRetryEventIterator,
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  updateEventIteratorStatus
+} from "./chunk-HYT35LXG.js";
+
 // src/client.ts
 function createORPCClient(link, options) {
   const path = options?.path ?? [];
   const procedureClient = async (...[input, options2]) => {
-    return await link.call(path, input, options2 ?? {});
+    const optionsOut = {
+      ...options2,
+      context: options2?.context ?? {}
+      // options.context can be undefined when all field is optional
+    };
+    return await link.call(path, input, optionsOut);
   };
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
@@ -24,9 +36,8 @@ var DynamicLink = class {
     this.linkResolver = linkResolver;
   }
   async call(path, input, options) {
-    const clientContext = options.context ?? {};
-    const resolvedLink = await this.linkResolver(path, input, clientContext);
-    const output = await resolvedLink.call(path, input, { ...options, context: clientContext });
+    const resolvedLink = await this.linkResolver(options, path, input);
+    const output = await resolvedLink.call(path, input, options);
     return output;
   }
 };
@@ -36,8 +47,12 @@ import { isDefinedError, ORPCError, safe } from "@orpc/contract";
 export {
   DynamicLink,
   ORPCError,
+  createAutoRetryEventIterator,
   createORPCClient,
   isDefinedError,
-  safe
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  safe,
+  updateEventIteratorStatus
 };
 //# sourceMappingURL=index.js.map

package/dist/src/adapters/fetch/orpc-link.d.ts

@@ -1,8 +1,11 @@
-import type { ClientContext, ClientOptions, HTTPMethod } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from '../../types';
+import type { ClientContext, HTTPMethod } from '@orpc/contract';
+import type { Value } from '@orpc/shared';
+import type { ClientLink, ClientOptionsOut } from '../../types';
 import type { FetchWithContext } from './types';
 import { RPCSerializer } from '@orpc/server/standard';
+import { type EventIteratorReconnectOptions } from '../../event-iterator';
+export declare class InvalidEventSourceRetryResponse extends Error {
+}
 export interface RPCLinkOptions<TClientContext extends ClientContext> {
     /**
      * Base url for all requests.
@@ -13,13 +16,17 @@ export interface RPCLinkOptions<TClientContext extends ClientContext> {
      *
      * @default 2083
      */
-    maxURLLength?: number;
+    maxUrlLength?: number;
     /**
      * The method used to make the request.
      *
      * @default 'POST'
      */
-    method?(path: readonly string[], input: unknown, context: TClientContext): Promisable<HTTPMethod | undefined>;
+    method?: Value<HTTPMethod, [
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
     /**
      * The method to use when the payload cannot safely pass to the server with method return from method function.
      * GET is not allowed, it's very dangerous.
@@ -27,20 +34,64 @@ export interface RPCLinkOptions<TClientContext extends ClientContext> {
      * @default 'POST'
      */
     fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
-    headers?(path: readonly string[], input: unknown, context: TClientContext): Promisable<Headers | Record<string, string>>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<[string, string][] | Record<string, string> | Headers, [
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Custom fetch implementation.
+     *
+     * @default globalThis.fetch.bind(globalThis)
+     */
     fetch?: FetchWithContext<TClientContext>;
     rpcSerializer?: RPCSerializer;
+    /**
+     * Maximum number of retry attempts for EventSource errors before throwing.
+     *
+     * @default 5
+     */
+    eventSourceMaxNumberOfRetries?: number;
+    /**
+     * Delay (in ms) before retrying an EventSource call.
+     *
+     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
+     */
+    eventSourceRetryDelay?: Value<number, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Function to determine if an error is retryable.
+     *
+     * @default true
+     */
+    eventSourceRetry?: Value<boolean, [
+        reconnectOptions: EventIteratorReconnectOptions,
+        options: ClientOptionsOut<TClientContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
 }
 export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly fetch;
     private readonly rpcSerializer;
-    private readonly maxURLLength;
+    private readonly maxUrlLength;
     private readonly fallbackMethod;
-    private readonly getMethod;
-    private readonly getHeaders;
+    private readonly method;
+    private readonly headers;
     private readonly url;
+    private readonly eventSourceMaxNumberOfRetries;
+    private readonly eventSourceRetryDelay;
+    private readonly eventSourceRetry;
     constructor(options: RPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-    private encode;
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    private performCall;
+    private encodeRequest;
 }
 //# sourceMappingURL=orpc-link.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,5 +1,6 @@
 import type { ClientContext } from '@orpc/contract';
+import type { ClientOptionsOut } from '../../types';
 export interface FetchWithContext<TClientContext extends ClientContext> {
-    (url: Request | string | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
+    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/dynamic-link.d.ts

@@ -1,13 +1,13 @@
-import type { ClientContext, ClientOptions } from '@orpc/contract';
+import type { ClientContext } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from './types';
+import type { ClientLink, ClientOptionsOut } from './types';
 /**
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
  * based on the request path, input, and context.
  */
 export declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
-    constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
 }
 //# sourceMappingURL=dynamic-link.d.ts.map

package/dist/src/event-iterator-state.d.ts

@@ -0,0 +1,9 @@
+export type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
+export interface EventIteratorState {
+    status: ConnectionStatus;
+    listeners: Array<(newStatus: ConnectionStatus) => void>;
+}
+export declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
+export declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
+export declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+//# sourceMappingURL=event-iterator-state.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -0,0 +1,8 @@
+export interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+export declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,6 +1,8 @@
 /** unnoq */
 export * from './client';
 export * from './dynamic-link';
+export * from './event-iterator';
+export * from './event-iterator-state';
 export * from './types';
 export { isDefinedError, ORPCError, safe } from '@orpc/contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -1,5 +1,8 @@
 import type { ClientContext, ClientOptions } from '@orpc/contract';
+export type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
+    context: TClientContext;
+};
 export interface ClientLink<TClientContext extends ClientContext> {
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -34,17 +34,18 @@
     "dist"
   ],
   "dependencies": {
-    "@tinyhttp/content-disposition": "^2.2.2",
-    "@orpc/contract": "0.38.0",
-    "@orpc/shared": "0.38.0",
-    "@orpc/server": "0.38.0"
+    "@orpc/server-standard": "^0.4.0",
+    "@orpc/server-standard-fetch": "^0.4.0",
+    "@orpc/contract": "0.40.0",
+    "@orpc/server": "0.40.0",
+    "@orpc/shared": "0.40.0"
   },
   "devDependencies": {
     "zod": "^3.24.1",
-    "@orpc/openapi": "0.38.0"
+    "@orpc/openapi": "0.40.0"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }