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

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { a as isInferableError } from './shared/client.DMXKFDyV.mjs';
-export { b as RPCJsonSerializer, R as RPCSerializer, d as cloneORPCError, c as createORPCErrorFromJson, i as isORPCErrorJson, t as toORPCError, w as wrapEventIteratorPreservingMeta } from './shared/client.DMXKFDyV.mjs';
-import { getOrBind, toArray, intercept, isTypescriptObject } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-export { C as COMMON_ERROR_STATUS_MAP, O as ORPCError } from './shared/client.Dnfj8jnT.mjs';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+import { b as isDefinedError } from './shared/client.DpkGsZt-.mjs';
+export { d as RPCJsonSerializer, R as RPCSerializer, e as cloneORPCError, a as createORPCErrorFromJson, c as createORPCErrorFromMalformedResponse, i as isORPCErrorJson, t as toORPCError, w as wrapAsyncIteratorPreservingEventMeta } from './shared/client.DpkGsZt-.mjs';
+import { toArray, intercept, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, consumeAsyncIterator, consumeAsyncIterator as consumeEventIterator, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
+export { C as COMMON_ERROR_STATUS_MAP, M as MalformedResponseError, O as ORPCError } from './shared/client.DD2eNne_.mjs';
+export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
 
 const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
   /**
@@ -16,6 +16,16 @@ const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
    * context.
    */
   "bind",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context.
+   */
+  "call",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context and an arguments array.
+   */
+  "apply",
   /**
    * Commonly accessed during primitive conversion, inspection, and logging.
    */
@@ -50,51 +60,22 @@ async function safe(promise) {
     const output = await promise;
     return Object.assign(
       [null, output, null, true],
-      { error: null, data: output, inferableError: null, isSuccess: true }
+      { error: null, data: output, definedError: null, isSuccess: true }
     );
   } catch (e) {
     const error = e;
-    if (isInferableError(error)) {
+    if (isDefinedError(error)) {
       return Object.assign(
         [error, void 0, error, false],
-        { error, data: void 0, inferableError: error, isSuccess: false }
+        { error, data: void 0, definedError: error, isSuccess: false }
       );
     }
     return Object.assign(
       [error, void 0, null, false],
-      { error, data: void 0, inferableError: null, isSuccess: false }
+      { error, data: void 0, definedError: null, isSuccess: false }
     );
   }
 }
-function consumeEventIterator(iterator, options) {
-  void (async () => {
-    let onFinishState;
-    try {
-      const resolvedIterator = await iterator;
-      while (true) {
-        const { done, value } = await resolvedIterator.next();
-        if (done) {
-          const realValue = value;
-          onFinishState = [null, realValue, true];
-          options.onSuccess?.(realValue);
-          break;
-        }
-        options.onEvent(value);
-      }
-    } catch (error) {
-      onFinishState = [error, void 0, false];
-      if (!options.onError && !options.onFinish) {
-        throw error;
-      }
-      options.onError?.(error);
-    } finally {
-      options.onFinish?.(onFinishState);
-    }
-  })();
-  return async () => {
-    await (await iterator)?.return?.();
-  };
-}
 
 function createORPCClient(link, { path = [], ...options } = {}) {
   const procedureClient = (...rest) => {
@@ -109,30 +90,44 @@ function createORPCClient(link, { path = [], ...options } = {}) {
       ({ path: path2, input: input2, ...callOptions2 }) => link.call(path2, input2, callOptions2)
     );
   };
+  const cache = /* @__PURE__ */ new Map();
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
       if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
+        return Reflect.get(target, key);
+      }
+      let client = cache.get(key);
+      if (client === void 0) {
+        client = createORPCClient(link, {
+          ...options,
+          path: [...path, key],
+          scoped: options.scoped?.[key]
+        });
+        cache.set(key, client);
       }
-      const scoped = options.scoped === void 0 ? void 0 : options.scoped[key];
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key],
-        scoped
-      });
+      return client;
     }
   });
   return recursive;
 }
 
 function createSafeClient(client) {
+  const cache = /* @__PURE__ */ new Map();
   const proxy = new Proxy((...args) => safe(client(...args)), {
-    get(_, prop) {
-      const value = getOrBind(client, prop);
-      if (!isTypescriptObject(value)) {
-        return value;
+    get(target, prop) {
+      if (typeof prop !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(prop)) {
+        return Reflect.get(target, prop);
       }
-      return createSafeClient(value);
+      let safeClient = cache.get(prop);
+      if (safeClient === void 0) {
+        const value = client[prop];
+        if (!isTypescriptObject(value)) {
+          return value;
+        }
+        safeClient = createSafeClient(value);
+        cache.set(prop, safeClient);
+      }
+      return safeClient;
     }
   });
   return proxy;
@@ -149,6 +144,4 @@ class DynamicLink {
   }
 }
 
-const isDefinedError = isInferableError;
-
-export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, isInferableError, resolveClientRest, resolveFriendlyClientOptions, safe };
+export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, createORPCClient, createSafeClient, isDefinedError, resolveClientRest, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -1,7 +1,7 @@
 import { Value, Promisable } from '@orpc/shared';
-import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { C as ClientContext } from '../shared/client.8ug8I-zu.mjs';
-import { c as StandardLinkPlugin, d as StandardLinkTransportInterceptorOptions, b as StandardLinkOptions, e as StandardLinkInterceptorOptions } from '../shared/client.Cby_-GGh.mjs';
+import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standard-server/core';
+import { ClientContext } from '../index.mjs';
+import { StandardLinkPlugin, StandardLinkTransportInterceptorOptions, StandardLinkOptions, StandardLinkInterceptorOptions } from '../adapters/standard/index.mjs';
 
 type BatchLinkPluginMode = 'streaming' | 'buffered';
 interface BatchLinkPluginGroup<T extends ClientContext> {
@@ -23,8 +23,6 @@ interface BatchLinkPluginGroup<T extends ClientContext> {
      */
     path?: Value<string[], [items: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
 }
-declare class BatchLinkPluginError extends TypeError {
-}
 interface BatchLinkPluginOptions<T extends ClientContext> {
     groups: [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
     /**
@@ -33,12 +31,27 @@ interface BatchLinkPluginOptions<T extends ClientContext> {
      * @default () => true
      */
     filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
+    /**
+     * Only requests with the same scope are batched together.
+     * On the server, return a value unique to the incoming request so different users never share a batch.
+     *
+     * @default () => undefined
+     */
+    scope?: (options: StandardLinkTransportInterceptorOptions<T>) => unknown;
     /**
      * The maximum number of requests in the batch.
      *
      * @default 10
      */
     maxSize?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    /**
+     * How long (in ms) to wait for more requests before sending the batch,
+     * counted from the first queued request.
+     * With `0`, only requests made in the same event loop tick are batched.
+     *
+     * @default 0
+     */
+    wait?: number;
     /**
      * The batch response mode.
      *
@@ -79,11 +92,22 @@ interface BatchLinkPluginOptions<T extends ClientContext> {
      */
     mapSubresponse?: (subResponse: StandardLazyResponse, batchResponse: StandardLazyResponse, subOptions: StandardLinkTransportInterceptorOptions<T>) => StandardLazyResponse;
 }
+/**
+ * Combines multiple client requests into a single batch request
+ * and splits the batch response back into individual responses.
+ *
+ * @remarks
+ * **Note**: HTTP/2 and later already multiplex requests over a single connection, so this plugin is often less useful than it once was.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/batch | Batch Plugin}
+ */
 declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
     name: string;
     private readonly groups;
     private readonly filter;
+    private readonly scope;
     private readonly maxSize;
+    private readonly wait;
     private readonly mode;
     private readonly batchUrl;
     private readonly maxUrlLength;
@@ -94,6 +118,12 @@ declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPl
     constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
     init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
     private processPendingBatches;
+    /**
+     * Runs the batch in the async context of its first request instead of the timer's,
+     * so the transport and batch options see that caller's request state.
+     * `executeBatch` always runs in the context of its first request.
+     */
+    private executeBatchInOwnContext;
     private executeBatch;
 }
 
@@ -119,15 +149,38 @@ interface DedupeLinkPluginOptions<T extends ClientContext> {
     /**
      * Filters requests to dedupe.
      *
-     * @default ({ request }) => request.method === 'GET'
+     * @default ({ request }) => request.method === 'GET' || request.method === 'QUERY'
      */
     filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
+    /**
+     * Only requests with the same scope are deduplicated together.
+     * On the server, return a value unique to the incoming request so different users never share a response.
+     *
+     * @default () => undefined
+     */
+    scope?: (options: StandardLinkTransportInterceptorOptions<T>) => unknown;
+    /**
+     * How long (in ms) to wait for more identical requests before sending,
+     * counted from the first queued request.
+     * With `0`, only requests made in the same event loop tick are deduplicated.
+     *
+     * @default 0
+     */
+    wait?: number;
 }
+/**
+ * Prevents redundant requests by deduplicating similar in-flight requests,
+ * reducing the number of requests sent to the server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/dedupe | Dedupe Plugin}
+ */
 declare class DedupeLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
     name: string;
     before: string[];
     private readonly groups;
     private readonly filter;
+    private readonly scope;
+    private readonly wait;
     private readonly queue;
     constructor(options: NoInfer<DedupeLinkPluginOptions<T>>);
     init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
@@ -136,6 +189,76 @@ declare class DedupeLinkPlugin<T extends ClientContext> implements StandardLinkP
     private execute;
 }
 
+interface RequestCompressionLinkPluginOptions<T extends ClientContext> {
+    /**
+     * The compression scheme to use for request compression.
+     *
+     * @default 'gzip'
+     */
+    encoding?: 'gzip' | 'deflate' | 'deflate-raw';
+    /**
+     * The minimum request size in bytes required to trigger compression.
+     * Requests smaller than this threshold will not be compressed to avoid overhead.
+     * If the request size cannot be determined, compression will still be applied.
+     *
+     * @default 1024 (1KB)
+     */
+    threshold?: number;
+    /**
+     * Determines whether a request with the given Content-Type should be compressed.
+     * Only consulted for binary transfers (streams, files, and file form-data parts).
+     * Also receives the transport interceptor options for per-request decisions.
+     *
+     * @default isCompressibleContentType (covers common text-based formats)
+     */
+    isCompressibleContentType?: (contentType: string | null | undefined, options: StandardLinkTransportInterceptorOptions<T>) => boolean;
+}
+/**
+ * Compresses request bodies before sending them to the server,
+ * reducing bandwidth usage for large payloads.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-compression | Request Compression Plugin}
+ */
+declare class RequestCompressionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    /**
+     * Compression should be done after batching, to compress the final request
+     */
+    after: string[];
+    private readonly encoding;
+    private readonly threshold;
+    private readonly isCompressibleContentType;
+    constructor(options?: RequestCompressionLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
+interface ResponseCompressionLinkPluginOptions<_T extends ClientContext> {
+    /**
+     * Compression schemes to advertise via Accept-Encoding, in preference order.
+     * Only schemes that can be decompressed by this plugin should be listed.
+     *
+     * @default ['gzip', 'deflate']
+     */
+    encodings?: readonly ('gzip' | 'deflate' | 'deflate-raw')[];
+}
+/**
+ * Advertises Accept-Encoding on requests and decompresses response bodies
+ * based on the Content-Encoding header. Works at the standard link level,
+ * so it supports all adapters.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-compression | Response Compression Plugin}
+ */
+declare class ResponseCompressionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    /**
+     * Decompression should wrap the final batch response instead of sub-responses.
+     */
+    after: string[];
+    private readonly encodings;
+    constructor(options?: ResponseCompressionLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
 interface RetryLinkPluginAttemptOptions<T extends RetryLinkPluginContext> extends StandardLinkInterceptorOptions<T> {
     /**
      * Latest retry delay advertised by the server via event metadata.
@@ -150,10 +273,16 @@ interface RetryLinkPluginAttemptOptions<T extends RetryLinkPluginContext> extend
      */
     error: unknown;
 }
+/**
+ * Client context options that control retry behavior per call
+ * when the `RetryLinkPlugin` is enabled.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/retry | Retry Plugin}
+ */
 interface RetryLinkPluginContext {
     /**
      * Maximum retry attempts before throwing.
-     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g. for event iterators).
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g. for AsyncIteratorObject).
      *
      * @default 0
      */
@@ -161,7 +290,9 @@ interface RetryLinkPluginContext {
     /**
      * Delay (in ms) before retrying.
      *
-     * @info Why 2000ms? The EventSource spec suggests a default retry delay of 2 seconds if it doesn't specify
+     * @remarks
+     * **Note**: Why 2000ms? The EventSource spec suggests a default retry delay of 2 seconds if it doesn't specify
+     *
      * @default (o) => o.lastEventRetry ?? 2000
      */
     retryDelay?: Value<Promisable<number>, [RetryLinkPluginAttemptOptions<RetryLinkPluginContext>]>;
@@ -182,8 +313,15 @@ interface RetryLinkPluginOptions<_T extends RetryLinkPluginContext> {
      */
     default?: RetryLinkPluginContext | undefined;
 }
-declare class RetryLinkPluginInvalidEventIteratorRetryResponse extends Error {
-}
+/**
+ * Automatically retries failed requests based on customizable retry strategies,
+ * improving the resilience of your application.
+ *
+ * @remarks
+ * **Note**: Retry behavior is configured through the client context on each call.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/retry | Retry Plugin}
+ */
 declare class RetryLinkPlugin<T extends RetryLinkPluginContext & ClientContext> implements StandardLinkPlugin<T> {
     private readonly defaultRetry;
     private readonly defaultRetryDelay;
@@ -227,7 +365,7 @@ interface RetryAfterLinkPluginOptions<T extends ClientContext> {
  * The Retry After Link Plugin automatically retries requests based on server `retry-after` header.
  * This is particularly useful for handling rate limiting and temporary server unavailability.
  *
- * @see {@link https://orpc.dev/docs/plugins/retry-after Retry After Plugin Docs}
+ * @see {@link https://orpc.dev/docs/plugins/retry-after | Retry After Plugin}
  */
 declare class RetryAfterLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
     private readonly condition;
@@ -238,5 +376,28 @@ declare class RetryAfterLinkPlugin<T extends ClientContext> implements StandardL
     init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
 }
 
-export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, RetryLinkPluginInvalidEventIteratorRetryResponse };
-export type { BatchLinkPluginGroup, BatchLinkPluginMode, BatchLinkPluginOptions, DedupeLinkPluginGroup, DedupeLinkPluginOptions, RetryAfterLinkPluginOptions, RetryLinkPluginAttemptOptions, RetryLinkPluginContext, RetryLinkPluginOptions };
+interface TimeoutLinkPluginOptions<T extends ClientContext> {
+    /**
+     * Timeout in milliseconds before the request is aborted.
+     * Use `null` or `undefined` to disable the timeout.
+     */
+    timeout: Value<number | null | undefined, [options: StandardLinkInterceptorOptions<T>]>;
+}
+/**
+ * The Timeout Link Plugin aborts requests that exceed a configured timeout with an `AbortError`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/timeout | Timeout Plugin}
+ */
+declare class TimeoutLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly timeout;
+    name: string;
+    /**
+     * Should abort if the total retry time exceeds the configured timeout
+     */
+    after: string[];
+    constructor(options: NoInfer<TimeoutLinkPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+}
+
+export { BatchLinkPlugin, RetryLinkPlugin as ClientRetryPlugin, DedupeLinkPlugin, DedupeLinkPlugin as DedupeRequestsPlugin, RequestCompressionLinkPlugin, ResponseCompressionLinkPlugin, RetryAfterLinkPlugin, RetryAfterLinkPlugin as RetryAfterPlugin, RetryLinkPlugin, TimeoutLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginMode, BatchLinkPluginOptions, RetryLinkPluginContext as ClientRetryPluginContext, DedupeLinkPluginGroup, DedupeLinkPluginOptions, RequestCompressionLinkPluginOptions, ResponseCompressionLinkPluginOptions, RetryAfterLinkPluginOptions, RetryLinkPluginAttemptOptions, RetryLinkPluginContext, RetryLinkPluginOptions, TimeoutLinkPluginOptions };