@orpc/client 0.0.0-next.b825e0c → 0.0.0-next.b83dcee

package/dist/shared/client.pA2wFdly.mjs

@@ -0,0 +1,208 @@
+import { resolveMaybeOptionalOptions, getConstructor, isObject, AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.b83dcee";
+
+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;
+}
+const GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+void (globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+const globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== void 0 && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    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
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (globalORPCErrorConstructors.has(this)) {
+      const constructor = getConstructor(instance);
+      if (constructor && globalORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+globalORPCErrorConstructors.add(ORPCError);
+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
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(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" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+
+function mapEventIterator(iterator, maps) {
+  const mapError = async (error) => {
+    let mappedError = await maps.error(error);
+    if (mappedError !== error) {
+      const meta = getEventMeta(error);
+      if (meta && isTypescriptObject(mappedError)) {
+        mappedError = withEventMeta(mappedError, meta);
+      }
+    }
+    return mappedError;
+  };
+  return new AsyncIteratorClass(async () => {
+    const { done, value } = await (async () => {
+      try {
+        return await iterator.next();
+      } catch (error) {
+        throw await mapError(error);
+      }
+    })();
+    let mappedValue = await maps.value(value, done);
+    if (mappedValue !== value) {
+      const meta = getEventMeta(value);
+      if (meta && isTypescriptObject(mappedValue)) {
+        mappedValue = withEventMeta(mappedValue, meta);
+      }
+    }
+    return { done, value: mappedValue };
+  }, async () => {
+    try {
+      await iterator.return?.();
+    } catch (error) {
+      throw await mapError(error);
+    }
+  });
+}
+
+export { COMMON_ORPC_ERROR_DEFS as C, ORPC_CLIENT_PACKAGE_NAME as O, ORPC_CLIENT_PACKAGE_VERSION as a, fallbackORPCErrorMessage as b, ORPCError as c, isORPCErrorStatus as d, isORPCErrorJson as e, fallbackORPCErrorStatus as f, createORPCErrorFromJson as g, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.b825e0c",
+  "version": "0.0.0-next.b83dcee",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,36 +15,50 @@
   ],
   "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"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "content-disposition": "^0.5.4",
-    "@orpc/contract": "0.0.0-next.b825e0c",
-    "@orpc/server": "0.0.0-next.b825e0c",
-    "@orpc/shared": "0.0.0-next.b825e0c"
+    "@orpc/standard-server-fetch": "0.0.0-next.b83dcee",
+    "@orpc/shared": "0.0.0-next.b83dcee",
+    "@orpc/standard-server-peer": "0.0.0-next.b83dcee",
+    "@orpc/standard-server": "0.0.0-next.b83dcee"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.b825e0c"
+    "zod": "^4.1.5"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/fetch.js

@@ -1,103 +0,0 @@
-// src/adapters/fetch/orpc-link.ts
-import { ORPCError } from "@orpc/contract";
-import { fetchReToStandardBody } from "@orpc/server/fetch";
-import { RPCSerializer } from "@orpc/server/standard";
-import { isPlainObject, trim } from "@orpc/shared";
-import cd from "content-disposition";
-var RPCLink = class {
-  fetch;
-  rpcSerializer;
-  maxURLLength;
-  fallbackMethod;
-  getMethod;
-  getHeaders;
-  url;
-  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.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));
-    };
-  }
-  async call(path, input, options) {
-    const clientContext = options.context;
-    const encoded = await this.encode(path, input, options);
-    if (encoded.body instanceof Blob && !encoded.headers.has("content-disposition")) {
-      encoded.headers.set("content-disposition", cd(encoded.body instanceof File ? encoded.body.name : "blob"));
-    }
-    const response = await this.fetch(encoded.url, {
-      method: encoded.method,
-      headers: encoded.headers,
-      body: encoded.body,
-      signal: options.signal
-    }, clientContext);
-    const body = await fetchReToStandardBody(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) {
-      return deserialized;
-    }
-    throw ORPCError.fromJSON(deserialized);
-  }
-  async encode(path, input, options) {
-    const clientContext = options.context;
-    const expectMethod = await this.getMethod(path, input, clientContext);
-    const headers = await this.getHeaders(path, input, clientContext);
-    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    headers.append("x-orpc-handler", "rpc");
-    const serialized = this.rpcSerializer.serialize(input);
-    if (expectMethod === "GET" && isPlainObject(serialized)) {
-      const tryURL = new URL(url);
-      tryURL.searchParams.append("data", JSON.stringify(serialized));
-      if (tryURL.toString().length <= this.maxURLLength) {
-        return {
-          body: void 0,
-          method: expectMethod,
-          headers,
-          url: tryURL
-        };
-      }
-    }
-    const method = expectMethod === "GET" ? this.fallbackMethod : expectMethod;
-    if (isPlainObject(serialized)) {
-      if (!headers.has("content-type")) {
-        headers.set("content-type", "application/json");
-      }
-      return {
-        body: JSON.stringify(serialized),
-        method,
-        headers,
-        url
-      };
-    }
-    return {
-      body: serialized,
-      method,
-      headers,
-      url
-    };
-  }
-};
-export {
-  RPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,42 +0,0 @@
-// src/client.ts
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
-  const procedureClient = async (...[input, options2]) => {
-    return await link.call(path, input, options2 ?? {});
-  };
-  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(path, input, options.context);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/contract";
-export {
-  DynamicLink,
-  ORPCError,
-  createORPCClient,
-  isDefinedError,
-  safe
-};
-//# 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

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

@@ -1,46 +0,0 @@
-import type { ClientOptions, HTTPMethod } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from '../../types';
-import type { FetchWithContext } from './types';
-import { RPCSerializer } from '@orpc/server/standard';
-export interface RPCLinkOptions<TClientContext> {
-    /**
-     * 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?(path: readonly string[], input: unknown, context: TClientContext): Promisable<HTTPMethod | undefined>;
-    /**
-     * 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'>;
-    headers?(path: readonly string[], input: unknown, context: TClientContext): Promisable<Headers | Record<string, string>>;
-    fetch?: FetchWithContext<TClientContext>;
-    rpcSerializer?: RPCSerializer;
-}
-export declare class RPCLink<TClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly rpcSerializer;
-    private readonly maxURLLength;
-    private readonly fallbackMethod;
-    private readonly getMethod;
-    private readonly getHeaders;
-    private readonly url;
-    constructor(options: RPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-    private encode;
-}
-//# sourceMappingURL=orpc-link.d.ts.map

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

@@ -1,4 +0,0 @@
-export interface FetchWithContext<TClientContext> {
-    (input: RequestInfo | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -1,11 +0,0 @@
-import type { AnyContractRouter, ContractRouterClient } from '@orpc/contract';
-import type { AnyRouter, RouterClient } from '@orpc/server';
-import type { ClientLink } 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<TRouter extends AnyRouter | AnyContractRouter, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): TRouter extends AnyRouter ? RouterClient<TRouter, TClientContext> : TRouter extends AnyContractRouter ? ContractRouterClient<TRouter, TClientContext> : never;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1,13 +0,0 @@
-import type { ClientOptions } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } 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> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=dynamic-link.d.ts.map

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-/** unnoq */
-export * from './client';
-export * from './dynamic-link';
-export * from './types';
-export { isDefinedError, ORPCError, safe } from '@orpc/contract';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -1,5 +0,0 @@
-import type { ClientOptions } from '@orpc/contract';
-export interface ClientLink<TClientContext> {
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=types.d.ts.map