@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.1

package/cache/inmemory/inMemoryCache.js

@@ -1,49 +1,52 @@
-import { equal } from "@wry/equality";
+import { __assign, __extends } from "tslib";
+import { invariant } from "../../utilities/globals/index.js";
+// Make builtins like Map and Set safe to use with non-extensible objects.
+import "./fixPolyfills.js";
 import { wrap } from "optimism";
-import { addTypenameToDocument, cacheSizes, canonicalStringify, DocumentTransform, isReference, print, } from "@apollo/client/utilities";
-import { __DEV__ } from "@apollo/client/utilities/environment";
-import { getInMemoryCacheMemoryInternals } from "@apollo/client/utilities/internal";
-import { invariant } from "@apollo/client/utilities/invariant";
+import { equal } from "@wry/equality";
 import { ApolloCache } from "../core/cache.js";
-import { EntityStore, supportsResultCaching } from "./entityStore.js";
-import { hasOwn, normalizeConfig } from "./helpers.js";
-import { Policies } from "./policies.js";
-import { forgetCache, makeVar, recallCache } from "./reactiveVars.js";
+import { MissingFieldError } from "../core/types/common.js";
+import { addTypenameToDocument, isReference, DocumentTransform, canonicalStringify, print, cacheSizes, } from "../../utilities/index.js";
 import { StoreReader } from "./readFromStore.js";
 import { StoreWriter } from "./writeToStore.js";
-export class InMemoryCache extends ApolloCache {
-    data;
-    optimisticData;
-    config;
-    watches = new Set();
-    storeReader;
-    storeWriter;
-    addTypenameTransform = new DocumentTransform(addTypenameToDocument);
-    maybeBroadcastWatch;
-    // Override the default value, since InMemoryCache result objects are frozen
-    // in development and expected to remain logically immutable in production.
-    assumeImmutableResults = true;
-    // Dynamically imported code can augment existing typePolicies or
-    // possibleTypes by calling cache.policies.addTypePolicies or
-    // cache.policies.addPossibletypes.
-    policies;
-    makeVar = makeVar;
-    constructor(config = {}) {
-        super();
-        this.config = normalizeConfig(config);
-        this.policies = new Policies({
-            cache: this,
-            dataIdFromObject: this.config.dataIdFromObject,
-            possibleTypes: this.config.possibleTypes,
-            typePolicies: this.config.typePolicies,
+import { EntityStore, supportsResultCaching } from "./entityStore.js";
+import { makeVar, forgetCache, recallCache } from "./reactiveVars.js";
+import { Policies } from "./policies.js";
+import { hasOwn, normalizeConfig, shouldCanonizeResults } from "./helpers.js";
+import { getInMemoryCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
+import { muteDeprecations, warnRemovedOption, } from "../../utilities/deprecation/index.js";
+var InMemoryCache = /** @class */ (function (_super) {
+    __extends(InMemoryCache, _super);
+    function InMemoryCache(config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this) || this;
+        _this.watches = new Set();
+        _this.addTypenameTransform = new DocumentTransform(addTypenameToDocument);
+        // Override the default value, since InMemoryCache result objects are frozen
+        // in development and expected to remain logically immutable in production.
+        _this.assumeImmutableResults = true;
+        _this.makeVar = makeVar;
+        _this.txCount = 0;
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(config, "addTypename", "InMemoryCache", "Please remove the `addTypename` option when initializing `InMemoryCache`.");
+            warnRemovedOption(config, "canonizeResults", "InMemoryCache", "Please remove the `canonizeResults` option when initializing `InMemoryCache`.");
+        }
+        _this.config = normalizeConfig(config);
+        _this.addTypename = !!_this.config.addTypename;
+        _this.policies = new Policies({
+            cache: _this,
+            dataIdFromObject: _this.config.dataIdFromObject,
+            possibleTypes: _this.config.possibleTypes,
+            typePolicies: _this.config.typePolicies,
         });
-        this.init();
+        _this.init();
+        return _this;
     }
-    init() {
+    InMemoryCache.prototype.init = function () {
         // Passing { resultCaching: false } in the InMemoryCache constructor options
         // will completely disable dependency tracking, which will improve memory
         // usage but worsen the performance of repeated reads.
-        const rootStore = (this.data = new EntityStore.Root({
+        var rootStore = (this.data = new EntityStore.Root({
             policies: this.policies,
             resultCaching: this.config.resultCaching,
         }));
@@ -54,29 +57,36 @@ export class InMemoryCache extends ApolloCache {
         // original this.data cache object.
         this.optimisticData = rootStore.stump;
         this.resetResultCache();
-    }
-    resetResultCache() {
-        const { fragments } = this.config;
+    };
+    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
+        var _this = this;
+        var previousReader = this.storeReader;
+        var fragments = this.config.fragments;
+        this.addTypenameTransform.resetCache();
+        fragments === null || fragments === void 0 ? void 0 : fragments.resetCaches();
         // The StoreWriter is mostly stateless and so doesn't really need to be
         // reset, but it does need to have its writer.storeReader reference updated,
         // so it's simpler to update this.storeWriter as well.
         this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({
             cache: this,
+            addTypename: this.addTypename,
             resultCacheMaxSize: this.config.resultCacheMaxSize,
-            fragments,
+            canonizeResults: shouldCanonizeResults(this.config),
+            canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),
+            fragments: fragments,
         })), fragments);
-        this.maybeBroadcastWatch = wrap((c, options) => {
-            return this.broadcastWatch(c, options);
+        this.maybeBroadcastWatch = wrap(function (c, options) {
+            return _this.broadcastWatch(c, options);
         }, {
             max: this.config.resultCacheMaxSize ||
                 cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
                 5000 /* defaultCacheSizes["inMemoryCache.maybeBroadcastWatch"] */,
-            makeCacheKey: (c) => {
+            makeCacheKey: function (c) {
                 // Return a cache key (thus enabling result caching) only if we're
                 // currently using a data store that can track cache dependencies.
-                const store = c.optimistic ? this.optimisticData : this.data;
+                var store = c.optimistic ? _this.optimisticData : _this.data;
                 if (supportsResultCaching(store)) {
-                    const { optimistic, id, variables } = c;
+                    var optimistic = c.optimistic, id = c.id, variables = c.variables;
                     return store.makeCacheKey(c.query, 
                     // Different watches can have the same query, optimistic
                     // status, rootId, and variables, but if their callbacks are
@@ -84,16 +94,18 @@ export class InMemoryCache extends ApolloCache {
                     // each distinct callback. The easiest way to achieve that
                     // separation is to include c.callback in the cache key for
                     // maybeBroadcastWatch calls. See issue #5733.
-                    c.callback, canonicalStringify({ optimistic, id, variables }));
+                    c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));
                 }
             },
         });
         // Since we have thrown away all the cached functions that depend on the
         // CacheGroup dependencies maintained by EntityStore, we should also reset
         // all CacheGroup dependency information.
-        new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());
-    }
-    restore(data) {
+        new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {
+            return group.resetCaching();
+        });
+    };
+    InMemoryCache.prototype.restore = function (data) {
         this.init();
         // Since calling this.init() discards/replaces the entire StoreReader, along
         // with the result caches it maintains, this.data.replace(data) won't have
@@ -101,12 +113,16 @@ export class InMemoryCache extends ApolloCache {
         if (data)
             this.data.replace(data);
         return this;
-    }
-    extract(optimistic = false) {
+    };
+    InMemoryCache.prototype.extract = function (optimistic) {
+        if (optimistic === void 0) { optimistic = false; }
         return (optimistic ? this.optimisticData : this.data).extract();
-    }
-    read(options) {
-        const { 
+    };
+    InMemoryCache.prototype.read = function (options) {
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options, "canonizeResults", "cache.read");
+        }
+        var 
         // Since read returns data or null, without any additional metadata
         // about whether/where there might have been missing fields, the
         // default behavior cannot be returnPartialData = true (like it is
@@ -114,15 +130,31 @@ export class InMemoryCache extends ApolloCache {
         // integrity of the T in the return type. However, partial data may
         // be useful in some cases, so returnPartialData:true may be
         // specified explicitly.
-        returnPartialData = false, } = options;
-        return this.storeReader.diffQueryAgainstStore({
-            ...options,
-            store: options.optimistic ? this.optimisticData : this.data,
-            config: this.config,
-            returnPartialData,
-        }).result;
-    }
-    write(options) {
+        _a = options.returnPartialData, 
+        // Since read returns data or null, without any additional metadata
+        // about whether/where there might have been missing fields, the
+        // default behavior cannot be returnPartialData = true (like it is
+        // for the diff method), since defaulting to true would violate the
+        // integrity of the T in the return type. However, partial data may
+        // be useful in some cases, so returnPartialData:true may be
+        // specified explicitly.
+        returnPartialData = _a === void 0 ? false : _a;
+        try {
+            return (this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);
+        }
+        catch (e) {
+            if (e instanceof MissingFieldError) {
+                // Swallow MissingFieldError and return null, so callers do not need to
+                // worry about catching "normal" exceptions resulting from incomplete
+                // cache data. Unexpected errors will be re-thrown. If you need more
+                // information about which fields were missing, use cache.diff instead,
+                // and examine diffResult.missing.
+                return null;
+            }
+            throw e;
+        }
+    };
+    InMemoryCache.prototype.write = function (options) {
         try {
             ++this.txCount;
             return this.storeWriter.writeToStore(this.data, options);
@@ -132,8 +164,8 @@ export class InMemoryCache extends ApolloCache {
                 this.broadcastWatches();
             }
         }
-    }
-    modify(options) {
+    };
+    InMemoryCache.prototype.modify = function (options) {
         if (hasOwn.call(options, "id") && !options.id) {
             // To my knowledge, TypeScript does not currently provide a way to
             // enforce that an optional property?:type must *not* be undefined
@@ -146,7 +178,7 @@ export class InMemoryCache extends ApolloCache {
             // that nothing was modified.
             return false;
         }
-        const store = ((options.optimistic) // Defaults to false.
+        var store = ((options.optimistic) // Defaults to false.
         ) ?
             this.optimisticData
             : this.data;
@@ -159,16 +191,15 @@ export class InMemoryCache extends ApolloCache {
                 this.broadcastWatches();
             }
         }
-    }
-    diff(options) {
-        return this.storeReader.diffQueryAgainstStore({
-            ...options,
-            store: options.optimistic ? this.optimisticData : this.data,
-            rootId: options.id || "ROOT_QUERY",
-            config: this.config,
-        });
-    }
-    watch(watch) {
+    };
+    InMemoryCache.prototype.diff = function (options) {
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options, "canonizeResults", "cache.diff");
+        }
+        return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || "ROOT_QUERY", config: this.config }));
+    };
+    InMemoryCache.prototype.watch = function (watch) {
+        var _this = this;
         if (!this.watches.size) {
             // In case we previously called forgetCache(this) because
             // this.watches became empty (see below), reattach this cache to any
@@ -186,30 +217,36 @@ export class InMemoryCache extends ApolloCache {
         if (watch.immediate) {
             this.maybeBroadcastWatch(watch);
         }
-        return () => {
+        return function () {
             // Once we remove the last watch from this.watches, cache.broadcastWatches
             // no longer does anything, so we preemptively tell the reactive variable
             // system to exclude this cache from future broadcasts.
-            if (this.watches.delete(watch) && !this.watches.size) {
-                forgetCache(this);
+            if (_this.watches.delete(watch) && !_this.watches.size) {
+                forgetCache(_this);
             }
             // Remove this watch from the LRU cache managed by the
             // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory
             // leaks involving the closure of watch.callback.
-            this.maybeBroadcastWatch.forget(watch);
+            _this.maybeBroadcastWatch.forget(watch);
         };
-    }
-    gc(options) {
+    };
+    InMemoryCache.prototype.gc = function (options) {
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options || {}, "resetResultIdentities", "cache.gc", "First ensure all usages of `canonizeResults` are removed, then remove this option.");
+        }
         canonicalStringify.reset();
         print.reset();
-        this.addTypenameTransform.resetCache();
-        this.config.fragments?.resetCaches();
-        const ids = this.optimisticData.gc();
-        if (options && !this.txCount && options.resetResultCache) {
-            this.resetResultCache();
+        var ids = this.optimisticData.gc();
+        if (options && !this.txCount) {
+            if (options.resetResultCache) {
+                this.resetResultCache(options.resetResultIdentities);
+            }
+            else if (options.resetResultIdentities) {
+                this.storeReader.resetCanon();
+            }
         }
         return ids;
-    }
+    };
     // Call this method to ensure the given root ID remains in the cache after
     // garbage collection, along with its transitive child entities. Note that
     // the cache automatically retains all directly written entities. By default,
@@ -217,41 +254,41 @@ export class InMemoryCache extends ApolloCache {
     // for the optimistic argument if you would prefer for the retainment to be
     // discarded when the top-most optimistic layer is removed. Returns the
     // resulting (non-negative) retainment count.
-    retain(rootId, optimistic) {
+    InMemoryCache.prototype.retain = function (rootId, optimistic) {
         return (optimistic ? this.optimisticData : this.data).retain(rootId);
-    }
+    };
     // Call this method to undo the effect of the retain method, above. Once the
     // retainment count falls to zero, the given ID will no longer be preserved
     // during garbage collection, though it may still be preserved by other safe
     // entities that refer to it. Returns the resulting (non-negative) retainment
     // count, in case that's useful.
-    release(rootId, optimistic) {
+    InMemoryCache.prototype.release = function (rootId, optimistic) {
         return (optimistic ? this.optimisticData : this.data).release(rootId);
-    }
+    };
     // Returns the canonical ID for a given StoreObject, obeying typePolicies
     // and keyFields (and dataIdFromObject, if you still use that). At minimum,
     // the object must contain a __typename and any primary key fields required
     // to identify entities of that type. If you pass a query result object, be
     // sure that none of the primary key fields have been renamed by aliasing.
     // If you pass a Reference object, its __ref ID string will be returned.
-    identify(object) {
+    InMemoryCache.prototype.identify = function (object) {
         if (isReference(object))
             return object.__ref;
         try {
             return this.policies.identify(object)[0];
         }
         catch (e) {
-            __DEV__ && invariant.warn(e);
+            globalThis.__DEV__ !== false && invariant.warn(e);
         }
-    }
-    evict(options) {
+    };
+    InMemoryCache.prototype.evict = function (options) {
         if (!options.id) {
             if (hasOwn.call(options, "id")) {
                 // See comment in modify method about why we return false when
                 // options.id exists but is falsy/undefined.
                 return false;
             }
-            options = { ...options, id: "ROOT_QUERY" };
+            options = __assign(__assign({}, options), { id: "ROOT_QUERY" });
         }
         try {
             // It's unlikely that the eviction will end up invoking any other
@@ -269,14 +306,15 @@ export class InMemoryCache extends ApolloCache {
                 this.broadcastWatches();
             }
         }
-    }
-    reset(options) {
+    };
+    InMemoryCache.prototype.reset = function (options) {
+        var _this = this;
         this.init();
         canonicalStringify.reset();
         if (options && options.discardWatches) {
             // Similar to what happens in the unsubscribe function returned by
             // cache.watch, applied to all current watches.
-            this.watches.forEach((watch) => this.maybeBroadcastWatch.forget(watch));
+            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
             this.watches.clear();
             forgetCache(this);
         }
@@ -290,34 +328,34 @@ export class InMemoryCache extends ApolloCache {
             this.broadcastWatches();
         }
         return Promise.resolve();
-    }
-    removeOptimistic(idToRemove) {
-        const newOptimisticData = this.optimisticData.removeLayer(idToRemove);
+    };
+    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
+        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
         if (newOptimisticData !== this.optimisticData) {
             this.optimisticData = newOptimisticData;
             this.broadcastWatches();
         }
-    }
-    txCount = 0;
-    batch(options) {
-        const { update, optimistic = true, removeOptimistic, onWatchUpdated, } = options;
-        let updateResult;
-        const perform = (layer) => {
-            const { data, optimisticData } = this;
-            ++this.txCount;
+    };
+    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;
             if (layer) {
-                this.data = this.optimisticData = layer;
+                _this.data = _this.optimisticData = layer;
             }
             try {
-                return (updateResult = update(this));
+                return (updateResult = update(_this));
             }
             finally {
-                --this.txCount;
-                this.data = data;
-                this.optimisticData = optimisticData;
+                --_this.txCount;
+                _this.data = data;
+                _this.optimisticData = optimisticData;
             }
         };
-        const alreadyDirty = new Set();
+        var alreadyDirty = new Set();
         if (onWatchUpdated && !this.txCount) {
             // If an options.onWatchUpdated callback is provided, we want to call it
             // with only the Cache.WatchOptions objects affected by options.update,
@@ -328,13 +366,10 @@ export class InMemoryCache extends ApolloCache {
             // post-update broadcast, allowing them to receive their pending
             // broadcasts the next time broadcastWatches is called, just as they would
             // if we never called cache.batch.
-            this.broadcastWatches({
-                ...options,
-                onWatchUpdated(watch) {
+            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {
                     alreadyDirty.add(watch);
                     return false;
-                },
-            });
+                } }));
         }
         if (typeof optimistic === "string") {
             // Note that there can be multiple layers with the same optimistic ID.
@@ -362,10 +397,8 @@ export class InMemoryCache extends ApolloCache {
         // takes the else branch and calls this.broadcastWatches(options), which
         // does nothing when this.txCount > 0.
         if (onWatchUpdated && alreadyDirty.size) {
-            this.broadcastWatches({
-                ...options,
-                onWatchUpdated(watch, diff) {
-                    const result = onWatchUpdated.call(this, watch, diff);
+            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {
+                    var result = onWatchUpdated.call(this, watch, diff);
                     if (result !== false) {
                         // Since onWatchUpdated did not return false, this diff is
                         // about to be broadcast to watch.callback, so we don't need
@@ -373,12 +406,11 @@ export class InMemoryCache extends ApolloCache {
                         alreadyDirty.delete(watch);
                     }
                     return result;
-                },
-            });
+                } }));
             // Silently re-dirty any watches that were already dirty before the update
             // was performed, and were not broadcast just now.
             if (alreadyDirty.size) {
-                alreadyDirty.forEach((watch) => this.maybeBroadcastWatch.dirty(watch));
+                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
             }
         }
         else {
@@ -388,46 +420,55 @@ export class InMemoryCache extends ApolloCache {
             this.broadcastWatches(options);
         }
         return updateResult;
-    }
-    performTransaction(update, optimisticId) {
+    };
+    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
         return this.batch({
-            update,
+            update: update,
             optimistic: optimisticId || optimisticId !== null,
         });
-    }
-    transformDocument(document) {
-        return this.addTypenameTransform.transformDocument(this.addFragmentsToDocument(document));
-    }
-    fragmentMatches(fragment, typename) {
+    };
+    InMemoryCache.prototype.transformDocument = function (document) {
+        return this.addTypenameToDocument(this.addFragmentsToDocument(document));
+    };
+    InMemoryCache.prototype.fragmentMatches = function (fragment, typename) {
         return this.policies.fragmentMatches(fragment, typename);
-    }
-    lookupFragment(fragmentName) {
-        return this.config.fragments?.lookup(fragmentName) || null;
-    }
-    broadcastWatches(options) {
+    };
+    InMemoryCache.prototype.lookupFragment = function (fragmentName) {
+        var _a;
+        return ((_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.lookup(fragmentName)) || null;
+    };
+    InMemoryCache.prototype.broadcastWatches = function (options) {
+        var _this = this;
         if (!this.txCount) {
-            this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));
+            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
         }
-    }
-    addFragmentsToDocument(document) {
-        const { fragments } = this.config;
+    };
+    InMemoryCache.prototype.addFragmentsToDocument = function (document) {
+        var fragments = this.config.fragments;
         return fragments ? fragments.transform(document) : document;
-    }
+    };
+    InMemoryCache.prototype.addTypenameToDocument = function (document) {
+        if (this.addTypename) {
+            return this.addTypenameTransform.transformDocument(document);
+        }
+        return document;
+    };
     // This method is wrapped by maybeBroadcastWatch, which is called by
     // broadcastWatches, so that we compute and broadcast results only when
     // the data that would be broadcast might have changed. It would be
     // simpler to check for changes after recomputing a result but before
     // broadcasting it, but this wrapping approach allows us to skip both
     // the recomputation and the broadcast, in most cases.
-    broadcastWatch(c, options) {
-        const { lastDiff } = c;
+    InMemoryCache.prototype.broadcastWatch = function (c, options) {
+        var _this = this;
+        var lastDiff = c.lastDiff;
         // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions
         // currently requires no additional properties, so we can use c (a
         // WatchOptions object) as DiffOptions, without having to allocate a new
         // object, and without having to enumerate the relevant properties (query,
         // variables, etc.) explicitly. There will be some additional properties
         // (lastDiff, callback, etc.), but cache.diff ignores them.
-        const diff = this.diff(c);
+        var diff = muteDeprecations("canonizeResults", function () { return _this.diff(c); });
         if (options) {
             if (c.optimistic && typeof options.optimistic === "string") {
                 diff.fromOptimisticTransaction = true;
@@ -442,9 +483,11 @@ export class InMemoryCache extends ApolloCache {
         if (!lastDiff || !equal(lastDiff.result, diff.result)) {
             c.callback((c.lastDiff = diff), lastDiff);
         }
-    }
-}
-if (__DEV__) {
+    };
+    return InMemoryCache;
+}(ApolloCache));
+export { InMemoryCache };
+if (globalThis.__DEV__ !== false) {
     InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;
 }
-//# sourceMappingURL=inMemoryCache.js.map
+//# sourceMappingURL=inMemoryCache.js.map