@orpc/client 0.0.0-next.a8e421c → 0.0.0-next.a910d34

package/dist/plugins/index.mjs

@@ -1,6 +1,249 @@
-export { C as CompositeClientPlugin } from '../shared/client.CvnV7_uV.mjs';
-import { isAsyncIteratorObject, value } from '@orpc/shared';
-import { getEventMeta } from '@orpc/standard-server';
+import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse, toBatchAbortSignal } from '@orpc/standard-server/batch';
+import { replicateStandardLazyResponse, getEventMeta } from '@orpc/standard-server';
+
+class BatchLinkPlugin {
+  groups;
+  maxSize;
+  batchUrl;
+  maxUrlLength;
+  batchHeaders;
+  mapRequestItem;
+  exclude;
+  mode;
+  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.mode = options.mode ?? "streaming";
+    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);
+        defer(() => 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 mode = value(this.mode, options);
+      const lazyResponse = await options[0].next({
+        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
+        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 DedupeRequestsPlugin {
+  #groups;
+  #filter;
+  order = 4e6;
+  // make sure execute before batch plugin
+  #queue = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#groups = options.groups;
+    this.#filter = options.filter ?? (({ request }) => request.method === "GET");
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push((options2) => {
+      if (options2.request.body instanceof Blob || options2.request.body instanceof FormData || options2.request.body instanceof URLSearchParams || isAsyncIteratorObject(options2.request.body) || !this.#filter(options2)) {
+        return options2.next();
+      }
+      const group = this.#groups.find((group2) => group2.condition(options2));
+      if (!group) {
+        return options2.next();
+      }
+      return new Promise((resolve, reject) => {
+        this.#enqueue(group, options2, resolve, reject);
+        defer(() => this.#dequeue());
+      });
+    });
+  }
+  #enqueue(group, options, resolve, reject) {
+    let queue = this.#queue.get(group);
+    if (!queue) {
+      this.#queue.set(group, queue = []);
+    }
+    const matched = queue.find((item) => {
+      const requestString1 = stringifyJSON({
+        body: item.options.request.body,
+        headers: item.options.request.headers,
+        method: item.options.request.method,
+        url: item.options.request.url
+      });
+      const requestString2 = stringifyJSON({
+        body: options.request.body,
+        headers: options.request.headers,
+        method: options.request.method,
+        url: options.request.url
+      });
+      return requestString1 === requestString2;
+    });
+    if (matched) {
+      matched.signals.push(options.request.signal);
+      matched.resolves.push(resolve);
+      matched.rejects.push(reject);
+    } else {
+      queue.push({
+        options,
+        signals: [options.request.signal],
+        resolves: [resolve],
+        rejects: [reject]
+      });
+    }
+  }
+  async #dequeue() {
+    const promises = [];
+    for (const [group, items] of this.#queue) {
+      for (const { options, signals, resolves, rejects } of items) {
+        promises.push(
+          this.#execute(group, options, signals, resolves, rejects)
+        );
+      }
+    }
+    this.#queue.clear();
+    await Promise.all(promises);
+  }
+  async #execute(group, options, signals, resolves, rejects) {
+    try {
+      const dedupedRequest = {
+        ...options.request,
+        signal: toBatchAbortSignal(signals)
+      };
+      const response = await options.next({
+        ...options,
+        request: dedupedRequest,
+        signal: dedupedRequest.signal,
+        context: group.context
+      });
+      const replicatedResponses = replicateStandardLazyResponse(response, resolves.length);
+      for (const resolve of resolves) {
+        resolve(replicatedResponses.shift());
+      }
+    } catch (error) {
+      for (const reject of rejects) {
+        reject(error);
+      }
+    }
+  }
+}
 
 class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
 }
@@ -11,78 +254,64 @@ class ClientRetryPlugin {
   defaultOnRetry;
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
-    this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.eventIteratorLastRetry ?? 2e3);
+    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 = interceptorOptions.options.context.retry ?? this.defaultRetry;
-      const retryDelay = interceptorOptions.options.context.retryDelay ?? this.defaultRetryDelay;
-      const shouldRetry = interceptorOptions.options.context.shouldRetry ?? this.defaultShouldRetry;
-      const onRetry = interceptorOptions.options.context.onRetry ?? this.defaultOnRetry;
+      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 eventIteratorLastEventId = interceptorOptions.options.lastEventId;
-      let eventIteratorLastRetry;
-      let unsubscribe;
+      let lastEventId = interceptorOptions.lastEventId;
+      let lastEventRetry;
+      let callback;
       let attemptIndex = 0;
-      const next = async (initial) => {
-        let current = initial;
+      const next = async (initialError) => {
+        let currentError = initialError;
         while (true) {
-          if (current) {
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          if (currentError) {
             if (attemptIndex >= maxAttempts) {
-              throw current.error;
+              throw currentError.error;
             }
             const attemptOptions = {
+              ...updatedInterceptorOptions,
               attemptIndex,
-              error: current.error,
-              eventIteratorLastEventId,
-              eventIteratorLastRetry
+              error: currentError.error,
+              lastEventRetry
             };
             const shouldRetryBool = await value(
               shouldRetry,
-              attemptOptions,
-              interceptorOptions.options,
-              interceptorOptions.path,
-              interceptorOptions.input
+              attemptOptions
             );
             if (!shouldRetryBool) {
-              throw current.error;
+              throw currentError.error;
             }
-            unsubscribe = onRetry?.(
-              attemptOptions,
-              interceptorOptions.options,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
-            const retryDelayMs = await value(
-              retryDelay,
-              attemptOptions,
-              interceptorOptions.options,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
+            callback = onRetry?.(attemptOptions);
+            const retryDelayMs = await value(retryDelay, attemptOptions);
             await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
             attemptIndex++;
           }
           try {
-            const newClientOptions = { ...interceptorOptions.options, lastEventId: eventIteratorLastEventId };
-            const output2 = await interceptorOptions.next({
-              ...interceptorOptions,
-              options: newClientOptions
-            });
-            return output2;
+            currentError = void 0;
+            return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
-            if (interceptorOptions.options.signal?.aborted === true) {
+            currentError = { error };
+            if (updatedInterceptorOptions.signal?.aborted === true) {
               throw error;
             }
-            current = { error };
           } finally {
-            unsubscribe?.();
-            unsubscribe = void 0;
+            callback?.(!currentError);
+            callback = void 0;
           }
         }
       };
@@ -97,16 +326,16 @@ class ClientRetryPlugin {
             try {
               const item = await current.next();
               const meta = getEventMeta(item.value);
-              eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
-              eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
               if (item.done) {
                 return item.value;
               }
               yield item.value;
             } catch (error) {
               const meta = getEventMeta(error);
-              eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
-              eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
               const maybeEventIterator = await next({ error });
               if (!isAsyncIteratorObject(maybeEventIterator)) {
                 throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
@@ -124,4 +353,37 @@ class ClientRetryPlugin {
   }
 }
 
-export { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };
+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, DedupeRequestsPlugin, SimpleCsrfProtectionLinkPlugin };

package/dist/shared/client.BOYsZIRq.d.mts

@@ -0,0 +1,29 @@
+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>;
+}
+
+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 };

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

@@ -0,0 +1,29 @@
+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>;
+}
+
+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 };

package/dist/shared/{client.BacCdg3F.mjs → client.BngOL3Ai.mjs}

@@ -1,4 +1,4 @@
-import { isObject, isTypescriptObject } from '@orpc/shared';
+import { resolveMaybeOptionalOptions, isObject, AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
 import { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const COMMON_ORPC_ERROR_DEFS = {
@@ -90,16 +90,17 @@ class ORPCError extends Error {
   code;
   status;
   data;
-  constructor(code, ...[options]) {
-    if (options?.status && (options.status < 400 || options.status >= 600)) {
-      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+  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);
+    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;
+    this.status = fallbackORPCErrorStatus(code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
   }
   toJSON() {
     return {
@@ -110,22 +111,6 @@ class ORPCError extends Error {
       data: this.data
     };
   }
-  static fromJSON(json, options) {
-    return new ORPCError(json.code, {
-      ...options,
-      ...json
-    });
-  }
-  static isValidJSON(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" && "message" in json && typeof json.message === "string";
-  }
 }
 function isDefinedError(error) {
   return error instanceof ORPCError && error.defined;
@@ -136,37 +121,53 @@ function toORPCError(error) {
     cause: error
   });
 }
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
 
 function mapEventIterator(iterator, maps) {
-  return async function* () {
-    try {
-      while (true) {
-        const { done, value } = await iterator.next();
-        let mappedValue = await maps.value(value, done);
-        if (mappedValue !== value) {
-          const meta = getEventMeta(value);
-          if (meta && isTypescriptObject(mappedValue)) {
-            mappedValue = withEventMeta(mappedValue, meta);
+  return new AsyncIteratorClass(async () => {
+    const { done, value } = await (async () => {
+      try {
+        return await iterator.next();
+      } catch (error) {
+        let mappedError = await maps.error(error);
+        if (mappedError !== error) {
+          const meta = getEventMeta(error);
+          if (meta && isTypescriptObject(mappedError)) {
+            mappedError = withEventMeta(mappedError, meta);
           }
         }
-        if (done) {
-          return mappedValue;
-        }
-        yield mappedValue;
+        throw mappedError;
       }
-    } catch (error) {
-      let mappedError = await maps.error(error);
-      if (mappedError !== error) {
-        const meta = getEventMeta(error);
-        if (meta && isTypescriptObject(mappedError)) {
-          mappedError = withEventMeta(mappedError, meta);
-        }
+    })();
+    let mappedValue = await maps.value(value, done);
+    if (mappedValue !== value) {
+      const meta = getEventMeta(value);
+      if (meta && isTypescriptObject(mappedValue)) {
+        mappedValue = withEventMeta(mappedValue, meta);
       }
-      throw mappedError;
-    } finally {
-      await iterator.return?.();
     }
-  }();
+    return { done, value: mappedValue };
+  }, async () => {
+    await iterator.return?.();
+  });
 }
 
-export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, isORPCErrorJson as c, createORPCErrorFromJson as d, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };