fix: cleanup file path adjustment

src/data-source/options/module.ts

@@ -1,22 +1,13 @@
 import type { DataSourceOptions } from 'typeorm';
 import { OptionsError } from '../../errors';
+import { adjustFilePaths } from '../../utils';
 import { findDataSource } from '../find';
 import type { DataSourceOptionsBuildContext } from './type';
 import {
-    adjustFilePathsForDataSourceOptions,
     mergeDataSourceOptionsWithEnv,
     readDataSourceOptionsFromEnv,
 } from './utils';
 
-export async function extendDataSourceOptions(
-    options: DataSourceOptions,
-    tsConfigDirectory?: string,
-) : Promise<DataSourceOptions> {
-    await adjustFilePathsForDataSourceOptions(options, { root: tsConfigDirectory });
-
-    return options;
-}
-
 /**
  * Build DataSourceOptions from DataSource or from configuration.
  *
@@ -36,8 +27,13 @@ export async function buildDataSourceOptions(
     });
 
     if (dataSource) {
-        const options = await extendDataSourceOptions(
+        const options = await adjustFilePaths(
             dataSource.options,
+            [
+                'entities',
+                'migrations',
+                'subscribers',
+            ],
             tsconfigDirectory,
         );
 
@@ -46,7 +42,11 @@ export async function buildDataSourceOptions(
 
     const options = readDataSourceOptionsFromEnv();
     if (options) {
-        return extendDataSourceOptions(options);
+        return adjustFilePaths(
+            options,
+            ['entities', 'migrations', 'subscribers'],
+            tsconfigDirectory,
+        );
     }
 
     throw OptionsError.notFound();

src/data-source/options/utils/index.ts

@@ -1,3 +1,2 @@
 export * from './env';
-export * from './file-path';
 export * from './merge';

src/seeder/executor.ts

@@ -2,8 +2,9 @@ import type { ObjectLiteral } from 'rapiq';
 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 { setDataSource } from '../data-source';
 import { useEnv } from '../env';
+import { adjustFilePaths } from '../utils';
 import { SeederEntity } from './entity';
 import { prepareSeederFactories, useSeederFactoryManager } from './factory';
 import type { SeederOptions, SeederPrepareElement } from './type';
@@ -328,9 +329,7 @@ export class SeederExecutor {
             options.factories = ['src/database/factories/**/*{.ts,.js}'];
         }
 
-        await adjustFilePathsForDataSourceOptions(options, {
-            keys: ['seeds', 'factories'],
-        });
+        await adjustFilePaths(options, ['seeds', 'factories']);
 
         return options;
     }

src/utils/file-path.ts

@@ -1,5 +1,7 @@
+import { CodeTransformation, isCodeTransformation } from './code-transformation';
 import { safeReplaceWindowsSeparator } from './separator';
 import { withoutTrailingSlash } from './slash';
+import { readTsConfig } from './tsconfig';
 
 const stripLeadingModifier = (text: string) => {
     if (text.startsWith('./')) {
@@ -100,3 +102,37 @@ export function transformFilePath(
 
     return stripLeadingModifier(base);
 }
+
+export async function adjustFilePaths<T extends Record<string, any>>(
+    input: T,
+    keys?: (keyof T)[],
+    rootDirectory?: string,
+): Promise<T> {
+    if (isCodeTransformation(CodeTransformation.JUST_IN_TIME)) {
+        return input;
+    }
+
+    const { compilerOptions } = await readTsConfig(rootDirectory);
+
+    keys = keys || Object.keys(input);
+
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        let value = input[key] as unknown;
+
+        if (typeof value === 'string') {
+            value = transformFilePath(value, compilerOptions?.outDir);
+        } else if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                if (typeof value[i] === 'string') {
+                    value[i] = transformFilePath(value[i], compilerOptions?.outDir);
+                }
+            }
+        }
+
+        input[key] = value as T[keyof T];
+    }
+
+    return input;
+}

test/unit/data-source/options/env.spec.ts

@@ -4,7 +4,8 @@ import {
     buildDataSourceOptions,
     hasEnvDataSourceOptions,
     mergeDataSourceOptionsWithEnv,
-    readDataSourceOptionsFromEnv, resetEnv,
+    readDataSourceOptionsFromEnv,
+    resetEnv,
 } from '../../../../src';
 import { User } from '../../../data/entity/user';
 

test/unit/utils/file-path.spec.ts

@@ -1,5 +1,6 @@
 import {
-    adjustFilePathsForDataSourceOptions, transformFilePath,
+    adjustFilePaths,
+    transformFilePath,
 } from '../../../src';
 
 describe('src/connection/utils.ts', () => {
@@ -88,7 +89,7 @@ describe('src/connection/utils.ts', () => {
     });
 
     it('should modify connection option(s) for runtime environment', async () => {
-        const modifiedConnectionOptions = await adjustFilePathsForDataSourceOptions({
+        const modifiedConnectionOptions = await adjustFilePaths({
             factories: ['src/factories.ts'],
             seeds: ['src/seeds.ts'],
             entities: ['src/entities.ts'],
@@ -102,12 +103,12 @@ describe('src/connection/utils.ts', () => {
             subscribers: ['dist/subscribers.js'],
         });
 
-        const modifiedConnectionOption = await adjustFilePathsForDataSourceOptions({
+        const modifiedConnectionOption = await adjustFilePaths({
             entities: ['./src/entities.ts'],
         });
         expect(modifiedConnectionOption).toEqual({ entities: ['dist/entities.js'] });
 
-        const modifiedConnectionOptionAlt = await adjustFilePathsForDataSourceOptions({
+        const modifiedConnectionOptionAlt = await adjustFilePaths({
             entities: ['src/entities.ts'],
         });
         expect(modifiedConnectionOptionAlt).toEqual({ entities: ['dist/entities.js'] });