@apollo/client 3.13.4 → 4.0.0-alpha.0

package/cache/inmemory/inMemoryCache.js

@@ -1,47 +1,53 @@
-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 { equal } from "@wry/equality";
+import { wrap } from "optimism";
+import { addTypenameToDocument, cacheSizes, canonicalStringify, DocumentTransform, isReference, print, } from "@apollo/client/utilities";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { invariant } from "@apollo/client/utilities/invariant";
+import { getInMemoryCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
 import { ApolloCache } from "../core/cache.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";
 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";
-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;
-        _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,
+import { Policies } from "./policies.js";
+import { forgetCache, makeVar, recallCache } from "./reactiveVars.js";
+import { StoreReader } from "./readFromStore.js";
+import { StoreWriter } from "./writeToStore.js";
+// Make builtins like Map and Set safe to use with non-extensible objects.
+// TODO: this needs to be removed for 4.0, so we really don't have side effects.
+// that means we have to find an alternative means for the React Native fixes in there.
+import "./fixPolyfills.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,
         });
-        _this.init();
-        return _this;
+        this.init();
     }
-    InMemoryCache.prototype.init = function () {
+    init() {
         // 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.
-        var rootStore = (this.data = new EntityStore.Root({
+        const rootStore = (this.data = new EntityStore.Root({
             policies: this.policies,
             resultCaching: this.config.resultCaching,
         }));
@@ -52,34 +58,32 @@ var InMemoryCache = /** @class */ (function (_super) {
         // original this.data cache object.
         this.optimisticData = rootStore.stump;
         this.resetResultCache();
-    };
-    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
-        var _this = this;
-        var previousReader = this.storeReader;
-        var fragments = this.config.fragments;
+    }
+    resetResultCache(resetResultIdentities) {
+        const previousReader = this.storeReader;
+        const { fragments } = this.config;
         // 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,
             canonizeResults: shouldCanonizeResults(this.config),
             canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),
-            fragments: fragments,
+            fragments,
         })), fragments);
-        this.maybeBroadcastWatch = wrap(function (c, options) {
-            return _this.broadcastWatch(c, options);
+        this.maybeBroadcastWatch = wrap((c, options) => {
+            return this.broadcastWatch(c, options);
         }, {
             max: this.config.resultCacheMaxSize ||
                 cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
                 5000 /* defaultCacheSizes["inMemoryCache.maybeBroadcastWatch"] */,
-            makeCacheKey: function (c) {
+            makeCacheKey: (c) => {
                 // Return a cache key (thus enabling result caching) only if we're
                 // currently using a data store that can track cache dependencies.
-                var store = c.optimistic ? _this.optimisticData : _this.data;
+                const store = c.optimistic ? this.optimisticData : this.data;
                 if (supportsResultCaching(store)) {
-                    var optimistic = c.optimistic, id = c.id, variables = c.variables;
+                    const { optimistic, id, variables } = c;
                     return store.makeCacheKey(c.query, 
                     // Different watches can have the same query, optimistic
                     // status, rootId, and variables, but if their callbacks are
@@ -87,18 +91,16 @@ var InMemoryCache = /** @class */ (function (_super) {
                     // 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: optimistic, id: id, variables: variables }));
+                    c.callback, canonicalStringify({ optimistic, id, 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(function (group) {
-            return group.resetCaching();
-        });
-    };
-    InMemoryCache.prototype.restore = function (data) {
+        new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());
+    }
+    restore(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
@@ -106,21 +108,12 @@ var InMemoryCache = /** @class */ (function (_super) {
         if (data)
             this.data.replace(data);
         return this;
-    };
-    InMemoryCache.prototype.extract = function (optimistic) {
-        if (optimistic === void 0) { optimistic = false; }
+    }
+    extract(optimistic = false) {
         return (optimistic ? this.optimisticData : this.data).extract();
-    };
-    InMemoryCache.prototype.read = function (options) {
-        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
-        // 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.
-        _a = options.returnPartialData, 
+    }
+    read(options) {
+        const { 
         // 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
@@ -128,23 +121,15 @@ var InMemoryCache = /** @class */ (function (_super) {
         // 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) {
+        returnPartialData = false, } = options;
+        return this.storeReader.diffQueryAgainstStore({
+            ...options,
+            store: options.optimistic ? this.optimisticData : this.data,
+            config: this.config,
+            returnPartialData,
+        }).result;
+    }
+    write(options) {
         try {
             ++this.txCount;
             return this.storeWriter.writeToStore(this.data, options);
@@ -154,8 +139,8 @@ var InMemoryCache = /** @class */ (function (_super) {
                 this.broadcastWatches();
             }
         }
-    };
-    InMemoryCache.prototype.modify = function (options) {
+    }
+    modify(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
@@ -168,7 +153,7 @@ var InMemoryCache = /** @class */ (function (_super) {
             // that nothing was modified.
             return false;
         }
-        var store = ((options.optimistic) // Defaults to false.
+        const store = ((options.optimistic) // Defaults to false.
         ) ?
             this.optimisticData
             : this.data;
@@ -181,12 +166,16 @@ var InMemoryCache = /** @class */ (function (_super) {
                 this.broadcastWatches();
             }
         }
-    };
-    InMemoryCache.prototype.diff = function (options) {
-        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;
+    }
+    diff(options) {
+        return this.storeReader.diffQueryAgainstStore({
+            ...options,
+            store: options.optimistic ? this.optimisticData : this.data,
+            rootId: options.id || "ROOT_QUERY",
+            config: this.config,
+        });
+    }
+    watch(watch) {
         if (!this.watches.size) {
             // In case we previously called forgetCache(this) because
             // this.watches became empty (see below), reattach this cache to any
@@ -204,26 +193,25 @@ var InMemoryCache = /** @class */ (function (_super) {
         if (watch.immediate) {
             this.maybeBroadcastWatch(watch);
         }
-        return function () {
+        return () => {
             // 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);
         };
-    };
-    InMemoryCache.prototype.gc = function (options) {
-        var _a;
+    }
+    gc(options) {
         canonicalStringify.reset();
         print.reset();
         this.addTypenameTransform.resetCache();
-        (_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();
-        var ids = this.optimisticData.gc();
+        this.config.fragments?.resetCaches();
+        const ids = this.optimisticData.gc();
         if (options && !this.txCount) {
             if (options.resetResultCache) {
                 this.resetResultCache(options.resetResultIdentities);
@@ -233,7 +221,7 @@ var InMemoryCache = /** @class */ (function (_super) {
             }
         }
         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,
@@ -241,41 +229,41 @@ var InMemoryCache = /** @class */ (function (_super) {
     // 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.
-    InMemoryCache.prototype.retain = function (rootId, optimistic) {
+    retain(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.
-    InMemoryCache.prototype.release = function (rootId, optimistic) {
+    release(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.
-    InMemoryCache.prototype.identify = function (object) {
+    identify(object) {
         if (isReference(object))
             return object.__ref;
         try {
             return this.policies.identify(object)[0];
         }
         catch (e) {
-            globalThis.__DEV__ !== false && invariant.warn(e);
+            __DEV__ && invariant.warn(e);
         }
-    };
-    InMemoryCache.prototype.evict = function (options) {
+    }
+    evict(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 = __assign(__assign({}, options), { id: "ROOT_QUERY" });
+            options = { ...options, id: "ROOT_QUERY" };
         }
         try {
             // It's unlikely that the eviction will end up invoking any other
@@ -293,15 +281,14 @@ var InMemoryCache = /** @class */ (function (_super) {
                 this.broadcastWatches();
             }
         }
-    };
-    InMemoryCache.prototype.reset = function (options) {
-        var _this = this;
+    }
+    reset(options) {
         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(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
+            this.watches.forEach((watch) => this.maybeBroadcastWatch.forget(watch));
             this.watches.clear();
             forgetCache(this);
         }
@@ -315,34 +302,34 @@ var InMemoryCache = /** @class */ (function (_super) {
             this.broadcastWatches();
         }
         return Promise.resolve();
-    };
-    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
-        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
+    }
+    removeOptimistic(idToRemove) {
+        const newOptimisticData = this.optimisticData.removeLayer(idToRemove);
         if (newOptimisticData !== this.optimisticData) {
             this.optimisticData = newOptimisticData;
             this.broadcastWatches();
         }
-    };
-    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;
+    }
+    txCount = 0;
+    batch(options) {
+        const { update, optimistic = true, removeOptimistic, onWatchUpdated, } = options;
+        let updateResult;
+        const perform = (layer) => {
+            const { data, optimisticData } = this;
+            ++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;
             }
         };
-        var alreadyDirty = new Set();
+        const 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,
@@ -353,10 +340,13 @@ var InMemoryCache = /** @class */ (function (_super) {
             // 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(__assign(__assign({}, options), { onWatchUpdated: function (watch) {
+            this.broadcastWatches({
+                ...options,
+                onWatchUpdated(watch) {
                     alreadyDirty.add(watch);
                     return false;
-                } }));
+                },
+            });
         }
         if (typeof optimistic === "string") {
             // Note that there can be multiple layers with the same optimistic ID.
@@ -384,8 +374,10 @@ var InMemoryCache = /** @class */ (function (_super) {
         // takes the else branch and calls this.broadcastWatches(options), which
         // does nothing when this.txCount > 0.
         if (onWatchUpdated && alreadyDirty.size) {
-            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {
-                    var result = onWatchUpdated.call(this, watch, diff);
+            this.broadcastWatches({
+                ...options,
+                onWatchUpdated(watch, diff) {
+                    const 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
@@ -393,11 +385,12 @@ var InMemoryCache = /** @class */ (function (_super) {
                         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(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
+                alreadyDirty.forEach((watch) => this.maybeBroadcastWatch.dirty(watch));
             }
         }
         else {
@@ -407,54 +400,46 @@ var InMemoryCache = /** @class */ (function (_super) {
             this.broadcastWatches(options);
         }
         return updateResult;
-    };
-    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
+    }
+    performTransaction(update, optimisticId) {
         return this.batch({
-            update: update,
+            update,
             optimistic: optimisticId || optimisticId !== null,
         });
-    };
-    InMemoryCache.prototype.transformDocument = function (document) {
-        return this.addTypenameToDocument(this.addFragmentsToDocument(document));
-    };
-    InMemoryCache.prototype.fragmentMatches = function (fragment, typename) {
+    }
+    transformDocument(document) {
+        return this.addTypenameTransform.transformDocument(this.addFragmentsToDocument(document));
+    }
+    fragmentMatches(fragment, typename) {
         return this.policies.fragmentMatches(fragment, typename);
-    };
-    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;
+    }
+    lookupFragment(fragmentName) {
+        return this.config.fragments?.lookup(fragmentName) || null;
+    }
+    broadcastWatches(options) {
         if (!this.txCount) {
-            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
+            this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));
         }
-    };
-    InMemoryCache.prototype.addFragmentsToDocument = function (document) {
-        var fragments = this.config.fragments;
+    }
+    addFragmentsToDocument(document) {
+        const { fragments } = this.config;
         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.
-    InMemoryCache.prototype.broadcastWatch = function (c, options) {
-        var lastDiff = c.lastDiff;
+    broadcastWatch(c, options) {
+        const { lastDiff } = c;
         // 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.
-        var diff = this.diff(c);
+        const diff = this.diff(c);
         if (options) {
             if (c.optimistic && typeof options.optimistic === "string") {
                 diff.fromOptimisticTransaction = true;
@@ -469,11 +454,9 @@ var InMemoryCache = /** @class */ (function (_super) {
         if (!lastDiff || !equal(lastDiff.result, diff.result)) {
             c.callback((c.lastDiff = diff), lastDiff);
         }
-    };
-    return InMemoryCache;
-}(ApolloCache));
-export { InMemoryCache };
-if (globalThis.__DEV__ !== false) {
+    }
+}
+if (__DEV__) {
     InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;
 }
-//# sourceMappingURL=inMemoryCache.js.map
+//# sourceMappingURL=inMemoryCache.js.map