refactor(core): Use injectable classes for db repositories (part-1) (no-changelog) (#5953)

Co-authored-by: ricardo <ricardoespinoza105@gmail.com>

packages/cli/test/unit/ActiveWorkflowRunner.test.ts

@@ -11,10 +11,10 @@ import {
 
 import { ActiveWorkflowRunner } from '@/ActiveWorkflowRunner';
 import * as Db from '@/Db';
-import { WorkflowEntity } from '@/databases/entities/WorkflowEntity';
-import { SharedWorkflow } from '@/databases/entities/SharedWorkflow';
-import { Role } from '@/databases/entities/Role';
-import { User } from '@/databases/entities/User';
+import { WorkflowEntity } from '@db/entities/WorkflowEntity';
+import { SharedWorkflow } from '@db/entities/SharedWorkflow';
+import { Role } from '@db/entities/Role';
+import { User } from '@db/entities/User';
 import { getLogger } from '@/Logger';
 import { randomEmail, randomName } from '../integration/shared/random';
 import * as Helpers from './Helpers';

packages/cli/test/unit/Events.test.ts

@@ -1,11 +1,12 @@
 import { IRun, LoggerProxy, WorkflowExecuteMode } from 'n8n-workflow';
-import { QueryFailedError, Repository } from 'typeorm';
+import { QueryFailedError } from 'typeorm';
 import { mock } from 'jest-mock-extended';
 
 import config from '@/config';
 import * as Db from '@/Db';
 import { User } from '@db/entities/User';
 import { WorkflowStatistics } from '@db/entities/WorkflowStatistics';
+import { WorkflowStatisticsRepository } from '@db/repositories';
 import { nodeFetchedData, workflowExecutionCompleted } from '@/events/WorkflowStatistics';
 import * as UserManagementHelper from '@/UserManagement/UserManagementHelper';
 import { getLogger } from '@/Logger';
@@ -14,7 +15,6 @@ import { InternalHooks } from '@/InternalHooks';
 import { mockInstance } from '../integration/shared/utils';
 import { UserService } from '@/user/user.service';
 
-type WorkflowStatisticsRepository = Repository<WorkflowStatistics>;
 jest.mock('@/Db', () => {
 	return {
 		collections: {

packages/cli/test/unit/controllers/me.controller.test.ts

@@ -5,6 +5,7 @@ import { mock, anyObject, captor } from 'jest-mock-extended';
 import type { ILogger } from 'n8n-workflow';
 import type { IExternalHooksClass, IInternalHooksClass } from '@/Interfaces';
 import type { User } from '@db/entities/User';
+import { UserRepository } from '@db/repositories';
 import { MeController } from '@/controllers';
 import { AUTH_COOKIE_NAME } from '@/constants';
 import { BadRequestError } from '@/ResponseHelper';
@@ -15,7 +16,7 @@ describe('MeController', () => {
 	const logger = mock<ILogger>();
 	const externalHooks = mock<IExternalHooksClass>();
 	const internalHooks = mock<IInternalHooksClass>();
-	const userRepository = mock<Repository<User>>();
+	const userRepository = mock<UserRepository>();
 	const controller = new MeController({
 		logger,
 		externalHooks,

packages/cli/test/unit/controllers/owner.controller.test.ts

@@ -1,12 +1,15 @@
-import type { Repository } from 'typeorm';
 import type { CookieOptions, Response } from 'express';
 import { anyObject, captor, mock } from 'jest-mock-extended';
 import type { ILogger } from 'n8n-workflow';
 import jwt from 'jsonwebtoken';
-import type { ICredentialsDb, IInternalHooksClass } from '@/Interfaces';
+import type { IInternalHooksClass } from '@/Interfaces';
 import type { User } from '@db/entities/User';
-import type { Settings } from '@db/entities/Settings';
-import type { WorkflowEntity } from '@db/entities/WorkflowEntity';
+import type {
+	CredentialsRepository,
+	SettingsRepository,
+	UserRepository,
+	WorkflowRepository,
+} from '@db/repositories';
 import type { Config } from '@/config';
 import { BadRequestError } from '@/ResponseHelper';
 import type { OwnerRequest } from '@/requests';
@@ -18,10 +21,10 @@ describe('OwnerController', () => {
 	const config = mock<Config>();
 	const logger = mock<ILogger>();
 	const internalHooks = mock<IInternalHooksClass>();
-	const userRepository = mock<Repository<User>>();
-	const settingsRepository = mock<Repository<Settings>>();
-	const credentialsRepository = mock<Repository<ICredentialsDb>>();
-	const workflowsRepository = mock<Repository<WorkflowEntity>>();
+	const userRepository = mock<UserRepository>();
+	const settingsRepository = mock<SettingsRepository>();
+	const credentialsRepository = mock<CredentialsRepository>();
+	const workflowsRepository = mock<WorkflowRepository>();
 	const controller = new OwnerController({
 		config,
 		logger,

packages/cli/test/unit/repositories/role.repository.test.ts

@@ -0,0 +1,47 @@
+import { Container } from 'typedi';
+import { DataSource, EntityManager } from 'typeorm';
+import { mock } from 'jest-mock-extended';
+import { Role, RoleNames, RoleScopes } from '@db/entities/Role';
+import { RoleRepository } from '@db/repositories/role.repository';
+import { mockInstance } from '../../integration/shared/utils';
+import { randomInteger } from '../../integration/shared/random';
+
+describe('RoleRepository', () => {
+	const entityManager = mockInstance(EntityManager);
+	const dataSource = mockInstance(DataSource, { manager: entityManager });
+	dataSource.getMetadata.mockReturnValue(mock());
+	Object.assign(entityManager, { connection: dataSource });
+	const roleRepository = Container.get(RoleRepository);
+
+	describe('findRole', () => {
+		test('should return the role when present', async () => {
+			entityManager.findOne.mockResolvedValueOnce(createRole('global', 'owner'));
+			const role = await roleRepository.findRole('global', 'owner');
+			expect(role?.name).toEqual('owner');
+			expect(role?.scope).toEqual('global');
+		});
+
+		test('should return null otherwise', async () => {
+			entityManager.findOne.mockResolvedValueOnce(null);
+			const role = await roleRepository.findRole('global', 'owner');
+			expect(role).toEqual(null);
+		});
+	});
+
+	describe('findRoleOrFail', () => {
+		test('should return the role when present', async () => {
+			entityManager.findOneOrFail.mockResolvedValueOnce(createRole('global', 'owner'));
+			const role = await roleRepository.findRoleOrFail('global', 'owner');
+			expect(role?.name).toEqual('owner');
+			expect(role?.scope).toEqual('global');
+		});
+
+		test('should throw otherwise', async () => {
+			entityManager.findOneOrFail.mockRejectedValueOnce(new Error());
+			expect(() => roleRepository.findRoleOrFail('global', 'owner')).rejects.toThrow();
+		});
+	});
+
+	const createRole = (scope: RoleScopes, name: RoleNames) =>
+		Object.assign(new Role(), { name, scope, id: `${randomInteger()}` });
+});

packages/cli/test/unit/services/role.service.test.ts

@@ -0,0 +1,28 @@
+import { SharedWorkflowRepository } from '@db/repositories/sharedWorkflow.repository';
+import { Role } from '@db/entities/Role';
+import { SharedWorkflow } from '@db/entities/SharedWorkflow';
+import { RoleService } from '@/role/role.service';
+import { mockInstance } from '../../integration/shared/utils';
+
+describe('RoleService', () => {
+	const sharedWorkflowRepository = mockInstance(SharedWorkflowRepository);
+	const roleService = new RoleService(sharedWorkflowRepository);
+
+	const userId = '1';
+	const workflowId = '42';
+
+	describe('getUserRoleForWorkflow', () => {
+		test('should return the role if a shared workflow is found', async () => {
+			const sharedWorkflow = Object.assign(new SharedWorkflow(), { role: new Role() });
+			sharedWorkflowRepository.findOne.mockResolvedValueOnce(sharedWorkflow);
+			const role = await roleService.getUserRoleForWorkflow(userId, workflowId);
+			expect(role).toBe(sharedWorkflow.role);
+		});
+
+		test('should return undefined if no shared workflow is found', async () => {
+			sharedWorkflowRepository.findOne.mockResolvedValueOnce(null);
+			const role = await roleService.getUserRoleForWorkflow(userId, workflowId);
+			expect(role).toBeUndefined();
+		});
+	});
+});