@orpc/client 1.0.2 → 1.1.0

package/dist/plugins/index.d.mts

@@ -0,0 +1,162 @@
+import { Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.FXep-a3a.mjs';
+import { a as ClientContext } from '../shared/client.CipPQkhk.mjs';
+
+interface BatchLinkPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    context: T;
+    path?: readonly string[];
+    input?: unknown;
+}
+interface BatchLinkPluginOptions<T extends ClientContext> {
+    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    /**
+     * The maximum number of requests in the batch.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Defines the URL to use for the batch request.
+     *
+     * @default the URL of the first request in the batch + '/__batch__'
+     */
+    url?: Value<string | URL, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Defines the HTTP headers to use for the batch request.
+     *
+     * @default The same headers of all requests in the batch
+     */
+    headers?: Value<StandardHeaders, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Map the batch request items before sending them.
+     *
+     * @default Removes headers that are duplicated in the batch headers.
+     */
+    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
+        batchUrl: URL;
+        batchHeaders: StandardHeaders;
+    }) => StandardRequest;
+    /**
+     * Exclude a request from the batch.
+     *
+     * @default () => false
+     */
+    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+}
+/**
+ * The Batch Request/Response Plugin allows you to combine multiple requests and responses into a single batch,
+ * reducing the overhead of sending each one separately.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/batch-request-response Batch Request/Response Plugin Docs}
+ */
+declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    private readonly groups;
+    private readonly maxSize;
+    private readonly batchUrl;
+    private readonly maxUrlLength;
+    private readonly batchHeaders;
+    private readonly mapRequestItem;
+    private readonly exclude;
+    private pending;
+    order: number;
+    constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    lastEventRetry: number | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | ((isSuccess: boolean) => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+/**
+ * The Client Retry Plugin enables retrying client calls when errors occur.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/client-retry Client Retry Plugin Docs}
+ */
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
+    /**
+     * The name of the header to check.
+     *
+     * @default 'x-csrf-token'
+     */
+    headerName?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * The value of the header to check.
+     *
+     * @default 'orpc'
+     *
+     */
+    headerValue?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * Exclude a procedure from the plugin.
+     *
+     * @default false
+     */
+    exclude?: Value<boolean, [options: StandardLinkClientInterceptorOptions<T>]>;
+}
+/**
+ * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
+ * It helps ensure that requests to your procedures originate from JavaScript code,
+ * not from other sources like standard HTML forms or direct browser navigation.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/simple-csrf-protection Simple CSRF Protection Plugin Docs}
+ */
+declare class SimpleCsrfProtectionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly headerName;
+    private readonly headerValue;
+    private readonly exclude;
+    constructor(options?: SimpleCsrfProtectionLinkPluginOptions<T>);
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, SimpleCsrfProtectionLinkPluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,162 @@
+import { Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.C9U9n1f3.js';
+import { a as ClientContext } from '../shared/client.CipPQkhk.js';
+
+interface BatchLinkPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    context: T;
+    path?: readonly string[];
+    input?: unknown;
+}
+interface BatchLinkPluginOptions<T extends ClientContext> {
+    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    /**
+     * The maximum number of requests in the batch.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Defines the URL to use for the batch request.
+     *
+     * @default the URL of the first request in the batch + '/__batch__'
+     */
+    url?: Value<string | URL, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Defines the HTTP headers to use for the batch request.
+     *
+     * @default The same headers of all requests in the batch
+     */
+    headers?: Value<StandardHeaders, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * Map the batch request items before sending them.
+     *
+     * @default Removes headers that are duplicated in the batch headers.
+     */
+    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
+        batchUrl: URL;
+        batchHeaders: StandardHeaders;
+    }) => StandardRequest;
+    /**
+     * Exclude a request from the batch.
+     *
+     * @default () => false
+     */
+    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+}
+/**
+ * The Batch Request/Response Plugin allows you to combine multiple requests and responses into a single batch,
+ * reducing the overhead of sending each one separately.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/batch-request-response Batch Request/Response Plugin Docs}
+ */
+declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    private readonly groups;
+    private readonly maxSize;
+    private readonly batchUrl;
+    private readonly maxUrlLength;
+    private readonly batchHeaders;
+    private readonly mapRequestItem;
+    private readonly exclude;
+    private pending;
+    order: number;
+    constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    lastEventRetry: number | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | ((isSuccess: boolean) => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+/**
+ * The Client Retry Plugin enables retrying client calls when errors occur.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/client-retry Client Retry Plugin Docs}
+ */
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
+    /**
+     * The name of the header to check.
+     *
+     * @default 'x-csrf-token'
+     */
+    headerName?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * The value of the header to check.
+     *
+     * @default 'orpc'
+     *
+     */
+    headerValue?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * Exclude a procedure from the plugin.
+     *
+     * @default false
+     */
+    exclude?: Value<boolean, [options: StandardLinkClientInterceptorOptions<T>]>;
+}
+/**
+ * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
+ * It helps ensure that requests to your procedures originate from JavaScript code,
+ * not from other sources like standard HTML forms or direct browser navigation.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/simple-csrf-protection Simple CSRF Protection Plugin Docs}
+ */
+declare class SimpleCsrfProtectionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly headerName;
+    private readonly headerValue;
+    private readonly exclude;
+    constructor(options?: SimpleCsrfProtectionLinkPluginOptions<T>);
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, SimpleCsrfProtectionLinkPluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,291 @@
+import { isAsyncIteratorObject, value, splitInHalf, toArray } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse } from '@orpc/standard-server/batch';
+import { getEventMeta } from '@orpc/standard-server';
+
+class BatchLinkPlugin {
+  groups;
+  maxSize;
+  batchUrl;
+  maxUrlLength;
+  batchHeaders;
+  mapRequestItem;
+  exclude;
+  pending;
+  order = 5e6;
+  constructor(options) {
+    this.groups = options.groups;
+    this.pending = /* @__PURE__ */ new Map();
+    this.maxSize = options.maxSize ?? 10;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
+    this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(options2.request.headers)) {
+        if (rest.every((item) => item.request.headers[key] === value2)) {
+          headers[key] = value2;
+        }
+      }
+      return headers;
+    });
+    this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(request.headers)) {
+        if (batchHeaders[key] !== value2) {
+          headers[key] = value2;
+        }
+      }
+      return {
+        method: request.method,
+        url: request.url,
+        headers,
+        body: request.body,
+        signal: request.signal
+      };
+    });
+    this.exclude = options.exclude ?? (() => false);
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push((options2) => {
+      if (options2.request.headers["x-orpc-batch"] !== "1") {
+        return options2.next();
+      }
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            "x-orpc-batch": void 0
+          }
+        }
+      });
+    });
+    options.clientInterceptors.push((options2) => {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+        return options2.next();
+      }
+      const group = this.groups.find((group2) => group2.condition(options2));
+      if (!group) {
+        return options2.next();
+      }
+      return new Promise((resolve, reject) => {
+        this.#enqueueRequest(group, options2, resolve, reject);
+        setTimeout(() => this.#processPendingBatches());
+      });
+    });
+  }
+  #enqueueRequest(group, options, resolve, reject) {
+    const items = this.pending.get(group);
+    if (items) {
+      items.push([options, resolve, reject]);
+    } else {
+      this.pending.set(group, [[options, resolve, reject]]);
+    }
+  }
+  async #processPendingBatches() {
+    const pending = this.pending;
+    this.pending = /* @__PURE__ */ new Map();
+    for (const [group, items] of pending) {
+      const getItems = items.filter(([options]) => options.request.method === "GET");
+      const restItems = items.filter(([options]) => options.request.method !== "GET");
+      this.#executeBatch("GET", group, getItems);
+      this.#executeBatch("POST", group, restItems);
+    }
+  }
+  async #executeBatch(method, group, groupItems) {
+    if (!groupItems.length) {
+      return;
+    }
+    const batchItems = groupItems;
+    if (batchItems.length === 1) {
+      batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
+      return;
+    }
+    try {
+      const options = batchItems.map(([options2]) => options2);
+      const maxSize = await value(this.maxSize, options);
+      if (batchItems.length > maxSize) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        this.#executeBatch(method, group, second);
+        return;
+      }
+      const batchUrl = new URL(await value(this.batchUrl, options));
+      const batchHeaders = await value(this.batchHeaders, options);
+      const mappedItems = batchItems.map(([options2]) => this.mapRequestItem({ ...options2, batchUrl, batchHeaders }));
+      const batchRequest = toBatchRequest({
+        method,
+        url: batchUrl,
+        headers: batchHeaders,
+        requests: mappedItems
+      });
+      const maxUrlLength = await value(this.maxUrlLength, options);
+      if (batchRequest.url.toString().length > maxUrlLength) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        this.#executeBatch(method, group, second);
+        return;
+      }
+      const lazyResponse = await options[0].next({
+        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": "1" } },
+        signal: batchRequest.signal,
+        context: group.context,
+        input: group.input,
+        path: toArray(group.path)
+      });
+      const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
+      for await (const item of parsed) {
+        batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+      }
+      throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
+    } catch (error) {
+      for (const [, , reject] of batchItems) {
+        reject(error);
+      }
+    }
+  }
+}
+
+class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+class ClientRetryPlugin {
+  defaultRetry;
+  defaultRetryDelay;
+  defaultShouldRetry;
+  defaultOnRetry;
+  constructor(options = {}) {
+    this.defaultRetry = options.default?.retry ?? 0;
+    this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
+    this.defaultShouldRetry = options.default?.shouldRetry ?? true;
+    this.defaultOnRetry = options.default?.onRetry;
+  }
+  init(options) {
+    options.interceptors ??= [];
+    options.interceptors.push(async (interceptorOptions) => {
+      const maxAttempts = await value(
+        interceptorOptions.context.retry ?? this.defaultRetry,
+        interceptorOptions
+      );
+      const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
+      if (maxAttempts <= 0) {
+        return interceptorOptions.next();
+      }
+      let lastEventId = interceptorOptions.lastEventId;
+      let lastEventRetry;
+      let callback;
+      let attemptIndex = 0;
+      const next = async (initialError) => {
+        let currentError = initialError;
+        while (true) {
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          if (currentError) {
+            if (attemptIndex >= maxAttempts) {
+              throw currentError.error;
+            }
+            const attemptOptions = {
+              ...updatedInterceptorOptions,
+              attemptIndex,
+              error: currentError.error,
+              lastEventRetry
+            };
+            const shouldRetryBool = await value(
+              shouldRetry,
+              attemptOptions
+            );
+            if (!shouldRetryBool) {
+              throw currentError.error;
+            }
+            callback = onRetry?.(attemptOptions);
+            const retryDelayMs = await value(retryDelay, attemptOptions);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            attemptIndex++;
+          }
+          try {
+            currentError = void 0;
+            return await interceptorOptions.next(updatedInterceptorOptions);
+          } catch (error) {
+            currentError = { error };
+            if (updatedInterceptorOptions.signal?.aborted === true) {
+              throw error;
+            }
+          } finally {
+            callback?.(!currentError);
+            callback = void 0;
+          }
+        }
+      };
+      const output = await next();
+      if (!isAsyncIteratorObject(output)) {
+        return output;
+      }
+      return async function* () {
+        let current = output;
+        try {
+          while (true) {
+            try {
+              const item = await current.next();
+              const meta = getEventMeta(item.value);
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
+              if (item.done) {
+                return item.value;
+              }
+              yield item.value;
+            } catch (error) {
+              const meta = getEventMeta(error);
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
+              const maybeEventIterator = await next({ error });
+              if (!isAsyncIteratorObject(maybeEventIterator)) {
+                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
+                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
+                );
+              }
+              current = maybeEventIterator;
+            }
+          }
+        } finally {
+          await current.return?.();
+        }
+      }();
+    });
+  }
+}
+
+class SimpleCsrfProtectionLinkPlugin {
+  headerName;
+  headerValue;
+  exclude;
+  constructor(options = {}) {
+    this.headerName = options.headerName ?? "x-csrf-token";
+    this.headerValue = options.headerValue ?? "orpc";
+    this.exclude = options.exclude ?? false;
+  }
+  order = 8e6;
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (options2) => {
+      const excluded = await value(this.exclude, options2);
+      if (excluded) {
+        return options2.next();
+      }
+      const headerName = await value(this.headerName, options2);
+      const headerValue = await value(this.headerValue, options2);
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            [headerName]: headerValue
+          }
+        }
+      });
+    });
+  }
+}
+
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };