@apollo/client 4.3.3 → 4.3.5

package/core/ApolloClient.js

@@ -71,8 +71,8 @@ export class ApolloClient {
      */
     constructor(options) {
         if (__DEV__) {
-            invariant(options.cache, 70);
-            invariant(options.link, 71);
+            invariant(options.cache, 71);
+            invariant(options.link, 72);
         }
         const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new NotImplementedHandler(), experiments = [], refetchEventManager, } = options;
         this.link = link;
@@ -260,12 +260,12 @@ export class ApolloClient {
             if (refetchOn) {
                 const operationName = getOperationName(query, "(anonymous)");
                 if (!refetchEventManager) {
-                    __DEV__ && invariant.warn(72, operationName);
+                    __DEV__ && invariant.warn(73, operationName);
                 }
                 else if (typeof refetchOn === "object") {
                     Object.keys(refetchOn).forEach((source) => {
                         if (!refetchEventManager.hasSource(source)) {
-                            __DEV__ && invariant.warn(73, source, operationName);
+                            __DEV__ && invariant.warn(74, source, operationName);
                         }
                     });
                 }
@@ -287,13 +287,13 @@ export class ApolloClient {
             options = mergeOptions(this.defaultOptions.query, options);
         }
         if (__DEV__) {
-            invariant(options.fetchPolicy !== "cache-and-network", 74);
-            invariant(options.fetchPolicy !== "standby", 75);
-            invariant(options.query, 76);
-            invariant(options.query.kind === "Document", 77);
-            invariant(!options.returnPartialData, 78);
-            invariant(!options.pollInterval, 79);
-            invariant(!options.notifyOnNetworkStatusChange, 80);
+            invariant(options.fetchPolicy !== "cache-and-network", 75);
+            invariant(options.fetchPolicy !== "standby", 76);
+            invariant(options.query, 77);
+            invariant(options.query.kind === "Document", 78);
+            invariant(!options.returnPartialData, 79);
+            invariant(!options.pollInterval, 80);
+            invariant(!options.notifyOnNetworkStatusChange, 81);
         }
         return this.queryManager.query(options);
     };
@@ -311,9 +311,9 @@ export class ApolloClient {
             errorPolicy: "none",
         }, this.defaultOptions.mutate), options);
         if (__DEV__) {
-            invariant(optionsWithDefaults.mutation, 81);
+            invariant(optionsWithDefaults.mutation, 82);
             invariant(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 82);
+                optionsWithDefaults.fetchPolicy === "no-cache", 83);
         }
         checkDocument(optionsWithDefaults.mutation, OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
@@ -519,7 +519,7 @@ export 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.debug(83, error);
+            __DEV__ && invariant.debug(84, error);
         });
         return result;
     }

package/core/ObservableQuery.js

@@ -102,7 +102,7 @@ export class ObservableQuery {
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
         if (options[variablesUnknownSymbol]) {
-            invariant(fetchPolicy === "standby", 84);
+            invariant(fetchPolicy === "standby", 85);
             this.variablesUnknown = true;
         }
         this.lastQuery = transformedQuery;
@@ -411,7 +411,7 @@ export class ObservableQuery {
             const queryDef = getQueryDefinition(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant.warn(85, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant.warn(86, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !equal(this.variables, variables)) {
@@ -426,7 +426,7 @@ export class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         invariant(
             this.options.fetchPolicy !== "cache-only",
-            86,
+            87,
             getOperationName(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -460,7 +460,7 @@ export class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 87);
+            invariant(updateQuery, 88);
         }
         const { finalize, pushNotification } = this.pushOperation(NetworkStatus.fetchMore);
         pushNotification({
@@ -634,7 +634,7 @@ export class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant.error(88, error);
+                        invariant.error(89, error);
                     }
                     return;
                 }
@@ -885,7 +885,7 @@ export class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant.warn(89, getOperationName(this.query, "(anonymous)"));
+                    __DEV__ && invariant.warn(90, getOperationName(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -1511,7 +1511,7 @@ export class ObservableQuery {
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(90, missing);
+        __DEV__ && invariant.debug(91, missing);
     }
 }
 function isEqualQuery(a, b) {
@@ -1555,6 +1555,6 @@ function getTrackingOperatorPromise(defaultValue) {
     return { promise, operator };
 }
 function warnOnFeud(query, diff) {
-    __DEV__ && invariant.warn(91, getOperationName(query, "(anonymous)"), diff.missing?.missing);
+    __DEV__ && invariant.warn(92, getOperationName(query, "(anonymous)"), diff.missing?.missing);
 }
 //# sourceMappingURL=ObservableQuery.js.map

package/core/QueryInfo.d.ts

@@ -59,7 +59,7 @@ export declare class QueryInfo<TData, TVariables extends OperationVariables = Op
         update?: MutationUpdaterFunction<TData, TVariables, TCache>;
         keepRootFields?: boolean;
     }): boolean;
-    markSubscriptionResult(result: FormattedExecutionResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): void;
+    markSubscriptionResult(result: FormattedExecutionResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): TData | null | undefined;
 }
 export {};
 //# sourceMappingURL=QueryInfo.d.ts.map

package/core/QueryInfo.js

@@ -1,6 +1,5 @@
-import { Trie } from "@wry/trie";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { getOperationName, graphQLResultHasError, handleIncrementalSymbol, hasDirectives, toDiffWithDataState, } from "@apollo/client/utilities/internal";
+import { coerceScalarFieldsToParsed, getOperationName, graphQLResultHasError, handleIncrementalSymbol, toDiffWithDataState, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { NetworkStatus } from "./networkStatus.js";
 const IGNORE = {};
@@ -67,26 +66,7 @@ export 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 &&
-                hasDirectives(["defer"], query))) {
+        if (this.incremental?.isDeferPending()) {
             result.dataState = "streaming";
         }
         if (skipCache || !shouldWriteResult(result, errorPolicy)) {
@@ -113,6 +93,9 @@ export class QueryInfo {
                     variables,
                     overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
                     extensions: result.extensions,
+                    [handleIncrementalSymbol]: {
+                        isDeferPending: this.incremental?.isDeferPending,
+                    },
                 });
                 const { dataState, result: diffResult } = this.getDiff({
                     ...diffOptions,
@@ -141,23 +124,18 @@ export 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(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;
     }
@@ -197,6 +175,9 @@ export class QueryInfo {
                 query: mutation.document,
                 variables: mutation.variables,
                 extensions: result.extensions,
+                [handleIncrementalSymbol]: {
+                    isDeferPending: this.incremental?.isDeferPending,
+                },
             });
             const { updateQueries } = mutation;
             if (updateQueries) {
@@ -354,16 +335,24 @@ export 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 coerceScalarFieldsToParsed(result.data, document, this.cache);
+        }
+        return result.data;
     }
 }
 function warnAboutPartialCacheResult(query, networkResult, diff) {
     __DEV__ && invariant.warn(
-        92,
+        93,
         getOperationName(query, "(anonymous)"),
         diff.missing?.missing,
         networkResult,