feat: remove legacy data-source options building

BREAKING CHANGE: ormconfig no longer supported

src/cli/commands/database/create.ts

@@ -7,8 +7,6 @@ import { CodeTransformation, setCodeTransformation } from '../../../utils';
 export interface DatabaseCreateArguments extends Arguments {
     codeTransformation: string,
     root: string;
-    connection: 'default' | string;
-    config: 'ormconfig' | string;
     dataSource: 'data-source' | string;
     synchronize: string;
     initialDatabase?: unknown;
@@ -31,18 +29,6 @@ export class DatabaseCreateCommand implements CommandModule {
                 default: process.cwd(),
                 describe: 'Path to the data-source / config file.',
             })
-            .option('connection', {
-                alias: 'c',
-                default: 'default',
-                describe: 'Name of the connection on which run a query.',
-                deprecated: true,
-            })
-            .option('config', {
-                alias: 'f',
-                default: 'ormconfig',
-                describe: 'Name of the file with the data-source configuration.',
-                deprecated: true,
-            })
             .option('dataSource', {
                 alias: 'd',
                 default: 'data-source',
@@ -67,8 +53,6 @@ export class DatabaseCreateCommand implements CommandModule {
         }
 
         const dataSourceOptions = await buildDataSourceOptions({
-            name: args.connection,
-            configName: args.config,
             directory: args.root,
             dataSourceName: args.dataSource,
         });

src/cli/commands/database/drop.ts

@@ -7,8 +7,6 @@ import { CodeTransformation, setCodeTransformation } from '../../../utils';
 export interface DatabaseDropArguments extends Arguments {
     codeTransformation: string,
     root: string;
-    connection: 'default' | string;
-    config: 'ormconfig' | string;
     dataSource: 'data-source' | string;
 }
 
@@ -29,18 +27,6 @@ export class DatabaseDropCommand implements CommandModule {
                 default: process.cwd(),
                 describe: 'Path to the data-source / config file.',
             })
-            .option('connection', {
-                alias: 'c',
-                default: 'default',
-                describe: 'Name of the connection on which run a query.',
-                deprecated: true,
-            })
-            .option('config', {
-                alias: 'f',
-                default: 'ormconfig',
-                describe: 'Name of the file with the data-source configuration.',
-                deprecated: true,
-            })
             .option('dataSource', {
                 alias: 'd',
                 default: 'data-source',
@@ -59,8 +45,6 @@ export class DatabaseDropCommand implements CommandModule {
         }
 
         const dataSourceOptions = await buildDataSourceOptions({
-            name: args.connection,
-            configName: args.config,
             directory: args.root,
             dataSourceName: args.dataSource,
         });

src/cli/commands/seed.ts

@@ -6,8 +6,6 @@ import { CodeTransformation, setCodeTransformation } from '../../utils';
 export interface DatabaseSeedArguments extends Arguments {
     codeTransformation: string,
     root: string;
-    connection: 'default' | string;
-    config: 'ormconfig' | string;
     dataSource: 'data-source' | string;
     seed: undefined | string,
 }
@@ -29,18 +27,6 @@ export class SeedCommand implements CommandModule {
                 default: process.cwd(),
                 describe: 'Path to the data-source / config file.',
             })
-            .option('connection', {
-                alias: 'c',
-                default: 'default',
-                describe: 'Name of the connection on which run a query.',
-                deprecated: true,
-            })
-            .option('config', {
-                alias: 'f',
-                default: 'ormconfig',
-                describe: 'Name of the file with the data-source configuration.',
-                deprecated: true,
-            })
             .option('dataSource', {
                 alias: 'd',
                 default: 'data-source',
@@ -60,8 +46,6 @@ export class SeedCommand implements CommandModule {
         }
 
         const dataSourceOptions = await buildDataSourceOptions({
-            name: args.connection,
-            configName: args.config,
             directory: args.root,
             dataSourceName: args.dataSource,
         });

src/data-source/options/module.ts

@@ -1,6 +1,6 @@
 import type { DataSourceOptions } from 'typeorm';
-import { ConnectionOptionsReader } from 'typeorm';
 import { useEnv } from '../../env';
+import { OptionsError } from '../../errors';
 import type { SeederOptions } from '../../seeder';
 import { findDataSource } from '../find';
 import type { DataSourceOptionsBuildContext } from './type';
@@ -53,28 +53,6 @@ export async function extendDataSourceOptions(
     return options;
 }
 
-/**
- * Build DataSourceOptions from configuration.
- *
- * @deprecated
- * @param context
- */
-export async function buildLegacyDataSourceOptions(
-    context: DataSourceOptionsBuildContext,
-) : Promise<DataSourceOptions> {
-    const directory : string = context.directory || process.cwd();
-    const tsconfigDirectory : string = context.tsconfigDirectory || process.cwd();
-
-    const connectionOptionsReader = new ConnectionOptionsReader({
-        root: directory,
-        configName: context.configName,
-    });
-
-    const dataSourceOptions = await connectionOptionsReader.get(context.name || 'default');
-
-    return extendDataSourceOptions(dataSourceOptions, tsconfigDirectory);
-}
-
 /**
  * Build DataSourceOptions from DataSource or from configuration.
  *
@@ -99,19 +77,13 @@ export async function buildDataSourceOptions(
             tsconfigDirectory,
         );
 
-        if (context.experimental) {
-            return mergeDataSourceOptionsWithEnv(options);
-        }
-
-        return options;
+        return mergeDataSourceOptionsWithEnv(options);
     }
 
-    if (context.experimental) {
-        const options = readDataSourceOptionsFromEnv();
-        if (options) {
-            return extendDataSourceOptions(options);
-        }
+    const options = readDataSourceOptionsFromEnv();
+    if (options) {
+        return extendDataSourceOptions(options);
     }
 
-    return buildLegacyDataSourceOptions(context);
+    throw OptionsError.notFound();
 }

src/data-source/options/type.ts

@@ -1,37 +1,20 @@
 export type DataSourceOptionsBuildContext = {
-    /**
-     * Database connection name
-     * Default: default
-     *
-     * @deprecated
-     */
-    name?: string,
-    /**
-     * Configuration file name without extension
-     * Default: ormconfig
-     *
-     * @deprecated
-     */
-    configName?: string,
     /**
      * Data source file name without extension
+     *
      * Default: data-source
      */
     dataSourceName?: string,
     /**
      * Directory where to find dataSource + config
+     *
      * Default: process.cwd()
      */
     directory?: string,
     /**
      * Directory path to the tsconfig.json file
+     *
      * Default: process.cwd()
      */
-    tsconfigDirectory?: string,
-
-    /**
-     * Use experimental features,
-     * like merging env and file data-source options.
-     */
-    experimental?: boolean
+    tsconfigDirectory?: string
 };

src/errors/options.ts

@@ -9,6 +9,10 @@ export class OptionsError extends TypeormExtensionError {
         return new OptionsError('The database options could not be determined.');
     }
 
+    static notFound() {
+        return new OptionsError('The database options could not be located/loaded.');
+    }
+
     static databaseNotDefined() {
         return new OptionsError('The database name to connect to is not defined.');
     }

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

@@ -5,7 +5,7 @@ import {
     mergeDataSourceOptionsWithEnv,
     readDataSourceOptionsFromEnv
 } from "../../../../src";
-import {EnvironmentVariableName, resetEnv, } from "../../../../src/env";
+import {EnvironmentVariableName, resetEnv, } from "../../../../src";
 import {User} from "../../../data/entity/user";
 
 describe('src/data-source/options/env', function () {
@@ -64,8 +64,7 @@ describe('src/data-source/options/env', function () {
         };
 
         const options = await buildDataSourceOptions({
-            directory: 'test/data/typeorm',
-            experimental: true
+            directory: 'test/data/typeorm'
         });
 
         expect(options).toBeDefined();

test/unit/database/index.spec.ts

@@ -1,48 +1,20 @@
-import path from "path";
+import path from "node:path";
 import {
-    buildLegacyDataSourceOptions,
+    buildDataSourceOptions,
 } from "../../../src";
-import {buildDriverOptions} from "../../../src";
-import {getCharsetFromDataSourceOptions} from "../../../src";
 import {checkTestDatabase, destroyTestDatabase} from "../../data/typeorm/utils";
 
 describe('src/database/module.ts', () => {
     const rootPath : string = path.resolve(process.cwd(), 'test/data/typeorm');
 
     it('should build simple connection options', async () => {
-        const options = await buildLegacyDataSourceOptions({
+        const options = await buildDataSourceOptions({
             directory: rootPath,
-            configName: 'ormconfig.json'
         });
 
         expect(options).toBeDefined();
-
-        const driverOptions = buildDriverOptions(options);
-        expect(driverOptions).toBeDefined();
-        expect(driverOptions.host).toEqual('localhost');
-        expect(driverOptions.user).toEqual('root');
-        expect(driverOptions.password).toEqual('admin');
-        expect(driverOptions.database).toEqual('test');
-        expect(driverOptions.extra).toBeDefined();
-        if(driverOptions.extra) {
-            expect(driverOptions.extra.socketPath).toEqual('/var/mysqld/mysqld.sock');
-        }
-        expect(driverOptions.port).toEqual(3306);
-        expect(driverOptions.charset).toEqual('UTF8_GENERAL_CI');
     });
 
-    it('should extend database operation options', async () => {
-        const connectionOptions = await buildLegacyDataSourceOptions({
-            directory: rootPath,
-            configName: 'ormconfig.json'
-        });
-
-        expect(connectionOptions).toBeDefined();
-
-        const charset = getCharsetFromDataSourceOptions(connectionOptions);
-        expect(charset).toEqual('UTF8_GENERAL_CI');
-    })
-
     it('should check database',  async () => {
         let check = await checkTestDatabase();