@ember-data/store 5.4.0-alpha.1 → 5.4.0-alpha.11

package/addon/-private.js

@@ -1 +1 @@
-export { f as AdapterPopulatedRecordArray, C as CacheHandler, h as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, m as StoreMap, _ as _clearCaches, e as coerceId, j as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, k as removeRecordDataFor, o as setCacheFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, l as setRecordIdentifier, s as storeFor } from "./store-service-0a03d2a4";
+export { f as AdapterPopulatedRecordArray, C as CacheHandler, h as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, m as StoreMap, _ as _clearCaches, e as coerceId, j as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, k as removeRecordDataFor, o as setCacheFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, l as setRecordIdentifier, s as storeFor } from "./store-service-fc1e0bd5";

package/addon/index.js

@@ -1 +1 @@
-export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-0a03d2a4";
+export { C as CacheHandler, S as default, r as recordIdentifierFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./store-service-fc1e0bd5";

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

@@ -396,6 +396,10 @@ function ensureStringId(id) {
 // provided for additional debuggability
 const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');
 const DEBUG_IDENTIFIER_BUCKET = Symbol('identifier-bucket');
+const DEBUG_STALE_CACHE_OWNER = Symbol('warpDriveStaleCache');
+
+// also present in production
+const CACHE_OWNER = Symbol('warpDriveCache');
 function normalizeModelName(type) {
   if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_STRICT_TYPES)) {
     const result = dasherize(type);
@@ -476,7 +480,7 @@ function hasType(resource) {
 const IDENTIFIERS = new Set();
 const DOCUMENTS = new Set();
 function isStableIdentifier(identifier) {
-  return IDENTIFIERS.has(identifier);
+  return identifier[CACHE_OWNER] !== undefined || IDENTIFIERS.has(identifier);
 }
 function isDocumentIdentifier(identifier) {
   return DOCUMENTS.has(identifier);
@@ -519,6 +523,7 @@ function setIdentifierResetMethod(method) {
 // Map<type, Map<id, lid>>
 
 const NEW_IDENTIFIERS = new Map();
+let IDENTIFIER_CACHE_ID = 0;
 function updateTypeIdMapping(typeMap, identifier, id) {
   let idMap = typeMap.get(identifier.type);
   if (!idMap) {
@@ -601,6 +606,7 @@ class IdentifierCache {
     this._merge = defaultMergeMethod;
     this._keyInfoForResource = defaultKeyInfoMethod;
     this._isDefaultConfig = !configuredGenerationMethod;
+    this._id = IDENTIFIER_CACHE_ID++;
     this._cache = {
       resources: new Map(),
       resourcesByType: Object.create(null),
@@ -658,7 +664,7 @@ class IdentifierCache {
       console.log(`Identifiers: ${lid ? 'no ' : ''}lid ${lid ? lid + ' ' : ''}determined for resource`, resource);
     }
     let identifier = /*#__NOINLINE__*/getIdentifierFromLid(this._cache, lid, resource);
-    if (identifier !== undefined) {
+    if (identifier !== null) {
       if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
         // eslint-disable-next-line no-console
         console.groupEnd();
@@ -676,11 +682,13 @@ class IdentifierCache {
     // if we still don't have an identifier, time to generate one
     if (shouldGenerate === 2) {
       resource.lid = lid;
+      resource[CACHE_OWNER] = this._id;
       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;
+      keyInfo[CACHE_OWNER] = this._id;
       identifier = /*#__NOINLINE__*/makeStableRecordIdentifier(keyInfo, 'record', false);
     }
     addResourceToCache(this._cache, identifier);
@@ -767,7 +775,8 @@ class IdentifierCache {
     let identifier = /*#__NOINLINE__*/makeStableRecordIdentifier({
       id: data.id || null,
       type: data.type,
-      lid: newLid
+      lid: newLid,
+      [CACHE_OWNER]: this._id
     }, 'record', true);
 
     // populate our unique table
@@ -899,6 +908,10 @@ class IdentifierCache {
     }
     this._cache.resources.delete(identifier.lid);
     typeSet.lid.delete(identifier.lid);
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
+      identifier[DEBUG_STALE_CACHE_OWNER] = identifier[CACHE_OWNER];
+    }
+    identifier[CACHE_OWNER] = undefined;
     IDENTIFIERS.delete(identifier);
     this._forget(identifier, 'record');
     if (macroCondition(getOwnConfig().debug.LOG_IDENTIFIERS)) {
@@ -929,15 +942,33 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
       get type() {
         return recordIdentifier.type;
       },
-      toString() {
+      get [CACHE_OWNER]() {
+        return recordIdentifier[CACHE_OWNER];
+      },
+      set [CACHE_OWNER](value) {
+        recordIdentifier[CACHE_OWNER] = value;
+      },
+      get [DEBUG_STALE_CACHE_OWNER]() {
+        return recordIdentifier[DEBUG_STALE_CACHE_OWNER];
+      },
+      set [DEBUG_STALE_CACHE_OWNER](value) {
+        recordIdentifier[DEBUG_STALE_CACHE_OWNER] = value;
+      }
+    };
+    Object.defineProperty(wrapper, 'toString', {
+      enumerable: false,
+      value: () => {
         const {
           type,
           id,
           lid
         } = recordIdentifier;
         return `${clientOriginated ? '[CLIENT_ORIGINATED] ' : ''}${String(type)}:${String(id)} (${lid})`;
-      },
-      toJSON() {
+      }
+    });
+    Object.defineProperty(wrapper, 'toJSON', {
+      enumerable: false,
+      value: () => {
         const {
           type,
           id,
@@ -949,7 +980,7 @@ function makeStableRecordIdentifier(recordIdentifier, bucket, clientOriginated)
           lid
         };
       }
-    };
+    });
     wrapper[DEBUG_CLIENT_ORIGINATED] = clientOriginated;
     wrapper[DEBUG_IDENTIFIER_BUCKET] = bucket;
     IDENTIFIERS.add(wrapper);
@@ -1022,7 +1053,7 @@ function detectMerge(cache, keyInfo, identifier, data) {
     // 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;
+      return getIdentifierFromLid(cache, data.lid, data) || 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 && hasLid(data) && data.lid === lid) {
@@ -1039,7 +1070,7 @@ function getIdentifierFromLid(cache, lid, resource) {
     // eslint-disable-next-line no-console
     console.log(`Identifiers: cache ${identifier ? 'HIT' : 'MISS'} - Non-Stable ${lid}`, resource);
   }
-  return identifier;
+  return identifier || null;
 }
 function addResourceToCache(cache, identifier) {
   cache.resources.set(identifier.lid, identifier);
@@ -2201,6 +2232,65 @@ class CacheManager {
   // Relationships
   // =============
 
+  /**
+   * Query the cache for the changes to relationships of a resource.
+   *
+   * Returns a map of relationship names to RelationshipDiff objects.
+   *
+   * ```ts
+   * type RelationshipDiff =
+  | {
+      kind: 'collection';
+      remoteState: StableRecordIdentifier[];
+      additions: Set<StableRecordIdentifier>;
+      removals: Set<StableRecordIdentifier>;
+      localState: StableRecordIdentifier[];
+      reordered: boolean;
+    }
+  | {
+      kind: 'resource';
+      remoteState: StableRecordIdentifier | null;
+      localState: StableRecordIdentifier | null;
+    };
+    ```
+   *
+   * @method changedRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @returns {Map<string, RelationshipDiff>}
+   */
+  changedRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].changedRelationships(identifier);
+  }
+
+  /**
+   * Query the cache for whether any mutated attributes exist
+   *
+   * @method hasChangedRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @returns {boolean}
+   */
+  hasChangedRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].hasChangedRelationships(identifier);
+  }
+
+  /**
+   * Tell the cache to discard any uncommitted mutations to relationships.
+   *
+   * This will also discard the change on any appropriate inverses.
+   *
+   * This method is a candidate to become a mutation
+   *
+   * @method rollbackRelationships
+   * @public
+   * @param {StableRecordIdentifier} identifier
+   * @returns {string[]} the names of relationships that were restored
+   */
+  rollbackRelationships(identifier) {
+    return _classPrivateFieldBase(this, _cache)[_cache].rollbackRelationships(identifier);
+  }
+
   /**
    * Query the cache for the current state of a relationship property
    *
@@ -2818,7 +2908,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     }
     this.isUpdating = true;
     let updatingPromise = this._update();
-    updatingPromise.finally(() => {
+    void updatingPromise.finally(() => {
       this._updatingPromise = null;
       if (this.isDestroying || this.isDestroyed) {
         return;
@@ -4031,7 +4121,7 @@ class Store extends EmberObject {
         // to avoid conflicts.
 
         if (properties.id === null || properties.id === undefined) {
-          let adapter = this.adapterFor(modelName);
+          let adapter = this.adapterFor(modelName, true);
           if (adapter && adapter.generateIdForRecord) {
             properties.id = adapter.generateIdForRecord(this, modelName, properties);
           } else {
@@ -5298,7 +5388,8 @@ class Store extends EmberObject {
     @param {String} modelName
     @return Adapter
   */
-  adapterFor(modelName) {
+
+  adapterFor(modelName, _allowMissing) {
     if (macroCondition(getOwnConfig().env.DEBUG)) {
       assertDestroyingStore(this, 'adapterFor');
     }
@@ -5328,7 +5419,7 @@ class Store extends EmberObject {
       _adapterCache.application = adapter;
       return adapter;
     }
-    assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`);
+    assert(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`, _allowMissing);
   }
 
   /**