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

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

@@ -4,6 +4,8 @@
 import { assert, warn } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
+import { getOwnConfig, importSync, macroCondition } from '@embroider/macros';
+
 import { LOG_IDENTIFIERS } from '@ember-data/private-build-infra/debugging';
 import type { ExistingResourceObject, ResourceIdentifierObject } from '@ember-data/types/q/ember-data-json-api';
 import type {
@@ -34,6 +36,10 @@ export function isStableIdentifier(identifier: Object): identifier is StableReco
 const isFastBoot = typeof FastBoot !== 'undefined';
 const _crypto: Crypto = isFastBoot ? (FastBoot.require('crypto') as Crypto) : window.crypto;
 
+if (macroCondition(getOwnConfig<{ polyfillUUID: boolean }>().polyfillUUID)) {
+  importSync('./utils/uuid-polyfill');
+}
+
 function uuidv4(): string {
   return _crypto.randomUUID();
 }
@@ -48,7 +54,6 @@ function freeze<T>(obj: T): T {
 interface KeyOptions {
   lid: IdentifierMap;
   id: IdentifierMap;
-  _allIdentifiers: StableRecordIdentifier[];
 }
 
 type IdentifierMap = ConfidentDict<StableRecordIdentifier>;
@@ -115,19 +120,15 @@ if (DEBUG) {
    @public
  */
 export class IdentifierCache {
-  // Typescript still leaks private properties in the final
-  // compiled class, so we may want to move these from _underscore
-  // to a WeakMap to avoid leaking
-  // currently we leak this for test purposes
   _cache = {
     lids: Object.create(null) as IdentifierMap,
     types: Object.create(null) as TypeMap,
   };
-  private _generate: GenerationMethod;
-  private _update: UpdateMethod;
-  private _forget: ForgetMethod;
-  private _reset: ResetMethod;
-  private _merge: MergeMethod;
+  declare _generate: GenerationMethod;
+  declare _update: UpdateMethod;
+  declare _forget: ForgetMethod;
+  declare _reset: ResetMethod;
+  declare _merge: MergeMethod;
 
   constructor() {
     // we cache the user configuredGenerationMethod at init because it must
@@ -156,12 +157,9 @@ export class IdentifierCache {
    * @method _getRecordIdentifier
    * @private
    */
-  private _getRecordIdentifier(resource: ResourceIdentifierObject, shouldGenerate: true): StableRecordIdentifier;
-  private _getRecordIdentifier(
-    resource: ResourceIdentifierObject,
-    shouldGenerate: false
-  ): StableRecordIdentifier | undefined;
-  private _getRecordIdentifier(
+  _getRecordIdentifier(resource: ResourceIdentifierObject, shouldGenerate: true): StableRecordIdentifier;
+  _getRecordIdentifier(resource: ResourceIdentifierObject, shouldGenerate: false): StableRecordIdentifier | undefined;
+  _getRecordIdentifier(
     resource: ResourceIdentifierObject,
     shouldGenerate: boolean = false
   ): StableRecordIdentifier | undefined {
@@ -169,7 +167,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 (!(resource.lid in this._cache.lids) || this._cache.lids[resource.lid] !== resource) {
+        if (!(this._cache.lids[resource.lid] !== undefined) || this._cache.lids[resource.lid] !== resource) {
           throw new Error(`The supplied identifier ${resource} does not belong to this store instance`);
         }
       }
@@ -197,7 +195,7 @@ export class IdentifierCache {
     }
 
     if (shouldGenerate === false) {
-      if (!('type' in resource) || !('id' in resource) || !resource.type || !resource.id) {
+      if (!(resource as ExistingResourceObject).type || !(resource as ExistingResourceObject).id) {
         return;
       }
     }
@@ -252,7 +250,7 @@ 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 (identifier.lid in this._cache.lids) {
+            if (this._cache.lids[identifier.lid] !== undefined) {
               throw new Error(`You should not change the <type> of a RecordIdentifier`);
             }
           }
@@ -262,9 +260,6 @@ export class IdentifierCache {
           // TODO consider having the `lid` cache be
           // one level up
           keyOptions.lid[identifier.lid] = identifier;
-          // TODO exists temporarily to support `peekAll`
-          // but likely to move
-          keyOptions._allIdentifiers.push(identifier);
 
           if (LOG_IDENTIFIERS && shouldGenerate) {
             // eslint-disable-next-line no-console
@@ -360,7 +355,7 @@ export class IdentifierCache {
 
     // populate our unique table
     if (DEBUG) {
-      if (identifier.lid in this._cache.lids) {
+      if (this._cache.lids[identifier.lid] !== undefined) {
         throw new Error(`The lid generated for the new record is not unique as it matches an existing identifier`);
       }
     }
@@ -368,9 +363,6 @@ export class IdentifierCache {
 
     // populate the type+lid cache
     keyOptions.lid[newLid] = identifier;
-    // ensure a peekAll sees our new identifier too
-    // TODO move this outta here?
-    keyOptions._allIdentifiers.push(identifier);
 
     if (LOG_IDENTIFIERS) {
       // eslint-disable-next-line no-console
@@ -405,13 +397,17 @@ export class IdentifierCache {
   updateRecordIdentifier(identifierObject: RecordIdentifier, data: ResourceData): StableRecordIdentifier {
     let identifier = this.getOrCreateRecordIdentifier(identifierObject);
 
-    let newId = 'id' in data ? coerceId(data.id) : null;
+    let newId =
+      (data as ExistingResourceObject).id !== undefined ? coerceId((data as ExistingResourceObject).id) : null;
     let existingIdentifier = detectMerge(this._cache.types, identifier, data, newId, this._cache.lids);
 
     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 ('type' in data && data.type && identifier.type !== normalizeModelName(data.type)) {
+      if (
+        (data as ExistingResourceObject).type &&
+        identifier.type !== normalizeModelName((data as ExistingResourceObject).type)
+      ) {
         let incomingDataResource = { ...data };
         // Need to strip the lid from the incomingData in order force a new identifier creation
         delete incomingDataResource.lid;
@@ -455,7 +451,7 @@ export class IdentifierCache {
       keyOptions.id[newId] = identifier;
 
       if (id !== null) {
-        delete keyOptions.id[id];
+        keyOptions.id[id] = undefined as unknown as StableRecordIdentifier;
       }
     } else if (LOG_IDENTIFIERS) {
       // eslint-disable-next-line no-console
@@ -511,13 +507,10 @@ export class IdentifierCache {
     let identifier = this.getOrCreateRecordIdentifier(identifierObject);
     let keyOptions = getTypeIndex(this._cache.types, identifier.type);
     if (identifier.id !== null) {
-      delete keyOptions.id[identifier.id];
+      keyOptions.id[identifier.id] = undefined as unknown as StableRecordIdentifier;
     }
-    delete this._cache.lids[identifier.lid];
-    delete keyOptions.lid[identifier.lid];
-
-    let index = keyOptions._allIdentifiers.indexOf(identifier);
-    keyOptions._allIdentifiers.splice(index, 1);
+    this._cache.lids[identifier.lid] = undefined as unknown as StableRecordIdentifier;
+    keyOptions.lid[identifier.lid] = undefined as unknown as StableRecordIdentifier;
 
     IDENTIFIERS.delete(identifierObject);
     this._forget(identifier, 'record');
@@ -539,7 +532,6 @@ function getTypeIndex(typeMap: TypeMap, type: string): KeyOptions {
     typeIndex = {
       lid: Object.create(null),
       id: Object.create(null),
-      _allIdentifiers: [],
     };
     typeMap[type] = typeIndex;
   }
@@ -643,8 +635,8 @@ function performRecordIdentifierUpdate(identifier: StableRecordIdentifier, data:
   // for the multiple-cache-key scenario we "could"
   // use a heuristic to guess the best id for display
   // (usually when `data.id` is available and `data.attributes` is not)
-  if ('id' in data && data.id !== undefined) {
-    identifier.id = coerceId(data.id);
+  if ((data as ExistingResourceObject).id !== undefined) {
+    identifier.id = coerceId((data as ExistingResourceObject).id);
   }
 }
 
@@ -662,7 +654,7 @@ function detectMerge(
 
     return existingIdentifier !== undefined ? existingIdentifier : false;
   } else {
-    let newType = 'type' in data && data.type && normalizeModelName(data.type);
+    let newType = (data as ExistingResourceObject).type && normalizeModelName((data as ExistingResourceObject).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) {