@orpc/client 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/plugins/index.mjs

@@ -1,10 +1,9 @@
-import { toArray, value, splitInHalf, stringifyJSON, isAsyncIteratorObject, defer, loadBytes, allAbortSignal, replicateAsyncIterator, replicateReadableStream, override, AsyncIteratorClass, sleep } from '@orpc/shared';
-import { parseStandardUrl, getEventMeta, flattenStandardHeader } from '@standardserver/core';
+import { toArray, value, splitInHalf, stringifyJSON, once, isAsyncIteratorObject, defer, loadBytes, allAbortSignal, replicateAsyncIterator, replicateReadableStream, isCompressibleContentType, override, AsyncIteratorClass, sleep, AbortError, anyAbortSignal } from '@orpc/shared';
+import { parseStandardUrl, flattenStandardHeader, generateContentDisposition, getEventMeta } from '@standardserver/core';
 import { ClientPeer, isServerPeerSendMessage, decodePeerMessage } from '@standardserver/peer';
-import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.Dnfj8jnT.mjs';
+import { toFetchHeaders, toStandardBody } from '@standardserver/fetch';
+import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.DcoDDrD4.mjs';
 
-class BatchLinkPluginError extends TypeError {
-}
 class BatchLinkPlugin {
   name = "~batch";
   groups;
@@ -51,7 +50,7 @@ class BatchLinkPlugin {
         headers: subHeaders
       };
     });
-    this.mapSubresponse = (subResponse, batchResponse) => {
+    this.mapSubresponse = options.mapSubresponse ?? ((subResponse, batchResponse) => {
       return {
         ...subResponse,
         headers: {
@@ -60,7 +59,7 @@ class BatchLinkPlugin {
           ...subResponse.headers
         }
       };
-    };
+    });
   }
   init(options) {
     const transportInterceptor = async (interceptorOptions) => {
@@ -90,9 +89,11 @@ class BatchLinkPlugin {
     this.queue.clear();
     for (const [group, items] of pending) {
       const getItems = items.filter(([options]) => options.request.method === "GET");
-      const restItems = items.filter(([options]) => options.request.method !== "GET");
+      const queryItems = items.filter(([options]) => options.request.method === "QUERY");
+      const unsafeItems = items.filter(([options]) => options.request.method !== "GET" && options.request.method !== "QUERY");
       this.executeBatch("GET", group, getItems);
-      this.executeBatch("POST", group, restItems);
+      this.executeBatch("QUERY", group, queryItems);
+      this.executeBatch("POST", group, unsafeItems);
     }
   }
   async executeBatch(method, group, groupItems) {
@@ -161,6 +162,16 @@ class BatchLinkPlugin {
               request,
               signal: controller.signal
             });
+            if (batchResponse.status >= 400) {
+              suppressErrorFromCurrentBatch = true;
+              const resolveBody = once(() => batchResponse.resolveBody());
+              const errorResponse = { ...batchResponse, resolveBody };
+              groupItems.forEach(([subOptions, resolve]) => {
+                resolve(this.mapSubresponse(errorResponse, batchResponse, subOptions));
+              });
+              await peer.close();
+              return;
+            }
             const body = await batchResponse.resolveBody();
             if (Array.isArray(body) && body.every((v) => isServerPeerSendMessage(v))) {
               for (const message2 of body) {
@@ -171,9 +182,9 @@ class BatchLinkPlugin {
             } else if (body instanceof ReadableStream) {
               await decodeLengthPrefixedStream(body, peer);
             } else {
-              throw new BatchLinkPluginError("Invalid batch response format.");
+              throw new TypeError("Invalid batch response format.");
             }
-            await peer.close(new BatchLinkPluginError("Batch response is incomplete."));
+            await peer.close(new TypeError("Batch response is incomplete."));
           } catch (error) {
             await peer.close(error);
           }
@@ -194,19 +205,19 @@ async function decodeLengthPrefixedBlob(blob, peer) {
   let offset = 0;
   while (offset < buffer.length) {
     if (offset + 4 > buffer.length) {
-      throw new BatchLinkPluginError("Invalid batch response: incomplete length header.");
+      throw new TypeError("Invalid batch response: incomplete length header.");
     }
     const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 4);
     const length = view.getUint32(0, false);
     offset += 4;
     if (offset + length > buffer.length) {
-      throw new BatchLinkPluginError("Invalid batch response: incomplete message.");
+      throw new TypeError("Invalid batch response: incomplete message.");
     }
     const messageBytes = buffer.subarray(offset, offset + length);
     offset += length;
     const result = decodePeerMessage(messageBytes);
     if (!result.matched || !isServerPeerSendMessage(result.message)) {
-      throw new BatchLinkPluginError("Invalid batch response: invalid message.");
+      throw new TypeError("Invalid batch response: invalid message.");
     }
     await peer.message(result.message);
   }
@@ -226,6 +237,10 @@ async function decodeLengthPrefixedStream(stream, peer) {
       while (buffer.length >= 4) {
         const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
         const length = view.getUint32(0, false);
+        if (length === 0) {
+          buffer = buffer.subarray(4);
+          continue;
+        }
         if (buffer.length < 4 + length) {
           break;
         }
@@ -233,7 +248,7 @@ async function decodeLengthPrefixedStream(stream, peer) {
         buffer = buffer.subarray(4 + length);
         const result = decodePeerMessage(messageBytes);
         if (!result.matched || !isServerPeerSendMessage(result.message)) {
-          throw new BatchLinkPluginError("Invalid batch response: invalid message.");
+          throw new TypeError("Invalid batch response: invalid message.");
         }
         await peer.message(result.message);
       }
@@ -254,7 +269,7 @@ class DedupeLinkPlugin {
   queue = /* @__PURE__ */ new Map();
   constructor(options) {
     this.groups = options.groups;
-    this.filter = options.filter ?? (({ request }) => request.method === "GET");
+    this.filter = options.filter ?? (({ request }) => request.method === "GET" || request.method === "QUERY");
   }
   init(options) {
     const transportInterceptor = (interceptorOptions) => {
@@ -387,8 +402,229 @@ function shouldDedupe(items) {
   return items.length >= 2;
 }
 
-class RetryLinkPluginInvalidEventIteratorRetryResponse extends Error {
+const AVG_BYTES_PER_CHAR = 1.2;
+class RequestCompressionLinkPlugin {
+  name = "~request-compression";
+  /**
+   * Compression should be done after batching, to compress the final request
+   */
+  after = ["~batch"];
+  encoding;
+  threshold;
+  constructor(options = {}) {
+    this.encoding = options.encoding ?? "gzip";
+    this.threshold = options.threshold ?? 1024;
+  }
+  init(options) {
+    const transportInterceptor = async ({ next, ...interceptorOptions }) => {
+      const request = interceptorOptions.request;
+      const contentEncoding = flattenStandardHeader(request.headers["content-encoding"])?.trim()?.toLowerCase();
+      if (contentEncoding !== void 0) {
+        return next();
+      }
+      if (request.body instanceof ReadableStream) {
+        const contentLength = Number(flattenStandardHeader(request.headers["content-length"]));
+        if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && isCompressibleContentType(flattenStandardHeader(request.headers["content-type"]))) {
+          const compressedStream = request.body.pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": "octet-stream",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof Blob) {
+        if ((!Number.isFinite(request.body.size) || request.body.size >= this.threshold) && isCompressibleContentType(request.body.type)) {
+          const compressedStream = request.body.stream().pipeThrough(new CompressionStream(this.encoding));
+          const contentDisposition = request.headers["content-disposition"] ?? generateContentDisposition(
+            request.body instanceof File ? request.body.name : "blob"
+          );
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": "file",
+                "content-type": request.body.type,
+                "content-length": [],
+                "content-disposition": contentDisposition,
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof FormData) {
+        const PART_OVERHEAD = 64;
+        let contentLength = 0;
+        for (const [key, value] of request.body) {
+          contentLength += PART_OVERHEAD + key.length;
+          if (value instanceof Blob) {
+            if (!Number.isFinite(value.size)) {
+              if (!isCompressibleContentType(value.type)) {
+                contentLength = -Infinity;
+                break;
+              }
+              contentLength = Infinity;
+            } else {
+              contentLength += isCompressibleContentType(value.type) ? value.size : -value.size;
+            }
+          } else {
+            contentLength += value.length * AVG_BYTES_PER_CHAR;
+          }
+        }
+        if (contentLength >= this.threshold) {
+          const res = new Response(request.body);
+          const compressedStream = res.body.pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": res.headers.get("content-type"),
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof URLSearchParams) {
+        const string = request.body.toString();
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          const compressedStream = new Blob([string]).stream().pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": "application/x-www-form-urlencoded",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body !== void 0 && !isAsyncIteratorObject(request.body)) {
+        const string = stringifyJSON(request.body);
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          const compressedStream = new Blob([string]).stream().pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": "application/json",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      }
+      return next();
+    };
+    return {
+      ...options,
+      transportInterceptors: [
+        ...toArray(options.transportInterceptors),
+        transportInterceptor
+      ]
+    };
+  }
 }
+
+class ResponseCompressionLinkPlugin {
+  name = "~response-compression";
+  /**
+   * Decompression should wrap the final batch response instead of sub-responses.
+   */
+  after = ["~batch"];
+  encodings;
+  constructor(options = {}) {
+    this.encodings = options.encodings ?? ["gzip", "deflate"];
+  }
+  init(options) {
+    const acceptEncodingHeader = this.encodings.join(", ");
+    const transportInterceptor = async ({ next, ...interceptorOptions }) => {
+      const response = await next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          headers: {
+            ...interceptorOptions.request.headers,
+            "accept-encoding": acceptEncodingHeader
+          }
+        }
+      });
+      const encodings = parseContentEncodings(
+        flattenStandardHeader(response.headers["content-encoding"])
+      );
+      if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+        return response;
+      }
+      const decompressedHeaders = {
+        ...response.headers,
+        "content-length": void 0,
+        "content-encoding": void 0
+      };
+      return {
+        ...response,
+        headers: decompressedHeaders,
+        async resolveBody(hint) {
+          const stream = await response.resolveBody("octet-stream");
+          if (!(stream instanceof ReadableStream)) {
+            return stream;
+          }
+          let decompressedStream = stream;
+          for (let i = encodings.length - 1; i >= 0; i--) {
+            decompressedStream = decompressedStream.pipeThrough(
+              new DecompressionStream(encodings[i])
+            );
+          }
+          const fetchResponse = new Response(decompressedStream, {
+            headers: toFetchHeaders(decompressedHeaders)
+          });
+          return toStandardBody(fetchResponse, { hint });
+        }
+      };
+    };
+    return {
+      ...options,
+      transportInterceptors: [
+        ...toArray(options.transportInterceptors),
+        transportInterceptor
+      ]
+    };
+  }
+}
+const SUPPORTED_ENCODINGS = ["gzip", "deflate", "deflate-raw"];
+function isSupportedEncoding(encoding) {
+  return SUPPORTED_ENCODINGS.includes(encoding);
+}
+function parseContentEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().toLowerCase());
+}
+
 class RetryLinkPlugin {
   defaultRetry;
   defaultRetryDelay;
@@ -484,13 +720,13 @@ class RetryLinkPlugin {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              const maybeEventIterator = await callNext({ error });
-              if (!isAsyncIteratorObject(maybeEventIterator)) {
-                throw new RetryLinkPluginInvalidEventIteratorRetryResponse(
-                  "RetryLinkPlugin: Expected an Event Iterator, got a non-Event Iterator"
+              const asyncIteratorObject = await callNext({ error });
+              if (!isAsyncIteratorObject(asyncIteratorObject)) {
+                throw new TypeError(
+                  "RetryLinkPlugin: Expected an AsyncIteratorObject, got a different type."
                 );
               }
-              current = maybeEventIterator;
+              current = asyncIteratorObject;
               if (isIteratorAborted) {
                 await current.return?.();
                 throw error;
@@ -571,4 +807,35 @@ function parseRetryAfterHeader(value2) {
   return void 0;
 }
 
-export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, RetryLinkPluginInvalidEventIteratorRetryResponse };
+class TimeoutLinkPlugin {
+  timeout;
+  name = "~timeout";
+  /**
+   * Should abort if the total retry time exceeds the configured timeout
+   */
+  after = ["~retry"];
+  constructor(options) {
+    this.timeout = options.timeout;
+  }
+  init(options) {
+    const interceptor = async (interceptorOptions) => {
+      const timeoutMs = value(this.timeout, interceptorOptions);
+      if (timeoutMs === null || timeoutMs === void 0) {
+        return interceptorOptions.next();
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => {
+        controller.abort(new AbortError(`Request timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
+      try {
+        return await interceptorOptions.next({ ...interceptorOptions, signal });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    };
+    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
+  }
+}
+
+export { BatchLinkPlugin, RetryLinkPlugin as ClientRetryPlugin, DedupeLinkPlugin, DedupeLinkPlugin as DedupeRequestsPlugin, RequestCompressionLinkPlugin, ResponseCompressionLinkPlugin, RetryAfterLinkPlugin, RetryAfterLinkPlugin as RetryAfterPlugin, RetryLinkPlugin, TimeoutLinkPlugin };

package/dist/shared/{client.Cby_-GGh.d.mts → client.B0-4UDVl.d.mts}

@@ -1,6 +1,6 @@
 import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.8ug8I-zu.mjs';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.CFVTHyN6.mjs';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';

package/dist/shared/{client.CPF3hX6O.d.ts → client.BhTyskpV.d.ts}

@@ -1,6 +1,6 @@
 import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.8ug8I-zu.js';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.CFVTHyN6.js';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';