@ember-data/store 5.3.0-alpha.9 → 5.4.0-alpha.0

package/addon/{store-service-845a5162.js → store-service-0a03d2a4.js}

@@ -1,6 +1,6 @@
 import { macroCondition, getOwnConfig } from '@embroider/macros';
 import { getOwner } from '@ember/application';
-import { assert, warn } from '@ember/debug';
+import { assert, deprecate, warn } from '@ember/debug';
 import EmberObject from '@ember/object';
 import { _backburner } from '@ember/runloop';
 import { tracked } from '@glimmer/tracking';
@@ -354,50 +354,63 @@ function copyDocumentProperties(target, source) {
   }
 }
 
-/**
-  @module @ember-data/store
-*/
-
 // Used by the store to normalize IDs entering the store.  Despite the fact
 // that developers may provide IDs as numbers (e.g., `store.findRecord('person', 1)`),
 // it is important that internally we use strings, since IDs may be serialized
 // and lose type information.  For example, Ember's router may put a record's
 // ID into the URL, and if we later try to deserialize that URL and find the
 // corresponding record, we will not know if it is a string or a number.
-
 function coerceId(id) {
-  if (id === null || id === undefined || id === '') {
-    return null;
-  }
-  if (typeof id === 'string') {
-    return id;
-  }
-  if (typeof id === 'symbol') {
-    return id.toString();
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_ID)) {
+    let normalized;
+    if (id === null || id === undefined || id === '') {
+      normalized = null;
+    } else {
+      normalized = String(id);
+    }
+    deprecate(`The resource id '<${typeof id}> ${String(id)} ' is not normalized. Update your application code to use '${JSON.stringify(normalized)}' instead.`, normalized === id, {
+      id: 'ember-data:deprecate-non-strict-id',
+      until: '6.0',
+      for: 'ember-data',
+      since: {
+        available: '5.3',
+        enabled: '5.3'
+      }
+    });
+    return normalized;
   }
-  return '' + id;
+  assert(`Resource IDs must be a non-empty string or null. Received '${String(id)}'.`, id === null || typeof id === 'string' && id.length > 0);
+  return id;
 }
 function ensureStringId(id) {
   let normalized = null;
   if (typeof id === 'string') {
     normalized = id.length > 0 ? id : null;
   } else if (typeof id === 'number' && !isNaN(id)) {
-    normalized = '' + id;
-  }
-  if (normalized === null) {
-    throw new Error(`Expected id to be a string or number, received ${String(id)}`);
+    normalized = String(id);
   }
+  assert(`Expected id to be a string or number, received ${String(id)}`, normalized !== null);
   return normalized;
 }
 
 // provided for additional debuggability
 const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');
 const DEBUG_IDENTIFIER_BUCKET = Symbol('identifier-bucket');
-function isNonEmptyString(str) {
-  return str && typeof str === 'string';
-}
-function normalizeModelName(modelName) {
-  return dasherize(modelName);
+function normalizeModelName(type) {
+  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_TYPES)) {
+    const result = dasherize(type);
+    deprecate(`The resource type '${type}' is not normalized. Update your application code to use '${result}' instead of '${type}'.`, result === type, {
+      id: 'ember-data:deprecate-non-strict-types',
+      until: '6.0',
+      for: 'ember-data',
+      since: {
+        available: '5.3',
+        enabled: '5.3'
+      }
+    });
+    return result;
+  }
+  return type;
 }
 
 /**
@@ -441,6 +454,21 @@ function installPolyfill() {
     };
   }
 }
+function isResource(resource) {
+  return Boolean(resource && typeof resource === 'object');
+}
+function hasProp(resource, prop) {
+  return Boolean(isResource(resource) && prop in resource && typeof resource[prop] === 'string' && resource[prop].length);
+}
+function hasLid(resource) {
+  return hasProp(resource, 'lid');
+}
+function hasId(resource) {
+  return hasProp(resource, 'id') || Boolean(isResource(resource) && 'id' in resource && typeof resource.id === 'number');
+}
+function hasType(resource) {
+  return hasProp(resource, 'type');
+}
 
 /**
   @module @ember-data/store
@@ -459,7 +487,7 @@ if (macroCondition(getOwnConfig().polyfillUUID)) {
   installPolyfill();
 }
 function uuidv4() {
-  assert('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/emberjs/data#randomuuid-polyfill', _crypto.randomUUID);
+  assert('crypto.randomUUID needs to be avaliable. Some browsers incorrectly disallow it in insecure contexts. You maybe want to enable the polyfill: https://github.com/emberjs/data#randomuuid-polyfill', typeof _crypto.randomUUID === 'function');
   return _crypto.randomUUID();
 }
 function freeze(obj) {
@@ -468,6 +496,9 @@ function freeze(obj) {
   }
   return obj;
 }
+
+// type IdentifierTypeLookup = { all: Set<StableRecordIdentifier>; id: Map<string, StableRecordIdentifier> };
+// type IdentifiersByType = Map<string, IdentifierTypeLookup>;
 let configuredForgetMethod;
 let configuredGenerationMethod;
 let configuredResetMethod;
@@ -484,20 +515,46 @@ function setIdentifierForgetMethod(method) {
 function setIdentifierResetMethod(method) {
   configuredResetMethod = method;
 }
+
+// Map<type, Map<id, lid>>
+
+const NEW_IDENTIFIERS = new Map();
+function updateTypeIdMapping(typeMap, identifier, id) {
+  let idMap = typeMap.get(identifier.type);
+  if (!idMap) {
+    idMap = new Map();
+    typeMap.set(identifier.type, idMap);
+  }
+  idMap.set(id, identifier.lid);
+}
+function defaultUpdateMethod(identifier, data, bucket) {
+  if (bucket === 'record') {
+    assert(`Expected identifier to be a StableRecordIdentifier`, isStableIdentifier(identifier));
+    if (!identifier.id && hasId(data)) {
+      updateTypeIdMapping(NEW_IDENTIFIERS, identifier, data.id);
+    }
+  }
+}
+function defaultKeyInfoMethod(resource, known) {
+  // TODO RFC something to make this configurable
+  const id = hasId(resource) ? coerceId(resource.id) : null;
+  const type = hasType(resource) ? normalizeModelName(resource.type) : known ? known.type : null;
+  assert(`Expected keyInfoForResource to provide a type for the resource`, type);
+  return {
+    type,
+    id
+  };
+}
 function defaultGenerationMethod(data, bucket) {
   if (bucket === 'record') {
-    if (isNonEmptyString(data.lid)) {
+    if (hasLid(data)) {
       return data.lid;
     }
-    if (data.id !== undefined) {
-      let {
-        type,
-        id
-      } = data;
-      // TODO: add test for id not a string
-      if (isNonEmptyString(coerceId(id))) {
-        return `@lid:${normalizeModelName(type)}-${id}`;
-      }
+    assert(`Cannot generate an identifier for a resource without a type`, hasType(data));
+    if (hasId(data)) {
+      const type = normalizeModelName(data.type);
+      const lid = NEW_IDENTIFIERS.get(type)?.get(data.id);
+      return lid || `@lid:${type}-${data.id}`;
     }
     return uuidv4();
   } else if (bucket === 'document') {
@@ -512,6 +569,9 @@ function defaultGenerationMethod(data, bucket) {
   assert(`Unknown bucket ${bucket}`, false);
 }
 function defaultEmptyCallback(...args) {}
+function defaultMergeMethod(a, _b, _c) {
+  return a;
+}
 let DEBUG_MAP;
 if (macroCondition(getOwnConfig().env.DEBUG)) {
   DEBUG_MAP = new WeakMap();
@@ -532,19 +592,20 @@ if (macroCondition(getOwnConfig().env.DEBUG)) {
  */
 class IdentifierCache {
   constructor() {
-    this._cache = {
-      lids: new Map(),
-      types: Object.create(null),
-      documents: new Map()
-    };
     // we cache the user configuredGenerationMethod at init because it must
     // be configured prior and is not allowed to be changed
     this._generate = configuredGenerationMethod || defaultGenerationMethod;
-    this._update = configuredUpdateMethod || defaultEmptyCallback;
+    this._update = configuredUpdateMethod || defaultUpdateMethod;
     this._forget = configuredForgetMethod || defaultEmptyCallback;
     this._reset = configuredResetMethod || defaultEmptyCallback;
-    this._merge = defaultEmptyCallback;
+    this._merge = defaultMergeMethod;
+    this._keyInfoForResource = defaultKeyInfoMethod;
     this._isDefaultConfig = !configuredGenerationMethod;
+    this._cache = {
+      resources: new Map(),
+      resourcesByType: Object.create(null),
+      documents: new Map()
+    };
   }
 
   /**
@@ -557,7 +618,10 @@ class IdentifierCache {
    * @private
    */
   __configureMerge(method) {
-    this._merge = method || defaultEmptyCallback;
+    this._merge = method || defaultMergeMethod;
+  }
+  upgradeIdentifier(resource) {
+    return this._getRecordIdentifier(resource, 2);
   }
 
   /**
@@ -565,130 +629,62 @@ class IdentifierCache {
    * @private
    */
 
-  _getRecordIdentifier(resource, shouldGenerate = false) {
+  _getRecordIdentifier(resource, shouldGenerate) {
+    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      // eslint-disable-next-line no-console
+      console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
+    }
     // short circuit if we're already the stable version
     if (isStableIdentifier(resource)) {
       if (macroCondition(getOwnConfig().env.DEBUG)) {
         // TODO should we instead just treat this case as a new generation skipping the short circuit?
-        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`);
+        if (!this._cache.resources.has(resource.lid) || this._cache.resources.get(resource.lid) !== resource) {
+          throw new Error(`The supplied identifier ${JSON.stringify(resource)} does not belong to this store instance`);
         }
       }
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
-        console.log(`Identifiers: Peeked Identifier was already Stable ${String(resource)}`);
+        console.log(`Identifiers: cache HIT - Stable ${resource.lid}`);
+        // eslint-disable-next-line no-console
+        console.groupEnd();
       }
       return resource;
     }
-    let lid = coerceId(resource.lid);
-    let identifier = lid !== null ? this._cache.lids.get(lid) : undefined;
+
+    // the resource is unknown, ask the application to identify this data for us
+    const lid = this._generate(resource, 'record');
+    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+      // eslint-disable-next-line no-console
+      console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
+    }
+    let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
     if (identifier !== undefined) {
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
-        console.log(`Identifiers: cache HIT ${identifier}`, resource);
+        console.groupEnd();
       }
       return identifier;
     }
-    if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
-      // eslint-disable-next-line no-console
-      console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
-    }
-    if (shouldGenerate === false) {
-      if (!resource.type || !resource.id) {
-        return;
-      }
-    }
-
-    // `type` must always be present
-    assert('resource.type needs to be a string', 'type' in resource && isNonEmptyString(resource.type));
-    let type = resource.type && normalizeModelName(resource.type);
-    let id = coerceId(resource.id);
-    let keyOptions = getTypeIndex(this._cache.types, type);
-
-    // go straight for the stable RecordIdentifier key'd to `lid`
-    if (lid !== null) {
-      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.get(id);
-    }
-    if (identifier === undefined) {
-      // we have definitely not seen this resource before
-      // so we allow the user configured `GenerationMethod` to tell us
-      let newLid = this._generate(resource, 'record');
+    if (shouldGenerate === 0) {
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
-        console.log(`Identifiers: lid ${newLid} determined for resource`, resource);
-      }
-
-      // we do this _even_ when `lid` is present because secondary lookups
-      // may need to be populated, but we enforce not giving us something
-      // different than expected
-      if (lid !== null && newLid !== lid) {
-        throw new Error(`You should not change the <lid> of a RecordIdentifier`);
-      } 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.get(newLid);
-      }
-      if (shouldGenerate === true) {
-        if (identifier === undefined) {
-          // if we still don't have an identifier, time to generate one
-          identifier = makeStableRecordIdentifier(id, type, newLid, 'record', false);
-
-          // populate our unique table
-          if (macroCondition(getOwnConfig().env.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.has(identifier.lid)) {
-              throw new Error(`You should not change the <type> of a RecordIdentifier`);
-            }
-          }
-          this._cache.lids.set(identifier.lid, identifier);
-
-          // populate our primary lookup table
-          // TODO consider having the `lid` cache be
-          // one level up
-          keyOptions.lid.set(identifier.lid, identifier);
-          if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
-            if (shouldGenerate) {
-              // eslint-disable-next-line no-console
-              console.log(`Identifiers: generated ${String(identifier)} for`, resource);
-              if (resource[DEBUG_IDENTIFIER_BUCKET]) {
-                // eslint-disable-next-line no-console
-                console.trace(`[WARNING] Identifiers: generated a new identifier from a previously used identifier. This is likely a bug.`);
-              }
-            }
-          }
-        }
-
-        // populate our own secondary lookup table
-        // even for the "successful" secondary lookup
-        // by `_generate()`, since we missed the cache
-        // previously
-        // we use identifier.id instead of id here
-        // because they may not match and we prefer
-        // what we've set via resource data
-        if (identifier.id !== null) {
-          keyOptions.id.set(identifier.id, identifier);
-
-          // TODO allow filling out of `id` here
-          // for the `username` non-client created
-          // case.
-        }
+        console.groupEnd();
       }
+      return;
     }
 
+    // if we still don't have an identifier, time to generate one
+    if (shouldGenerate === 2) {
+      resource.lid = lid;
+      identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(resource, 'record', false);
+    } else {
+      // we lie a bit here as a memory optimization
+      const keyInfo = this._keyInfoForResource(resource, null);
+      keyInfo.lid = lid;
+      identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(keyInfo, 'record', false);
+    }
+    addResourceToCache(this._cache, identifier);
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
-      if (!identifier && !shouldGenerate) {
-        // eslint-disable-next-line no-console
-        console.log(`Identifiers: cache MISS`, resource);
-      }
       // eslint-disable-next-line no-console
       console.groupEnd();
     }
@@ -706,7 +702,7 @@ class IdentifierCache {
    * @private
    */
   peekRecordIdentifier(resource) {
-    return this._getRecordIdentifier(resource, false);
+    return this._getRecordIdentifier(resource, 0);
   }
 
   /**
@@ -751,9 +747,8 @@ class IdentifierCache {
     @returns {StableRecordIdentifier}
     @public
   */
-
   getOrCreateRecordIdentifier(resource) {
-    return this._getRecordIdentifier(resource, true);
+    return this._getRecordIdentifier(resource, 1);
   }
 
   /**
@@ -769,22 +764,21 @@ class IdentifierCache {
   */
   createIdentifierForNewRecord(data) {
     let newLid = this._generate(data, 'record');
-    let identifier = makeStableRecordIdentifier(data.id || null, data.type, newLid, 'record', true);
-    let keyOptions = getTypeIndex(this._cache.types, data.type);
+    let identifier = /*#__NOINLINE__*/makeStableRecordIdentifier({
+      id: data.id || null,
+      type: data.type,
+      lid: newLid
+    }, 'record', true);
 
     // populate our unique table
     if (macroCondition(getOwnConfig().env.DEBUG)) {
-      if (this._cache.lids.has(identifier.lid)) {
+      if (this._cache.resources.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.set(identifier.lid, identifier);
 
-    // populate the type+lid cache
-    keyOptions.lid.set(newLid, identifier);
-    if (data.id) {
-      keyOptions.id.set(data.id, identifier);
-    }
+    /*#__NOINLINE__*/
+    addResourceToCache(this._cache, identifier);
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
       console.log(`Identifiers: created identifier ${String(identifier)} for newly generated resource`, data);
@@ -812,43 +806,49 @@ class IdentifierCache {
   */
   updateRecordIdentifier(identifierObject, data) {
     let identifier = this.getOrCreateRecordIdentifier(identifierObject);
-    let newId = data.id !== undefined ? coerceId(data.id) : null;
-    let existingIdentifier = detectMerge(this._cache.types, identifier, data, newId, this._cache.lids);
+    const keyInfo = this._keyInfoForResource(data, identifier);
+    let existingIdentifier = /*#__NOINLINE__*/detectMerge(this._cache, keyInfo, identifier, data);
+    const hadLid = hasLid(data);
     if (!existingIdentifier) {
       // If the incoming type does not match the identifier type, we need to create an identifier for the incoming
       // data so we can merge the incoming data with the existing identifier, see #7325 and #7363
-      if (data.type && identifier.type !== normalizeModelName(data.type)) {
-        let incomingDataResource = {
-          ...data
-        };
-        // Need to strip the lid from the incomingData in order force a new identifier creation
-        delete incomingDataResource.lid;
-        existingIdentifier = this.getOrCreateRecordIdentifier(incomingDataResource);
+      if (identifier.type !== keyInfo.type) {
+        if (hadLid) {
+          // Strip the lid to ensure we force a new identifier creation
+          delete data.lid;
+        }
+        existingIdentifier = this.getOrCreateRecordIdentifier(data);
       }
     }
     if (existingIdentifier) {
-      let keyOptions = getTypeIndex(this._cache.types, identifier.type);
       let generatedIdentifier = identifier;
-      identifier = this._mergeRecordIdentifiers(keyOptions, generatedIdentifier, existingIdentifier, data, newId);
+      identifier = this._mergeRecordIdentifiers(keyInfo, generatedIdentifier, existingIdentifier, data);
+
+      // make sure that the `lid` on the data we are processing matches the lid we kept
+      if (hadLid) {
+        data.lid = identifier.lid;
+      }
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
         console.log(`Identifiers: merged identifiers ${generatedIdentifier.lid} and ${existingIdentifier.lid} for resource into ${identifier.lid}`, data);
       }
     }
     let id = identifier.id;
-    performRecordIdentifierUpdate(identifier, data, this._update);
-    newId = identifier.id;
+    /*#__NOINLINE__*/
+    performRecordIdentifierUpdate(identifier, keyInfo, data, this._update);
+    const newId = identifier.id;
 
     // add to our own secondary lookup table
     if (id !== newId && newId !== null) {
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
-        console.log(`Identifiers: updated id for identifier ${identifier.lid} from '${id}' to '${newId}' for resource`, data);
+        console.log(`Identifiers: updated id for identifier ${identifier.lid} from '${String(id)}' to '${String(newId)}' for resource`, data);
       }
-      let keyOptions = getTypeIndex(this._cache.types, identifier.type);
-      keyOptions.id.set(newId, identifier);
+      const typeSet = this._cache.resourcesByType[identifier.type];
+      assert(`Expected to find a typeSet for ${identifier.type}`, typeSet);
+      typeSet.id.set(newId, identifier);
       if (id !== null) {
-        keyOptions.id.delete(id);
+        typeSet.id.delete(id);
       }
     } else if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
@@ -861,22 +861,22 @@ class IdentifierCache {
    * @method _mergeRecordIdentifiers
    * @private
    */
-  _mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId) {
+  _mergeRecordIdentifiers(keyInfo, identifier, existingIdentifier, data) {
+    assert(`Expected keyInfo to contain an id`, hasId(keyInfo));
     // delegate determining which identifier to keep to the configured MergeMethod
-    let kept = this._merge(identifier, existingIdentifier, data);
-    let abandoned = kept === identifier ? existingIdentifier : identifier;
+    const kept = this._merge(identifier, existingIdentifier, data);
+    const abandoned = kept === identifier ? existingIdentifier : identifier;
 
     // cleanup the identifier we no longer need
     this.forgetRecordIdentifier(abandoned);
 
     // ensure a secondary cache entry for this id for the identifier we do keep
-    keyOptions.id.set(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.set(newId, kept);
+    // let baseKeyOptions = getTypeIndex(this._cache.resourcesByType, existingIdentifier.type);
+    // 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;
     return kept;
   }
 
@@ -891,14 +891,15 @@ class IdentifierCache {
    @public
   */
   forgetRecordIdentifier(identifierObject) {
-    let identifier = this.getOrCreateRecordIdentifier(identifierObject);
-    let keyOptions = getTypeIndex(this._cache.types, identifier.type);
+    const identifier = this.getOrCreateRecordIdentifier(identifierObject);
+    const typeSet = this._cache.resourcesByType[identifier.type];
+    assert(`Expected to find a typeSet for ${identifier.type}`, typeSet);
     if (identifier.id !== null) {
-      keyOptions.id.delete(identifier.id);
+      typeSet.id.delete(identifier.id);
     }
-    this._cache.lids.delete(identifier.lid);
-    keyOptions.lid.delete(identifier.lid);
-    IDENTIFIERS.delete(identifierObject);
+    this._cache.resources.delete(identifier.lid);
+    typeSet.lid.delete(identifier.lid);
+    IDENTIFIERS.delete(identifier);
     this._forget(identifier, 'record');
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
       // eslint-disable-next-line no-console
@@ -906,29 +907,14 @@ class IdentifierCache {
     }
   }
   destroy() {
+    NEW_IDENTIFIERS.clear();
     this._cache.documents.forEach(identifier => {
       DOCUMENTS.delete(identifier);
     });
     this._reset();
   }
 }
-function getTypeIndex(typeMap, type) {
-  let typeIndex = typeMap[type];
-  if (typeIndex === undefined) {
-    typeIndex = {
-      lid: new Map(),
-      id: new Map()
-    };
-    typeMap[type] = typeIndex;
-  }
-  return typeIndex;
-}
-function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = false) {
-  let recordIdentifier = {
-    lid,
-    id,
-    type
-  };
+function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated) {
   IDENTIFIERS.add(recordIdentifier);
   if (macroCondition(getOwnConfig().env.DEBUG)) {
     // we enforce immutability in dev
@@ -944,15 +930,15 @@ function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = fa
         return recordIdentifier.type;
       },
       toString() {
-        let {
+        const {
           type,
           id,
           lid
         } = recordIdentifier;
-        return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${type}:${id} (${lid})`;
+        return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${String(type)}:${String(id)} (${lid})`;
       },
       toJSON() {
-        let {
+        const {
           type,
           id,
           lid
@@ -973,37 +959,33 @@ function makeStableRecordIdentifier(id, type, lid, bucket, clientOriginated = fa
   }
   return recordIdentifier;
 }
-function performRecordIdentifierUpdate(identifier, data, updateFn) {
+function performRecordIdentifierUpdate(identifier, keyInfo, data, updateFn) {
   if (macroCondition(getOwnConfig().env.DEBUG)) {
-    let {
-      lid
-    } = data;
-    let id = 'id' in data ? data.id : undefined;
-    let type = 'type' in data && data.type && normalizeModelName(data.type);
+    const {
+      id,
+      type
+    } = keyInfo;
 
     // get the mutable instance behind our proxy wrapper
     let wrapper = identifier;
     identifier = DEBUG_MAP.get(wrapper);
-    if (lid !== undefined) {
-      let newLid = coerceId(lid);
-      if (newLid !== identifier.lid) {
-        throw new Error(`The 'lid' for a RecordIdentifier cannot be updated once it has been created. Attempted to set lid for '${wrapper}' to '${lid}'.`);
+    if (hasLid(data)) {
+      const lid = data.lid;
+      if (lid !== identifier.lid) {
+        throw new Error(`The 'lid' for a RecordIdentifier cannot be updated once it has been created. Attempted to set lid for '${wrapper.lid}' to '${lid}'.`);
       }
     }
-    if (id !== undefined) {
-      let newId = coerceId(id);
-      if (identifier.id !== null && identifier.id !== newId) {
-        // here we warn and ignore, as this may be a mistake, but we allow the user
-        // to have multiple cache-keys pointing at a single lid so we cannot error
-        warn(`The 'id' for a RecordIdentifier should not be updated once it has been set. Attempted to set id for '${wrapper}' to '${newId}'.`, false, {
-          id: 'ember-data:multiple-ids-for-identifier'
-        });
-      }
+    if (id && identifier.id !== null && identifier.id !== id) {
+      // here we warn and ignore, as this may be a mistake, but we allow the user
+      // to have multiple cache-keys pointing at a single lid so we cannot error
+      warn(`The 'id' for a RecordIdentifier should not be updated once it has been set. Attempted to set id for '${wrapper.lid}' to '${id}'.`, false, {
+        id: 'ember-data:multiple-ids-for-identifier'
+      });
     }
 
     // TODO consider just ignoring here to allow flexible polymorphic support
     if (type && type !== identifier.type) {
-      throw new Error(`The 'type' for a RecordIdentifier cannot be updated once it has been set. Attempted to set type for '${wrapper}' to '${type}'.`);
+      throw new Error(`The 'type' for a RecordIdentifier cannot be updated once it has been set. Attempted to set type for '${wrapper.lid}' to '${type}'.`);
     }
     updateFn(wrapper, data, 'record');
   } else {
@@ -1018,32 +1000,62 @@ function performRecordIdentifierUpdate(identifier, data, updateFn) {
     identifier.id = coerceId(data.id);
   }
 }
-function detectMerge(typesCache, identifier, data, newId, lids) {
+function detectMerge(cache, keyInfo, identifier, data) {
+  const newId = keyInfo.id;
   const {
     id,
     type,
     lid
   } = identifier;
+  const typeSet = cache.resourcesByType[identifier.type];
+
+  // if the IDs are present but do not match
+  // then check if we have an existing identifier
+  // for the newer ID.
   if (id !== null && id !== newId && newId !== null) {
-    let keyOptions = getTypeIndex(typesCache, identifier.type);
-    let existingIdentifier = keyOptions.id.get(newId);
+    const existingIdentifier = typeSet && typeSet.id.get(newId);
     return existingIdentifier !== undefined ? existingIdentifier : false;
   } else {
-    let newType = data.type && normalizeModelName(data.type);
+    const newType = keyInfo.type;
 
     // 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.get(data.lid);
-      return existingIdentifier !== undefined ? existingIdentifier : false;
+    // we trigger a merge of the identifiers
+    // though probably we should just throw an error here
+    if (id !== null && id === newId && newType === type && hasLid(data) && data.lid !== lid) {
+      return cache.resources.get(data.lid) || 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.get(id);
+    } else if (id !== null && id === newId && newType && newType !== type && hasLid(data) && data.lid === lid) {
+      const newTypeSet = cache.resourcesByType[newType];
+      const existingIdentifier = newTypeSet && newTypeSet.id.get(newId);
       return existingIdentifier !== undefined ? existingIdentifier : false;
     }
   }
   return false;
 }
+function getIdentifierFromLid(cache, lid, resource) {
+  const identifier = cache.resources.get(lid);
+  if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
+    // eslint-disable-next-line no-console
+    console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
+  }
+  return identifier;
+}
+function addResourceToCache(cache, identifier) {
+  cache.resources.set(identifier.lid, identifier);
+  let typeSet = cache.resourcesByType[identifier.type];
+  if (!typeSet) {
+    typeSet = {
+      lid: new Map(),
+      id: new Map()
+    };
+    cache.resourcesByType[identifier.type] = typeSet;
+  }
+  typeSet.lid.set(identifier.lid, identifier);
+  if (identifier.id) {
+    typeSet.id.set(identifier.id, identifier);
+  }
+}
 var _class$1, _descriptor$1;
 
 /**
@@ -1402,9 +1414,12 @@ class InstanceCache {
     store.identifierCache.__configureMerge((identifier, matchedIdentifier, resourceData) => {
       let keptIdentifier = identifier;
       if (identifier.id !== matchedIdentifier.id) {
+        // @ts-expect-error TODO this needs to be fixed
         keptIdentifier = 'id' in resourceData && identifier.id === resourceData.id ? identifier : matchedIdentifier;
       } else if (identifier.type !== matchedIdentifier.type) {
-        keptIdentifier = 'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
+        keptIdentifier =
+        // @ts-expect-error TODO this needs to be fixed
+        'type' in resourceData && identifier.type === resourceData.type ? identifier : matchedIdentifier;
       }
       let staleIdentifier = identifier === keptIdentifier ? matchedIdentifier : identifier;
 
@@ -1419,6 +1434,7 @@ class InstanceCache {
         // we can probably just "swap" what data source the abandoned
         // record points at so long as
         // it itself is not retained by the store in any way.
+        // @ts-expect-error TODO this needs to be fixed
         if ('id' in resourceData) {
           throw new Error(`Failed to update the 'id' for the RecordIdentifier '${identifier.type}:${String(identifier.id)} (${identifier.lid})' to '${String(resourceData.id)}', because that id is already in use by '${matchedIdentifier.type}:${String(matchedIdentifier.id)} (${matchedIdentifier.lid})'`);
         }
@@ -1557,11 +1573,11 @@ class InstanceCache {
     if (type === undefined) {
       // it would be cool if we could just de-ref cache here
       // but probably would require WeakRef models to do so.
-      cache.lids.forEach(identifier => {
+      cache.resources.forEach(identifier => {
         this.unloadRecord(identifier);
       });
     } else {
-      const typeCache = cache.types;
+      const typeCache = cache.resourcesByType;
       let identifiers = typeCache[type]?.lid;
       if (identifiers) {
         identifiers.forEach(identifier => {
@@ -1683,7 +1699,7 @@ function _convertPreloadRelationshipToJSON(value, type) {
   if (typeof value === 'string' || typeof value === 'number') {
     return {
       type,
-      id: value
+      id: ensureStringId(value)
     };
   }
   // TODO if not a record instance assert it's an identifier
@@ -1712,7 +1728,7 @@ function getShimClass(store, modelName) {
   return shim;
 }
 function mapFromHash(hash) {
-  let map = new Map();
+  const map = new Map();
   for (let i in hash) {
     if (Object.prototype.hasOwnProperty.call(hash, i)) {
       map.set(i, hash[i]);
@@ -1721,7 +1737,7 @@ function mapFromHash(hash) {
   return map;
 }
 
-// Mimics the static apis of DSModel
+// Mimics the static apis of @ember-data/model
 class ShimModelClass {
   constructor(store, modelName) {
     this.__store = store;
@@ -2561,13 +2577,13 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     @type Store
     */
 
-  destroy() {
-    this.isDestroying = true;
+  destroy(clear) {
+    this.isDestroying = !clear;
     // changing the reference breaks the Proxy
     // this[SOURCE] = [];
     this[SOURCE].length = 0;
     this[NOTIFY]();
-    this.isDestroyed = true;
+    this.isDestroyed = !clear;
   }
 
   // length must be on self for proxied methods to work properly
@@ -2872,8 +2888,8 @@ class Collection extends IdentifierArray {
     });
     return promise;
   }
-  destroy() {
-    super.destroy();
+  destroy(clear) {
+    super.destroy(clear);
     this._manager._managed.delete(this);
     this._manager._pending.delete(this);
   }
@@ -2971,10 +2987,14 @@ class RecordArrayManager {
     this._staged = new Map();
     this._keyedArrays = new Map();
     this._identifiers = new Map();
+    this._set = new Map();
+    this._visibilitySet = new Map();
     this._subscription = this.store.notifications.subscribe('resource', (identifier, type) => {
       if (type === 'added') {
+        this._visibilitySet.set(identifier, true);
         this.identifierAdded(identifier);
       } else if (type === 'removed') {
+        this._visibilitySet.set(identifier, false);
         this.identifierRemoved(identifier);
       } else if (type === 'state') {
         this.identifierChanged(identifier);
@@ -2986,7 +3006,7 @@ class RecordArrayManager {
     if (!pending || this.isDestroying || this.isDestroyed) {
       return;
     }
-    sync(array, pending);
+    sync(array, pending, this._set.get(array));
     this._pending.delete(array);
   }
 
@@ -3019,6 +3039,7 @@ class RecordArrayManager {
         manager: this
       });
       this._live.set(type, array);
+      this._set.set(array, new Set(identifiers));
     }
     return array;
   }
@@ -3036,6 +3057,7 @@ class RecordArrayManager {
     };
     let array = new Collection(options);
     this._managed.add(array);
+    this._set.set(array, new Set(options.identifiers || []));
     if (config.identifiers) {
       associate(this._identifiers, array, config.identifiers);
     }
@@ -3107,6 +3129,7 @@ class RecordArrayManager {
     const old = source.slice();
     source.length = 0;
     fastPush(source, identifiers);
+    this._set.set(array, new Set(identifiers));
     notifyArray(array);
     array.meta = payload.meta || null;
     array.links = payload.links || null;
@@ -3144,21 +3167,30 @@ class RecordArrayManager {
   }
   identifierChanged(identifier) {
     let newState = this.store._instanceCache.recordIsLoaded(identifier, true);
+
+    // if the change matches the most recent direct added/removed
+    // state, then we can ignore it
+    if (this._visibilitySet.get(identifier) === newState) {
+      return;
+    }
     if (newState) {
       this.identifierAdded(identifier);
     } else {
       this.identifierRemoved(identifier);
     }
   }
-  clear() {
-    this._live.forEach(array => array.destroy());
-    this._managed.forEach(array => array.destroy());
+  clear(isClear = true) {
+    this._live.forEach(array => array.destroy(isClear));
+    this._managed.forEach(array => array.destroy(isClear));
     this._managed.clear();
     this._identifiers.clear();
+    this._pending.clear();
+    this._set.forEach(set => set.clear());
+    this._visibilitySet.clear();
   }
   destroy() {
     this.isDestroying = true;
-    this.clear();
+    this.clear(false);
     this._live.clear();
     this.isDestroyed = true;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -3187,19 +3219,20 @@ function disassociateIdentifier(ArraysCache, array, identifier) {
     cache.delete(array);
   }
 }
-function sync(array, changes) {
+function sync(array, changes, arraySet) {
   let state = array[SOURCE];
   const adds = [];
   const removes = [];
   changes.forEach((value, key) => {
     if (value === 'add') {
       // likely we want to keep a Set along-side
-      if (state.includes(key)) {
+      if (arraySet.has(key)) {
         return;
       }
       adds.push(key);
+      arraySet.add(key);
     } else {
-      if (state.includes(key)) {
+      if (arraySet.has(key)) {
         removes.push(key);
       }
     }
@@ -3207,6 +3240,7 @@ function sync(array, changes) {
   if (removes.length) {
     if (removes.length === state.length) {
       state.length = 0;
+      arraySet.clear();
       // changing the reference breaks the Proxy
       // state = array[SOURCE] = [];
     } else {
@@ -3214,6 +3248,7 @@ function sync(array, changes) {
         const index = state.indexOf(i);
         if (index !== -1) {
           state.splice(index, 1);
+          arraySet.delete(i);
         }
       });
     }
@@ -3232,11 +3267,9 @@ function sync(array, changes) {
   }
 }
 
-/**
- * @module @ember-data/store
- */
 const Touching = Symbol('touching');
 const RequestPromise = Symbol('promise');
+const EMPTY_ARR = macroCondition(getOwnConfig().env.DEBUG) ? Object.freeze([]) : [];
 function hasRecordIdentifier(op) {
   return 'recordIdentifier' in op;
 }
@@ -3250,9 +3283,9 @@ function hasRecordIdentifier(op) {
  */
 class RequestStateService {
   constructor(store) {
-    this._pending = Object.create(null);
+    this._pending = new Map();
     this._done = new Map();
-    this._subscriptions = Object.create(null);
+    this._subscriptions = new Map();
     this._toFlush = [];
     this._store = void 0;
     this._store = store;
@@ -3263,10 +3296,10 @@ class RequestStateService {
   _enqueue(promise, queryRequest) {
     let query = queryRequest.data[0];
     if (hasRecordIdentifier(query)) {
-      let lid = query.recordIdentifier.lid;
+      const identifier = query.recordIdentifier;
       let type = query.op === 'saveRecord' ? 'mutation' : 'query';
-      if (!this._pending[lid]) {
-        this._pending[lid] = [];
+      if (!this._pending.has(identifier)) {
+        this._pending.set(identifier, []);
       }
       let request = {
         state: 'pending',
@@ -3275,10 +3308,10 @@ class RequestStateService {
       };
       request[Touching] = [query.recordIdentifier];
       request[RequestPromise] = promise;
-      this._pending[lid].push(request);
+      this._pending.get(identifier).push(request);
       this._triggerSubscriptions(request);
       return promise.then(result => {
-        this._dequeue(lid, request);
+        this._dequeue(identifier, request);
         let finalizedRequest = {
           state: 'fulfilled',
           request: queryRequest,
@@ -3292,7 +3325,7 @@ class RequestStateService {
         this._triggerSubscriptions(finalizedRequest);
         return result;
       }, error => {
-        this._dequeue(lid, request);
+        this._dequeue(identifier, request);
         let finalizedRequest = {
           state: 'rejected',
           request: queryRequest,
@@ -3329,13 +3362,15 @@ class RequestStateService {
   }
   _flushRequest(req) {
     req[Touching].forEach(identifier => {
-      if (this._subscriptions[identifier.lid]) {
-        this._subscriptions[identifier.lid].forEach(callback => callback(req));
+      const subscriptions = this._subscriptions.get(identifier);
+      if (subscriptions) {
+        subscriptions.forEach(callback => callback(req));
       }
     });
   }
-  _dequeue(lid, request) {
-    this._pending[lid] = this._pending[lid].filter(req => req !== request);
+  _dequeue(identifier, request) {
+    const pending = this._pending.get(identifier);
+    this._pending.set(identifier, pending.filter(req => req !== request));
   }
   _addDone(request) {
     request[Touching].forEach(identifier => {
@@ -3346,7 +3381,7 @@ class RequestStateService {
         requests = requests.filter(req => {
           // TODO add support for multiple
           let data;
-          if (req.request.data instanceof Array) {
+          if (Array.isArray(req.request.data)) {
             data = req.request.data[0];
           } else {
             data = req.request.data;
@@ -3390,10 +3425,12 @@ class RequestStateService {
    * @param {(state: RequestState) => void} callback
    */
   subscribeForRecord(identifier, callback) {
-    if (!this._subscriptions[identifier.lid]) {
-      this._subscriptions[identifier.lid] = [];
+    let subscriptions = this._subscriptions.get(identifier);
+    if (!subscriptions) {
+      subscriptions = [];
+      this._subscriptions.set(identifier, subscriptions);
     }
-    this._subscriptions[identifier.lid].push(callback);
+    subscriptions.push(callback);
   }
 
   /**
@@ -3405,10 +3442,7 @@ class RequestStateService {
    * @returns {RequestState[]} an array of request states for any pending requests for the given identifier
    */
   getPendingRequestsForRecord(identifier) {
-    if (this._pending[identifier.lid]) {
-      return this._pending[identifier.lid];
-    }
-    return [];
+    return this._pending.get(identifier) || EMPTY_ARR;
   }
 
   /**
@@ -3427,6 +3461,9 @@ class RequestStateService {
     return null;
   }
 }
+function isNonEmptyString(str) {
+  return Boolean(str && typeof str === 'string');
+}
 function constructResource(type, id, lid) {
   if (typeof type === 'object' && type !== null) {
     let resource = type;
@@ -3623,17 +3660,34 @@ class Store extends EmberObject {
   _run(cb) {
     assert(`EmberData should never encounter a nested run`, !this._cbs);
     const _cbs = this._cbs = {};
-    cb();
-    if (_cbs.coalesce) {
-      _cbs.coalesce();
-    }
-    if (_cbs.sync) {
-      _cbs.sync();
-    }
-    if (_cbs.notify) {
-      _cbs.notify();
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      try {
+        cb();
+        if (_cbs.coalesce) {
+          _cbs.coalesce();
+        }
+        if (_cbs.sync) {
+          _cbs.sync();
+        }
+        if (_cbs.notify) {
+          _cbs.notify();
+        }
+      } finally {
+        this._cbs = null;
+      }
+    } else {
+      cb();
+      if (_cbs.coalesce) {
+        _cbs.coalesce();
+      }
+      if (_cbs.sync) {
+        _cbs.sync();
+      }
+      if (_cbs.notify) {
+        _cbs.notify();
+      }
+      this._cbs = null;
     }
-    this._cbs = null;
   }
   _join(cb) {
     if (this._cbs) {
@@ -3666,9 +3720,8 @@ class Store extends EmberObject {
     if (macroCondition(getOwnConfig().env.TESTING)) {
       const all = [];
       const pending = this._requestCache._pending;
-      const lids = Object.keys(pending);
-      lids.forEach(lid => {
-        all.push(...pending[lid].map(v => v[RequestPromise]));
+      pending.forEach(requests => {
+        all.push(...requests.map(v => v[RequestPromise]));
       });
       this.requestManager._pending.forEach(v => all.push(v));
       const promise = Promise.allSettled(all);
@@ -3994,7 +4047,7 @@ class Store extends EmberObject {
         };
         if (resource.id) {
           const identifier = this.identifierCache.peekRecordIdentifier(resource);
-          assert(`The id ${properties.id} has already been used with another '${normalizedModelName}' record.`, !identifier);
+          assert(`The id ${String(properties.id)} has already been used with another '${normalizedModelName}' record.`, !identifier);
         }
         const identifier = this.identifierCache.createIdentifierForNewRecord(resource);
         const cache = this.cache;
@@ -4476,7 +4529,7 @@ class Store extends EmberObject {
       assertDestroyingStore(this, 'peekRecord');
     }
     assert(`You need to pass a model name to the store's peekRecord method`, identifier);
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${identifier}`, typeof identifier === 'string');
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(identifier)}`, typeof identifier === 'string');
     const type = normalizeModelName(identifier);
     const normalizedId = ensureStringId(id);
     const resource = {
@@ -4864,7 +4917,7 @@ class Store extends EmberObject {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyedStoreOnly(this, 'unloadAll');
     }
-    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, !modelName || typeof modelName === 'string');
+    assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${String(modelName)}`, !modelName || typeof modelName === 'string');
     this._join(() => {
       if (modelName === undefined) {
         // destroy the graph before unloadAll
@@ -5032,7 +5085,7 @@ class Store extends EmberObject {
      @method _push
     @private
     @param {Object} jsonApiDoc
-    @return {StableRecordIdentifier|Array<StableRecordIdentifier>} identifiers for the primary records that had data loaded
+    @return {StableRecordIdentifier|Array<StableRecordIdentifier>|null} identifiers for the primary records that had data loaded
   */
   _push(jsonApiDoc, asyncFlush) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
@@ -5058,7 +5111,7 @@ class Store extends EmberObject {
       });
     });
     this._enableAsyncFlush = null;
-    return ret.data;
+    return 'data' in ret ? ret.data : null;
   }
 
   /**
@@ -5109,19 +5162,10 @@ class Store extends EmberObject {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'pushPayload');
     }
-    let serializer;
-    let payload;
-    if (!inputPayload) {
-      payload = modelName;
-      serializer = this.serializerFor('application');
-      assert(`You cannot use 'store#pushPayload' without a modelName unless your default serializer defines 'pushPayload'`, typeof serializer.pushPayload === 'function');
-    } else {
-      payload = inputPayload;
-      assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${modelName}`, typeof modelName === 'string');
-      let normalizedModelName = normalizeModelName(modelName);
-      serializer = this.serializerFor(normalizedModelName);
-    }
-    assert(`You must define a pushPayload method in your serializer in order to call store.pushPayload`, serializer.pushPayload);
+    const payload = inputPayload || modelName;
+    const normalizedModelName = inputPayload ? normalizeModelName(modelName) : 'application';
+    const serializer = this.serializerFor(normalizedModelName);
+    assert(`You cannot use 'store.pushPayload(<type>, <payload>)' unless the serializer for '${normalizedModelName}' defines 'pushPayload'`, serializer && typeof serializer.pushPayload === 'function');
     serializer.pushPayload(this, payload);
   }
 
@@ -5147,7 +5191,7 @@ class Store extends EmberObject {
       return Promise.reject(`Record Is Disconnected`);
     }
     // TODO we used to check if the record was destroyed here
-    assert(`Cannot initiate a save request for an unloaded record: ${identifier}`, this._instanceCache.recordIsLoaded(identifier));
+    assert(`Cannot initiate a save request for an unloaded record: ${identifier.lid}`, this._instanceCache.recordIsLoaded(identifier));
     if (resourceIsFullyDeleted(this._instanceCache, identifier)) {
       return Promise.resolve(record);
     }
@@ -5235,11 +5279,11 @@ class Store extends EmberObject {
     }
     assert(`You need to pass a model name to the store's normalize method`, modelName);
     assert(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`, typeof modelName === 'string');
-    let normalizedModelName = normalizeModelName(modelName);
-    let serializer = this.serializerFor(normalizedModelName);
-    let model = this.modelFor(normalizedModelName);
-    assert(`You must define a normalize method in your serializer in order to call store.normalize`, serializer?.normalize);
-    return serializer.normalize(model, payload);
+    const normalizedModelName = normalizeModelName(modelName);
+    const serializer = this.serializerFor(normalizedModelName);
+    const schema = this.modelFor(normalizedModelName);
+    assert(`You must define a normalize method in your serializer in order to call store.normalize`, typeof serializer?.normalize === 'function');
+    return serializer.normalize(schema, payload);
   }
 
   /**
@@ -5268,7 +5312,7 @@ class Store extends EmberObject {
     if (adapter) {
       return adapter;
     }
-    let owner = getOwner(this);
+    const owner = getOwner(this);
 
     // name specific adapter
     adapter = owner.lookup(`adapter:${normalizedModelName}`);
@@ -5315,9 +5359,9 @@ class Store extends EmberObject {
     if (serializer) {
       return serializer;
     }
-    let owner = getOwner(this);
 
     // by name
+    const owner = getOwner(this);
     serializer = owner.lookup(`serializer:${normalizedModelName}`);
     if (serializer !== undefined) {
       _serializerCache[normalizedModelName] = serializer;
@@ -5369,9 +5413,11 @@ class Store extends EmberObject {
 let assertDestroyingStore;
 let assertDestroyedStoreOnly;
 if (macroCondition(getOwnConfig().env.DEBUG)) {
-  assertDestroyingStore = function assertDestroyedStore(store, method) {
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  assertDestroyingStore = function assertDestroyingStore(store, method) {
     assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !(store.isDestroying || store.isDestroyed));
   };
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   assertDestroyedStoreOnly = function assertDestroyedStoreOnly(store, method) {
     assert(`Attempted to call store.${method}(), but the store instance has already been destroyed.`, !store.isDestroyed);
   };