@apollo/client 4.3.0-alpha.4 → 4.3.0-alpha.6

package/cache/inmemory/readFromStore.d.ts

@@ -22,7 +22,7 @@ export declare class StoreReader {
      * identify if any data was missing from the store.
      */
     diffQueryAgainstStore<T>(options: DiffQueryAgainstStoreOptions & {
-        [handleIncrementalSymbol]: true | DiffIncrementalInfo;
+        [handleIncrementalSymbol]: DiffIncrementalInfo | undefined;
     }): Cache.InternalDiffResultWithDataState<T>;
     diffQueryAgainstStore<T>(options: DiffQueryAgainstStoreOptions): Cache.DiffResult<T>;
     isFresh(result: Record<string, any>, parent: StoreObject | Reference, selectionSet: SelectionSetNode, context: ReadMergeModifyContext): boolean;

package/cache/inmemory/readFromStore.js

@@ -4,7 +4,7 @@ import { Kind } from "graphql";
 import { wrap } from "optimism";
 import { addTypenameToDocument, cacheSizes, canonicalStringify, isReference, } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { DeepMerger, getDefaultValues, getFragmentFromSelection, getMainDefinition, getQueryDefinition, handleIncrementalSymbol, isArray, isDeferredFragment, isField, isNonNullObject, isStreamField, makeReference, maybeDeepFreeze, mergeDeepArray, resultKeyNameFromField, shouldInclude, } from "@apollo/client/utilities/internal";
+import { compact, DeepMerger, getDefaultValues, getDirectiveArgValue, getFragmentFromSelection, getMainDefinition, getQueryDefinition, handleIncrementalSymbol, isArray, isDeferredFragment, isField, isNonNullObject, isStreamField, makeReference, maybeDeepFreeze, mergeDeepArray, resultKeyNameFromField, shouldInclude, } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { MissingFieldError } from "../core/types/common.js";
 import { maybeDependOnExistenceOfEntity, supportsResultCaching, } from "./entityStore.js";
@@ -89,12 +89,10 @@ export class StoreReader {
             },
         });
     }
-    diffQueryAgainstStore({ store, query, rootId = "ROOT_QUERY", variables, returnPartialData = true, [handleIncrementalSymbol]: handleIncremental, }) {
+    diffQueryAgainstStore({ store, query, rootId = "ROOT_QUERY", variables, returnPartialData = true, ...options }) {
+        const returnIncremental = Object.hasOwn(options, handleIncrementalSymbol);
         const policies = this.config.cache.policies;
-        variables = {
-            ...getDefaultValues(getQueryDefinition(query)),
-            ...variables,
-        };
+        variables = compact(getDefaultValues(getQueryDefinition(query)), variables);
         const rootRef = makeReference(rootId);
         const context = {
             store,
@@ -103,7 +101,7 @@ export class StoreReader {
             variables,
             varString: canonicalStringify(variables),
             ...extractFragmentContext(query, this.config.fragments),
-            ...(typeof handleIncremental === "object" ? handleIncremental : (undefined)),
+            ...options[handleIncrementalSymbol],
         };
         let execResult = this.executeSelectionSet({
             selectionSet: getMainDefinition(query).selectionSet,
@@ -116,17 +114,7 @@ export class StoreReader {
         // partial defer boundaries. The "deferPartial" data state tells us that the
         // only part of the result that contributed to its partiality is data inside
         // a defer boundary.
-        if (handleIncremental &&
-            (execResult.dataState === "deferPartial" ||
-                execResult.dataState === "streamPartial" ||
-                // If the last cache write repaired a partial @stream array to a
-                // complete array, the stream array might contain stale entries after
-                // the last written value. We only want to deliver the results up to
-                // the index the network wrote so we need to prune it too.
-                context.streamInfo ||
-                // The network hasn't delivered these @defer boundaries yet, so prune
-                // the (possibly complete) cached data sitting at them.
-                context.deferInfo)) {
+        if (returnIncremental && shouldPrune(execResult, context)) {
             const pruned = this.prunePartialBoundaries({
                 selectionSet: getMainDefinition(query).selectionSet,
                 data: execResult.result,
@@ -134,7 +122,7 @@ export class StoreReader {
                 context,
                 path: [],
             });
-            const changed = execResult.result !== pruned;
+            const changed = execResult.result !== pruned.result;
             // It's possible that pruning didn't actually change the result which can
             // happen if a defer boundary is misclassified as "deferPartial" instead
             // of "streaming" (sibling defer boundaries with overlapping selection
@@ -144,19 +132,12 @@ export class StoreReader {
             // we want to keep the original execResult which contains the partial
             // data.
             if (!changed || !returnPartialData) {
-                const { dataState } = execResult;
                 // Omit `missing` property since pruning puts it in a state that doesn't
                 // report missing fields.
                 execResult = {
-                    result: pruned,
+                    result: pruned.result,
                     partialBoundaries: execResult.partialBoundaries,
-                    dataState: dataState === "deferPartial" ? "streaming"
-                        : dataState === "streamPartial" ? "complete"
-                            // A cached @defer boundary the network hasn't delivered was
-                            // pruned from an otherwise complete result, so we're still
-                            // streaming.
-                            : context.deferInfo && changed ? "streaming"
-                                : dataState,
+                    dataState: pruned.dataState,
                 };
             }
         }
@@ -167,7 +148,7 @@ export class StoreReader {
             // We don't need to report missing fields inside defer boundaries since
             // the "streaming" dataState tells us that the only missing fields in
             // the object is inside a defer boundary.
-            (dataState !== "streaming" || !handleIncremental);
+            (dataState !== "streaming" || !returnIncremental);
         // If we get all root @defer boundaries with an empty result, report it as
         // empty instead of streaming.
         if (dataState === "streaming" && Object.keys(result).length === 0) {
@@ -176,7 +157,7 @@ export class StoreReader {
         let missingError;
         if (dataState === "deferPartial" ||
             dataState === "streamPartial" ||
-            (dataState === "streaming" && !handleIncremental)) {
+            (dataState === "streaming" && !returnIncremental)) {
             dataState = "partial";
         }
         if (dataState === "partial" && !returnPartialData) {
@@ -196,7 +177,7 @@ export class StoreReader {
                 return missingError;
             },
         };
-        if (handleIncremental) {
+        if (returnIncremental) {
             diffResult.dataState =
                 dataState;
         }
@@ -301,7 +282,7 @@ export class StoreReader {
                         if (typename) {
                             const policy = policies["getFieldPolicy"](typename, fieldName);
                             if (policy?.scalar) {
-                                __DEV__ && invariant.warn(112, `${typename}.${fieldName}`, policy.scalar);
+                                __DEV__ && invariant.warn(114, `${typename}.${fieldName}`, policy.scalar);
                             }
                         }
                     }
@@ -338,7 +319,7 @@ export class StoreReader {
             else {
                 const fragment = getFragmentFromSelection(selection, context.lookupFragment);
                 if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {
-                    throw newInvariantError(113, selection.name.value);
+                    throw newInvariantError(115, selection.name.value);
                 }
                 if (fragment && policies.fragmentMatches(fragment, typename)) {
                     const isDeferBoundary = isDeferredFragment(selection, context.variables);
@@ -372,7 +353,8 @@ export class StoreReader {
                     if (execResult.missing) {
                         missing = missingMerger.merge(missing, execResult.missing);
                     }
-                    if (isDeferBoundary && nextDataState === "partial") {
+                    if (isDeferBoundary &&
+                        (nextDataState === "partial" || nextDataState === "empty")) {
                         partialBoundaries.add(selection);
                     }
                     dataState = mergeDataState(dataState, isDeferBoundary ?
@@ -465,10 +447,12 @@ export class StoreReader {
     }
     prunePartialBoundariesImpl({ boundaries, context, data, path, selectionSet, }) {
         const { variables, lookupFragment, policies } = context;
-        if (data == null || !boundaries)
-            return data;
+        if (data == null || !boundaries) {
+            return { result: data, dataState: "complete" };
+        }
         const merger = new DeepMerger();
         let changed = false;
+        let dataState = "complete";
         const result = {};
         // __typename might not be part of the selection set, so preserve it when
         // available, otherwise it gets removed since it's never visited when
@@ -494,8 +478,9 @@ export class StoreReader {
                         context,
                         path: path.concat(resultName),
                     });
-                    changed ||= pruned !== fieldValue;
-                    result[resultName] = pruned;
+                    changed ||= pruned.result !== fieldValue;
+                    result[resultName] = pruned.result;
+                    dataState = mergeDataState(dataState, pruned.dataState);
                 }
                 else if (!selection.selectionSet) {
                     result[resultName] = fieldValue;
@@ -508,13 +493,14 @@ export class StoreReader {
                         context,
                         path: path.concat(resultName),
                     });
-                    changed ||= pruned !== fieldValue;
+                    changed ||= pruned.result !== fieldValue;
+                    dataState = mergeDataState(dataState, pruned.dataState);
                     // A response key can be selected by more than one selection (e.g. a
                     // field and an overlapping fragment), so merge their kept fields.
                     result[resultName] =
                         Object.hasOwn(result, resultName) ?
-                            merger.merge(result[resultName], pruned)
-                            : pruned;
+                            merger.merge(result[resultName], pruned.result)
+                            : pruned.result;
                 }
                 return;
             }
@@ -526,11 +512,19 @@ export class StoreReader {
             // Object.keys(result).length check actually detects whether keys were
             // dropped or not.
             const fragment = getFragmentFromSelection(selection, lookupFragment);
-            if (fragment &&
-                policies.fragmentMatches(fragment, data.__typename) &&
-                !boundaries.has(selection) &&
-                !context.deferInfo?.peekArray(path)) {
-                fragment.selectionSet.selections.forEach(workSet.add, workSet);
+            let prune = false;
+            if (context.deferInfo && isDeferredFragment(selection, variables)) {
+                const directive = selection.directives?.find((d) => d.name.value === "defer");
+                const label = directive && getDirectiveArgValue(directive, "label", Kind.STRING);
+                prune = !!context.deferInfo.peekArray(path.concat(label || []));
+            }
+            if (fragment && policies.fragmentMatches(fragment, data.__typename)) {
+                if (boundaries.has(selection) || prune) {
+                    dataState = mergeDataState(dataState, "streaming");
+                }
+                else {
+                    fragment.selectionSet.selections.forEach(workSet.add, workSet);
+                }
             }
         });
         if (Object.keys(result).length !== Object.keys(data).length) {
@@ -543,18 +537,22 @@ export class StoreReader {
             // actually dropped by the partial @defer fragment.
             changed = !equal(result, data);
         }
-        return changed ? result : data;
+        return { result: changed ? result : data, dataState };
     }
     prunePartialStreamArrayImpl({ field, array, boundaries, context, path, }) {
         if (!boundaries)
-            return array;
+            return { result: array, dataState: "complete" };
         let changed = false;
+        let dataState = "complete";
         let pruned = [];
         const state = context.streamInfo?.peekArray(path)?.state;
         const length = Math.min(array.length, state?.truncate ? state.streamPosition : Number.MAX_SAFE_INTEGER);
         for (let i = 0; i < length; i++) {
             const item = array[i];
-            let prunedItem = item;
+            let prunedResult = {
+                result: item,
+                dataState: "complete",
+            };
             const boundary = boundaries.getChild(i);
             if (boundary?.has(field)) {
                 // The presence of streamInfo determines how we truncate partial
@@ -569,11 +567,12 @@ export class StoreReader {
                 }
                 else {
                     pruned = [];
+                    dataState = "complete";
                 }
                 break;
             }
             if (Array.isArray(item)) {
-                prunedItem = this.prunePartialStreamArray({
+                prunedResult = this.prunePartialStreamArray({
                     field,
                     array: item,
                     boundaries: boundaries.getChild(i),
@@ -582,7 +581,7 @@ export class StoreReader {
                 });
             }
             else if (field.selectionSet) {
-                prunedItem = this.prunePartialBoundaries({
+                prunedResult = this.prunePartialBoundaries({
                     data: item,
                     selectionSet: field.selectionSet,
                     boundaries: boundaries.getChild(i),
@@ -590,11 +589,12 @@ export class StoreReader {
                     path: path.concat(i),
                 });
             }
-            pruned.push(prunedItem);
-            changed ||= prunedItem !== item;
+            pruned.push(prunedResult.result);
+            changed ||= prunedResult.result !== item;
+            dataState = mergeDataState(dataState, prunedResult.dataState);
         }
         changed ||= pruned.length !== array.length;
-        return changed ? pruned : array;
+        return { result: changed ? pruned : array, dataState };
     }
 }
 function firstMissing(tree) {
@@ -616,7 +616,7 @@ function assertSelectionSetForIdValue(store, field, fieldValue) {
             if (isNonNullObject(value)) {
                 invariant(
                     !isReference(value),
-                    114,
+                    116,
                     getTypenameFromStoreObject(store, value),
                     field.name.value
                 );
@@ -667,6 +667,23 @@ class PartialBoundaries {
         return this;
     }
 }
+function shouldPrune({ dataState }, context) {
+    if (dataState === "deferPartial" || dataState === "streamPartial") {
+        return true;
+    }
+    if (dataState === "complete" || dataState === "streaming") {
+        return !!(
+        // If the last cache write repaired a partial @stream array to a
+        // complete array, the stream array might contain stale entries after
+        // the last written value. We only want to deliver the results up to
+        // the index the network wrote so we need to prune it too.
+        (context.streamInfo ||
+            // The network hasn't delivered these @defer boundaries yet, so prune
+            // the (possibly complete) cached data sitting at them.
+            context.deferInfo));
+    }
+    return false;
+}
 // Describes the data state transitions that change the running state when it's
 // combined with the next data state. Omitted object values represent
 // "impossible" merges where the data state should remain the same.