refactor(core): Reduce code duplication in DB config (no-changelog) (#8679)

packages/cli/src/Db.ts

@@ -1,27 +1,14 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 import { Container } from 'typedi';
-import type {
-	DataSourceOptions as ConnectionOptions,
-	EntityManager,
-	LoggerOptions,
-} from '@n8n/typeorm';
+import type { EntityManager } from '@n8n/typeorm';
 import { DataSource as Connection } from '@n8n/typeorm';
-import type { TlsOptions } from 'tls';
-import { ApplicationError, ErrorReporterProxy as ErrorReporter } from 'n8n-workflow';
+import { ErrorReporterProxy as ErrorReporter } from 'n8n-workflow';
 
 import config from '@/config';
-
-import { entities } from '@db/entities';
-import {
-	getMariaDBConnectionOptions,
-	getMysqlConnectionOptions,
-	getOptionOverrides,
-	getPostgresConnectionOptions,
-	getSqliteConnectionOptions,
-} from '@db/config';
 import { inTest } from '@/constants';
 import { wrapMigration } from '@db/utils/migrationHelpers';
-import type { DatabaseType, Migration } from '@db/types';
+import type { Migration } from '@db/types';
+import { getConnectionOptions } from '@db/config';
 
 let connection: Connection;
 
@@ -61,46 +48,6 @@ export async function transaction<T>(fn: (entityManager: EntityManager) => Promi
 	return await connection.transaction(fn);
 }
 
-export function getConnectionOptions(dbType: DatabaseType): ConnectionOptions {
-	switch (dbType) {
-		case 'postgresdb':
-			const sslCa = config.getEnv('database.postgresdb.ssl.ca');
-			const sslCert = config.getEnv('database.postgresdb.ssl.cert');
-			const sslKey = config.getEnv('database.postgresdb.ssl.key');
-			const sslRejectUnauthorized = config.getEnv('database.postgresdb.ssl.rejectUnauthorized');
-
-			let ssl: TlsOptions | boolean = config.getEnv('database.postgresdb.ssl.enabled');
-			if (sslCa !== '' || sslCert !== '' || sslKey !== '' || !sslRejectUnauthorized) {
-				ssl = {
-					ca: sslCa || undefined,
-					cert: sslCert || undefined,
-					key: sslKey || undefined,
-					rejectUnauthorized: sslRejectUnauthorized,
-				};
-			}
-
-			return {
-				...getPostgresConnectionOptions(),
-				...getOptionOverrides('postgresdb'),
-				ssl,
-			};
-
-		case 'mariadb':
-		case 'mysqldb':
-			return {
-				...(dbType === 'mysqldb' ? getMysqlConnectionOptions() : getMariaDBConnectionOptions()),
-				...getOptionOverrides('mysqldb'),
-				timezone: 'Z', // set UTC as default
-			};
-
-		case 'sqlite':
-			return getSqliteConnectionOptions();
-
-		default:
-			throw new ApplicationError('Database type currently not supported', { extra: { dbType } });
-	}
-}
-
 export async function setSchema(conn: Connection) {
 	const schema = config.getEnv('database.postgresdb.schema');
 	const searchPath = ['public'];
@@ -111,33 +58,11 @@ export async function setSchema(conn: Connection) {
 	await conn.query(`SET search_path TO ${searchPath.join(',')};`);
 }
 
-export async function init(testConnectionOptions?: ConnectionOptions): Promise<void> {
+export async function init(): Promise<void> {
 	if (connectionState.connected) return;
 
 	const dbType = config.getEnv('database.type');
-	const connectionOptions = testConnectionOptions ?? getConnectionOptions(dbType);
-
-	let loggingOption: LoggerOptions = config.getEnv('database.logging.enabled');
-
-	if (loggingOption) {
-		const optionsString = config.getEnv('database.logging.options').replace(/\s+/g, '');
-
-		if (optionsString === 'all') {
-			loggingOption = optionsString;
-		} else {
-			loggingOption = optionsString.split(',') as LoggerOptions;
-		}
-	}
-
-	const maxQueryExecutionTime = config.getEnv('database.logging.maxQueryExecutionTime');
-
-	Object.assign(connectionOptions, {
-		entities: Object.values(entities),
-		synchronize: false,
-		logging: loggingOption,
-		maxQueryExecutionTime,
-		migrationsRun: false,
-	});
+	const connectionOptions = getConnectionOptions();
 
 	connection = new Connection(connectionOptions);
 	Container.set(Connection, connection);

packages/cli/src/commands/db/revert.ts

@@ -3,7 +3,8 @@ import type { DataSourceOptions as ConnectionOptions } from '@n8n/typeorm';
 import { DataSource as Connection } from '@n8n/typeorm';
 import { Container } from 'typedi';
 import { Logger } from '@/Logger';
-import { getConnectionOptions, setSchema } from '@/Db';
+import { setSchema } from '@/Db';
+import { getConnectionOptions } from '@db/config';
 import type { Migration } from '@db/types';
 import { wrapMigration } from '@db/utils/migrationHelpers';
 import config from '@/config';
@@ -28,7 +29,7 @@ export class DbRevertMigrationCommand extends Command {
 	async run() {
 		const dbType = config.getEnv('database.type');
 		const connectionOptions: ConnectionOptions = {
-			...getConnectionOptions(dbType),
+			...getConnectionOptions(),
 			subscribers: [],
 			synchronize: false,
 			migrationsRun: false,

packages/cli/src/databases/config.ts

@@ -1,45 +1,41 @@
 import path from 'path';
 import { Container } from 'typedi';
+import type { TlsOptions } from 'tls';
+import type { DataSourceOptions, LoggerOptions } from '@n8n/typeorm';
 import type { SqliteConnectionOptions } from '@n8n/typeorm/driver/sqlite/SqliteConnectionOptions';
 import type { PostgresConnectionOptions } from '@n8n/typeorm/driver/postgres/PostgresConnectionOptions';
 import type { MysqlConnectionOptions } from '@n8n/typeorm/driver/mysql/MysqlConnectionOptions';
 import { InstanceSettings } from 'n8n-core';
+import { ApplicationError } from 'n8n-workflow';
 
+import config from '@/config';
 import { entities } from './entities';
 import { mysqlMigrations } from './migrations/mysqldb';
 import { postgresMigrations } from './migrations/postgresdb';
 import { sqliteMigrations } from './migrations/sqlite';
-import type { DatabaseType } from '@db/types';
-import config from '@/config';
 
-const entitiesDir = path.resolve(__dirname, 'entities');
-
-const getDBConnectionOptions = (dbType: DatabaseType) => {
+const getCommonOptions = () => {
 	const entityPrefix = config.getEnv('database.tablePrefix');
-	const migrationsDir = path.resolve(__dirname, 'migrations', dbType);
-	const configDBType = dbType === 'mariadb' ? 'mysqldb' : dbType;
-	const connectionDetails =
-		configDBType === 'sqlite'
-			? {
-					database: path.resolve(
-						Container.get(InstanceSettings).n8nFolder,
-						config.getEnv('database.sqlite.database'),
-					),
-					enableWAL: config.getEnv('database.sqlite.enableWAL'),
-			  }
-			: {
-					database: config.getEnv(`database.${configDBType}.database`),
-					username: config.getEnv(`database.${configDBType}.user`),
-					password: config.getEnv(`database.${configDBType}.password`),
-					host: config.getEnv(`database.${configDBType}.host`),
-					port: config.getEnv(`database.${configDBType}.port`),
-			  };
+	const maxQueryExecutionTime = config.getEnv('database.logging.maxQueryExecutionTime');
+
+	let loggingOption: LoggerOptions = config.getEnv('database.logging.enabled');
+	if (loggingOption) {
+		const optionsString = config.getEnv('database.logging.options').replace(/\s+/g, '');
+
+		if (optionsString === 'all') {
+			loggingOption = optionsString;
+		} else {
+			loggingOption = optionsString.split(',') as LoggerOptions;
+		}
+	}
 	return {
 		entityPrefix,
 		entities: Object.values(entities),
 		migrationsTableName: `${entityPrefix}migrations`,
-		cli: { entitiesDir, migrationsDir },
-		...connectionDetails,
+		migrationsRun: false,
+		synchronize: false,
+		maxQueryExecutionTime,
+		logging: loggingOption,
 	};
 };
 
@@ -51,28 +47,63 @@ export const getOptionOverrides = (dbType: 'postgresdb' | 'mysqldb') => ({
 	password: config.getEnv(`database.${dbType}.password`),
 });
 
-export const getSqliteConnectionOptions = (): SqliteConnectionOptions => ({
+const getSqliteConnectionOptions = (): SqliteConnectionOptions => ({
 	type: 'sqlite',
-	...getDBConnectionOptions('sqlite'),
+	...getCommonOptions(),
+	database: path.resolve(
+		Container.get(InstanceSettings).n8nFolder,
+		config.getEnv('database.sqlite.database'),
+	),
+	enableWAL: config.getEnv('database.sqlite.enableWAL'),
 	migrations: sqliteMigrations,
 });
 
-export const getPostgresConnectionOptions = (): PostgresConnectionOptions => ({
-	type: 'postgres',
-	...getDBConnectionOptions('postgresdb'),
-	schema: config.getEnv('database.postgresdb.schema'),
-	poolSize: config.getEnv('database.postgresdb.poolSize'),
-	migrations: postgresMigrations,
+const getPostgresConnectionOptions = (): PostgresConnectionOptions => {
+	const sslCa = config.getEnv('database.postgresdb.ssl.ca');
+	const sslCert = config.getEnv('database.postgresdb.ssl.cert');
+	const sslKey = config.getEnv('database.postgresdb.ssl.key');
+	const sslRejectUnauthorized = config.getEnv('database.postgresdb.ssl.rejectUnauthorized');
+
+	let ssl: TlsOptions | boolean = config.getEnv('database.postgresdb.ssl.enabled');
+	if (sslCa !== '' || sslCert !== '' || sslKey !== '' || !sslRejectUnauthorized) {
+		ssl = {
+			ca: sslCa || undefined,
+			cert: sslCert || undefined,
+			key: sslKey || undefined,
+			rejectUnauthorized: sslRejectUnauthorized,
+		};
+	}
+
+	return {
+		type: 'postgres',
+		...getCommonOptions(),
+		...getOptionOverrides('postgresdb'),
+		schema: config.getEnv('database.postgresdb.schema'),
+		poolSize: config.getEnv('database.postgresdb.poolSize'),
+		migrations: postgresMigrations,
+		ssl,
+	};
+};
+
+const getMysqlConnectionOptions = (dbType: 'mariadb' | 'mysqldb'): MysqlConnectionOptions => ({
+	type: dbType === 'mysqldb' ? 'mysql' : 'mariadb',
+	...getCommonOptions(),
+	...getOptionOverrides('mysqldb'),
+	migrations: mysqlMigrations,
+	timezone: 'Z', // set UTC as default
 });
 
-export const getMysqlConnectionOptions = (): MysqlConnectionOptions => ({
-	type: 'mysql',
-	...getDBConnectionOptions('mysqldb'),
-	migrations: mysqlMigrations,
-});
-
-export const getMariaDBConnectionOptions = (): MysqlConnectionOptions => ({
-	type: 'mariadb',
-	...getDBConnectionOptions('mysqldb'),
-	migrations: mysqlMigrations,
-});
+export function getConnectionOptions(): DataSourceOptions {
+	const dbType = config.getEnv('database.type');
+	switch (dbType) {
+		case 'sqlite':
+			return getSqliteConnectionOptions();
+		case 'postgresdb':
+			return getPostgresConnectionOptions();
+		case 'mariadb':
+		case 'mysqldb':
+			return getMysqlConnectionOptions(dbType);
+		default:
+			throw new ApplicationError('Database type currently not supported', { extra: { dbType } });
+	}
+}

packages/cli/src/databases/ormconfig.ts

@@ -1,13 +0,0 @@
-import {
-	getMariaDBConnectionOptions,
-	getMysqlConnectionOptions,
-	getPostgresConnectionOptions,
-	getSqliteConnectionOptions,
-} from './config';
-
-export default [
-	getSqliteConnectionOptions(),
-	getPostgresConnectionOptions(),
-	getMysqlConnectionOptions(),
-	getMariaDBConnectionOptions(),
-];