fix: move reference-check error to preparation phase

previously this error would be thrown synchronously, as the join
options are configured:

```js
QueryError('Model: there are no references to `OtherModel`');
```

Author: joelmukuthu

lib/KnormRelations.js

@@ -117,6 +117,7 @@ class KnormRelations {
         super(model);
         // TODO: only initialize parsedRows when needed
         this.parsedRows = new Map();
+        // TODO: move this to base model default options
         this.options.ensureUniqueField = true;
         this.config.references = model.config.references;
         this.config.referenceFunctions = model.config.referenceFunctions;
@@ -127,56 +128,14 @@ class KnormRelations {
           joins = [joins];
         }
 
+        // TODO: use appendOption
         this.options.joins = this.options.joins || [];
 
         joins.forEach(join => {
           if (join.prototype instanceof Model) {
             join = join.query;
           }
 
-          const joinReferences = Object.assign({}, join.config.references);
-          const thisReferences = Object.assign({}, this.config.references);
-
-          Object.entries(join.config.referenceFunctions).forEach(
-            ([fieldName, referenceFunction]) => {
-              const field = join.config.fields[fieldName];
-              addReferenceByFunction(joinReferences, referenceFunction, field);
-            }
-          );
-
-          Object.entries(this.config.referenceFunctions).forEach(
-            ([fieldName, referenceFunction]) => {
-              const field = this.config.fields[fieldName];
-              addReferenceByFunction(thisReferences, referenceFunction, field);
-            }
-          );
-
-          if (
-            !thisReferences[join.model.name] &&
-            !joinReferences[this.model.name]
-          ) {
-            throw new Query.QueryError(
-              `${this.model.name}: there are no references to \`${
-                join.model.name
-              }\``
-            );
-          }
-
-          const isReverseJoin = !!thisReferences[join.model.name];
-          const mergedReferences = Object.assign(
-            {},
-            thisReferences[join.model.name],
-            joinReferences[this.model.name]
-          );
-          const mergedReferencesReversed = mapReferencesByReferencedField(
-            mergedReferences,
-            isReverseJoin ? join.model : this.model
-          );
-
-          join.config.isReverseJoin = isReverseJoin;
-          join.config.mergedReferences = mergedReferences;
-          join.config.mergedReferencesReversed = mergedReferencesReversed;
-
           join.options.joinType = type;
           join.setOptions(options);
 
@@ -206,18 +165,57 @@ class KnormRelations {
       }
 
       prepareOn() {
+        const join = this;
+        const parent = this.parent;
+        const joinReferences = Object.assign({}, join.config.references);
+        const parentReferences = Object.assign({}, parent.config.references);
+
+        Object.entries(join.config.referenceFunctions).forEach(
+          ([fieldName, referenceFunction]) => {
+            const field = join.config.fields[fieldName];
+            addReferenceByFunction(joinReferences, referenceFunction, field);
+          }
+        );
+
+        Object.entries(parent.config.referenceFunctions).forEach(
+          ([fieldName, referenceFunction]) => {
+            const field = parent.config.fields[fieldName];
+            addReferenceByFunction(parentReferences, referenceFunction, field);
+          }
+        );
+
+        if (
+          !parentReferences[join.model.name] &&
+          !joinReferences[parent.model.name]
+        ) {
+          throw new Query.QueryError(
+            `${parent.model.name}: there are no references to \`${
+              join.model.name
+            }\``
+          );
+        }
+
+        const isReverseJoin = !!parentReferences[join.model.name];
+        const toModel = isReverseJoin ? join.model : parent.model;
+        const mergedReferences = Object.assign(
+          {},
+          parentReferences[join.model.name],
+          joinReferences[parent.model.name]
+        );
+        const mergedReferencesReversed = mapReferencesByReferencedField(
+          mergedReferences,
+          toModel
+        );
         let references = [];
 
         if (this.options.on) {
           this.options.on.forEach(field => {
             if (field instanceof Field) {
-              if (field.model === this.parent.model) {
-                if (this.config.mergedReferences[field.name]) {
-                  references.push(this.config.mergedReferences[field.name]);
+              if (field.model === parent.model) {
+                if (mergedReferences[field.name]) {
+                  references.push(mergedReferences[field.name]);
                 } else {
-                  references.push(
-                    ...this.config.mergedReferencesReversed[field.name]
-                  );
+                  references.push(...mergedReferencesReversed[field.name]);
                 }
                 return;
               }
@@ -226,37 +224,34 @@ class KnormRelations {
               field = field.name;
             }
 
-            if (this.config.mergedReferencesReversed[field]) {
-              references.push(...this.config.mergedReferencesReversed[field]);
+            if (mergedReferencesReversed[field]) {
+              references.push(...mergedReferencesReversed[field]);
             } else {
-              references.push(this.config.mergedReferences[field]);
+              references.push(mergedReferences[field]);
             }
           });
         } else {
-          references = Object.values(this.config.mergedReferences);
+          references = Object.values(mergedReferences);
         }
 
-        const isReverseJoin = this.config.isReverseJoin;
-
         return references.reduce((columns, field) => {
           const fromColumn = field.column;
           const references = isArray(field.references)
             ? field.references
             : [field.references];
 
           references.forEach(reference => {
-            const toModel = isReverseJoin ? this.model : this.parent.model;
             if (reference.model.name === toModel.name) {
               const toColumn = reference.column;
               let from;
               let to;
 
-              if (this.config.isReverseJoin) {
-                from = this.formatColumn(toColumn);
-                to = this.parent.formatColumn(fromColumn);
+              if (isReverseJoin) {
+                from = join.formatColumn(toColumn);
+                to = parent.formatColumn(fromColumn);
               } else {
-                from = this.formatColumn(fromColumn);
-                to = this.parent.formatColumn(toColumn);
+                from = join.formatColumn(fromColumn);
+                to = parent.formatColumn(toColumn);
               }
 
               columns[from] = to;

test/KnormRelations.spec.js

@@ -450,17 +450,17 @@ describe('KnormRelations', () => {
       });
 
       describe("with a 'leftJoin' configured", () => {
-        it('throws if the models do not reference each other', () => {
+        it('rejects if the models do not reference each other', async () => {
           class Foo extends Model {}
           Foo.table = 'foo';
-          expect(
-            () => new Query(User).leftJoin(new Query(Foo)),
-            'to throw',
+          await expect(
+            new Query(User).leftJoin(new Query(Foo)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('User: there are no references to `Foo`')
           );
-          expect(
-            () => new Query(Foo).leftJoin(new Query(User)),
-            'to throw',
+          await expect(
+            new Query(Foo).leftJoin(new Query(User)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('Foo: there are no references to `User`')
           );
         });
@@ -1494,7 +1494,7 @@ describe('KnormRelations', () => {
           };
         });
 
-        it('throws if models used in a join do not reference each other', () => {
+        it('rejects if models used in a join do not reference each other', async () => {
           class Foo extends Model {}
           Foo.table = 'foo';
           Foo.fields = {
@@ -1503,14 +1503,14 @@ describe('KnormRelations', () => {
               references: [Message.fields.id, OtherMessage.fields.id]
             }
           };
-          expect(
-            () => new Query(User).leftJoin(new Query(Foo)),
-            'to throw',
+          await expect(
+            new Query(User).leftJoin(new Query(Foo)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('User: there are no references to `Foo`')
           );
-          expect(
-            () => new Query(Foo).leftJoin(new Query(User)),
-            'to throw',
+          await expect(
+            new Query(Foo).leftJoin(new Query(User)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('Foo: there are no references to `User`')
           );
         });
@@ -1823,7 +1823,7 @@ describe('KnormRelations', () => {
           };
         });
 
-        it('throws if models used in a join do not reference each other', () => {
+        it('rejects if models used in a join do not reference each other', async () => {
           class Foo extends Model {}
           Foo.table = 'foo';
           Foo.fields = {
@@ -1834,14 +1834,14 @@ describe('KnormRelations', () => {
               }
             }
           };
-          expect(
-            () => new Query(User).leftJoin(new Query(Foo)),
-            'to throw',
+          await expect(
+            new Query(User).leftJoin(new Query(Foo)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('User: there are no references to `Foo`')
           );
-          expect(
-            () => new Query(Foo).leftJoin(new Query(User)),
-            'to throw',
+          await expect(
+            new Query(Foo).leftJoin(new Query(User)).fetch(),
+            'to be rejected with error satisfying',
             new Query.QueryError('Foo: there are no references to `User`')
           );
         });
@@ -2059,7 +2059,7 @@ describe('KnormRelations', () => {
             };
           });
 
-          it('throws if models used in a join do not reference each other', () => {
+          it('rejects if models used in a join do not reference each other', async () => {
             class Foo extends Model {}
             Foo.table = 'foo';
             Foo.fields = {
@@ -2070,14 +2070,14 @@ describe('KnormRelations', () => {
                 }
               }
             };
-            expect(
-              () => new Query(User).leftJoin(new Query(Foo)),
-              'to throw',
+            await expect(
+              new Query(User).leftJoin(new Query(Foo)).fetch(),
+              'to be rejected with error satisfying',
               new Query.QueryError('User: there are no references to `Foo`')
             );
-            expect(
-              () => new Query(Foo).leftJoin(new Query(User)),
-              'to throw',
+            await expect(
+              new Query(Foo).leftJoin(new Query(User)).fetch(),
+              'to be rejected with error satisfying',
               new Query.QueryError('Foo: there are no references to `User`')
             );
           });