@apollo/client 4.0.0-alpha.20 → 4.0.0-alpha.21

package/__cjs/core/ObservableQuery.d.cts

@@ -4,7 +4,6 @@ import { Observable } from "rxjs";
 import type { Cache, MissingFieldError } from "@apollo/client/cache";
 import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
-import type { LastWrite } from "./QueryInfo.cjs";
 import type { QueryManager } from "./QueryManager.cjs";
 import type { ApolloQueryResult, DefaultContext, OperationVariables, QueryResult, TypedDocumentNode } from "./types.cjs";
 import type { ErrorPolicy, FetchMoreQueryOptions, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.cjs";
@@ -177,7 +176,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     * 
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
-    _lastWrite?: LastWrite;
+    _lastWrite?: unknown;
     get query(): TypedDocumentNode<TData, TVariables>;
     /**
      * An object containing the variables that were provided for the query.

package/__cjs/core/QueryInfo.cjs

@@ -1,9 +1,14 @@
-"use strict";
+"use strict";;
+const {
+    __DEV__
+} = require("@apollo/client/utilities/environment");
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInfo = void 0;
-exports.shouldWriteResult = shouldWriteResult;
 const equality_1 = require("@wry/equality");
 const internal_1 = require("@apollo/client/utilities/internal");
+const invariant_1 = require("@apollo/client/utilities/invariant");
+const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
     const original = cache[methodName];
@@ -21,26 +26,28 @@ function wrapDestructiveCacheMethod(cache, methodName) {
         };
     }
 }
+const queryInfoIds = new WeakMap();
 // A QueryInfo object represents a single network request, either initiated
 // from the QueryManager or from an ObservableQuery.
 // It will only ever be used for a single network call.
 // It is responsible for reporting results to the cache, merging and in a no-cache
 // scenario accumulating the response.
 class QueryInfo {
-    document = null;
     // TODO remove soon - this should be able to be handled by cancelling old operations before starting new ones
     lastRequestId = 1;
-    variables;
     cache;
-    queryId;
-    // TODO should be private
+    queryManager;
+    id;
     observableQuery;
-    constructor({ queryManager, observableQuery, }) {
+    constructor(queryManager, observableQuery) {
         const cache = (this.cache = queryManager.cache);
-        this.queryId = queryManager.generateQueryId();
+        const id = (queryInfoIds.get(queryManager) || 0) + 1;
+        queryInfoIds.set(queryManager, id);
+        this.id = id + "";
         this.observableQuery = observableQuery;
+        this.queryManager = queryManager;
         // Track how often cache.evict is called, since we want eviction to
-        // override the feud-stopping logic in the markResult method, by
+        // override the feud-stopping logic in the markQueryResult method, by
         // causing shouldWrite to return true. Wrapping the cache.evict method
         // is a bit of a hack, but it saves us from having to make eviction
         // counting an official part of the ApolloCache API.
@@ -51,19 +58,6 @@ class QueryInfo {
             wrapDestructiveCacheMethod(cache, "reset");
         }
     }
-    init(query) {
-        this.document = query.document;
-        this.variables = query.variables;
-        return this;
-    }
-    getDiffOptions(variables = this.variables) {
-        return {
-            query: this.document,
-            variables,
-            returnPartialData: true,
-            optimistic: true,
-        };
-    }
     /**
     * @internal
     * For feud-preventing behaviour, `lastWrite` should be shared by all `QueryInfo` instances of an `ObservableQuery`.
@@ -91,16 +85,18 @@ class QueryInfo {
             (0, equality_1.equal)(variables, lastWrite.variables) &&
             (0, equality_1.equal)(result.data, lastWrite.result.data));
     }
-    resetDiff() {
-        this.lastDiff = void 0;
-    }
     lastDiff;
-    markResult(result, document, options, cacheWriteBehavior) {
+    markQueryResult(result, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+        const diffOptions = {
+            query,
+            variables,
+            returnPartialData: true,
+            optimistic: true,
+        };
         // Cancel the pending notify timeout (if it exists) to prevent extraneous network
         // requests. To allow future notify timeouts, diff and dirty are reset as well.
         this.observableQuery?.["resetNotifications"]();
         if (cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */) {
-            const diffOptions = this.getDiffOptions(options.variables);
             const lastDiff = this.lastDiff && (0, equality_1.equal)(diffOptions, this.lastDiff.options) ?
                 this.lastDiff.diff
                 : { result: null, complete: false };
@@ -111,9 +107,9 @@ class QueryInfo {
             };
         }
         else {
-            const lastDiff = this.cache.diff(this.getDiffOptions());
+            const lastDiff = this.cache.diff(diffOptions);
             handleIncrementalResult(result, lastDiff);
-            if (shouldWriteResult(result, options.errorPolicy)) {
+            if (shouldWriteResult(result, errorPolicy)) {
                 // Using a transaction here so we have a chance to read the result
                 // back from the cache before the watch callback fires as a result
                 // of writeQuery, so we can store the new diff quietly and ignore
@@ -129,16 +125,16 @@ class QueryInfo {
                         }
                     },
                     update: (cache) => {
-                        if (this.shouldWrite(result, options.variables)) {
+                        if (this.shouldWrite(result, variables)) {
                             cache.writeQuery({
-                                query: document,
+                                query,
                                 data: result.data,
-                                variables: options.variables,
+                                variables,
                                 overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
                             });
                             this.lastWrite = {
                                 result,
-                                variables: options.variables,
+                                variables,
                                 dmCount: destructiveMethodCounts.get(this.cache),
                             };
                         }
@@ -184,7 +180,6 @@ class QueryInfo {
                             // If the previous this.diff was incomplete, fall through to
                             // re-reading the latest data with cache.diff, below.
                         }
-                        const diffOptions = this.getDiffOptions(options.variables);
                         const diff = cache.diff(diffOptions);
                         // If we're allowed to write to the cache, and we can read a
                         // complete result from the cache, update result.data to be the
@@ -202,6 +197,200 @@ class QueryInfo {
             }
         }
     }
+    markMutationResult(result, mutation, cache = this.cache) {
+        const cacheWrites = [];
+        const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
+        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
+            if (!(0, internal_1.isExecutionPatchIncrementalResult)(result)) {
+                cacheWrites.push({
+                    result: result.data,
+                    dataId: "ROOT_MUTATION",
+                    query: mutation.document,
+                    variables: mutation.variables,
+                });
+            }
+            if ((0, internal_1.isExecutionPatchIncrementalResult)(result) &&
+                (0, internal_1.isNonEmptyArray)(result.incremental)) {
+                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,
+                });
+                let mergedData;
+                if (diff.result) {
+                    mergedData = (0, internal_1.mergeIncrementalData)(diff.result, result);
+                }
+                if (typeof mergedData !== "undefined") {
+                    // cast the ExecutionPatchResult to FetchResult here since
+                    // ExecutionPatchResult never has `data` when returned from the server
+                    result.data = mergedData;
+                    cacheWrites.push({
+                        result: mergedData,
+                        dataId: "ROOT_MUTATION",
+                        query: mutation.document,
+                        variables: mutation.variables,
+                    });
+                }
+            }
+            const { updateQueries } = mutation;
+            if (updateQueries) {
+                this.queryManager
+                    .getObservableQueries("all")
+                    .forEach((observableQuery) => {
+                    const queryName = observableQuery && observableQuery.queryName;
+                    if (!queryName ||
+                        !Object.hasOwnProperty.call(updateQueries, queryName)) {
+                        return;
+                    }
+                    const updater = updateQueries[queryName];
+                    const { query: document, variables } = observableQuery;
+                    // Read the current query result from the store.
+                    const { result: currentQueryResult, complete } = observableQuery.getCacheDiff({ optimistic: false });
+                    if (complete && currentQueryResult) {
+                        // Run our reducer using the current query result and the mutation result.
+                        const nextQueryResult = updater(currentQueryResult, {
+                            mutationResult: result,
+                            queryName: (document && (0, internal_1.getOperationName)(document)) || void 0,
+                            queryVariables: variables,
+                        });
+                        // Write the modified result back into the store if we got a new result.
+                        if (nextQueryResult) {
+                            cacheWrites.push({
+                                result: nextQueryResult,
+                                dataId: "ROOT_QUERY",
+                                query: document,
+                                variables,
+                            });
+                        }
+                    }
+                });
+            }
+        }
+        if (cacheWrites.length > 0 ||
+            (mutation.refetchQueries || "").length > 0 ||
+            mutation.update ||
+            mutation.onQueryUpdated ||
+            mutation.removeOptimistic) {
+            const results = [];
+            this.queryManager
+                .refetchQueries({
+                updateCache: (cache) => {
+                    if (!skipCache) {
+                        cacheWrites.forEach((write) => cache.write(write));
+                    }
+                    // If the mutation has some writes associated with it then we need to
+                    // apply those writes to the store by running this reducer again with
+                    // a write action.
+                    const { update } = mutation;
+                    // Determine whether result is a SingleExecutionResult,
+                    // or the final ExecutionPatchResult.
+                    const isFinalResult = !(0, internal_1.isExecutionPatchResult)(result) ||
+                        ((0, internal_1.isExecutionPatchIncrementalResult)(result) && !result.hasNext);
+                    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 ("incremental" in result) {
+                                    delete result.incremental;
+                                }
+                                if ("hasNext" in result) {
+                                    delete result.hasNext;
+                                }
+                            }
+                        }
+                        // If we've received the whole response,
+                        // either a SingleExecutionResult or the final ExecutionPatchResult,
+                        // call the update function.
+                        if (isFinalResult) {
+                            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 && isFinalResult) {
+                        cache.modify({
+                            id: "ROOT_MUTATION",
+                            fields(value, { fieldName, DELETE }) {
+                                return fieldName === "__typename" ? value : DELETE;
+                            },
+                        });
+                    }
+                },
+                include: mutation.refetchQueries,
+                // Write the final mutation.result to the root layer of the cache.
+                optimistic: false,
+                // Remove the corresponding optimistic layer at the same time as we
+                // write the final non-optimistic result.
+                removeOptimistic: mutation.removeOptimistic,
+                // Let the caller of client.mutate optionally determine the refetching
+                // behavior for watched queries after the mutation.update function runs.
+                // If no onQueryUpdated function was provided for this mutation, pass
+                // null instead of undefined to disable the default refetching behavior.
+                onQueryUpdated: mutation.onQueryUpdated || null,
+            })
+                .forEach((result) => results.push(result));
+            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
+                // Returning a promise here makes the mutation await that promise, so we
+                // include results in that promise's work if awaitRefetchQueries or an
+                // onQueryUpdated function was specified.
+                return Promise.all(results).then(() => result);
+            }
+        }
+        return Promise.resolve(result);
+    }
+    markMutationOptimistic(optimisticResponse, mutation) {
+        const data = typeof optimisticResponse === "function" ?
+            optimisticResponse(mutation.variables, { IGNORE })
+            : optimisticResponse;
+        if (data === IGNORE) {
+            return false;
+        }
+        this.cache.recordOptimisticTransaction((cache) => {
+            try {
+                this.markMutationResult({ data }, mutation, cache);
+            }
+            catch (error) {
+                __DEV__ && invariant_1.invariant.error(error);
+            }
+        }, this.id);
+        return true;
+    }
+    markSubscriptionResult(result, { document, variables, errorPolicy, cacheWriteBehavior, }) {
+        if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
+            if (shouldWriteResult(result, errorPolicy)) {
+                this.cache.write({
+                    query: document,
+                    result: result.data,
+                    dataId: "ROOT_SUBSCRIPTION",
+                    variables: variables,
+                });
+            }
+            this.queryManager.broadcastQueries();
+        }
+    }
 }
 exports.QueryInfo = QueryInfo;
 function handleIncrementalResult(result, lastDiff) {