@orpc/client 0.0.0-next.4555a17 → 0.0.0-next.47e44e3

package/dist/fetch.js

@@ -0,0 +1,128 @@
+import {
+  RPCSerializer
+} from "./chunk-OX3K2AN4.js";
+import {
+  ORPCError,
+  createAutoRetryEventIterator
+} from "./chunk-2UPNYYFF.js";
+
+// src/adapters/fetch/rpc-link.ts
+import { isAsyncIteratorObject } from "@orpc/server-standard";
+import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
+import { trim, value } from "@orpc/shared";
+var InvalidEventSourceRetryResponse = class extends Error {
+};
+var RPCLink = class {
+  fetch;
+  rpcSerializer;
+  maxUrlLength;
+  fallbackMethod;
+  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.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.url = options.url;
+    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 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: fetchBody,
+      signal: options.signal
+    }, options, path, input);
+    const body = await toStandardBody(response);
+    const deserialized = (() => {
+      try {
+        return this.rpcSerializer.deserialize(body);
+      } catch (error) {
+        if (response.ok) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Invalid RPC response",
+            cause: error
+          });
+        }
+        throw new ORPCError(response.status.toString(), {
+          message: response.statusText
+        });
+      }
+    })();
+    if (!response.ok) {
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Invalid RPC error response",
+        cause: deserialized
+      });
+    }
+    return deserialized;
+  }
+  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("/")}`);
+    const serialized = this.rpcSerializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !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: expectedMethod,
+          headers,
+          url: getUrl
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized
+    };
+  }
+};
+export {
+  InvalidEventSourceRetryResponse,
+  RPCLink
+};
+//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,86 +1,81 @@
-// src/procedure.ts
-import { ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-var serializer = new ORPCSerializer();
-var deserializer = new ORPCDeserializer();
-function createProcedureClient(options) {
-  const client = async (...args) => {
-    const [input, callerOptions] = args;
-    const fetch_ = options.fetch ?? fetch;
-    const url = `${trim(options.baseURL, "/")}/${options.path.map(encodeURIComponent).join("/")}`;
-    const headers = new Headers({
-      [ORPC_PROTOCOL_HEADER]: ORPC_PROTOCOL_VALUE
-    });
-    let customHeaders = await options.headers?.(input);
-    customHeaders = customHeaders instanceof Headers ? customHeaders : new Headers(customHeaders);
-    for (const [key, value] of customHeaders.entries()) {
-      headers.append(key, value);
-    }
-    const serialized = serializer.serialize(input);
-    for (const [key, value] of serialized.headers.entries()) {
-      headers.append(key, value);
-    }
-    const response = await fetch_(url, {
-      method: "POST",
-      headers,
-      body: serialized.body,
-      signal: callerOptions?.signal
-    });
-    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
-        });
+import {
+  COMMON_ORPC_ERROR_DEFS,
+  ORPCError,
+  createAutoRetryEventIterator,
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
+  isDefinedError,
+  mapEventIterator,
+  onEventIteratorStatusChange,
+  registerEventIteratorState,
+  toORPCError,
+  updateEventIteratorStatus
+} from "./chunk-2UPNYYFF.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 [output, void 0, false];
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return [void 0, error, true];
     }
-  );
-  return client;
+    return [void 0, error, 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,330 @@
+import {
+  ORPCError,
+  __export,
+  mapEventIterator,
+  toORPCError
+} from "./chunk-2UPNYYFF.js";
+
+// src/openapi/bracket-notation.ts
+var bracket_notation_exports = {};
+__export(bracket_notation_exports, {
+  deserialize: () => deserialize,
+  escapeSegment: () => escapeSegment,
+  parsePath: () => parsePath,
+  serialize: () => serialize,
+  stringifyPath: () => stringifyPath
+});
+import { isObject } from "@orpc/shared";
+function serialize(payload, parentKey = "") {
+  if (!Array.isArray(payload) && !isObject(payload))
+    return [["", payload]];
+  const result = [];
+  function helper(value, path) {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        helper(item, [...path, String(index)]);
+      });
+    } else if (isObject(value)) {
+      for (const [key, val] of Object.entries(value)) {
+        helper(val, [...path, key]);
+      }
+    } else {
+      result.push([stringifyPath(path), value]);
+    }
+  }
+  helper(payload, parentKey ? [parentKey] : []);
+  return result;
+}
+function deserialize(entities) {
+  if (entities.length === 0) {
+    return void 0;
+  }
+  const isRootArray = entities.every(([path]) => path === "");
+  const result = isRootArray ? [] : {};
+  const arrayPushPaths = /* @__PURE__ */ new Set();
+  for (const [path, _] of entities) {
+    const segments = parsePath(path);
+    const base = segments.slice(0, -1).join(".");
+    const last = segments[segments.length - 1];
+    if (last === "") {
+      arrayPushPaths.add(base);
+    } else {
+      arrayPushPaths.delete(base);
+    }
+  }
+  function setValue(obj, segments, value, fullPath) {
+    const [first, ...rest_] = segments;
+    if (Array.isArray(obj) && first === "") {
+      ;
+      obj.push(value);
+      return;
+    }
+    const objAsRecord = obj;
+    if (rest_.length === 0) {
+      objAsRecord[first] = value;
+      return;
+    }
+    const rest = rest_;
+    if (rest[0] === "") {
+      const pathToCheck = segments.slice(0, -1).join(".");
+      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
+        if (!(first in objAsRecord)) {
+          objAsRecord[first] = [];
+        }
+        if (Array.isArray(objAsRecord[first])) {
+          ;
+          objAsRecord[first].push(value);
+          return;
+        }
+      }
+      if (!(first in objAsRecord)) {
+        objAsRecord[first] = {};
+      }
+      const target = objAsRecord[first];
+      target[""] = value;
+      return;
+    }
+    if (!(first in objAsRecord)) {
+      objAsRecord[first] = {};
+    }
+    setValue(
+      objAsRecord[first],
+      rest,
+      value,
+      fullPath
+    );
+  }
+  for (const [path, value] of entities) {
+    const segments = parsePath(path);
+    setValue(result, segments, value, path);
+  }
+  return result;
+}
+function escapeSegment(segment) {
+  return segment.replace(/[\\[\]]/g, (match) => {
+    switch (match) {
+      case "\\":
+        return "\\\\";
+      case "[":
+        return "\\[";
+      case "]":
+        return "\\]";
+      default:
+        return match;
+    }
+  });
+}
+function stringifyPath(path) {
+  const [first, ...rest] = path;
+  const firstSegment = escapeSegment(first);
+  const base = first === "" ? "" : firstSegment;
+  return rest.reduce(
+    (result, segment) => `${result}[${escapeSegment(segment)}]`,
+    base
+  );
+}
+function parsePath(path) {
+  if (path === "")
+    return [""];
+  const result = [];
+  let currentSegment = "";
+  let inBracket = false;
+  let bracketContent = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === "\\") {
+      backslashCount++;
+      continue;
+    }
+    if (backslashCount > 0) {
+      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
+      if (char === "[" || char === "]") {
+        if (backslashCount % 2 === 1) {
+          if (inBracket) {
+            bracketContent += literalBackslashes + char;
+          } else {
+            currentSegment += literalBackslashes + char;
+          }
+        } else {
+          if (inBracket) {
+            bracketContent += literalBackslashes;
+          } else {
+            currentSegment += literalBackslashes;
+          }
+          if (char === "[" && !inBracket) {
+            if (currentSegment !== "" || result.length === 0) {
+              result.push(currentSegment);
+            }
+            inBracket = true;
+            bracketContent = "";
+            currentSegment = "";
+          } else if (char === "]" && inBracket) {
+            result.push(bracketContent);
+            inBracket = false;
+            bracketContent = "";
+          } else {
+            if (inBracket) {
+              bracketContent += char;
+            } else {
+              currentSegment += char;
+            }
+          }
+        }
+      } else {
+        const allBackslashes = "\\".repeat(backslashCount);
+        if (inBracket) {
+          bracketContent += allBackslashes + char;
+        } else {
+          currentSegment += allBackslashes + char;
+        }
+      }
+      backslashCount = 0;
+      continue;
+    }
+    if (char === "[" && !inBracket) {
+      if (currentSegment !== "" || result.length === 0) {
+        result.push(currentSegment);
+      }
+      inBracket = true;
+      bracketContent = "";
+      currentSegment = "";
+      continue;
+    }
+    if (char === "]" && inBracket) {
+      result.push(bracketContent);
+      inBracket = false;
+      bracketContent = "";
+      continue;
+    }
+    if (inBracket) {
+      bracketContent += char;
+    } else {
+      currentSegment += char;
+    }
+  }
+  if (backslashCount > 0) {
+    const remainingBackslashes = "\\".repeat(backslashCount);
+    if (inBracket) {
+      bracketContent += remainingBackslashes;
+    } else {
+      currentSegment += remainingBackslashes;
+    }
+  }
+  if (inBracket) {
+    if (currentSegment !== "" || result.length === 0) {
+      result.push(currentSegment);
+    }
+    result.push(`[${bracketContent}`);
+  } else if (currentSegment !== "" || result.length === 0) {
+    result.push(currentSegment);
+  }
+  return result;
+}
+
+// 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 { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
+var OpenAPISerializer = class {
+  constructor(jsonSerializer = new OpenAPIJsonSerializer()) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  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 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 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 {
+  bracket_notation_exports as BracketNotation,
+  OpenAPIJsonSerializer,
+  OpenAPISerializer
+};
+//# sourceMappingURL=openapi.js.map

package/dist/rpc.js

@@ -0,0 +1,10 @@
+import {
+  RPCJsonSerializer,
+  RPCSerializer
+} from "./chunk-OX3K2AN4.js";
+import "./chunk-2UPNYYFF.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