perf(core): Load node types on demand on runners (no-changelog) (#11559)

packages/@n8n/task-runner/src/task-runner.ts

@@ -1,4 +1,4 @@
-import { ApplicationError, type INodeTypeDescription } from 'n8n-workflow';
+import { ApplicationError } from 'n8n-workflow';
 import { nanoid } from 'nanoid';
 import { type MessageEvent, WebSocket } from 'ws';
 
@@ -25,6 +25,12 @@ interface DataRequest {
 	reject: (error: unknown) => void;
 }
 
+interface NodeTypesRequest {
+	requestId: string;
+	resolve: (data: unknown) => void;
+	reject: (error: unknown) => void;
+}
+
 interface RPCCall {
 	callId: string;
 	resolve: (data: unknown) => void;
@@ -58,6 +64,8 @@ export abstract class TaskRunner {
 
 	dataRequests: Map<DataRequest['requestId'], DataRequest> = new Map();
 
+	nodeTypesRequests: Map<NodeTypesRequest['requestId'], NodeTypesRequest> = new Map();
+
 	rpcCalls: Map<RPCCall['callId'], RPCCall> = new Map();
 
 	nodeTypes: TaskRunnerNodeTypes = new TaskRunnerNodeTypes([]);
@@ -168,15 +176,11 @@ export abstract class TaskRunner {
 				this.handleRpcResponse(message.callId, message.status, message.data);
 				break;
 			case 'broker:nodetypes':
-				this.setNodeTypes(message.nodeTypes as unknown as INodeTypeDescription[]);
+				this.processNodeTypesResponse(message.requestId, message.nodeTypes);
 				break;
 		}
 	}
 
-	setNodeTypes(nodeTypes: INodeTypeDescription[]) {
-		this.nodeTypes = new TaskRunnerNodeTypes(nodeTypes);
-	}
-
 	processDataResponse(requestId: string, data: unknown) {
 		const request = this.dataRequests.get(requestId);
 		if (!request) {
@@ -187,6 +191,16 @@ export abstract class TaskRunner {
 		request.resolve(data);
 	}
 
+	processNodeTypesResponse(requestId: string, nodeTypes: unknown) {
+		const request = this.nodeTypesRequests.get(requestId);
+
+		if (!request) return;
+
+		// Deleting of the request is handled in `requestNodeTypes`, using a
+		// `finally` wrapped around the return
+		request.resolve(nodeTypes);
+	}
+
 	hasOpenTasks() {
 		return Object.values(this.runningTasks).length < this.maxConcurrency;
 	}
@@ -282,6 +296,34 @@ export abstract class TaskRunner {
 		throw new ApplicationError('Unimplemented');
 	}
 
+	async requestNodeTypes<T = unknown>(
+		taskId: Task['taskId'],
+		requestParams: RunnerMessage.ToBroker.NodeTypesRequest['requestParams'],
+	) {
+		const requestId = nanoid();
+
+		const nodeTypesPromise = new Promise<T>((resolve, reject) => {
+			this.nodeTypesRequests.set(requestId, {
+				requestId,
+				resolve: resolve as (data: unknown) => void,
+				reject,
+			});
+		});
+
+		this.send({
+			type: 'runner:nodetypesrequest',
+			taskId,
+			requestId,
+			requestParams,
+		});
+
+		try {
+			return await nodeTypesPromise;
+		} finally {
+			this.nodeTypesRequests.delete(requestId);
+		}
+	}
+
 	async requestData<T = unknown>(
 		taskId: Task['taskId'],
 		requestParams: RunnerMessage.ToBroker.TaskDataRequest['requestParams'],