@apollo/client 4.3.3 → 4.3.5

package/__cjs/cache/inmemory/writeToStore.d.cts

@@ -2,9 +2,10 @@ import type { FieldNode, SelectionSetNode } from "graphql";
 import type { Cache, OperationVariables } from "@apollo/client";
 import type { Reference, StoreObject } from "@apollo/client/utilities";
 import type { FragmentMap, FragmentMapFunction } from "@apollo/client/utilities/internal";
+import { handleIncrementalSymbol } from "@apollo/client/utilities/internal";
 import type { InMemoryCache } from "./inMemoryCache.cjs";
 import type { StoreReader } from "./readFromStore.cjs";
-import type { InMemoryCacheConfig, MergeTree, NormalizedCache, ReadMergeModifyContext } from "./types.cjs";
+import type { DiffIncrementalInfo, InMemoryCacheConfig, MergeTree, NormalizedCache, ReadMergeModifyContext } from "./types.cjs";
 export interface WriteContext extends ReadMergeModifyContext {
     readonly written: {
         [dataId: string]: SelectionSetNode[];
@@ -28,7 +29,9 @@ export declare class StoreWriter {
     private reader?;
     private fragments?;
     constructor(cache: InMemoryCache, reader?: StoreReader | undefined, fragments?: InMemoryCacheConfig["fragments"]);
-    writeToStore<TData = unknown, TVariables extends OperationVariables = OperationVariables>(store: NormalizedCache, { query, result, dataId, variables, overwrite, extensions, }: Cache.WriteOptions<TData, TVariables>): Reference | undefined;
+    writeToStore<TData = unknown, TVariables extends OperationVariables = OperationVariables>(store: NormalizedCache, { query, result, dataId, variables, overwrite, extensions, [handleIncrementalSymbol]: incrementalInfo, }: Cache.WriteOptions<TData, TVariables> & {
+        [handleIncrementalSymbol]?: DiffIncrementalInfo;
+    }): Reference | undefined;
     private processSelectionSet;
     private processFieldValue;
     private flattenFields;

package/__cjs/core/ApolloClient.cjs

@@ -78,8 +78,8 @@ class ApolloClient {
      */
     constructor(options) {
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.cache, 70);
-            (0, invariant_1.invariant)(options.link, 71);
+            (0, invariant_1.invariant)(options.cache, 71);
+            (0, invariant_1.invariant)(options.link, 72);
         }
         const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new incremental_1.NotImplementedHandler(), experiments = [], refetchEventManager, } = options;
         this.link = link;
@@ -267,12 +267,12 @@ class ApolloClient {
             if (refetchOn) {
                 const operationName = (0, internal_1.getOperationName)(query, "(anonymous)");
                 if (!refetchEventManager) {
-                    __DEV__ && invariant_1.invariant.warn(72, operationName);
+                    __DEV__ && invariant_1.invariant.warn(73, operationName);
                 }
                 else if (typeof refetchOn === "object") {
                     Object.keys(refetchOn).forEach((source) => {
                         if (!refetchEventManager.hasSource(source)) {
-                            __DEV__ && invariant_1.invariant.warn(73, source, operationName);
+                            __DEV__ && invariant_1.invariant.warn(74, source, operationName);
                         }
                     });
                 }
@@ -294,13 +294,13 @@ class ApolloClient {
             options = (0, internal_1.mergeOptions)(this.defaultOptions.query, options);
         }
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 74);
-            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 75);
-            (0, invariant_1.invariant)(options.query, 76);
-            (0, invariant_1.invariant)(options.query.kind === "Document", 77);
-            (0, invariant_1.invariant)(!options.returnPartialData, 78);
-            (0, invariant_1.invariant)(!options.pollInterval, 79);
-            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 80);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "cache-and-network", 75);
+            (0, invariant_1.invariant)(options.fetchPolicy !== "standby", 76);
+            (0, invariant_1.invariant)(options.query, 77);
+            (0, invariant_1.invariant)(options.query.kind === "Document", 78);
+            (0, invariant_1.invariant)(!options.returnPartialData, 79);
+            (0, invariant_1.invariant)(!options.pollInterval, 80);
+            (0, invariant_1.invariant)(!options.notifyOnNetworkStatusChange, 81);
         }
         return this.queryManager.query(options);
     };
@@ -318,9 +318,9 @@ class ApolloClient {
             errorPolicy: "none",
         }, this.defaultOptions.mutate), options);
         if (environment_1.__DEV__) {
-            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 81);
+            (0, invariant_1.invariant)(optionsWithDefaults.mutation, 82);
             (0, invariant_1.invariant)(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 82);
+                optionsWithDefaults.fetchPolicy === "no-cache", 83);
         }
         (0, internal_1.checkDocument)(optionsWithDefaults.mutation, graphql_1.OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
@@ -526,7 +526,7 @@ class ApolloClient {
         // result.queries and result.results instead, you shouldn't have to worry
         // about preventing uncaught rejections for the Promise.all result.
         result.catch((error) => {
-            __DEV__ && invariant_1.invariant.debug(83, error);
+            __DEV__ && invariant_1.invariant.debug(84, error);
         });
         return result;
     }

package/__cjs/core/ObservableQuery.cjs

@@ -110,7 +110,7 @@ class ObservableQuery {
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
         if (options[internal_1.variablesUnknownSymbol]) {
-            (0, invariant_1.invariant)(fetchPolicy === "standby", 84);
+            (0, invariant_1.invariant)(fetchPolicy === "standby", 85);
             this.variablesUnknown = true;
         }
         this.lastQuery = transformedQuery;
@@ -419,7 +419,7 @@ class ObservableQuery {
             const queryDef = (0, internal_1.getQueryDefinition)(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant_1.invariant.warn(85, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant_1.invariant.warn(86, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !(0, equality_1.equal)(this.variables, variables)) {
@@ -434,7 +434,7 @@ class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         (0, invariant_1.invariant)(
             this.options.fetchPolicy !== "cache-only",
-            86,
+            87,
             (0, internal_1.getOperationName)(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -468,7 +468,7 @@ class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 87);
+            (0, invariant_1.invariant)(updateQuery, 88);
         }
         const { finalize, pushNotification } = this.pushOperation(networkStatus_js_1.NetworkStatus.fetchMore);
         pushNotification({
@@ -642,7 +642,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant_1.invariant.error(88, error);
+                        invariant_1.invariant.error(89, error);
                     }
                     return;
                 }
@@ -893,7 +893,7 @@ class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant_1.invariant.warn(89, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
+                    __DEV__ && invariant_1.invariant.warn(90, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -1520,7 +1520,7 @@ class ObservableQuery {
 exports.ObservableQuery = ObservableQuery;
 function logMissingFieldErrors(missing) {
     if (environment_1.__DEV__ && missing) {
-        __DEV__ && invariant_1.invariant.debug(90, missing);
+        __DEV__ && invariant_1.invariant.debug(91, missing);
     }
 }
 function isEqualQuery(a, b) {
@@ -1565,7 +1565,7 @@ function getTrackingOperatorPromise(defaultValue) {
 }
 function warnOnFeud(query, diff) {
     __DEV__ && invariant_1.invariant.warn(
-        91,
+        92,
         (0, internal_1.getOperationName)(query, "(anonymous)"),
         diff.missing?.missing
     );

package/__cjs/core/QueryInfo.cjs

@@ -5,7 +5,6 @@ const {
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInfo = void 0;
-const trie_1 = require("@wry/trie");
 const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
@@ -74,26 +73,7 @@ class QueryInfo {
             ...incrementalResult,
             dataState: incrementalResult.data == null ? "empty" : "complete",
         };
-        const hasPendingDefer = this.incremental
-            ?.getPendingWithInfo?.()
-            .some((pending) => pending.type === "defer" && !pending.delivered);
-        if (hasPendingDefer ||
-            // The Defer20220824Handler cannot track pending/completed incremental
-            // chunks due to its data format so we naively set dataState to
-            // streaming if we are still processing chunks. The only case where
-            // streaming is incorrect and should actually be complete is when
-            // both a @defer and @stream boundary is present and the @defer chunk
-            // has completed before the `@stream` array.
-            //
-            // Assigning the naive "streaming" value avoids a much more expensive
-            // pass over `result.data` that would otherwise need to traverse the
-            // selection sets and evaluate the data object at each defer boundary
-            // to see if it fulfills the selection set. For such a narrow case where
-            // its incorrect on a format that is now outdated is not worth the
-            // fix so we are ok with reporting a `streaming` here.
-            (!this.incremental?.getPendingWithInfo &&
-                this.hasNext &&
-                (0, internal_1.hasDirectives)(["defer"], query))) {
+        if (this.incremental?.isDeferPending()) {
             result.dataState = "streaming";
         }
         if (skipCache || !shouldWriteResult(result, errorPolicy)) {
@@ -120,6 +100,9 @@ class QueryInfo {
                     variables,
                     overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
                     extensions: result.extensions,
+                    [internal_1.handleIncrementalSymbol]: {
+                        isDeferPending: this.incremental?.isDeferPending,
+                    },
                 });
                 const { dataState, result: diffResult } = this.getDiff({
                     ...diffOptions,
@@ -148,23 +131,18 @@ class QueryInfo {
         return result;
     }
     getIncrementalInfo({ prune }) {
-        const pending = this.incremental?.getPendingWithInfo?.() ?? [];
         const streamInfo = this.incremental?.streamInfo;
         const incrementalInfo = { streamInfo };
         // We don't want to deliver stream items or complete defer boundaries
         // for a network-only request if they haven't yet streamed from the
         // network. We record all the still-pending paths so that cache.diff
         // can prune complete defer/stream boundaries at those paths.
-        if (prune) {
-            for (const item of pending) {
-                if (item.type === "defer" && !item.delivered) {
-                    incrementalInfo.deferInfo ||= new trie_1.Trie(true, () => true);
-                    incrementalInfo.deferInfo.lookupArray(item.path.concat(item.label || []));
-                }
-                else if (streamInfo && item.type === "stream") {
-                    streamInfo.lookupArray(item.path).state.truncate = true;
-                }
+        if (prune && this.incremental?.tracksPending) {
+            const isDeferPending = this.incremental.isDeferPending;
+            if (isDeferPending()) {
+                incrementalInfo.isDeferPending ||= (path, label) => isDeferPending(path, label);
             }
+            this.incremental.markStreamedPendingForTruncation?.();
         }
         return incrementalInfo;
     }
@@ -204,6 +182,9 @@ class QueryInfo {
                 query: mutation.document,
                 variables: mutation.variables,
                 extensions: result.extensions,
+                [internal_1.handleIncrementalSymbol]: {
+                    isDeferPending: this.incremental?.isDeferPending,
+                },
             });
             const { updateQueries } = mutation;
             if (updateQueries) {
@@ -361,17 +342,25 @@ class QueryInfo {
                     returnPartialData: true,
                 });
                 if (diff.complete) {
-                    result.data = diff.result;
+                    return diff.result;
                 }
             }
             this.queryManager.broadcastQueries();
         }
+        else if (result.data != null &&
+            this.cache.configuresScalars() &&
+            shouldWriteResult(result, errorPolicy)) {
+            // The result is not written to the cache, so parse scalar values
+            // directly from the network result.
+            return (0, internal_1.coerceScalarFieldsToParsed)(result.data, document, this.cache);
+        }
+        return result.data;
     }
 }
 exports.QueryInfo = QueryInfo;
 function warnAboutPartialCacheResult(query, networkResult, diff) {
     __DEV__ && invariant_1.invariant.warn(
-        92,
+        93,
         (0, internal_1.getOperationName)(query, "(anonymous)"),
         diff.missing?.missing,
         networkResult,