@orpc/client 0.0.0-next.c59d67c → 0.0.0-next.ca29a36

package/dist/index.js

@@ -1,83 +1,90 @@
-// src/procedure.ts
 import {
-  ORPC_HEADER,
-  ORPC_HEADER_VALUE
-} from "@orpc/contract";
-import { trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-function createProcedureClient(options) {
-  const serializer = new ORPCSerializer();
-  const deserializer = new ORPCDeserializer();
-  const client = async (input) => {
-    const fetch_ = options.fetch ?? fetch;
-    const url = `${trim(options.baseURL, "/")}/${options.path.map(encodeURIComponent).join("/")}`;
-    let headers = await options.headers?.(input);
-    headers = headers instanceof Headers ? headers : new Headers(headers);
-    const { body, headers: headers_ } = serializer.serialize(input);
-    for (const [key, value] of headers_.entries()) {
-      headers.set(key, value);
-    }
-    headers.set(ORPC_HEADER, ORPC_HEADER_VALUE);
-    const response = await fetch_(url, {
-      method: "POST",
-      headers,
-      body
-    });
-    const json = await (async () => {
-      try {
-        return await deserializer.deserialize(response);
-      } catch (e) {
-        throw new ORPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "Cannot parse response.",
-          cause: e
-        });
+  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]) => {
+    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) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
       }
-    })();
-    if (!response.ok) {
-      throw ORPCError.fromJSON(json) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error"
+      return createORPCClient(link, {
+        ...options,
+        path: [...path, key]
       });
     }
-    return json;
-  };
-  return client;
+  });
+  return recursive;
 }
 
-// src/router.ts
-function createRouterClient(options) {
-  const path = options?.path ?? [];
-  const client = new Proxy(
-    createProcedureClient({
-      baseURL: options.baseURL,
-      fetch: options.fetch,
-      headers: options.headers,
-      path
-    }),
-    {
-      get(target, key) {
-        if (typeof key !== "string") {
-          return Reflect.get(target, key);
-        }
-        return createRouterClient({
-          ...options,
-          path: [...path, key]
-        });
-      }
+// src/dynamic-link.ts
+var DynamicLink = class {
+  constructor(linkResolver) {
+    this.linkResolver = linkResolver;
+  }
+  async call(path, input, options) {
+    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 client;
+    return Object.assign(
+      [error, void 0, false],
+      { error, data: void 0, isDefined: false }
+    );
+  }
 }
-
-// src/index.ts
-export * from "@orpc/shared/error";
-var createORPCClient = createRouterClient;
 export {
+  COMMON_ORPC_ERROR_DEFS,
+  DynamicLink,
+  ORPCError,
+  createAutoRetryEventIterator,
   createORPCClient,
-  createProcedureClient,
-  createRouterClient
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
+  isDefinedError,
+  mapEventIterator,
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  safe,
+  toORPCError,
+  updateEventIteratorStatus
 };
 //# sourceMappingURL=index.js.map

package/dist/openapi.js

@@ -0,0 +1,232 @@
+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) => {
+          if (e instanceof ErrorEvent) {
+            return new ErrorEvent({
+              data: this.#serialize(e.data, false),
+              cause: 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-FF5VXXNP.js";
+import "./chunk-7F3XVLRJ.js";
+export {
+  RPCJsonSerializer,
+  RPCSerializer
+};
+//# sourceMappingURL=rpc.js.map

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

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

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

@@ -0,0 +1,98 @@
+import type { Value } from '@orpc/shared';
+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> {
+    /**
+     * 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;
+    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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,9 @@
+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<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { Promisable } from '@orpc/shared';
+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 extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    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/error.d.ts

@@ -0,0 +1,106 @@
+import { type MaybeOptionalOptions } from '@orpc/shared';
+export declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+export type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+export type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+export declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+export declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+export type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+export declare function toORPCError(error: unknown): ORPCError<any, any>;
+//# sourceMappingURL=error.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,12 @@
+export declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
+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