@orpc/client 0.0.0-next.ccd4e42 → 0.0.0-next.d0e429d

package/dist/fetch.js

@@ -1,43 +1,76 @@
-// src/adapters/fetch/orpc-link.ts
-import { ORPCError } from "@orpc/contract";
-import { fetchReToStandardBody } from "@orpc/server/fetch";
-import { RPCSerializer } from "@orpc/server/standard";
-import { isPlainObject, trim } from "@orpc/shared";
-import cd from "content-disposition";
+import {
+  RPCSerializer
+} from "./chunk-I4MCMTJ2.js";
+import {
+  ORPCError,
+  createAutoRetryEventIterator
+} from "./chunk-7F3XVLRJ.js";
+
+// src/adapters/fetch/rpc-link.ts
+import { isAsyncIteratorObject, stringifyJSON, trim, value } from "@orpc/shared";
+import { toFetchBody, toStandardBody } from "@orpc/standard-server-fetch";
+var InvalidEventSourceRetryResponse = class extends Error {
+};
 var RPCLink = class {
   fetch;
   rpcSerializer;
-  maxURLLength;
+  maxUrlLength;
   fallbackMethod;
-  getMethod;
-  getHeaders;
+  method;
+  headers;
   url;
+  eventSourceMaxNumberOfRetries;
+  eventSourceRetryDelay;
+  eventSourceRetry;
+  toFetchBodyOptions;
   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);
+    this.toFetchBodyOptions = options;
   }
   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", cd(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, this.toFetchBodyOptions);
+    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,51 +86,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" && isPlainObject(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) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(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 (isPlainObject(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,27 @@
+import {
+  COMMON_ORPC_ERROR_DEFS,
+  ORPCError,
+  createAutoRetryEventIterator,
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
+  isDefinedError,
+  mapEventIterator,
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  toORPCError,
+  updateEventIteratorStatus
+} from "./chunk-7F3XVLRJ.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,19 +43,52 @@ var DynamicLink = class {
     this.linkResolver = linkResolver;
   }
   async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(path, input, options.context);
+    const resolvedLink = await this.linkResolver(options, path, input);
     const output = await resolvedLink.call(path, input, options);
     return output;
   }
 };
 
+// src/utils.ts
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return Object.assign(
+      [null, output, false],
+      { error: null, data: output, isDefined: false }
+    );
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return Object.assign(
+        [error, void 0, true],
+        { error, data: void 0, isDefined: true }
+      );
+    }
+    return Object.assign(
+      [error, void 0, false],
+      { error, data: void 0, isDefined: false }
+    );
+  }
+}
+
 // src/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/contract";
+import { ErrorEvent } from "@orpc/standard-server";
 export {
+  COMMON_ORPC_ERROR_DEFS,
   DynamicLink,
+  ErrorEvent,
   ORPCError,
+  createAutoRetryEventIterator,
   createORPCClient,
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
   isDefinedError,
-  safe
+  mapEventIterator,
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  safe,
+  toORPCError,
+  updateEventIteratorStatus
 };
 //# sourceMappingURL=index.js.map

package/dist/openapi.js

@@ -0,0 +1,226 @@
+import {
+  ORPCError,
+  mapEventIterator,
+  toORPCError
+} from "./chunk-7F3XVLRJ.js";
+
+// src/openapi/bracket-notation.ts
+import { isObject } from "@orpc/shared";
+var BracketNotationSerializer = class {
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.serialize(item, [...segments, i], result);
+      });
+    } else if (isObject(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
+      }
+    } else {
+      result.push([this.stringifyPath(segments), data]);
+    }
+    return result;
+  }
+  deserialize(serialized) {
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
+        }
+        if (i !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
+            currentRef[nextSegment] = { ...currentRef[nextSegment] };
+          }
+        } else {
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            } else {
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
+              } else if (!isValidArrayIndex(segment)) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            }
+          }
+        }
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef)) {
+        if (nextSegment === "") {
+          arrayPushStyles.add(currentRef);
+          currentRef.push(value);
+        } else {
+          currentRef[Number(nextSegment)] = value;
+        }
+      } else {
+        currentRef[nextSegment] = value;
+      }
+    }
+    return ref.value;
+  }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i) => {
+      if (i === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
+  }
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path] : segments;
+  }
+};
+function isValidArrayIndex(value) {
+  return /^0$|^[1-9]\d*$/.test(value);
+}
+
+// src/openapi/json-serializer.ts
+import { isObject as isObject2 } from "@orpc/shared";
+var OpenAPIJsonSerializer = class {
+  serialize(data, hasBlobRef = { value: false }) {
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json, hasBlobRef.value];
+    }
+    if (isObject2(data)) {
+      const json = {};
+      for (const k in data) {
+        json[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
+    }
+    return [data, hasBlobRef.value];
+  }
+};
+
+// src/openapi/serializer.ts
+import { isAsyncIteratorObject } from "@orpc/shared";
+import { ErrorEvent } from "@orpc/standard-server";
+var OpenAPISerializer = class {
+  constructor(jsonSerializer = new OpenAPIJsonSerializer(), bracketNotation = new BracketNotationSerializer()) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    if (data instanceof Blob || data === void 0) {
+      return data;
+    }
+    const [json, hasBlob] = this.jsonSerializer.serialize(data);
+    if (!enableFormData || !hasBlob) {
+      return json;
+    }
+    const form = new FormData();
+    for (const [path, value] of this.bracketNotation.serialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => value,
+        error: async (e) => {
+          if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
+            return ORPCError.fromJSON(e.data, { cause: e });
+          }
+          return e;
+        }
+      });
+    }
+    return data;
+  }
+};
+export {
+  BracketNotationSerializer,
+  OpenAPIJsonSerializer,
+  OpenAPISerializer
+};
+//# sourceMappingURL=openapi.js.map

package/dist/rpc.js

@@ -0,0 +1,10 @@
+import {
+  RPCJsonSerializer,
+  RPCSerializer
+} from "./chunk-I4MCMTJ2.js";
+import "./chunk-7F3XVLRJ.js";
+export {
+  RPCJsonSerializer,
+  RPCSerializer
+};
+//# sourceMappingURL=rpc.js.map

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

@@ -1,3 +1,3 @@
-export * from './orpc-link';
+export * from './rpc-link';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,100 @@
+import type { Value } from '@orpc/shared';
+import type { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
+import type { ClientContext, ClientLink, ClientOptionsOut } from '../../types';
+import type { FetchWithContext } from './types';
+import { type EventIteratorReconnectOptions } from '../../event-iterator';
+import { RPCSerializer } from '../../rpc';
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export declare class InvalidEventSourceRetryResponse extends Error {
+}
+export interface RPCLinkOptions<TClientContext extends ClientContext> extends ToFetchBodyOptions {
+    /**
+     * Base url for all requests.
+     */
+    url: string;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: number;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    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.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * 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 fallbackMethod;
+    private readonly method;
+    private readonly headers;
+    private readonly url;
+    private readonly eventSourceMaxNumberOfRetries;
+    private readonly eventSourceRetryDelay;
+    private readonly eventSourceRetry;
+    private readonly toFetchBodyOptions;
+    constructor(options: RPCLinkOptions<TClientContext>);
+    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    private performCall;
+    private encodeRequest;
+}
+export {};
+//# sourceMappingURL=rpc-link.d.ts.map

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

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

package/dist/src/client.d.ts

@@ -1,11 +1,9 @@
-import type { AnyContractRouter, ContractRouterClient } from '@orpc/contract';
-import type { AnyRouter, RouterClient } from '@orpc/server';
-import type { ClientLink } from './types';
+import type { ClientLink, InferClientContext, NestedClient } from './types';
 export interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
     path?: string[];
 }
-export declare function createORPCClient<TRouter extends AnyRouter | AnyContractRouter, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): TRouter extends AnyRouter ? RouterClient<TRouter, TClientContext> : TRouter extends AnyContractRouter ? ContractRouterClient<TRouter, TClientContext> : never;
+export declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 //# sourceMappingURL=client.d.ts.map

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

@@ -1,13 +1,12 @@
-import type { ClientOptions } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from './types';
+import type { ClientContext, 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> implements ClientLink<TClientContext> {
+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