@orpc/client 0.0.0-next.d7b5662 → 0.0.0-next.d7ee74c

package/dist/shared/client.i2uoJbEp.d.ts

@@ -0,0 +1,83 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? 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).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? 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).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientErrorUnion<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrorUnion<T[K]> : never;
+}[keyof T];
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f, InferClientInputs as g, InferClientBodyInputs as h, InferClientOutputs as i, InferClientBodyOutputs as j, InferClientErrors as k, InferClientErrorUnion as l };

package/dist/shared/client.wwGi6dZj.mjs

@@ -0,0 +1,171 @@
+import { resolveMaybeOptionalOptions, getConstructor, isObject } from '@orpc/shared';
+
+const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.d7ee74c";
+
+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
+  });
+}
+
+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, toORPCError as t };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.d7b5662",
+  "version": "0.0.0-next.d7ee74c",
   "license": "MIT",
-  "homepage": "https://orpc.unnoq.com",
+  "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/unnoq/orpc.git",
@@ -15,37 +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"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
+    },
+    "./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"
   ],
-  "peerDependencies": {
-    "@orpc/contract": "0.0.0-next.d7b5662"
-  },
   "dependencies": {
-    "@orpc/server": "0.0.0-next.d7b5662",
-    "@orpc/shared": "0.0.0-next.d7b5662"
+    "@orpc/standard-server-fetch": "0.0.0-next.d7ee74c",
+    "@orpc/shared": "0.0.0-next.d7ee74c",
+    "@orpc/standard-server-peer": "0.0.0-next.d7ee74c",
+    "@orpc/standard-server": "0.0.0-next.d7ee74c"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.d7b5662"
+    "zod": "^4.2.1"
   },
   "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,46 +0,0 @@
-// 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 {
-  constructor(options) {
-    this.options = options;
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
-  }
-  fetch;
-  payloadCodec;
-  async call(path, input, options) {
-    const url = `${trim(this.options.url, "/")}/${path.map(encodeURIComponent).join("/")}`;
-    const encoded = this.payloadCodec.encode(input);
-    const headers = new Headers(encoded.headers);
-    headers.append(ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE);
-    const clientContext = options.context;
-    let customHeaders = await this.options.headers?.(input, clientContext);
-    customHeaders = customHeaders instanceof Headers ? customHeaders : new Headers(customHeaders);
-    for (const [key, value] of customHeaders.entries()) {
-      headers.append(key, value);
-    }
-    const response = await this.fetch(url, {
-      method: "POST",
-      headers,
-      body: encoded.body,
-      signal: options.signal
-    }, clientContext);
-    const decoded = await this.payloadCodec.decode(response);
-    if (!response.ok) {
-      const error = ORPCError.fromJSON(decoded) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: decoded
-      });
-      throw error;
-    }
-    return decoded;
-  }
-};
-export {
-  ORPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,39 +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);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/index.ts
-export * from "@orpc/shared/error";
-export {
-  DynamicLink,
-  createORPCClient
-};
-//# 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,19 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-import type { Promisable } from '@orpc/shared';
-import type { ClientLink } from '../../types';
-import type { FetchWithContext } from './types';
-import { type PublicORPCPayloadCodec } from '@orpc/server/fetch';
-export interface ORPCLinkOptions<TClientContext> {
-    url: string;
-    headers?: (input: unknown, context: TClientContext) => Promisable<Headers | Record<string, string>>;
-    fetch?: FetchWithContext<TClientContext>;
-    payloadCodec?: PublicORPCPayloadCodec;
-}
-export declare class ORPCLink<TClientContext> implements ClientLink<TClientContext> {
-    private readonly options;
-    private readonly fetch;
-    private readonly payloadCodec;
-    constructor(options: ORPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
-}
-//# 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 { ContractRouter } from '@orpc/contract';
-import type { ANY_ROUTER, 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 ANY_ROUTER | ContractRouter, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): RouterClient<TRouter, TClientContext>;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1,15 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-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, options: ProcedureClientOptions<TClientContext> & {
-        context: TClientContext;
-    }) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<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 * from '@orpc/shared/error';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

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