refactor(core): Cache workflow ownership (#6738)

* refactor: Set up ownership service

* refactor: Specify cache keys and values

* refactor: Replace util with service calls

* test: Mock service in tests

* refactor: Use dependency injection

* test: Write tests

* refactor: Apply feedback from Omar and Micha

* test: Fix tests

* test: Fix missing spot

* refactor: Return user entity from cache

* refactor: More dependency injection!

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

@@ -15,13 +15,15 @@ import type { WorkflowStatistics } from '@db/entities/WorkflowStatistics';
 import { WorkflowStatisticsRepository } from '@db/repositories';
 import { EventsService } from '@/services/events.service';
 import { UserService } from '@/user/user.service';
-import { getWorkflowOwner } from '@/UserManagement/UserManagementHelper';
+import { OwnershipService } from '@/services/ownership.service';
+import { mockInstance } from '../../integration/shared/utils';
 
 jest.mock('@/UserManagement/UserManagementHelper', () => ({ getWorkflowOwner: jest.fn() }));
 
 describe('EventsService', () => {
 	const dbType = config.getEnv('database.type');
 	const fakeUser = mock<User>({ id: 'abcde-fghij' });
+	const ownershipService = mockInstance(OwnershipService);
 
 	const entityManager = mock<EntityManager>();
 	const dataSource = mock<DataSource>({
@@ -36,10 +38,13 @@ describe('EventsService', () => {
 	LoggerProxy.init(mock<ILogger>());
 	config.set('diagnostics.enabled', true);
 	config.set('deployment.type', 'n8n-testing');
-	mocked(getWorkflowOwner).mockResolvedValue(fakeUser);
+	mocked(ownershipService.getWorkflowOwnerCached).mockResolvedValue(fakeUser);
 	const updateUserSettingsMock = jest.spyOn(UserService, 'updateUserSettings').mockImplementation();
 
-	const eventsService = new EventsService(new WorkflowStatisticsRepository(dataSource));
+	const eventsService = new EventsService(
+		new WorkflowStatisticsRepository(dataSource),
+		ownershipService,
+	);
 
 	const onFirstProductionWorkflowSuccess = jest.fn();
 	const onFirstWorkflowDataLoad = jest.fn();

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

@@ -0,0 +1,68 @@
+import { OwnershipService } from '@/services/ownership.service';
+import { RoleRepository, SharedWorkflowRepository, UserRepository } from '@/databases/repositories';
+import { mockInstance } from '../../integration/shared/utils';
+import { Role } from '@/databases/entities/Role';
+import { randomInteger } from '../../integration/shared/random';
+import { SharedWorkflow } from '@/databases/entities/SharedWorkflow';
+import { CacheService } from '@/services/cache.service';
+import { User } from '@/databases/entities/User';
+
+const wfOwnerRole = () =>
+	Object.assign(new Role(), {
+		scope: 'workflow',
+		name: 'owner',
+		id: randomInteger(),
+	});
+
+describe('OwnershipService', () => {
+	const cacheService = mockInstance(CacheService);
+	const roleRepository = mockInstance(RoleRepository);
+	const userRepository = mockInstance(UserRepository);
+	const sharedWorkflowRepository = mockInstance(SharedWorkflowRepository);
+
+	const ownershipService = new OwnershipService(
+		cacheService,
+		userRepository,
+		roleRepository,
+		sharedWorkflowRepository,
+	);
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe('getWorkflowOwner()', () => {
+		test('should retrieve a workflow owner', async () => {
+			roleRepository.findWorkflowOwnerRole.mockResolvedValueOnce(wfOwnerRole());
+
+			const mockOwner = new User();
+			const mockNonOwner = new User();
+
+			const sharedWorkflow = Object.assign(new SharedWorkflow(), {
+				role: new Role(),
+				user: mockOwner,
+			});
+
+			sharedWorkflowRepository.findOneOrFail.mockResolvedValueOnce(sharedWorkflow);
+
+			const returnedOwner = await ownershipService.getWorkflowOwnerCached('some-workflow-id');
+
+			expect(returnedOwner).toBe(mockOwner);
+			expect(returnedOwner).not.toBe(mockNonOwner);
+		});
+
+		test('should throw if no workflow owner role found', async () => {
+			roleRepository.findWorkflowOwnerRole.mockRejectedValueOnce(new Error());
+
+			await expect(ownershipService.getWorkflowOwnerCached('some-workflow-id')).rejects.toThrow();
+		});
+
+		test('should throw if no workflow owner found', async () => {
+			roleRepository.findWorkflowOwnerRole.mockResolvedValueOnce(wfOwnerRole());
+
+			sharedWorkflowRepository.findOneOrFail.mockRejectedValue(new Error());
+
+			await expect(ownershipService.getWorkflowOwnerCached('some-workflow-id')).rejects.toThrow();
+		});
+	});
+});