@apollo/client 3.4.17 → 3.5.6

package/cache/{cache.cjs.js → cache.cjs}

@@ -15,9 +15,12 @@ var ApolloCache = (function () {
         this.getFragmentDoc = optimism.wrap(utilities.getFragmentQueryDocument);
     }
     ApolloCache.prototype.batch = function (options) {
+        var _this = this;
         var optimisticId = typeof options.optimistic === "string" ? options.optimistic :
             options.optimistic === false ? null : void 0;
-        this.performTransaction(options.update, optimisticId);
+        var updateResult;
+        this.performTransaction(function () { return updateResult = options.update(_this); }, optimisticId);
+        return updateResult;
     };
     ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
         this.performTransaction(transaction, optimisticId);
@@ -60,6 +63,30 @@ var ApolloCache = (function () {
             result: data,
         }));
     };
+    ApolloCache.prototype.updateQuery = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readQuery(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
+    ApolloCache.prototype.updateFragment = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readFragment(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
     return ApolloCache;
 }());
 
@@ -67,19 +94,15 @@ exports.Cache = void 0;
 (function (Cache) {
 })(exports.Cache || (exports.Cache = {}));
 
-var MissingFieldError = (function (_super) {
-    tslib.__extends(MissingFieldError, _super);
+var MissingFieldError = (function () {
     function MissingFieldError(message, path, query, variables) {
-        var _this = _super.call(this, message) || this;
-        _this.message = message;
-        _this.path = path;
-        _this.query = query;
-        _this.variables = variables;
-        _this.__proto__ = MissingFieldError.prototype;
-        return _this;
+        this.message = message;
+        this.path = path;
+        this.query = query;
+        this.variables = variables;
     }
     return MissingFieldError;
-}(Error));
+}());
 
 var hasOwn = Object.prototype.hasOwnProperty;
 function defaultDataIdFromObject(_a, context) {
@@ -94,7 +117,7 @@ function defaultDataIdFromObject(_a, context) {
         if (id === void 0)
             id = _id;
         if (id !== void 0) {
-            return __typename + ":" + ((typeof id === "number" ||
+            return "".concat(__typename, ":").concat((typeof id === "number" ||
                 typeof id === "string") ? id : JSON.stringify(id));
         }
     }
@@ -720,9 +743,6 @@ function resetCanonicalStringify() {
     stringifyCache = new (utilities.canUseWeakMap ? WeakMap : Map)();
 }
 
-function missingFromInvariant(err, context) {
-    return new MissingFieldError(err.message, context.path.slice(), context.query, context.variables);
-}
 function execSelectionSetKeyArgs(options) {
     return [
         options.selectionSet,
@@ -784,6 +804,7 @@ var StoreReader = (function () {
         var policies = this.config.cache.policies;
         variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(utilities.getQueryDefinition(query))), variables);
         var rootRef = utilities.makeReference(rootId);
+        var merger = new utilities.DeepMerger;
         var execResult = this.executeSelectionSet({
             selectionSet: utilities.getMainDefinition(query).selectionSet,
             objectOrReference: rootRef,
@@ -796,17 +817,22 @@ var StoreReader = (function () {
                 varString: canonicalStringify(variables),
                 canonizeResults: canonizeResults,
                 fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
-                path: [],
+                merge: function (a, b) {
+                    return merger.merge(a, b);
+                },
             },
         });
-        var hasMissingFields = execResult.missing && execResult.missing.length > 0;
-        if (hasMissingFields && !returnPartialData) {
-            throw execResult.missing[0];
+        var missing;
+        if (execResult.missing) {
+            missing = [new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables)];
+            if (!returnPartialData) {
+                throw missing[0];
+            }
         }
         return {
             result: execResult.result,
-            missing: execResult.missing,
-            complete: !hasMissingFields,
+            complete: !missing,
+            missing: missing,
         };
     };
     StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {
@@ -827,30 +853,28 @@ var StoreReader = (function () {
             !context.store.has(objectOrReference.__ref)) {
             return {
                 result: this.canon.empty,
-                missing: [missingFromInvariant(__DEV__ ? new globals.InvariantError("Dangling reference to missing " + objectOrReference.__ref + " object") : new globals.InvariantError(5), context)],
+                missing: "Dangling reference to missing ".concat(objectOrReference.__ref, " object"),
             };
         }
         var variables = context.variables, policies = context.policies, store = context.store;
-        var objectsToMerge = [];
-        var finalResult = { result: null };
         var typename = store.getFieldValue(objectOrReference, "__typename");
+        var result = {};
+        var missing;
         if (this.config.addTypename &&
             typeof typename === "string" &&
             !policies.rootIdsByTypename[typename]) {
-            objectsToMerge.push({ __typename: typename });
+            result = { __typename: typename };
         }
-        function getMissing() {
-            return finalResult.missing || (finalResult.missing = []);
-        }
-        function handleMissing(result) {
+        function handleMissing(result, resultName) {
             var _a;
-            if (result.missing)
-                (_a = getMissing()).push.apply(_a, result.missing);
+            if (result.missing) {
+                missing = context.merge(missing, (_a = {}, _a[resultName] = result.missing, _a));
+            }
             return result.result;
         }
         var workSet = new Set(selectionSet.selections);
         workSet.forEach(function (selection) {
-            var _a;
+            var _a, _b;
             if (!utilities.shouldInclude(selection, variables))
                 return;
             if (utilities.isField(selection)) {
@@ -861,12 +885,13 @@ var StoreReader = (function () {
                     from: objectOrReference,
                 }, context);
                 var resultName = utilities.resultKeyNameFromField(selection);
-                context.path.push(resultName);
                 if (fieldValue === void 0) {
                     if (!utilities.addTypenameToDocument.added(selection)) {
-                        getMissing().push(missingFromInvariant(__DEV__ ? new globals.InvariantError("Can't find field '" + selection.name.value + "' on " + (utilities.isReference(objectOrReference)
-                            ? objectOrReference.__ref + " object"
-                            : "object " + JSON.stringify(objectOrReference, null, 2))) : new globals.InvariantError(6), context));
+                        missing = context.merge(missing, (_a = {},
+                            _a[resultName] = "Can't find field '".concat(selection.name.value, "' on ").concat(utilities.isReference(objectOrReference)
+                                ? objectOrReference.__ref + " object"
+                                : "object " + JSON.stringify(objectOrReference, null, 2)),
+                            _a));
                     }
                 }
                 else if (Array.isArray(fieldValue)) {
@@ -875,7 +900,7 @@ var StoreReader = (function () {
                         array: fieldValue,
                         enclosingRef: enclosingRef,
                         context: context,
-                    }));
+                    }), resultName);
                 }
                 else if (!selection.selectionSet) {
                     if (context.canonizeResults) {
@@ -888,12 +913,11 @@ var StoreReader = (function () {
                         objectOrReference: fieldValue,
                         enclosingRef: utilities.isReference(fieldValue) ? fieldValue : enclosingRef,
                         context: context,
-                    }));
+                    }), resultName);
                 }
                 if (fieldValue !== void 0) {
-                    objectsToMerge.push((_a = {}, _a[resultName] = fieldValue, _a));
+                    result = context.merge(result, (_b = {}, _b[resultName] = fieldValue, _b));
                 }
-                globals.invariant(context.path.pop() === resultName);
             }
             else {
                 var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
@@ -902,23 +926,24 @@ var StoreReader = (function () {
                 }
             }
         });
-        var merged = utilities.mergeDeepArray(objectsToMerge);
-        finalResult.result = context.canonizeResults
-            ? this.canon.admit(merged)
-            : utilities.maybeDeepFreeze(merged);
-        this.knownResults.set(finalResult.result, selectionSet);
-        return finalResult;
+        var finalResult = { result: result, missing: missing };
+        var frozen = context.canonizeResults
+            ? this.canon.admit(finalResult)
+            : utilities.maybeDeepFreeze(finalResult);
+        if (frozen.result) {
+            this.knownResults.set(frozen.result, selectionSet);
+        }
+        return frozen;
     };
     StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {
         var _this = this;
         var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;
         var missing;
         function handleMissing(childResult, i) {
+            var _a;
             if (childResult.missing) {
-                missing = missing || [];
-                missing.push.apply(missing, childResult.missing);
+                missing = context.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));
             }
-            globals.invariant(context.path.pop() === i);
             return childResult.result;
         }
         if (field.selectionSet) {
@@ -928,7 +953,6 @@ var StoreReader = (function () {
             if (item === null) {
                 return null;
             }
-            context.path.push(i);
             if (Array.isArray(item)) {
                 return handleMissing(_this.executeSubSelectedArray({
                     field: field,
@@ -948,7 +972,6 @@ var StoreReader = (function () {
             if (__DEV__) {
                 assertSelectionSetForIdValue(context.store, field, item);
             }
-            globals.invariant(context.path.pop() === i);
             return item;
         });
         return {
@@ -958,466 +981,275 @@ var StoreReader = (function () {
     };
     return StoreReader;
 }());
+function firstMissing(tree) {
+    try {
+        JSON.stringify(tree, function (_, value) {
+            if (typeof value === "string")
+                throw value;
+            return value;
+        });
+    }
+    catch (result) {
+        return result;
+    }
+}
 function assertSelectionSetForIdValue(store, field, fieldValue) {
     if (!field.selectionSet) {
         var workSet_1 = new Set([fieldValue]);
         workSet_1.forEach(function (value) {
             if (utilities.isNonNullObject(value)) {
-                __DEV__ ? globals.invariant(!utilities.isReference(value), "Missing selection set for object of type " + getTypenameFromStoreObject(store, value) + " returned for query field " + field.name.value) : globals.invariant(!utilities.isReference(value), 7);
+                __DEV__ ? globals.invariant(!utilities.isReference(value), "Missing selection set for object of type ".concat(getTypenameFromStoreObject(store, value), " returned for query field ").concat(field.name.value)) : globals.invariant(!utilities.isReference(value), 5);
                 Object.values(value).forEach(workSet_1.add, workSet_1);
             }
         });
     }
 }
 
-var StoreWriter = (function () {
-    function StoreWriter(cache, reader) {
-        this.cache = cache;
-        this.reader = reader;
+var cacheSlot = new context.Slot();
+var cacheInfoMap = new WeakMap();
+function getCacheInfo(cache) {
+    var info = cacheInfoMap.get(cache);
+    if (!info) {
+        cacheInfoMap.set(cache, info = {
+            vars: new Set,
+            dep: optimism.dep(),
+        });
     }
-    StoreWriter.prototype.writeToStore = function (store, _a) {
-        var _this = this;
-        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
-        var operationDefinition = utilities.getOperationDefinition(query);
-        var merger = makeProcessedFieldsMerger();
-        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(operationDefinition)), variables);
-        var context = {
-            store: store,
-            written: Object.create(null),
-            merge: function (existing, incoming) {
-                return merger.merge(existing, incoming);
-            },
-            variables: variables,
-            varString: canonicalStringify(variables),
-            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
-            overwrite: !!overwrite,
-            incomingById: new Map,
-            clientOnly: false,
+    return info;
+}
+function forgetCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
+}
+function recallCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
+}
+function makeVar(value) {
+    var caches = new Set();
+    var listeners = new Set();
+    var rv = function (newValue) {
+        if (arguments.length > 0) {
+            if (value !== newValue) {
+                value = newValue;
+                caches.forEach(function (cache) {
+                    getCacheInfo(cache).dep.dirty(rv);
+                    broadcast(cache);
+                });
+                var oldListeners = Array.from(listeners);
+                listeners.clear();
+                oldListeners.forEach(function (listener) { return listener(value); });
+            }
+        }
+        else {
+            var cache = cacheSlot.getValue();
+            if (cache) {
+                attach(cache);
+                getCacheInfo(cache).dep(rv);
+            }
+        }
+        return value;
+    };
+    rv.onNextChange = function (listener) {
+        listeners.add(listener);
+        return function () {
+            listeners.delete(listener);
         };
-        var ref = this.processSelectionSet({
-            result: result || Object.create(null),
-            dataId: dataId,
-            selectionSet: operationDefinition.selectionSet,
-            mergeTree: { map: new Map },
-            context: context,
+    };
+    var attach = rv.attachCache = function (cache) {
+        caches.add(cache);
+        getCacheInfo(cache).vars.add(rv);
+        return rv;
+    };
+    rv.forgetCache = function (cache) { return caches.delete(cache); };
+    return rv;
+}
+function broadcast(cache) {
+    if (cache.broadcastWatches) {
+        cache.broadcastWatches();
+    }
+}
+
+var specifierInfoCache = Object.create(null);
+function lookupSpecifierInfo(spec) {
+    var cacheKey = JSON.stringify(spec);
+    return specifierInfoCache[cacheKey] ||
+        (specifierInfoCache[cacheKey] = Object.create(null));
+}
+function keyFieldsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {
+        var extract = function (from, key) { return context.readField(key, from); };
+        var keyObject = context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {
+            var extracted = extractKeyPath(context.storeObject, schemaKeyPath, extract);
+            if (extracted === void 0 &&
+                object !== context.storeObject &&
+                hasOwn.call(object, schemaKeyPath[0])) {
+                extracted = extractKeyPath(object, schemaKeyPath, extractKey);
+            }
+            __DEV__ ? globals.invariant(extracted !== void 0, "Missing field '".concat(schemaKeyPath.join('.'), "' while extracting keyFields from ").concat(JSON.stringify(object))) : globals.invariant(extracted !== void 0, 2);
+            return extracted;
         });
-        if (!utilities.isReference(ref)) {
-            throw __DEV__ ? new globals.InvariantError("Could not identify object " + JSON.stringify(result)) : new globals.InvariantError(8);
-        }
-        context.incomingById.forEach(function (_a, dataId) {
-            var fields = _a.fields, mergeTree = _a.mergeTree, selections = _a.selections;
-            var entityRef = utilities.makeReference(dataId);
-            if (mergeTree && mergeTree.map.size) {
-                var applied = _this.applyMerges(mergeTree, entityRef, fields, context);
-                if (utilities.isReference(applied)) {
-                    return;
+        return "".concat(context.typename, ":").concat(JSON.stringify(keyObject));
+    });
+}
+function keyArgsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyArgsFn || (info.keyArgsFn = function (args, _a) {
+        var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;
+        var collected = collectSpecifierPaths(specifier, function (keyPath) {
+            var firstKey = keyPath[0];
+            var firstChar = firstKey.charAt(0);
+            if (firstChar === "@") {
+                if (field && utilities.isNonEmptyArray(field.directives)) {
+                    var directiveName_1 = firstKey.slice(1);
+                    var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });
+                    var directiveArgs = d && utilities.argumentsObjectFromField(d, variables);
+                    return directiveArgs && extractKeyPath(directiveArgs, keyPath.slice(1));
                 }
-                fields = applied;
+                return;
             }
-            if (__DEV__ && !context.overwrite) {
-                var hasSelectionSet_1 = function (storeFieldName) {
-                    return fieldsWithSelectionSets_1.has(fieldNameFromStoreName(storeFieldName));
-                };
-                var fieldsWithSelectionSets_1 = new Set();
-                selections.forEach(function (selection) {
-                    if (utilities.isField(selection) && selection.selectionSet) {
-                        fieldsWithSelectionSets_1.add(selection.name.value);
-                    }
-                });
-                var hasMergeFunction_1 = function (storeFieldName) {
-                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
-                    return Boolean(childTree && childTree.info && childTree.info.merge);
-                };
-                Object.keys(fields).forEach(function (storeFieldName) {
-                    if (hasSelectionSet_1(storeFieldName) &&
-                        !hasMergeFunction_1(storeFieldName)) {
-                        warnAboutDataLoss(entityRef, fields, storeFieldName, context.store);
-                    }
-                });
+            if (firstChar === "$") {
+                var variableName = firstKey.slice(1);
+                if (variables && hasOwn.call(variables, variableName)) {
+                    var varKeyPath = keyPath.slice(0);
+                    varKeyPath[0] = variableName;
+                    return extractKeyPath(variables, varKeyPath);
+                }
+                return;
             }
-            store.merge(dataId, fields);
-        });
-        store.retain(ref.__ref);
-        return ref;
-    };
-    StoreWriter.prototype.processSelectionSet = function (_a) {
-        var _this = this;
-        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;
-        var policies = this.cache.policies;
-        var _b = policies.identify(result, selectionSet, context.fragmentMap), id = _b[0], keyObject = _b[1];
-        dataId = dataId || id;
-        if ("string" === typeof dataId) {
-            var sets = context.written[dataId] || (context.written[dataId] = []);
-            var ref = utilities.makeReference(dataId);
-            if (sets.indexOf(selectionSet) >= 0)
-                return ref;
-            sets.push(selectionSet);
-            if (this.reader && this.reader.isFresh(result, ref, selectionSet, context)) {
-                return ref;
+            if (args) {
+                return extractKeyPath(args, keyPath);
             }
+        });
+        var suffix = JSON.stringify(collected);
+        if (args || suffix !== "{}") {
+            fieldName += ":" + suffix;
         }
-        var incomingFields = Object.create(null);
-        if (keyObject) {
-            incomingFields = context.merge(incomingFields, keyObject);
-        }
-        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
-            utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
-            (dataId && context.store.get(dataId, "__typename"));
-        if ("string" === typeof typename) {
-            incomingFields.__typename = typename;
+        return fieldName;
+    });
+}
+function collectSpecifierPaths(specifier, extractor) {
+    var merger = new utilities.DeepMerger;
+    return getSpecifierPaths(specifier).reduce(function (collected, path) {
+        var _a;
+        var toMerge = extractor(path);
+        if (toMerge !== void 0) {
+            for (var i = path.length - 1; i >= 0; --i) {
+                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);
+            }
+            collected = merger.merge(collected, toMerge);
         }
-        var selections = new Set(selectionSet.selections);
-        selections.forEach(function (selection) {
-            var _a;
-            if (!utilities.shouldInclude(selection, context.variables))
-                return;
-            if (utilities.isField(selection)) {
-                var resultFieldKey = utilities.resultKeyNameFromField(selection);
-                var value = result[resultFieldKey];
-                var wasClientOnly = context.clientOnly;
-                context.clientOnly = wasClientOnly || !!(selection.directives &&
-                    selection.directives.some(function (d) { return d.name.value === "client"; }));
-                if (value !== void 0) {
-                    var storeFieldName = policies.getStoreFieldName({
-                        typename: typename,
-                        fieldName: selection.name.value,
-                        field: selection,
-                        variables: context.variables,
-                    });
-                    var childTree = getChildMergeTree(mergeTree, storeFieldName);
-                    var incomingValue = _this.processFieldValue(value, selection, context, childTree);
-                    var childTypename = void 0;
-                    if (selection.selectionSet) {
-                        childTypename = context.store.getFieldValue(incomingValue, "__typename");
-                        if (!childTypename && utilities.isReference(incomingValue)) {
-                            var info = context.incomingById.get(incomingValue.__ref);
-                            childTypename = info && info.fields.__typename;
-                        }
-                    }
-                    var merge = policies.getMergeFunction(typename, selection.name.value, childTypename);
-                    if (merge) {
-                        childTree.info = {
-                            field: selection,
-                            typename: typename,
-                            merge: merge,
-                        };
-                    }
-                    else {
-                        maybeRecycleChildMergeTree(mergeTree, storeFieldName);
-                    }
-                    incomingFields = context.merge(incomingFields, (_a = {},
-                        _a[storeFieldName] = incomingValue,
-                        _a));
-                }
-                else if (!context.clientOnly &&
-                    !utilities.addTypenameToDocument.added(selection)) {
-                    __DEV__ && globals.invariant.error(("Missing field '" + utilities.resultKeyNameFromField(selection) + "' while writing result " + JSON.stringify(result, null, 2)).substring(0, 1000));
-                }
-                context.clientOnly = wasClientOnly;
+        return collected;
+    }, Object.create(null));
+}
+function getSpecifierPaths(spec) {
+    var info = lookupSpecifierInfo(spec);
+    if (!info.paths) {
+        var paths_1 = info.paths = [];
+        var currentPath_1 = [];
+        spec.forEach(function (s, i) {
+            if (Array.isArray(s)) {
+                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });
+                currentPath_1.length = 0;
             }
             else {
-                var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
-                if (fragment &&
-                    policies.fragmentMatches(fragment, typename, result, context.variables)) {
-                    fragment.selectionSet.selections.forEach(selections.add, selections);
+                currentPath_1.push(s);
+                if (!Array.isArray(spec[i + 1])) {
+                    paths_1.push(currentPath_1.slice(0));
+                    currentPath_1.length = 0;
                 }
             }
         });
-        if ("string" === typeof dataId) {
-            var previous = context.incomingById.get(dataId);
-            if (previous) {
-                previous.fields = context.merge(previous.fields, incomingFields);
-                previous.mergeTree = mergeMergeTrees(previous.mergeTree, mergeTree);
-                previous.selections.forEach(selections.add, selections);
-                previous.selections = selections;
+    }
+    return info.paths;
+}
+function extractKey(object, key) {
+    return object[key];
+}
+function extractKeyPath(object, path, extract) {
+    extract = extract || extractKey;
+    return normalize(path.reduce(function reducer(obj, key) {
+        return Array.isArray(obj)
+            ? obj.map(function (child) { return reducer(child, key); })
+            : obj && extract(obj, key);
+    }, object));
+}
+function normalize(value) {
+    if (utilities.isNonNullObject(value)) {
+        if (Array.isArray(value)) {
+            return value.map(normalize);
+        }
+        return collectSpecifierPaths(Object.keys(value).sort(), function (path) { return extractKeyPath(value, path); });
+    }
+    return value;
+}
+
+utilities.getStoreKeyName.setStringify(canonicalStringify);
+function argsFromFieldSpecifier(spec) {
+    return spec.args !== void 0 ? spec.args :
+        spec.field ? utilities.argumentsObjectFromField(spec.field, spec.variables) : null;
+}
+var nullKeyFieldsFn = function () { return void 0; };
+var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
+var mergeTrueFn = function (existing, incoming, _a) {
+    var mergeObjects = _a.mergeObjects;
+    return mergeObjects(existing, incoming);
+};
+var mergeFalseFn = function (_, incoming) { return incoming; };
+var Policies = (function () {
+    function Policies(config) {
+        this.config = config;
+        this.typePolicies = Object.create(null);
+        this.toBeAdded = Object.create(null);
+        this.supertypeMap = new Map();
+        this.fuzzySubtypes = new Map();
+        this.rootIdsByTypename = Object.create(null);
+        this.rootTypenamesById = Object.create(null);
+        this.usingPossibleTypes = false;
+        this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);
+        this.cache = this.config.cache;
+        this.setRootTypename("Query");
+        this.setRootTypename("Mutation");
+        this.setRootTypename("Subscription");
+        if (config.possibleTypes) {
+            this.addPossibleTypes(config.possibleTypes);
+        }
+        if (config.typePolicies) {
+            this.addTypePolicies(config.typePolicies);
+        }
+    }
+    Policies.prototype.identify = function (object, partialContext) {
+        var _a;
+        var policies = this;
+        var typename = partialContext && (partialContext.typename ||
+            ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename)) || object.__typename;
+        if (typename === this.rootTypenamesById.ROOT_QUERY) {
+            return ["ROOT_QUERY"];
+        }
+        var storeObject = partialContext && partialContext.storeObject || object;
+        var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: partialContext && partialContext.readField || function () {
+                var options = normalizeReadFieldOptions(arguments, storeObject);
+                return policies.readField(options, {
+                    store: policies.cache["data"],
+                    variables: options.variables,
+                });
+            } });
+        var id;
+        var policy = typename && this.getTypePolicy(typename);
+        var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;
+        while (keyFn) {
+            var specifierOrId = keyFn(object, context);
+            if (Array.isArray(specifierOrId)) {
+                keyFn = keyFieldsFnFromSpecifier(specifierOrId);
             }
             else {
-                context.incomingById.set(dataId, {
-                    fields: incomingFields,
-                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
-                    selections: selections,
-                });
+                id = specifierOrId;
+                break;
             }
-            return utilities.makeReference(dataId);
         }
-        return incomingFields;
+        id = id ? String(id) : void 0;
+        return context.keyObject ? [id, context.keyObject] : [id];
     };
-    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
-        var _this = this;
-        if (!field.selectionSet || value === null) {
-            return __DEV__ ? utilities.cloneDeep(value) : value;
-        }
-        if (Array.isArray(value)) {
-            return value.map(function (item, i) {
-                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
-                maybeRecycleChildMergeTree(mergeTree, i);
-                return value;
-            });
-        }
-        return this.processSelectionSet({
-            result: value,
-            selectionSet: field.selectionSet,
-            context: context,
-            mergeTree: mergeTree,
-        });
-    };
-    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
-        var _a;
-        var _this = this;
-        if (mergeTree.map.size && !utilities.isReference(incoming)) {
-            var e_1 = (!Array.isArray(incoming) &&
-                (utilities.isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;
-            var i_1 = incoming;
-            if (e_1 && !getStorageArgs) {
-                getStorageArgs = [utilities.isReference(e_1) ? e_1.__ref : e_1];
-            }
-            var changedFields_1;
-            var getValue_1 = function (from, name) {
-                return Array.isArray(from)
-                    ? (typeof name === "number" ? from[name] : void 0)
-                    : context.store.getFieldValue(from, String(name));
-            };
-            mergeTree.map.forEach(function (childTree, storeFieldName) {
-                var eVal = getValue_1(e_1, storeFieldName);
-                var iVal = getValue_1(i_1, storeFieldName);
-                if (void 0 === iVal)
-                    return;
-                if (getStorageArgs) {
-                    getStorageArgs.push(storeFieldName);
-                }
-                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
-                if (aVal !== iVal) {
-                    changedFields_1 = changedFields_1 || new Map;
-                    changedFields_1.set(storeFieldName, aVal);
-                }
-                if (getStorageArgs) {
-                    globals.invariant(getStorageArgs.pop() === storeFieldName);
-                }
-            });
-            if (changedFields_1) {
-                incoming = (Array.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
-                changedFields_1.forEach(function (value, name) {
-                    incoming[name] = value;
-                });
-            }
-        }
-        if (mergeTree.info) {
-            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
-        }
-        return incoming;
-    };
-    return StoreWriter;
-}());
-var emptyMergeTreePool = [];
-function getChildMergeTree(_a, name) {
-    var map = _a.map;
-    if (!map.has(name)) {
-        map.set(name, emptyMergeTreePool.pop() || { map: new Map });
-    }
-    return map.get(name);
-}
-function mergeMergeTrees(left, right) {
-    if (left === right || !right || mergeTreeIsEmpty(right))
-        return left;
-    if (!left || mergeTreeIsEmpty(left))
-        return right;
-    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
-    var needToMergeMaps = left.map.size && right.map.size;
-    var map = needToMergeMaps ? new Map :
-        left.map.size ? left.map : right.map;
-    var merged = { info: info, map: map };
-    if (needToMergeMaps) {
-        var remainingRightKeys_1 = new Set(right.map.keys());
-        left.map.forEach(function (leftTree, key) {
-            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
-            remainingRightKeys_1.delete(key);
-        });
-        remainingRightKeys_1.forEach(function (key) {
-            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
-        });
-    }
-    return merged;
-}
-function mergeTreeIsEmpty(tree) {
-    return !tree || !(tree.info || tree.map.size);
-}
-function maybeRecycleChildMergeTree(_a, name) {
-    var map = _a.map;
-    var childTree = map.get(name);
-    if (childTree && mergeTreeIsEmpty(childTree)) {
-        emptyMergeTreePool.push(childTree);
-        map.delete(name);
-    }
-}
-var warnings = new Set();
-function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
-    var getChild = function (objOrRef) {
-        var child = store.getFieldValue(objOrRef, storeFieldName);
-        return typeof child === "object" && child;
-    };
-    var existing = getChild(existingRef);
-    if (!existing)
-        return;
-    var incoming = getChild(incomingObj);
-    if (!incoming)
-        return;
-    if (utilities.isReference(existing))
-        return;
-    if (equality.equal(existing, incoming))
-        return;
-    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
-        return;
-    }
-    var parentType = store.getFieldValue(existingRef, "__typename") ||
-        store.getFieldValue(incomingObj, "__typename");
-    var fieldName = fieldNameFromStoreName(storeFieldName);
-    var typeDotName = parentType + "." + fieldName;
-    if (warnings.has(typeDotName))
-        return;
-    warnings.add(typeDotName);
-    var childTypenames = [];
-    if (!Array.isArray(existing) &&
-        !Array.isArray(incoming)) {
-        [existing, incoming].forEach(function (child) {
-            var typename = store.getFieldValue(child, "__typename");
-            if (typeof typename === "string" &&
-                !childTypenames.includes(typename)) {
-                childTypenames.push(typename);
-            }
-        });
-    }
-    __DEV__ && globals.invariant.warn("Cache data may be lost when replacing the " + fieldName + " field of a " + parentType + " object.\n\nTo address this problem (which is not a bug in Apollo Client), " + (childTypenames.length
-        ? "either ensure all objects of type " +
-            childTypenames.join(" and ") + " have an ID or a custom merge function, or "
-        : "") + "define a custom merge function for the " + typeDotName + " field, so InMemoryCache can safely merge these objects:\n\n  existing: " + JSON.stringify(existing).slice(0, 1000) + "\n  incoming: " + JSON.stringify(incoming).slice(0, 1000) + "\n\nFor more information about these options, please refer to the documentation:\n\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\n");
-}
-
-var cacheSlot = new context.Slot();
-var cacheInfoMap = new WeakMap();
-function getCacheInfo(cache) {
-    var info = cacheInfoMap.get(cache);
-    if (!info) {
-        cacheInfoMap.set(cache, info = {
-            vars: new Set,
-            dep: optimism.dep(),
-        });
-    }
-    return info;
-}
-function forgetCache(cache) {
-    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
-}
-function recallCache(cache) {
-    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
-}
-function makeVar(value) {
-    var caches = new Set();
-    var listeners = new Set();
-    var rv = function (newValue) {
-        if (arguments.length > 0) {
-            if (value !== newValue) {
-                value = newValue;
-                caches.forEach(function (cache) {
-                    getCacheInfo(cache).dep.dirty(rv);
-                    broadcast(cache);
-                });
-                var oldListeners = Array.from(listeners);
-                listeners.clear();
-                oldListeners.forEach(function (listener) { return listener(value); });
-            }
-        }
-        else {
-            var cache = cacheSlot.getValue();
-            if (cache) {
-                attach(cache);
-                getCacheInfo(cache).dep(rv);
-            }
-        }
-        return value;
-    };
-    rv.onNextChange = function (listener) {
-        listeners.add(listener);
-        return function () {
-            listeners.delete(listener);
-        };
-    };
-    var attach = rv.attachCache = function (cache) {
-        caches.add(cache);
-        getCacheInfo(cache).vars.add(rv);
-        return rv;
-    };
-    rv.forgetCache = function (cache) { return caches.delete(cache); };
-    return rv;
-}
-function broadcast(cache) {
-    if (cache.broadcastWatches) {
-        cache.broadcastWatches();
-    }
-}
-
-utilities.getStoreKeyName.setStringify(canonicalStringify);
-function argsFromFieldSpecifier(spec) {
-    return spec.args !== void 0 ? spec.args :
-        spec.field ? utilities.argumentsObjectFromField(spec.field, spec.variables) : null;
-}
-var nullKeyFieldsFn = function () { return void 0; };
-var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
-var mergeTrueFn = function (existing, incoming, _a) {
-    var mergeObjects = _a.mergeObjects;
-    return mergeObjects(existing, incoming);
-};
-var mergeFalseFn = function (_, incoming) { return incoming; };
-var Policies = (function () {
-    function Policies(config) {
-        this.config = config;
-        this.typePolicies = Object.create(null);
-        this.toBeAdded = Object.create(null);
-        this.supertypeMap = new Map();
-        this.fuzzySubtypes = new Map();
-        this.rootIdsByTypename = Object.create(null);
-        this.rootTypenamesById = Object.create(null);
-        this.usingPossibleTypes = false;
-        this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);
-        this.cache = this.config.cache;
-        this.setRootTypename("Query");
-        this.setRootTypename("Mutation");
-        this.setRootTypename("Subscription");
-        if (config.possibleTypes) {
-            this.addPossibleTypes(config.possibleTypes);
-        }
-        if (config.typePolicies) {
-            this.addTypePolicies(config.typePolicies);
-        }
-    }
-    Policies.prototype.identify = function (object, selectionSet, fragmentMap) {
-        var typename = selectionSet && fragmentMap
-            ? utilities.getTypenameFromResult(object, selectionSet, fragmentMap)
-            : object.__typename;
-        if (typename === this.rootTypenamesById.ROOT_QUERY) {
-            return ["ROOT_QUERY"];
-        }
-        var context = {
-            typename: typename,
-            selectionSet: selectionSet,
-            fragmentMap: fragmentMap,
-        };
-        var id;
-        var policy = typename && this.getTypePolicy(typename);
-        var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;
-        while (keyFn) {
-            var specifierOrId = keyFn(object, context);
-            if (Array.isArray(specifierOrId)) {
-                keyFn = keyFieldsFnFromSpecifier(specifierOrId);
-            }
-            else {
-                id = specifierOrId;
-                break;
-            }
-        }
-        id = id ? String(id) : void 0;
-        return context.keyObject ? [id, context.keyObject] : [id];
-    };
-    Policies.prototype.addTypePolicies = function (typePolicies) {
+    Policies.prototype.addTypePolicies = function (typePolicies) {
         var _this = this;
         Object.keys(typePolicies).forEach(function (typename) {
             var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = tslib.__rest(_a, ["queryType", "mutationType", "subscriptionType"]);
@@ -1482,7 +1314,7 @@ var Policies = (function () {
         var rootId = "ROOT_" + which.toUpperCase();
         var old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            __DEV__ ? globals.invariant(!old || old === which, "Cannot change root " + which + " __typename more than once") : globals.invariant(!old || old === which, 2);
+            __DEV__ ? globals.invariant(!old || old === which, "Cannot change root ".concat(which, " __typename more than once")) : globals.invariant(!old || old === which, 3);
             if (old)
                 delete this.rootIdsByTypename[old];
             this.rootIdsByTypename[typename] = rootId;
@@ -1566,7 +1398,7 @@ var Policies = (function () {
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && globals.invariant.warn("Inferring subtype " + typename + " of supertype " + supertype);
+                            __DEV__ && globals.invariant.warn("Inferring subtype ".concat(typename, " of supertype ").concat(supertype));
                         }
                         typenameSupertypeSet.add(supertype);
                     }
@@ -1654,6 +1486,10 @@ var Policies = (function () {
         }
         return existing;
     };
+    Policies.prototype.getReadFunction = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName, false);
+        return policy && policy.read;
+    };
     Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
         var policy = this.getFieldPolicy(parentTypename, fieldName, false);
         var merge = policy && policy.merge;
@@ -1694,144 +1530,456 @@ function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, contex
         storage: storage,
         cache: policies.cache,
         canRead: canRead,
-        readField: function (fieldNameOrOptions, from) {
-            var options;
-            if (typeof fieldNameOrOptions === "string") {
-                options = {
-                    fieldName: fieldNameOrOptions,
-                    from: arguments.length > 1 ? from : objectOrReference,
+        readField: function () {
+            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, context), context);
+        },
+        mergeObjects: makeMergeObjectsFunction(context.store),
+    };
+}
+function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
+    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
+    var options;
+    if (typeof fieldNameOrOptions === "string") {
+        options = {
+            fieldName: fieldNameOrOptions,
+            from: argc > 1 ? from : objectOrReference,
+        };
+    }
+    else {
+        options = tslib.__assign({}, fieldNameOrOptions);
+        if (!hasOwn.call(options, "from")) {
+            options.from = objectOrReference;
+        }
+    }
+    if (__DEV__ && options.from === void 0) {
+        __DEV__ && globals.invariant.warn("Undefined 'from' passed to readField with arguments ".concat(utilities.stringifyForDisplay(Array.from(readFieldArgs))));
+    }
+    if (void 0 === options.variables) {
+        options.variables = variables;
+    }
+    return options;
+}
+function makeMergeObjectsFunction(store) {
+    return function mergeObjects(existing, incoming) {
+        if (Array.isArray(existing) || Array.isArray(incoming)) {
+            throw __DEV__ ? new globals.InvariantError("Cannot automatically merge arrays") : new globals.InvariantError(4);
+        }
+        if (utilities.isNonNullObject(existing) &&
+            utilities.isNonNullObject(incoming)) {
+            var eType = store.getFieldValue(existing, "__typename");
+            var iType = store.getFieldValue(incoming, "__typename");
+            var typesDiffer = eType && iType && eType !== iType;
+            if (typesDiffer) {
+                return incoming;
+            }
+            if (utilities.isReference(existing) &&
+                storeValueIsStoreObject(incoming)) {
+                store.merge(existing.__ref, incoming);
+                return existing;
+            }
+            if (storeValueIsStoreObject(existing) &&
+                utilities.isReference(incoming)) {
+                store.merge(existing, incoming.__ref);
+                return incoming;
+            }
+            if (storeValueIsStoreObject(existing) &&
+                storeValueIsStoreObject(incoming)) {
+                return tslib.__assign(tslib.__assign({}, existing), incoming);
+            }
+        }
+        return incoming;
+    };
+}
+
+function getContextFlavor(context, clientOnly, deferred) {
+    var key = "".concat(clientOnly).concat(deferred);
+    var flavored = context.flavors.get(key);
+    if (!flavored) {
+        context.flavors.set(key, flavored = (context.clientOnly === clientOnly &&
+            context.deferred === deferred) ? context : tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred }));
+    }
+    return flavored;
+}
+var StoreWriter = (function () {
+    function StoreWriter(cache, reader) {
+        this.cache = cache;
+        this.reader = reader;
+    }
+    StoreWriter.prototype.writeToStore = function (store, _a) {
+        var _this = this;
+        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
+        var operationDefinition = utilities.getOperationDefinition(query);
+        var merger = makeProcessedFieldsMerger();
+        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(operationDefinition)), variables);
+        var context = {
+            store: store,
+            written: Object.create(null),
+            merge: function (existing, incoming) {
+                return merger.merge(existing, incoming);
+            },
+            variables: variables,
+            varString: canonicalStringify(variables),
+            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
+            overwrite: !!overwrite,
+            incomingById: new Map,
+            clientOnly: false,
+            deferred: false,
+            flavors: new Map,
+        };
+        var ref = this.processSelectionSet({
+            result: result || Object.create(null),
+            dataId: dataId,
+            selectionSet: operationDefinition.selectionSet,
+            mergeTree: { map: new Map },
+            context: context,
+        });
+        if (!utilities.isReference(ref)) {
+            throw __DEV__ ? new globals.InvariantError("Could not identify object ".concat(JSON.stringify(result))) : new globals.InvariantError(6);
+        }
+        context.incomingById.forEach(function (_a, dataId) {
+            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
+            var entityRef = utilities.makeReference(dataId);
+            if (mergeTree && mergeTree.map.size) {
+                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
+                if (utilities.isReference(applied)) {
+                    return;
+                }
+                storeObject = applied;
+            }
+            if (__DEV__ && !context.overwrite) {
+                var fieldsWithSelectionSets_1 = Object.create(null);
+                fieldNodeSet.forEach(function (field) {
+                    if (field.selectionSet) {
+                        fieldsWithSelectionSets_1[field.name.value] = true;
+                    }
+                });
+                var hasSelectionSet_1 = function (storeFieldName) {
+                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] === true;
+                };
+                var hasMergeFunction_1 = function (storeFieldName) {
+                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
+                    return Boolean(childTree && childTree.info && childTree.info.merge);
                 };
+                Object.keys(storeObject).forEach(function (storeFieldName) {
+                    if (hasSelectionSet_1(storeFieldName) &&
+                        !hasMergeFunction_1(storeFieldName)) {
+                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
+                    }
+                });
             }
-            else if (utilities.isNonNullObject(fieldNameOrOptions)) {
-                options = tslib.__assign({}, fieldNameOrOptions);
-                if (!hasOwn.call(fieldNameOrOptions, "from")) {
-                    options.from = objectOrReference;
+            store.merge(dataId, storeObject);
+        });
+        store.retain(ref.__ref);
+        return ref;
+    };
+    StoreWriter.prototype.processSelectionSet = function (_a) {
+        var _this = this;
+        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;
+        var policies = this.cache.policies;
+        var incoming = Object.create(null);
+        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
+            utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
+            (dataId && context.store.get(dataId, "__typename"));
+        if ("string" === typeof typename) {
+            incoming.__typename = typename;
+        }
+        var readField = function () {
+            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
+            if (utilities.isReference(options.from)) {
+                var info = context.incomingById.get(options.from.__ref);
+                if (info) {
+                    var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);
+                    if (result_1 !== void 0) {
+                        return result_1;
+                    }
                 }
             }
-            else {
-                __DEV__ && globals.invariant.warn("Unexpected readField arguments: " + utilities.stringifyForDisplay(Array.from(arguments)));
-                return;
+            return policies.readField(options, context);
+        };
+        var fieldNodeSet = new Set();
+        this.flattenFields(selectionSet, result, context, typename).forEach(function (context, field) {
+            var _a;
+            var resultFieldKey = utilities.resultKeyNameFromField(field);
+            var value = result[resultFieldKey];
+            fieldNodeSet.add(field);
+            if (value !== void 0) {
+                var storeFieldName = policies.getStoreFieldName({
+                    typename: typename,
+                    fieldName: field.name.value,
+                    field: field,
+                    variables: context.variables,
+                });
+                var childTree = getChildMergeTree(mergeTree, storeFieldName);
+                var incomingValue = _this.processFieldValue(value, field, field.selectionSet
+                    ? getContextFlavor(context, false, false)
+                    : context, childTree);
+                var childTypename = void 0;
+                if (field.selectionSet &&
+                    (utilities.isReference(incomingValue) ||
+                        storeValueIsStoreObject(incomingValue))) {
+                    childTypename = readField("__typename", incomingValue);
+                }
+                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
+                if (merge) {
+                    childTree.info = {
+                        field: field,
+                        typename: typename,
+                        merge: merge,
+                    };
+                }
+                else {
+                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);
+                }
+                incoming = context.merge(incoming, (_a = {},
+                    _a[storeFieldName] = incomingValue,
+                    _a));
             }
-            if (__DEV__ && options.from === void 0) {
-                __DEV__ && globals.invariant.warn("Undefined 'from' passed to readField with arguments " + utilities.stringifyForDisplay(Array.from(arguments)));
+            else if (__DEV__ &&
+                !context.clientOnly &&
+                !context.deferred &&
+                !utilities.addTypenameToDocument.added(field) &&
+                !policies.getReadFunction(typename, field.name.value)) {
+                __DEV__ && globals.invariant.error("Missing field '".concat(utilities.resultKeyNameFromField(field), "' while writing result ").concat(JSON.stringify(result, null, 2)).substring(0, 1000));
             }
-            if (void 0 === options.variables) {
-                options.variables = variables;
+        });
+        try {
+            var _b = policies.identify(result, {
+                typename: typename,
+                selectionSet: selectionSet,
+                fragmentMap: context.fragmentMap,
+                storeObject: incoming,
+                readField: readField,
+            }), id = _b[0], keyObject = _b[1];
+            dataId = dataId || id;
+            if (keyObject) {
+                incoming = context.merge(incoming, keyObject);
             }
-            return policies.readField(options, context);
-        },
-        mergeObjects: makeMergeObjectsFunction(context.store),
-    };
-}
-function makeMergeObjectsFunction(store) {
-    return function mergeObjects(existing, incoming) {
-        if (Array.isArray(existing) || Array.isArray(incoming)) {
-            throw __DEV__ ? new globals.InvariantError("Cannot automatically merge arrays") : new globals.InvariantError(3);
         }
-        if (utilities.isNonNullObject(existing) &&
-            utilities.isNonNullObject(incoming)) {
-            var eType = store.getFieldValue(existing, "__typename");
-            var iType = store.getFieldValue(incoming, "__typename");
-            var typesDiffer = eType && iType && eType !== iType;
-            if (typesDiffer) {
-                return incoming;
-            }
-            if (utilities.isReference(existing) &&
-                storeValueIsStoreObject(incoming)) {
-                store.merge(existing.__ref, incoming);
-                return existing;
+        catch (e) {
+            if (!dataId)
+                throw e;
+        }
+        if ("string" === typeof dataId) {
+            var dataRef = utilities.makeReference(dataId);
+            var sets = context.written[dataId] || (context.written[dataId] = []);
+            if (sets.indexOf(selectionSet) >= 0)
+                return dataRef;
+            sets.push(selectionSet);
+            if (this.reader && this.reader.isFresh(result, dataRef, selectionSet, context)) {
+                return dataRef;
             }
-            if (storeValueIsStoreObject(existing) &&
-                utilities.isReference(incoming)) {
-                store.merge(existing, incoming.__ref);
-                return incoming;
+            var previous_1 = context.incomingById.get(dataId);
+            if (previous_1) {
+                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
+                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
+                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
             }
-            if (storeValueIsStoreObject(existing) &&
-                storeValueIsStoreObject(incoming)) {
-                return tslib.__assign(tslib.__assign({}, existing), incoming);
+            else {
+                context.incomingById.set(dataId, {
+                    storeObject: incoming,
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
+                    fieldNodeSet: fieldNodeSet,
+                });
             }
+            return dataRef;
         }
         return incoming;
     };
-}
-function keyArgsFnFromSpecifier(specifier) {
-    return function (args, context) {
-        return args ? context.fieldName + ":" + JSON.stringify(computeKeyObject(args, specifier, false)) : context.fieldName;
-    };
-}
-function keyFieldsFnFromSpecifier(specifier) {
-    var trie$1 = new trie.Trie(utilities.canUseWeakMap);
-    return function (object, context) {
-        var aliasMap;
-        if (context.selectionSet && context.fragmentMap) {
-            var info = trie$1.lookupArray([
-                context.selectionSet,
-                context.fragmentMap,
-            ]);
-            aliasMap = info.aliasMap || (info.aliasMap = makeAliasMap(context.selectionSet, context.fragmentMap));
-        }
-        var keyObject = context.keyObject =
-            computeKeyObject(object, specifier, true, aliasMap);
-        return context.typename + ":" + JSON.stringify(keyObject);
+    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
+        var _this = this;
+        if (!field.selectionSet || value === null) {
+            return __DEV__ ? utilities.cloneDeep(value) : value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(function (item, i) {
+                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
+                maybeRecycleChildMergeTree(mergeTree, i);
+                return value;
+            });
+        }
+        return this.processSelectionSet({
+            result: value,
+            selectionSet: field.selectionSet,
+            context: context,
+            mergeTree: mergeTree,
+        });
     };
-}
-function makeAliasMap(selectionSet, fragmentMap) {
-    var map = Object.create(null);
-    var workQueue = new Set([selectionSet]);
-    workQueue.forEach(function (selectionSet) {
-        selectionSet.selections.forEach(function (selection) {
-            if (utilities.isField(selection)) {
-                if (selection.alias) {
-                    var responseKey = selection.alias.value;
-                    var storeKey = selection.name.value;
-                    if (storeKey !== responseKey) {
-                        var aliases = map.aliases || (map.aliases = Object.create(null));
-                        aliases[storeKey] = responseKey;
+    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
+        if (typename === void 0) { typename = utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap); }
+        var fieldMap = new Map();
+        var policies = this.cache.policies;
+        var limitingTrie = new trie.Trie(false);
+        (function flatten(selectionSet, inheritedContext) {
+            var visitedNode = limitingTrie.lookup(selectionSet, inheritedContext.clientOnly, inheritedContext.deferred);
+            if (visitedNode.visited)
+                return;
+            visitedNode.visited = true;
+            selectionSet.selections.forEach(function (selection) {
+                if (!utilities.shouldInclude(selection, context.variables))
+                    return;
+                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
+                if (!(clientOnly && deferred) &&
+                    utilities.isNonEmptyArray(selection.directives)) {
+                    selection.directives.forEach(function (dir) {
+                        var name = dir.name.value;
+                        if (name === "client")
+                            clientOnly = true;
+                        if (name === "defer") {
+                            var args = utilities.argumentsObjectFromField(dir, context.variables);
+                            if (!args || args.if !== false) {
+                                deferred = true;
+                            }
+                        }
+                    });
+                }
+                if (utilities.isField(selection)) {
+                    var existing = fieldMap.get(selection);
+                    if (existing) {
+                        clientOnly = clientOnly && existing.clientOnly;
+                        deferred = deferred && existing.deferred;
                     }
+                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
                 }
-                if (selection.selectionSet) {
-                    var subsets = map.subsets || (map.subsets = Object.create(null));
-                    subsets[selection.name.value] =
-                        makeAliasMap(selection.selectionSet, fragmentMap);
+                else {
+                    var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
+                    if (fragment &&
+                        policies.fragmentMatches(fragment, typename, result, context.variables)) {
+                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
+                    }
                 }
+            });
+        })(selectionSet, context);
+        return fieldMap;
+    };
+    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
+        var _a;
+        var _this = this;
+        if (mergeTree.map.size && !utilities.isReference(incoming)) {
+            var e_1 = (!Array.isArray(incoming) &&
+                (utilities.isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;
+            var i_1 = incoming;
+            if (e_1 && !getStorageArgs) {
+                getStorageArgs = [utilities.isReference(e_1) ? e_1.__ref : e_1];
             }
-            else {
-                var fragment = utilities.getFragmentFromSelection(selection, fragmentMap);
-                if (fragment) {
-                    workQueue.add(fragment.selectionSet);
+            var changedFields_1;
+            var getValue_1 = function (from, name) {
+                return Array.isArray(from)
+                    ? (typeof name === "number" ? from[name] : void 0)
+                    : context.store.getFieldValue(from, String(name));
+            };
+            mergeTree.map.forEach(function (childTree, storeFieldName) {
+                var eVal = getValue_1(e_1, storeFieldName);
+                var iVal = getValue_1(i_1, storeFieldName);
+                if (void 0 === iVal)
+                    return;
+                if (getStorageArgs) {
+                    getStorageArgs.push(storeFieldName);
+                }
+                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
+                if (aVal !== iVal) {
+                    changedFields_1 = changedFields_1 || new Map;
+                    changedFields_1.set(storeFieldName, aVal);
+                }
+                if (getStorageArgs) {
+                    globals.invariant(getStorageArgs.pop() === storeFieldName);
                 }
+            });
+            if (changedFields_1) {
+                incoming = (Array.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
+                changedFields_1.forEach(function (value, name) {
+                    incoming[name] = value;
+                });
             }
+        }
+        if (mergeTree.info) {
+            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
+        }
+        return incoming;
+    };
+    return StoreWriter;
+}());
+var emptyMergeTreePool = [];
+function getChildMergeTree(_a, name) {
+    var map = _a.map;
+    if (!map.has(name)) {
+        map.set(name, emptyMergeTreePool.pop() || { map: new Map });
+    }
+    return map.get(name);
+}
+function mergeMergeTrees(left, right) {
+    if (left === right || !right || mergeTreeIsEmpty(right))
+        return left;
+    if (!left || mergeTreeIsEmpty(left))
+        return right;
+    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
+    var needToMergeMaps = left.map.size && right.map.size;
+    var map = needToMergeMaps ? new Map :
+        left.map.size ? left.map : right.map;
+    var merged = { info: info, map: map };
+    if (needToMergeMaps) {
+        var remainingRightKeys_1 = new Set(right.map.keys());
+        left.map.forEach(function (leftTree, key) {
+            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
+            remainingRightKeys_1.delete(key);
         });
-    });
-    return map;
+        remainingRightKeys_1.forEach(function (key) {
+            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
+        });
+    }
+    return merged;
 }
-function computeKeyObject(response, specifier, strict, aliasMap) {
-    var keyObj = Object.create(null);
-    var lastResponseKey;
-    var lastActualKey;
-    specifier.forEach(function (s) {
-        if (Array.isArray(s)) {
-            if (typeof lastActualKey === "string" &&
-                typeof lastResponseKey === "string") {
-                var subsets = aliasMap && aliasMap.subsets;
-                var subset = subsets && subsets[lastActualKey];
-                keyObj[lastActualKey] =
-                    computeKeyObject(response[lastResponseKey], s, strict, subset);
-            }
-        }
-        else {
-            var aliases = aliasMap && aliasMap.aliases;
-            var responseName = aliases && aliases[s] || s;
-            if (hasOwn.call(response, responseName)) {
-                keyObj[lastActualKey = s] = response[lastResponseKey = responseName];
-            }
-            else {
-                __DEV__ ? globals.invariant(!strict, "Missing field '" + responseName + "' while computing key fields") : globals.invariant(!strict, 4);
-                lastResponseKey = lastActualKey = void 0;
+function mergeTreeIsEmpty(tree) {
+    return !tree || !(tree.info || tree.map.size);
+}
+function maybeRecycleChildMergeTree(_a, name) {
+    var map = _a.map;
+    var childTree = map.get(name);
+    if (childTree && mergeTreeIsEmpty(childTree)) {
+        emptyMergeTreePool.push(childTree);
+        map.delete(name);
+    }
+}
+var warnings = new Set();
+function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
+    var getChild = function (objOrRef) {
+        var child = store.getFieldValue(objOrRef, storeFieldName);
+        return typeof child === "object" && child;
+    };
+    var existing = getChild(existingRef);
+    if (!existing)
+        return;
+    var incoming = getChild(incomingObj);
+    if (!incoming)
+        return;
+    if (utilities.isReference(existing))
+        return;
+    if (equality.equal(existing, incoming))
+        return;
+    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
+        return;
+    }
+    var parentType = store.getFieldValue(existingRef, "__typename") ||
+        store.getFieldValue(incomingObj, "__typename");
+    var fieldName = fieldNameFromStoreName(storeFieldName);
+    var typeDotName = "".concat(parentType, ".").concat(fieldName);
+    if (warnings.has(typeDotName))
+        return;
+    warnings.add(typeDotName);
+    var childTypenames = [];
+    if (!Array.isArray(existing) &&
+        !Array.isArray(incoming)) {
+        [existing, incoming].forEach(function (child) {
+            var typename = store.getFieldValue(child, "__typename");
+            if (typeof typename === "string" &&
+                !childTypenames.includes(typename)) {
+                childTypenames.push(typename);
             }
-        }
-    });
-    return keyObj;
+        });
+    }
+    __DEV__ && globals.invariant.warn("Cache data may be lost when replacing the ".concat(fieldName, " field of a ").concat(parentType, " object.\n\nTo address this problem (which is not a bug in Apollo Client), ").concat(childTypenames.length
+        ? "either ensure all objects of type " +
+            childTypenames.join(" and ") + " have an ID or a custom merge function, or "
+        : "", "define a custom merge function for the ").concat(typeDotName, " field, so InMemoryCache can safely merge these objects:\n\n  existing: ").concat(JSON.stringify(existing).slice(0, 1000), "\n  incoming: ").concat(JSON.stringify(incoming).slice(0, 1000), "\n\nFor more information about these options, please refer to the documentation:\n\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\n"));
 }
 
 var InMemoryCache = (function (_super) {
@@ -1980,8 +2128,14 @@ var InMemoryCache = (function (_super) {
         return (optimistic ? this.optimisticData : this.data).release(rootId);
     };
     InMemoryCache.prototype.identify = function (object) {
-        return utilities.isReference(object) ? object.__ref :
-            this.policies.identify(object)[0];
+        if (utilities.isReference(object))
+            return object.__ref;
+        try {
+            return this.policies.identify(object)[0];
+        }
+        catch (e) {
+            __DEV__ && globals.invariant.warn(e);
+        }
     };
     InMemoryCache.prototype.evict = function (options) {
         if (!options.id) {
@@ -2024,6 +2178,7 @@ var InMemoryCache = (function (_super) {
     InMemoryCache.prototype.batch = function (options) {
         var _this = this;
         var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
+        var updateResult;
         var perform = function (layer) {
             var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
             ++_this.txCount;
@@ -2031,7 +2186,7 @@ var InMemoryCache = (function (_super) {
                 _this.data = _this.optimisticData = layer;
             }
             try {
-                update(_this);
+                return updateResult = update(_this);
             }
             finally {
                 --_this.txCount;
@@ -2073,6 +2228,7 @@ var InMemoryCache = (function (_super) {
         else {
             this.broadcastWatches(options);
         }
+        return updateResult;
     };
     InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
         return this.batch({
@@ -2129,4 +2285,4 @@ exports.canonicalStringify = canonicalStringify;
 exports.defaultDataIdFromObject = defaultDataIdFromObject;
 exports.fieldNameFromStoreName = fieldNameFromStoreName;
 exports.makeVar = makeVar;
-//# sourceMappingURL=cache.cjs.js.map
+//# sourceMappingURL=cache.cjs.map