feat(core): Switch to structured destination node (no-changelog)

packages/@n8n/db/src/repositories/execution.repository.ts

@@ -29,10 +29,12 @@ import type {
 	ExecutionStatus,
 	ExecutionSummary,
 	IRunExecutionData,
+	IRunExecutionDataAll,
 } from 'n8n-workflow';
 import {
 	createEmptyRunExecutionData,
 	ManualExecutionCancelledError,
+	migrateRunExecutionData,
 	UnexpectedError,
 } from 'n8n-workflow';
 
@@ -196,9 +198,7 @@ export class ExecutionRepository extends Repository<ExecutionEntity> {
 		},
 	): Promise<IExecutionFlattedDb[] | IExecutionResponse[] | IExecutionBase[]> {
 		if (options?.includeData) {
-			if (!queryParams.relations) {
-				queryParams.relations = [];
-			}
+			queryParams.relations ??= [];
 
 			if (Array.isArray(queryParams.relations)) {
 				queryParams.relations.push('executionData', 'metadata');
@@ -210,35 +210,26 @@ export class ExecutionRepository extends Repository<ExecutionEntity> {
 
 		const executions = await this.find(queryParams);
 
-		if (options?.includeData && options?.unflattenData) {
-			const [valid, invalid] = separate(executions, (e) => e.executionData !== null);
-			this.reportInvalidExecutions(invalid);
-			return valid.map((execution) => {
-				const { executionData, metadata, ...rest } = execution;
-				return {
-					...rest,
-					data: parse(executionData.data) as IRunExecutionData,
-					workflowData: executionData.workflowData,
-					customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
-				} as IExecutionResponse;
-			});
-		} else if (options?.includeData) {
-			const [valid, invalid] = separate(executions, (e) => e.executionData !== null);
-			this.reportInvalidExecutions(invalid);
-			return valid.map((execution) => {
-				const { executionData, metadata, ...rest } = execution;
-				return {
-					...rest,
-					data: execution.executionData.data,
-					workflowData: execution.executionData.workflowData,
-					customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
-				} as IExecutionFlattedDb;
-			});
+		const [valid, invalid] = separate(executions, (e) => e.executionData !== null);
+		this.reportInvalidExecutions(invalid);
+
+		if (!options?.includeData) {
+			// No data to include, so we exclude it and return early.
+			return executions.map((execution) => {
+				const { executionData, ...rest } = execution;
+				return rest;
+			}) as IExecutionFlattedDb[] | IExecutionResponse[] | IExecutionBase[];
 		}
 
-		return executions.map((execution) => {
-			const { executionData, ...rest } = execution;
-			return rest;
+		return valid.map((execution) => {
+			const { executionData, metadata, ...rest } = execution;
+			const data = this.handleExecutionRunData(executionData.data, options);
+			return {
+				...rest,
+				data,
+				workflowData: executionData.workflowData,
+				customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
+			};
 		}) as IExecutionFlattedDb[] | IExecutionResponse[] | IExecutionBase[];
 	}
 
@@ -339,15 +330,23 @@ export class ExecutionRepository extends Repository<ExecutionEntity> {
 			});
 		}
 
+		if (!options?.includeData) {
+			// Not including run data, so return early.
+			const { executionData, ...rest } = execution;
+			return {
+				...rest,
+				...(options?.includeAnnotation &&
+					serializedAnnotation && { annotation: serializedAnnotation }),
+			} as IExecutionFlattedDb | IExecutionResponse | IExecutionBase;
+		}
+
+		// Include the run data.
+		const data = this.handleExecutionRunData(executionData.data, options);
 		return {
 			...rest,
-			...(options?.includeData && {
-				data: options?.unflattenData
-					? (parse(executionData.data) as IRunExecutionData)
-					: executionData.data,
-				workflowData: executionData?.workflowData,
-				customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
-			}),
+			data,
+			workflowData: executionData.workflowData,
+			customData: Object.fromEntries(metadata.map((m) => [m.key, m.value])),
 			...(options?.includeAnnotation &&
 				serializedAnnotation && { annotation: serializedAnnotation }),
 		} as IExecutionFlattedDb | IExecutionResponse | IExecutionBase;
@@ -804,7 +803,8 @@ export class ExecutionRepository extends Repository<ExecutionEntity> {
 	async stopDuringRun(execution: IExecutionResponse) {
 		const error = new ManualExecutionCancelledError(execution.id);
 
-		execution.data ??= createEmptyRunExecutionData();
+		execution.data = execution.data || createEmptyRunExecutionData();
+
 		execution.data.resultData.error = {
 			...error,
 			message: error.message,
@@ -1164,4 +1164,21 @@ export class ExecutionRepository extends Repository<ExecutionEntity> {
 
 		return concurrentExecutionsCount;
 	}
+
+	private handleExecutionRunData(
+		data: string,
+		options: { unflattenData?: boolean } = {},
+	): IRunExecutionData | string | undefined {
+		if (options.unflattenData) {
+			// Parse the serialized data.
+			const deserializedData: unknown = parse(data);
+			// If it parses to an object, migrate and return it.
+			if (deserializedData) {
+				return migrateRunExecutionData(deserializedData as IRunExecutionDataAll);
+			}
+			return undefined;
+		}
+		// Just return the string data as-is.
+		return data;
+	}
 }

packages/@n8n/task-runner/src/js-task-runner/__tests__/js-task-runner.test.ts

@@ -477,7 +477,7 @@ describe('JsTaskRunner', () => {
 				});
 
 				const helsinkiTimeNow = DateTime.now().setZone('Europe/Helsinki').toSeconds();
-				expect(outcome.result).toEqual({ val: expect.closeTo(helsinkiTimeNow, 1) });
+				expect(outcome.result).toEqual({ val: expect.closeTo(helsinkiTimeNow, 0) });
 			});
 		});
 

packages/cli/src/__tests__/manual-execution.service.test.ts

@@ -13,6 +13,7 @@ import type {
 	IWaitingForExecution,
 	IWaitingForExecutionSource,
 	INodeExecutionData,
+	IDestinationNode,
 } from 'n8n-workflow';
 import type PCancelable from 'p-cancelable';
 
@@ -190,6 +191,10 @@ describe('ManualExecutionService', () => {
 			const startNodeName = 'startNode';
 			const triggerNodeName = 'triggerNode';
 			const destinationNodeName = 'destinationNode';
+			const destinationNode: IDestinationNode = {
+				nodeName: destinationNodeName,
+				mode: 'inclusive',
+			};
 
 			const data = mock<IWorkflowExecutionDataProcess>({
 				triggerToStartFrom: {
@@ -198,7 +203,7 @@ describe('ManualExecutionService', () => {
 				},
 				startNodes: [{ name: startNodeName }],
 				executionMode: 'manual',
-				destinationNode: destinationNodeName,
+				destinationNode,
 			});
 
 			const startNode = mock<INode>({ name: startNodeName });
@@ -225,9 +230,7 @@ describe('ManualExecutionService', () => {
 				additionalData,
 				data.executionMode,
 				expect.objectContaining({
-					startData: {
-						destinationNode: destinationNodeName,
-					},
+					startData: { destinationNode },
 					resultData: expect.any(Object),
 					executionData: expect.any(Object),
 				}),
@@ -379,12 +382,16 @@ describe('ManualExecutionService', () => {
 			const mockRunData = { node1: [{ data: { main: [[{ json: {} }]] } }] };
 			const dirtyNodeNames = ['node2', 'node3'];
 			const destinationNodeName = 'destinationNode';
+			const destinationNode: IDestinationNode = {
+				nodeName: destinationNodeName,
+				mode: 'inclusive',
+			};
 			const data = mock<IWorkflowExecutionDataProcess>({
 				executionMode: 'manual',
 				runData: mockRunData,
 				startNodes: [{ name: 'node1' }],
 				dirtyNodeNames,
-				destinationNode: destinationNodeName,
+				destinationNode,
 			});
 
 			const workflow = mock<Workflow>({
@@ -411,7 +418,7 @@ describe('ManualExecutionService', () => {
 
 			expect(mockRunPartialWorkflow2).toHaveBeenCalled();
 			expect(mockRunPartialWorkflow2.mock.calls[0][0]).toBe(workflow);
-			expect(mockRunPartialWorkflow2.mock.calls[0][4]).toBe(destinationNodeName);
+			expect(mockRunPartialWorkflow2.mock.calls[0][4]).toEqual(destinationNode);
 		});
 
 		it('should validate nodes exist before execution', async () => {
@@ -489,11 +496,15 @@ describe('ManualExecutionService', () => {
 		it('should call runPartialWorkflow2 with runData and empty startNodes', async () => {
 			const mockRunData = { nodeA: [{ data: { main: [[{ json: { value: 'test' } }]] } }] };
 			const destinationNodeName = 'nodeB';
+			const destinationNode: IDestinationNode = {
+				nodeName: destinationNodeName,
+				mode: 'inclusive',
+			};
 			const data = mock<IWorkflowExecutionDataProcess>({
 				executionMode: 'manual',
 				runData: mockRunData,
 				startNodes: [],
-				destinationNode: destinationNodeName,
+				destinationNode,
 				pinData: {},
 				dirtyNodeNames: [],
 				agentRequest: undefined,
@@ -526,7 +537,7 @@ describe('ManualExecutionService', () => {
 				mockRunData,
 				data.pinData,
 				data.dirtyNodeNames,
-				destinationNodeName,
+				destinationNode,
 				data.agentRequest,
 			);
 		});

packages/cli/src/evaluation.ee/test-runner/__tests__/test-runner.service.ee.test.ts

@@ -458,7 +458,10 @@ describe('TestRunnerService', () => {
 			const runCallArg = workflowRunner.run.mock.calls[0][0];
 
 			// Verify it has the correct structure
-			expect(runCallArg).toHaveProperty('destinationNode', triggerNodeName);
+			expect(runCallArg).toHaveProperty('destinationNode', {
+				nodeName: triggerNodeName,
+				mode: 'inclusive',
+			});
 			expect(runCallArg).toHaveProperty('executionMode', 'manual');
 			expect(runCallArg).toHaveProperty('workflowData.settings.saveManualExecutions', false);
 			expect(runCallArg).toHaveProperty('workflowData.settings.saveDataErrorExecution', 'none');
@@ -531,7 +534,10 @@ describe('TestRunnerService', () => {
 			const runCallArg = workflowRunner.run.mock.calls[0][0];
 
 			// Verify it has the correct structure
-			expect(runCallArg).toHaveProperty('destinationNode', triggerNodeName);
+			expect(runCallArg).toHaveProperty('destinationNode', {
+				nodeName: triggerNodeName,
+				mode: 'inclusive',
+			});
 			expect(runCallArg).toHaveProperty('executionMode', 'manual');
 			expect(runCallArg).toHaveProperty('workflowData.settings.saveManualExecutions', false);
 			expect(runCallArg).toHaveProperty('workflowData.settings.saveDataErrorExecution', 'none');
@@ -546,7 +552,10 @@ describe('TestRunnerService', () => {
 			// But executionData itself should still exist with startData and manualData
 			expect(runCallArg).toHaveProperty('executionData');
 			expect(runCallArg.executionData).toBeDefined();
-			expect(runCallArg).toHaveProperty('executionData.startData.destinationNode', triggerNodeName);
+			expect(runCallArg).toHaveProperty('executionData.startData.destinationNode', {
+				nodeName: triggerNodeName,
+				mode: 'inclusive',
+			});
 			expect(runCallArg).toHaveProperty('executionData.manualData.userId', metadata.userId);
 			expect(runCallArg).toHaveProperty(
 				'executionData.manualData.triggerToStartFrom.name',

packages/cli/src/evaluation.ee/test-runner/test-runner.service.ee.ts

@@ -318,7 +318,7 @@ export class TestRunnerService {
 		};
 
 		const data: IWorkflowExecutionDataProcess = {
-			destinationNode: triggerNode.name,
+			destinationNode: { nodeName: triggerNode.name, mode: 'inclusive' },
 			executionMode: 'manual',
 			runData: {},
 			workflowData: {
@@ -334,7 +334,7 @@ export class TestRunnerService {
 			userId: metadata.userId,
 			executionData: createRunExecutionData({
 				startData: {
-					destinationNode: triggerNode.name,
+					destinationNode: { nodeName: triggerNode.name, mode: 'inclusive' },
 				},
 				manualData: {
 					userId: metadata.userId,