orchid-orm 1.3.3 → 1.3.5

package/src/relations/hasOne.test.ts

@@ -1340,6 +1340,97 @@ describe('hasOne through', () => {
     expect(Object.keys(db.tag.relations)).toEqual(['postTag', 'post']);
   });
 
+  it('should throw if through relation is not defined', () => {
+    class Post extends Model {
+      table = 'post';
+      columns = this.setColumns((t) => ({
+        id: t.serial().primaryKey(),
+      }));
+
+      relations = {
+        tag: this.hasOne(() => Tag, {
+          through: 'postTag',
+          source: 'tag',
+        }),
+      };
+    }
+
+    class Tag extends Model {
+      table = 'tag';
+      columns = this.setColumns((t) => ({
+        id: t.serial().primaryKey(),
+      }));
+    }
+
+    expect(() => {
+      orchidORM(
+        {
+          ...pgConfig,
+          log: false,
+        },
+        {
+          post: Post,
+          tag: Tag,
+        },
+      );
+    }).toThrow(
+      'Cannot define a `tag` relation on `post`: cannot find `postTag` relation required by the `through` option',
+    );
+  });
+
+  it('should throw if source relation is not defined', () => {
+    class Post extends Model {
+      table = 'post';
+      columns = this.setColumns((t) => ({
+        id: t.serial().primaryKey(),
+      }));
+
+      relations = {
+        postTag: this.hasOne(() => PostTag, {
+          primaryKey: 'id',
+          foreignKey: 'postId',
+        }),
+
+        tag: this.hasOne(() => Tag, {
+          through: 'postTag',
+          source: 'tag',
+        }),
+      };
+    }
+
+    class Tag extends Model {
+      table = 'tag';
+      columns = this.setColumns((t) => ({
+        id: t.serial().primaryKey(),
+      }));
+    }
+
+    class PostTag extends Model {
+      table = 'postTag';
+      columns = this.setColumns((t) => ({
+        postId: t.integer().foreignKey(() => Post, 'id'),
+        tagId: t.integer().foreignKey(() => Tag, 'id'),
+        ...t.primaryKey(['postId', 'tagId']),
+      }));
+    }
+
+    expect(() => {
+      orchidORM(
+        {
+          ...pgConfig,
+          log: false,
+        },
+        {
+          post: Post,
+          tag: Tag,
+          postTag: PostTag,
+        },
+      );
+    }).toThrow(
+      'Cannot define a `tag` relation on `post`: cannot find `tag` relation in `postTag` required by the `source` option',
+    );
+  });
+
   it('should have method to query related data', async () => {
     const profileQuery = db.profile.take();
 

package/src/relations/relations.ts

@@ -200,6 +200,45 @@ export const applyRelations = (
       applyRelation(qb, data, delayedRelations);
     }
   }
+
+  if (delayedRelations.size) {
+    const { value } = delayedRelations.values().next() as {
+      value: Record<string, ApplyRelationData[]>;
+    };
+    for (const key in value) {
+      for (const item of value[key]) {
+        const { relation } = item;
+
+        if (item.dbModel.relations[item.relationName as never]) continue;
+
+        const as = item.dbModel.definedAs;
+        let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
+        const model = result[as];
+
+        const { through, source } = relation.options as {
+          through: string;
+          source: string;
+        };
+        const throughRel = model.relations[
+          through as never
+        ] as unknown as BaseRelation;
+
+        if (through && !throughRel) {
+          message += `: cannot find \`${through}\` relation required by the \`through\` option`;
+        } else if (
+          source &&
+          throughRel &&
+          !throughRel.model.relations[source as never]
+        ) {
+          message += `: cannot find \`${source}\` relation in \`${
+            (throughRel.model as DbModel<ModelClass>).definedAs
+          }\` required by the \`source\` option`;
+        }
+
+        throw new Error(message);
+      }
+    }
+  }
 };
 
 const delayRelation = (