@orpc/client 0.0.0-next.b0f324e → 0.0.0-next.b12bcdb

package/dist/adapters/message-port/index.mjs

@@ -0,0 +1,72 @@
+import { ClientPeer } from '@orpc/standard-server-peer';
+import '@orpc/shared';
+import { c as StandardRPCLink } from '../../shared/client.Bp1jlnBk.mjs';
+import '@orpc/standard-server';
+import '@orpc/standard-server-fetch';
+import '../../shared/client.txdq_i5V.mjs';
+
+function postMessagePortMessage(port, data) {
+  port.postMessage(data);
+}
+function onMessagePortMessage(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("message", (event) => {
+      callback(event.data);
+    });
+  } else if ("on" in port) {
+    port.on("message", (event) => {
+      callback(event?.data);
+    });
+  } else if ("onMessage" in port) {
+    port.onMessage.addListener((data) => {
+      callback(data);
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onMessage method on the port");
+  }
+}
+function onMessagePortClose(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("close", async () => {
+      callback();
+    });
+  } else if ("on" in port) {
+    port.on("close", async () => {
+      callback();
+    });
+  } else if ("onDisconnect" in port) {
+    port.onDisconnect.addListener(() => {
+      callback();
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onDisconnect method on the port");
+  }
+}
+
+class LinkMessagePortClient {
+  peer;
+  constructor(options) {
+    this.peer = new ClientPeer((message) => {
+      return postMessagePortMessage(options.port, message);
+    });
+    onMessagePortMessage(options.port, async (message) => {
+      await this.peer.message(message);
+    });
+    onMessagePortClose(options.port, () => {
+      this.peer.close();
+    });
+  }
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkMessagePortClient(options);
+    super(linkClient, { ...options, url: "orpc:/" });
+  }
+}
+
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };

package/dist/adapters/standard/index.d.mts

@@ -1,22 +1,11 @@
-import { Segment } from '@orpc/shared';
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.Bwgm6dgk.mjs';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client._Y_enhib.mjs';
+import { StandardHeaders } from '@orpc/standard-server';
+import { H as HTTPPath } from '../../shared/client.BOYsZIRq.mjs';
+import '@orpc/shared';
 
-type RPCJsonSerializedMeta = [
-    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
-    Segment[]
-][];
-type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
-declare class RPCJsonSerializer {
-    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
-}
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function toStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-declare class RPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };
+export { getMalformedResponseErrorCode, toHttpPath, toStandardHeaders };

package/dist/adapters/standard/index.d.ts

@@ -1,22 +1,11 @@
-import { Segment } from '@orpc/shared';
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.BG98rYdO.js';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.CVVVqf1Y.js';
+import { StandardHeaders } from '@orpc/standard-server';
+import { H as HTTPPath } from '../../shared/client.BOYsZIRq.js';
+import '@orpc/shared';
 
-type RPCJsonSerializedMeta = [
-    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
-    Segment[]
-][];
-type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
-declare class RPCJsonSerializer {
-    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
-}
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function toStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-declare class RPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };
+export { getMalformedResponseErrorCode, toHttpPath, toStandardHeaders };

package/dist/adapters/standard/index.mjs

@@ -1,4 +1,5 @@
-export { R as RPCJsonSerializer, a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+export { C as CompositeStandardLinkPlugin, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLink, d as StandardRPCLinkCodec, e as StandardRPCSerializer, g as getMalformedResponseErrorCode, t as toHttpPath, f as toStandardHeaders } from '../../shared/client.Bp1jlnBk.mjs';
 import '@orpc/shared';
 import '@orpc/standard-server';
-import '../../shared/client.Ly4zGQrc.mjs';
+import '../../shared/client.txdq_i5V.mjs';
+import '@orpc/standard-server-fetch';

package/dist/adapters/websocket/index.d.mts

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.mjs';
+import { f as StandardLinkClient } from '../../shared/client.Bwgm6dgk.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client._Y_enhib.mjs';
+import '@orpc/shared';
+
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

package/dist/adapters/websocket/index.d.ts

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.js';
+import { f as StandardLinkClient } from '../../shared/client.BG98rYdO.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.CVVVqf1Y.js';
+import '@orpc/shared';
+
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

package/dist/adapters/websocket/index.mjs

@@ -0,0 +1,46 @@
+import { readAsBuffer } from '@orpc/shared';
+import { ClientPeer } from '@orpc/standard-server-peer';
+import { c as StandardRPCLink } from '../../shared/client.Bp1jlnBk.mjs';
+import '@orpc/standard-server';
+import '@orpc/standard-server-fetch';
+import '../../shared/client.txdq_i5V.mjs';
+
+const WEBSOCKET_CONNECTING = 0;
+class LinkWebsocketClient {
+  peer;
+  constructor(options) {
+    const untilOpen = new Promise((resolve) => {
+      if (options.websocket.readyState === WEBSOCKET_CONNECTING) {
+        options.websocket.addEventListener("open", () => {
+          resolve();
+        }, { once: true });
+      } else {
+        resolve();
+      }
+    });
+    this.peer = new ClientPeer(async (message) => {
+      await untilOpen;
+      return options.websocket.send(message);
+    });
+    options.websocket.addEventListener("message", async (event) => {
+      const message = event.data instanceof Blob ? await readAsBuffer(event.data) : event.data;
+      this.peer.message(message);
+    });
+    options.websocket.addEventListener("close", () => {
+      this.peer.close();
+    });
+  }
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkWebsocketClient(options);
+    super(linkClient, { ...options, url: "orpc:/" });
+  }
+}
+
+export { LinkWebsocketClient, RPCLink };

package/dist/index.d.mts

@@ -1,25 +1,21 @@
-import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.mjs';
-export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.mjs';
-import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.mjs';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.mjs';
+import { MaybeOptionalOptions, ThrowableError, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    path?: string[];
+    path?: readonly string[];
 }
-declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
-
 /**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
+ * Create a oRPC client-side client from a link.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/client-side Client-side Client Docs}
  */
-declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 
 declare const COMMON_ORPC_ERROR_DEFS: {
     readonly BAD_REQUEST: {
@@ -117,37 +113,73 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
-    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
-    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 declare function toORPCError(error: unknown): ORPCError<any, any>;
+declare function isORPCErrorStatus(status: number): boolean;
+declare function isORPCErrorJson(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+declare function createORPCErrorFromJson<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
 
-type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
-interface EventIteratorState {
-    status: ConnectionStatus;
-    listeners: Array<(newStatus: ConnectionStatus) => void>;
-}
-declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
-declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
-declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
-
-type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
     isDefined: false;
-} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    isSuccess: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
     error: Exclude<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: false;
-} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    isSuccess: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
     error: Extract<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: true;
+    isSuccess: false;
 };
-declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+/**
+ * Works like try/catch, but can infer error types.
+ *
+ * @info support both tuple `[error, data, isDefined, isSuccess]` and object `{ error, data, isDefined, isSuccess }` styles.
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling Client Error Handling Docs}
+ */
+declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+
+type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
+};
+/**
+ * Create a safe client that automatically wraps all procedure calls with the `safe` util.
+ *
+ * @example
+ * ```ts
+ * const safeClient = createSafeClient(client)
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * ```
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ */
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncIteratorClass<TMap, TMap, TNext>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };

package/dist/index.d.ts

@@ -1,25 +1,21 @@
-import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.js';
-export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.js';
-import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.js';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.js';
+import { MaybeOptionalOptions, ThrowableError, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    path?: string[];
+    path?: readonly string[];
 }
-declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
-
 /**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
+ * Create a oRPC client-side client from a link.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/client-side Client-side Client Docs}
  */
-declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 
 declare const COMMON_ORPC_ERROR_DEFS: {
     readonly BAD_REQUEST: {
@@ -117,37 +113,73 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
-    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
-    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 declare function toORPCError(error: unknown): ORPCError<any, any>;
+declare function isORPCErrorStatus(status: number): boolean;
+declare function isORPCErrorJson(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+declare function createORPCErrorFromJson<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
 
-type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
-interface EventIteratorState {
-    status: ConnectionStatus;
-    listeners: Array<(newStatus: ConnectionStatus) => void>;
-}
-declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
-declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
-declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
-
-type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
     isDefined: false;
-} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    isSuccess: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
     error: Exclude<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: false;
-} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    isSuccess: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
     error: Extract<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: true;
+    isSuccess: false;
 };
-declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+/**
+ * Works like try/catch, but can infer error types.
+ *
+ * @info support both tuple `[error, data, isDefined, isSuccess]` and object `{ error, data, isDefined, isSuccess }` styles.
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling Client Error Handling Docs}
+ */
+declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+
+type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
+};
+/**
+ * Create a safe client that automatically wraps all procedure calls with the `safe` util.
+ *
+ * @example
+ * ```ts
+ * const safeClient = createSafeClient(client)
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * ```
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ */
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncIteratorClass<TMap, TMap, TNext>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };

package/dist/index.mjs

@@ -1,17 +1,42 @@
-import { i as isDefinedError } from './shared/client.Ly4zGQrc.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, c as createAutoRetryEventIterator, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, m as mapEventIterator, o as onEventIteratorStatusChange, r as registerEventIteratorState, t as toORPCError, u as updateEventIteratorStatus } from './shared/client.Ly4zGQrc.mjs';
+import { preventNativeAwait, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+import { i as isDefinedError } from './shared/client.txdq_i5V.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, d as createORPCErrorFromJson, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, c as isORPCErrorJson, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.txdq_i5V.mjs';
 export { ErrorEvent } from '@orpc/standard-server';
-import '@orpc/shared';
 
-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);
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return Object.assign(
+      [null, output, false, true],
+      { error: null, data: output, isDefined: false, isSuccess: true }
+    );
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return Object.assign(
+        [error, void 0, true, false],
+        { error, data: void 0, isDefined: true, isSuccess: false }
+      );
+    }
+    return Object.assign(
+      [error, void 0, false, false],
+      { error, data: void 0, isDefined: false, isSuccess: false }
+    );
+  }
+}
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
   };
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
@@ -24,7 +49,23 @@ function createORPCClient(link, options) {
       });
     }
   });
-  return recursive;
+  return preventNativeAwait(recursive);
+}
+
+function createSafeClient(client) {
+  const proxy = new Proxy((...args) => safe(client(...args)), {
+    get(_, prop, receiver) {
+      const value = Reflect.get(client, prop, receiver);
+      if (typeof prop !== "string") {
+        return value;
+      }
+      if (!isTypescriptObject(value)) {
+        return value;
+      }
+      return createSafeClient(value);
+    }
+  });
+  return proxy;
 }
 
 class DynamicLink {
@@ -38,26 +79,4 @@ class DynamicLink {
   }
 }
 
-async function safe(promise) {
-  try {
-    const output = await promise;
-    return Object.assign(
-      [null, output, false],
-      { error: null, data: output, isDefined: false }
-    );
-  } catch (e) {
-    const error = e;
-    if (isDefinedError(error)) {
-      return Object.assign(
-        [error, void 0, true],
-        { error, data: void 0, isDefined: true }
-      );
-    }
-    return Object.assign(
-      [error, void 0, false],
-      { error, data: void 0, isDefined: false }
-    );
-  }
-}
-
-export { DynamicLink, createORPCClient, isDefinedError, safe };
+export { DynamicLink, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };