| 1 | {"version":3,"file":"inMemoryCache.js","sourceRoot":"","sources":["../../../src/cache/inmemory/inMemoryCache.ts"],"names":[],"mappings":"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","sourcesContent":["import { invariant } from '../../utilities/globals';\n\n// Make builtins like Map and Set safe to use with non-extensible objects.\nimport './fixPolyfills';\n\nimport { DocumentNode } from 'graphql';\nimport { OptimisticWrapperFunction, wrap } from 'optimism';\nimport { equal } from '@wry/equality';\n\nimport { ApolloCache } from '../core/cache';\nimport { Cache } from '../core/types/Cache';\nimport { MissingFieldError } from '../core/types/common';\nimport {\n addTypenameToDocument,\n StoreObject,\n Reference,\n isReference,\n} from '../../utilities';\nimport { InMemoryCacheConfig, NormalizedCacheObject } from './types';\nimport { StoreReader } from './readFromStore';\nimport { StoreWriter } from './writeToStore';\nimport { EntityStore, supportsResultCaching } from './entityStore';\nimport { makeVar, forgetCache, recallCache } from './reactiveVars';\nimport { Policies } from './policies';\nimport { hasOwn, normalizeConfig, shouldCanonizeResults } from './helpers';\nimport { canonicalStringify } from './object-canon';\n\ntype BroadcastOptions = Pick<\n Cache.BatchOptions<InMemoryCache>,\n | \"optimistic\"\n | \"onWatchUpdated\"\n>\n\nexport class InMemoryCache extends ApolloCache<NormalizedCacheObject> {\n private data: EntityStore;\n private optimisticData: EntityStore;\n\n protected config: InMemoryCacheConfig;\n private watches = new Set<Cache.WatchOptions>();\n private addTypename: boolean;\n\n private typenameDocumentCache = new Map<DocumentNode, DocumentNode>();\n private storeReader: StoreReader;\n private storeWriter: StoreWriter;\n\n private maybeBroadcastWatch: OptimisticWrapperFunction<\n [Cache.WatchOptions, BroadcastOptions?],\n any,\n [Cache.WatchOptions]>;\n\n // Dynamically imported code can augment existing typePolicies or\n // possibleTypes by calling cache.policies.addTypePolicies or\n // cache.policies.addPossibletypes.\n public readonly policies: Policies;\n\n public readonly makeVar = makeVar;\n\n constructor(config: InMemoryCacheConfig = {}) {\n super();\n this.config = normalizeConfig(config);\n this.addTypename = !!this.config.addTypename;\n\n this.policies = new Policies({\n cache: this,\n dataIdFromObject: this.config.dataIdFromObject,\n possibleTypes: this.config.possibleTypes,\n typePolicies: this.config.typePolicies,\n });\n\n this.init();\n }\n\n private init() {\n // Passing { resultCaching: false } in the InMemoryCache constructor options\n // will completely disable dependency tracking, which will improve memory\n // usage but worsen the performance of repeated reads.\n const rootStore = this.data = new EntityStore.Root({\n policies: this.policies,\n resultCaching: this.config.resultCaching,\n });\n\n // When no optimistic writes are currently active, cache.optimisticData ===\n // cache.data, so there are no additional layers on top of the actual data.\n // When an optimistic update happens, this.optimisticData will become a\n // linked list of EntityStore Layer objects that terminates with the\n // original this.data cache object.\n this.optimisticData = rootStore.stump;\n\n this.resetResultCache();\n }\n\n private resetResultCache(resetResultIdentities?: boolean) {\n const previousReader = this.storeReader;\n const { fragments } = this.config;\n\n // The StoreWriter is mostly stateless and so doesn't really need to be\n // reset, but it does need to have its writer.storeReader reference updated,\n // so it's simpler to update this.storeWriter as well.\n this.storeWriter = new StoreWriter(\n this,\n this.storeReader = new StoreReader({\n cache: this,\n addTypename: this.addTypename,\n resultCacheMaxSize: this.config.resultCacheMaxSize,\n canonizeResults: shouldCanonizeResults(this.config),\n canon: resetResultIdentities\n ? void 0\n : previousReader && previousReader.canon,\n fragments,\n }),\n fragments,\n );\n\n this.maybeBroadcastWatch = wrap((\n c: Cache.WatchOptions,\n options?: BroadcastOptions,\n ) => {\n return this.broadcastWatch(c, options);\n }, {\n max: this.config.resultCacheMaxSize,\n makeCacheKey: (c: Cache.WatchOptions) => {\n // Return a cache key (thus enabling result caching) only if we're\n // currently using a data store that can track cache dependencies.\n const store = c.optimistic ? this.optimisticData : this.data;\n if (supportsResultCaching(store)) {\n const { optimistic, id, variables } = c;\n return store.makeCacheKey(\n c.query,\n // Different watches can have the same query, optimistic\n // status, rootId, and variables, but if their callbacks are\n // different, the (identical) result needs to be delivered to\n // each distinct callback. The easiest way to achieve that\n // separation is to include c.callback in the cache key for\n // maybeBroadcastWatch calls. See issue #5733.\n c.callback,\n canonicalStringify({ optimistic, id, variables }),\n );\n }\n }\n });\n\n // Since we have thrown away all the cached functions that depend on the\n // CacheGroup dependencies maintained by EntityStore, we should also reset\n // all CacheGroup dependency information.\n new Set([\n this.data.group,\n this.optimisticData.group,\n ]).forEach(group => group.resetCaching());\n }\n\n public restore(data: NormalizedCacheObject): this {\n this.init();\n // Since calling this.init() discards/replaces the entire StoreReader, along\n // with the result caches it maintains, this.data.replace(data) won't have\n // to bother deleting the old data.\n if (data) this.data.replace(data);\n return this;\n }\n\n public extract(optimistic: boolean = false): NormalizedCacheObject {\n return (optimistic ? this.optimisticData : this.data).extract();\n }\n\n public read<T>(options: Cache.ReadOptions): T | null {\n const {\n // Since read returns data or null, without any additional metadata\n // about whether/where there might have been missing fields, the\n // default behavior cannot be returnPartialData = true (like it is\n // for the diff method), since defaulting to true would violate the\n // integrity of the T in the return type. However, partial data may\n // be useful in some cases, so returnPartialData:true may be\n // specified explicitly.\n returnPartialData = false,\n } = options;\n try {\n return this.storeReader.diffQueryAgainstStore<T>({\n ...options,\n store: options.optimistic ? this.optimisticData : this.data,\n config: this.config,\n returnPartialData,\n }).result || null;\n } catch (e) {\n if (e instanceof MissingFieldError) {\n // Swallow MissingFieldError and return null, so callers do not need to\n // worry about catching \"normal\" exceptions resulting from incomplete\n // cache data. Unexpected errors will be re-thrown. If you need more\n // information about which fields were missing, use cache.diff instead,\n // and examine diffResult.missing.\n return null;\n }\n throw e;\n }\n }\n\n public write(options: Cache.WriteOptions): Reference | undefined {\n try {\n ++this.txCount;\n return this.storeWriter.writeToStore(this.data, options);\n } finally {\n if (!--this.txCount && options.broadcast !== false) {\n this.broadcastWatches();\n }\n }\n }\n\n public modify(options: Cache.ModifyOptions): boolean {\n if (hasOwn.call(options, \"id\") && !options.id) {\n // To my knowledge, TypeScript does not currently provide a way to\n // enforce that an optional property?:type must *not* be undefined\n // when present. That ability would be useful here, because we want\n // options.id to default to ROOT_QUERY only when no options.id was\n // provided. If the caller attempts to pass options.id with a\n // falsy/undefined value (perhaps because cache.identify failed), we\n // should not assume the goal was to modify the ROOT_QUERY object.\n // We could throw, but it seems natural to return false to indicate\n // that nothing was modified.\n return false;\n }\n const store = options.optimistic // Defaults to false.\n ? this.optimisticData\n : this.data;\n try {\n ++this.txCount;\n return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n } finally {\n if (!--this.txCount && options.broadcast !== false) {\n this.broadcastWatches();\n }\n }\n }\n\n public diff<TData, TVariables = any>(\n options: Cache.DiffOptions<TData, TVariables>,\n ): Cache.DiffResult<TData> {\n return this.storeReader.diffQueryAgainstStore({\n ...options,\n store: options.optimistic ? this.optimisticData : this.data,\n rootId: options.id || \"ROOT_QUERY\",\n config: this.config,\n });\n }\n\n public watch<TData = any, TVariables = any>(\n watch: Cache.WatchOptions<TData, TVariables>,\n ): () => void {\n if (!this.watches.size) {\n // In case we previously called forgetCache(this) because\n // this.watches became empty (see below), reattach this cache to any\n // reactive variables on which it previously depended. It might seem\n // paradoxical that we're able to recall something we supposedly\n // forgot, but the point of calling forgetCache(this) is to silence\n // useless broadcasts while this.watches is empty, and to allow the\n // cache to be garbage collected. If, however, we manage to call\n // recallCache(this) here, this cache object must not have been\n // garbage collected yet, and should resume receiving updates from\n // reactive variables, now that it has a watcher to notify.\n recallCache(this);\n }\n this.watches.add(watch);\n if (watch.immediate) {\n this.maybeBroadcastWatch(watch);\n }\n return () => {\n // Once we remove the last watch from this.watches, cache.broadcastWatches\n // no longer does anything, so we preemptively tell the reactive variable\n // system to exclude this cache from future broadcasts.\n if (this.watches.delete(watch) && !this.watches.size) {\n forgetCache(this);\n }\n // Remove this watch from the LRU cache managed by the\n // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory\n // leaks involving the closure of watch.callback.\n this.maybeBroadcastWatch.forget(watch);\n };\n }\n\n public gc(options?: {\n // If true, also free non-essential result cache memory by bulk-releasing\n // this.{store{Reader,Writer},maybeBroadcastWatch}. Defaults to false.\n resetResultCache?: boolean;\n // If resetResultCache is true, this.storeReader.canon will be preserved by\n // default, but can also be discarded by passing resetResultIdentities:true.\n // Defaults to false.\n resetResultIdentities?: boolean;\n }) {\n canonicalStringify.reset();\n const ids = this.optimisticData.gc();\n if (options && !this.txCount) {\n if (options.resetResultCache) {\n this.resetResultCache(options.resetResultIdentities);\n } else if (options.resetResultIdentities) {\n this.storeReader.resetCanon();\n }\n }\n return ids;\n }\n\n // Call this method to ensure the given root ID remains in the cache after\n // garbage collection, along with its transitive child entities. Note that\n // the cache automatically retains all directly written entities. By default,\n // the retainment persists after optimistic updates are removed. Pass true\n // for the optimistic argument if you would prefer for the retainment to be\n // discarded when the top-most optimistic layer is removed. Returns the\n // resulting (non-negative) retainment count.\n public retain(rootId: string, optimistic?: boolean): number {\n return (optimistic ? this.optimisticData : this.data).retain(rootId);\n }\n\n // Call this method to undo the effect of the retain method, above. Once the\n // retainment count falls to zero, the given ID will no longer be preserved\n // during garbage collection, though it may still be preserved by other safe\n // entities that refer to it. Returns the resulting (non-negative) retainment\n // count, in case that's useful.\n public release(rootId: string, optimistic?: boolean): number {\n return (optimistic ? this.optimisticData : this.data).release(rootId);\n }\n\n // Returns the canonical ID for a given StoreObject, obeying typePolicies\n // and keyFields (and dataIdFromObject, if you still use that). At minimum,\n // the object must contain a __typename and any primary key fields required\n // to identify entities of that type. If you pass a query result object, be\n // sure that none of the primary key fields have been renamed by aliasing.\n // If you pass a Reference object, its __ref ID string will be returned.\n public identify(object: StoreObject | Reference): string | undefined {\n if (isReference(object)) return object.__ref;\n try {\n return this.policies.identify(object)[0];\n } catch (e) {\n invariant.warn(e);\n }\n }\n\n public evict(options: Cache.EvictOptions): boolean {\n if (!options.id) {\n if (hasOwn.call(options, \"id\")) {\n // See comment in modify method about why we return false when\n // options.id exists but is falsy/undefined.\n return false;\n }\n options = { ...options, id: \"ROOT_QUERY\" };\n }\n try {\n // It's unlikely that the eviction will end up invoking any other\n // cache update operations while it's running, but {in,de}crementing\n // this.txCount still seems like a good idea, for uniformity with\n // the other update methods.\n ++this.txCount;\n // Pass this.data as a limit on the depth of the eviction, so evictions\n // during optimistic updates (when this.data is temporarily set equal to\n // this.optimisticData) do not escape their optimistic Layer.\n return this.optimisticData.evict(options, this.data);\n } finally {\n if (!--this.txCount && options.broadcast !== false) {\n this.broadcastWatches();\n }\n }\n }\n\n public reset(options?: Cache.ResetOptions): Promise<void> {\n this.init();\n\n canonicalStringify.reset();\n\n if (options && options.discardWatches) {\n // Similar to what happens in the unsubscribe function returned by\n // cache.watch, applied to all current watches.\n this.watches.forEach(watch => this.maybeBroadcastWatch.forget(watch));\n this.watches.clear();\n forgetCache(this);\n } else {\n // Calling this.init() above unblocks all maybeBroadcastWatch caching, so\n // this.broadcastWatches() triggers a broadcast to every current watcher\n // (letting them know their data is now missing). This default behavior is\n // convenient because it means the watches do not have to be manually\n // reestablished after resetting the cache. To prevent this broadcast and\n // cancel all watches, pass true for options.discardWatches.\n this.broadcastWatches();\n }\n\n return Promise.resolve();\n }\n\n public removeOptimistic(idToRemove: string) {\n const newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n if (newOptimisticData !== this.optimisticData) {\n this.optimisticData = newOptimisticData;\n this.broadcastWatches();\n }\n }\n\n private txCount = 0;\n\n public batch<TUpdateResult>(\n options: Cache.BatchOptions<InMemoryCache, TUpdateResult>,\n ): TUpdateResult {\n const {\n update,\n optimistic = true,\n removeOptimistic,\n onWatchUpdated,\n } = options;\n\n let updateResult: TUpdateResult;\n const perform = (layer?: EntityStore): TUpdateResult => {\n const { data, optimisticData } = this;\n ++this.txCount;\n if (layer) {\n this.data = this.optimisticData = layer;\n }\n try {\n return updateResult = update(this);\n } finally {\n --this.txCount;\n this.data = data;\n this.optimisticData = optimisticData;\n }\n };\n\n const alreadyDirty = new Set<Cache.WatchOptions>();\n\n if (onWatchUpdated && !this.txCount) {\n // If an options.onWatchUpdated callback is provided, we want to call it\n // with only the Cache.WatchOptions objects affected by options.update,\n // but there might be dirty watchers already waiting to be broadcast that\n // have nothing to do with the update. To prevent including those watchers\n // in the post-update broadcast, we perform this initial broadcast to\n // collect the dirty watchers, so we can re-dirty them later, after the\n // post-update broadcast, allowing them to receive their pending\n // broadcasts the next time broadcastWatches is called, just as they would\n // if we never called cache.batch.\n this.broadcastWatches({\n ...options,\n onWatchUpdated(watch) {\n alreadyDirty.add(watch);\n return false;\n },\n });\n }\n\n if (typeof optimistic === 'string') {\n // Note that there can be multiple layers with the same optimistic ID.\n // When removeOptimistic(id) is called for that id, all matching layers\n // will be removed, and the remaining layers will be reapplied.\n this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n } else if (optimistic === false) {\n // Ensure both this.data and this.optimisticData refer to the root\n // (non-optimistic) layer of the cache during the update. Note that\n // this.data could be a Layer if we are currently executing an optimistic\n // update function, but otherwise will always be an EntityStore.Root\n // instance.\n perform(this.data);\n } else {\n // Otherwise, leave this.data and this.optimisticData unchanged and run\n // the update with broadcast batching.\n perform();\n }\n\n if (typeof removeOptimistic === \"string\") {\n this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n }\n\n // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code\n // takes the else branch and calls this.broadcastWatches(options), which\n // does nothing when this.txCount > 0.\n if (onWatchUpdated && alreadyDirty.size) {\n this.broadcastWatches({\n ...options,\n onWatchUpdated(watch, diff) {\n const result = onWatchUpdated.call(this, watch, diff);\n if (result !== false) {\n // Since onWatchUpdated did not return false, this diff is\n // about to be broadcast to watch.callback, so we don't need\n // to re-dirty it with the other alreadyDirty watches below.\n alreadyDirty.delete(watch);\n }\n return result;\n }\n });\n // Silently re-dirty any watches that were already dirty before the update\n // was performed, and were not broadcast just now.\n if (alreadyDirty.size) {\n alreadyDirty.forEach(watch => this.maybeBroadcastWatch.dirty(watch));\n }\n } else {\n // If alreadyDirty is empty or we don't have an onWatchUpdated\n // function, we don't need to go to the trouble of wrapping\n // options.onWatchUpdated.\n this.broadcastWatches(options);\n }\n\n return updateResult!;\n }\n\n public performTransaction(\n update: (cache: InMemoryCache) => any,\n optimisticId?: string | null,\n ) {\n return this.batch({\n update,\n optimistic: optimisticId || (optimisticId !== null),\n });\n }\n\n public transformDocument(document: DocumentNode): DocumentNode {\n if (this.addTypename) {\n let result = this.typenameDocumentCache.get(document);\n if (!result) {\n result = addTypenameToDocument(document);\n this.typenameDocumentCache.set(document, result);\n // If someone calls transformDocument and then mistakenly passes the\n // result back into an API that also calls transformDocument, make sure\n // we don't keep creating new query documents.\n this.typenameDocumentCache.set(result, result);\n }\n return result;\n }\n return document;\n }\n\n public transformForLink(document: DocumentNode): DocumentNode {\n const { fragments } = this.config;\n return fragments\n ? fragments.transform(document)\n : document;\n }\n\n protected broadcastWatches(options?: BroadcastOptions) {\n if (!this.txCount) {\n this.watches.forEach(c => this.maybeBroadcastWatch(c, options));\n }\n }\n\n // This method is wrapped by maybeBroadcastWatch, which is called by\n // broadcastWatches, so that we compute and broadcast results only when\n // the data that would be broadcast might have changed. It would be\n // simpler to check for changes after recomputing a result but before\n // broadcasting it, but this wrapping approach allows us to skip both\n // the recomputation and the broadcast, in most cases.\n private broadcastWatch(\n c: Cache.WatchOptions,\n options?: BroadcastOptions,\n ) {\n const { lastDiff } = c;\n\n // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions\n // currently requires no additional properties, so we can use c (a\n // WatchOptions object) as DiffOptions, without having to allocate a new\n // object, and without having to enumerate the relevant properties (query,\n // variables, etc.) explicitly. There will be some additional properties\n // (lastDiff, callback, etc.), but cache.diff ignores them.\n const diff = this.diff<any>(c);\n\n if (options) {\n if (c.optimistic &&\n typeof options.optimistic === \"string\") {\n diff.fromOptimisticTransaction = true;\n }\n\n if (options.onWatchUpdated &&\n options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n // Returning false from the onWatchUpdated callback will prevent\n // calling c.callback(diff) for this watcher.\n return;\n }\n }\n\n if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n c.callback(c.lastDiff = diff, lastDiff);\n }\n }\n}\n"]} |