feat: separate different types of lazy attributes

.gitignore

@@ -27,4 +27,5 @@ tmp
 old
 
 ### Arch linux error ###
-~
+~
+.vscode/

src/factory.ts

@@ -1,6 +1,7 @@
 import type { SaveOptions } from 'typeorm'
 import { fetchConnection } from './connection'
-import { LazyAttribute } from './lazyAttribute'
+import { InstanceAttribute } from './instanceAttribute'
+import { LazyInstanceAttribute } from './lazyInstanceAttribute'
 import { Subfactory } from './subfactory'
 import type { Constructable, FactorizedAttrs } from './types'
 
@@ -38,11 +39,11 @@ export abstract class Factory<T> {
     const attrs = { ...this.attrs, ...overrideParams }
     const entity = await this.makeEntity(attrs, true)
 
-    const connection = await fetchConnection()
-    const savedEntity = await connection.createEntityManager().save<T>(entity, saveOptions)
-    await this.applyLazyAttributes(savedEntity, attrs, true)
+    const em = (await fetchConnection()).createEntityManager()
+    const savedEntity = await em.save<T>(entity, saveOptions)
 
-    return savedEntity
+    await this.applyLazyAttributes(savedEntity, attrs, true)
+    return em.save<T>(savedEntity, saveOptions)
   }
 
   /**
@@ -69,13 +70,22 @@ export abstract class Factory<T> {
       }),
     )
 
+    await Promise.all(
+      Object.entries(attrs).map(async ([key, value]) => {
+        if (value instanceof InstanceAttribute) {
+          const newAttrib = value.resolve(entity)
+          Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) })
+        }
+      }),
+    )
+
     return entity
   }
 
   private async applyLazyAttributes(entity: T, attrs: FactorizedAttrs<T>, shouldPersist: boolean) {
     await Promise.all(
       Object.entries(attrs).map(async ([key, value]) => {
-        if (value instanceof LazyAttribute) {
+        if (value instanceof LazyInstanceAttribute) {
           const newAttrib = value.resolve(entity)
           Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) })
         }

src/index.ts

@@ -1,6 +1,8 @@
 export * from './connection'
 export * from './factory'
 export * from './lazyAttribute'
+export * from './instanceAttribute'
+export * from './lazyInstanceAttribute'
 export * from './seeder'
 export * from './types'
 export * from './useSeeders'

src/instanceAttribute.ts

@@ -0,0 +1,3 @@
+import { LazyAttribute } from './lazyAttribute'
+
+export class InstanceAttribute<T, V> extends LazyAttribute<T, V> {}

src/lazyAttribute.ts

@@ -1,6 +1,6 @@
 import type { FactorizedAttr, LazyAttributeCallback } from './types'
 
-export class LazyAttribute<T, V> {
+export abstract class LazyAttribute<T, V> {
   constructor(private callback: LazyAttributeCallback<T, V>) {}
 
   resolve(entity: T): FactorizedAttr<V> {

src/lazyInstanceAttribute.ts

@@ -0,0 +1,3 @@
+import { LazyAttribute } from './lazyAttribute'
+
+export class LazyInstanceAttribute<T, V> extends LazyAttribute<T, V> {}

test/factories/Pet.factory.ts

@@ -1,6 +1,7 @@
 import faker from '@faker-js/faker'
 import { Factory } from '../../src/factory'
-import { LazyAttribute } from '../../src/lazyAttribute'
+import { InstanceAttribute } from '../../src/instanceAttribute'
+import { LazyInstanceAttribute } from '../../src/lazyInstanceAttribute'
 import { Subfactory } from '../../src/subfactory'
 import type { FactorizedAttrs } from '../../src/types'
 import { Pet } from '../entities/Pet.entity'
@@ -11,9 +12,9 @@ export class PetFactory extends Factory<Pet> {
   protected attrs: FactorizedAttrs<Pet> = {
     name: faker.name.findName(),
     lastName: async () => faker.name.findName(),
-    address: new LazyAttribute((instance) => async () => `${instance.name.toLowerCase()} address`),
-    email: new LazyAttribute((instance) => `${instance.name.toLowerCase()}@example.com`),
-    owner: new LazyAttribute(
+    address: new InstanceAttribute((instance) => async () => `${instance.name.toLowerCase()} address`),
+    email: new InstanceAttribute((instance) => `${instance.name.toLowerCase()}@example.com`),
+    owner: new LazyInstanceAttribute(
       (instance) =>
         new Subfactory(UserFactory, {
           name: () => `${instance.name} owner`,

test/factories/User.factory.ts

@@ -1,6 +1,6 @@
-import faker from '@faker-js/faker'
+import { faker } from '@faker-js/faker'
 import { Factory } from '../../src/factory'
-import { LazyAttribute } from '../../src/lazyAttribute'
+import { InstanceAttribute } from '../../src/instanceAttribute'
 import { Subfactory } from '../../src/subfactory'
 import type { FactorizedAttrs } from '../../src/types'
 import { User } from '../entities/User.entity'
@@ -11,8 +11,8 @@ export class UserFactory extends Factory<User> {
   protected attrs: FactorizedAttrs<User> = {
     name: faker.name.findName(),
     lastName: async () => faker.name.findName(),
-    address: new LazyAttribute((instance) => async () => `${instance.name.toLowerCase()} address`),
-    email: new LazyAttribute((instance) => `${instance.name.toLowerCase()}@example.com`),
+    address: new InstanceAttribute((instance) => async () => `${instance.name.toLowerCase()} address`),
+    email: new InstanceAttribute((instance) => `${instance.name.toLowerCase()}@example.com`),
     pets: new Subfactory(PetFactory, 2),
   }
 }

test/seeders/User.seeder.ts

@@ -7,6 +7,6 @@ export class UserSeeder extends Seeder {
   async run(connection: Connection) {
     await new UserFactory().createMany(10)
 
-    await this.call(connection, [PetSeeder])
+    await this.call(connection, [])
   }
 }