@ember-data/store 4.8.0-alpha.4 → 4.8.0-alpha.5

package/addon/-private/caches/identifier-cache.ts

@@ -25,9 +25,8 @@ import coerceId from '../utils/coerce-id';
 import { DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '../utils/identifer-debug-consts';
 import isNonEmptyString from '../utils/is-non-empty-string';
 import normalizeModelName from '../utils/normalize-model-name';
-import WeakCache from '../utils/weak-cache';
 
-const IDENTIFIERS = new WeakSet();
+const IDENTIFIERS = new Set();
 
 export function isStableIdentifier(identifier: Object): identifier is StableRecordIdentifier {
   return IDENTIFIERS.has(identifier);
@@ -56,7 +55,7 @@ interface KeyOptions {
   id: IdentifierMap;
 }
 
-type IdentifierMap = ConfidentDict<StableRecordIdentifier>;
+type IdentifierMap = Map<string, StableRecordIdentifier>;
 type TypeMap = ConfidentDict<KeyOptions>;
 export type MergeMethod = (
   targetIdentifier: StableRecordIdentifier,
@@ -85,12 +84,15 @@ export function setIdentifierResetMethod(method: ResetMethod | null): void {
   configuredResetMethod = method;
 }
 
+type WithLid = { lid: string };
+type WithId = { id: string | null; type: string };
+
 function defaultGenerationMethod(data: ResourceData | { type: string }, bucket: IdentifierBucket): string {
-  if ('lid' in data && isNonEmptyString(data.lid)) {
-    return data.lid;
+  if (isNonEmptyString((data as WithLid).lid)) {
+    return (data as WithLid).lid;
   }
-  if ('id' in data) {
-    let { type, id } = data;
+  if ((data as WithId).id !== undefined) {
+    let { type, id } = data as WithId;
     // TODO: add test for id not a string
     if (isNonEmptyString(coerceId(id))) {
       return `@lid:${normalizeModelName(type)}-${id}`;
@@ -103,7 +105,7 @@ function defaultEmptyCallback(...args: any[]): any {}
 
 let DEBUG_MAP;
 if (DEBUG) {
-  DEBUG_MAP = new WeakCache<StableRecordIdentifier, StableRecordIdentifier>('identifier-proxy-target');
+  DEBUG_MAP = new WeakMap<StableRecordIdentifier, StableRecordIdentifier>();
 }
 
 /**
@@ -121,7 +123,7 @@ if (DEBUG) {
  */
 export class IdentifierCache {
   _cache = {
-    lids: Object.create(null) as IdentifierMap,
+    lids: new Map<string, StableRecordIdentifier>(),
     types: Object.create(null) as TypeMap,
   };
   declare _generate: GenerationMethod;
@@ -129,6 +131,7 @@ export class IdentifierCache {
   declare _forget: ForgetMethod;
   declare _reset: ResetMethod;
   declare _merge: MergeMethod;
+  declare _isDefaultConfig: boolean;
 
   constructor() {
     // we cache the user configuredGenerationMethod at init because it must
@@ -138,6 +141,7 @@ export class IdentifierCache {
     this._forget = configuredForgetMethod || defaultEmptyCallback;
     this._reset = configuredResetMethod || defaultEmptyCallback;
     this._merge = defaultEmptyCallback;
+    this._isDefaultConfig = !configuredGenerationMethod;
   }
 
   /**
@@ -167,7 +171,7 @@ export class IdentifierCache {
     if (isStableIdentifier(resource)) {
       if (DEBUG) {
         // TODO should we instead just treat this case as a new generation skipping the short circuit?
-        if (!(this._cache.lids[resource.lid] !== undefined) || this._cache.lids[resource.lid] !== resource) {
+        if (!this._cache.lids.has(resource.lid) || this._cache.lids.get(resource.lid) !== resource) {
           throw new Error(`The supplied identifier ${resource} does not belong to this store instance`);
         }
       }
@@ -179,7 +183,7 @@ export class IdentifierCache {
     }
 
     let lid = coerceId(resource.lid);
-    let identifier: StableRecordIdentifier | undefined = lid !== null ? this._cache.lids[lid] : undefined;
+    let identifier: StableRecordIdentifier | undefined = lid !== null ? this._cache.lids.get(lid) : undefined;
 
     if (identifier !== undefined) {
       if (LOG_IDENTIFIERS) {
@@ -210,13 +214,13 @@ export class IdentifierCache {
 
     // go straight for the stable RecordIdentifier key'd to `lid`
     if (lid !== null) {
-      identifier = keyOptions.lid[lid];
+      identifier = keyOptions.lid.get(lid);
     }
 
     // we may have not seen this resource before
     // but just in case we check our own secondary lookup (`id`)
     if (identifier === undefined && id !== null) {
-      identifier = keyOptions.id[id];
+      identifier = keyOptions.id.get(id);
     }
 
     if (identifier === undefined) {
@@ -233,12 +237,12 @@ export class IdentifierCache {
       // different than expected
       if (lid !== null && newLid !== lid) {
         throw new Error(`You should not change the <lid> of a RecordIdentifier`);
-      } else if (lid === null) {
+      } else if (lid === null && !this._isDefaultConfig) {
         // allow configuration to tell us that we have
         // seen this `lid` before. E.g. a secondary lookup
         // connects this resource to a previously seen
         // resource.
-        identifier = keyOptions.lid[newLid];
+        identifier = keyOptions.lid.get(newLid);
       }
 
       if (shouldGenerate === true) {
@@ -250,16 +254,16 @@ export class IdentifierCache {
           if (DEBUG) {
             // realistically if you hit this it means you changed `type` :/
             // TODO consider how to handle type change assertions more gracefully
-            if (this._cache.lids[identifier.lid] !== undefined) {
+            if (this._cache.lids.has(identifier.lid)) {
               throw new Error(`You should not change the <type> of a RecordIdentifier`);
             }
           }
-          this._cache.lids[identifier.lid] = identifier;
+          this._cache.lids.set(identifier.lid, identifier);
 
           // populate our primary lookup table
           // TODO consider having the `lid` cache be
           // one level up
-          keyOptions.lid[identifier.lid] = identifier;
+          keyOptions.lid.set(identifier.lid, identifier);
 
           if (LOG_IDENTIFIERS && shouldGenerate) {
             // eslint-disable-next-line no-console
@@ -281,7 +285,7 @@ export class IdentifierCache {
         // because they may not match and we prefer
         // what we've set via resource data
         if (identifier.id !== null) {
-          keyOptions.id[identifier.id] = identifier;
+          keyOptions.id.set(identifier.id, identifier);
 
           // TODO allow filling out of `id` here
           // for the `username` non-client created
@@ -355,14 +359,17 @@ export class IdentifierCache {
 
     // populate our unique table
     if (DEBUG) {
-      if (this._cache.lids[identifier.lid] !== undefined) {
+      if (this._cache.lids.has(identifier.lid)) {
         throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);
       }
     }
-    this._cache.lids[identifier.lid] = identifier;
+    this._cache.lids.set(identifier.lid, identifier);
 
     // populate the type+lid cache
-    keyOptions.lid[newLid] = identifier;
+    keyOptions.lid.set(newLid, identifier);
+    if (data.id) {
+      keyOptions.id.set(data.id, identifier);
+    }
 
     if (LOG_IDENTIFIERS) {
       // eslint-disable-next-line no-console
@@ -448,10 +455,10 @@ export class IdentifierCache {
         );
       }
       let keyOptions = getTypeIndex(this._cache.types, identifier.type);
-      keyOptions.id[newId] = identifier;
+      keyOptions.id.set(newId, identifier);
 
       if (id !== null) {
-        keyOptions.id[id] = undefined as unknown as StableRecordIdentifier;
+        keyOptions.id.delete(id);
       }
     } else if (LOG_IDENTIFIERS) {
       // eslint-disable-next-line no-console
@@ -480,10 +487,10 @@ export class IdentifierCache {
     this.forgetRecordIdentifier(abandoned);
 
     // ensure a secondary cache entry for this id for the identifier we do keep
-    keyOptions.id[newId] = kept;
+    keyOptions.id.set(newId, kept);
     // ensure a secondary cache entry for this id for the abandoned identifier's type we do keep
     let baseKeyOptions = getTypeIndex(this._cache.types, existingIdentifier.type);
-    baseKeyOptions.id[newId] = kept;
+    baseKeyOptions.id.set(newId, kept);
 
     // make sure that the `lid` on the data we are processing matches the lid we kept
     data.lid = kept.lid;
@@ -507,10 +514,10 @@ export class IdentifierCache {
     let identifier = this.getOrCreateRecordIdentifier(identifierObject);
     let keyOptions = getTypeIndex(this._cache.types, identifier.type);
     if (identifier.id !== null) {
-      keyOptions.id[identifier.id] = undefined as unknown as StableRecordIdentifier;
+      keyOptions.id.delete(identifier.id);
     }
-    this._cache.lids[identifier.lid] = undefined as unknown as StableRecordIdentifier;
-    keyOptions.lid[identifier.lid] = undefined as unknown as StableRecordIdentifier;
+    this._cache.lids.delete(identifier.lid);
+    keyOptions.lid.delete(identifier.lid);
 
     IDENTIFIERS.delete(identifierObject);
     this._forget(identifier, 'record');
@@ -530,8 +537,8 @@ function getTypeIndex(typeMap: TypeMap, type: string): KeyOptions {
 
   if (typeIndex === undefined) {
     typeIndex = {
-      lid: Object.create(null),
-      id: Object.create(null),
+      lid: new Map(),
+      id: new Map(),
     };
     typeMap[type] = typeIndex;
   }
@@ -650,7 +657,7 @@ function detectMerge(
   const { id, type, lid } = identifier;
   if (id !== null && id !== newId && newId !== null) {
     let keyOptions = getTypeIndex(typesCache, identifier.type);
-    let existingIdentifier = keyOptions.id[newId];
+    let existingIdentifier = keyOptions.id.get(newId);
 
     return existingIdentifier !== undefined ? existingIdentifier : false;
   } else {
@@ -658,12 +665,12 @@ function detectMerge(
 
     // If the ids and type are the same but lid is not the same, we should trigger a merge of the identifiers
     if (id !== null && id === newId && newType === type && data.lid && data.lid !== lid) {
-      let existingIdentifier = lids[data.lid];
+      let existingIdentifier = lids.get(data.lid);
       return existingIdentifier !== undefined ? existingIdentifier : false;
       // If the lids are the same, and ids are the same, but types are different we should trigger a merge of the identifiers
     } else if (id !== null && id === newId && newType && newType !== type && data.lid && data.lid === lid) {
       let keyOptions = getTypeIndex(typesCache, newType);
-      let existingIdentifier = keyOptions.id[id];
+      let existingIdentifier = keyOptions.id.get(id);
       return existingIdentifier !== undefined ? existingIdentifier : false;
     }
   }

package/addon/-private/caches/instance-cache.ts

@@ -37,7 +37,6 @@ import { assertIdentifierHasId } from '../store-service';
 import coerceId, { ensureStringId } from '../utils/coerce-id';
 import constructResource from '../utils/construct-resource';
 import normalizeModelName from '../utils/normalize-model-name';
-import WeakCache, { DebugWeakCache } from '../utils/weak-cache';
 import { removeRecordDataFor, setRecordDataFor } from './record-data-for';
 
 let _peekGraph: peekGraph;
@@ -54,10 +53,7 @@ if (HAS_RECORD_DATA_PACKAGE) {
   @module @ember-data/store
 */
 
-const RecordCache = new WeakCache<RecordInstance, StableRecordIdentifier>(DEBUG ? 'identifier' : '');
-if (DEBUG) {
-  RecordCache._expectMsg = (key: RecordInstance) => `${String(key)} is not a record instantiated by @ember-data/store`;
-}
+const RecordCache = new Map<RecordInstance, StableRecordIdentifier>();
 
 export function peekRecordIdentifier(record: RecordInstance): StableRecordIdentifier | undefined {
   return RecordCache.get(record);
@@ -83,7 +79,8 @@ export function peekRecordIdentifier(record: RecordInstance): StableRecordIdenti
   @returns {StableRecordIdentifier}
  */
 export function recordIdentifierFor(record: RecordInstance): StableRecordIdentifier {
-  return RecordCache.getWithError(record);
+  assert(`${String(record)} is not a record instantiated by @ember-data/store`, RecordCache.has(record));
+  return RecordCache.get(record)!;
 }
 
 export function setRecordIdentifier(record: RecordInstance, identifier: StableRecordIdentifier): void {
@@ -102,7 +99,7 @@ export function setRecordIdentifier(record: RecordInstance, identifier: StableRe
   RecordCache.set(record, identifier);
 }
 
-export const StoreMap = new WeakCache<RecordInstance, Store>(DEBUG ? 'store' : '');
+export const StoreMap = new Map<RecordInstance, Store>();
 
 export function storeFor(record: RecordInstance): Store | undefined {
   const store = StoreMap.get(record);
@@ -117,33 +114,32 @@ export function storeFor(record: RecordInstance): Store | undefined {
 type Caches = {
   record: Map<StableRecordIdentifier, RecordInstance>;
   recordData: Map<StableRecordIdentifier, RecordData>;
-  reference: DebugWeakCache<StableRecordIdentifier, RecordReference>;
+  reference: WeakMap<StableRecordIdentifier, RecordReference>;
 };
 
 export class InstanceCache {
   declare store: Store;
   declare _storeWrapper: RecordDataStoreWrapper;
-  declare peekList: Dict<Set<StableRecordIdentifier>>;
   declare __recordDataFor: (resource: RecordIdentifier) => RecordData;
 
   declare __cacheManager: NonSingletonRecordDataManager;
   __instances: Caches = {
     record: new Map<StableRecordIdentifier, RecordInstance>(),
     recordData: new Map<StableRecordIdentifier, RecordData>(),
-    reference: new WeakCache<StableRecordIdentifier, RecordReference>(DEBUG ? 'reference' : ''),
+    reference: new WeakMap<StableRecordIdentifier, RecordReference>(),
   };
 
   recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted: boolean = false) {
-    const recordData = this.peek({ identifier, bucket: 'recordData' });
+    const recordData = this.__instances.recordData.get(identifier);
     if (!recordData) {
       return false;
     }
     const isNew = recordData.isNew(identifier);
-    const isEmpty = recordData.isEmpty?.(identifier) || false;
+    const isEmpty = recordData.isEmpty(identifier);
 
     // if we are new we must consider ourselves loaded
     if (isNew) {
-      return true;
+      return !recordData.isDeleted(identifier);
     }
     // even if we have a past request, if we are now empty we are not loaded
     // typically this is true after an unloadRecord call
@@ -152,23 +148,27 @@ export class InstanceCache {
     // we should consider allowing for something to be loaded that is simply "not empty".
     // which is how RecordState currently handles this case; however, RecordState is buggy
     // in that it does not account for unloading.
-    // return !isEmpty;
+    return filterDeleted && recordData.isDeletionCommitted(identifier) ? false : !isEmpty;
 
+    /*
     const req = this.store.getRequestStateService();
     const fulfilled = req.getLastRequestForRecord(identifier);
+    const isLocallyLoaded = !isEmpty;
     const isLoading =
-      fulfilled !== null && req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
+      !isLocallyLoaded &&
+      fulfilled === null &&
+      req.getPendingRequestsForRecord(identifier).some((req) => req.type === 'query');
 
     if (isEmpty || (filterDeleted && recordData.isDeletionCommitted(identifier)) || isLoading) {
       return false;
     }
 
     return true;
+    */
   }
 
   constructor(store: Store) {
     this.store = store;
-    this.peekList = Object.create(null) as Dict<Set<StableRecordIdentifier>>;
 
     this._storeWrapper = new RecordDataStoreWrapper(this.store);
     this.__recordDataFor = (resource: RecordIdentifier) => {
@@ -177,10 +177,6 @@ export class InstanceCache {
       return this.getRecordData(identifier);
     };
 
-    this.__instances.reference._generator = (identifier) => {
-      return new RecordReference(this.store, identifier);
-    };
-
     store.identifierCache.__configureMerge(
       (identifier: StableRecordIdentifier, matchedIdentifier: StableRecordIdentifier, resourceData) => {
         let intendedIdentifier = identifier;
@@ -228,7 +224,6 @@ export class InstanceCache {
         // remove "other" from cache
         if (otherHasRecord) {
           // TODO probably need to release other things
-          this.peekList[altIdentifier.type]?.delete(altIdentifier);
         }
 
         if (imRecordData === null && otherRecordData === null) {
@@ -244,14 +239,11 @@ export class InstanceCache {
           if (imRecordData) {
             // TODO check if we are retained in any async relationships
             // TODO probably need to release other things
-            this.peekList[intendedIdentifier.type]?.delete(intendedIdentifier);
             // im.destroy();
           }
           imRecordData = otherRecordData!;
           // TODO do we need to notify the id change?
           // TODO swap recordIdentifierFor result?
-          this.peekList[intendedIdentifier.type] = this.peekList[intendedIdentifier.type] || new Set();
-          this.peekList[intendedIdentifier.type]!.add(intendedIdentifier);
 
           // just use im
         } else {
@@ -285,7 +277,7 @@ export class InstanceCache {
   }
 
   getRecord(identifier: StableRecordIdentifier, properties?: CreateRecordProperties): RecordInstance {
-    let record = this.peek({ identifier, bucket: 'record' });
+    let record = this.__instances.record.get(identifier);
 
     if (!record) {
       const recordData = this.getRecordData(identifier);
@@ -311,7 +303,7 @@ export class InstanceCache {
   }
 
   getRecordData(identifier: StableRecordIdentifier): RecordData {
-    let recordData = this.peek({ identifier, bucket: 'recordData' });
+    let recordData = this.__instances.recordData.get(identifier);
 
     if (!recordData) {
       if (DEPRECATE_V1CACHE_STORE_APIS && this.store.createRecordDataFor.length > 2) {
@@ -354,8 +346,6 @@ export class InstanceCache {
       setRecordDataFor(identifier, recordData);
 
       this.__instances.recordData.set(identifier, recordData);
-      this.peekList[identifier.type] = this.peekList[identifier.type] || new Set();
-      this.peekList[identifier.type]!.add(identifier);
       if (LOG_INSTANCE_CACHE) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: created RecordData for ${String(identifier)}`);
@@ -366,7 +356,14 @@ export class InstanceCache {
   }
 
   getReference(identifier: StableRecordIdentifier) {
-    return this.__instances.reference.lookup(identifier);
+    let cache = this.__instances.reference;
+    let reference = cache.get(identifier);
+
+    if (!reference) {
+      reference = new RecordReference(this.store, identifier);
+      cache.set(identifier, reference);
+    }
+    return reference;
   }
 
   createSnapshot(identifier: StableRecordIdentifier, options: FindOptions = {}): Snapshot {
@@ -411,10 +408,9 @@ export class InstanceCache {
     }
 
     // TODO is this join still necessary?
-    this.store._backburner.join(() => {
-      const record = this.peek({ identifier, bucket: 'record' });
-      const recordData = this.peek({ identifier, bucket: 'recordData' });
-      this.peekList[identifier.type]?.delete(identifier);
+    this.store._join(() => {
+      const record = this.__instances.record.get(identifier);
+      const recordData = this.__instances.recordData.get(identifier);
 
       if (record) {
         this.store.teardownRecord(record);
@@ -438,7 +434,7 @@ export class InstanceCache {
       }
 
       this.store._fetchManager.clearEntries(identifier);
-      this.store.recordArrayManager.recordDidChange(identifier);
+      this.store.recordArrayManager.identifierRemoved(identifier);
       if (LOG_INSTANCE_CACHE) {
         // eslint-disable-next-line no-console
         console.log(`InstanceCache: unloaded RecordData for ${String(identifier)}`);
@@ -449,20 +445,19 @@ export class InstanceCache {
   }
 
   clear(type?: string) {
+    const typeCache = this.store.identifierCache._cache.types;
     if (type === undefined) {
-      let keys = Object.keys(this.peekList);
-      keys.forEach((key) => this.clear(key));
+      this.__instances.recordData.forEach((value, identifier) => {
+        this.unloadRecord(identifier);
+      });
     } else {
-      let identifiers = this.peekList[type];
+      let identifiers = typeCache[type]?.lid;
+      const rds = this.__instances.recordData;
       if (identifiers) {
         identifiers.forEach((identifier) => {
-          // TODO we rely on not removing the main cache
-          // and only removing the peekList cache apparently.
-          // we should figure out this duality and codify whatever
-          // signal it is actually trying to give us.
-          // this.cache.delete(identifier);
-          this.peekList[identifier.type]!.delete(identifier);
-          this.unloadRecord(identifier);
+          if (rds.has(identifier)) {
+            this.unloadRecord(identifier);
+          }
           // TODO we don't remove the identifier, should we?
         });
       }
@@ -479,7 +474,7 @@ export class InstanceCache {
     const isLoading = _isLoading(this, identifier);
 
     if (options.preload) {
-      this.store._backburner.join(() => {
+      this.store._join(() => {
         preloadData(this.store, identifier, options.preload!);
       });
     }
@@ -589,7 +584,7 @@ export class InstanceCache {
     recordData.pushData(identifier, data, hasRecord);
 
     if (!isUpdate) {
-      this.store.recordArrayManager.recordDidChange(identifier);
+      this.store.recordArrayManager.identifierAdded(identifier);
     }
 
     return identifier as StableExistingRecordIdentifier;
@@ -603,7 +598,7 @@ function _recordDataIsFullDeleted(identifier: StableRecordIdentifier, recordData
 }
 
 export function recordDataIsFullyDeleted(cache: InstanceCache, identifier: StableRecordIdentifier): boolean {
-  let recordData = cache.peek({ identifier, bucket: 'recordData' });
+  let recordData = cache.__instances.recordData.get(identifier);
   return !recordData || _recordDataIsFullDeleted(identifier, recordData);
 }
 
@@ -678,13 +673,13 @@ function _convertPreloadRelationshipToJSON(
 }
 
 function _isEmpty(cache: InstanceCache, identifier: StableRecordIdentifier): boolean {
-  const recordData = cache.peek({ identifier: identifier, bucket: 'recordData' });
+  const recordData = cache.__instances.recordData.get(identifier);
   if (!recordData) {
     return true;
   }
   const isNew = recordData.isNew(identifier);
   const isDeleted = recordData.isDeleted(identifier);
-  const isEmpty = recordData.isEmpty?.(identifier) || false;
+  const isEmpty = recordData.isEmpty(identifier);
 
   return (!isNew || isDeleted) && isEmpty;
 }

package/addon/-private/caches/record-data-for.ts

@@ -1,20 +1,15 @@
 import { assert } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
 
 import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
 import type { RecordData } from '@ember-data/types/q/record-data';
 import type { RecordInstance } from '@ember-data/types/q/record-instance';
 
-import WeakCache from '../utils/weak-cache';
-
 /*
  * Returns the RecordData instance associated with a given
  * Model or Identifier
  */
 
-const RecordDataForIdentifierCache = new WeakCache<StableRecordIdentifier | RecordInstance, RecordData>(
-  DEBUG ? 'recordData' : ''
-);
+const RecordDataForIdentifierCache = new Map<StableRecordIdentifier | RecordInstance, RecordData>();
 
 export function setRecordDataFor(identifier: StableRecordIdentifier | RecordInstance, recordData: RecordData): void {
   assert(

package/addon/-private/index.ts

@@ -53,4 +53,3 @@ export { default as SnapshotRecordArray } from './network/snapshot-record-array'
 
 // leaked for private use / test use, should investigate removing
 export { default as recordDataFor, removeRecordDataFor } from './caches/record-data-for';
-export { default as WeakCache } from './utils/weak-cache';

package/addon/-private/legacy-model-support/shim-model-class.ts

@@ -1,18 +1,20 @@
-import { DEBUG } from '@glimmer/env';
-
 import type { ModelSchema } from '@ember-data/types/q/ds-model';
 import type { AttributeSchema, RelationshipSchema } from '@ember-data/types/q/record-data-schemas';
 import type { Dict } from '@ember-data/types/q/utils';
 
 import type Store from '../store-service';
-import WeakCache from '../utils/weak-cache';
 
-const AvailableShims = new WeakCache<Store, Dict<ShimModelClass>>(DEBUG ? 'schema-shims' : '');
-AvailableShims._generator = () => {
-  return Object.create(null) as Dict<ShimModelClass>;
-};
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap<Store, Dict<ShimModelClass>>();
+
 export function getShimClass(store: Store, modelName: string): ShimModelClass {
-  let shims = AvailableShims.lookup(store);
+  let shims = AvailableShims.get(store);
+
+  if (!shims) {
+    shims = Object.create(null) as Dict<ShimModelClass>;
+    AvailableShims.set(store, shims);
+  }
   let shim = shims[modelName];
   if (shim === undefined) {
     shim = shims[modelName] = new ShimModelClass(store, modelName);