fix bug for when multiple columns reference same table

Author: craigmichaelmartin

src/core.spec.ts

@@ -8,6 +8,7 @@ import { entities as fiveEntities } from '../test-utils/five/entities';
 import { entities as sixEntities } from '../test-utils/six/entities';
 import { entities as twelveEntities } from '../test-utils/twelve/entities';
 import { entities as thirteenEntities } from '../test-utils/thirteen/entities';
+import { entities as fourteenEntities } from '../test-utils/fourteen/entities';
 import { Articles } from '../test-utils/blog/models/article';
 const two = require('../test-utils/two/results');
 const three = require('../test-utils/three/results');
@@ -22,6 +23,7 @@ const ten = require('../test-utils/ten/results.json');
 const eleven = require('../test-utils/eleven/results.json');
 const twelve = require('../test-utils/twelve/results.json');
 const thirteen = require('../test-utils/thirteen/results.json');
+const fourteen = require('../test-utils/fourteen/results.json');
 
 describe('createFromDatabase', () => {
   test('multiple rows reduce to one nested object (with all one-to-one or one-to-many tables)', () => {
@@ -1066,6 +1068,19 @@ describe('createFromDatabase', () => {
         .audience.id
     ).toEqual(1);
   });
+
+  // Issue occcurs in nestClump
+  // Problem when a table has two columns which reference the same other table
+  test('14', () => {
+    const core = createCore({ entities: fourteenEntities });
+    const persons = core.createFromDatabase(fourteen);
+    expect(persons?.models.length).toEqual(1);
+    expect(persons.models[0].id).toEqual(67);
+    // Known issue: A reference always uses the model's name,
+    // instead of some version of the column's name
+    expect(persons.models[0].customers?.models.length).toEqual(1);
+    expect(persons.models[0].customers.models[0].id).toEqual(4);
+  });
 });
 
 describe('createOneFromDatabase', () => {

src/core.ts

@@ -292,16 +292,23 @@ export const createCore = ({
           ...nodes.slice(0, indexOfOldestParent + 1).reverse()
         ];
         const nodeItPointsTo = parentHeirarchy.find((parent) => {
-          const index = Object.values(
-            getEntityByModel(model).references
-          ).indexOf(parent.constructor);
-          if (index === -1) {
+          const indexes = Object.values(getEntityByModel(model).references)
+            .map((x: IModelClass, i: number) =>
+              x === parent.constructor ? i : null
+            )
+            .filter((x: number | null, i) => x != null) as Array<number>;
+          if (!indexes.length) {
             return false;
           }
-          const property = Object.keys(getEntityByModel(model).references)[
-            index
-          ];
-          return model[property as keyof typeof model] === parent.id;
+          for (const index of indexes) {
+            const property = Object.keys(getEntityByModel(model).references)[
+              index
+            ];
+            if (model[property] === parent.id) {
+              return true;
+            }
+          }
+          return false;
         });
         if (isNodeAlreadySeen) {
           if (nodeItPointsTo && !nodePointingToIt) {

test-utils/fourteen/entities.ts

@@ -0,0 +1,3 @@
+import { personEntity } from './models/person';
+import { customerEntity } from './models/customer';
+export const entities = [personEntity, customerEntity];

test-utils/fourteen/models/customer.ts

@@ -0,0 +1,36 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+import { Person } from './person';
+
+export const tableName: string = 'customer';
+
+export const columns: IColumns = [
+  'id',
+  { column: 'locked_to_affiliate_id', references: Person },
+  { column: 'locked_to_salesperson_id', references: Person }
+];
+
+export class Customer implements IModel {
+  id: number;
+  lockedToAffiliateId: number;
+  lockedToSalespersonId: number;
+
+  constructor(props: any) {
+    this.id = props.id;
+    this.lockedToAffiliateId = props.lockedToAffiliateId;
+    this.lockedToSalespersonId = props.lockedToSalespersonId;
+  }
+}
+
+export class Customers implements ICollection<Customer> {
+  models: Array<Customer>;
+  constructor({ models }: any) {
+    this.models = models;
+  }
+}
+
+export const customerEntity = {
+  tableName,
+  columns,
+  Model: Customer,
+  Collection: Customers
+};

test-utils/fourteen/models/person.ts

@@ -0,0 +1,27 @@
+import { IModel, ICollection, IColumns } from '../../../src/index';
+
+export const tableName: string = 'person';
+
+export const columns: IColumns = ['id'];
+
+export class Person implements IModel {
+  id: number;
+
+  constructor(props: any) {
+    this.id = props.id;
+  }
+}
+
+export class Persons implements ICollection<Person> {
+  models: Array<Person>;
+  constructor({ models }: any) {
+    this.models = models;
+  }
+}
+
+export const personEntity = {
+  tableName,
+  columns,
+  Model: Person,
+  Collection: Persons
+};

test-utils/fourteen/results.json

@@ -0,0 +1,8 @@
+[
+  {
+    "person#id": 67,
+    "customer#id": 4,
+    "customer#locked_to_affiliate_id": null,
+    "customer#locked_to_salesperson_id": 67
+  }
+]