@orpc/client 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/shared/{client.8ug8I-zu.d.ts → client.Dw9_40WO.d.ts}

@@ -1,4 +1,5 @@
 import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse } from '@standard-server/core';
 
 interface ClientContext {
     [key: PropertyKey]: any;
@@ -21,6 +22,11 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type AnyNestedClient = NestedClient<any>;
+/**
+ * Infers the **client context type** required by a client.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-context | Client-Side Clients - Infer Client Context}
+ */
 type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
@@ -29,6 +35,8 @@ interface ClientLink<TClientContext extends ClientContext> {
  * Recursively infers the **input types** from a client.
  *
  * Produces a nested map where each endpoint's input type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-inputs | Client-Side Clients - Infer Client Inputs}
  */
 type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
@@ -38,6 +46,8 @@ type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer
  *
  * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body input types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-inputs | Client-Side Clients - Infer Client Body Inputs}
  */
 type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
     body: infer UBody;
@@ -48,6 +58,8 @@ type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, in
  * Recursively infers the **output types** from a client.
  *
  * Produces a nested map where each endpoint's output type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-outputs | Client-Side Clients - Infer Client Outputs}
  */
 type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
@@ -57,6 +69,8 @@ type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any,
  *
  * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body output types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-outputs | Client-Side Clients - Infer Client Body Outputs}
  */
 type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
     body: infer UBody;
@@ -64,22 +78,33 @@ type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, a
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
 };
 /**
- * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Produces a nested map where each endpoint's error type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-errors | Client-Side Clients - Infer Client Errors}
  */
 type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
 };
 /**
- * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Useful when you want to handle all possible errors from any endpoint at once.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-error | Client-Side Clients - Infer Client Error}
  */
 type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
 }[keyof T];
 
+/**
+ * Default mapping between common oRPC error codes and HTTP status codes.
+ * Handlers use it to determine response status codes; spread it to build a custom `errorStatusMap`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#custom-error-response | RPC Handler - Custom Error Response}
+ * @see {@link https://orpc.dev/docs/openapi/handler#custom-error-response | OpenAPI Handler - Custom Error Response}
+ */
 declare const COMMON_ERROR_STATUS_MAP: {
     BAD_REQUEST: number;
     UNAUTHORIZED: number;
@@ -91,6 +116,7 @@ declare const COMMON_ERROR_STATUS_MAP: {
     TIMEOUT: number;
     CONFLICT: number;
     GONE: number;
+    LENGTH_REQUIRED: number;
     PRECONDITION_FAILED: number;
     PAYLOAD_TOO_LARGE: number;
     UNSUPPORTED_MEDIA_TYPE: number;
@@ -114,24 +140,26 @@ type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
+/**
+ * Typed error carrying a `code`, a `message`, and optional `data`.
+ * Throw it from handlers or middleware to produce typed error responses on the client.
+ *
+ * @see {@link https://orpc.dev/docs/error-handling#orpcerror-class | Error Handling - ORPCError Class}
+ */
 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     /**
-     * @info
-     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * @remarks
+     * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
      * an `ORPCError` instance from plain objects with a similar structure.
      */
     readonly name: "ORPCError" & {
         __branch: "ORPCError";
     };
     /**
-     * Indicates whether the error matches a definition in the procedure's `.errors` map.
+     * Indicates whether the error matches a definition in the procedure's `.errors` map,
+     * which makes its type inferable on the client.
      */
     readonly defined: boolean;
-    /**
-     * Indicates whether the error's type is inferable at the TypeScript level.
-     * This is typically true when the error is explicitly defined or returned within a handler.
-     */
-    readonly inferable: boolean;
     code: TCode;
     data: TData;
     constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
@@ -155,13 +183,26 @@ interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCod
      * remove readonly
      */
     defined: boolean;
-    /**
-     * remove readonly
-     */
-    inferable: boolean;
 }
 type AnyORPCError = ORPCError<any, any>;
 type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+interface MalformedResponseErrorOptions extends ErrorOptions {
+    message?: string;
+    response: StandardResponse;
+}
+/**
+ * Error indicating a response does not follow the expected oRPC format, carrying
+ * the resolved response. Found as the `cause` of a `MALFORMED_ORPC_RESPONSE`
+ * `ORPCError`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare class MalformedResponseError extends Error {
+    readonly name = "MalformedResponseError";
+    response: StandardResponse;
+    constructor(options: MalformedResponseErrorOptions);
+}
 
-export { ORPCError as c, COMMON_ERROR_STATUS_MAP as j };
-export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, ORPCErrorJSON as d, AnyNestedClient as e, InferClientError as f, Client as g, ClientRest as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };
+export { ORPCError as h, COMMON_ERROR_STATUS_MAP as j, MalformedResponseError as p };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, MalformedResponseErrorOptions as M, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as g, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as q };

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.41",
+  "description": "Consume oRPC and OpenAPI APIs with end-to-end type safety over HTTP, WebSocket, or message ports",
   "license": "MIT",
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
+  ],
   "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
@@ -10,7 +15,15 @@
     "directory": "packages/client"
   },
   "keywords": [
-    "orpc"
+    "orpc",
+    "rpc",
+    "api",
+    "typescript",
+    "typesafe",
+    "client",
+    "fetch",
+    "websocket",
+    "openapi"
   ],
   "sideEffects": false,
   "exports": {
@@ -50,16 +63,17 @@
     "dist"
   ],
   "dependencies": {
-    "@standardserver/core": "^0.0.25",
-    "@standardserver/fetch": "^0.0.25",
-    "@standardserver/peer": "^0.0.25",
-    "@orpc/shared": "2.0.0-beta.4"
+    "@orpc/shared": "2.0.0-beta.41",
+    "@standard-server/core": "~0.10.0",
+    "@standard-server/fetch": "~0.10.0",
+    "@standard-server/peer": "~0.10.0"
   },
   "devDependencies": {
-    "zod": "^4.4.3"
+    "@types/ws": "^8.18.1",
+    "ws": "^8.21.3",
+    "zod": "^4.5.4"
   },
   "scripts": {
-    "build": "unbuild",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/client.DMXKFDyV.mjs

@@ -1,343 +0,0 @@
-import { isPlainObject, wrapAsyncIterator, isTypescriptObject, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
-import { getEventMeta, withEventMeta, ErrorEvent } from '@standardserver/core';
-import { O as ORPCError } from './client.Dnfj8jnT.mjs';
-
-function isInferableError(error) {
-  return error instanceof ORPCError && error.inferable;
-}
-function toORPCError(error) {
-  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", { cause: error });
-}
-function isORPCErrorJson(json) {
-  if (!isPlainObject(json)) {
-    return false;
-  }
-  const validKeys = ["defined", "inferable", "code", "message", "data"];
-  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
-    return false;
-  }
-  return "defined" in json && typeof json.defined === "boolean" && "inferable" in json && typeof json.inferable === "boolean" && "code" in json && typeof json.code === "string" && "message" in json && typeof json.message === "string";
-}
-function createORPCErrorFromJson(json, options = {}) {
-  const error = new ORPCError(json.code, {
-    ...json,
-    ...options
-  });
-  error.defined = json.defined;
-  error.inferable = json.inferable;
-  return error;
-}
-function cloneORPCError(error) {
-  const cloned = new ORPCError(error.code, {
-    ...error,
-    message: error.message,
-    data: error.data,
-    cause: error.cause
-  });
-  cloned.stack = error.stack;
-  cloned.defined = error.defined;
-  cloned.inferable = error.inferable;
-  return cloned;
-}
-
-function wrapEventIteratorPreservingMeta(iterator, { mapResult, mapError, ...rest }) {
-  return wrapAsyncIterator(iterator, {
-    ...rest,
-    mapResult: mapResult && (async (result) => {
-      const mapped = await mapResult(result);
-      if (mapped.value !== result.value) {
-        const meta = getEventMeta(result.value);
-        if (meta && isTypescriptObject(mapped.value)) {
-          return { done: mapped.done, value: withEventMeta(mapped.value, meta) };
-        }
-      }
-      return mapped;
-    }),
-    mapError: mapError && (async (error) => {
-      const mapped = await mapError(error);
-      if (mapped !== error) {
-        const meta = getEventMeta(error);
-        if (meta && isTypescriptObject(mapped)) {
-          return withEventMeta(mapped, meta);
-        }
-      }
-      return mapped;
-    })
-  });
-}
-
-const REGEX_STRING_PATTERN = /^\/(.*)\/([a-z]*)$/;
-const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
-  undefined: {
-    condition(data) {
-      return data === void 0;
-    },
-    serialize() {
-      return null;
-    },
-    deserialize() {
-      return void 0;
-    },
-    isTerminal: true
-  },
-  bigint: {
-    condition(data) {
-      return typeof data === "bigint";
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      return BigInt(serialized);
-    },
-    isTerminal: true
-  },
-  date: {
-    condition(data) {
-      return data instanceof Date;
-    },
-    serialize(data) {
-      if (Number.isNaN(data.getTime())) {
-        return null;
-      }
-      return data.toISOString();
-    },
-    deserialize(serialized) {
-      return new Date(serialized ?? "Invalid Date");
-    },
-    isTerminal: true
-  },
-  nan: {
-    condition(data) {
-      return typeof data === "number" && Number.isNaN(data);
-    },
-    serialize() {
-      return null;
-    },
-    deserialize() {
-      return Number.NaN;
-    },
-    isTerminal: true
-  },
-  url: {
-    condition(data) {
-      return data instanceof URL;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      return new URL(serialized);
-    },
-    isTerminal: true
-  },
-  regexp: {
-    condition(data) {
-      return data instanceof RegExp;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      const [, pattern, flags] = serialized.match(REGEX_STRING_PATTERN);
-      return new RegExp(pattern, flags);
-    },
-    isTerminal: true
-  },
-  set: {
-    condition(data) {
-      return data instanceof Set;
-    },
-    serialize(data) {
-      return Array.from(data);
-    },
-    deserialize(serialized) {
-      return new Set(serialized);
-    }
-  },
-  map: {
-    condition(data) {
-      return data instanceof Map;
-    },
-    serialize(data) {
-      return Array.from(data.entries());
-    },
-    deserialize(serialized) {
-      return new Map(serialized);
-    }
-  }
-};
-class RPCJsonSerializer {
-  handlers;
-  omitUndefinedProperties;
-  constructor(options = {}) {
-    this.handlers = {
-      ...DEFAULT_RPC_JSON_SERIALIZER_HANDLERS,
-      ...options.handlers
-    };
-    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
-  }
-  serialize(data) {
-    const [json, meta_, maps, blobs] = this.serializeValue(data, [], [], [], []);
-    const meta = meta_.length === 0 ? void 0 : meta_;
-    if (maps.length === 0) {
-      return { json, meta };
-    }
-    return { json, meta, maps, blobs };
-  }
-  serializeValue(data, segments, meta, maps, blobs) {
-    for (const key in this.handlers) {
-      const handler = this.handlers[key];
-      if (handler && handler.condition(data)) {
-        const serialized = handler.serialize(data);
-        if (handler.isTerminal) {
-          meta.push([key, ...segments]);
-          return [serialized, meta, maps, blobs];
-        }
-        const result = this.serializeValue(serialized, segments, meta, maps, blobs);
-        meta.push([key, ...segments]);
-        return result;
-      }
-    }
-    if (data instanceof Blob) {
-      maps.push(segments);
-      blobs.push(data);
-      return [data, meta, maps, blobs];
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        return this.serializeValue(v, [...segments, i], meta, maps, blobs)[0];
-      });
-      return [json, meta, maps, blobs];
-    }
-    if (isPlainObject(data)) {
-      const json = {};
-      for (const k in data) {
-        const v = data[k];
-        if (k === "toJSON" && typeof v === "function") {
-          continue;
-        }
-        if (v === void 0 && this.omitUndefinedProperties) {
-          continue;
-        }
-        json[k] = this.serializeValue(v, [...segments, k], meta, maps, blobs)[0];
-      }
-      return [json, meta, maps, blobs];
-    }
-    return [data, meta, maps, blobs];
-  }
-  deserialize(serialized) {
-    const ref = { data: serialized.json };
-    if (serialized.blobs?.length) {
-      serialized.maps.forEach((segments, i) => {
-        let currentRef = ref;
-        let preSegment = "data";
-        segments.forEach((segment) => {
-          currentRef = currentRef[preSegment];
-          preSegment = segment;
-          if (!Object.hasOwn(currentRef, preSegment)) {
-            throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
-          }
-        });
-        currentRef[preSegment] = serialized.blobs[i];
-      });
-    }
-    serialized.meta?.forEach((item) => {
-      const type = item[0];
-      let currentRef = ref;
-      let preSegment = "data";
-      for (let i = 1; i < item.length; i++) {
-        currentRef = currentRef[preSegment];
-        preSegment = item[i];
-        if (!Object.hasOwn(currentRef, preSegment)) {
-          throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
-        }
-      }
-      currentRef[preSegment] = this.handlers[type].deserialize(currentRef[preSegment]);
-    });
-    return ref.data;
-  }
-}
-
-class RPCSerializer {
-  jsonSerializer;
-  defaultSerializeOptions;
-  constructor(options = {}) {
-    this.jsonSerializer = new RPCJsonSerializer(options);
-    this.defaultSerializeOptions = options.serialize;
-  }
-  serialize(data, options = {}) {
-    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return wrapEventIteratorPreservingMeta(data, {
-        mapResult: (result) => {
-          if (result.value === void 0) {
-            return result;
-          }
-          return { done: result.done, value: this.serializeValue(result.value, options) };
-        },
-        mapError: (e) => new ErrorEvent(
-          this.serializeValue(toORPCError(e).toJSON(), { ...options, useFormDataForBlobFields: false }),
-          { cause: e }
-        )
-      });
-    }
-    return this.serializeValue(data, options);
-  }
-  serializeValue(data, options) {
-    const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
-    const { json, meta, maps, blobs } = this.jsonSerializer.serialize(data);
-    if (!useFormDataForBlobs || !blobs?.length) {
-      return { json, meta };
-    }
-    const form = new FormData();
-    form.set("data", stringifyJSON({ json, meta, maps }));
-    blobs.forEach((blob, i) => {
-      form.set(i.toString(), blob);
-    });
-    return form;
-  }
-  deserialize(data) {
-    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return wrapEventIteratorPreservingMeta(data, {
-        mapResult: (result) => {
-          if (result.value === void 0) {
-            return result;
-          }
-          return { done: result.done, value: this.deserializeValue(result.value) };
-        },
-        mapError: (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = this.deserializeValue(e.data);
-          if (isORPCErrorJson(deserialized)) {
-            return createORPCErrorFromJson(deserialized, { cause: e });
-          }
-          return new ErrorEvent(deserialized, { cause: e });
-        }
-      });
-    }
-    return this.deserializeValue(data);
-  }
-  deserializeValue(data) {
-    if (!(data instanceof FormData)) {
-      return this.jsonSerializer.deserialize(data);
-    }
-    const serialized = JSON.parse(data.get("data"));
-    const blobs = [];
-    for (const [key, value] of data.entries()) {
-      if (value instanceof Blob) {
-        blobs[Number(key)] = value;
-      }
-    }
-    return this.jsonSerializer.deserialize({ ...serialized, blobs });
-  }
-}
-
-export { RPCSerializer as R, isInferableError as a, RPCJsonSerializer as b, createORPCErrorFromJson as c, cloneORPCError as d, isORPCErrorJson as i, toORPCError as t, wrapEventIteratorPreservingMeta as w };