@ember-data/model 4.12.4 → 4.12.6

package/addon/-private.js

@@ -1,5 +1,5 @@
-import { M as Model } from "./has-many-c1bfdebf";
-export { E as Errors, L as LEGACY_SUPPORT, R as ManyArray, P as PromiseBelongsTo, c as PromiseManyArray, a as attr, b as belongsTo, h as hasMany } from "./has-many-c1bfdebf";
+import { M as Model } from "./has-many-d45aa09e";
+export { E as Errors, L as LEGACY_SUPPORT, R as ManyArray, P as PromiseBelongsTo, c as PromiseManyArray, a as attr, b as belongsTo, h as hasMany } from "./has-many-d45aa09e";
 import { getOwner } from '@ember/application';
 
 /*

package/addon/{has-many-c1bfdebf.js → has-many-d45aa09e.js}

@@ -14,8 +14,8 @@ import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 import ObjectProxy from '@ember/object/proxy';
 import ArrayProxy from '@ember/array/proxy';
 import { mapBy, not } from '@ember/object/computed';
-import { cacheFor } from '@ember/object/internals';
 import { addToTransaction, subscribe } from '@ember-data/tracking/-private';
+import { cacheFor } from '@ember/object/internals';
 function isElementDescriptor(args) {
   let [maybeTarget, maybeKey, maybeDesc] = args;
   return (
@@ -639,6 +639,28 @@ let Errors = (_dec$1 = computed(), _dec2 = mapBy('content', 'message'), _dec3 =
   initializer: null
 })), _class$6));
 
+/*
+NOTES ON MANY ARRAY DUPLICATION DEPRECATION APPROACH:
+
+// 4.6 behavior
+
+dedupe, no error and no deprecation
+
+// 4.12 approach
+
+DEPRECATE_MANY_ARRAY_DUPLICATES_4_12 === true => dedupe, no error
+DEPRECATE_MANY_ARRAY_DUPLICATES_4_12 === false => no dedupe, error (same as 6.0)
+
+// 5.3 approach
+
+DEPRECATE_MANY_ARRAY_DUPLICATES === true => dedupe, deprecation
+DEPRECATE_MANY_ARRAY_DUPLICATES === false => no dedupe, error (same as 6.0)
+
+// 6.0 approach
+
+no-dedupe, error
+*/
+
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
   relationship.
@@ -742,109 +764,192 @@ class RelatedCollection extends RecordArray {
     this.identifier = options.identifier;
     this.key = options.key;
   }
-  [MUTATE](prop, args, result) {
+  [MUTATE](target, receiver, prop, args, _TAG) {
     switch (prop) {
       case 'length 0':
         {
-          this._manager.mutate({
-            op: 'replaceRelatedRecords',
-            record: this.identifier,
-            field: this.key,
-            value: []
-          });
-          break;
+          Reflect.set(target, 'length', 0);
+          mutateReplaceRelatedRecords(this, [], _TAG);
+          return true;
         }
       case 'replace cell':
         {
           const [index, prior, value] = args;
-          this._manager.mutate({
-            op: 'replaceRelatedRecord',
-            record: this.identifier,
-            field: this.key,
+          target[index] = value;
+          mutateReplaceRelatedRecord(this, {
             value,
             prior,
             index
-          });
-          break;
+          }, _TAG);
+          return true;
         }
       case 'push':
-        this._manager.mutate({
-          op: 'addToRelatedRecords',
-          record: this.identifier,
-          field: this.key,
-          value: extractIdentifiersFromRecords(args)
-        });
-        break;
+        {
+          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES_4_12)) {
+            // dedupe, no error
+            const seen = new Set(target);
+            const unique = new Set();
+            args.forEach(item => {
+              const identifier = recordIdentifierFor$1(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.add(item);
+              }
+            });
+            const newArgs = Array.from(unique);
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (newArgs.length) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(newArgs)
+              }, _TAG);
+            }
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const newValues = extractIdentifiersFromRecords(args);
+          assertNoDuplicates(this, target, currentState => currentState.push(...newValues), `Cannot push duplicates to a hasMany's state.`);
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (newValues.length) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues
+            }, _TAG);
+          }
+          return result;
+        }
       case 'pop':
-        if (result) {
-          this._manager.mutate({
-            op: 'removeFromRelatedRecords',
-            record: this.identifier,
-            field: this.key,
-            value: recordIdentifierFor$1(result)
-          });
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (result) {
+            mutateRemoveFromRelatedRecords(this, {
+              value: recordIdentifierFor$1(result)
+            }, _TAG);
+          }
+          return result;
         }
-        break;
       case 'unshift':
-        this._manager.mutate({
-          op: 'addToRelatedRecords',
-          record: this.identifier,
-          field: this.key,
-          value: extractIdentifiersFromRecords(args),
-          index: 0
-        });
-        break;
+        {
+          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES_4_12)) {
+            // dedupe, no error
+            const seen = new Set(target);
+            const unique = new Set();
+            args.forEach(item => {
+              const identifier = recordIdentifierFor$1(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.add(item);
+              }
+            });
+            const newArgs = Array.from(unique);
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (newArgs.length) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(newArgs),
+                index: 0
+              }, _TAG);
+            }
+            return result;
+          }
+
+          // else, no dedupe, error on duplicates
+          const newValues = extractIdentifiersFromRecords(args);
+          assertNoDuplicates(this, target, currentState => currentState.unshift(...newValues), `Cannot unshift duplicates to a hasMany's state.`);
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (newValues.length) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues,
+              index: 0
+            }, _TAG);
+          }
+          return result;
+        }
       case 'shift':
-        if (result) {
-          this._manager.mutate({
-            op: 'removeFromRelatedRecords',
-            record: this.identifier,
-            field: this.key,
-            value: recordIdentifierFor$1(result),
-            index: 0
-          });
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (result) {
+            mutateRemoveFromRelatedRecords(this, {
+              value: recordIdentifierFor$1(result),
+              index: 0
+            }, _TAG);
+          }
+          return result;
         }
-        break;
       case 'sort':
-        this._manager.mutate({
-          op: 'sortRelatedRecords',
-          record: this.identifier,
-          field: this.key,
-          value: result.map(recordIdentifierFor$1)
-        });
-        break;
+        {
+          const result = Reflect.apply(target[prop], receiver, args);
+          mutateSortRelatedRecords(this, result.map(recordIdentifierFor$1), _TAG);
+          return result;
+        }
       case 'splice':
         {
-          const [start, removeCount, ...adds] = args;
+          const [start, deleteCount, ...adds] = args;
+
           // detect a full replace
-          if (removeCount > 0 && adds.length === this[SOURCE].length) {
-            this._manager.mutate({
-              op: 'replaceRelatedRecords',
-              record: this.identifier,
-              field: this.key,
-              value: extractIdentifiersFromRecords(adds)
+          if (start === 0 && deleteCount === this[SOURCE].length) {
+            if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES_4_12)) {
+              // dedupe, no error
+              const current = new Set(adds);
+              const unique = Array.from(current);
+              const newArgs = [start, deleteCount].concat(unique);
+              const result = Reflect.apply(target[prop], receiver, newArgs);
+              mutateReplaceRelatedRecords(this, extractIdentifiersFromRecords(unique), _TAG);
+              return result;
+            }
+
+            // else, no dedupe, error on duplicates
+            const newValues = extractIdentifiersFromRecords(adds);
+            assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot replace a hasMany's state with a new state that contains duplicates.`);
+            const result = Reflect.apply(target[prop], receiver, args);
+            mutateReplaceRelatedRecords(this, newValues, _TAG);
+            return result;
+          }
+          if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MANY_ARRAY_DUPLICATES_4_12)) {
+            // dedupe, no error
+            const currentState = target.slice();
+            currentState.splice(start, deleteCount);
+            const seen = new Set(currentState);
+            const unique = [];
+            adds.forEach(item => {
+              const identifier = recordIdentifierFor$1(item);
+              if (!seen.has(identifier)) {
+                seen.add(identifier);
+                unique.push(item);
+              }
             });
-            return;
+            const newArgs = [start, deleteCount, ...unique];
+            const result = Reflect.apply(target[prop], receiver, newArgs);
+            if (deleteCount > 0) {
+              mutateRemoveFromRelatedRecords(this, {
+                value: result.map(recordIdentifierFor$1),
+                index: start
+              }, _TAG);
+            }
+            if (unique.length > 0) {
+              mutateAddToRelatedRecords(this, {
+                value: extractIdentifiersFromRecords(unique),
+                index: start
+              }, _TAG);
+            }
+            return result;
           }
-          if (removeCount > 0) {
-            this._manager.mutate({
-              op: 'removeFromRelatedRecords',
-              record: this.identifier,
-              field: this.key,
+
+          // else, no dedupe, error on duplicates
+          const newValues = extractIdentifiersFromRecords(adds);
+          assertNoDuplicates(this, target, currentState => currentState.splice(start, deleteCount, ...newValues), `Cannot splice a hasMany's state with a new state that contains duplicates.`);
+          const result = Reflect.apply(target[prop], receiver, args);
+          if (deleteCount > 0) {
+            mutateRemoveFromRelatedRecords(this, {
               value: result.map(recordIdentifierFor$1),
               index: start
-            });
+            }, _TAG);
           }
-          if (adds?.length) {
-            this._manager.mutate({
-              op: 'addToRelatedRecords',
-              record: this.identifier,
-              field: this.key,
-              value: extractIdentifiersFromRecords(adds),
+          if (newValues.length > 0) {
+            mutateAddToRelatedRecords(this, {
+              value: newValues,
               index: start
-            });
+            }, _TAG);
           }
-          break;
+          return result;
         }
       default:
         assert(`unable to convert ${prop} into a transaction that updates the cache state for this record array`);
@@ -959,6 +1064,58 @@ function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
 function isPromiseRecord$1(record) {
   return !!record.then;
 }
+function assertNoDuplicates(collection, target, callback, reason) {
+  const state = target.slice();
+  callback(state);
+  if (state.length !== new Set(state).size) {
+    const duplicates = state.filter((currentValue, currentIndex) => state.indexOf(currentValue) !== currentIndex);
+    throw new Error(`${reason} Found duplicates for the following records within the new state provided to \`<${collection.identifier.type}:${collection.identifier.id || collection.identifier.lid}>.${collection.key}\`\n\t- ${Array.from(new Set(duplicates)).map(r => isStableIdentifier(r) ? r.lid : recordIdentifierFor$1(r).lid).sort((a, b) => a.localeCompare(b)).join('\n\t- ')}`);
+  }
+}
+function mutateAddToRelatedRecords(collection, operationInfo, _TAG) {
+  mutate(collection, {
+    op: 'addToRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _TAG);
+}
+function mutateRemoveFromRelatedRecords(collection, operationInfo, _TAG) {
+  mutate(collection, {
+    op: 'removeFromRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _TAG);
+}
+function mutateReplaceRelatedRecord(collection, operationInfo, _TAG) {
+  mutate(collection, {
+    op: 'replaceRelatedRecord',
+    record: collection.identifier,
+    field: collection.key,
+    ...operationInfo
+  }, _TAG);
+}
+function mutateReplaceRelatedRecords(collection, value, _TAG) {
+  mutate(collection, {
+    op: 'replaceRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    value
+  }, _TAG);
+}
+function mutateSortRelatedRecords(collection, value, _TAG) {
+  mutate(collection, {
+    op: 'sortRelatedRecords',
+    record: collection.identifier,
+    field: collection.key,
+    value
+  }, _TAG);
+}
+function mutate(collection, mutation, _TAG) {
+  collection._manager.mutate(mutation);
+  addToTransaction(_TAG);
+}
 var _dec, _class$5;
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -2521,9 +2678,8 @@ class LegacySupport {
       if (relatedIdentifier === null) {
         return null;
       } else {
-        let toReturn = store._instanceCache.getRecord(relatedIdentifier);
-        assert(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`, toReturn === null || store._instanceCache.recordIsLoaded(relatedIdentifier, true));
-        return toReturn;
+        assert(`You looked up the '${key}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`, store._instanceCache.recordIsLoaded(relatedIdentifier, true));
+        return store._instanceCache.getRecord(relatedIdentifier);
       }
     }
   }