Fix missing inverse

addon/-private/system/relationships/relationship-payloads-manager.js

@@ -132,9 +132,11 @@ export default class RelationshipPayloadsManager {
     let modelClass = this._store._modelFor(modelName);
     let relationshipsByName = get(modelClass, 'relationshipsByName');
     relationshipsByName.forEach((_, relationshipName) => {
+      let relationship = relationshipsByName.get(relationshipName);
+      let modelThatOwnsRelationship = relationship.parentType;
       let relationshipPayloads = this._getRelationshipPayloads(modelName, relationshipName, modelClass, relationshipsByName, false);
       if (relationshipPayloads) {
-        relationshipPayloads.unload(modelName, id, relationshipName);
+        relationshipPayloads.unload(modelThatOwnsRelationship.modelName || modelName, id, relationshipName);
       }
     });
   }
@@ -156,7 +158,7 @@ export default class RelationshipPayloadsManager {
       relationshipPayloads.get('user', 'hobbies') === relationshipPayloads.get('hobby', 'user');
 
     The signature has a somewhat large arity to avoid extra work, such as
-      a)  string maipulation & allocation with `modelName` and
+      a)  string manipulation & allocation with `modelName` and
          `relationshipName`
       b)  repeatedly getting `relationshipsByName` via `Ember.get`
 
@@ -167,9 +169,10 @@ export default class RelationshipPayloadsManager {
   _getRelationshipPayloads(modelName, relationshipName, modelClass, relationshipsByName, init) {
     if (!relationshipsByName.has(relationshipName)) { return; }
 
-    let key = `${modelName}:${relationshipName}`;
+    let parentType = relationshipsByName.get(relationshipName).parentType;
+    let key = `${parentType.modelName}:${relationshipName}`;
     if (!this._cache[key] && init) {
-      return this._initializeRelationshipPayloads(modelName, relationshipName, modelClass, relationshipsByName);
+      return this._initializeRelationshipPayloads(parentType.modelName || modelName, relationshipName, parentType, relationshipsByName);
     }
 
     return this._cache[key];

addon/-private/system/relationships/state/create.js

@@ -62,7 +62,8 @@ export default class Relationships {
 
       if (!rel) { return undefined; }
 
-      let relationshipPayload = internalModel.store._relationshipsPayloads.get(internalModel.modelName, internalModel.id, key);
+      let modelThatOwnsRelationship = rel.parentType;
+      let relationshipPayload = internalModel.store._relationshipsPayloads.get(modelThatOwnsRelationship.modelName || internalModel.modelName, internalModel.id, key);
 
       relationship = relationships[key] = createRelationshipFor(internalModel, rel, internalModel.store);
 

tests/integration/inverse-test.js

@@ -6,9 +6,9 @@ import { module, test } from 'qunit';
 
 import DS from 'ember-data';
 
-let env, store, User, Job, ReflexiveModel;
+let env, store, User, Manager, Job, Company, ReflexiveModel;
 
-const { attr, belongsTo } = DS;
+const { attr, belongsTo, hasMany } = DS;
 
 function stringify(string) {
   return function() { return string; };
@@ -19,18 +19,27 @@ module('integration/inverse_test - inverseFor', {
     User = DS.Model.extend({
       name: attr('string'),
       bestFriend: belongsTo('user', { async: true, inverse: null }),
-      job: belongsTo('job', { async: false })
+      job: belongsTo('job', { async: false }),
+      employer: belongsTo('company', {inverse:"employees"})
     });
 
     User.toString = stringify('user');
 
+    Manager = User.extend({});
+    Manager.toString = stringify('manager');
+
     Job = DS.Model.extend({
       isGood: attr(),
       user: belongsTo('user', { async: false })
     });
 
     Job.toString = stringify('job');
 
+    Company = DS.Model.extend({
+      employees: hasMany('user', {inverse: "employer", polymorphic: true})
+    });
+    Company.toString = stringify('company');
+
     ReflexiveModel = DS.Model.extend({
       reflexiveProp: belongsTo('reflexive-model', { async: false })
     });
@@ -39,7 +48,9 @@ module('integration/inverse_test - inverseFor', {
 
     env = setupStore({
       user: User,
+      manager: Manager,
       job: Job,
+      company: Company,
       reflexiveModel: ReflexiveModel
     });
 
@@ -124,6 +135,122 @@ test("Caches findInverseFor return value", function(assert) {
   assert.equal(inverseForUser, Job.inverseFor('user', store), 'Inverse cached succesfully');
 });
 
+test("polymorphic hasMany inverse is populated after push of base model", function(assert) {
+  const done = assert.async();
+
+  run(() => {
+    store.push({
+      data: {
+        id: 'c1',
+        type: 'company',
+        relationships: {
+          employees: {
+            data: [
+              {id: 'u1', type: 'user'}
+            ]
+          }
+        }
+      },
+      included: [
+        {
+          id: 'u1',
+          type: 'user',
+          relationships: {}
+        }
+      ]
+    });
+  });
+
+  const user = store.peekRecord('user', 'u1');
+
+  user.get('employer').then(employer => {
+    assert.ok(employer);
+    done();
+  });
+});
+
+test("polymorphic hasMany inverse is populated after push of descendant model", function(assert) {
+  const done = assert.async();
+
+  run(() => {
+    store.push({
+      data: {
+        id: 'c1',
+        type: 'company',
+        relationships: {
+          employees: {
+            data: [
+              {id: 'u1', type: 'manager'}
+            ]
+          }
+        }
+      },
+      included: [
+        {
+          id: 'u1',
+          type: 'manager',
+          relationships: {}
+        }
+      ]
+    });
+  });
+
+  const user = store.peekRecord('manager', 'u1');
+
+  user.get('employer').then(employer => {
+    assert.ok(employer);
+    done();
+  });
+});
+
+test("polymorphic hasMany contains both models after pushing two different types of model", function(assert) {
+  const done = assert.async();
+
+  run(() => {
+    store.push({
+      data: {
+        id: 'c1',
+        type: 'company',
+        relationships: {
+          employees: {
+            data: [
+            ]
+          }
+        }
+      }
+    });
+    store.push({
+      data: {
+        id: 'u1',
+        type: 'user',
+        relationships: {
+          employer: {
+            data: { id: 'c1', type: 'company'}
+          }
+        }
+      }
+    });
+    store.push({
+      data: {
+        id: 'm1',
+        type: 'manager',
+        relationships: {
+          employer: {
+            data: { id: 'c1', type: 'company'}
+          }
+        }
+      }
+    });
+  });
+
+  const company = store.peekRecord('company', 'c1');
+
+  company.get('employees').then(employees => {
+    assert.equal(employees.length, 2);
+    done();
+  });
+});
+
 testInDebug("Errors out if you do not define an inverse for a reflexive relationship", function(assert) {
 
   //Maybe store is evaluated lazily, so we need this :(