@apollo/client 4.3.0-alpha.1 → 4.3.0-alpha.3

package/core/QueryInfo.d.ts

@@ -24,9 +24,12 @@ interface OperationInfo<TData, TVariables extends OperationVariables, AllowedCac
     variables: TVariables;
     errorPolicy: ErrorPolicy;
     cacheWriteBehavior: AllowedCacheWriteBehavior;
+    returnPartialData?: boolean | undefined;
+}
+interface MarkQueryResult<TData, TExtensions> extends FormattedExecutionResult<TData, TExtensions> {
+    dataState: "empty" | "partial" | "streaming" | "complete";
 }
 export declare class QueryInfo<TData, TVariables extends OperationVariables = OperationVariables, TCache extends Cache.Implementation = Cache.Implementation> {
-    lastRequestId: number;
     private cache;
     private queryManager;
     readonly id: string;
@@ -47,7 +50,7 @@ export declare class QueryInfo<TData, TVariables extends OperationVariables = Op
     private shouldWrite;
     get hasNext(): boolean;
     private maybeHandleIncrementalResult;
-    markQueryResult(incoming: ApolloLink.Result<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables>): FormattedExecutionResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>;
+    markQueryResult(incoming: ApolloLink.Result<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, }: OperationInfo<TData, TVariables>): MarkQueryResult<DataValue.Complete<TData> | DataValue.Streaming<TData>, ExtensionsWithStreamInfo>;
     markMutationResult(incoming: ApolloLink.Result<TData>, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
         context?: DefaultContext;
         updateQueries: UpdateQueries<TData>;

package/core/QueryInfo.js

@@ -1,5 +1,5 @@
 import { equal } from "@wry/equality";
-import { getOperationName, graphQLResultHasError, streamInfoSymbol, } from "@apollo/client/utilities/internal";
+import { collectSiblingFields, createFragmentMap, getFragmentDefinitions, getFragmentFromSelection, getMainDefinition, getOperationName, graphQLResultHasError, hasDirectives, isDeferredFragment, isField, isTypenameField, resultKeyNameFromField, streamInfoSymbol, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
@@ -26,8 +26,6 @@ const queryInfoIds = new WeakMap();
 // It is responsible for reporting results to the cache, merging and in a no-cache
 // scenario accumulating the response.
 export class QueryInfo {
-    // TODO remove soon - this should be able to be handled by cancelling old operations before starting new ones
-    lastRequestId = 1;
     cache;
     queryManager;
     id;
@@ -97,7 +95,7 @@ export class QueryInfo {
         }
         return incoming;
     }
-    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, }) {
         const diffOptions = {
             query,
             variables,
@@ -109,9 +107,26 @@ export class QueryInfo {
         this.observableQuery?.["resetNotifications"]();
         const skipCache = cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
         const lastDiff = skipCache ? undefined : this.cache.diff(diffOptions);
-        let result = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
+        const incrementalResult = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
+        let result = {
+            ...incrementalResult,
+            dataState: incrementalResult.data == null ? "empty"
+                : this.hasNext ? "streaming"
+                    : "complete",
+        };
         if (skipCache) {
-            return result;
+            return {
+                ...result,
+                dataState: result.data == null ? "empty"
+                    // Ww can simplify the checks for no-cache queries because the
+                    // result is purely server driven which means we can assume a
+                    // well-formed GraphQL response. In this case, `streaming` only
+                    // makes sense if we are using the `@defer` directive and there are
+                    // more chunks still streaming (i.e. this.hasNext is true). Purely
+                    // `@stream` queries should always be complete.
+                    : this.hasNext && hasDirectives(["defer"], query) ? "streaming"
+                        : "complete",
+            };
         }
         if (shouldWriteResult(result, errorPolicy)) {
             // Using a transaction here so we have a chance to read the result
@@ -179,7 +194,11 @@ export class QueryInfo {
                         if (lastDiff && lastDiff.complete) {
                             // Reuse data from the last good (complete) diff that we
                             // received, when possible.
-                            result = { ...result, data: lastDiff.result };
+                            result = {
+                                ...result,
+                                data: lastDiff.result,
+                                dataState: "complete",
+                            };
                             return;
                         }
                         // If the previous this.diff was incomplete, fall through to
@@ -192,7 +211,27 @@ export class QueryInfo {
                     // Set without setDiff to avoid triggering a notify call, since
                     // we have other ways of notifying for this result.
                     if (diff.complete) {
-                        result = { ...result, data: diff.result };
+                        result = {
+                            ...result,
+                            data: diff.result,
+                            dataState: "complete",
+                        };
+                    }
+                    else if (this.hasNext && diff.result !== null) {
+                        const isPartial = isStreamingPartial(diff, query, variables);
+                        // If we tolerate partial results always apply `diff.result` to
+                        // ensure we return the result of any transforms in cache read
+                        // functions or custom scalars. If we don't tolerate partial
+                        // results, we only want to apply the diff result if the only hole
+                        // in the data is at a defer boundary (e.g.
+                        // `diff.complete === false && isStreamingPartial === false`)
+                        if (returnPartialData || !isPartial) {
+                            result = {
+                                ...result,
+                                data: diff.result,
+                                dataState: isPartial ? "partial" : "streaming",
+                            };
+                        }
                     }
                 },
             });
@@ -289,38 +328,34 @@ export class QueryInfo {
                     const { update } = mutation;
                     // Determine whether result is a SingleExecutionResult,
                     // or the final ExecutionPatchResult.
-                    if (update) {
-                        if (!skipCache) {
-                            // Re-read the ROOT_MUTATION data we just wrote into the cache
-                            // (the first cache.write call in the cacheWrites.forEach loop
-                            // above), so field read functions have a chance to run for
-                            // fields within mutation result objects.
-                            const diff = cache.diff({
-                                id: "ROOT_MUTATION",
-                                // The cache complains if passed a mutation where it expects a
-                                // query, so we transform mutations and subscriptions to queries
-                                // (only once, thanks to this.transformCache).
-                                query: this.queryManager.getDocumentInfo(mutation.document)
-                                    .asQuery,
-                                variables: mutation.variables,
-                                optimistic: false,
-                                returnPartialData: true,
-                            });
-                            if (diff.complete) {
-                                result = {
-                                    ...result,
-                                    data: diff.result,
-                                };
-                            }
-                        }
-                        // If we've received the whole response, call the update function.
-                        if (!this.hasNext) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
+                    // Re-read from the cache after writing to it to update `result`
+                    // with any parsed scalar values that might have been written.
+                    if (!skipCache) {
+                        const diff = cache.diff({
+                            id: "ROOT_MUTATION",
+                            // The cache complains if passed a mutation where it expects a
+                            // query, so we transform mutations and subscriptions to queries
+                            // (only once, thanks to this.transformCache).
+                            query: this.queryManager.getDocumentInfo(mutation.document)
+                                .asQuery,
+                            variables: mutation.variables,
+                            optimistic: false,
+                            returnPartialData: true,
+                        });
+                        if (diff.complete) {
+                            result = {
+                                ...result,
+                                data: diff.result,
+                            };
                         }
                     }
+                    // If we've received the whole response, call the update function.
+                    if (update && !this.hasNext) {
+                        update(cache, result, {
+                            context: mutation.context,
+                            variables: mutation.variables,
+                        });
+                    }
                     // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
                     // shallow to allow rolling back optimistic evictions.
                     if (!skipCache && !mutation.keepRootFields && !this.hasNext) {
@@ -381,6 +416,20 @@ export class QueryInfo {
                     variables: variables,
                     extensions: result.extensions,
                 });
+                // Re-read from the cache to get parsed scalar values
+                const diff = this.cache.diff({
+                    // The cache complains if passed a mutation where it expects a
+                    // query, so we transform mutations and subscriptions to queries
+                    // (only once, thanks to this.transformCache).
+                    query: this.queryManager.getDocumentInfo(document).asQuery,
+                    id: "ROOT_SUBSCRIPTION",
+                    variables,
+                    optimistic: false,
+                    returnPartialData: true,
+                });
+                if (diff.complete) {
+                    result.data = diff.result;
+                }
             }
             this.queryManager.broadcastQueries();
         }
@@ -394,4 +443,129 @@ function shouldWriteResult(result, errorPolicy = "none") {
     }
     return writeWithErrors;
 }
+function isStreamingPartial(diff, document, variables) {
+    if (!diff.missing)
+        return false;
+    const fragmentMap = createFragmentMap(getFragmentDefinitions(document));
+    return isPartialInSelectionSet(getMainDefinition(document).selectionSet, diff.missing.missing, { fragmentMap, variables });
+}
+function isPartialInSelectionSet(selectionSet, missingTree, context) {
+    if (typeof missingTree === "string")
+        return true;
+    if (missingTree === undefined)
+        return false;
+    const missingKeys = Object.keys(missingTree);
+    if (missingKeys.length > 0 && missingKeys.every(isArrayIndex)) {
+        return missingKeys.some((key) => {
+            if (typeof missingTree[key] === "string")
+                return true;
+            return isPartialInSelectionSet(selectionSet, missingTree[key], context);
+        });
+    }
+    const { fragmentMap, variables } = context;
+    for (const selection of selectionSet.selections) {
+        if (isField(selection)) {
+            if (isTypenameField(selection))
+                continue;
+            const missing = missingTree[resultKeyNameFromField(selection)];
+            // If a missing entry is absent, we have a value for this field
+            if (missing === undefined)
+                continue;
+            if (!selection.selectionSet ||
+                isPartialInSelectionSet(selection.selectionSet, missing, context)) {
+                return true;
+            }
+        }
+        else {
+            const fragment = getFragmentFromSelection(selection, fragmentMap);
+            if (!fragment)
+                continue;
+            if (isDeferredFragment(selection, variables)) {
+                // We need to know the non-deferred fields that might overlap with the
+                // deferred selection set so that we accurately report the right
+                // dataState when all the non-deferred fields are satisfied and only the
+                // selections inside the fragment are missing.
+                // For example:
+                //
+                // {
+                //   recipient {
+                //     name
+                //   }
+                //   ... @defer {
+                //     recipient {
+                //       name
+                //       email
+                //     }
+                //   }
+                // }
+                //
+                // dataState should be `streaming`, not `partial` if `name` is present,
+                // but `email` is absent since `name` is not deferred.
+                if (isPartialDeferBoundary(fragment.selectionSet, missingTree, collectSiblingFields(selectionSet, {
+                    ...context,
+                    exclude: selection,
+                }), fragmentMap)) {
+                    return true;
+                }
+            }
+            else if (isPartialInSelectionSet(fragment.selectionSet, missingTree, context)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isPartialDeferBoundary(selectionSet, missing, nonDeferredFields, fragmentMap) {
+    // This flag tracks whether all fields in this selection set should contain
+    // values or should all be missing. A defer boundary is only partial if some
+    // fields are missing. The first selection node will set this value and all
+    // sibling fields should match after that. As soon as we get a mismatch, we
+    // have a partial defer boundary.
+    let shouldContainValues;
+    for (const selection of selectionSet.selections) {
+        if (isField(selection)) {
+            if (isTypenameField(selection))
+                continue;
+            const name = resultKeyNameFromField(selection);
+            const nonDeferredField = nonDeferredFields?.[name];
+            // If this field is not exclusive to this selection set, we don't care
+            // what the value is as far as the defer boundary is concerned. Ignore it
+            // and continue checking other siblings.
+            if (nonDeferredField === true)
+                continue;
+            // The value of missing means different things:
+            // - undefined: The field is fully satisfied (i.e. it has a value for the field)
+            // - string: the field is fully unsatisfied (no scalar value, or object is
+            //   missing all fields)
+            // - object: The field has a selection set and is partially satisfied.
+            const missingField = missing[name];
+            if (typeof missingField !== "object") {
+                const hasValue = missingField === undefined;
+                if (shouldContainValues === undefined) {
+                    shouldContainValues = hasValue;
+                }
+                if (hasValue !== shouldContainValues) {
+                    return true;
+                }
+                continue;
+            }
+            if (selection.selectionSet &&
+                isPartialDeferBoundary(selection.selectionSet, missingField, nonDeferredField, fragmentMap)) {
+                return true;
+            }
+        }
+        else {
+            const fragment = getFragmentFromSelection(selection, fragmentMap);
+            if (!fragment)
+                continue;
+            if (isPartialDeferBoundary(fragment.selectionSet, missing, nonDeferredFields, fragmentMap)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isArrayIndex(key) {
+    return /^\d+$/.test(key);
+}
 //# sourceMappingURL=QueryInfo.js.map