@ember-data/store 4.12.4 → 4.12.6

package/addon/-private.js

@@ -1 +1 @@
-export { f as AdapterPopulatedRecordArray, C as CacheHandler, j as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, h as SOURCE, S as Store, _ as _clearCaches, e as coerceId, k as fastPush, i as isStableIdentifier, n as normalizeModelName, g as notifyArray, p as peekCache, r as recordIdentifierFor, l as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./index-7883b099";
+export { f as AdapterPopulatedRecordArray, C as CacheHandler, j as IDENTIFIER_ARRAY_TAG, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, h as SOURCE, S as Store, _ as _clearCaches, e as coerceId, k as fastPush, i as isStableIdentifier, n as normalizeModelName, g as notifyArray, p as peekCache, r as recordIdentifierFor, l as removeRecordDataFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, s as storeFor } from "./index-ecc2c2e5";

package/addon/{index-7883b099.js → index-ecc2c2e5.js}

@@ -1332,7 +1332,7 @@ function legacyCachePut(store, doc) {
  * `recordDataFor` function supplied to the store
  * hook `instantiateRecord`, and the `recordDataFor`
  * method on the `CacheStoreWrapper`. It is not
- * directly instantiatable.
+ * directly instantiable.
  *
  * It handles translating between cache versions when
  * necessary, for instance when a Store is configured
@@ -1412,7 +1412,7 @@ class NonSingletonCacheManager {
    * semantics, `put` has `replace` semantics similar to
    * the `http` method `PUT`
    *
-   * the individually cacheabl
+   * the individually cacheable
    * e resource data it may contain
    * should upsert, but the document data surrounding it should
    * fully replace any existing information
@@ -1517,7 +1517,7 @@ class NonSingletonCacheManager {
    * An implementation might want to do this because
    * de-referencing records which read from their own
    * blob is generally safer because the record does
-   * not require retainining connections to the Store
+   * not require retaining connections to the Store
    * and Cache to present data on a per-field basis.
    *
    * This generally takes the place of `getAttr` as
@@ -1746,7 +1746,7 @@ class NonSingletonCacheManager {
   // ================
 
   /**
-   * [LIFECYLCE] Signal to the cache that a new record has been instantiated on the client
+   * [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
    *
    * It returns properties from options that should be set on the record during the create
    * process. This return value behavior is deprecated.
@@ -2599,7 +2599,7 @@ class LegacyWrapper {
       if (!isStableIdentifier(type)) {
         // we also deprecate create capability. This behavior was problematic because
         // there's no outside association between this RecordData and an Identifier.
-        // It's likely a mistake when we hit this codepath, but we said in an early
+        // It's likely a mistake when we hit this code-path, but we said in an early
         // RFC we'd allow this.
         // With V2 we are enforcing someone to use the record-data and identifier-cache APIs to
         // create a new identifier and then call clientDidCreate on the RecordData
@@ -2717,6 +2717,8 @@ class V2CacheStoreWrapper {
     if (this._store._cbs) {
       this._store._schedule('notify', () => this._flushNotifications());
     } else {
+      // TODO @runspired determine if relationship mutations should schedule
+      // into join/run vs immediate flush
       this._flushNotifications();
     }
   }
@@ -2949,10 +2951,14 @@ class InstanceCache {
             until: '5.0'
           });
         }
+        assert(`Cannot create a record for ${identifier.type + ':' + String(identifier.id)} (${identifier.lid}) as no resource data exists`,
+        // @ts-expect-error managedVersion is private and debug only
+        Boolean(cache.managedVersion === '1' || cache.peek(identifier)));
         record = this.store.instantiateRecord(identifier, properties || {},
         // @ts-expect-error
         this.__cacheFor, this.store.notifications);
       } else {
+        assert(`Cannot create a record for ${identifier.type + ':' + String(identifier.id)} (${identifier.lid}) as no resource data exists`, cache.peek(identifier));
         record = this.store.instantiateRecord(identifier, properties || {});
       }
       setRecordIdentifier(record, identifier);
@@ -4005,7 +4011,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
     this[IS_COLLECTION] = true;
     this[SOURCE] = void 0;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let self = this;
+    const self = this;
     this.modelName = options.type;
     this.store = options.store;
     this._manager = options.manager;
@@ -4050,7 +4056,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
               fn = function () {
                 subscribe(_TAG);
                 transaction = true;
-                let result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
+                const result = safeForEach(receiver, target, store, arguments[0], arguments[1]);
                 transaction = false;
                 return result;
               };
@@ -4060,7 +4066,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
                 // array functions must run through Reflect to work properly
                 // binding via other means will not work.
                 transaction = true;
-                let result = Reflect.apply(target[prop], receiver, arguments);
+                const result = Reflect.apply(target[prop], receiver, arguments);
                 transaction = false;
                 return result;
               };
@@ -4082,10 +4088,7 @@ let IdentifierArray = (_class3 = class IdentifierArray {
               const args = Array.prototype.slice.call(arguments);
               assert(`Cannot start a new array transaction while a previous transaction is underway`, !transaction);
               transaction = true;
-              let result = Reflect.apply(target[prop], receiver, args);
-              self[MUTATE](prop, args, result);
-              addToTransaction(_TAG);
-              // TODO handle cache updates
+              const result = self[MUTATE](target, receiver, prop, args, _TAG);
               transaction = false;
               return result;
             };
@@ -4123,13 +4126,11 @@ let IdentifierArray = (_class3 = class IdentifierArray {
         }
         return target[prop];
       },
-      set(target, prop, value) {
+      set(target, prop, value, receiver) {
         if (prop === 'length') {
           if (!transaction && value === 0) {
             transaction = true;
-            addToTransaction(_TAG);
-            Reflect.set(target, prop, value);
-            self[MUTATE]('length 0', []);
+            self[MUTATE](target, receiver, 'length 0', [], _TAG);
             transaction = false;
             return true;
           } else if (transaction) {
@@ -4147,8 +4148,21 @@ let IdentifierArray = (_class3 = class IdentifierArray {
           return true;
         }
         let index = convertToInt(prop);
+
+        // we do not allow "holey" arrays and so if the index is
+        // greater than length then we will disallow setting it.
+        // however, there is a special case for "unshift" with more than
+        // one item being inserted since current items will be moved to the
+        // new indices first.
+        // we "loosely" detect this by just checking whether we are in
+        // a transaction.
         if (index === null || index > target.length) {
-          if (prop in self) {
+          if (index !== null && transaction) {
+            const identifier = recordIdentifierFor(value);
+            assert(`Cannot set index ${index} past the end of the array.`, isStableIdentifier(identifier));
+            target[index] = identifier;
+            return true;
+          } else if (prop in self) {
             self[prop] = value;
             return true;
           }
@@ -4160,10 +4174,27 @@ let IdentifierArray = (_class3 = class IdentifierArray {
         }
         let original = target[index];
         let newIdentifier = extractIdentifierFromRecord$1(value);
-        target[index] = newIdentifier;
+        assert(`Expected a record`, isStableIdentifier(newIdentifier));
+        // We generate "transactions" whenever a setter method on the array
+        // is called and might bulk update multiple array cells. Fundamentally,
+        // all array operations decompose into individual cell replacements.
+        // e.g. a push is really a "replace cell at next index with new value"
+        // or a splice is "shift all values left/right by X and set out of new
+        // bounds cells to undefined"
+        //
+        // so, if we are in a transaction, then this is not a user generated change
+        // but one generated by a setter method. In this case we want to only apply
+        // the change to the target array and not call the MUTATE method.
+        // If there is no transaction though, then this means the user themselves has
+        // directly changed the value of a specific index and we need to thus generate
+        // a mutation for that change.
+        // e.g. "arr.push(newVal)" is handled by a "addToRelatedRecords" mutation within
+        // a transaction.
+        // while "arr[arr.length] = newVal;" is handled by this replace cell code path.
         if (!transaction) {
-          self[MUTATE]('replace cell', [index, original, newIdentifier]);
-          addToTransaction(_TAG);
+          self[MUTATE](target, receiver, 'replace cell', [index, original, newIdentifier], _TAG);
+        } else {
+          target[index] = newIdentifier;
         }
         return true;
       },
@@ -4406,9 +4437,9 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_ARRAY_LIKE)) {
     let arrIndex = Math.sign(index) === -1 ? this.length + index : index;
     return this[arrIndex];
   };
-  IdentifierArray.prototype.objectsAt = function (indeces) {
+  IdentifierArray.prototype.objectsAt = function (indices) {
     deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'objectsAt', 'at');
-    return indeces.map(index => this.objectAt(index));
+    return indices.map(index => this.objectAt(index));
   };
   IdentifierArray.prototype.removeAt = function (index) {
     deprecateArrayLike(this.DEPRECATED_CLASS_NAME, 'removeAt', 'splice');