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

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 } });
+	}
+}