@orpc/client 0.0.0-next.ea0903c → 0.0.0-next.ea1d4fd

package/dist/plugins/index.mjs

@@ -1,5 +1,261 @@
-import { isAsyncIteratorObject, value } from '@orpc/shared';
-import { getEventMeta } from '@orpc/standard-server';
+import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON, overlayProxy, AsyncIteratorClass } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse, toBatchAbortSignal } from '@orpc/standard-server/batch';
+import { replicateStandardLazyResponse, getEventMeta, flattenHeader } from '@orpc/standard-server';
+import { C as COMMON_ORPC_ERROR_DEFS } from '../shared/client.BDbd8GMX.mjs';
+
+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) || options2.request.signal?.aborted) {
+        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);
+      try {
+        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) });
+        }
+      } catch (err) {
+        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
+          for (const [{ signal }, , reject] of batchItems) {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            }
+          }
+        }
+        throw err;
+      }
+      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 {
 }
@@ -8,6 +264,7 @@ class ClientRetryPlugin {
   defaultRetryDelay;
   defaultShouldRetry;
   defaultOnRetry;
+  order = 18e5;
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
     this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
@@ -17,71 +274,57 @@ class ClientRetryPlugin {
   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 lastEventId = interceptorOptions.options.lastEventId;
+      let lastEventId = interceptorOptions.lastEventId;
       let lastEventRetry;
-      let unsubscribe;
+      let callback;
       let attemptIndex = 0;
-      const next = async (initial) => {
-        let current = initial;
+      const next = async (initialError) => {
+        let currentError = initialError;
         while (true) {
-          const newClientOptions = { ...interceptorOptions.options, lastEventId };
-          if (current) {
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          if (currentError) {
             if (attemptIndex >= maxAttempts) {
-              throw current.error;
+              throw currentError.error;
             }
             const attemptOptions = {
+              ...updatedInterceptorOptions,
               attemptIndex,
-              error: current.error,
-              lastEventId,
+              error: currentError.error,
               lastEventRetry
             };
             const shouldRetryBool = await value(
               shouldRetry,
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
+              attemptOptions
             );
             if (!shouldRetryBool) {
-              throw current.error;
+              throw currentError.error;
             }
-            unsubscribe = onRetry?.(
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
-            const retryDelayMs = await value(
-              retryDelay,
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
+            callback = onRetry?.(attemptOptions);
+            const retryDelayMs = await value(retryDelay, attemptOptions);
             await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
             attemptIndex++;
           }
           try {
-            const output2 = await interceptorOptions.next({
-              ...interceptorOptions,
-              options: newClientOptions
-            });
-            return output2;
+            currentError = void 0;
+            return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
-            if (newClientOptions.signal?.aborted === true) {
+            currentError = { error };
+            if (updatedInterceptorOptions.signal?.aborted) {
               throw error;
             }
-            current = { error };
           } finally {
-            unsubscribe?.();
-            unsubscribe = void 0;
+            callback?.(!currentError);
+            callback = void 0;
           }
         }
       };
@@ -89,19 +332,17 @@ class ClientRetryPlugin {
       if (!isAsyncIteratorObject(output)) {
         return output;
       }
-      return async function* () {
-        let current = output;
-        try {
+      let current = output;
+      let isIteratorAborted = false;
+      return overlayProxy(() => current, new AsyncIteratorClass(
+        async () => {
           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;
+              return item;
             } catch (error) {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
@@ -113,14 +354,132 @@ class ClientRetryPlugin {
                 );
               }
               current = maybeEventIterator;
+              if (isIteratorAborted) {
+                await current.return?.();
+                throw error;
+              }
             }
           }
-        } finally {
-          await current.return?.();
+        },
+        async (reason) => {
+          isIteratorAborted = true;
+          if (reason !== "next") {
+            await current.return?.();
+          }
+        }
+      ));
+    });
+  }
+}
+
+class RetryAfterPlugin {
+  condition;
+  maxAttempts;
+  timeout;
+  order = 19e5;
+  constructor(options = {}) {
+    this.condition = options.condition ?? ((response) => response.status === COMMON_ORPC_ERROR_DEFS.TOO_MANY_REQUESTS.status || response.status === COMMON_ORPC_ERROR_DEFS.SERVICE_UNAVAILABLE.status);
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.timeout = options.timeout ?? 5 * 60 * 1e3;
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (interceptorOptions) => {
+      const startTime = Date.now();
+      let attemptCount = 0;
+      while (true) {
+        attemptCount++;
+        const response = await interceptorOptions.next();
+        if (!value(this.condition, response, interceptorOptions)) {
+          return response;
+        }
+        const retryAfterHeader = flattenHeader(response.headers["retry-after"]);
+        const retryAfterMs = this.parseRetryAfterHeader(retryAfterHeader);
+        if (retryAfterMs === void 0) {
+          return response;
+        }
+        if (attemptCount >= value(this.maxAttempts, response, interceptorOptions)) {
+          return response;
+        }
+        const timeoutMs = value(this.timeout, response, interceptorOptions);
+        const elapsedTime = Date.now() - startTime;
+        if (elapsedTime + retryAfterMs > timeoutMs) {
+          return response;
+        }
+        await this.delayExecution(retryAfterMs, interceptorOptions.signal);
+        if (interceptorOptions.signal?.aborted) {
+          return response;
+        }
+      }
+    });
+  }
+  parseRetryAfterHeader(value2) {
+    value2 = value2?.trim();
+    if (!value2) {
+      return void 0;
+    }
+    const seconds = Number(value2);
+    if (Number.isFinite(seconds)) {
+      return Math.max(0, seconds * 1e3);
+    }
+    const retryDate = Date.parse(value2);
+    if (!Number.isNaN(retryDate)) {
+      return Math.max(0, retryDate - Date.now());
+    }
+    return void 0;
+  }
+  delayExecution(ms, signal) {
+    return new Promise((resolve) => {
+      if (signal?.aborted) {
+        resolve();
+        return;
+      }
+      let timeout;
+      const onAbort = () => {
+        clearTimeout(timeout);
+        timeout = void 0;
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+    });
+  }
+}
+
+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 { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };

package/dist/shared/client.BDbd8GMX.mjs

@@ -0,0 +1,171 @@
+import { resolveMaybeOptionalOptions, getConstructor, isObject } from '@orpc/shared';
+
+const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.ea1d4fd";
+
+const COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+const GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+void (globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+const globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== void 0 && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    const message = fallbackORPCErrorMessage(code, options.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (globalORPCErrorConstructors.has(this)) {
+      const constructor = getConstructor(instance);
+      if (constructor && globalORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+globalORPCErrorConstructors.add(ORPCError);
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+
+export { COMMON_ORPC_ERROR_DEFS as C, ORPC_CLIENT_PACKAGE_NAME as O, ORPC_CLIENT_PACKAGE_VERSION as a, fallbackORPCErrorMessage as b, ORPCError as c, isORPCErrorStatus as d, isORPCErrorJson as e, fallbackORPCErrorStatus as f, createORPCErrorFromJson as g, isDefinedError as i, toORPCError as t };