refactor(core): Use an IoC container to manage singleton classes [Part-1] (no-changelog) (#5509)

* add typedi

* convert ActiveWorkflowRunner into an injectable service

* convert ExternalHooks into an injectable service

* convert InternalHooks into an injectable service

* convert LoadNodesAndCredentials into an injectable service

* convert NodeTypes and CredentialTypes into an injectable service

* convert ActiveExecutions into an injectable service

* convert WaitTracker into an injectable service

* convert Push into an injectable service

* convert ActiveWebhooks and  TestWebhooks into an injectable services

* handle circular references, and log errors when a circular dependency is found

packages/cli/test/integration/audit/nodes.risk.test.ts

@@ -6,6 +6,13 @@ import { OFFICIAL_RISKY_NODE_TYPES, NODES_REPORT } from '@/audit/constants';
 import { getRiskSection, MOCK_PACKAGE, saveManualTriggerWorkflow } from './utils';
 import * as testDb from '../shared/testDb';
 import { toReportTitle } from '@/audit/utils';
+import { mockInstance } from '../shared/utils';
+import { LoadNodesAndCredentials } from '@/LoadNodesAndCredentials';
+import { NodeTypes } from '@/NodeTypes';
+
+const nodesAndCredentials = mockInstance(LoadNodesAndCredentials);
+nodesAndCredentials.getCustomDirectories.mockReturnValue([]);
+mockInstance(NodeTypes);
 
 beforeAll(async () => {
 	await testDb.init();

packages/cli/test/integration/commands/reset.cmd.test.ts

@@ -2,10 +2,17 @@ import * as Db from '@/Db';
 import { Reset } from '@/commands/user-management/reset';
 import type { Role } from '@db/entities/Role';
 import * as testDb from '../shared/testDb';
+import { mockInstance } from '../shared/utils';
+import { InternalHooks } from '@/InternalHooks';
+import { LoadNodesAndCredentials } from '@/LoadNodesAndCredentials';
+import { NodeTypes } from '@/NodeTypes';
 
 let globalOwnerRole: Role;
 
 beforeAll(async () => {
+	mockInstance(InternalHooks);
+	mockInstance(LoadNodesAndCredentials);
+	mockInstance(NodeTypes);
 	await testDb.init();
 
 	globalOwnerRole = await testDb.getGlobalOwnerRole();

packages/cli/test/integration/nodes.api.test.ts

@@ -20,6 +20,12 @@ import type { Role } from '@db/entities/Role';
 import type { AuthAgent } from './shared/types';
 import type { InstalledNodes } from '@db/entities/InstalledNodes';
 import { COMMUNITY_PACKAGE_VERSION } from './shared/constants';
+import { NodeTypes } from '@/NodeTypes';
+import { Push } from '@/push';
+
+const mockLoadNodesAndCredentials = utils.mockInstance(LoadNodesAndCredentials);
+utils.mockInstance(NodeTypes);
+utils.mockInstance(Push);
 
 jest.mock('@/CommunityNodes/helpers', () => {
 	return {
@@ -213,7 +219,7 @@ test('POST /nodes should allow installing packages that could not be loaded', as
 	mocked(hasPackageLoaded).mockReturnValueOnce(false);
 	mocked(checkNpmPackageStatus).mockResolvedValueOnce({ status: 'OK' });
 
-	jest.spyOn(LoadNodesAndCredentials(), 'loadNpmModule').mockImplementationOnce(mockedEmptyPackage);
+	mockLoadNodesAndCredentials.loadNpmModule.mockImplementationOnce(mockedEmptyPackage);
 
 	const { statusCode } = await authAgent(ownerShell).post('/nodes').send({
 		name: utils.installedPackagePayload().packageName,
@@ -267,9 +273,7 @@ test('DELETE /nodes should reject if package is not installed', async () => {
 test('DELETE /nodes should uninstall package', async () => {
 	const ownerShell = await testDb.createUserShell(globalOwnerRole);
 
-	const removeSpy = jest
-		.spyOn(LoadNodesAndCredentials(), 'removeNpmModule')
-		.mockImplementationOnce(jest.fn());
+	const removeSpy = mockLoadNodesAndCredentials.removeNpmModule.mockImplementationOnce(jest.fn());
 
 	mocked(findInstalledPackage).mockImplementationOnce(mockedEmptyPackage);
 
@@ -310,9 +314,8 @@ test('PATCH /nodes reject if package is not installed', async () => {
 test('PATCH /nodes should update a package', async () => {
 	const ownerShell = await testDb.createUserShell(globalOwnerRole);
 
-	const updateSpy = jest
-		.spyOn(LoadNodesAndCredentials(), 'updateNpmModule')
-		.mockImplementationOnce(mockedEmptyPackage);
+	const updateSpy =
+		mockLoadNodesAndCredentials.updateNpmModule.mockImplementationOnce(mockedEmptyPackage);
 
 	mocked(findInstalledPackage).mockImplementationOnce(mockedEmptyPackage);
 

packages/cli/test/integration/shared/utils.ts

@@ -1,3 +1,4 @@
+import { Container } from 'typedi';
 import { randomBytes } from 'crypto';
 import { existsSync } from 'fs';
 
@@ -25,14 +26,15 @@ import {
 import superagent from 'superagent';
 import request from 'supertest';
 import { URL } from 'url';
+import { mock } from 'jest-mock-extended';
+import { DeepPartial } from 'ts-essentials';
 import config from '@/config';
 import * as Db from '@/Db';
 import { WorkflowEntity } from '@db/entities/WorkflowEntity';
 import { CredentialTypes } from '@/CredentialTypes';
 import { ExternalHooks } from '@/ExternalHooks';
-import { InternalHooksManager } from '@/InternalHooksManager';
 import { NodeTypes } from '@/NodeTypes';
-import * as ActiveWorkflowRunner from '@/ActiveWorkflowRunner';
+import { ActiveWorkflowRunner } from '@/ActiveWorkflowRunner';
 import { nodesController } from '@/api/nodes.api';
 import { workflowsController } from '@/workflows/workflows.controller';
 import { AUTH_COOKIE_NAME, NODE_PACKAGE_PREFIX } from '@/constants';
@@ -74,16 +76,25 @@ import * as testDb from '../shared/testDb';
 import { v4 as uuid } from 'uuid';
 import { handleLdapInit } from '@/Ldap/helpers';
 import { ldapController } from '@/Ldap/routes/ldap.controller.ee';
+import { InternalHooks } from '@/InternalHooks';
+import { LoadNodesAndCredentials } from '@/LoadNodesAndCredentials';
 import { PostHogClient } from '@/posthog';
 
+export const mockInstance = <T>(
+	ctor: new (...args: any[]) => T,
+	data: DeepPartial<T> | undefined = undefined,
+) => {
+	const instance = mock<T>(data);
+	Container.set(ctor, instance);
+	return instance;
+};
+
 const loadNodesAndCredentials: INodesAndCredentials = {
 	loaded: { nodes: {}, credentials: {} },
 	known: { nodes: {}, credentials: {} },
 	credentialTypes: {} as ICredentialTypes,
 };
-
-const mockNodeTypes = NodeTypes(loadNodesAndCredentials);
-CredentialTypes(loadNodesAndCredentials);
+Container.set(LoadNodesAndCredentials, loadNodesAndCredentials);
 
 /**
  * Initialize a test server.
@@ -108,11 +119,9 @@ export async function initTestServer({
 	const logger = getLogger();
 	LoggerProxy.init(logger);
 
-	const postHog = new PostHogClient();
-	postHog.init('test-instance-id');
-
-	// Pre-requisite: Mock the telemetry module before calling.
-	await InternalHooksManager.init('test-instance-id', mockNodeTypes, postHog);
+	// Mock all telemetry.
+	mockInstance(InternalHooks);
+	mockInstance(PostHogClient);
 
 	testServer.app.use(bodyParser.json());
 	testServer.app.use(bodyParser.urlencoded({ extended: true }));
@@ -137,7 +146,7 @@ export async function initTestServer({
 		endpointGroups.includes('users') ||
 		endpointGroups.includes('passwordReset')
 	) {
-		testServer.externalHooks = ExternalHooks();
+		testServer.externalHooks = Container.get(ExternalHooks);
 	}
 
 	const [routerEndpoints, functionEndpoints] = classifyEndpointGroups(endpointGroups);
@@ -167,8 +176,8 @@ export async function initTestServer({
 	}
 
 	if (functionEndpoints.length) {
-		const externalHooks = ExternalHooks();
-		const internalHooks = InternalHooksManager.getInstance();
+		const externalHooks = Container.get(ExternalHooks);
+		const internalHooks = Container.get(InternalHooks);
 		const mailer = UserManagementMailer.getInstance();
 		const repositories = Db.collections;
 
@@ -218,7 +227,7 @@ export async function initTestServer({
 							externalHooks,
 							internalHooks,
 							repositories,
-							activeWorkflowRunner: ActiveWorkflowRunner.getInstance(),
+							activeWorkflowRunner: Container.get(ActiveWorkflowRunner),
 							logger,
 						}),
 					);
@@ -261,8 +270,8 @@ const classifyEndpointGroups = (endpointGroups: EndpointGroup[]) => {
 /**
  * Initialize node types.
  */
-export async function initActiveWorkflowRunner(): Promise<ActiveWorkflowRunner.ActiveWorkflowRunner> {
-	const workflowRunner = ActiveWorkflowRunner.getInstance();
+export async function initActiveWorkflowRunner(): Promise<ActiveWorkflowRunner> {
+	const workflowRunner = Container.get(ActiveWorkflowRunner);
 	workflowRunner.init();
 	return workflowRunner;
 }
@@ -303,7 +312,7 @@ export function gitHubCredentialType(): ICredentialType {
  * Initialize node types.
  */
 export async function initCredentialsTypes(): Promise<void> {
-	loadNodesAndCredentials.loaded.credentials = {
+	Container.get(LoadNodesAndCredentials).loaded.credentials = {
 		githubApi: {
 			type: gitHubCredentialType(),
 			sourcePath: '',
@@ -322,7 +331,7 @@ export async function initLdapManager(): Promise<void> {
  * Initialize node types.
  */
 export async function initNodeTypes() {
-	loadNodesAndCredentials.loaded.nodes = {
+	Container.get(LoadNodesAndCredentials).loaded.nodes = {
 		'n8n-nodes-base.start': {
 			sourcePath: '',
 			type: {