feat: support cross-references factories

packages/core/src/builder/builder.ts

@@ -22,6 +22,13 @@ export class Builder<
     this.statesManager = new StatesManager(factory)
   }
 
+  /**
+   * If the builder is at its initial state
+   */
+  // @ts-expect-error isReset is used in reset method.
+  // Take a look at the RelationshipMeta contract for more details about why.
+  private isReset = true
+
   /**
    * The attributes that will be merged for the next created models.
    */
@@ -84,12 +91,16 @@ export class Builder<
   /**
    * Reset the builder to its initial state.
    */
-  private resetBuilder() {
+  private reset() {
+    this.isReset = true
     this.mergeInput = []
     this.statesManager.reset()
     this.relationshipBuilder.reset()
 
-    Object.values(this.factory.relations).forEach((relation) => relation.factory().resetBuilder())
+    Object.values(this.factory.relations).forEach((relation) => {
+      const factory = relation.factory()
+      if (factory.isReset === false) factory.reset()
+    })
   }
 
   /**
@@ -129,6 +140,7 @@ export class Builder<
    * Create multiple models and persist them to the database.
    */
   public async createMany(count: number): Promise<Model[]> {
+    this.isReset = false
     this.ensureFactoryConnectionIsSet(factorioConfig.knex)
     let models: Record<string, any>[] = []
 
@@ -175,7 +187,7 @@ export class Builder<
      */
     const finalModels = this.relationshipBuilder.postHydrate(res)
 
-    this.resetBuilder()
+    this.reset()
 
     return finalModels.map((model) => convertCase(model, factorioConfig.casing.return)) as Model[]
   }

packages/core/src/contracts.ts

@@ -93,8 +93,14 @@ export interface RelationshipMeta {
 
   /**
    * Reference to the relation factory
+   *
+   * Note: Type is any because otherwise the circular dependency betweens
+   * two factories that are cross-referenced would totally break the type system.
+   *
+   * I don't know how to solve this problem yet. If you come up with a solution,
+   * or any ideas, please open a issue. Would be awesome to have this !
    */
-  factory: () => Builder<any, any, any>
+  factory: any
 }
 
 export type RelationshipMetaOptions = Optional<

packages/core/src/model.ts

@@ -43,8 +43,9 @@ export class FactoryModel<
     type: RelationType,
     meta?: RelationshipMetaOptions
   ) {
+    const foreignKey = type === RelationType.BelongsTo ? `${name}_id` : `${this.tableName}_id`
     this.relations[name] = {
-      foreignKey: `${this.tableName}_id`,
+      foreignKey,
       localKey: 'id',
       factory,
       ...meta,

tests-helpers/setup.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
 import { defineFactory } from '@julr/factorio'
 
 export const ProfileFactory = defineFactory('profile', ({ faker }) => ({
@@ -14,22 +15,23 @@ export const PostFactory = defineFactory('post', ({ faker }) => ({
   .state('nodeArticle', () => ({ title: 'NodeJS' }))
   .build()
 
+export const AdminFactory = defineFactory('admin', ({ faker }) => ({
+  id: faker.datatype.number(),
+})).build()
+
 export const UserFactory = defineFactory<any>('user', ({ faker }) => ({
   id: faker.datatype.number(),
 }))
   .state('easyPassword', () => ({ password: 'easy' }))
   .state('easyEmail', () => ({ email: 'easy@easy.com' }))
-  .hasOne('profile', () => ProfileFactory, { foreignKey: 'user_id', localKey: 'id' })
-  .hasMany('posts', () => PostFactory, { foreignKey: 'user_id', localKey: 'id' })
+  .hasOne('profile', () => ProfileFactory)
+  .hasMany('posts', () => PostFactory)
+  .hasOne('account', () => AccountFactory)
   .build()
 
-export const AdminFactory = defineFactory('admin', ({ faker }) => ({
-  id: faker.datatype.number(),
-})).build()
-
 export const AccountFactory = defineFactory('account', ({ faker }) => ({
   name: faker.commerce.productName(),
 }))
-  .belongsTo('user', () => UserFactory, { foreignKey: 'user_id', localKey: 'id' })
-  .belongsTo('admin', () => AdminFactory, { foreignKey: 'admin_id', localKey: 'id' })
+  .belongsTo('user', () => UserFactory)
+  .belongsTo('admin', () => AdminFactory)
   .build()

tests/core.spec.ts

@@ -2,6 +2,7 @@
 import { test } from '@japa/runner'
 import { defineFactory } from '@julr/factorio'
 import { DatabaseUtils } from '@julr/japa-database-plugin'
+import { AccountFactory, UserFactory as BaseUserFactory } from '../tests-helpers/setup.js'
 import { setupDb } from '../tests-helpers/db.js'
 
 const UserFactory = defineFactory<any>('user', ({ faker }) => ({
@@ -99,4 +100,19 @@ test.group('factorio', (group) => {
     await userFactory.apply('admin').create()
     await database.assertHas('user', { email: 'admin@admin.admin', password: 'topsecret' })
   })
+
+  test('cross reference', async ({ database }) => {
+    const account = await AccountFactory.with('user').create()
+
+    await database.assertHas('user', { id: account.userId })
+    await database.assertHas('account', { id: account.id })
+
+    const user = await BaseUserFactory.with('account').create()
+
+    await database.assertHas('user', { id: user.id })
+    await database.assertHas('account', { id: user.account.id })
+
+    await database.assertCount('user', 2)
+    await database.assertCount('account', 2)
+  })
 })