fix: persist belongs to before persisting the parent model

src/Factory/FactoryBuilder.ts

@@ -33,6 +33,16 @@ export class FactoryBuilder implements FactoryBuilderContract<FactoryModelContra
     callback?: (factory: any) => void,
   }[] = []
 
+  /**
+   * Belongs to relationships are treated different, since they are
+   * persisted before the parent model
+   */
+  private withBelongsToRelations: {
+    name: string,
+    count?: number,
+    callback?: (factory: any) => void,
+  }[] = []
+
   /**
    * The current index. Updated by `makeMany` and `createMany`
    */
@@ -151,8 +161,14 @@ export class FactoryBuilder implements FactoryBuilderContract<FactoryModelContra
   /**
    * Makes and persists relationship instances
    */
-  public async createRelations (modelInstance: LucidRow, ctx: FactoryContextContract) {
-    for (let { name, count, callback } of this.withRelations) {
+  private async createRelations (
+    modelInstance: LucidRow,
+    ctx: FactoryContextContract,
+    cycle: 'before' | 'after',
+  ) {
+    const relationships = cycle === 'before' ? this.withBelongsToRelations : this.withRelations
+
+    for (let { name, count, callback } of relationships) {
       const relation = this.model.getRelation(name)
       await relation.useCtx(ctx).create(modelInstance, callback, count)
     }
@@ -170,8 +186,15 @@ export class FactoryBuilder implements FactoryBuilderContract<FactoryModelContra
   /**
    * Load relationship
    */
-  public with (relation: string, count?: number, callback?: (factory: never) => void): this {
-    this.withRelations.push({ name: relation, count, callback })
+  public with (name: string, count?: number, callback?: (factory: never) => void): this {
+    const relation = this.model.getRelation(name)
+
+    if (relation.relation.type === 'belongsTo') {
+      this.withBelongsToRelations.push({ name, count, callback })
+      return this
+    }
+
+    this.withRelations.push({ name, count, callback })
     return this
   }
 
@@ -250,16 +273,24 @@ export class FactoryBuilder implements FactoryBuilderContract<FactoryModelContra
     await this.model.hooks.exec('before', 'create', this, modelInstance, ctx)
 
     try {
+      modelInstance.$trx = ctx.$trx
+
+      /**
+       * Create belongs to relationships before calling the save method. Even though
+       * we can update the foriegn key after the initial insert call, we avoid it
+       * for cases, where FK is a not nullable.
+       */
+      await this.createRelations(modelInstance, ctx, 'before')
+
       /**
        * Persist model instance
        */
-      modelInstance.$trx = ctx.$trx
       await modelInstance.save()
 
       /**
        * Create relationships.
        */
-      await this.createRelations(modelInstance, ctx)
+      await this.createRelations(modelInstance, ctx, 'after')
 
       /**
        * Fire after hook before the transaction is committed, so that

test/factory/belongs-to-spec.ts

@@ -269,6 +269,13 @@ test.group('Factory | BelongTo | create', (group) => {
     assert.instanceOf(profile.user, User)
     assert.isTrue(profile.user.$isPersisted)
     assert.equal(profile.user.id, profile.userId)
+
+    const users = await db.from('users').select('*')
+    const profiles = await db.from('profiles').select('*')
+
+    assert.lengthOf(profiles, 1)
+    assert.lengthOf(users, 1)
+    assert.equal(profiles[0].user_id, users[0].id)
   })
 
   test('pass custom attributes to the relationship', async (assert) => {

test/factory/has-many.spec.ts

@@ -255,6 +255,13 @@ test.group('Factory | HasMany | create', (group) => {
     assert.instanceOf(user.posts[0], Post)
     assert.isTrue(user.posts[0].$isPersisted)
     assert.equal(user.posts[0].userId, user.id)
+
+    const users = await db.from('users').select('*')
+    const posts = await db.from('posts').select('*')
+
+    assert.lengthOf(posts, 1)
+    assert.lengthOf(users, 1)
+    assert.equal(posts[0].user_id, users[0].id)
   })
 
   test('pass custom attributes to relationship', async (assert) => {

test/factory/has-one.spec.ts

@@ -206,6 +206,13 @@ test.group('Factory | HasOne | create', (group) => {
     assert.instanceOf(user.profile, Profile)
     assert.isTrue(user.profile.$isPersisted)
     assert.equal(user.profile.userId, user.id)
+
+    const users = await db.from('users').select('*')
+    const profiles = await db.from('profiles').select('*')
+
+    assert.lengthOf(profiles, 1)
+    assert.lengthOf(users, 1)
+    assert.equal(profiles[0].user_id, users[0].id)
   })
 
   test('pass custom attributes to relationship', async (assert) => {

test/factory/many-to-many.spec.ts

@@ -272,6 +272,15 @@ test.group('Factory | ManyToMany | create', (group) => {
       user_id: user.id,
       skill_id: user.skills[0].id,
     })
+
+    const users = await db.from('users').select('*')
+    const skills = await db.from('skills').select('*')
+    const skillUsers = await db.from('skill_user').select('*')
+
+    assert.lengthOf(skills, 1)
+    assert.lengthOf(users, 1)
+    assert.equal(skillUsers[0].user_id, users[0].id)
+    assert.equal(skillUsers[0].skill_id, skills[0].id)
   })
 
   test('pass custom attributes', async (assert) => {