@orpc/client 0.0.0-next.fd1db03 → 0.0.0-next.ff5907c

package/dist/chunk-2UPNYYFF.js

@@ -0,0 +1,288 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/error.ts
+import { isObject } from "@orpc/shared";
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var ORPCError = class _ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...[options]) {
+    if (options?.status && (options.status < 400 || options.status >= 600)) {
+      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+    }
+    const message = fallbackORPCErrorMessage(code, options?.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options?.status);
+    this.defined = options?.defined ?? false;
+    this.data = options?.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static fromJSON(json, options) {
+    return new _ORPCError(json.code, {
+      ...options,
+      ...json
+    });
+  }
+  static isValidJSON(json) {
+    if (!isObject(json)) {
+      return false;
+    }
+    const validKeys = ["defined", "code", "status", "message", "data"];
+    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+      return false;
+    }
+    return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
+  }
+};
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+
+// 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, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
+import { retry } from "@orpc/shared";
+function mapEventIterator(iterator, maps) {
+  return async function* () {
+    try {
+      while (true) {
+        const { done, value } = await iterator.next();
+        let mappedValue = await maps.value(value, done);
+        if (mappedValue !== value) {
+          const meta = getEventMeta(value);
+          if (meta && isEventMetaContainer(mappedValue)) {
+            mappedValue = withEventMeta(mappedValue, meta);
+          }
+        }
+        if (done) {
+          return mappedValue;
+        }
+        yield mappedValue;
+      }
+    } catch (error) {
+      let mappedError = await maps.error(error);
+      if (mappedError !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isEventMetaContainer(mappedError)) {
+          mappedError = withEventMeta(mappedError, meta);
+        }
+      }
+      throw mappedError;
+    } finally {
+      await iterator.return?.();
+    }
+  }();
+}
+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 {
+  __export,
+  COMMON_ORPC_ERROR_DEFS,
+  fallbackORPCErrorStatus,
+  fallbackORPCErrorMessage,
+  ORPCError,
+  isDefinedError,
+  toORPCError,
+  registerEventIteratorState,
+  updateEventIteratorStatus,
+  onEventIteratorStatusChange,
+  mapEventIterator,
+  createAutoRetryEventIterator
+};
+//# sourceMappingURL=chunk-2UPNYYFF.js.map

package/dist/chunk-TPEMQB7D.js

@@ -0,0 +1,178 @@
+import {
+  ORPCError,
+  mapEventIterator,
+  toORPCError
+} from "./chunk-2UPNYYFF.js";
+
+// src/rpc/serializer.ts
+import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
+import { findDeepMatches, isObject, set } from "@orpc/shared";
+var RPCSerializer = class {
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => serializeRPCJson(value),
+        error: async (e) => {
+          if (e instanceof ErrorEvent) {
+            return new ErrorEvent({
+              data: serializeRPCJson(e.data),
+              cause: e
+            });
+          }
+          return new ErrorEvent({
+            data: serializeRPCJson(toORPCError(e).toJSON()),
+            cause: e
+          });
+        }
+      });
+    }
+    const serializedJSON = serializeRPCJson(data);
+    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
+    if (blobs.length === 0) {
+      return serializedJSON;
+    }
+    const form = new FormData();
+    form.set("data", JSON.stringify(serializedJSON));
+    form.set("maps", JSON.stringify(maps));
+    for (const i in blobs) {
+      form.set(i, blobs[i]);
+    }
+    return form;
+  }
+  deserialize(serialized) {
+    if (isAsyncIteratorObject(serialized)) {
+      return mapEventIterator(serialized, {
+        value: async (value) => deserializeRPCJson(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = deserializeRPCJson(e.data);
+          if (ORPCError.isValidJSON(deserialized)) {
+            return ORPCError.fromJSON(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    if (!(serialized instanceof FormData)) {
+      return deserializeRPCJson(serialized);
+    }
+    const data = JSON.parse(serialized.get("data"));
+    const maps = JSON.parse(serialized.get("maps"));
+    for (const i in maps) {
+      data.json = set(data.json, maps[i], serialized.get(i));
+    }
+    return deserializeRPCJson(data);
+  }
+};
+function serializeRPCJson(value, segments = [], meta = []) {
+  if (typeof value === "bigint") {
+    meta.push(["bigint", segments]);
+    return { json: value.toString(), meta };
+  }
+  if (value instanceof Date) {
+    meta.push(["date", segments]);
+    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+    return { json: data, meta };
+  }
+  if (Number.isNaN(value)) {
+    meta.push(["nan", segments]);
+    return { json: "NaN", meta };
+  }
+  if (value instanceof RegExp) {
+    meta.push(["regexp", segments]);
+    return { json: value.toString(), meta };
+  }
+  if (value instanceof URL) {
+    meta.push(["url", segments]);
+    return { json: value.toString(), meta };
+  }
+  if (isObject(value)) {
+    const json = {};
+    for (const k in value) {
+      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
+    }
+    return { json, meta };
+  }
+  if (Array.isArray(value)) {
+    const json = value.map((v, i) => {
+      if (v === void 0) {
+        meta.push(["undefined", [...segments, i]]);
+        return null;
+      }
+      return serializeRPCJson(v, [...segments, i], meta).json;
+    });
+    return { json, meta };
+  }
+  if (value instanceof Set) {
+    const result = serializeRPCJson(Array.from(value), segments, meta);
+    meta.push(["set", segments]);
+    return result;
+  }
+  if (value instanceof Map) {
+    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
+    meta.push(["map", segments]);
+    return result;
+  }
+  return { json: value, meta };
+}
+function deserializeRPCJson({
+  json,
+  meta
+}) {
+  if (meta.length === 0) {
+    return json;
+  }
+  const ref = { data: json };
+  for (const [type, segments] of meta) {
+    let currentRef = ref;
+    let preSegment = "data";
+    for (let i = 0; i < segments.length; i++) {
+      currentRef = currentRef[preSegment];
+      preSegment = segments[i];
+    }
+    switch (type) {
+      case "nan":
+        currentRef[preSegment] = Number.NaN;
+        break;
+      case "bigint":
+        currentRef[preSegment] = BigInt(currentRef[preSegment]);
+        break;
+      case "date":
+        currentRef[preSegment] = new Date(currentRef[preSegment]);
+        break;
+      case "regexp": {
+        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+        currentRef[preSegment] = new RegExp(pattern, flags);
+        break;
+      }
+      case "url":
+        currentRef[preSegment] = new URL(currentRef[preSegment]);
+        break;
+      case "undefined":
+        currentRef[preSegment] = void 0;
+        break;
+      case "map":
+        currentRef[preSegment] = new Map(currentRef[preSegment]);
+        break;
+      case "set":
+        currentRef[preSegment] = new Set(currentRef[preSegment]);
+        break;
+      /* v8 ignore next 3 */
+      default: {
+        const _expected = type;
+      }
+    }
+  }
+  return ref.data;
+}
+
+export {
+  RPCSerializer,
+  serializeRPCJson
+};
+//# sourceMappingURL=chunk-TPEMQB7D.js.map

package/dist/fetch.js

@@ -1,87 +1,128 @@
-// src/adapters/fetch/orpc-link.ts
-import { ORPCPayloadCodec } from "@orpc/server/fetch";
-import { ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE, trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-var ORPCLink = class {
+import {
+  RPCSerializer
+} from "./chunk-TPEMQB7D.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;
-  payloadCodec;
-  maxURLLength;
+  rpcSerializer;
+  maxUrlLength;
   fallbackMethod;
-  getMethod;
-  getHeaders;
+  method;
+  headers;
   url;
+  eventSourceMaxNumberOfRetries;
+  eventSourceRetryDelay;
+  eventSourceRetry;
   constructor(options) {
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
-    this.maxURLLength = options.maxURLLength ?? 2083;
+    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
+    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);
+    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 decoded = await this.payloadCodec.decode(response);
+    }, 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) {
-      const error = ORPCError.fromJSON(decoded) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: decoded
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Invalid RPC error response",
+        cause: deserialized
       });
-      throw error;
     }
-    return decoded;
+    return deserialized;
   }
-  async encode(path, input, options) {
-    const clientContext = options.context;
-    const expectMethod = await this.getMethod(path, input, clientContext);
-    const methods = /* @__PURE__ */ new Set([expectMethod, this.fallbackMethod]);
-    const baseHeaders = await this.getHeaders(path, input, clientContext);
-    const baseUrl = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    baseHeaders.append(ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE);
-    for (const method of methods) {
-      const url = new URL(baseUrl);
-      const headers = new Headers(baseHeaders);
-      const encoded = this.payloadCodec.encode(input, method, this.fallbackMethod);
-      if (encoded.query) {
-        for (const [key, value] of encoded.query.entries()) {
-          url.searchParams.append(key, value);
-        }
+  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) && !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
+        };
       }
-      if (url.toString().length > this.maxURLLength) {
-        continue;
-      }
-      if (encoded.headers) {
-        for (const [key, value] of encoded.headers.entries()) {
-          headers.append(key, value);
-        }
-      }
-      return {
-        url,
-        headers,
-        method: encoded.method,
-        body: encoded.body
-      };
     }
-    throw new ORPCError({
-      code: "BAD_REQUEST",
-      message: "Cannot encode the request, please check the url length or payload."
-    });
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized
+    };
   }
 };
 export {
-  ORPCLink
+  InvalidEventSourceRetryResponse,
+  RPCLink
 };
 //# sourceMappingURL=fetch.js.map