chore: convert relationships to use identifiers (emberjs#7470)

* graph

* fix rebase and address comments

* fixup

Author: runspired

.prettierrc

@@ -1,3 +1,3 @@
 singleQuote: true
 trailingComma: 'es5'
-printWidth: 120
+printWidth: 120

packages/-ember-data/tests/acceptance/relationships/belongs-to-test.js

@@ -10,6 +10,7 @@ import { setupRenderingTest } from 'ember-qunit';
 import { ServerError } from '@ember-data/adapter/error';
 import JSONAPIAdapter from '@ember-data/adapter/json-api';
 import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+import { implicitRelationshipsFor } from '@ember-data/record-data/-private';
 import JSONAPISerializer from '@ember-data/serializer/json-api';
 import Store from '@ember-data/store';
 
@@ -259,7 +260,9 @@ module('async belongs-to rendering tests', function(hooks) {
         },
       });
 
-      const implicitRelationships = pete._internalModel.__recordData.__implicitRelationships;
+      const storeWrapper = store._storeWrapper;
+      const identifier = pete._internalModel.identifier;
+      const implicitRelationships = implicitRelationshipsFor(storeWrapper, identifier);
       const implicitKeys = Object.keys(implicitRelationships);
       const petOwnerImplicit = implicitRelationships[implicitKeys[0]];
 

packages/-ember-data/tests/integration/record-data/record-data-errors-test.ts

@@ -102,7 +102,7 @@ class TestRecordData implements RecordData {
   isAttrDirty(key: string) {
     return false;
   }
-  removeFromInverseRelationships(isNew: boolean) {}
+  removeFromInverseRelationships() {}
 
   _initRecordCreateOptions(options) {
     return {};

packages/-ember-data/tests/integration/record-data/record-data-state-test.ts

@@ -99,7 +99,7 @@ class TestRecordData implements RecordData {
   isAttrDirty(key: string) {
     return false;
   }
-  removeFromInverseRelationships(isNew: boolean) {}
+  removeFromInverseRelationships() {}
 
   _initRecordCreateOptions(options) {
     return {};

packages/-ember-data/tests/integration/record-data/record-data-test.ts

@@ -79,7 +79,7 @@ class TestRecordData {
   isAttrDirty(key: string) {
     return false;
   }
-  removeFromInverseRelationships(isNew: boolean) {}
+  removeFromInverseRelationships() {}
 
   _initRecordCreateOptions(options) {}
   isNew() {

packages/-ember-data/tests/integration/record-data/store-wrapper-test.ts

@@ -79,7 +79,7 @@ class TestRecordData {
   isAttrDirty(key: string) {
     return false;
   }
-  removeFromInverseRelationships(isNew: boolean) {}
+  removeFromInverseRelationships() {}
 
   _initRecordCreateOptions(options) {}
 }

packages/-ember-data/tests/integration/references/has-many-test.js

@@ -262,7 +262,7 @@ module('integration/references/has-many', function(hooks) {
             },
             relationships: {
               family: {
-                data: { type: 'family', id: '2' },
+                data: { type: 'family', id: '1' },
               },
             },
           },

packages/-ember-data/tests/integration/relationships/belongs-to-test.js

@@ -10,10 +10,9 @@ import { setupTest } from 'ember-qunit';
 
 import JSONAPIAdapter from '@ember-data/adapter/json-api';
 import Model from '@ember-data/model';
-import { RecordData, relationshipsFor, relationshipStateFor } from '@ember-data/record-data/-private';
+import { relationshipsFor, relationshipStateFor } from '@ember-data/record-data/-private';
 import JSONAPISerializer from '@ember-data/serializer/json-api';
 import Store from '@ember-data/store';
-import { identifierCacheFor, recordDataFor } from '@ember-data/store/-private';
 import testInDebug from '@ember-data/unpublished-test-infra/test-support/test-in-debug';
 
 const { attr: DSattr, hasMany: DShasMany, belongsTo: DSbelongsTo } = DS;
@@ -2005,175 +2004,4 @@ module('integration/relationship/belongs_to Belongs-To Relationships', function(
 
     assert.equal(count, 0);
   });
-
-  test("belongsTo relationship doesn't trigger when model data doesn't support implicit relationship", function(assert) {
-    class TestRecordData extends RecordData {
-      constructor(...args) {
-        super(...args);
-        delete this.__implicitRelationships;
-        delete this.__relationships;
-      }
-
-      _destroyRelationships() {}
-
-      _allRelatedRecordDatas() {
-        return [this];
-      }
-
-      _cleanupOrphanedRecordDatas() {}
-
-      destroy() {
-        this.isDestroyed = true;
-        this.storeWrapper.disconnectRecord(this.modelName, this.id, this.clientId);
-      }
-
-      get _implicitRelationships() {
-        return undefined;
-      }
-      get _relationships() {
-        return undefined;
-      }
-    }
-
-    Chapter.reopen({
-      // book is still an inverse from prior to the reopen
-      sections: DS.hasMany('section', { async: false }),
-      book1: DS.belongsTo('book1', { async: false, inverse: 'chapters' }), // incorrect inverse
-      book2: DS.belongsTo('book1', { async: false, inverse: null }), // correct inverse
-    });
-
-    let store = this.owner.lookup('service:store');
-
-    const createRecordDataFor = store.createRecordDataFor;
-    store.createRecordDataFor = function(modelName, id, lid, storeWrapper) {
-      if (modelName === 'book1' || modelName === 'section') {
-        let identifier = identifierCacheFor(this).getOrCreateRecordIdentifier({
-          type: modelName,
-          id,
-          lid,
-        });
-        return new TestRecordData(identifier, storeWrapper);
-      }
-      return createRecordDataFor.call(this, modelName, id, lid, storeWrapper);
-    };
-
-    const data = {
-      data: {
-        type: 'chapter',
-        id: '1',
-        relationships: {
-          book1: {
-            data: { type: 'book1', id: '1' },
-          },
-          book2: {
-            data: { type: 'book1', id: '2' },
-          },
-          book: {
-            data: { type: 'book', id: '1' },
-          },
-          sections: {
-            data: [
-              {
-                type: 'section',
-                id: 1,
-              },
-              {
-                type: 'section',
-                id: 2,
-              },
-            ],
-          },
-        },
-      },
-      included: [
-        { type: 'book1', id: '1' },
-        { type: 'book1', id: '2' },
-        { type: 'section', id: '1' },
-        { type: 'book', id: '1' },
-        { type: 'section', id: '2' },
-      ],
-    };
-
-    // Expect assertion failure as Book1 RecordData
-    // doesn't have relationship attribute
-    // and inverse is not set to null in
-    // DSbelongsTo
-    assert.expectAssertion(() => {
-      run(() => {
-        store.push(data);
-      });
-    }, `Assertion Failed: We found no inverse relationships by the name of 'chapters' on the 'book1' model. This is most likely due to a missing attribute on your model definition.`);
-
-    //Update setup
-    // with inverse set to null
-    // no errors thrown
-    Chapter.reopen({
-      book1: DS.belongsTo({ async: false }),
-      sections: DS.hasMany('section', { async: false }),
-      book: DS.belongsTo({ async: false, inverse: null }),
-    });
-
-    run(() => {
-      store.push(data);
-    });
-
-    let chapter = store.peekRecord('chapter', '1');
-    let book1 = store.peekRecord('book1', '1');
-    let book2 = store.peekRecord('book1', '2');
-    let book = store.peekRecord('book', '1');
-    let section1 = store.peekRecord('section', '1');
-    let section2 = store.peekRecord('section', '2');
-
-    let sections = chapter.get('sections');
-
-    assert.equal(chapter.get('book1.id'), '1');
-    assert.equal(chapter.get('book2.id'), '2');
-    assert.equal(chapter.get('book.id'), '1');
-
-    // No inverse setup created for book1
-    // as Model-Data of book1 doesn't support this
-    // functionality.
-    assert.notOk(book1.get('chapter'));
-    assert.notOk(book2.get('chapter'));
-    assert.notOk(book.get('chapter'));
-    assert.notOk(
-      recordDataFor(book1)._implicitRelationships,
-      'no support for implicit relationship in custom RecordData'
-    );
-    assert.notOk(
-      recordDataFor(book2)._implicitRelationships,
-      'no support for implicit relationship in custom RecordData'
-    );
-    assert.ok(recordDataFor(book)._implicitRelationships, 'support for implicit relationship in default RecordData');
-
-    // No inverse setup is created for section
-    assert.notOk(section1.get('chapter'));
-    assert.notOk(section2.get('chapter'));
-
-    // Removing the sections
-    // shouldnot throw error
-    // as Model-data of section
-    // doesn't support implicit Relationship
-    run(() => {
-      chapter.get('sections').removeObject(section1);
-      assert.notOk(recordDataFor(section1)._implicitRelationships);
-
-      chapter.get('sections').removeObject(section2);
-      assert.notOk(recordDataFor(section2)._implicitRelationships);
-    });
-
-    assert.equal(chapter.get('sections.length'), 0);
-
-    // Update the current state of chapter by
-    // adding new sections
-    // shouldnot throw error during
-    // setup of implicit inverse
-    run(() => {
-      sections.addObject(store.createRecord('section', { id: 3 }));
-      sections.addObject(store.createRecord('section', { id: 4 }));
-      sections.addObject(store.createRecord('section', { id: 5 }));
-    });
-    assert.equal(chapter.get('sections.length'), 3);
-    assert.notOk(recordDataFor(sections.get('firstObject'))._implicitRelationships);
-  });
 });

packages/-ember-data/tests/integration/relationships/inverse-relationships-test.js

@@ -5,6 +5,7 @@ import { module, test } from 'qunit';
 import { setupTest } from 'ember-qunit';
 
 import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+import { graphFor } from '@ember-data/record-data/-private';
 import testInDebug from '@ember-data/unpublished-test-infra/test-support/test-in-debug';
 
 module('integration/relationships/inverse_relationships - Inverse Relationships', function(hooks) {
@@ -679,16 +680,13 @@ module('integration/relationships/inverse_relationships - Inverse Relationships'
 
     await settled();
 
-    assert.deepEqual(
-      comment._internalModel.__recordData.__relationships.initializedRelationships,
-      {},
-      'relationships are cleared'
-    );
-    assert.equal(
-      comment._internalModel.__recordData.__implicitRelationships,
-      null,
-      'implicitRelationships are cleared'
-    );
+    const identifier = comment._internalModel.identifier;
+    const relationships = graphFor(store._storeWrapper).get(identifier);
+    const implicitRelationships = graphFor(store._storeWrapper).getImplicit(identifier);
+    const initializedRelationships = relationships.initializedRelationships;
+
+    assert.deepEqual(Object.keys(initializedRelationships), [], 'relationships are cleared');
+    assert.deepEqual(Object.keys(implicitRelationships), [], 'implicitRelationships are cleared');
     assert.ok(comment._internalModel.__recordData.isDestroyed, 'recordData is destroyed');
   });
 });

packages/record-data/addon/-private/accessors.ts

@@ -1,28 +1,68 @@
-import { recordDataFor } from '@ember-data/store/-private';
+import { graphFor } from './graph/index';
 
+type RecordDataStoreWrapper = import('@ember-data/store/-private').RecordDataStoreWrapper;
+type StableRecordIdentifier = import('@ember-data/store/-private/ts-interfaces/identifier').StableRecordIdentifier;
+type InternalModel = import('@ember-data/store/-private').InternalModel;
 type RelationshipRecordData = import('./ts-interfaces/relationship-record-data').RelationshipRecordData;
-type ConfidentDict<T> = import('@ember-data/store/-private/ts-interfaces/utils').ConfidentDict<T>;
+type RelationshipDict = import('@ember-data/store/-private/ts-interfaces/utils').ConfidentDict<Relationship>;
 type ManyRelationship = import('./relationships/state/has-many').default;
 type BelongsToRelationship = import('./relationships/state/belongs-to').default;
 type Relationship = import('./relationships/state/relationship').default;
 type Relationships = import('./relationships/state/create').default;
 
-export function relationshipsFor(instance: any): Relationships {
-  let recordData = (recordDataFor(instance) || instance) as RelationshipRecordData;
+type MappableToRelationships = { _internalModel: InternalModel };
 
-  return recordData._relationships;
-}
+export function relationshipsFor(instance: RecordDataStoreWrapper, identifier: StableRecordIdentifier): Relationships;
+export function relationshipsFor(instance: MappableToRelationships): Relationships;
+export function relationshipsFor(
+  instance: MappableToRelationships | RecordDataStoreWrapper,
+  identifier?: StableRecordIdentifier
+): Relationships {
+  if (!identifier) {
+    let internalModel = ((instance as unknown) as MappableToRelationships)._internalModel;
+    identifier = internalModel.identifier;
+
+    // safe to upgrade as relationshipsFor is a private util used only for our own things
+    instance = (internalModel._recordData as RelationshipRecordData).storeWrapper;
+  }
 
-export function relationshipStateFor(instance: any, propertyName: string): BelongsToRelationship | ManyRelationship {
-  return relationshipsFor(instance).get(propertyName);
+  return graphFor(instance as RecordDataStoreWrapper).get(identifier);
 }
 
-export function implicitRelationshipsFor(instance: any): ConfidentDict<Relationship> {
-  let recordData = (recordDataFor(instance) || instance) as RelationshipRecordData;
+export function relationshipStateFor(
+  instance: RecordDataStoreWrapper,
+  identifier: StableRecordIdentifier,
+  propertyName: string
+): BelongsToRelationship | ManyRelationship;
+export function relationshipStateFor(
+  instance: MappableToRelationships,
+  identifier: string
+): BelongsToRelationship | ManyRelationship;
+export function relationshipStateFor(
+  instance: RecordDataStoreWrapper | MappableToRelationships,
+  identifier: string | StableRecordIdentifier,
+  propertyName?: string
+): BelongsToRelationship | ManyRelationship {
+  if (!propertyName) {
+    let internalModel = ((instance as unknown) as MappableToRelationships)._internalModel;
+    propertyName = (identifier as unknown) as string;
+    identifier = internalModel.identifier;
+    instance = (internalModel._recordData as RelationshipRecordData).storeWrapper;
+  }
+  return relationshipsFor(instance as RecordDataStoreWrapper, identifier as StableRecordIdentifier).get(propertyName);
+}
 
-  return recordData._implicitRelationships;
+export function implicitRelationshipsFor(
+  storeWrapper: RecordDataStoreWrapper,
+  identifier: StableRecordIdentifier
+): RelationshipDict {
+  return graphFor(storeWrapper).getImplicit(identifier);
 }
 
-export function implicitRelationshipStateFor(instance: any, propertyName: string): Relationship {
-  return implicitRelationshipsFor(instance)[propertyName];
+export function implicitRelationshipStateFor(
+  storeWrapper: RecordDataStoreWrapper,
+  identifier: StableRecordIdentifier,
+  propertyName: string
+): Relationship {
+  return implicitRelationshipsFor(storeWrapper, identifier)[propertyName];
 }