fix: circular dependencies

src/data-source/index.ts

@@ -1,4 +1,4 @@
-export * from './options';
 export * from './find';
+export * from './options';
 export * from './singleton';
 export * from './type';

src/data-source/options/module.ts

@@ -1,6 +1,5 @@
 import type { DataSourceOptions } from 'typeorm';
 import { OptionsError } from '../../errors';
-import { extendSeederOptions } from '../../seeder';
 import { findDataSource } from '../find';
 import type { DataSourceOptionsBuildContext } from './type';
 import {
@@ -13,8 +12,6 @@ export async function extendDataSourceOptions(
     options: DataSourceOptions,
     tsConfigDirectory?: string,
 ) : Promise<DataSourceOptions> {
-    options = extendSeederOptions(options);
-
     await adjustFilePathsForDataSourceOptions(options, { root: tsConfigDirectory });
 
     return options;

src/database/utils/context.ts

@@ -1,6 +1,7 @@
 import type { DataSourceOptions } from 'typeorm';
+import { buildDataSourceOptions } from '../../data-source/options';
 import type { DatabaseBaseContext, DatabaseCreateContext, DatabaseDropContext } from '../type';
-import { buildDataSourceOptions, findDataSource } from '../../data-source';
+import { findDataSource } from '../../data-source';
 
 async function setDatabaseContextOptions<T extends DatabaseBaseContext>(context: T) : Promise<T> {
     if (!context.options) {

src/seeder/executor.ts

@@ -3,10 +3,11 @@ import { MssqlParameter, Table } from 'typeorm';
 import type { DataSource, DataSourceOptions, QueryRunner } from 'typeorm';
 import type { MongoQueryRunner } from 'typeorm/driver/mongodb/MongoQueryRunner';
 import { adjustFilePathsForDataSourceOptions, setDataSource } from '../data-source';
+import { useEnv } from '../env';
 import { SeederEntity } from './entity';
-import { useSeederFactoryManager } from './factory';
+import { prepareSeederFactories, useSeederFactoryManager } from './factory';
 import type { SeederOptions, SeederPrepareElement } from './type';
-import { extendSeederOptions, prepareSeederFactories, prepareSeederSeeds } from './utils';
+import { prepareSeederSeeds } from './utils';
 
 export class SeederExecutor {
     protected dataSource : DataSource;
@@ -298,7 +299,7 @@ export class SeederExecutor {
     }
 
     protected async buildOptions(input: SeederOptions = {}) {
-        let options : SeederOptions = {
+        const options : SeederOptions = {
             seeds: input.seeds || [],
             factories: input.factories || [],
         };
@@ -307,11 +308,25 @@ export class SeederExecutor {
             options.seeds = this.options.seeds;
         }
 
+        if (!options.seeds || options.seeds.length === 0) {
+            options.seeds = useEnv('seeds');
+        }
+
+        if (!options.seeds || options.seeds.length === 0) {
+            options.seeds = ['src/database/seeds/**/*{.ts,.js}'];
+        }
+
         if (!options.factories || options.factories.length === 0) {
             options.factories = this.options.factories;
         }
 
-        options = extendSeederOptions(options);
+        if (!options.factories || options.factories.length === 0) {
+            options.factories = useEnv('factories');
+        }
+
+        if (!options.factories || options.factories.length === 0) {
+            options.factories = ['src/database/factories/**/*{.ts,.js}'];
+        }
 
         await adjustFilePathsForDataSourceOptions(options, {
             keys: ['seeds', 'factories'],

src/seeder/factory/utils.ts

@@ -1,4 +1,6 @@
+import { load } from 'locter';
 import type { EntitySchema, ObjectType } from 'typeorm';
+import { resolveFilePaths, resolveFilePatterns } from '../utils';
 import { SeederFactoryManager } from './manager';
 import type { FactoryCallback, SeederFactoryItem } from './type';
 
@@ -28,3 +30,39 @@ export function useSeederFactory<O extends Record<string, any>>(
     const manager = useSeederFactoryManager();
     return manager.get(entity);
 }
+
+export async function prepareSeederFactories(
+    items: SeederFactoryItem[] | string[],
+) {
+    let factoryFiles: string[] = [];
+    const factoryConfigs: SeederFactoryItem[] = [];
+
+    for (let i = 0; i < items.length; i++) {
+        const value = items[i];
+        if (typeof value === 'string') {
+            factoryFiles.push(value);
+        } else {
+            factoryConfigs.push(value);
+        }
+    }
+
+    if (factoryFiles.length > 0) {
+        factoryFiles = await resolveFilePatterns(factoryFiles);
+        factoryFiles = resolveFilePaths(factoryFiles);
+
+        for (let i = 0; i < factoryFiles.length; i++) {
+            await load(factoryFiles[i]);
+        }
+    }
+
+    if (factoryConfigs.length > 0) {
+        const factoryManager = useSeederFactoryManager();
+
+        for (let i = 0; i < factoryConfigs.length; i++) {
+            factoryManager.set(
+                factoryConfigs[i].entity,
+                factoryConfigs[i].factoryFn,
+            );
+        }
+    }
+}

src/seeder/utils/index.ts

@@ -1,4 +1,3 @@
 export * from './file-path';
-export * from './options';
 export * from './prepare';
 export * from './promise';

src/seeder/utils/prepare.ts

@@ -1,45 +1,8 @@
 import { getModuleExport, load } from 'locter';
 import path from 'node:path';
-import type { SeederFactoryItem } from '../factory';
-import { useSeederFactoryManager } from '../factory';
 import type { SeederConstructor, SeederPrepareElement } from '../type';
 import { resolveFilePaths, resolveFilePatterns } from './file-path';
 
-export async function prepareSeederFactories(
-    items: SeederFactoryItem[] | string[],
-) {
-    let factoryFiles: string[] = [];
-    const factoryConfigs: SeederFactoryItem[] = [];
-
-    for (let i = 0; i < items.length; i++) {
-        const value = items[i];
-        if (typeof value === 'string') {
-            factoryFiles.push(value);
-        } else {
-            factoryConfigs.push(value);
-        }
-    }
-
-    if (factoryFiles.length > 0) {
-        factoryFiles = await resolveFilePatterns(factoryFiles);
-        factoryFiles = resolveFilePaths(factoryFiles);
-
-        for (let i = 0; i < factoryFiles.length; i++) {
-            await load(factoryFiles[i]);
-        }
-    }
-
-    if (factoryConfigs.length > 0) {
-        const factoryManager = useSeederFactoryManager();
-
-        for (let i = 0; i < factoryConfigs.length; i++) {
-            factoryManager.set(
-                factoryConfigs[i].entity,
-                factoryConfigs[i].factoryFn,
-            );
-        }
-    }
-}
 export async function prepareSeederSeeds(
     input: SeederConstructor[] | string[],
 ): Promise<SeederPrepareElement[]> {