@orpc/client 0.0.0-next.bf323bf → 0.0.0-next.c0088c7

package/dist/shared/client.DcaJQZfy.mjs

@@ -0,0 +1,265 @@
+import { isObject, isTypescriptObject, retry } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const 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;
+}
+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
+  });
+}
+
+const 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);
+    }
+  };
+}
+
+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 && isTypescriptObject(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 && isTypescriptObject(mappedError)) {
+          mappedError = withEventMeta(mappedError, meta);
+        }
+      }
+      throw mappedError;
+    } finally {
+      await iterator.return?.();
+    }
+  }();
+}
+const 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 iterator. 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 { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, createAutoRetryEventIterator as c, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, onEventIteratorStatusChange as o, registerEventIteratorState as r, toORPCError as t, updateEventIteratorStatus as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.bf323bf",
+  "version": "0.0.0-next.c0088c7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,37 +15,34 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./fetch": {
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/server": "0.0.0-next.bf323bf",
-    "@orpc/contract": "0.0.0-next.bf323bf",
-    "@orpc/shared": "0.0.0-next.bf323bf"
+    "@orpc/shared": "0.0.0-next.c0088c7",
+    "@orpc/standard-server": "0.0.0-next.c0088c7",
+    "@orpc/standard-server-fetch": "0.0.0-next.c0088c7"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.bf323bf"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-HYT35LXG.js

@@ -1,105 +0,0 @@
-// 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,126 +0,0 @@
-import {
-  createAutoRetryEventIterator
-} from "./chunk-HYT35LXG.js";
-
-// src/adapters/fetch/orpc-link.ts
-import { ORPCError } from "@orpc/contract";
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
-import { RPCSerializer } from "@orpc/server/standard";
-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) && !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,58 +0,0 @@
-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]) => {
-    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);
-      }
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// 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/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/contract";
-export {
-  DynamicLink,
-  ORPCError,
-  createAutoRetryEventIterator,
-  createORPCClient,
-  isDefinedError,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  safe,
-  updateEventIteratorStatus
-};
-//# sourceMappingURL=index.js.map

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

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