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

package/addon/-debug/index.js

@@ -9,7 +9,7 @@ import { DEBUG } from '@glimmer/env';
   relationship (specified via `relationshipMeta`) of the `record`.
 
   This utility should only be used internally, as both record parameters must
-  be an InternalModel and the `relationshipMeta` needs to be the meta
+  be stable record identifiers and the `relationshipMeta` needs to be the meta
   information about the relationship, retrieved via
   `record.relationshipFor(key)`.
 */

package/addon/-private/{identifier-cache.ts → caches/identifier-cache.ts}

@@ -4,6 +4,9 @@
 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 {
   ForgetMethod,
@@ -18,13 +21,12 @@ import type {
 } from '@ember-data/types/q/identifier';
 import type { ConfidentDict } from '@ember-data/types/q/utils';
 
-import coerceId from './coerce-id';
-import { DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from './identifer-debug-consts';
-import normalizeModelName from './normalize-model-name';
-import isNonEmptyString from './utils/is-non-empty-string';
-import WeakCache from './weak-cache';
+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';
 
-const IDENTIFIERS = new WeakSet();
+const IDENTIFIERS = new Set();
 
 export function isStableIdentifier(identifier: Object): identifier is StableRecordIdentifier {
   return IDENTIFIERS.has(identifier);
@@ -33,6 +35,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();
 }
@@ -47,10 +53,9 @@ function freeze<T>(obj: T): T {
 interface KeyOptions {
   lid: IdentifierMap;
   id: IdentifierMap;
-  _allIdentifiers: StableRecordIdentifier[];
 }
 
-type IdentifierMap = ConfidentDict<StableRecordIdentifier>;
+type IdentifierMap = Map<string, StableRecordIdentifier>;
 type TypeMap = ConfidentDict<KeyOptions>;
 export type MergeMethod = (
   targetIdentifier: StableRecordIdentifier,
@@ -79,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}`;
@@ -97,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>();
 }
 
 /**
@@ -114,19 +122,16 @@ 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,
+    lids: new Map<string, StableRecordIdentifier>(),
     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;
+  declare _isDefaultConfig: boolean;
 
   constructor() {
     // we cache the user configuredGenerationMethod at init because it must
@@ -136,13 +141,14 @@ export class IdentifierCache {
     this._forget = configuredForgetMethod || defaultEmptyCallback;
     this._reset = configuredResetMethod || defaultEmptyCallback;
     this._merge = defaultEmptyCallback;
+    this._isDefaultConfig = !configuredGenerationMethod;
   }
 
   /**
    * Internal hook to allow management of merge conflicts with identifiers.
    *
-   * we allow late binding of this private internal merge so that `internalModelFactory`
-   * can insert itself here to handle elimination of duplicates
+   * we allow late binding of this private internal merge so that
+   * the cache can insert itself here to handle elimination of duplicates
    *
    * @method __configureMerge
    * @private
@@ -155,12 +161,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 {
@@ -168,22 +171,35 @@ 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.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 (LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: Peeked Identifier was already Stable ${String(resource)}`);
+      }
       return resource;
     }
 
     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) {
+        // eslint-disable-next-line no-console
+        console.log(`Identifiers: cache HIT ${identifier}`, resource);
+      }
       return identifier;
     }
 
+    if (LOG_IDENTIFIERS) {
+      // eslint-disable-next-line no-console
+      console.groupCollapsed(`Identifiers: ${shouldGenerate ? 'Generating' : 'Peeking'} Identifier`, resource);
+    }
+
     if (shouldGenerate === false) {
-      if (!('type' in resource) || !('id' in resource) || !resource.type || !resource.id) {
+      if (!(resource as ExistingResourceObject).type || !(resource as ExistingResourceObject).id) {
         return;
       }
     }
@@ -198,31 +214,35 @@ 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) {
       // 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 (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) {
+      } 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) {
@@ -234,19 +254,27 @@ 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.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;
-          // TODO exists temporarily to support `peekAll`
-          // but likely to move
-          keyOptions._allIdentifiers.push(identifier);
+          keyOptions.lid.set(identifier.lid, identifier);
+
+          if (LOG_IDENTIFIERS && 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
@@ -257,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
@@ -266,6 +294,15 @@ export class IdentifierCache {
       }
     }
 
+    if (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();
+    }
+
     return identifier;
   }
 
@@ -322,17 +359,22 @@ export class IdentifierCache {
 
     // populate our unique table
     if (DEBUG) {
-      if (identifier.lid in this._cache.lids) {
+      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;
-    // ensure a peekAll sees our new identifier too
-    // TODO move this outta here?
-    keyOptions._allIdentifiers.push(identifier);
+    keyOptions.lid.set(newLid, identifier);
+    if (data.id) {
+      keyOptions.id.set(data.id, identifier);
+    }
+
+    if (LOG_IDENTIFIERS) {
+      // eslint-disable-next-line no-console
+      console.log(`Identifiers: createded identifier ${String(identifier)} for newly generated resource`, data);
+    }
 
     return identifier;
   }
@@ -362,13 +404,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;
@@ -378,7 +424,21 @@ export class IdentifierCache {
 
     if (existingIdentifier) {
       let keyOptions = getTypeIndex(this._cache.types, identifier.type);
-      identifier = this._mergeRecordIdentifiers(keyOptions, identifier, existingIdentifier, data, newId as string);
+      let generatedIdentifier = identifier;
+      identifier = this._mergeRecordIdentifiers(
+        keyOptions,
+        generatedIdentifier,
+        existingIdentifier,
+        data,
+        newId as string
+      );
+      if (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;
@@ -387,12 +447,22 @@ export class IdentifierCache {
 
     // add to our own secondary lookup table
     if (id !== newId && newId !== null) {
+      if (LOG_IDENTIFIERS) {
+        // eslint-disable-next-line no-console
+        console.log(
+          `Identifiers: updated id for identifier ${identifier.lid} from '${id}' to '${newId}' for resource`,
+          data
+        );
+      }
       let keyOptions = getTypeIndex(this._cache.types, identifier.type);
-      keyOptions.id[newId] = identifier;
+      keyOptions.id.set(newId, identifier);
 
       if (id !== null) {
-        delete keyOptions.id[id];
+        keyOptions.id.delete(id);
       }
+    } else if (LOG_IDENTIFIERS) {
+      // eslint-disable-next-line no-console
+      console.log(`Identifiers: updated identifier ${identifier.lid} resource`, data);
     }
 
     return identifier;
@@ -417,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;
@@ -444,16 +514,17 @@ 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.delete(identifier.id);
     }
-    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.delete(identifier.lid);
+    keyOptions.lid.delete(identifier.lid);
 
     IDENTIFIERS.delete(identifierObject);
     this._forget(identifier, 'record');
+    if (LOG_IDENTIFIERS) {
+      // eslint-disable-next-line no-console
+      console.log(`Identifiers: released identifier ${identifierObject.lid}`);
+    }
   }
 
   destroy() {
@@ -466,9 +537,8 @@ function getTypeIndex(typeMap: TypeMap, type: string): KeyOptions {
 
   if (typeIndex === undefined) {
     typeIndex = {
-      lid: Object.create(null),
-      id: Object.create(null),
-      _allIdentifiers: [],
+      lid: new Map(),
+      id: new Map(),
     };
     typeMap[type] = typeIndex;
   }
@@ -507,6 +577,10 @@ function makeStableRecordIdentifier(
         let { type, id, lid } = recordIdentifier;
         return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${type}:${id} (${lid})`;
       },
+      toJSON() {
+        let { type, id, lid } = recordIdentifier;
+        return { type, id, lid };
+      },
     };
     wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
     wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
@@ -568,8 +642,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);
   }
 }
 
@@ -583,20 +657,20 @@ 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 {
-    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) {
-      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;
     }
   }