ci(core): Reduce memory usage in tests (part-1) (no-changelog) (#7654)

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

@@ -6,61 +6,27 @@ import request from 'supertest';
 import { URL } from 'url';
 
 import config from '@/config';
-import { ExternalHooks } from '@/ExternalHooks';
-import { ActiveWorkflowRunner } from '@/ActiveWorkflowRunner';
-import { workflowsController } from '@/workflows/workflows.controller';
 import { AUTH_COOKIE_NAME } from '@/constants';
-import { credentialsController } from '@/credentials/credentials.controller';
 import type { User } from '@db/entities/User';
-import { loadPublicApiVersions } from '@/PublicApi/';
 import { issueJWT } from '@/auth/jwt';
-import { UserManagementMailer } from '@/UserManagement/email/UserManagementMailer';
-import { licenseController } from '@/license/license.controller';
 import { registerController } from '@/decorators';
-import {
-	AuthController,
-	LdapController,
-	MFAController,
-	MeController,
-	OwnerController,
-	PasswordResetController,
-	TagsController,
-	UsersController,
-} from '@/controllers';
 import { rawBodyReader, bodyParser, setupAuthMiddlewares } from '@/middlewares';
-
 import { InternalHooks } from '@/InternalHooks';
 import { PostHogClient } from '@/posthog';
-import { variablesController } from '@/environments/variables/variables.controller';
-import { LdapManager } from '@/Ldap/LdapManager.ee';
-import { handleLdapInit } from '@/Ldap/helpers';
-import { setSamlLoginEnabled } from '@/sso/saml/samlHelpers';
-import { SamlController } from '@/sso/saml/routes/saml.controller.ee';
-import { EventBusController } from '@/eventbus/eventBus.controller';
-import { EventBusControllerEE } from '@/eventbus/eventBus.controller.ee';
 import { License } from '@/License';
-import { SourceControlController } from '@/environments/sourceControl/sourceControl.controller.ee';
 
-import * as testDb from '../../shared/testDb';
-import { AUTHLESS_ENDPOINTS, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from '../constants';
-import type { EndpointGroup, SetupProps, TestServer } from '../types';
-import { mockInstance } from './mocking';
-import { ExternalSecretsController } from '@/ExternalSecrets/ExternalSecrets.controller.ee';
-import { MfaService } from '@/Mfa/mfa.service';
-import { MetricsService } from '@/services/metrics.service';
 import {
 	SettingsRepository,
 	SharedCredentialsRepository,
 	SharedWorkflowRepository,
 } from '@/databases/repositories';
-import { JwtService } from '@/services/jwt.service';
-import { RoleService } from '@/services/role.service';
-import { UserService } from '@/services/user.service';
-import { executionsController } from '@/executions/executions.controller';
-import { WorkflowHistoryController } from '@/workflows/workflowHistory/workflowHistory.controller.ee';
-import { BinaryDataController } from '@/controllers/binaryData.controller';
 import { Logger } from '@/Logger';
 
+import * as testDb from '../../shared/testDb';
+import { AUTHLESS_ENDPOINTS, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from '../constants';
+import type { SetupProps, TestServer } from '../types';
+import { mockInstance } from './mocking';
+
 /**
  * Plugin to prefix a path segment into a request URL pathname.
  *
@@ -81,30 +47,6 @@ function prefix(pathSegment: string) {
 	};
 }
 
-/**
- * Classify endpoint groups into `routerEndpoints` (newest, using `express.Router`),
- * and `functionEndpoints` (legacy, namespaced inside a function).
- */
-const classifyEndpointGroups = (endpointGroups: EndpointGroup[]) => {
-	const routerEndpoints: EndpointGroup[] = [];
-	const functionEndpoints: EndpointGroup[] = [];
-
-	const ROUTER_GROUP = [
-		'credentials',
-		'workflows',
-		'publicApi',
-		'license',
-		'variables',
-		'executions',
-	];
-
-	endpointGroups.forEach((group) =>
-		(ROUTER_GROUP.includes(group) ? routerEndpoints : functionEndpoints).push(group),
-	);
-
-	return [routerEndpoints, functionEndpoints];
-};
-
 function createAgent(app: express.Application, options?: { auth: boolean; user: User }) {
 	const agent = request.agent(app);
 	void agent.use(prefix(REST_PATH_SEGMENT));
@@ -168,118 +110,177 @@ export const setupTestServer = ({
 
 		app.use(bodyParser);
 
-		const [routerEndpoints, functionEndpoints] = classifyEndpointGroups(endpointGroups);
-
-		if (routerEndpoints.length) {
-			const map: Record<string, express.Router | express.Router[] | any> = {
-				credentials: { controller: credentialsController, path: 'credentials' },
-				workflows: { controller: workflowsController, path: 'workflows' },
-				license: { controller: licenseController, path: 'license' },
-				variables: { controller: variablesController, path: 'variables' },
-				executions: { controller: executionsController, path: 'executions' },
-			};
-
-			if (enablePublicAPI) {
-				const { apiRouters } = await loadPublicApiVersions(PUBLIC_API_REST_PATH_SEGMENT);
-				map.publicApi = apiRouters;
-			}
-
-			for (const group of routerEndpoints) {
-				if (group === 'publicApi') {
-					app.use(...(map[group] as express.Router[]));
-				} else {
-					app.use(`/${REST_PATH_SEGMENT}/${map[group].path}`, map[group].controller);
-				}
-			}
+		if (enablePublicAPI) {
+			const { loadPublicApiVersions } = await import('@/PublicApi');
+			const { apiRouters } = await loadPublicApiVersions(PUBLIC_API_REST_PATH_SEGMENT);
+			app.use(...apiRouters);
 		}
 
-		if (functionEndpoints.length) {
-			const externalHooks = Container.get(ExternalHooks);
-			const internalHooks = Container.get(InternalHooks);
-			const mailer = Container.get(UserManagementMailer);
-			const mfaService = Container.get(MfaService);
-			const userService = Container.get(UserService);
-
-			for (const group of functionEndpoints) {
+		if (endpointGroups.length) {
+			for (const group of endpointGroups) {
 				switch (group) {
+					case 'credentials':
+						const { credentialsController } = await import('@/credentials/credentials.controller');
+						app.use(`/${REST_PATH_SEGMENT}/credentials`, credentialsController);
+						break;
+
+					case 'workflows':
+						const { workflowsController } = await import('@/workflows/workflows.controller');
+						app.use(`/${REST_PATH_SEGMENT}/workflows`, workflowsController);
+						break;
+
+					case 'executions':
+						const { executionsController } = await import('@/executions/executions.controller');
+						app.use(`/${REST_PATH_SEGMENT}/executions`, executionsController);
+						break;
+
+					case 'variables':
+						const { variablesController } = await import(
+							'@/environments/variables/variables.controller'
+						);
+						app.use(`/${REST_PATH_SEGMENT}/variables`, variablesController);
+						break;
+
+					case 'license':
+						const { licenseController } = await import('@/license/license.controller');
+						app.use(`/${REST_PATH_SEGMENT}/license`, licenseController);
+						break;
+
 					case 'metrics':
+						const { MetricsService } = await import('@/services/metrics.service');
 						await Container.get(MetricsService).configureMetrics(app);
 						break;
+
 					case 'eventBus':
+						const { EventBusController } = await import('@/eventbus/eventBus.controller');
+						const { EventBusControllerEE } = await import('@/eventbus/eventBus.controller.ee');
 						registerController(app, config, new EventBusController());
 						registerController(app, config, new EventBusControllerEE());
 						break;
+
 					case 'auth':
+						const { AuthController } = await import('@/controllers/auth.controller');
 						registerController(app, config, Container.get(AuthController));
 						break;
+
 					case 'mfa':
-						registerController(app, config, new MFAController(mfaService));
+						const { MFAController } = await import('@/controllers/mfa.controller');
+						registerController(app, config, Container.get(MFAController));
+						break;
+
 					case 'ldap':
+						const { LdapManager } = await import('@/Ldap/LdapManager.ee');
+						const { handleLdapInit } = await import('@/Ldap/helpers');
+						const { LdapController } = await import('@/controllers/ldap.controller');
 						Container.get(License).isLdapEnabled = () => true;
 						await handleLdapInit();
 						const { service, sync } = LdapManager.getInstance();
-						registerController(app, config, new LdapController(service, sync, internalHooks));
+						registerController(
+							app,
+							config,
+							new LdapController(service, sync, Container.get(InternalHooks)),
+						);
 						break;
+
 					case 'saml':
+						const { setSamlLoginEnabled } = await import('@/sso/saml/samlHelpers');
+						const { SamlController } = await import('@/sso/saml/routes/saml.controller.ee');
 						await setSamlLoginEnabled(true);
 						registerController(app, config, Container.get(SamlController));
 						break;
+
 					case 'sourceControl':
+						const { SourceControlController } = await import(
+							'@/environments/sourceControl/sourceControl.controller.ee'
+						);
 						registerController(app, config, Container.get(SourceControlController));
 						break;
+
 					case 'community-packages':
 						const { CommunityPackagesController } = await import(
 							'@/controllers/communityPackages.controller'
 						);
 						registerController(app, config, Container.get(CommunityPackagesController));
+						break;
+
 					case 'me':
+						const { MeController } = await import('@/controllers/me.controller');
 						registerController(app, config, Container.get(MeController));
 						break;
+
 					case 'passwordReset':
+						const { PasswordResetController } = await import(
+							'@/controllers/passwordReset.controller'
+						);
 						registerController(app, config, Container.get(PasswordResetController));
 						break;
+
 					case 'owner':
+						const { UserService } = await import('@/services/user.service');
+						const { OwnerController } = await import('@/controllers/owner.controller');
 						registerController(
 							app,
 							config,
 							new OwnerController(
 								config,
 								logger,
-								internalHooks,
+								Container.get(InternalHooks),
 								Container.get(SettingsRepository),
-								userService,
+								Container.get(UserService),
 							),
 						);
 						break;
+
 					case 'users':
+						const { ActiveWorkflowRunner } = await import('@/ActiveWorkflowRunner');
+						const { ExternalHooks } = await import('@/ExternalHooks');
+						const { JwtService } = await import('@/services/jwt.service');
+						const { RoleService } = await import('@/services/role.service');
+						const { UserService: US } = await import('@/services/user.service');
+						const { UserManagementMailer } = await import(
+							'@/UserManagement/email/UserManagementMailer'
+						);
+						const { UsersController } = await import('@/controllers/users.controller');
 						registerController(
 							app,
 							config,
 							new UsersController(
 								config,
 								logger,
-								externalHooks,
-								internalHooks,
+								Container.get(ExternalHooks),
+								Container.get(InternalHooks),
 								Container.get(SharedCredentialsRepository),
 								Container.get(SharedWorkflowRepository),
 								Container.get(ActiveWorkflowRunner),
-								mailer,
+								Container.get(UserManagementMailer),
 								Container.get(JwtService),
 								Container.get(RoleService),
-								userService,
+								Container.get(US),
 							),
 						);
 						break;
+
 					case 'tags':
+						const { TagsController } = await import('@/controllers/tags.controller');
 						registerController(app, config, Container.get(TagsController));
 						break;
+
 					case 'externalSecrets':
+						const { ExternalSecretsController } = await import(
+							'@/ExternalSecrets/ExternalSecrets.controller.ee'
+						);
 						registerController(app, config, Container.get(ExternalSecretsController));
 						break;
+
 					case 'workflowHistory':
+						const { WorkflowHistoryController } = await import(
+							'@/workflows/workflowHistory/workflowHistory.controller.ee'
+						);
 						registerController(app, config, Container.get(WorkflowHistoryController));
 						break;
+
 					case 'binaryData':
+						const { BinaryDataController } = await import('@/controllers/binaryData.controller');
 						registerController(app, config, Container.get(BinaryDataController));
 						break;
 				}