@depup/apollo__client 4.1.6-depup.0

package/link/batch/batchLink.d.ts

@@ -0,0 +1,117 @@
+import type { Observable } from "rxjs";
+import { ApolloLink } from "@apollo/client/link";
+export declare namespace BatchLink {
+    namespace Shared {
+        /** These options are shared between `BatchLink` and `BatchHttpLink` */
+        interface Options {
+            /**
+             * The interval at which to batch, in milliseconds.
+             *
+             * @defaultValue 10
+             */
+            batchInterval?: number;
+            /**
+             * "batchInterval" is a throttling behavior by default, if you instead wish
+             * to debounce outbound requests, set "batchDebounce" to true. More useful
+             * for mutations than queries.
+             */
+            batchDebounce?: boolean;
+            /**
+             * The maximum number of operations to include in a single batch.
+             *
+             * @defaultValue \{\{defaultValue\}\}
+             */
+            batchMax?: number;
+            /**
+             * Creates the key for a batch
+             */
+            batchKey?: (operation: ApolloLink.Operation) => string;
+        }
+    }
+    /**
+     * Function type for handling a batch of GraphQL operations.
+     *
+     * @remarks
+     *
+     * The batch handler is responsible for processing multiple operations together
+     * and returning their results. Each operation has a corresponding forward function
+     * that can be used to continue processing down the link chain.
+     *
+     * Results must be returned in the same order as the input operations to ensure
+     * proper correlation with the original requests.
+     *
+     * @param operations - Array of GraphQL operations to process
+     * @param forward - Array of forward functions, one per operation
+     * @returns Observable that emits an array of results in the same order as operations
+     */
+    type BatchHandler = (operations: ApolloLink.Operation[], forward: ApolloLink.ForwardFunction[]) => Observable<ApolloLink.Result[]>;
+    /**
+     * Configuration options for creating a `BatchLink` instance.
+     *
+     * @remarks
+     *
+     * `BatchLink` options control how operations are grouped into batches
+     * and when those batches are processed. The `batchHandler` function
+     * is responsible for actually processing the batched operations.
+     *
+     * Most batching behavior is configured through timing options:
+     *
+     * - `batchInterval`: How long to wait before processing a batch
+     * - `batchDebounce`: Whether to reset the timer on new operations
+     * - `batchMax`: Maximum operations per batch (0 = unlimited)
+     *
+     * Custom grouping logic can be implemented via `batchKey` function.
+     */
+    interface Options extends Shared.Options {
+        /**
+         * The handler that executes a batch of operations.
+         *
+         * @remarks
+         *
+         * This function receives an array of operations and their corresponding
+         * forward functions, and should return an Observable that emits the results
+         * for all operations in the batch.
+         */
+        batchHandler?: BatchLink.BatchHandler;
+        /**
+        * The maximum number of operations to include in a single batch.
+        * 
+        * @defaultValue 0
+        */
+        batchMax?: number;
+    }
+}
+/**
+ * `BatchLink` is a non-terminating link that provides the core batching
+ * functionality for grouping multiple GraphQL operations into batches based
+ * on configurable timing and key-based grouping strategies. It serves as a base
+ * link to `BatchHttpLink`.
+ *
+ * @remarks
+ *
+ * > [!NOTE]
+ * > You will not generally use `BatchLink` on your own unless you need to
+ * > provide batching capabilities to third-party terminating links. Prefer
+ * > using `BatchHttpLink` to batch GraphQL operations over HTTP.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BatchLink } from "@apollo/client/link/batch";
+ *
+ * const link = new BatchLink({
+ *   batchInterval: 20,
+ *   batchMax: 5,
+ *   batchHandler: (operations, forwards) => {
+ *     // Custom logic to process batch of operations
+ *     return handleBatch(operations, forwards);
+ *   },
+ * });
+ * ```
+ */
+export declare class BatchLink extends ApolloLink {
+    private batcher;
+    constructor(options?: BatchLink.Options);
+    request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
+}
+//# sourceMappingURL=batchLink.d.ts.map

package/link/batch/batchLink.js

@@ -0,0 +1,49 @@
+import { EMPTY } from "rxjs";
+import { ApolloLink } from "@apollo/client/link";
+import { OperationBatcher } from "./batching.js";
+/**
+ * `BatchLink` is a non-terminating link that provides the core batching
+ * functionality for grouping multiple GraphQL operations into batches based
+ * on configurable timing and key-based grouping strategies. It serves as a base
+ * link to `BatchHttpLink`.
+ *
+ * @remarks
+ *
+ * > [!NOTE]
+ * > You will not generally use `BatchLink` on your own unless you need to
+ * > provide batching capabilities to third-party terminating links. Prefer
+ * > using `BatchHttpLink` to batch GraphQL operations over HTTP.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BatchLink } from "@apollo/client/link/batch";
+ *
+ * const link = new BatchLink({
+ *   batchInterval: 20,
+ *   batchMax: 5,
+ *   batchHandler: (operations, forwards) => {
+ *     // Custom logic to process batch of operations
+ *     return handleBatch(operations, forwards);
+ *   },
+ * });
+ * ```
+ */
+export class BatchLink extends ApolloLink {
+    batcher;
+    constructor(options) {
+        super();
+        const { batchDebounce, batchInterval = 10, batchMax = 0, batchHandler = () => EMPTY, batchKey = () => "", } = options || {};
+        this.batcher = new OperationBatcher({
+            batchDebounce,
+            batchInterval,
+            batchMax,
+            batchHandler,
+            batchKey,
+        });
+    }
+    request(operation, forward) {
+        return this.batcher.enqueueRequest({ operation, forward });
+    }
+}
+//# sourceMappingURL=batchLink.js.map

package/link/batch/batchLink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batchLink.js","sourceRoot":"","sources":["../../../src/link/batch/batchLink.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7B,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAyFjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,SAAU,SAAQ,UAAU;IAC/B,OAAO,CAAmB;IAElC,YAAY,OAA2B;QACrC,KAAK,EAAE,CAAC;QAER,MAAM,EACJ,aAAa,EACb,aAAa,GAAG,EAAE,EAClB,QAAQ,GAAG,CAAC,EACZ,YAAY,GAAG,GAAG,EAAE,CAAC,KAAK,EAC1B,QAAQ,GAAG,GAAG,EAAE,CAAC,EAAE,GACpB,GAAG,OAAO,IAAI,EAAE,CAAC;QAElB,IAAI,CAAC,OAAO,GAAG,IAAI,gBAAgB,CAAC;YAClC,aAAa;YACb,aAAa;YACb,QAAQ;YACR,YAAY;YACZ,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;IAEM,OAAO,CACZ,SAA+B,EAC/B,OAAmC;QAEnC,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF","sourcesContent":["import type { Observable } from \"rxjs\";\nimport { EMPTY } from \"rxjs\";\n\nimport { ApolloLink } from \"@apollo/client/link\";\n\nimport { OperationBatcher } from \"./batching.js\";\n\nexport declare namespace BatchLink {\n  export namespace Shared {\n    /** These options are shared between `BatchLink` and `BatchHttpLink` */\n    interface Options {\n      /**\n       * The interval at which to batch, in milliseconds.\n       *\n       * @defaultValue 10\n       */\n      batchInterval?: number;\n\n      /**\n       * \"batchInterval\" is a throttling behavior by default, if you instead wish\n       * to debounce outbound requests, set \"batchDebounce\" to true. More useful\n       * for mutations than queries.\n       */\n      batchDebounce?: boolean;\n\n      /**\n       * The maximum number of operations to include in a single batch.\n       *\n       * @defaultValue \\{\\{defaultValue\\}\\}\n       */\n      batchMax?: number;\n\n      /**\n       * Creates the key for a batch\n       */\n      batchKey?: (operation: ApolloLink.Operation) => string;\n    }\n  }\n\n  /**\n   * Function type for handling a batch of GraphQL operations.\n   *\n   * @remarks\n   *\n   * The batch handler is responsible for processing multiple operations together\n   * and returning their results. Each operation has a corresponding forward function\n   * that can be used to continue processing down the link chain.\n   *\n   * Results must be returned in the same order as the input operations to ensure\n   * proper correlation with the original requests.\n   *\n   * @param operations - Array of GraphQL operations to process\n   * @param forward - Array of forward functions, one per operation\n   * @returns Observable that emits an array of results in the same order as operations\n   */\n  export type BatchHandler = (\n    operations: ApolloLink.Operation[],\n    forward: ApolloLink.ForwardFunction[]\n  ) => Observable<ApolloLink.Result[]>;\n\n  /**\n   * Configuration options for creating a `BatchLink` instance.\n   *\n   * @remarks\n   *\n   * `BatchLink` options control how operations are grouped into batches\n   * and when those batches are processed. The `batchHandler` function\n   * is responsible for actually processing the batched operations.\n   *\n   * Most batching behavior is configured through timing options:\n   *\n   * - `batchInterval`: How long to wait before processing a batch\n   * - `batchDebounce`: Whether to reset the timer on new operations\n   * - `batchMax`: Maximum operations per batch (0 = unlimited)\n   *\n   * Custom grouping logic can be implemented via `batchKey` function.\n   */\n  export interface Options extends Shared.Options {\n    /**\n     * The handler that executes a batch of operations.\n     *\n     * @remarks\n     *\n     * This function receives an array of operations and their corresponding\n     * forward functions, and should return an Observable that emits the results\n     * for all operations in the batch.\n     */\n    batchHandler?: BatchLink.BatchHandler;\n\n    /** {@inheritDoc @apollo/client/link/batch!BatchLink.Shared.Options#batchMax:member {\"defaultValue\": 0}} */\n    batchMax?: number;\n  }\n}\n\n/**\n * `BatchLink` is a non-terminating link that provides the core batching\n * functionality for grouping multiple GraphQL operations into batches based\n * on configurable timing and key-based grouping strategies. It serves as a base\n * link to `BatchHttpLink`.\n *\n * @remarks\n *\n * > [!NOTE]\n * > You will not generally use `BatchLink` on your own unless you need to\n * > provide batching capabilities to third-party terminating links. Prefer\n * > using `BatchHttpLink` to batch GraphQL operations over HTTP.\n *\n * @example\n *\n * ```ts\n * import { BatchLink } from \"@apollo/client/link/batch\";\n *\n * const link = new BatchLink({\n *   batchInterval: 20,\n *   batchMax: 5,\n *   batchHandler: (operations, forwards) => {\n *     // Custom logic to process batch of operations\n *     return handleBatch(operations, forwards);\n *   },\n * });\n * ```\n */\nexport class BatchLink extends ApolloLink {\n  private batcher: OperationBatcher;\n\n  constructor(options?: BatchLink.Options) {\n    super();\n\n    const {\n      batchDebounce,\n      batchInterval = 10,\n      batchMax = 0,\n      batchHandler = () => EMPTY,\n      batchKey = () => \"\",\n    } = options || {};\n\n    this.batcher = new OperationBatcher({\n      batchDebounce,\n      batchInterval,\n      batchMax,\n      batchHandler,\n      batchKey,\n    });\n  }\n\n  public request(\n    operation: ApolloLink.Operation,\n    forward: ApolloLink.ForwardFunction\n  ): Observable<ApolloLink.Result> {\n    return this.batcher.enqueueRequest({ operation, forward });\n  }\n}\n"]}

package/link/batch/batching.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from "rxjs";
+import type { ApolloLink } from "@apollo/client/link";
+import type { BatchLink } from "./batchLink.js";
+export interface BatchableRequest {
+    operation: ApolloLink.Operation;
+    forward: ApolloLink.ForwardFunction;
+}
+export declare class OperationBatcher {
+    private batchesByKey;
+    private scheduledBatchTimerByKey;
+    private batchDebounce?;
+    private batchInterval?;
+    private batchMax;
+    private batchHandler;
+    private batchKey;
+    constructor({ batchDebounce, batchInterval, batchMax, batchHandler, batchKey, }: {
+        batchDebounce?: boolean;
+        batchInterval?: number;
+        batchMax?: number;
+        batchHandler: BatchLink.BatchHandler;
+        batchKey?: (operation: ApolloLink.Operation) => string;
+    });
+    enqueueRequest(request: BatchableRequest): Observable<ApolloLink.Result>;
+    consumeQueue(key?: string): (Observable<ApolloLink.Result> | undefined)[] | undefined;
+    private scheduleQueueConsumption;
+}
+//# sourceMappingURL=batching.d.ts.map

package/link/batch/batching.js

@@ -0,0 +1,152 @@
+import { Observable } from "rxjs";
+// QueryBatcher doesn't fire requests immediately. Requests that were enqueued within
+// a certain amount of time (configurable through `batchInterval`) will be batched together
+// into one query.
+export class OperationBatcher {
+    // Queue on which the QueryBatcher will operate on a per-tick basis.
+    batchesByKey = new Map();
+    scheduledBatchTimerByKey = new Map();
+    batchDebounce;
+    batchInterval;
+    batchMax;
+    //This function is called to the queries in the queue to the server.
+    batchHandler;
+    batchKey;
+    constructor({ batchDebounce, batchInterval, batchMax, batchHandler, batchKey, }) {
+        this.batchDebounce = batchDebounce;
+        this.batchInterval = batchInterval;
+        this.batchMax = batchMax || 0;
+        this.batchHandler = batchHandler;
+        this.batchKey = batchKey || (() => "");
+    }
+    enqueueRequest(request) {
+        const requestCopy = {
+            ...request,
+            next: [],
+            error: [],
+            complete: [],
+            subscribers: new Set(),
+        };
+        const key = this.batchKey(request.operation);
+        if (!requestCopy.observable) {
+            requestCopy.observable = new Observable((observer) => {
+                let batch = this.batchesByKey.get(key);
+                if (!batch)
+                    this.batchesByKey.set(key, (batch = new Set()));
+                // These booleans seem to me (@benjamn) like they might always be the
+                // same (and thus we could do with only one of them), but I'm not 100%
+                // sure about that.
+                const isFirstEnqueuedRequest = batch.size === 0;
+                const isFirstSubscriber = requestCopy.subscribers.size === 0;
+                requestCopy.subscribers.add(observer);
+                if (isFirstSubscriber) {
+                    batch.add(requestCopy);
+                }
+                // called for each subscriber, so need to save all listeners (next, error, complete)
+                if (observer.next) {
+                    requestCopy.next.push(observer.next.bind(observer));
+                }
+                if (observer.error) {
+                    requestCopy.error.push(observer.error.bind(observer));
+                }
+                if (observer.complete) {
+                    requestCopy.complete.push(observer.complete.bind(observer));
+                }
+                // The first enqueued request triggers the queue consumption after `batchInterval` milliseconds.
+                if (isFirstEnqueuedRequest || this.batchDebounce) {
+                    this.scheduleQueueConsumption(key);
+                }
+                // When amount of requests reaches `batchMax`, trigger the queue consumption without waiting on the `batchInterval`.
+                if (batch.size === this.batchMax) {
+                    this.consumeQueue(key);
+                }
+                return () => {
+                    // If this is last subscriber for this request, remove request from queue
+                    if (requestCopy.subscribers.delete(observer) &&
+                        requestCopy.subscribers.size < 1) {
+                        // If this is last request from queue, remove queue entirely
+                        if (batch.delete(requestCopy) && batch.size < 1) {
+                            this.consumeQueue(key);
+                            // If queue was in flight, cancel it
+                            batch.subscription?.unsubscribe();
+                        }
+                    }
+                };
+            });
+        }
+        return requestCopy.observable;
+    }
+    // Consumes the queue.
+    // Returns a list of promises (one for each query).
+    consumeQueue(key = "") {
+        const batch = this.batchesByKey.get(key);
+        // Delete this batch and process it below.
+        this.batchesByKey.delete(key);
+        if (!batch || !batch.size) {
+            // No requests to be processed.
+            return;
+        }
+        const operations = [];
+        const forwards = [];
+        const observables = [];
+        const nexts = [];
+        const errors = [];
+        const completes = [];
+        // Even though batch is a Set, it preserves the order of first insertion
+        // when iterating (per ECMAScript specification), so these requests will be
+        // handled in the order they were enqueued (minus any deleted ones).
+        batch.forEach((request) => {
+            operations.push(request.operation);
+            forwards.push(request.forward);
+            observables.push(request.observable);
+            nexts.push(request.next);
+            errors.push(request.error);
+            completes.push(request.complete);
+        });
+        const batchedObservable = this.batchHandler(operations, forwards);
+        const onError = (error) => {
+            //each callback list in batch
+            errors.forEach((rejecters) => {
+                if (rejecters) {
+                    //each subscriber to request
+                    rejecters.forEach((e) => e(error));
+                }
+            });
+        };
+        batch.subscription = batchedObservable.subscribe({
+            next: (results) => {
+                if (!Array.isArray(results)) {
+                    results = [results];
+                }
+                if (nexts.length !== results.length) {
+                    const error = new Error(`server returned results with length ${results.length}, expected length of ${nexts.length}`);
+                    error.result = results;
+                    return onError(error);
+                }
+                results.forEach((result, index) => {
+                    if (nexts[index]) {
+                        nexts[index].forEach((next) => next(result));
+                    }
+                });
+            },
+            error: onError,
+            complete: () => {
+                completes.forEach((complete) => {
+                    if (complete) {
+                        //each subscriber to request
+                        complete.forEach((c) => c());
+                    }
+                });
+            },
+        });
+        return observables;
+    }
+    scheduleQueueConsumption(key) {
+        clearTimeout(this.scheduledBatchTimerByKey.get(key));
+        this.scheduledBatchTimerByKey.set(key, setTimeout(() => {
+            this.consumeQueue(key);
+            this.scheduledBatchTimerByKey.delete(key);
+        }, this.batchInterval));
+    }
+}
+//# sourceMappingURL=batching.js.map

package/link/batch/batching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.js","sourceRoot":"","sources":["../../../src/link/batch/batching.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Subscription } from \"rxjs\";\nimport { Observable } from \"rxjs\";\n\nimport type { ApolloLink } from \"@apollo/client/link\";\n\nimport type { BatchLink } from \"./batchLink.js\";\n\nexport interface BatchableRequest {\n  operation: ApolloLink.Operation;\n  forward: ApolloLink.ForwardFunction;\n}\n\ntype QueuedRequest = BatchableRequest & {\n  observable?: Observable<ApolloLink.Result>;\n  next: Array<(result: ApolloLink.Result) => void>;\n  error: Array<(error: Error) => void>;\n  complete: Array<() => void>;\n  subscribers: Set<object>;\n};\n\n// Batches are primarily a Set<QueuedRequest>, but may have other optional\n// properties, such as batch.subscription.\ntype RequestBatch = Set<QueuedRequest> & {\n  subscription?: Subscription;\n};\n\n// QueryBatcher doesn't fire requests immediately. Requests that were enqueued within\n// a certain amount of time (configurable through `batchInterval`) will be batched together\n// into one query.\nexport class OperationBatcher {\n  // Queue on which the QueryBatcher will operate on a per-tick basis.\n  private batchesByKey = new Map<string, RequestBatch>();\n\n  private scheduledBatchTimerByKey = new Map<\n    string,\n    ReturnType<typeof setTimeout>\n  >();\n  private batchDebounce?: boolean;\n  private batchInterval?: number;\n  private batchMax: number;\n\n  //This function is called to the queries in the queue to the server.\n  private batchHandler: BatchLink.BatchHandler;\n  private batchKey: (operation: ApolloLink.Operation) => string;\n\n  constructor({\n    batchDebounce,\n    batchInterval,\n    batchMax,\n    batchHandler,\n    batchKey,\n  }: {\n    batchDebounce?: boolean;\n    batchInterval?: number;\n    batchMax?: number;\n    batchHandler: BatchLink.BatchHandler;\n    batchKey?: (operation: ApolloLink.Operation) => string;\n  }) {\n    this.batchDebounce = batchDebounce;\n    this.batchInterval = batchInterval;\n    this.batchMax = batchMax || 0;\n    this.batchHandler = batchHandler;\n    this.batchKey = batchKey || (() => \"\");\n  }\n\n  public enqueueRequest(\n    request: BatchableRequest\n  ): Observable<ApolloLink.Result> {\n    const requestCopy: QueuedRequest = {\n      ...request,\n      next: [],\n      error: [],\n      complete: [],\n      subscribers: new Set(),\n    };\n\n    const key = this.batchKey(request.operation);\n\n    if (!requestCopy.observable) {\n      requestCopy.observable = new Observable<ApolloLink.Result>((observer) => {\n        let batch = this.batchesByKey.get(key)!;\n        if (!batch) this.batchesByKey.set(key, (batch = new Set()));\n\n        // These booleans seem to me (@benjamn) like they might always be the\n        // same (and thus we could do with only one of them), but I'm not 100%\n        // sure about that.\n        const isFirstEnqueuedRequest = batch.size === 0;\n        const isFirstSubscriber = requestCopy.subscribers.size === 0;\n        requestCopy.subscribers.add(observer);\n        if (isFirstSubscriber) {\n          batch.add(requestCopy);\n        }\n\n        // called for each subscriber, so need to save all listeners (next, error, complete)\n        if (observer.next) {\n          requestCopy.next.push(observer.next.bind(observer));\n        }\n\n        if (observer.error) {\n          requestCopy.error.push(observer.error.bind(observer));\n        }\n\n        if (observer.complete) {\n          requestCopy.complete.push(observer.complete.bind(observer));\n        }\n\n        // The first enqueued request triggers the queue consumption after `batchInterval` milliseconds.\n        if (isFirstEnqueuedRequest || this.batchDebounce) {\n          this.scheduleQueueConsumption(key);\n        }\n\n        // When amount of requests reaches `batchMax`, trigger the queue consumption without waiting on the `batchInterval`.\n        if (batch.size === this.batchMax) {\n          this.consumeQueue(key);\n        }\n\n        return () => {\n          // If this is last subscriber for this request, remove request from queue\n          if (\n            requestCopy.subscribers.delete(observer) &&\n            requestCopy.subscribers.size < 1\n          ) {\n            // If this is last request from queue, remove queue entirely\n            if (batch.delete(requestCopy) && batch.size < 1) {\n              this.consumeQueue(key);\n              // If queue was in flight, cancel it\n              batch.subscription?.unsubscribe();\n            }\n          }\n        };\n      });\n    }\n\n    return requestCopy.observable;\n  }\n\n  // Consumes the queue.\n  // Returns a list of promises (one for each query).\n  public consumeQueue(\n    key: string = \"\"\n  ): (Observable<ApolloLink.Result> | undefined)[] | undefined {\n    const batch = this.batchesByKey.get(key);\n    // Delete this batch and process it below.\n    this.batchesByKey.delete(key);\n    if (!batch || !batch.size) {\n      // No requests to be processed.\n      return;\n    }\n\n    const operations: QueuedRequest[\"operation\"][] = [];\n    const forwards: QueuedRequest[\"forward\"][] = [];\n    const observables: QueuedRequest[\"observable\"][] = [];\n    const nexts: QueuedRequest[\"next\"][] = [];\n    const errors: QueuedRequest[\"error\"][] = [];\n    const completes: QueuedRequest[\"complete\"][] = [];\n\n    // Even though batch is a Set, it preserves the order of first insertion\n    // when iterating (per ECMAScript specification), so these requests will be\n    // handled in the order they were enqueued (minus any deleted ones).\n    batch.forEach((request) => {\n      operations.push(request.operation);\n      forwards.push(request.forward);\n      observables.push(request.observable);\n      nexts.push(request.next);\n      errors.push(request.error);\n      completes.push(request.complete);\n    });\n\n    const batchedObservable = this.batchHandler(operations, forwards);\n\n    const onError = (error: Error) => {\n      //each callback list in batch\n      errors.forEach((rejecters) => {\n        if (rejecters) {\n          //each subscriber to request\n          rejecters.forEach((e) => e(error));\n        }\n      });\n    };\n\n    batch.subscription = batchedObservable.subscribe({\n      next: (results) => {\n        if (!Array.isArray(results)) {\n          results = [results];\n        }\n\n        if (nexts.length !== results.length) {\n          const error = new Error(\n            `server returned results with length ${results.length}, expected length of ${nexts.length}`\n          );\n          (error as any).result = results;\n\n          return onError(error);\n        }\n\n        results.forEach((result, index) => {\n          if (nexts[index]) {\n            nexts[index].forEach((next) => next(result));\n          }\n        });\n      },\n      error: onError,\n      complete: () => {\n        completes.forEach((complete) => {\n          if (complete) {\n            //each subscriber to request\n            complete.forEach((c) => c());\n          }\n        });\n      },\n    });\n\n    return observables;\n  }\n\n  private scheduleQueueConsumption(key: string): void {\n    clearTimeout(this.scheduledBatchTimerByKey.get(key));\n    this.scheduledBatchTimerByKey.set(\n      key,\n      setTimeout(() => {\n        this.consumeQueue(key);\n        this.scheduledBatchTimerByKey.delete(key);\n      }, this.batchInterval)\n    );\n  }\n}\n"]}

package/link/batch/index.d.ts

@@ -0,0 +1,2 @@
+export { BatchLink } from "./batchLink.js";
+//# sourceMappingURL=index.d.ts.map

package/link/batch/index.js

@@ -0,0 +1,2 @@
+export { BatchLink } from "./batchLink.js";
+//# sourceMappingURL=index.js.map

package/link/batch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/link/batch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC","sourcesContent":["export { BatchLink } from \"./batchLink.js\";\n"]}

package/link/batch-http/BaseBatchHttpLink.d.ts

@@ -0,0 +1,68 @@
+import { Observable } from "rxjs";
+import { ApolloLink } from "@apollo/client/link";
+import { BatchLink } from "@apollo/client/link/batch";
+import type { BaseHttpLink } from "@apollo/client/link/http";
+export declare namespace BaseBatchHttpLink {
+    /**
+     * Options passed to `BaseBatchHttpLink` through [request context](https://apollographql.com/docs/react/api/link/introduction#managing-context). Previous
+     * non-terminating links in the link chain also can set these values to
+     * customize the behavior of `BatchHttpLink` for each operation.
+     *
+     * > [!NOTE]
+     * > Some of these values can also be provided to the `BaseBatchHttpLink` constructor.
+     * > If a value is provided to both, the value in `context` takes precedence.
+     */
+    interface ContextOptions extends BaseHttpLink.ContextOptions {
+    }
+    /**
+     * Configuration options for creating a `BaseBatchHttpLink` instance.
+     *
+     * > [!NOTE]
+     * > Some of these options are also available to override in [request context](https://apollographql.com/docs/react/api/link/introduction#managing-context).
+     * > Context options override the options passed to the constructor. Treat
+     * > these options as default values that are used when the request context
+     * > does not override the value.
+     */
+    interface Options extends BatchLink.Shared.Options, BaseHttpLink.Shared.Options {
+        /**
+        * The maximum number of operations to include in a single batch.
+        * 
+        * @defaultValue 10
+        */
+        batchMax?: number;
+    }
+}
+/**
+ * `BaseBatchHttpLink` is a terminating link that batches array of individual
+ * GraphQL operations into a single HTTP request that's sent to a single GraphQL
+ * endpoint. It serves as a base link to `BatchHttpLink`.
+ *
+ * @remarks
+ *
+ * > [!NOTE]
+ * > Prefer using `BatchHttpLink` over `BaseBatchHttpLink`. Use
+ * > `BaseBatchHttpLink` when you need to disable client awareness features and
+ * > would like to tree-shake the implementation of `ClientAwarenessLink` out
+ * > of your app bundle.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BaseBatchHttpLink } from "@apollo/client/link/batch-http";
+ *
+ * const link = new BaseBatchHttpLink({
+ *   uri: "http://localhost:4000/graphql",
+ *   batchMax: 5, // No more than 5 operations per batch
+ *   batchInterval: 20, // Wait no more than 20ms after first batched operation
+ * });
+ * ```
+ */
+export declare class BaseBatchHttpLink extends ApolloLink {
+    private batchDebounce?;
+    private batchInterval;
+    private batchMax;
+    private batcher;
+    constructor(options?: BaseBatchHttpLink.Options);
+    request(operation: ApolloLink.Operation, forward: ApolloLink.ForwardFunction): Observable<ApolloLink.Result>;
+}
+//# sourceMappingURL=BaseBatchHttpLink.d.ts.map

package/link/batch-http/BaseBatchHttpLink.js

@@ -0,0 +1,152 @@
+import { Observable, throwError } from "rxjs";
+import { ApolloLink } from "@apollo/client/link";
+import { BatchLink } from "@apollo/client/link/batch";
+import { checkFetcher, defaultPrinter, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBodyInternal, selectURI, } from "@apollo/client/link/http";
+import { filterOperationVariables } from "@apollo/client/link/utils";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { compact } from "@apollo/client/utilities/internal";
+import { maybe } from "@apollo/client/utilities/internal/globals";
+const backupFetch = maybe(() => fetch);
+/**
+ * `BaseBatchHttpLink` is a terminating link that batches array of individual
+ * GraphQL operations into a single HTTP request that's sent to a single GraphQL
+ * endpoint. It serves as a base link to `BatchHttpLink`.
+ *
+ * @remarks
+ *
+ * > [!NOTE]
+ * > Prefer using `BatchHttpLink` over `BaseBatchHttpLink`. Use
+ * > `BaseBatchHttpLink` when you need to disable client awareness features and
+ * > would like to tree-shake the implementation of `ClientAwarenessLink` out
+ * > of your app bundle.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BaseBatchHttpLink } from "@apollo/client/link/batch-http";
+ *
+ * const link = new BaseBatchHttpLink({
+ *   uri: "http://localhost:4000/graphql",
+ *   batchMax: 5, // No more than 5 operations per batch
+ *   batchInterval: 20, // Wait no more than 20ms after first batched operation
+ * });
+ * ```
+ */
+export class BaseBatchHttpLink extends ApolloLink {
+    batchDebounce;
+    batchInterval;
+    batchMax;
+    batcher;
+    constructor(options = {}) {
+        super();
+        let { uri = "/graphql", 
+        // use default global fetch if nothing is passed in
+        fetch: preferredFetch, print = defaultPrinter, includeExtensions, preserveHeaderCase, batchInterval, batchDebounce, batchMax, batchKey, includeUnusedVariables = false, ...requestOptions } = options;
+        if (__DEV__) {
+            // Make sure at least one of preferredFetch, window.fetch, or backupFetch
+            // is defined, so requests won't fail at runtime.
+            checkFetcher(preferredFetch || backupFetch);
+        }
+        const linkConfig = {
+            http: compact({ includeExtensions, preserveHeaderCase }),
+            options: requestOptions.fetchOptions,
+            credentials: requestOptions.credentials,
+            headers: requestOptions.headers,
+        };
+        this.batchDebounce = batchDebounce;
+        this.batchInterval = batchInterval || 10;
+        this.batchMax = batchMax || 10;
+        const batchHandler = (operations) => {
+            const chosenURI = selectURI(operations[0], uri);
+            const context = operations[0].getContext();
+            const contextConfig = {
+                http: context.http,
+                options: context.fetchOptions,
+                credentials: context.credentials,
+                headers: context.headers,
+            };
+            //uses fallback, link, and then context to build options
+            const optsAndBody = operations.map((operation) => {
+                const result = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig);
+                if (result.body.variables && !includeUnusedVariables) {
+                    result.body.variables = filterOperationVariables(result.body.variables, operation.query);
+                }
+                return result;
+            });
+            const loadedBody = optsAndBody.map(({ body }) => body);
+            const options = optsAndBody[0].options;
+            // There's no spec for using GET with batches.
+            if (options.method === "GET") {
+                return throwError(() => new Error("apollo-link-batch-http does not support GET requests"));
+            }
+            try {
+                options.body = JSON.stringify(loadedBody);
+            }
+            catch (parseError) {
+                return throwError(() => parseError);
+            }
+            let controller;
+            if (!options.signal && typeof AbortController !== "undefined") {
+                controller = new AbortController();
+                options.signal = controller.signal;
+            }
+            return new Observable((observer) => {
+                // Prefer BatchHttpLink.Options.fetch (preferredFetch) if provided, and
+                // otherwise fall back to the *current* global window.fetch function
+                // (see issue #7832), or (if all else fails) the backupFetch function we
+                // saved when this module was first evaluated. This last option protects
+                // against the removal of window.fetch, which is unlikely but not
+                // impossible.
+                const currentFetch = preferredFetch || maybe(() => fetch) || backupFetch;
+                currentFetch(chosenURI, options)
+                    .then((response) => {
+                    // Make the raw response available in the context.
+                    operations.forEach((operation) => operation.setContext({ response }));
+                    return response;
+                })
+                    .then(parseAndCheckHttpResponse(operations))
+                    .then((result) => {
+                    controller = undefined;
+                    // we have data and can send it to back up the link chain
+                    observer.next(result);
+                    observer.complete();
+                    return result;
+                })
+                    .catch((err) => {
+                    controller = undefined;
+                    observer.error(err);
+                });
+                return () => {
+                    // XXX support canceling this request
+                    // https://developers.google.com/web/updates/2017/09/abortable-fetch
+                    if (controller)
+                        controller.abort();
+                };
+            });
+        };
+        batchKey =
+            batchKey ||
+                ((operation) => {
+                    const context = operation.getContext();
+                    const contextConfig = {
+                        http: context.http,
+                        options: context.fetchOptions,
+                        credentials: context.credentials,
+                        headers: context.headers,
+                    };
+                    //may throw error if config not serializable
+                    return selectURI(operation, uri) + JSON.stringify(contextConfig);
+                });
+        this.batcher = new BatchLink({
+            batchDebounce: this.batchDebounce,
+            batchInterval: this.batchInterval,
+            batchMax: this.batchMax,
+            batchKey,
+            batchHandler,
+        });
+    }
+    request(operation, forward) {
+        return this.batcher.request(operation, forward);
+    }
+}
+//# sourceMappingURL=BaseBatchHttpLink.js.map

package/link/batch-http/BaseBatchHttpLink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseBatchHttpLink.js","sourceRoot":"","sources":["../../../src/link/batch-http/BaseBatchHttpLink.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, throwError } from \"rxjs\";\n\nimport { ApolloLink } from \"@apollo/client/link\";\nimport { BatchLink } from \"@apollo/client/link/batch\";\nimport type { BaseHttpLink } from \"@apollo/client/link/http\";\nimport {\n  checkFetcher,\n  defaultPrinter,\n  fallbackHttpConfig,\n  parseAndCheckHttpResponse,\n  selectHttpOptionsAndBodyInternal,\n  selectURI,\n} from \"@apollo/client/link/http\";\nimport { filterOperationVariables } from \"@apollo/client/link/utils\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { compact } from \"@apollo/client/utilities/internal\";\nimport { maybe } from \"@apollo/client/utilities/internal/globals\";\n\nexport declare namespace BaseBatchHttpLink {\n  /**\n   * Options passed to `BaseBatchHttpLink` through [request context](https://apollographql.com/docs/react/api/link/introduction#managing-context). Previous\n   * non-terminating links in the link chain also can set these values to\n   * customize the behavior of `BatchHttpLink` for each operation.\n   *\n   * > [!NOTE]\n   * > Some of these values can also be provided to the `BaseBatchHttpLink` constructor.\n   * > If a value is provided to both, the value in `context` takes precedence.\n   */\n  export interface ContextOptions extends BaseHttpLink.ContextOptions {}\n  /**\n   * Configuration options for creating a `BaseBatchHttpLink` instance.\n   *\n   * > [!NOTE]\n   * > Some of these options are also available to override in [request context](https://apollographql.com/docs/react/api/link/introduction#managing-context).\n   * > Context options override the options passed to the constructor. Treat\n   * > these options as default values that are used when the request context\n   * > does not override the value.\n   */\n  interface Options\n    extends BatchLink.Shared.Options,\n      BaseHttpLink.Shared.Options {\n    /** {@inheritDoc @apollo/client/link/batch!BatchLink.Shared.Options#batchMax:member {\"defaultValue\": 10}} */\n    batchMax?: number;\n  }\n}\n\nconst backupFetch = maybe(() => fetch);\n\n/**\n * `BaseBatchHttpLink` is a terminating link that batches array of individual\n * GraphQL operations into a single HTTP request that's sent to a single GraphQL\n * endpoint. It serves as a base link to `BatchHttpLink`.\n *\n * @remarks\n *\n * > [!NOTE]\n * > Prefer using `BatchHttpLink` over `BaseBatchHttpLink`. Use\n * > `BaseBatchHttpLink` when you need to disable client awareness features and\n * > would like to tree-shake the implementation of `ClientAwarenessLink` out\n * > of your app bundle.\n *\n * @example\n *\n * ```ts\n * import { BaseBatchHttpLink } from \"@apollo/client/link/batch-http\";\n *\n * const link = new BaseBatchHttpLink({\n *   uri: \"http://localhost:4000/graphql\",\n *   batchMax: 5, // No more than 5 operations per batch\n *   batchInterval: 20, // Wait no more than 20ms after first batched operation\n * });\n * ```\n */\nexport class BaseBatchHttpLink extends ApolloLink {\n  private batchDebounce?: boolean;\n  private batchInterval: number;\n  private batchMax: number;\n  private batcher: ApolloLink;\n\n  constructor(options: BaseBatchHttpLink.Options = {}) {\n    super();\n\n    let {\n      uri = \"/graphql\",\n      // use default global fetch if nothing is passed in\n      fetch: preferredFetch,\n      print = defaultPrinter,\n      includeExtensions,\n      preserveHeaderCase,\n      batchInterval,\n      batchDebounce,\n      batchMax,\n      batchKey,\n      includeUnusedVariables = false,\n      ...requestOptions\n    } = options;\n\n    if (__DEV__) {\n      // Make sure at least one of preferredFetch, window.fetch, or backupFetch\n      // is defined, so requests won't fail at runtime.\n      checkFetcher(preferredFetch || backupFetch);\n    }\n\n    const linkConfig = {\n      http: compact({ includeExtensions, preserveHeaderCase }),\n      options: requestOptions.fetchOptions,\n      credentials: requestOptions.credentials,\n      headers: requestOptions.headers,\n    };\n\n    this.batchDebounce = batchDebounce;\n    this.batchInterval = batchInterval || 10;\n    this.batchMax = batchMax || 10;\n\n    const batchHandler: BatchLink.BatchHandler = (operations) => {\n      const chosenURI = selectURI(operations[0], uri);\n\n      const context = operations[0].getContext();\n\n      const contextConfig = {\n        http: context.http,\n        options: context.fetchOptions,\n        credentials: context.credentials,\n        headers: context.headers,\n      };\n\n      //uses fallback, link, and then context to build options\n      const optsAndBody = operations.map((operation) => {\n        const result = selectHttpOptionsAndBodyInternal(\n          operation,\n          print,\n          fallbackHttpConfig,\n          linkConfig,\n          contextConfig\n        );\n\n        if (result.body.variables && !includeUnusedVariables) {\n          result.body.variables = filterOperationVariables(\n            result.body.variables,\n            operation.query\n          );\n        }\n\n        return result;\n      });\n\n      const loadedBody = optsAndBody.map(({ body }) => body);\n      const options = optsAndBody[0].options;\n\n      // There's no spec for using GET with batches.\n      if (options.method === \"GET\") {\n        return throwError(\n          () =>\n            new Error(\"apollo-link-batch-http does not support GET requests\")\n        );\n      }\n\n      try {\n        (options as any).body = JSON.stringify(loadedBody);\n      } catch (parseError) {\n        return throwError(() => parseError);\n      }\n\n      let controller: AbortController | undefined;\n      if (!options.signal && typeof AbortController !== \"undefined\") {\n        controller = new AbortController();\n        options.signal = controller.signal;\n      }\n\n      return new Observable((observer) => {\n        // Prefer BatchHttpLink.Options.fetch (preferredFetch) if provided, and\n        // otherwise fall back to the *current* global window.fetch function\n        // (see issue #7832), or (if all else fails) the backupFetch function we\n        // saved when this module was first evaluated. This last option protects\n        // against the removal of window.fetch, which is unlikely but not\n        // impossible.\n        const currentFetch =\n          preferredFetch || maybe(() => fetch) || backupFetch;\n\n        currentFetch!(chosenURI, options)\n          .then((response) => {\n            // Make the raw response available in the context.\n            operations.forEach((operation) =>\n              operation.setContext({ response })\n            );\n            return response;\n          })\n          .then(parseAndCheckHttpResponse(operations))\n          .then((result) => {\n            controller = undefined;\n            // we have data and can send it to back up the link chain\n            observer.next(result);\n            observer.complete();\n            return result;\n          })\n          .catch((err) => {\n            controller = undefined;\n            observer.error(err);\n          });\n\n        return () => {\n          // XXX support canceling this request\n          // https://developers.google.com/web/updates/2017/09/abortable-fetch\n          if (controller) controller.abort();\n        };\n      });\n    };\n\n    batchKey =\n      batchKey ||\n      ((operation: ApolloLink.Operation) => {\n        const context = operation.getContext();\n\n        const contextConfig = {\n          http: context.http,\n          options: context.fetchOptions,\n          credentials: context.credentials,\n          headers: context.headers,\n        };\n\n        //may throw error if config not serializable\n        return selectURI(operation, uri) + JSON.stringify(contextConfig);\n      });\n\n    this.batcher = new BatchLink({\n      batchDebounce: this.batchDebounce,\n      batchInterval: this.batchInterval,\n      batchMax: this.batchMax,\n      batchKey,\n      batchHandler,\n    });\n  }\n\n  public request(\n    operation: ApolloLink.Operation,\n    forward: ApolloLink.ForwardFunction\n  ): Observable<ApolloLink.Result> {\n    return this.batcher.request(operation, forward);\n  }\n}\n"]}