@ember-data/store 4.13.0-alpha.5 → 4.13.0-alpha.7

package/dist/{-private-ki-omnNZ.js → -private-uEHANwvx.js}

@@ -1,10 +1,10 @@
 import { deprecate, warn, assert } from '@ember/debug';
 import { dasherize } from '@ember-data/request-utils/string';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { setLogging, getRuntimeConfig } from '@warp-drive/build-config/runtime';
 import { EnableHydration, SkipCache } from '@warp-drive/core-types/request';
+import { setLogging, getRuntimeConfig } from '@warp-drive/core-types/runtime';
 import { getOrSetGlobal, peekTransient, setTransient } from '@warp-drive/core-types/-private';
-import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_IDENTIFIER_BUCKET } from '@warp-drive/core-types/identifier';
+import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_IDENTIFIER_BUCKET, DEBUG_CLIENT_ORIGINATED } from '@warp-drive/core-types/identifier';
 import { defineSignal, createSignal, subscribe, createArrayTags, addToTransaction, addTransactionCB } from '@ember-data/tracking/-private';
 import { _backburner } from '@ember/runloop';
 import { get, set } from '@ember/object';
@@ -669,15 +669,13 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
     // we enforce immutability in dev
     //  but preserve our ability to do controlled updates to the reference
     let wrapper = {
-      get lid() {
-        return recordIdentifier.lid;
-      },
+      type: recordIdentifier.type,
+      lid: recordIdentifier.lid,
       get id() {
         return recordIdentifier.id;
-      },
-      get type() {
-        return recordIdentifier.type;
-      },
+      }
+    };
+    const proto = {
       get [CACHE_OWNER]() {
         return recordIdentifier[CACHE_OWNER];
       },
@@ -689,9 +687,15 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
       },
       set [DEBUG_STALE_CACHE_OWNER](value) {
         recordIdentifier[DEBUG_STALE_CACHE_OWNER] = value;
+      },
+      get [DEBUG_CLIENT_ORIGINATED]() {
+        return clientOriginated;
+      },
+      get [DEBUG_IDENTIFIER_BUCKET]() {
+        return bucket;
       }
     };
-    Object.defineProperty(wrapper, 'toString', {
+    Object.defineProperty(proto, 'toString', {
       enumerable: false,
       value: () => {
         const {
@@ -702,7 +706,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
         return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${String(type)}:${String(id)} (${lid})`;
       }
     });
-    Object.defineProperty(wrapper, 'toJSON', {
+    Object.defineProperty(proto, 'toJSON', {
       enumerable: false,
       value: () => {
         const {
@@ -717,8 +721,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
         };
       }
     });
-    wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
-    wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
+    Object.setPrototypeOf(wrapper, proto);
     DEBUG_MAP.set(wrapper, recordIdentifier);
     wrapper = freeze(wrapper);
     return wrapper;
@@ -2313,10 +2316,8 @@ class CacheManager {
  * @module @ember-data/store
  */
 
-let tokenId = 0;
-const CacheOperations = new Set(['added', 'removed', 'state', 'updated', 'invalidated']);
 function isCacheOperationValue(value) {
-  return CacheOperations.has(value);
+  return value === 'added' || value === 'state' || value === 'updated' || value === 'removed' || value === 'invalidated';
 }
 function runLoopIsFlushing() {
   //@ts-expect-error
@@ -2327,8 +2328,16 @@ function count(label) {
   // eslint-disable-next-line
   globalThis.__WarpDriveMetricCountData[label] = (globalThis.__WarpDriveMetricCountData[label] || 0) + 1;
 }
-function _unsubscribe(tokens, token, cache) {
-  const identifier = tokens.get(token);
+function asInternalToken(token) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`Expected a token with a 'for' property`);
+    }
+  })(token && typeof token === 'function' && 'for' in token) : {};
+}
+function _unsubscribe(token, cache) {
+  asInternalToken(token);
+  const identifier = token.for;
   if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
     if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
       if (!identifier) {
@@ -2338,9 +2347,20 @@ function _unsubscribe(tokens, token, cache) {
     }
   }
   if (identifier) {
-    tokens.delete(token);
-    const map = cache.get(identifier);
-    map?.delete(token);
+    const callbacks = cache.get(identifier);
+    if (!callbacks) {
+      return;
+    }
+    const index = callbacks.indexOf(token);
+    if (index === -1) {
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot unsubscribe a token that is not subscribed`);
+        }
+      })(index !== -1) : {};
+      return;
+    }
+    callbacks.splice(index, 1);
   }
 }
 
@@ -2361,7 +2381,6 @@ class NotificationManager {
     this._buffered = new Map();
     this._hasFlush = false;
     this._cache = new Map();
-    this._tokens = new Map();
   }
 
   /**
@@ -2398,17 +2417,26 @@ class NotificationManager {
         throw new Error(`Expected to receive a stable Identifier to subscribe to`);
       }
     })(identifier === 'resource' || identifier === 'document' || isStableIdentifier(identifier) || isDocumentIdentifier(identifier)) : {};
-    let map = this._cache.get(identifier);
-    if (!map) {
-      map = new Map();
-      this._cache.set(identifier, map);
+    let callbacks = this._cache.get(identifier);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`expected to receive a valid callback`);
+      }
+    })(typeof callback === 'function') : {};
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`cannot subscribe with the same callback twice`);
+      }
+    })(!callbacks || !callbacks.includes(callback)) : {};
+    // we use the callback as the cancellation token
+    //@ts-expect-error
+    callback.for = identifier;
+    if (!callbacks) {
+      callbacks = [];
+      this._cache.set(identifier, callbacks);
     }
-    const unsubToken = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? {
-      _tokenRef: tokenId++
-    } : {};
-    map.set(unsubToken, callback);
-    this._tokens.set(unsubToken, identifier);
-    return unsubToken;
+    callbacks.push(callback);
+    return callback;
   }
 
   /**
@@ -2420,7 +2448,7 @@ class NotificationManager {
    */
   unsubscribe(token) {
     if (!this.isDestroyed) {
-      _unsubscribe(this._tokens, token, this._cache);
+      _unsubscribe(token, this._cache);
     }
   }
 
@@ -2450,7 +2478,7 @@ class NotificationManager {
       }
       return false;
     }
-    const hasSubscribers = Boolean(this._cache.get(identifier)?.size);
+    const hasSubscribers = Boolean(this._cache.get(identifier)?.length);
     if (isCacheOperationValue(value) || hasSubscribers) {
       let buffer = this._buffered.get(identifier);
       if (!buffer) {
@@ -2470,9 +2498,16 @@ class NotificationManager {
           }
         }
       }
-    } else if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
-      if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
-        count(`DISCARDED notify ${'type' in identifier ? identifier.type : '<document>'} ${value} ${key}`);
+    } else {
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_NOTIFICATIONS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_NOTIFICATIONS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_NOTIFICATIONS) {
+          log('notify', 'discarded', `${'type' in identifier ? identifier.type : 'document'}`, identifier.lid, `${value}`, key || '');
+        }
+      }
+      if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
+        if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
+          count(`DISCARDED notify ${'type' in identifier ? identifier.type : '<document>'} ${value} ${key}`);
+        }
       }
     }
     return hasSubscribers;
@@ -2525,11 +2560,11 @@ class NotificationManager {
         });
       }
     }
-    const callbackMap = this._cache.get(identifier);
-    if (!callbackMap || !callbackMap.size) {
+    const callbacks = this._cache.get(identifier);
+    if (!callbacks || !callbacks.length) {
       return false;
     }
-    callbackMap.forEach(cb => {
+    callbacks.forEach(cb => {
       // @ts-expect-error overload doesn't narrow within body
       cb(identifier, value, key);
     });
@@ -2537,7 +2572,6 @@ class NotificationManager {
   }
   destroy() {
     this.isDestroyed = true;
-    this._tokens.clear();
     this._cache.clear();
   }
 }
@@ -3124,6 +3158,15 @@ class IdentifierArray {
         })() : {};
       };
     }
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      Object.defineProperty(this, '__SHOW_ME_THE_DATA_(debug mode only)__', {
+        enumerable: false,
+        configurable: true,
+        get() {
+          return proxy.slice();
+        }
+      });
+    }
     createArrayTags(proxy, _SIGNAL);
     this[NOTIFY] = this[NOTIFY].bind(proxy);
     return proxy;
@@ -4327,16 +4370,108 @@ globalThis.setWarpDriveLogging = setLogging;
 globalThis.getWarpDriveRuntimeConfig = getRuntimeConfig;
 if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.LOG_METRIC_COUNTS)) {
   if (getGlobalConfig().WarpDrive.debug.LOG_METRIC_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_METRIC_COUNTS) {
-    // @ts-expect-error
+    // @ts-expect-error adding to globalThis
     // eslint-disable-next-line
     globalThis.__WarpDriveMetricCountData = globalThis.__WarpDriveMetricCountData || {};
 
-    // @ts-expect-error
+    // @ts-expect-error adding to globalThis
     globalThis.getWarpDriveMetricCounts = () => {
       // @ts-expect-error
       // eslint-disable-next-line
-      return globalThis.__WarpDriveMetricCountData;
+      return structuredClone(globalThis.__WarpDriveMetricCountData);
+    };
+
+    // @ts-expect-error adding to globalThis
+    globalThis.resetWarpDriveMetricCounts = () => {
+      // @ts-expect-error
+      globalThis.__WarpDriveMetricCountData = {};
     };
+    if (macroCondition(getGlobalConfig().WarpDrive.activeLogging.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS)) {
+      if (getGlobalConfig().WarpDrive.debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS || globalThis.getWarpDriveRuntimeConfig().debug.__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS) {
+        // @ts-expect-error adding to globalThis
+        globalThis.__primitiveInstanceId = 0;
+        function interceptAndLog(klassName, methodName) {
+          const klass = globalThis[klassName];
+          if (methodName === 'constructor') {
+            const instantiationLabel = `new ${klassName}()`;
+            // @ts-expect-error
+            globalThis[klassName] = class extends klass {
+              // @ts-expect-error
+              constructor(...args) {
+                // eslint-disable-next-line
+                super(...args);
+                // @ts-expect-error
+
+                const instanceId = globalThis.__primitiveInstanceId++;
+                // @ts-expect-error
+                // eslint-disable-next-line
+                globalThis.__WarpDriveMetricCountData[instantiationLabel] =
+                // @ts-expect-error
+                // eslint-disable-next-line
+                (globalThis.__WarpDriveMetricCountData[instantiationLabel] || 0) + 1;
+                // @ts-expect-error
+                this.instanceName = `${klassName}:${instanceId} - ${new Error().stack?.split('\n')[2]}`;
+              }
+            };
+          } else {
+            // @ts-expect-error
+            // eslint-disable-next-line
+            const original = klass.prototype[methodName];
+            const logName = `${klassName}.${methodName}`;
+
+            // @ts-expect-error
+            klass.prototype[methodName] = function (...args) {
+              // @ts-expect-error
+              // eslint-disable-next-line
+              globalThis.__WarpDriveMetricCountData[logName] = (globalThis.__WarpDriveMetricCountData[logName] || 0) + 1;
+              // @ts-expect-error
+              const {
+                instanceName
+              } = this;
+              if (!instanceName) {
+                // @ts-expect-error
+                const instanceId = globalThis.__primitiveInstanceId++;
+                // @ts-expect-error
+                this.instanceName = `${klassName}.${methodName}:${instanceId} - ${new Error().stack?.split('\n')[2]}`;
+              }
+              const instanceLogName = `${logName} (${instanceName})`;
+              // @ts-expect-error
+              // eslint-disable-next-line
+              globalThis.__WarpDriveMetricCountData[instanceLogName] =
+              // @ts-expect-error
+              // eslint-disable-next-line
+              (globalThis.__WarpDriveMetricCountData[instanceLogName] || 0) + 1;
+              // eslint-disable-next-line
+              return original.apply(this, args);
+            };
+          }
+        }
+        interceptAndLog('Set', 'constructor');
+        interceptAndLog('Set', 'add');
+        interceptAndLog('Set', 'delete');
+        interceptAndLog('Set', 'has');
+        interceptAndLog('Set', 'set');
+        interceptAndLog('Set', 'get');
+        interceptAndLog('Map', 'constructor');
+        interceptAndLog('Map', 'set');
+        interceptAndLog('Map', 'delete');
+        interceptAndLog('Map', 'has');
+        interceptAndLog('Map', 'add');
+        interceptAndLog('Map', 'get');
+        interceptAndLog('WeakSet', 'constructor');
+        interceptAndLog('WeakSet', 'add');
+        interceptAndLog('WeakSet', 'delete');
+        interceptAndLog('WeakSet', 'has');
+        interceptAndLog('WeakSet', 'set');
+        interceptAndLog('WeakSet', 'get');
+        interceptAndLog('WeakMap', 'constructor');
+        interceptAndLog('WeakMap', 'set');
+        interceptAndLog('WeakMap', 'delete');
+        interceptAndLog('WeakMap', 'has');
+        interceptAndLog('WeakMap', 'add');
+        interceptAndLog('WeakMap', 'get');
+      }
+    }
   }
 }