Support testing with Postgres and MySQL for user management backend

packages/cli/jest.config.js

@@ -19,4 +19,6 @@ module.exports = {
 			isolatedModules: true
 		}
 	},
+	globalTeardown: '<rootDir>/test/teardown.ts',
+	setupFiles: ['<rootDir>/test/setup.ts'],
 }

packages/cli/package.json

@@ -29,7 +29,10 @@
     "start": "run-script-os",
     "start:default": "cd bin && ./n8n",
     "start:windows": "cd bin && n8n",
-    "test": "jest",
+    "test": "npm run test:sqlite",
+    "test:sqlite": "export DB_TYPE=sqlite && jest",
+    "test:postgres": "export DB_TYPE=postgresdb && jest",
+    "test:mysql": "export DB_TYPE=mysqldb && jest",
     "watch": "tsc --watch",
     "typeorm": "ts-node ../../node_modules/typeorm/cli.js"
   },

packages/cli/src/Db.ts

@@ -4,7 +4,16 @@
 /* eslint-disable no-case-declarations */
 /* eslint-disable @typescript-eslint/naming-convention */
 import { UserSettings } from 'n8n-core';
-import { ConnectionOptions, createConnection, getRepository, LoggerOptions } from 'typeorm';
+import {
+	Connection,
+	ConnectionOptions,
+	createConnection,
+	EntityManager,
+	EntityTarget,
+	getRepository,
+	LoggerOptions,
+	Repository,
+} from 'typeorm';
 import { TlsOptions } from 'tls';
 import * as path from 'path';
 // eslint-disable-next-line import/no-cycle
@@ -18,8 +27,6 @@ import { entities } from './databases/entities';
 import { postgresMigrations } from './databases/postgresdb/migrations';
 import { mysqlMigrations } from './databases/mysqldb/migrations';
 import { sqliteMigrations } from './databases/sqlite/migrations';
-import { TEST_CONNECTION_OPTIONS } from '../test/integration/shared/constants';
-import { isTestRun } from '../test/integration/shared/utils';
 
 export const collections: IDatabaseCollections = {
 	Credentials: null,
@@ -34,82 +41,100 @@ export const collections: IDatabaseCollections = {
 	Settings: null,
 };
 
-export async function init(): Promise<IDatabaseCollections> {
+let connection: Connection;
+
+export async function transaction<T>(fn: (entityManager: EntityManager) => Promise<T>): Promise<T> {
+	return connection.transaction(fn);
+}
+
+export function linkRepository<Entity>(entityClass: EntityTarget<Entity>): Repository<Entity> {
+	return getRepository(entityClass, connection.name);
+}
+
+export async function init(
+	testConnectionOptions?: ConnectionOptions,
+): Promise<IDatabaseCollections> {
 	const dbType = (await GenericHelpers.getConfigValue('database.type')) as DatabaseType;
 	const n8nFolder = UserSettings.getUserN8nFolderPath();
 
 	let connectionOptions: ConnectionOptions;
 
 	const entityPrefix = config.get('database.tablePrefix');
 
-	switch (dbType) {
-		case 'postgresdb':
-			const sslCa = (await GenericHelpers.getConfigValue('database.postgresdb.ssl.ca')) as string;
-			const sslCert = (await GenericHelpers.getConfigValue(
-				'database.postgresdb.ssl.cert',
-			)) as string;
-			const sslKey = (await GenericHelpers.getConfigValue('database.postgresdb.ssl.key')) as string;
-			const sslRejectUnauthorized = (await GenericHelpers.getConfigValue(
-				'database.postgresdb.ssl.rejectUnauthorized',
-			)) as boolean;
-
-			let ssl: TlsOptions | undefined;
-			if (sslCa !== '' || sslCert !== '' || sslKey !== '' || !sslRejectUnauthorized) {
-				ssl = {
-					ca: sslCa || undefined,
-					cert: sslCert || undefined,
-					key: sslKey || undefined,
-					rejectUnauthorized: sslRejectUnauthorized,
+	if (testConnectionOptions) {
+		connectionOptions = testConnectionOptions;
+	} else {
+		switch (dbType) {
+			case 'postgresdb':
+				const sslCa = (await GenericHelpers.getConfigValue('database.postgresdb.ssl.ca')) as string;
+				const sslCert = (await GenericHelpers.getConfigValue(
+					'database.postgresdb.ssl.cert',
+				)) as string;
+				const sslKey = (await GenericHelpers.getConfigValue(
+					'database.postgresdb.ssl.key',
+				)) as string;
+				const sslRejectUnauthorized = (await GenericHelpers.getConfigValue(
+					'database.postgresdb.ssl.rejectUnauthorized',
+				)) as boolean;
+
+				let ssl: TlsOptions | undefined;
+				if (sslCa !== '' || sslCert !== '' || sslKey !== '' || !sslRejectUnauthorized) {
+					ssl = {
+						ca: sslCa || undefined,
+						cert: sslCert || undefined,
+						key: sslKey || undefined,
+						rejectUnauthorized: sslRejectUnauthorized,
+					};
+				}
+
+				connectionOptions = {
+					type: 'postgres',
+					entityPrefix,
+					database: (await GenericHelpers.getConfigValue('database.postgresdb.database')) as string,
+					host: (await GenericHelpers.getConfigValue('database.postgresdb.host')) as string,
+					password: (await GenericHelpers.getConfigValue('database.postgresdb.password')) as string,
+					port: (await GenericHelpers.getConfigValue('database.postgresdb.port')) as number,
+					username: (await GenericHelpers.getConfigValue('database.postgresdb.user')) as string,
+					schema: config.get('database.postgresdb.schema'),
+					migrations: postgresMigrations,
+					migrationsRun: true,
+					migrationsTableName: `${entityPrefix}migrations`,
+					ssl,
+				};
+
+				break;
+
+			case 'mariadb':
+			case 'mysqldb':
+				connectionOptions = {
+					type: dbType === 'mysqldb' ? 'mysql' : 'mariadb',
+					database: (await GenericHelpers.getConfigValue('database.mysqldb.database')) as string,
+					entityPrefix,
+					host: (await GenericHelpers.getConfigValue('database.mysqldb.host')) as string,
+					password: (await GenericHelpers.getConfigValue('database.mysqldb.password')) as string,
+					port: (await GenericHelpers.getConfigValue('database.mysqldb.port')) as number,
+					username: (await GenericHelpers.getConfigValue('database.mysqldb.user')) as string,
+					migrations: mysqlMigrations,
+					migrationsRun: true,
+					migrationsTableName: `${entityPrefix}migrations`,
+					timezone: 'Z', // set UTC as default
+				};
+				break;
+
+			case 'sqlite':
+				connectionOptions = {
+					type: 'sqlite',
+					database: path.join(n8nFolder, 'database.sqlite'),
+					entityPrefix,
+					migrations: sqliteMigrations,
+					migrationsRun: false, // migrations for sqlite will be ran manually for now; see below
+					migrationsTableName: `${entityPrefix}migrations`,
 				};
-			}
-
-			connectionOptions = {
-				type: 'postgres',
-				entityPrefix,
-				database: (await GenericHelpers.getConfigValue('database.postgresdb.database')) as string,
-				host: (await GenericHelpers.getConfigValue('database.postgresdb.host')) as string,
-				password: (await GenericHelpers.getConfigValue('database.postgresdb.password')) as string,
-				port: (await GenericHelpers.getConfigValue('database.postgresdb.port')) as number,
-				username: (await GenericHelpers.getConfigValue('database.postgresdb.user')) as string,
-				schema: config.get('database.postgresdb.schema'),
-				migrations: postgresMigrations,
-				migrationsRun: true,
-				migrationsTableName: `${entityPrefix}migrations`,
-				ssl,
-			};
-
-			break;
-
-		case 'mariadb':
-		case 'mysqldb':
-			connectionOptions = {
-				type: dbType === 'mysqldb' ? 'mysql' : 'mariadb',
-				database: (await GenericHelpers.getConfigValue('database.mysqldb.database')) as string,
-				entityPrefix,
-				host: (await GenericHelpers.getConfigValue('database.mysqldb.host')) as string,
-				password: (await GenericHelpers.getConfigValue('database.mysqldb.password')) as string,
-				port: (await GenericHelpers.getConfigValue('database.mysqldb.port')) as number,
-				username: (await GenericHelpers.getConfigValue('database.mysqldb.user')) as string,
-				migrations: mysqlMigrations,
-				migrationsRun: true,
-				migrationsTableName: `${entityPrefix}migrations`,
-				timezone: 'Z', // set UTC as default
-			};
-			break;
-
-		case 'sqlite':
-			connectionOptions = {
-				type: 'sqlite',
-				database: path.join(n8nFolder, 'database.sqlite'),
-				entityPrefix,
-				migrations: sqliteMigrations,
-				migrationsRun: false, // migrations for sqlite will be ran manually for now; see below
-				migrationsTableName: `${entityPrefix}migrations`,
-			};
-			break;
-
-		default:
-			throw new Error(`The database "${dbType}" is currently not supported!`);
+				break;
+
+			default:
+				throw new Error(`The database "${dbType}" is currently not supported!`);
+		}
 	}
 
 	let loggingOption: LoggerOptions = (await GenericHelpers.getConfigValue(
@@ -128,10 +153,6 @@ export async function init(): Promise<IDatabaseCollections> {
 		}
 	}
 
-	if (isTestRun) {
-		connectionOptions = TEST_CONNECTION_OPTIONS;
-	}
-
 	Object.assign(connectionOptions, {
 		entities: Object.values(entities),
 		synchronize: false,
@@ -141,9 +162,9 @@ export async function init(): Promise<IDatabaseCollections> {
 		)) as string,
 	});
 
-	let connection = await createConnection(connectionOptions);
+	connection = await createConnection(connectionOptions);
 
-	if (dbType === 'sqlite') {
+	if (!testConnectionOptions && dbType === 'sqlite') {
 		// This specific migration changes database metadata.
 		// A field is now nullable. We need to reconnect so that
 		// n8n knows it has changed. Happens only on sqlite.
@@ -169,17 +190,17 @@ export async function init(): Promise<IDatabaseCollections> {
 		}
 	}
 
-	collections.Credentials = getRepository(entities.CredentialsEntity);
-	collections.Execution = getRepository(entities.ExecutionEntity);
-	collections.Workflow = getRepository(entities.WorkflowEntity);
-	collections.Webhook = getRepository(entities.WebhookEntity);
-	collections.Tag = getRepository(entities.TagEntity);
-
-	collections.Role = getRepository(entities.Role);
-	collections.User = getRepository(entities.User);
-	collections.SharedCredentials = getRepository(entities.SharedCredentials);
-	collections.SharedWorkflow = getRepository(entities.SharedWorkflow);
-	collections.Settings = getRepository(entities.Settings);
+	collections.Credentials = linkRepository(entities.CredentialsEntity);
+	collections.Execution = linkRepository(entities.ExecutionEntity);
+	collections.Workflow = linkRepository(entities.WorkflowEntity);
+	collections.Webhook = linkRepository(entities.WebhookEntity);
+	collections.Tag = linkRepository(entities.TagEntity);
+
+	collections.Role = linkRepository(entities.Role);
+	collections.User = linkRepository(entities.User);
+	collections.SharedCredentials = linkRepository(entities.SharedCredentials);
+	collections.SharedWorkflow = linkRepository(entities.SharedWorkflow);
+	collections.Settings = linkRepository(entities.Settings);
 
 	return collections;
 }

packages/cli/src/ResponseHelper.ts

@@ -15,7 +15,6 @@ import {
 	IExecutionResponse,
 	IWorkflowDb,
 } from '.';
-import { isTestRun } from '../test/integration/shared/utils';
 
 /**
  * Special Error which allows to return also an error code and http status code
@@ -103,7 +102,9 @@ export function sendErrorResponse(res: Response, error: ResponseError, shouldLog
 		httpStatusCode = error.httpStatusCode;
 	}
 
-	if (process.env.NODE_ENV !== 'production' && shouldLog && !isTestRun) {
+	shouldLog = !process.argv[1].split('/').includes('jest');
+
+	if (process.env.NODE_ENV !== 'production' && shouldLog) {
 		console.error('ERROR RESPONSE');
 		console.error(error);
 	}

packages/cli/src/UserManagement/UserManagementHelper.ts

@@ -42,8 +42,6 @@ export async function getInstanceOwner(): Promise<User> {
 	return owner;
 }
 
-export const isEmailSetUp = Boolean(config.get('userManagement.emails.mode'));
-
 /**
  * Return the n8n instance base URL without trailing slash.
  */

packages/cli/src/UserManagement/routes/users.ts

@@ -1,20 +1,16 @@
+/* eslint-disable no-restricted-syntax */
 /* eslint-disable import/no-cycle */
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { Response } from 'express';
-import { getConnection, In } from 'typeorm';
+import { In } from 'typeorm';
 import { genSaltSync, hashSync } from 'bcryptjs';
 import validator from 'validator';
 import { LoggerProxy as Logger } from 'n8n-workflow';
 
 import { Db, ResponseHelper } from '../..';
 import { N8nApp, PublicUser } from '../Interfaces';
 import { UserRequest } from '../../requests';
-import {
-	getInstanceBaseUrl,
-	isEmailSetUp,
-	sanitizeUser,
-	validatePassword,
-} from '../UserManagementHelper';
+import { getInstanceBaseUrl, sanitizeUser, validatePassword } from '../UserManagementHelper';
 import { User } from '../../databases/entities/User';
 import { SharedWorkflow } from '../../databases/entities/SharedWorkflow';
 import { SharedCredentials } from '../../databases/entities/SharedCredentials';
@@ -117,7 +113,7 @@ export function usersNamespace(this: N8nApp): void {
 			Logger.debug(total > 1 ? `Creating ${total} user shells...` : `Creating 1 user shell...`);
 
 			try {
-				await getConnection().transaction(async (transactionManager) => {
+				await Db.transaction(async (transactionManager) => {
 					return Promise.all(
 						usersToSetUp.map(async (email) => {
 							const newUser = Object.assign(new User(), {
@@ -204,6 +200,16 @@ export function usersNamespace(this: N8nApp): void {
 				throw new ResponseHelper.ResponseError('Invalid payload', undefined, 400);
 			}
 
+			// Postgres validates UUID format
+			for (const userId of [inviterId, inviteeId]) {
+				if (!validator.isUUID(userId)) {
+					Logger.debug('Request to resolve signup token failed because of invalid user ID', {
+						userId,
+					});
+					throw new ResponseHelper.ResponseError('Invalid userId', undefined, 400);
+				}
+			}
+
 			const users = await Db.collections.User!.find({ where: { id: In([inviterId, inviteeId]) } });
 
 			if (users.length !== 2) {
@@ -357,7 +363,7 @@ export function usersNamespace(this: N8nApp): void {
 
 			if (transferId) {
 				const transferee = users.find((user) => user.id === transferId);
-				await getConnection().transaction(async (transactionManager) => {
+				await Db.transaction(async (transactionManager) => {
 					await transactionManager.update(
 						SharedWorkflow,
 						{ user: userToDelete },
@@ -385,7 +391,7 @@ export function usersNamespace(this: N8nApp): void {
 				}),
 			]);
 
-			await getConnection().transaction(async (transactionManager) => {
+			await Db.transaction(async (transactionManager) => {
 				const ownedWorkflows = await Promise.all(
 					ownedSharedWorkflows.map(async ({ workflow }) => {
 						if (workflow.active) {
@@ -414,6 +420,8 @@ export function usersNamespace(this: N8nApp): void {
 		ResponseHelper.send(async (req: UserRequest.Reinvite) => {
 			const { id: idToReinvite } = req.params;
 
+			const isEmailSetUp = config.get('userManagement.emails.mode') as '' | 'smtp';
+
 			if (!isEmailSetUp) {
 				Logger.error('Request to reinvite a user failed because email sending was not set up');
 				throw new ResponseHelper.ResponseError(

packages/cli/src/api/credentials.api.ts

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable import/no-cycle */
 import express = require('express');
-import { getConnection, In } from 'typeorm';
+import { In } from 'typeorm';
 import { UserSettings, Credentials } from 'n8n-core';
 import { INodeCredentialTestResult } from 'n8n-workflow';
 
@@ -15,8 +15,8 @@ import {
 	ICredentialsDb,
 	ICredentialsResponse,
 	whereClause,
+	ResponseHelper,
 } from '..';
-import * as ResponseHelper from '../ResponseHelper';
 
 import { RESPONSE_ERROR_MESSAGES } from '../constants';
 import { CredentialsEntity } from '../databases/entities/CredentialsEntity';
@@ -162,7 +162,7 @@ credentialsController.post(
 			scope: 'credential',
 		});
 
-		const { id, ...rest } = await getConnection().transaction(async (transactionManager) => {
+		const { id, ...rest } = await Db.transaction(async (transactionManager) => {
 			const savedCredential = await transactionManager.save<CredentialsEntity>(newCredential);
 
 			savedCredential.data = newCredential.data;