From d8433d289543c40854e59b0384be356a3d7b947d Mon Sep 17 00:00:00 2001
From: Guillaume Jacquart <jacquart.guillaume@gmail.com>
Date: Mon, 24 Mar 2025 09:59:32 +0100
Subject: [PATCH 01/33] feat(API): Implement compaction logic for insights
 (#14062)

Co-authored-by: Danny Martini <danny@n8n.io>
---
 .../__tests__/insights.service.test.ts        | 361 +++++++++++++++++-
 .../insights/entities/__tests__/db-utils.ts   |  50 +++
 .../src/modules/insights/insights.config.ts   |  18 +
 .../src/modules/insights/insights.service.ts  |  77 +++-
 .../insights-by-period.repository.ts          | 155 +++++++-
 .../repositories/insights-raw.repository.ts   |  14 +
 6 files changed, 669 insertions(+), 6 deletions(-)
 create mode 100644 packages/cli/src/modules/insights/insights.config.ts

diff --git a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
index 9b84cbea6ad..f6010511d6c 100644
--- a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
+++ b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
@@ -14,6 +14,12 @@ import { createTeamProject } from '@test-integration/db/projects';
 import { createWorkflow } from '@test-integration/db/workflows';
 import * as testDb from '@test-integration/test-db';
 
+import {
+	createMetadata,
+	createRawInsightsEvent,
+	createCompactedInsightsEvent,
+	createRawInsightsEvents,
+} from '../entities/__tests__/db-utils';
 import { InsightsService } from '../insights.service';
 import { InsightsByPeriodRepository } from '../repositories/insights-by-period.repository';
 
@@ -30,13 +36,22 @@ async function truncateAll() {
 	}
 }
 
+// Initialize DB once for all tests
+beforeAll(async () => {
+	jest.useFakeTimers();
+	await testDb.init();
+});
+
+// Terminate DB once after all tests complete
+afterAll(async () => {
+	await testDb.terminate();
+});
+
 describe('workflowExecuteAfterHandler', () => {
 	let insightsService: InsightsService;
 	let insightsRawRepository: InsightsRawRepository;
 	let insightsMetadataRepository: InsightsMetadataRepository;
 	beforeAll(async () => {
-		await testDb.init();
-
 		insightsService = Container.get(InsightsService);
 		insightsRawRepository = Container.get(InsightsRawRepository);
 		insightsMetadataRepository = Container.get(InsightsMetadataRepository);
@@ -245,3 +260,345 @@ describe('workflowExecuteAfterHandler', () => {
 		);
 	});
 });
+
+describe('compaction', () => {
+	beforeEach(async () => {
+		await truncateAll();
+	});
+
+	describe('compactRawToHour', () => {
+		type TestData = {
+			name: string;
+			timestamps: DateTime[];
+			batches: number[];
+		};
+
+		test.each<TestData>([
+			{
+				name: 'compact into 2 rows',
+				timestamps: [
+					DateTime.utc(2000, 1, 1, 0, 0),
+					DateTime.utc(2000, 1, 1, 0, 59),
+					DateTime.utc(2000, 1, 1, 1, 0),
+				],
+				batches: [2, 1],
+			},
+			{
+				name: 'compact into 3 rows',
+				timestamps: [
+					DateTime.utc(2000, 1, 1, 0, 0),
+					DateTime.utc(2000, 1, 1, 1, 0),
+					DateTime.utc(2000, 1, 1, 2, 0),
+				],
+				batches: [1, 1, 1],
+			},
+		])('$name', async ({ timestamps, batches }) => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+			// create before so we can create the raw events in parallel
+			await createMetadata(workflow);
+			for (const timestamp of timestamps) {
+				await createRawInsightsEvent(workflow, { type: 'success', value: 1, timestamp });
+			}
+
+			// ACT
+			const compactedRows = await insightsService.compactRawToHour();
+
+			// ASSERT
+			expect(compactedRows).toBe(timestamps.length);
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+			const allCompacted = await insightsByPeriodRepository.find({ order: { periodStart: 1 } });
+			expect(allCompacted).toHaveLength(batches.length);
+			for (const [index, compacted] of allCompacted.entries()) {
+				expect(compacted.value).toBe(batches[index]);
+			}
+		});
+
+		test('batch compaction split events in hourly insight periods', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+
+			const batchSize = 100;
+
+			let timestamp = DateTime.utc().startOf('hour');
+			for (let i = 0; i < batchSize; i++) {
+				await createRawInsightsEvent(workflow, { type: 'success', value: 1, timestamp });
+				// create 60 events per hour
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			// ACT
+			await insightsService.compactInsights();
+
+			// ASSERT
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+
+			const allCompacted = await insightsByPeriodRepository.find({ order: { periodStart: 1 } });
+			const accumulatedValues = allCompacted.reduce((acc, event) => acc + event.value, 0);
+			expect(accumulatedValues).toBe(batchSize);
+			expect(allCompacted[0].value).toBe(60);
+			expect(allCompacted[1].value).toBe(40);
+		});
+
+		test('batch compaction split events in hourly insight periods by type and workflow', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			const project = await createTeamProject();
+			const workflow1 = await createWorkflow({}, project);
+			const workflow2 = await createWorkflow({}, project);
+
+			const batchSize = 100;
+
+			let timestamp = DateTime.utc().startOf('hour');
+			for (let i = 0; i < batchSize / 4; i++) {
+				await createRawInsightsEvent(workflow1, { type: 'success', value: 1, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			for (let i = 0; i < batchSize / 4; i++) {
+				await createRawInsightsEvent(workflow1, { type: 'failure', value: 1, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			for (let i = 0; i < batchSize / 4; i++) {
+				await createRawInsightsEvent(workflow2, { type: 'runtime_ms', value: 1200, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			for (let i = 0; i < batchSize / 4; i++) {
+				await createRawInsightsEvent(workflow2, { type: 'time_saved_min', value: 3, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			// ACT
+			await insightsService.compactInsights();
+
+			// ASSERT
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+
+			const allCompacted = await insightsByPeriodRepository.find({
+				order: { metaId: 'ASC', periodStart: 'ASC' },
+			});
+
+			// Expect 2 insights for workflow 1 (for success and failure)
+			// and 3 for workflow 2 (2 period starts for runtime_ms and 1 for time_saved_min)
+			expect(allCompacted).toHaveLength(5);
+			const metaIds = allCompacted.map((event) => event.metaId);
+
+			// meta id are ordered. first 2 are for workflow 1, last 3 are for workflow 2
+			const uniqueMetaIds = [metaIds[0], metaIds[2]];
+			const workflow1Insights = allCompacted.filter((event) => event.metaId === uniqueMetaIds[0]);
+			const workflow2Insights = allCompacted.filter((event) => event.metaId === uniqueMetaIds[1]);
+
+			expect(workflow1Insights).toHaveLength(2);
+			expect(workflow2Insights).toHaveLength(3);
+
+			const successInsights = workflow1Insights.find((event) => event.type === 'success');
+			const failureInsights = workflow1Insights.find((event) => event.type === 'failure');
+
+			expect(successInsights).toBeTruthy();
+			expect(failureInsights).toBeTruthy();
+			// success and failure insights should have the value matching the number or raw events (because value = 1)
+			expect(successInsights!.value).toBe(25);
+			expect(failureInsights!.value).toBe(25);
+
+			const runtimeMsEvents = workflow2Insights.filter((event) => event.type === 'runtime_ms');
+			const timeSavedMinEvents = workflow2Insights.find((event) => event.type === 'time_saved_min');
+			expect(runtimeMsEvents).toHaveLength(2);
+
+			// The last 10 minutes of the first hour
+			expect(runtimeMsEvents[0].value).toBe(1200 * 10);
+
+			// The first 15 minutes of the second hour
+			expect(runtimeMsEvents[1].value).toBe(1200 * 15);
+			expect(timeSavedMinEvents).toBeTruthy();
+			expect(timeSavedMinEvents!.value).toBe(3 * 25);
+		});
+
+		test('should return the number of compacted events', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+
+			const batchSize = 100;
+
+			let timestamp = DateTime.utc(2000, 1, 1, 0, 0);
+			for (let i = 0; i < batchSize; i++) {
+				await createRawInsightsEvent(workflow, { type: 'success', value: 1, timestamp });
+				// create 60 events per hour
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+
+			// ACT
+			const numberOfCompactedData = await insightsService.compactRawToHour();
+
+			// ASSERT
+			expect(numberOfCompactedData).toBe(100);
+		});
+
+		test('works with data in the compacted table', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+
+			const batchSize = 100;
+
+			let timestamp = DateTime.utc().startOf('hour');
+
+			// Create an existing compacted event for the first hour
+			await createCompactedInsightsEvent(workflow, {
+				type: 'success',
+				value: 10,
+				periodUnit: 'hour',
+				periodStart: timestamp,
+			});
+
+			const events = Array<{ type: 'success'; value: number; timestamp: DateTime }>();
+			for (let i = 0; i < batchSize; i++) {
+				events.push({ type: 'success', value: 1, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+			await createRawInsightsEvents(workflow, events);
+
+			// ACT
+			await insightsService.compactInsights();
+
+			// ASSERT
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+
+			const allCompacted = await insightsByPeriodRepository.find({ order: { periodStart: 1 } });
+			const accumulatedValues = allCompacted.reduce((acc, event) => acc + event.value, 0);
+			expect(accumulatedValues).toBe(batchSize + 10);
+			expect(allCompacted[0].value).toBe(70);
+			expect(allCompacted[1].value).toBe(40);
+		});
+
+		test('works with data bigger than the batch size', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			// spy on the compactRawToHour method to check if it's called multiple times
+			const rawToHourSpy = jest.spyOn(insightsService, 'compactRawToHour');
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+
+			const batchSize = 600;
+
+			let timestamp = DateTime.utc().startOf('hour');
+			const events = Array<{ type: 'success'; value: number; timestamp: DateTime }>();
+			for (let i = 0; i < batchSize; i++) {
+				events.push({ type: 'success', value: 1, timestamp });
+				timestamp = timestamp.plus({ minute: 1 });
+			}
+			await createRawInsightsEvents(workflow, events);
+
+			// ACT
+			await insightsService.compactInsights();
+
+			// ASSERT
+			expect(rawToHourSpy).toHaveBeenCalledTimes(3);
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+			const allCompacted = await insightsByPeriodRepository.find({ order: { periodStart: 1 } });
+			const accumulatedValues = allCompacted.reduce((acc, event) => acc + event.value, 0);
+			expect(accumulatedValues).toBe(batchSize);
+		});
+
+		test('compaction is running on schedule', async () => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+
+			// spy on the compactInsights method to check if it's called
+			insightsService.compactInsights = jest.fn();
+
+			// ACT
+			// advance by 1 hour and 1 minute
+			jest.advanceTimersByTime(1000 * 60 * 60);
+
+			// ASSERT
+			expect(insightsService.compactInsights).toHaveBeenCalledTimes(1);
+		});
+	});
+
+	describe('compactHourToDay', () => {
+		type TestData = {
+			name: string;
+			periodStarts: DateTime[];
+			batches: number[];
+		};
+
+		test.each<TestData>([
+			{
+				name: 'compact into 2 rows',
+				periodStarts: [
+					DateTime.utc(2000, 1, 1, 0, 0),
+					DateTime.utc(2000, 1, 1, 23, 59),
+					DateTime.utc(2000, 1, 2, 1, 0),
+				],
+				batches: [2, 1],
+			},
+			{
+				name: 'compact into 3 rows',
+				periodStarts: [
+					DateTime.utc(2000, 1, 1, 0, 0),
+					DateTime.utc(2000, 1, 1, 23, 59),
+					DateTime.utc(2000, 1, 2, 0, 0),
+					DateTime.utc(2000, 1, 2, 23, 59),
+					DateTime.utc(2000, 1, 3, 23, 59),
+				],
+				batches: [2, 2, 1],
+			},
+		])('$name', async ({ periodStarts, batches }) => {
+			// ARRANGE
+			const insightsService = Container.get(InsightsService);
+			const insightsRawRepository = Container.get(InsightsRawRepository);
+			const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+
+			const project = await createTeamProject();
+			const workflow = await createWorkflow({}, project);
+			// create before so we can create the raw events in parallel
+			await createMetadata(workflow);
+			for (const periodStart of periodStarts) {
+				await createCompactedInsightsEvent(workflow, {
+					type: 'success',
+					value: 1,
+					periodUnit: 'hour',
+					periodStart,
+				});
+			}
+
+			// ACT
+			const compactedRows = await insightsService.compactHourToDay();
+
+			// ASSERT
+			expect(compactedRows).toBe(periodStarts.length);
+			await expect(insightsRawRepository.count()).resolves.toBe(0);
+			const allCompacted = await insightsByPeriodRepository.find({ order: { periodStart: 1 } });
+			expect(allCompacted).toHaveLength(batches.length);
+			for (const [index, compacted] of allCompacted.entries()) {
+				expect(compacted.value).toBe(batches[index]);
+			}
+		});
+	});
+});
diff --git a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts b/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
index 8781220b93a..38a06eb800b 100644
--- a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
+++ b/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
@@ -1,3 +1,4 @@
+import { GlobalConfig } from '@n8n/config';
 import { Container } from '@n8n/di';
 import type { DateTime } from 'luxon';
 import type { IWorkflowBase } from 'n8n-workflow';
@@ -7,8 +8,10 @@ import { SharedWorkflowRepository } from '@/databases/repositories/shared-workfl
 
 import { InsightsMetadata } from '../../entities/insights-metadata';
 import { InsightsRaw } from '../../entities/insights-raw';
+import { InsightsByPeriodRepository } from '../../repositories/insights-by-period.repository';
 import { InsightsMetadataRepository } from '../../repositories/insights-metadata.repository';
 import { InsightsRawRepository } from '../../repositories/insights-raw.repository';
+import { InsightsByPeriod } from '../insights-by-period';
 
 async function getWorkflowSharing(workflow: IWorkflowBase) {
 	return await Container.get(SharedWorkflowRepository).find({
@@ -16,6 +19,7 @@ async function getWorkflowSharing(workflow: IWorkflowBase) {
 		relations: { project: true },
 	});
 }
+export const { type: dbType } = Container.get(GlobalConfig).database;
 
 export async function createMetadata(workflow: WorkflowEntity) {
 	const insightsMetadataRepository = Container.get(InsightsMetadataRepository);
@@ -62,3 +66,49 @@ export async function createRawInsightsEvent(
 	}
 	return await insightsRawRepository.save(event);
 }
+
+export async function createRawInsightsEvents(
+	workflow: WorkflowEntity,
+	parametersArray: Array<{
+		type: InsightsRaw['type'];
+		value: number;
+		timestamp?: DateTime;
+	}>,
+) {
+	const insightsRawRepository = Container.get(InsightsRawRepository);
+	const metadata = await createMetadata(workflow);
+
+	const events = parametersArray.map((parameters) => {
+		const event = new InsightsRaw();
+		event.metaId = metadata.metaId;
+		event.type = parameters.type;
+		event.value = parameters.value;
+		if (parameters.timestamp) {
+			event.timestamp = parameters.timestamp.toUTC().toJSDate();
+		}
+		return event;
+	});
+	await insightsRawRepository.save(events);
+}
+
+export async function createCompactedInsightsEvent(
+	workflow: WorkflowEntity,
+	parameters: {
+		type: InsightsByPeriod['type'];
+		value: number;
+		periodUnit: InsightsByPeriod['periodUnit'];
+		periodStart: DateTime;
+	},
+) {
+	const insightsByPeriodRepository = Container.get(InsightsByPeriodRepository);
+	const metadata = await createMetadata(workflow);
+
+	const event = new InsightsByPeriod();
+	event.metaId = metadata.metaId;
+	event.type = parameters.type;
+	event.value = parameters.value;
+	event.periodUnit = parameters.periodUnit;
+	event.periodStart = parameters.periodStart.toUTC().startOf(parameters.periodUnit).toJSDate();
+
+	return await insightsByPeriodRepository.save(event);
+}
diff --git a/packages/cli/src/modules/insights/insights.config.ts b/packages/cli/src/modules/insights/insights.config.ts
new file mode 100644
index 00000000000..f273f0e11c9
--- /dev/null
+++ b/packages/cli/src/modules/insights/insights.config.ts
@@ -0,0 +1,18 @@
+import { Config, Env } from '@n8n/config/src/decorators';
+
+@Config
+export class InsightsConfig {
+	/**
+	 * The interval in minutes at which the insights data should be compacted.
+	 * Default: 60
+	 */
+	@Env('N8N_INSIGHTS_COMPACTION_INTERVAL_MINUTES')
+	compactionIntervalMinutes: number = 60;
+
+	/**
+	 * The number of raw insights data to compact in a single batch.
+	 * Default: 500
+	 */
+	@Env('N8N_INSIGHTS_COMPACTION_BATCH_SIZE')
+	compactionBatchSize: number = 500;
+}
diff --git a/packages/cli/src/modules/insights/insights.service.ts b/packages/cli/src/modules/insights/insights.service.ts
index 3ccd92b9860..a2d86e262b7 100644
--- a/packages/cli/src/modules/insights/insights.service.ts
+++ b/packages/cli/src/modules/insights/insights.service.ts
@@ -1,13 +1,20 @@
-import { Service } from '@n8n/di';
+import { Container, Service } from '@n8n/di';
 import type { ExecutionLifecycleHooks } from 'n8n-core';
-import { UnexpectedError } from 'n8n-workflow';
 import type { ExecutionStatus, IRun, WorkflowExecuteMode } from 'n8n-workflow';
+import { UnexpectedError } from 'n8n-workflow';
 
 import { SharedWorkflow } from '@/databases/entities/shared-workflow';
 import { SharedWorkflowRepository } from '@/databases/repositories/shared-workflow.repository';
+import { OnShutdown } from '@/decorators/on-shutdown';
 import { InsightsMetadata } from '@/modules/insights/entities/insights-metadata';
 import { InsightsRaw } from '@/modules/insights/entities/insights-raw';
 
+import { InsightsConfig } from './insights.config';
+import { InsightsByPeriodRepository } from './repositories/insights-by-period.repository';
+import { InsightsRawRepository } from './repositories/insights-raw.repository';
+
+const config = Container.get(InsightsConfig);
+
 const shouldSkipStatus: Record<ExecutionStatus, boolean> = {
 	success: false,
 	crashed: false,
@@ -35,7 +42,27 @@ const shouldSkipMode: Record<WorkflowExecuteMode, boolean> = {
 
 @Service()
 export class InsightsService {
-	constructor(private readonly sharedWorkflowRepository: SharedWorkflowRepository) {}
+	private compactInsightsTimer: NodeJS.Timer | undefined;
+
+	constructor(
+		private readonly sharedWorkflowRepository: SharedWorkflowRepository,
+		private readonly insightsByPeriodRepository: InsightsByPeriodRepository,
+		private readonly insightsRawRepository: InsightsRawRepository,
+	) {
+		const intervalMilliseconds = config.compactionIntervalMinutes * 60 * 1000;
+		this.compactInsightsTimer = setInterval(
+			async () => await this.compactInsights(),
+			intervalMilliseconds,
+		);
+	}
+
+	@OnShutdown()
+	shutdown() {
+		if (this.compactInsightsTimer !== undefined) {
+			clearInterval(this.compactInsightsTimer);
+			this.compactInsightsTimer = undefined;
+		}
+	}
 
 	async workflowExecuteAfterHandler(ctx: ExecutionLifecycleHooks, fullRunData: IRun) {
 		if (shouldSkipStatus[fullRunData.status] || shouldSkipMode[fullRunData.mode]) {
@@ -107,4 +134,48 @@ export class InsightsService {
 			}
 		});
 	}
+
+	async compactInsights() {
+		let numberOfCompactedRawData: number;
+
+		// Compact raw data to hourly aggregates
+		do {
+			numberOfCompactedRawData = await this.compactRawToHour();
+		} while (numberOfCompactedRawData > 0);
+
+		let numberOfCompactedHourData: number;
+
+		// Compact hourly data to daily aggregates
+		do {
+			numberOfCompactedHourData = await this.compactHourToDay();
+		} while (numberOfCompactedHourData > 0);
+	}
+
+	// Compacts raw data to hourly aggregates
+	async compactRawToHour() {
+		// Build the query to gather raw insights data for the batch
+		const batchQuery = this.insightsRawRepository.getRawInsightsBatchQuery(
+			config.compactionBatchSize,
+		);
+
+		return await this.insightsByPeriodRepository.compactSourceDataIntoInsightPeriod({
+			sourceBatchQuery: batchQuery.getSql(),
+			sourceTableName: this.insightsRawRepository.metadata.tableName,
+			periodUnit: 'hour',
+		});
+	}
+
+	// Compacts hourly data to daily aggregates
+	async compactHourToDay() {
+		// get hour data query for batching
+		const batchQuery = this.insightsByPeriodRepository.getPeriodInsightsBatchQuery(
+			'hour',
+			config.compactionBatchSize,
+		);
+
+		return await this.insightsByPeriodRepository.compactSourceDataIntoInsightPeriod({
+			sourceBatchQuery: batchQuery.getSql(),
+			periodUnit: 'day',
+		});
+	}
 }
diff --git a/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts b/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
index 94bc0572711..e8a911f0564 100644
--- a/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
+++ b/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
@@ -1,11 +1,164 @@
-import { Service } from '@n8n/di';
+import { GlobalConfig } from '@n8n/config';
+import { Container, Service } from '@n8n/di';
 import { DataSource, Repository } from '@n8n/typeorm';
 
+import { sql } from '@/utils/sql';
+
 import { InsightsByPeriod } from '../entities/insights-by-period';
+import type { PeriodUnits } from '../entities/insights-shared';
+import { PeriodUnitToNumber } from '../entities/insights-shared';
+
+const dbType = Container.get(GlobalConfig).database.type;
 
 @Service()
 export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 	constructor(dataSource: DataSource) {
 		super(InsightsByPeriod, dataSource.manager);
 	}
+
+	private escapeField(fieldName: string) {
+		return this.manager.connection.driver.escape(fieldName);
+	}
+
+	private getPeriodFilterExpr(periodUnit: PeriodUnits) {
+		const daysAgo = periodUnit === 'day' ? 90 : 180;
+		// Database-specific period start expression to filter out data to compact by days matching the periodUnit
+		let periodStartExpr = `date('now', '-${daysAgo} days')`;
+		if (dbType === 'postgresdb') {
+			periodStartExpr = `CURRENT_DATE - INTERVAL '${daysAgo} day'`;
+		} else if (dbType === 'mysqldb' || dbType === 'mariadb') {
+			periodStartExpr = `DATE_SUB(CURRENT_DATE, INTERVAL ${daysAgo} DAY)`;
+		}
+
+		return periodStartExpr;
+	}
+
+	private getPeriodStartExpr(periodUnit: PeriodUnits) {
+		// Database-specific period start expression to truncate timestamp to the periodUnit
+		// SQLite by default
+		let periodStartExpr = `strftime('%Y-%m-%d ${periodUnit === 'hour' ? '%H' : '00'}:00:00.000', periodStart)`;
+		if (dbType === 'mysqldb' || dbType === 'mariadb') {
+			periodStartExpr =
+				periodUnit === 'hour'
+					? "DATE_FORMAT(periodStart, '%Y-%m-%d %H:00:00')"
+					: "DATE_FORMAT(periodStart, '%Y-%m-%d 00:00:00')";
+		} else if (dbType === 'postgresdb') {
+			periodStartExpr = `DATE_TRUNC('${periodUnit}', ${this.escapeField('periodStart')})`;
+		}
+
+		return periodStartExpr;
+	}
+
+	getPeriodInsightsBatchQuery(periodUnit: PeriodUnits, compactionBatchSize: number) {
+		// Build the query to gather period insights data for the batch
+		const batchQuery = this.createQueryBuilder()
+			.select(
+				['id', 'metaId', 'type', 'periodStart', 'value'].map((fieldName) =>
+					this.escapeField(fieldName),
+				),
+			)
+			.where(`${this.escapeField('periodUnit')} = ${PeriodUnitToNumber[periodUnit]}`)
+			.andWhere(`${this.escapeField('periodStart')} < ${this.getPeriodFilterExpr('day')}`)
+			.orderBy(this.escapeField('periodStart'), 'ASC')
+			.limit(compactionBatchSize);
+		return batchQuery;
+	}
+
+	getAggregationQuery(periodUnit: PeriodUnits) {
+		// Get the start period expression depending on the period unit and database type
+		const periodStartExpr = this.getPeriodStartExpr(periodUnit);
+
+		// Function to get the aggregation query
+		const aggregationQuery = this.manager
+			.createQueryBuilder()
+			.select(this.escapeField('metaId'))
+			.addSelect(this.escapeField('type'))
+			.addSelect(PeriodUnitToNumber[periodUnit].toString(), 'periodUnit')
+			.addSelect(periodStartExpr, 'periodStart')
+			.addSelect(`SUM(${this.escapeField('value')})`, 'value')
+			.from('rows_to_compact', 'rtc')
+			.groupBy(this.escapeField('metaId'))
+			.addGroupBy(this.escapeField('type'))
+			.addGroupBy(periodStartExpr);
+
+		return aggregationQuery;
+	}
+
+	async compactSourceDataIntoInsightPeriod({
+		sourceBatchQuery, // Query to get batch source data. Must return those fields: 'id', 'metaId', 'type', 'periodStart', 'value'
+		sourceTableName = this.metadata.tableName, // Repository references for table operations
+		periodUnit,
+	}: {
+		sourceBatchQuery: string;
+		sourceTableName?: string;
+		periodUnit: PeriodUnits;
+	}): Promise<number> {
+		// Create temp table that only exists in this transaction for rows to compact
+		const getBatchAndStoreInTemporaryTable = sql`
+			CREATE TEMPORARY TABLE rows_to_compact AS
+			${sourceBatchQuery};
+		`;
+
+		const countBatch = sql`
+			SELECT COUNT(*) ${this.escapeField('rowsInBatch')} FROM rows_to_compact;
+		`;
+
+		const targetColumnNamesStr = ['metaId', 'type', 'periodUnit', 'periodStart']
+			.map((param) => this.escapeField(param))
+			.join(', ');
+		const targetColumnNamesWithValue = `${targetColumnNamesStr}, value`;
+
+		// Function to get the aggregation query
+		const aggregationQuery = this.getAggregationQuery(periodUnit);
+
+		// Insert or update aggregated data
+		const insertQueryBase = sql`
+			INSERT INTO ${this.metadata.tableName}
+				(${targetColumnNamesWithValue})
+			${aggregationQuery.getSql()}
+		`;
+
+		// Database-specific duplicate key logic
+		let deduplicateQuery: string;
+		if (dbType === 'mysqldb' || dbType === 'mariadb') {
+			deduplicateQuery = sql`
+				ON DUPLICATE KEY UPDATE value = value + VALUES(value)`;
+		} else {
+			deduplicateQuery = sql`
+				ON CONFLICT(${targetColumnNamesStr})
+				DO UPDATE SET value = ${this.metadata.tableName}.value + excluded.value
+				RETURNING *`;
+		}
+
+		const upsertEvents = sql`
+			${insertQueryBase}
+			${deduplicateQuery}
+		`;
+
+		// Delete the processed rows
+		const deleteBatch = sql`
+			DELETE FROM ${sourceTableName}
+			WHERE id IN (SELECT id FROM rows_to_compact);
+		`;
+
+		// Clean up
+		const dropTemporaryTable = sql`
+			DROP TABLE rows_to_compact;
+		`;
+
+		const result = await this.manager.transaction(async (trx) => {
+			await trx.query(getBatchAndStoreInTemporaryTable);
+
+			await trx.query<Array<{ type: any; value: number }>>(upsertEvents);
+
+			const rowsInBatch = await trx.query<[{ rowsInBatch: number | string }]>(countBatch);
+
+			await trx.query(deleteBatch);
+			await trx.query(dropTemporaryTable);
+
+			return Number(rowsInBatch[0].rowsInBatch);
+		});
+
+		return result;
+	}
 }
diff --git a/packages/cli/src/modules/insights/repositories/insights-raw.repository.ts b/packages/cli/src/modules/insights/repositories/insights-raw.repository.ts
index 9bad708eed8..05eba9ff167 100644
--- a/packages/cli/src/modules/insights/repositories/insights-raw.repository.ts
+++ b/packages/cli/src/modules/insights/repositories/insights-raw.repository.ts
@@ -8,4 +8,18 @@ export class InsightsRawRepository extends Repository<InsightsRaw> {
 	constructor(dataSource: DataSource) {
 		super(InsightsRaw, dataSource.manager);
 	}
+
+	getRawInsightsBatchQuery(compactionBatchSize: number) {
+		// Build the query to gather raw insights data for the batch
+		const batchQuery = this.createQueryBuilder()
+			.select(
+				['id', 'metaId', 'type', 'value'].map((fieldName) =>
+					this.manager.connection.driver.escape(fieldName),
+				),
+			)
+			.addSelect('timestamp', 'periodStart')
+			.orderBy('timestamp', 'ASC')
+			.limit(compactionBatchSize);
+		return batchQuery;
+	}
 }

From 7614dbecd73e8a9e30b62becb0cc725c37bb31a2 Mon Sep 17 00:00:00 2001
From: Dmitrii <117591218+DmitriyM01@users.noreply.github.com>
Date: Mon, 24 Mar 2025 13:29:36 +0300
Subject: [PATCH 02/33] fix(n8n Form Trigger Node): Fix docs link
 (no-changelog) (#14118)

---
 packages/nodes-base/nodes/Form/Form.node.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/nodes-base/nodes/Form/Form.node.ts b/packages/nodes-base/nodes/Form/Form.node.ts
index 94a86ca15ae..4a9e9f245e8 100644
--- a/packages/nodes-base/nodes/Form/Form.node.ts
+++ b/packages/nodes-base/nodes/Form/Form.node.ts
@@ -74,7 +74,7 @@ export const formFieldsProperties: INodeProperties[] = [
 			'[\n   {\n      "fieldLabel":"Name",\n      "placeholder":"enter you name",\n      "requiredField":true\n   },\n   {\n      "fieldLabel":"Age",\n      "fieldType":"number",\n      "placeholder":"enter your age"\n   },\n   {\n      "fieldLabel":"Email",\n      "fieldType":"email",\n      "requiredField":true\n   }\n]',
 		validateType: 'form-fields',
 		ignoreValidationDuringExecution: true,
-		hint: '<a href="hhttps://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.form/" target="_blank">See docs</a> for field syntax',
+		hint: '<a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.form/" target="_blank">See docs</a> for field syntax',
 		displayOptions: {
 			show: {
 				defineForm: ['json'],

From 59a0ee75dd582badc61aead8faf11082b7c73756 Mon Sep 17 00:00:00 2001
From: Charlie Kolb <charlie@n8n.io>
Date: Mon, 24 Mar 2025 11:32:43 +0100
Subject: [PATCH 03/33] fix(editor): Fix folder creation (no-changelog)
 (#14125)

---
 packages/frontend/editor-ui/src/views/WorkflowsView.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/frontend/editor-ui/src/views/WorkflowsView.vue b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
index c478ecd78cf..107eafb4131 100644
--- a/packages/frontend/editor-ui/src/views/WorkflowsView.vue
+++ b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
@@ -1218,7 +1218,7 @@ const onCreateWorkflowClick = () => {
 		@sort="onSortUpdated"
 	>
 		<template #header>
-			<ProjectHeader>
+			<ProjectHeader @create-folder="createFolderInCurrent">
 				<InsightsSummary
 					v-if="overview.isOverviewSubPage"
 					:loading="insightsStore.summary.isLoading"

From 20fb325c4cdf3e1d51b1c427c88540e88aebbe4d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milorad=20FIlipovi=C4=87?= <milorad@n8n.io>
Date: Mon, 24 Mar 2025 11:55:10 +0100
Subject: [PATCH 04/33] fix(editor): Update registered community CTA
 (no-changelog) (#14117)

Co-authored-by: Charlie Kolb <charlie@n8n.io>
---
 .../CommunityPlusEnrollmentModal.vue          | 19 +++++++++++--------
 packages/frontend/editor-ui/src/constants.ts  |  2 ++
 .../src/plugins/i18n/locales/en.json          |  1 +
 3 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/packages/frontend/editor-ui/src/components/CommunityPlusEnrollmentModal.vue b/packages/frontend/editor-ui/src/components/CommunityPlusEnrollmentModal.vue
index fddfe8e3fd5..a2f25fc18e3 100644
--- a/packages/frontend/editor-ui/src/components/CommunityPlusEnrollmentModal.vue
+++ b/packages/frontend/editor-ui/src/components/CommunityPlusEnrollmentModal.vue
@@ -3,7 +3,7 @@ import { ref } from 'vue';
 import { createEventBus } from '@n8n/utils/event-bus';
 import type { Validatable, IValidator } from '@n8n/design-system';
 import { N8nFormInput } from '@n8n/design-system';
-import { VALID_EMAIL_REGEX } from '@/constants';
+import { VALID_EMAIL_REGEX, COMMUNITY_PLUS_DOCS_URL } from '@/constants';
 import Modal from '@/components/Modal.vue';
 import { useI18n } from '@/composables/useI18n';
 import { useToast } from '@/composables/useToast';
@@ -86,9 +86,6 @@ const confirm = async () => {
 	>
 		<template #content>
 			<div>
-				<p :class="$style.top">
-					<N8nBadge>{{ i18n.baseText('communityPlusModal.badge') }}</N8nBadge>
-				</p>
 				<N8nText tag="h1" align="center" size="xlarge" class="mb-m">{{
 					data?.customHeading ?? i18n.baseText('communityPlusModal.title')
 				}}</N8nText>
@@ -141,6 +138,14 @@ const confirm = async () => {
 			</div>
 		</template>
 		<template #footer>
+			<div :class="$style.notice">
+				<N8nText size="xsmall" tag="span">
+					{{ i18n.baseText('communityPlusModal.notice') }}
+					<a :href="COMMUNITY_PLUS_DOCS_URL" target="_blank">
+						{{ i18n.baseText('generic.moreInfo') }}
+					</a>
+				</N8nText>
+			</div>
 			<div :class="$style.buttons">
 				<N8nButton :class="$style.skip" type="secondary" text @click="closeModal">{{
 					i18n.baseText('communityPlusModal.button.skip')
@@ -154,10 +159,8 @@ const confirm = async () => {
 </template>
 
 <style lang="scss" module>
-.top {
-	display: flex;
-	justify-content: center;
-	margin: 0 0 var(--spacing-s);
+.notice {
+	margin-bottom: var(--spacing-l);
 }
 
 .features {
diff --git a/packages/frontend/editor-ui/src/constants.ts b/packages/frontend/editor-ui/src/constants.ts
index f5d87904285..0369186f329 100644
--- a/packages/frontend/editor-ui/src/constants.ts
+++ b/packages/frontend/editor-ui/src/constants.ts
@@ -470,6 +470,8 @@ export const LOCAL_STORAGE_NDV_INPUT_PANEL_DISPLAY_MODE = 'N8N_NDV_INPUT_PANEL_D
 export const LOCAL_STORAGE_NDV_OUTPUT_PANEL_DISPLAY_MODE = 'N8N_NDV_OUTPUT_PANEL_DISPLAY_MODE';
 export const LOCAL_STORAGE_LOGS_2025_SPRING = 'N8N_LOGS_2025_SPRING';
 export const BASE_NODE_SURVEY_URL = 'https://n8n-community.typeform.com/to/BvmzxqYv#nodename=';
+export const COMMUNITY_PLUS_DOCS_URL =
+	'https://docs.n8n.io/hosting/community-edition-features/#registered-community-edition';
 
 export const HIRING_BANNER = `
                                                                     //////
diff --git a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
index 04b5e900e0b..bf512ebf806 100644
--- a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
+++ b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
@@ -2909,6 +2909,7 @@
 	"communityPlusModal.input.email.label": "Enter email to receive your license key",
 	"communityPlusModal.button.skip": "Skip",
 	"communityPlusModal.button.confirm": "Send me a free license key",
+	"communityPlusModal.notice": "Included features may change, but once unlocked, you'll keep them forever.",
 	"executeWorkflowTrigger.createNewSubworkflow": "Create a Sub-Workflow in {projectName}",
 	"executeWorkflowTrigger.createNewSubworkflow.noProject": "Create a New Sub-Workflow",
 	"testDefinition.edit.descriptionPlaceholder": "Enter test description",

From cc502fb8c34b65d569b4abe4603cc8ef1eadc7a7 Mon Sep 17 00:00:00 2001
From: Ria Scholz <123465523+riascho@users.noreply.github.com>
Date: Mon, 24 Mar 2025 13:00:17 +0100
Subject: [PATCH 05/33] feat: Add xAiGrok Chat Model node and credentials
 (#13670)

Co-authored-by: Shireen Missi <94372015+ShireenMissi@users.noreply.github.com>
Co-authored-by: Shireen Missi <shireen@n8n.io>
---
 .../credentials/XAiApi.credentials.ts         |  47 ++++
 .../nodes/agents/Agent/Agent.node.ts          |   2 +
 .../llms/LmChatXAiGrok/LmChatXAiGrok.node.ts  | 253 ++++++++++++++++++
 .../nodes/llms/LmChatXAiGrok/logo.dark.svg    |   1 +
 .../nodes/llms/LmChatXAiGrok/logo.svg         |   1 +
 packages/@n8n/nodes-langchain/package.json    |   2 +
 6 files changed, 306 insertions(+)
 create mode 100644 packages/@n8n/nodes-langchain/credentials/XAiApi.credentials.ts
 create mode 100644 packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/LmChatXAiGrok.node.ts
 create mode 100644 packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.dark.svg
 create mode 100644 packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.svg

diff --git a/packages/@n8n/nodes-langchain/credentials/XAiApi.credentials.ts b/packages/@n8n/nodes-langchain/credentials/XAiApi.credentials.ts
new file mode 100644
index 00000000000..74878901841
--- /dev/null
+++ b/packages/@n8n/nodes-langchain/credentials/XAiApi.credentials.ts
@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class XAiApi implements ICredentialType {
+	name = 'xAiApi';
+
+	displayName = 'xAi';
+
+	documentationUrl = 'xAi';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'hidden',
+			default: 'https://api.x.ai/v1',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/models',
+		},
+	};
+}
diff --git a/packages/@n8n/nodes-langchain/nodes/agents/Agent/Agent.node.ts b/packages/@n8n/nodes-langchain/nodes/agents/Agent/Agent.node.ts
index 2830ca02c30..67a67528dbc 100644
--- a/packages/@n8n/nodes-langchain/nodes/agents/Agent/Agent.node.ts
+++ b/packages/@n8n/nodes-langchain/nodes/agents/Agent/Agent.node.ts
@@ -100,6 +100,7 @@ function getInputs(
 						'@n8n/n8n-nodes-langchain.lmChatAzureOpenAi',
 						'@n8n/n8n-nodes-langchain.lmChatDeepSeek',
 						'@n8n/n8n-nodes-langchain.lmChatOpenRouter',
+						'@n8n/n8n-nodes-langchain.lmChatXAiGrok',
 					],
 				},
 			},
@@ -130,6 +131,7 @@ function getInputs(
 						'@n8n/n8n-nodes-langchain.lmChatGoogleGemini',
 						'@n8n/n8n-nodes-langchain.lmChatDeepSeek',
 						'@n8n/n8n-nodes-langchain.lmChatOpenRouter',
+						'@n8n/n8n-nodes-langchain.lmChatXAiGrok',
 					],
 				},
 			},
diff --git a/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/LmChatXAiGrok.node.ts b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/LmChatXAiGrok.node.ts
new file mode 100644
index 00000000000..1926f013335
--- /dev/null
+++ b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/LmChatXAiGrok.node.ts
@@ -0,0 +1,253 @@
+/* eslint-disable n8n-nodes-base/node-dirname-against-convention */
+
+import { ChatOpenAI, type ClientOptions } from '@langchain/openai';
+import {
+	NodeConnectionTypes,
+	type INodeType,
+	type INodeTypeDescription,
+	type ISupplyDataFunctions,
+	type SupplyData,
+} from 'n8n-workflow';
+
+import { getConnectionHintNoticeField } from '@utils/sharedFields';
+
+import { openAiFailedAttemptHandler } from '../../vendors/OpenAi/helpers/error-handling';
+import { makeN8nLlmFailedAttemptHandler } from '../n8nLlmFailedAttemptHandler';
+import { N8nLlmTracing } from '../N8nLlmTracing';
+
+export class LmChatXAiGrok implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'xAI Grok Chat Model',
+		// eslint-disable-next-line n8n-nodes-base/node-class-description-name-miscased
+		name: 'lmChatXAiGrok',
+		icon: { light: 'file:logo.dark.svg', dark: 'file:logo.svg' },
+		group: ['transform'],
+		version: [1],
+		description: 'For advanced usage with an AI chain',
+		defaults: {
+			name: 'xAI Grok Chat Model',
+		},
+		codex: {
+			categories: ['AI'],
+			subcategories: {
+				AI: ['Language Models', 'Root Nodes'],
+				'Language Models': ['Chat Models (Recommended)'],
+			},
+			resources: {
+				primaryDocumentation: [
+					{
+						url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatxaigrok/',
+					},
+				],
+			},
+		},
+		// eslint-disable-next-line n8n-nodes-base/node-class-description-inputs-wrong-regular-node
+		inputs: [],
+		// eslint-disable-next-line n8n-nodes-base/node-class-description-outputs-wrong
+		outputs: [NodeConnectionTypes.AiLanguageModel],
+		outputNames: ['Model'],
+		credentials: [
+			{
+				name: 'xAiApi',
+				required: true,
+			},
+		],
+		requestDefaults: {
+			ignoreHttpStatusErrors: true,
+			baseURL: '={{ $credentials?.url }}',
+		},
+		properties: [
+			getConnectionHintNoticeField([NodeConnectionTypes.AiChain, NodeConnectionTypes.AiAgent]),
+			{
+				displayName:
+					'If using JSON response format, you must include word "json" in the prompt in your chain or agent. Also, make sure to select latest models released post November 2023.',
+				name: 'notice',
+				type: 'notice',
+				default: '',
+				displayOptions: {
+					show: {
+						'/options.responseFormat': ['json_object'],
+					},
+				},
+			},
+			{
+				displayName: 'Model',
+				name: 'model',
+				type: 'options',
+				description:
+					'The model which will generate the completion. <a href="https://docs.x.ai/docs/models">Learn more</a>.',
+				typeOptions: {
+					loadOptions: {
+						routing: {
+							request: {
+								method: 'GET',
+								url: '/models',
+							},
+							output: {
+								postReceive: [
+									{
+										type: 'rootProperty',
+										properties: {
+											property: 'data',
+										},
+									},
+									{
+										type: 'setKeyValue',
+										properties: {
+											name: '={{$responseItem.id}}',
+											value: '={{$responseItem.id}}',
+										},
+									},
+									{
+										type: 'sort',
+										properties: {
+											key: 'name',
+										},
+									},
+								],
+							},
+						},
+					},
+				},
+				routing: {
+					send: {
+						type: 'body',
+						property: 'model',
+					},
+				},
+				default: 'grok-2-vision-1212',
+			},
+			{
+				displayName: 'Options',
+				name: 'options',
+				placeholder: 'Add Option',
+				description: 'Additional options to add',
+				type: 'collection',
+				default: {},
+				options: [
+					{
+						displayName: 'Frequency Penalty',
+						name: 'frequencyPenalty',
+						default: 0,
+						typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+						description:
+							"Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim",
+						type: 'number',
+					},
+					{
+						displayName: 'Maximum Number of Tokens',
+						name: 'maxTokens',
+						default: -1,
+						description:
+							'The maximum number of tokens to generate in the completion. Most models have a context length of 2048 tokens (except for the newest models, which support 32,768).',
+						type: 'number',
+						typeOptions: {
+							maxValue: 32768,
+						},
+					},
+					{
+						displayName: 'Response Format',
+						name: 'responseFormat',
+						default: 'text',
+						type: 'options',
+						options: [
+							{
+								name: 'Text',
+								value: 'text',
+								description: 'Regular text response',
+							},
+							{
+								name: 'JSON',
+								value: 'json_object',
+								description:
+									'Enables JSON mode, which should guarantee the message the model generates is valid JSON',
+							},
+						],
+					},
+					{
+						displayName: 'Presence Penalty',
+						name: 'presencePenalty',
+						default: 0,
+						typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+						description:
+							"Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics",
+						type: 'number',
+					},
+					{
+						displayName: 'Sampling Temperature',
+						name: 'temperature',
+						default: 0.7,
+						typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
+						description:
+							'Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.',
+						type: 'number',
+					},
+					{
+						displayName: 'Timeout',
+						name: 'timeout',
+						default: 360000,
+						description: 'Maximum amount of time a request is allowed to take in milliseconds',
+						type: 'number',
+					},
+					{
+						displayName: 'Max Retries',
+						name: 'maxRetries',
+						default: 2,
+						description: 'Maximum number of retries to attempt',
+						type: 'number',
+					},
+					{
+						displayName: 'Top P',
+						name: 'topP',
+						default: 1,
+						typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
+						description:
+							'Controls diversity via nucleus sampling: 0.5 means half of all likelihood-weighted options are considered. We generally recommend altering this or temperature but not both.',
+						type: 'number',
+					},
+				],
+			},
+		],
+	};
+
+	async supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData> {
+		const credentials = await this.getCredentials<OpenAICompatibleCredential>('xAiApi');
+
+		const modelName = this.getNodeParameter('model', itemIndex) as string;
+
+		const options = this.getNodeParameter('options', itemIndex, {}) as {
+			frequencyPenalty?: number;
+			maxTokens?: number;
+			maxRetries: number;
+			timeout: number;
+			presencePenalty?: number;
+			temperature?: number;
+			topP?: number;
+			responseFormat?: 'text' | 'json_object';
+		};
+
+		const configuration: ClientOptions = {
+			baseURL: credentials.url,
+		};
+
+		const model = new ChatOpenAI({
+			openAIApiKey: credentials.apiKey,
+			modelName,
+			...options,
+			timeout: options.timeout ?? 60000,
+			maxRetries: options.maxRetries ?? 2,
+			configuration,
+			callbacks: [new N8nLlmTracing(this)],
+			modelKwargs: options.responseFormat
+				? {
+						response_format: { type: options.responseFormat },
+					}
+				: undefined,
+			onFailedAttempt: makeN8nLlmFailedAttemptHandler(this, openAiFailedAttemptHandler),
+		});
+
+		return {
+			response: model,
+		};
+	}
+}
diff --git a/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.dark.svg b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.dark.svg
new file mode 100644
index 00000000000..53f973030f4
--- /dev/null
+++ b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.dark.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" viewBox="0 0 24 24" aria-hidden="true" class="" focusable="false" style="fill: currentcolor; height: 28px; width: 28px;"><path d="m3.005 8.858 8.783 12.544h3.904L6.908 8.858zM6.905 15.825 3 21.402h3.907l1.951-2.788zM16.585 2l-6.75 9.64 1.953 2.79L20.492 2zM17.292 7.965v13.437h3.2V3.395z"></path></svg>
diff --git a/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.svg b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.svg
new file mode 100644
index 00000000000..58bdc2cbb35
--- /dev/null
+++ b/packages/@n8n/nodes-langchain/nodes/llms/LmChatXAiGrok/logo.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000" width="32" height="32"><g><polygon fill="#fff" points="226.83 411.15 501.31 803.15 623.31 803.15 348.82 411.15 226.83 411.15"></polygon><polygon fill="#fff" points="348.72 628.87 226.69 803.15 348.77 803.15 409.76 716.05 348.72 628.87"></polygon><polygon fill="#fff" points="651.23 196.85 440.28 498.12 501.32 585.29 773.31 196.85 651.23 196.85"></polygon><polygon fill="#fff" points="673.31 383.25 673.31 803.15 773.31 803.15 773.31 240.44 673.31 383.25"></polygon></g></svg>
diff --git a/packages/@n8n/nodes-langchain/package.json b/packages/@n8n/nodes-langchain/package.json
index 1f51f6ac7aa..76be1524899 100644
--- a/packages/@n8n/nodes-langchain/package.json
+++ b/packages/@n8n/nodes-langchain/package.json
@@ -37,6 +37,7 @@
       "dist/credentials/QdrantApi.credentials.js",
       "dist/credentials/SerpApi.credentials.js",
       "dist/credentials/WolframAlphaApi.credentials.js",
+      "dist/credentials/XAiApi.credentials.js",
       "dist/credentials/XataApi.credentials.js",
       "dist/credentials/ZepApi.credentials.js"
     ],
@@ -73,6 +74,7 @@
       "dist/nodes/llms/LmChatMistralCloud/LmChatMistralCloud.node.js",
       "dist/nodes/llms/LMChatOllama/LmChatOllama.node.js",
       "dist/nodes/llms/LmChatOpenRouter/LmChatOpenRouter.node.js",
+      "dist/nodes/llms/LmChatXAiGrok/LmChatXAiGrok.node.js",
       "dist/nodes/llms/LMChatOpenAi/LmChatOpenAi.node.js",
       "dist/nodes/llms/LMOpenAi/LmOpenAi.node.js",
       "dist/nodes/llms/LMCohere/LmCohere.node.js",

From defeb2e817dbc559844124f20e6bebf7717d878a Mon Sep 17 00:00:00 2001
From: Jon <jonathan.bennetts@gmail.com>
Date: Mon, 24 Mar 2025 12:31:45 +0000
Subject: [PATCH 06/33] feat(Salesforce Node): Add support for PKCE (#14082)

---
 .../credentials/SalesforceOAuth2Api.credentials.ts   | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/nodes-base/credentials/SalesforceOAuth2Api.credentials.ts b/packages/nodes-base/credentials/SalesforceOAuth2Api.credentials.ts
index ff0e5a62a0c..96e261aee4d 100644
--- a/packages/nodes-base/credentials/SalesforceOAuth2Api.credentials.ts
+++ b/packages/nodes-base/credentials/SalesforceOAuth2Api.credentials.ts
@@ -10,6 +10,12 @@ export class SalesforceOAuth2Api implements ICredentialType {
 	documentationUrl = 'salesforce';
 
 	properties: INodeProperties[] = [
+		{
+			displayName: 'Grant Type',
+			name: 'grantType',
+			type: 'hidden',
+			default: 'pkce',
+		},
 		{
 			displayName: 'Environment Type',
 			name: 'environment',
@@ -26,12 +32,6 @@ export class SalesforceOAuth2Api implements ICredentialType {
 			],
 			default: 'production',
 		},
-		{
-			displayName: 'Grant Type',
-			name: 'grantType',
-			type: 'hidden',
-			default: 'authorizationCode',
-		},
 		{
 			displayName: 'Authorization URL',
 			name: 'authUrl',

From b9608647ca73c4892c84b19745226d411edbe7cf Mon Sep 17 00:00:00 2001
From: Alex Grozav <alex@grozav.com>
Date: Mon, 24 Mar 2025 14:40:19 +0200
Subject: [PATCH 07/33] refactor: Convert all enums to const object types in
 nodes-base (no-changelog) (#14131)

---
 .../nodes-base/nodes/Aws/DynamoDB/types.ts    | 26 ++++----
 .../nodes/Brevo/GenericFunctions.ts           | 20 +++---
 .../nodes/Clockify/ClockifyTrigger.node.ts    | 11 ++--
 .../nodes-base/nodes/Clockify/CommonDtos.ts   | 24 ++++---
 .../nodes-base/nodes/Clockify/EntryType.ts    |  5 ++
 .../nodes/Clockify/EntryTypeEnum.ts           |  3 -
 .../nodes/Clockify/ProjectInterfaces.ts       | 20 +++---
 .../nodes-base/nodes/Clockify/UserDtos.ts     | 12 ++--
 .../nodes/Clockify/WorkpaceInterfaces.ts      | 56 +++++++++-------
 .../nodes/Cortex/AnalyzerDescriptions.ts      | 10 +--
 .../nodes/Cortex/AnalyzerInterface.ts         | 65 ++++++++++---------
 .../nodes/Cortex/ResponderDescription.ts      | 26 ++++----
 .../nodes/Formstack/GenericFunctions.ts       | 13 ++--
 .../nodes/Freshdesk/Freshdesk.node.ts         | 48 ++++++++------
 .../nodes/Google/Chat/MessageInterface.ts     | 12 ++--
 .../Google/Drive/v2/helpers/interfaces.ts     | 36 +++++-----
 .../nodes/Mailchimp/Mailchimp.node.ts         | 16 +++--
 .../nodes/PayPal/PaymentInteface.ts           | 22 ++++---
 .../TheHive/descriptions/AlertDescription.ts  | 26 ++++----
 .../TheHive/descriptions/CaseDescription.ts   | 26 ++++----
 .../descriptions/ObservableDescription.ts     | 26 ++++----
 .../TheHive/interfaces/AlertInterface.ts      | 30 +++++----
 .../nodes/TheHive/interfaces/CaseInterface.ts | 41 +++++++-----
 .../nodes/TheHive/interfaces/LogInterface.ts  | 12 ++--
 .../TheHive/interfaces/ObservableInterface.ts | 45 +++++++------
 .../nodes/TheHive/interfaces/TaskInterface.ts | 14 ++--
 .../descriptions/common.description.ts        | 10 +--
 .../nodes/TheHiveProject/helpers/constants.ts | 50 +++++++-------
 .../TheHiveProject/helpers/interfaces.ts      | 14 ++--
 .../nodes/Todoist/v1/OperationHandler.ts      | 24 +++----
 .../nodes/Todoist/v2/OperationHandler.ts      | 24 +++----
 31 files changed, 422 insertions(+), 345 deletions(-)
 create mode 100644 packages/nodes-base/nodes/Clockify/EntryType.ts
 delete mode 100644 packages/nodes-base/nodes/Clockify/EntryTypeEnum.ts

diff --git a/packages/nodes-base/nodes/Aws/DynamoDB/types.ts b/packages/nodes-base/nodes/Aws/DynamoDB/types.ts
index 8431e199c0e..aca032974d1 100644
--- a/packages/nodes-base/nodes/Aws/DynamoDB/types.ts
+++ b/packages/nodes-base/nodes/Aws/DynamoDB/types.ts
@@ -51,18 +51,20 @@ export type PartitionKey = {
 	};
 };
 
-export const enum EAttributeValueType {
-	S = 'S',
-	SS = 'SS',
-	M = 'M',
-	L = 'L',
-	NS = 'NS',
-	N = 'N',
-	BOOL = 'BOOL',
-	B = 'B',
-	BS = 'BS',
-	NULL = 'NULL',
-}
+export const EAttributeValueTypes = {
+	S: 'S',
+	SS: 'SS',
+	M: 'M',
+	L: 'L',
+	NS: 'NS',
+	N: 'N',
+	BOOL: 'BOOL',
+	B: 'B',
+	BS: 'BS',
+	NULL: 'NULL',
+} as const;
+
+export type EAttributeValueType = (typeof EAttributeValueTypes)[keyof typeof EAttributeValueTypes];
 
 export interface IExpressionAttributeValue {
 	attribute: string;
diff --git a/packages/nodes-base/nodes/Brevo/GenericFunctions.ts b/packages/nodes-base/nodes/Brevo/GenericFunctions.ts
index 4b5da056c12..683861c800e 100644
--- a/packages/nodes-base/nodes/Brevo/GenericFunctions.ts
+++ b/packages/nodes-base/nodes/Brevo/GenericFunctions.ts
@@ -18,17 +18,17 @@ export namespace BrevoNode {
 	type BBCEmail = { bbc: Email[] };
 	type ValidatedEmail = ToEmail | SenderEmail | CCEmail | BBCEmail;
 
-	const enum OVERRIDE_MAP_VALUES {
-		CATEGORY = 'category',
-		NORMAL = 'boolean',
-		TRANSACTIONAL = 'id',
-	}
+	const OVERRIDE_MAP_VALUES = {
+		CATEGORY: 'category',
+		NORMAL: 'boolean',
+		TRANSACTIONAL: 'id',
+	} as const;
 
-	const enum OVERRIDE_MAP_TYPE {
-		CATEGORY = 'category',
-		NORMAL = 'normal',
-		TRANSACTIONAL = 'transactional',
-	}
+	const OVERRIDE_MAP_TYPE = {
+		CATEGORY: 'category',
+		NORMAL: 'normal',
+		TRANSACTIONAL: 'transactional',
+	} as const;
 
 	export const INTERCEPTORS = new Map<string, (body: JsonObject) => void>([
 		[
diff --git a/packages/nodes-base/nodes/Clockify/ClockifyTrigger.node.ts b/packages/nodes-base/nodes/Clockify/ClockifyTrigger.node.ts
index d9aa5095470..4702812ebec 100644
--- a/packages/nodes-base/nodes/Clockify/ClockifyTrigger.node.ts
+++ b/packages/nodes-base/nodes/Clockify/ClockifyTrigger.node.ts
@@ -10,7 +10,8 @@ import type {
 } from 'n8n-workflow';
 import { NodeConnectionTypes } from 'n8n-workflow';
 
-import { EntryTypeEnum } from './EntryTypeEnum';
+import type { EntryType } from './EntryType';
+import { EntryTypes } from './EntryType';
 import { clockifyApiRequest } from './GenericFunctions';
 import type { IUserDto } from './UserDtos';
 import type { IWorkspaceDto } from './WorkpaceInterfaces';
@@ -56,11 +57,11 @@ export class ClockifyTrigger implements INodeType {
 				options: [
 					{
 						name: 'New Time Entry',
-						value: EntryTypeEnum.NEW_TIME_ENTRY,
+						value: EntryTypes.NEW_TIME_ENTRY,
 					},
 				],
 				required: true,
-				default: EntryTypeEnum.NEW_TIME_ENTRY,
+				default: EntryTypes.NEW_TIME_ENTRY,
 			},
 		],
 	};
@@ -89,7 +90,7 @@ export class ClockifyTrigger implements INodeType {
 
 	async poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null> {
 		const webhookData = this.getWorkflowStaticData('node');
-		const triggerField = this.getNodeParameter('watchField') as EntryTypeEnum;
+		const triggerField = this.getNodeParameter('watchField') as EntryType;
 		const workspaceId = this.getNodeParameter('workspaceId');
 
 		if (!webhookData.userId) {
@@ -103,7 +104,7 @@ export class ClockifyTrigger implements INodeType {
 		let result = null;
 
 		switch (triggerField) {
-			case EntryTypeEnum.NEW_TIME_ENTRY:
+			case EntryTypes.NEW_TIME_ENTRY:
 			default:
 				const workflowTimezone = this.getTimezone();
 				resource = `workspaces/${workspaceId}/user/${webhookData.userId}/time-entries`;
diff --git a/packages/nodes-base/nodes/Clockify/CommonDtos.ts b/packages/nodes-base/nodes/Clockify/CommonDtos.ts
index 7e7f5bbd914..86168a31319 100644
--- a/packages/nodes-base/nodes/Clockify/CommonDtos.ts
+++ b/packages/nodes-base/nodes/Clockify/CommonDtos.ts
@@ -3,17 +3,21 @@ export interface IHourlyRateDto {
 	currency: string;
 }
 
-const enum MembershipStatusEnum {
-	PENDING = 'PENDING',
-	ACTIVE = 'ACTIVE',
-	DECLINED = 'DECLINED',
-	INACTIVE = 'INACTIVE',
-}
+const MembershipStatuses = {
+	PENDING: 'PENDING',
+	ACTIVE: 'ACTIVE',
+	DECLINED: 'DECLINED',
+	INACTIVE: 'INACTIVE',
+} as const;
 
-const enum TaskStatusEnum {
-	ACTIVE = 'ACTIVE',
-	DONE = 'DONE',
-}
+type MembershipStatusEnum = (typeof MembershipStatuses)[keyof typeof MembershipStatuses];
+
+const TaskStatuses = {
+	ACTIVE: 'ACTIVE',
+	DONE: 'DONE',
+} as const;
+
+type TaskStatusEnum = (typeof TaskStatuses)[keyof typeof TaskStatuses];
 
 export interface IMembershipDto {
 	hourlyRate: IHourlyRateDto;
diff --git a/packages/nodes-base/nodes/Clockify/EntryType.ts b/packages/nodes-base/nodes/Clockify/EntryType.ts
new file mode 100644
index 00000000000..ba68a58a17a
--- /dev/null
+++ b/packages/nodes-base/nodes/Clockify/EntryType.ts
@@ -0,0 +1,5 @@
+export const EntryTypes = {
+	NEW_TIME_ENTRY: 0,
+} as const;
+
+export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
diff --git a/packages/nodes-base/nodes/Clockify/EntryTypeEnum.ts b/packages/nodes-base/nodes/Clockify/EntryTypeEnum.ts
deleted file mode 100644
index d83881685f8..00000000000
--- a/packages/nodes-base/nodes/Clockify/EntryTypeEnum.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export const enum EntryTypeEnum {
-	NEW_TIME_ENTRY,
-}
diff --git a/packages/nodes-base/nodes/Clockify/ProjectInterfaces.ts b/packages/nodes-base/nodes/Clockify/ProjectInterfaces.ts
index 623a9fe5176..612e0b15698 100644
--- a/packages/nodes-base/nodes/Clockify/ProjectInterfaces.ts
+++ b/packages/nodes-base/nodes/Clockify/ProjectInterfaces.ts
@@ -1,9 +1,11 @@
 import type { IHourlyRateDto, IMembershipDto } from './CommonDtos';
 
-const enum EstimateEnum {
-	AUTO = 'AUTO',
-	MANUAL = 'MANUAL',
-}
+const Estimates = {
+	AUTO: 'AUTO',
+	MANUAL: 'MANUAL',
+} as const;
+
+type EstimateEnum = (typeof Estimates)[keyof typeof Estimates];
 
 interface IEstimateDto {
 	estimate: string;
@@ -40,10 +42,12 @@ export interface IProjectRequest {
 	tasks: ITaskDto;
 }
 
-const enum TaskStatusEnum {
-	ACTIVE = 'ACTIVE',
-	DONE = 'DONE',
-}
+const TaskStatuses = {
+	ACTIVE: 'ACTIVE',
+	DONE: 'DONE',
+} as const;
+
+type TaskStatusEnum = (typeof TaskStatuses)[keyof typeof TaskStatuses];
 
 export interface ITaskDto {
 	assigneeIds: object;
diff --git a/packages/nodes-base/nodes/Clockify/UserDtos.ts b/packages/nodes-base/nodes/Clockify/UserDtos.ts
index e482e47030e..ed72d2e7c4a 100644
--- a/packages/nodes-base/nodes/Clockify/UserDtos.ts
+++ b/packages/nodes-base/nodes/Clockify/UserDtos.ts
@@ -2,11 +2,13 @@ import type { IDataObject } from 'n8n-workflow';
 
 import type { IMembershipDto } from './CommonDtos';
 
-const enum UserStatusEnum {
-	ACTIVE,
-	PENDING_EMAIL_VERIFICATION,
-	DELETED,
-}
+const UserStatuses = {
+	ACTIVE: 0,
+	PENDING_EMAIL_VERIFICATION: 1,
+	DELETED: 2,
+};
+
+export type UserStatusEnum = (typeof UserStatuses)[keyof typeof UserStatuses];
 
 export interface IUserDto {
 	activeWorkspace: string;
diff --git a/packages/nodes-base/nodes/Clockify/WorkpaceInterfaces.ts b/packages/nodes-base/nodes/Clockify/WorkpaceInterfaces.ts
index 11eb0557e7d..775dc83e123 100644
--- a/packages/nodes-base/nodes/Clockify/WorkpaceInterfaces.ts
+++ b/packages/nodes-base/nodes/Clockify/WorkpaceInterfaces.ts
@@ -1,32 +1,40 @@
 import type { IHourlyRateDto, IMembershipDto } from './CommonDtos';
 
-const enum AdminOnlyPagesEnum {
-	PROJECT = 'PROJECT',
-	TEAM = 'TEAM',
-	REPORTS = 'REPORTS',
-}
+export const AdminOnlyPages = {
+	PROJECT: 'PROJECT',
+	TEAM: 'TEAM',
+	REPORTS: 'REPORTS',
+} as const;
 
-const enum DaysOfWeekEnum {
-	MONDAY = 'MONDAY',
-	TUESDAY = 'TUESDAY',
-	WEDNESDAY = 'WEDNESDAY',
-	THURSDAY = 'THURSDAY',
-	FRIDAY = 'FRIDAY',
-	SATURDAY = 'SATURDAY',
-	SUNDAY = 'SUNDAY',
-}
+export type AdminOnlyPagesEnum = (typeof AdminOnlyPages)[keyof typeof AdminOnlyPages];
 
-const enum DatePeriodEnum {
-	DAYS = 'DAYS',
-	WEEKS = 'WEEKS',
-	MONTHS = 'MONTHS',
-}
+export const DaysOfWeek = {
+	MONDAY: 'MONDAY',
+	TUESDAY: 'TUESDAY',
+	WEDNESDAY: 'WEDNESDAY',
+	THURSDAY: 'THURSDAY',
+	FRIDAY: 'FRIDAY',
+	SATURDAY: 'SATURDAY',
+	SUNDAY: 'SUNDAY',
+} as const;
 
-const enum AutomaticLockTypeEnum {
-	WEEKLY = 'WEEKLY',
-	MONTHLY = 'MONTHLY',
-	OLDER_THAN = 'OLDER_THAN',
-}
+export type DaysOfWeekEnum = (typeof DaysOfWeek)[keyof typeof DaysOfWeek];
+
+export const DatePeriods = {
+	DAYS: 'DAYS',
+	WEEKS: 'WEEKS',
+	MONTHS: 'MONTHS',
+} as const;
+
+export type DatePeriodEnum = (typeof DatePeriods)[keyof typeof DatePeriods];
+
+export const AutomaticLockTypes = {
+	WEEKLY: 'WEEKLY',
+	MONTHLY: 'MONTHLY',
+	OLDER_THAN: 'OLDER_THAN',
+} as const;
+
+export type AutomaticLockTypeEnum = (typeof AutomaticLockTypes)[keyof typeof AutomaticLockTypes];
 
 interface IAutomaticLockDto {
 	changeDay: DaysOfWeekEnum;
diff --git a/packages/nodes-base/nodes/Cortex/AnalyzerDescriptions.ts b/packages/nodes-base/nodes/Cortex/AnalyzerDescriptions.ts
index 338410f7366..d0c9c379fd2 100644
--- a/packages/nodes-base/nodes/Cortex/AnalyzerDescriptions.ts
+++ b/packages/nodes-base/nodes/Cortex/AnalyzerDescriptions.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from './AnalyzerInterface';
+import { TLPs } from './AnalyzerInterface';
 
 export const analyzersOperations: INodeProperties[] = [
 	{
@@ -120,19 +120,19 @@ export const analyzerFields: INodeProperties[] = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		default: 2,
diff --git a/packages/nodes-base/nodes/Cortex/AnalyzerInterface.ts b/packages/nodes-base/nodes/Cortex/AnalyzerInterface.ts
index a20948d01b6..4804924b912 100644
--- a/packages/nodes-base/nodes/Cortex/AnalyzerInterface.ts
+++ b/packages/nodes-base/nodes/Cortex/AnalyzerInterface.ts
@@ -1,36 +1,43 @@
 import type { IDataObject } from 'n8n-workflow';
 
-export const enum JobStatus {
-	WAITING = 'Waiting',
-	INPROGRESS = 'InProgress',
-	SUCCESS = 'Success',
-	FAILURE = 'Failure',
-	DELETED = 'Deleted',
-}
+export const JobStatuses = {
+	WAITING: 'Waiting',
+	INPROGRESS: 'InProgress',
+	SUCCESS: 'Success',
+	FAILURE: 'Failure',
+	DELETED: 'Deleted',
+} as const;
 
-export const enum TLP {
-	white,
-	green,
-	amber,
-	red,
-}
+export type JobStatus = (typeof JobStatuses)[keyof typeof JobStatuses];
+
+export const TLPs = {
+	white: 0,
+	green: 1,
+	amber: 2,
+	red: 3,
+} as const;
+
+export type TLP = (typeof TLPs)[keyof typeof TLPs];
+
+export const ObservableDataTypes = {
+	domain: 'domain',
+	file: 'file',
+	filename: 'filename',
+	fqdn: 'fqdn',
+	hash: 'hash',
+	ip: 'ip',
+	mail: 'mail',
+	mail_subject: 'mail_subject',
+	other: 'other',
+	regexp: 'regexp',
+	registry: 'registry',
+	uri_path: 'uri_path',
+	url: 'url',
+	'user-agent': 'user-agent',
+} as const;
+
+export type ObservableDataType = (typeof ObservableDataTypes)[keyof typeof ObservableDataTypes];
 
-export const enum ObservableDataType {
-	domain = 'domain',
-	file = 'file',
-	filename = 'filename',
-	fqdn = 'fqdn',
-	hash = 'hash',
-	ip = 'ip',
-	mail = 'mail',
-	mail_subject = 'mail_subject',
-	other = 'other',
-	regexp = 'regexp',
-	registry = 'registry',
-	uri_path = 'uri_path',
-	url = 'url',
-	'user-agent' = 'user-agent',
-}
 export interface IJob {
 	id?: string;
 	organization?: string;
diff --git a/packages/nodes-base/nodes/Cortex/ResponderDescription.ts b/packages/nodes-base/nodes/Cortex/ResponderDescription.ts
index 6de2a325893..57aab4bb249 100644
--- a/packages/nodes-base/nodes/Cortex/ResponderDescription.ts
+++ b/packages/nodes-base/nodes/Cortex/ResponderDescription.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from './AnalyzerInterface';
+import { TLPs } from './AnalyzerInterface';
 
 export const respondersOperations: INodeProperties[] = [
 	{
@@ -172,19 +172,19 @@ export const responderFields: INodeProperties[] = [
 						options: [
 							{
 								name: 'White',
-								value: TLP.white,
+								value: TLPs.white,
 							},
 							{
 								name: 'Green',
-								value: TLP.green,
+								value: TLPs.green,
 							},
 							{
 								name: 'Amber',
-								value: TLP.amber,
+								value: TLPs.amber,
 							},
 							{
 								name: 'Red',
-								value: TLP.red,
+								value: TLPs.red,
 							},
 						],
 						description: 'Traffic Light Protocol (TLP). Default=Amber.',
@@ -436,19 +436,19 @@ export const responderFields: INodeProperties[] = [
 						options: [
 							{
 								name: 'White',
-								value: TLP.white,
+								value: TLPs.white,
 							},
 							{
 								name: 'Green',
-								value: TLP.green,
+								value: TLPs.green,
 							},
 							{
 								name: 'Amber',
-								value: TLP.amber,
+								value: TLPs.amber,
 							},
 							{
 								name: 'Red',
-								value: TLP.red,
+								value: TLPs.red,
 							},
 						],
 						description: 'Traffic Light Protocol (TLP). Default=Amber.',
@@ -621,19 +621,19 @@ export const responderFields: INodeProperties[] = [
 						options: [
 							{
 								name: 'White',
-								value: TLP.white,
+								value: TLPs.white,
 							},
 							{
 								name: 'Green',
-								value: TLP.green,
+								value: TLPs.green,
 							},
 							{
 								name: 'Amber',
-								value: TLP.amber,
+								value: TLPs.amber,
 							},
 							{
 								name: 'Red',
-								value: TLP.red,
+								value: TLPs.red,
 							},
 						],
 						description: 'Traffic Light Protocol (TLP). Default=Amber.',
diff --git a/packages/nodes-base/nodes/Formstack/GenericFunctions.ts b/packages/nodes-base/nodes/Formstack/GenericFunctions.ts
index 2637cedecfa..abec8f8f960 100644
--- a/packages/nodes-base/nodes/Formstack/GenericFunctions.ts
+++ b/packages/nodes-base/nodes/Formstack/GenericFunctions.ts
@@ -39,11 +39,14 @@ export interface IFormstackSubmissionFieldContainer {
 	value: string;
 }
 
-export const enum FormstackFieldFormat {
-	ID = 'id',
-	Label = 'label',
-	Name = 'name',
-}
+export const FormstackFieldFormats = {
+	ID: 'id',
+	Label: 'label',
+	Name: 'name',
+} as const;
+
+export type FormstackFieldFormat =
+	(typeof FormstackFieldFormats)[keyof typeof FormstackFieldFormats];
 
 /**
  * Make an API request to Formstack
diff --git a/packages/nodes-base/nodes/Freshdesk/Freshdesk.node.ts b/packages/nodes-base/nodes/Freshdesk/Freshdesk.node.ts
index 83a5a0724e2..61da979f3e7 100644
--- a/packages/nodes-base/nodes/Freshdesk/Freshdesk.node.ts
+++ b/packages/nodes-base/nodes/Freshdesk/Freshdesk.node.ts
@@ -18,29 +18,35 @@ import {
 	// validateJSON,
 } from './GenericFunctions';
 
-const enum Status {
-	Open = 2,
-	Pending = 3,
-	Resolved = 4,
-	Closed = 5,
-}
+const Statuses = {
+	Open: 2,
+	Pending: 3,
+	Resolved: 4,
+	Closed: 5,
+} as const;
 
-const enum Priority {
-	Low = 1,
-	Medium = 2,
-	High = 3,
-	Urgent = 4,
-}
+type Status = (typeof Statuses)[keyof typeof Statuses];
 
-const enum Source {
-	Email = 1,
-	Portal = 2,
-	Phone = 3,
-	Chat = 7,
-	Mobihelp = 8,
-	FeedbackWidget = 9,
-	OutboundEmail = 10,
-}
+const Priorities = {
+	Low: 1,
+	Medium: 2,
+	High: 3,
+	Urgent: 4,
+} as const;
+
+type Priority = (typeof Priorities)[keyof typeof Priorities];
+
+const Sources = {
+	Email: 1,
+	Portal: 2,
+	Phone: 3,
+	Chat: 7,
+	Mobihelp: 8,
+	FeedbackWidget: 9,
+	OutboundEmail: 10,
+} as const;
+
+type Source = (typeof Sources)[keyof typeof Sources];
 
 interface ICreateTicketBody {
 	name?: string;
diff --git a/packages/nodes-base/nodes/Google/Chat/MessageInterface.ts b/packages/nodes-base/nodes/Google/Chat/MessageInterface.ts
index b2193f98200..5833fc7ab96 100644
--- a/packages/nodes-base/nodes/Google/Chat/MessageInterface.ts
+++ b/packages/nodes-base/nodes/Google/Chat/MessageInterface.ts
@@ -31,11 +31,13 @@ export interface IUser {
 	type?: Type;
 	isAnonymous?: boolean;
 }
-const enum Type {
-	TYPE_UNSPECIFIED,
-	HUMAN,
-	BOT,
-}
+const Types = {
+	TYPE_UNSPECIFIED: 0,
+	HUMAN: 1,
+	BOT: 2,
+} as const;
+
+export type Type = (typeof Types)[keyof typeof Types];
 
 // // TODO: define other interfaces
 //
diff --git a/packages/nodes-base/nodes/Google/Drive/v2/helpers/interfaces.ts b/packages/nodes-base/nodes/Google/Drive/v2/helpers/interfaces.ts
index 8da73ac857c..e4ed0dec832 100644
--- a/packages/nodes-base/nodes/Google/Drive/v2/helpers/interfaces.ts
+++ b/packages/nodes-base/nodes/Google/Drive/v2/helpers/interfaces.ts
@@ -17,21 +17,21 @@ export type SearchFilter = {
 export const RLC_DRIVE_DEFAULT = 'My Drive';
 export const RLC_FOLDER_DEFAULT = 'root';
 
-export const enum DRIVE {
-	FOLDER = 'application/vnd.google-apps.folder',
-	AUDIO = 'application/vnd.google-apps.audio',
-	DOCUMENT = 'application/vnd.google-apps.document',
-	SDK = 'application/vnd.google-apps.drive-sdk',
-	DRAWING = 'application/vnd.google-apps.drawing',
-	FILE = 'application/vnd.google-apps.file',
-	FORM = 'application/vnd.google-apps.form',
-	FUSIONTABLE = 'application/vnd.google-apps.fusiontable',
-	MAP = 'application/vnd.google-apps.map',
-	PHOTO = 'application/vnd.google-apps.photo',
-	PRESENTATION = 'application/vnd.google-apps.presentation',
-	APP_SCRIPTS = 'application/vnd.google-apps.script',
-	SITES = 'application/vnd.google-apps.sites',
-	SPREADSHEET = 'application/vnd.google-apps.spreadsheet',
-	UNKNOWN = 'application/vnd.google-apps.unknown',
-	VIDEO = 'application/vnd.google-apps.video',
-}
+export const DRIVE = {
+	FOLDER: 'application/vnd.google-apps.folder',
+	AUDIO: 'application/vnd.google-apps.audio',
+	DOCUMENT: 'application/vnd.google-apps.document',
+	SDK: 'application/vnd.google-apps.drive-sdk',
+	DRAWING: 'application/vnd.google-apps.drawing',
+	FILE: 'application/vnd.google-apps.file',
+	FORM: 'application/vnd.google-apps.form',
+	FUSIONTABLE: 'application/vnd.google-apps.fusiontable',
+	MAP: 'application/vnd.google-apps.map',
+	PHOTO: 'application/vnd.google-apps.photo',
+	PRESENTATION: 'application/vnd.google-apps.presentation',
+	APP_SCRIPTS: 'application/vnd.google-apps.script',
+	SITES: 'application/vnd.google-apps.sites',
+	SPREADSHEET: 'application/vnd.google-apps.spreadsheet',
+	UNKNOWN: 'application/vnd.google-apps.unknown',
+	VIDEO: 'application/vnd.google-apps.video',
+} as const;
diff --git a/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts b/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts
index f7203cb4d1d..c4f59830005 100644
--- a/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts
+++ b/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts
@@ -17,13 +17,15 @@ import {
 	validateJSON,
 } from './GenericFunctions';
 
-const enum Status {
-	subscribe = 'subscribe',
-	unsubscribed = 'unsubscribe',
-	cleaned = 'cleaned',
-	pending = 'pending',
-	transactional = 'transactional',
-}
+const Statuses = {
+	subscribe: 'subscribe',
+	unsubscribed: 'unsubscribe',
+	cleaned: 'cleaned',
+	pending: 'pending',
+	transactional: 'transactional',
+} as const;
+
+type Status = (typeof Statuses)[keyof typeof Statuses];
 
 interface ILocation {
 	latitude?: number;
diff --git a/packages/nodes-base/nodes/PayPal/PaymentInteface.ts b/packages/nodes-base/nodes/PayPal/PaymentInteface.ts
index d4e28c6ceef..bc1a97956c9 100644
--- a/packages/nodes-base/nodes/PayPal/PaymentInteface.ts
+++ b/packages/nodes-base/nodes/PayPal/PaymentInteface.ts
@@ -1,13 +1,17 @@
-export const enum RecipientType {
-	email = 'EMAIL',
-	phone = 'PHONE',
-	paypalId = 'PAYPAL_ID',
-}
+export const RecipientTypes = {
+	email: 'EMAIL',
+	phone: 'PHONE',
+	paypalId: 'PAYPAL_ID',
+} as const;
 
-export const enum RecipientWallet {
-	paypal = 'PAYPAL',
-	venmo = 'VENMO',
-}
+export type RecipientType = (typeof RecipientTypes)[keyof typeof RecipientTypes];
+
+export const RecipientWallets = {
+	paypal: 'PAYPAL',
+	venmo: 'VENMO',
+} as const;
+
+export type RecipientWallet = (typeof RecipientWallets)[keyof typeof RecipientWallets];
 
 export interface IAmount {
 	currency?: string;
diff --git a/packages/nodes-base/nodes/TheHive/descriptions/AlertDescription.ts b/packages/nodes-base/nodes/TheHive/descriptions/AlertDescription.ts
index 4742b95a46f..a532f22aa11 100644
--- a/packages/nodes-base/nodes/TheHive/descriptions/AlertDescription.ts
+++ b/packages/nodes-base/nodes/TheHive/descriptions/AlertDescription.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from '../interfaces/AlertInterface';
+import { TLPs } from '../interfaces/AlertInterface';
 
 export const alertOperations: INodeProperties[] = [
 	{
@@ -185,19 +185,19 @@ export const alertFields: INodeProperties[] = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		displayOptions: {
@@ -722,19 +722,19 @@ export const alertFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
@@ -891,19 +891,19 @@ export const alertFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
diff --git a/packages/nodes-base/nodes/TheHive/descriptions/CaseDescription.ts b/packages/nodes-base/nodes/TheHive/descriptions/CaseDescription.ts
index adc3e571e6f..80b7fba5f0a 100644
--- a/packages/nodes-base/nodes/TheHive/descriptions/CaseDescription.ts
+++ b/packages/nodes-base/nodes/TheHive/descriptions/CaseDescription.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from '../interfaces/AlertInterface';
+import { TLPs } from '../interfaces/AlertInterface';
 
 export const caseOperations: INodeProperties[] = [
 	{
@@ -179,19 +179,19 @@ export const caseFields: INodeProperties[] = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		displayOptions: {
@@ -578,19 +578,19 @@ export const caseFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
@@ -823,19 +823,19 @@ export const caseFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
diff --git a/packages/nodes-base/nodes/TheHive/descriptions/ObservableDescription.ts b/packages/nodes-base/nodes/TheHive/descriptions/ObservableDescription.ts
index 2e2c7ce5769..b2cf3bcb9f7 100644
--- a/packages/nodes-base/nodes/TheHive/descriptions/ObservableDescription.ts
+++ b/packages/nodes-base/nodes/TheHive/descriptions/ObservableDescription.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from '../interfaces/AlertInterface';
+import { TLPs } from '../interfaces/AlertInterface';
 
 export const observableOperations: INodeProperties[] = [
 	{
@@ -177,19 +177,19 @@ export const observableFields: INodeProperties[] = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		description: 'Traffict Light Protocol (TLP). Default=Amber.',
@@ -351,19 +351,19 @@ export const observableFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
@@ -542,19 +542,19 @@ export const observableFields: INodeProperties[] = [
 				options: [
 					{
 						name: 'White',
-						value: TLP.white,
+						value: TLPs.white,
 					},
 					{
 						name: 'Green',
-						value: TLP.green,
+						value: TLPs.green,
 					},
 					{
 						name: 'Amber',
-						value: TLP.amber,
+						value: TLPs.amber,
 					},
 					{
 						name: 'Red',
-						value: TLP.red,
+						value: TLPs.red,
 					},
 				],
 				description: 'Traffict Light Protocol (TLP). Default=Amber.',
diff --git a/packages/nodes-base/nodes/TheHive/interfaces/AlertInterface.ts b/packages/nodes-base/nodes/TheHive/interfaces/AlertInterface.ts
index 0286d8247a8..0821ccf1b69 100644
--- a/packages/nodes-base/nodes/TheHive/interfaces/AlertInterface.ts
+++ b/packages/nodes-base/nodes/TheHive/interfaces/AlertInterface.ts
@@ -1,16 +1,22 @@
 import type { IDataObject } from 'n8n-workflow';
-export const enum AlertStatus {
-	NEW = 'New',
-	UPDATED = 'Updated',
-	IGNORED = 'Ignored',
-	IMPORTED = 'Imported',
-}
-export const enum TLP {
-	white,
-	green,
-	amber,
-	red,
-}
+
+export const AlertStatuses = {
+	NEW: 'New',
+	UPDATED: 'Updated',
+	IGNORED: 'Ignored',
+	IMPORTED: 'Imported',
+} as const;
+
+export type AlertStatus = (typeof AlertStatuses)[keyof typeof AlertStatuses];
+
+export const TLPs = {
+	white: 0,
+	green: 1,
+	amber: 2,
+	red: 3,
+} as const;
+
+export type TLP = (typeof TLPs)[keyof typeof TLPs];
 
 export interface IAlert {
 	// Required attributes
diff --git a/packages/nodes-base/nodes/TheHive/interfaces/CaseInterface.ts b/packages/nodes-base/nodes/TheHive/interfaces/CaseInterface.ts
index 3eeee45b481..7fad8dd3c84 100644
--- a/packages/nodes-base/nodes/TheHive/interfaces/CaseInterface.ts
+++ b/packages/nodes-base/nodes/TheHive/interfaces/CaseInterface.ts
@@ -32,22 +32,29 @@ export interface ICase {
 	upadtedAt?: Date;
 }
 
-export const enum CaseStatus {
-	OPEN = 'Open',
-	RESOLVED = 'Resolved',
-	DELETED = 'Deleted',
-}
+export const CaseStatuses = {
+	OPEN: 'Open',
+	RESOLVED: 'Resolved',
+	DELETED: 'Deleted',
+} as const;
 
-export const enum CaseResolutionStatus {
-	INDETERMINATE = 'Indeterminate',
-	FALSEPOSITIVE = 'FalsePositive',
-	TRUEPOSITIVE = 'TruePositive',
-	OTHER = 'Other',
-	DUPLICATED = 'Duplicated',
-}
+export type CaseStatus = (typeof CaseStatuses)[keyof typeof CaseStatuses];
 
-export const enum CaseImpactStatus {
-	NOIMPACT = 'NoImpact',
-	WITHIMPACT = 'WithImpact',
-	NOTAPPLICABLE = 'NotApplicable',
-}
+export const CaseResolutionStatuses = {
+	INDETERMINATE: 'Indeterminate',
+	FALSEPOSITIVE: 'FalsePositive',
+	TRUEPOSITIVE: 'TruePositive',
+	OTHER: 'Other',
+	DUPLICATED: 'Duplicated',
+} as const;
+
+export type CaseResolutionStatus =
+	(typeof CaseResolutionStatuses)[keyof typeof CaseResolutionStatuses];
+
+export const CaseImpactStatuses = {
+	NOIMPACT: 'NoImpact',
+	WITHIMPACT: 'WithImpact',
+	NOTAPPLICABLE: 'NotApplicable',
+} as const;
+
+export type CaseImpactStatus = (typeof CaseImpactStatuses)[keyof typeof CaseImpactStatuses];
diff --git a/packages/nodes-base/nodes/TheHive/interfaces/LogInterface.ts b/packages/nodes-base/nodes/TheHive/interfaces/LogInterface.ts
index 2e786a962f8..2acee18e7d6 100644
--- a/packages/nodes-base/nodes/TheHive/interfaces/LogInterface.ts
+++ b/packages/nodes-base/nodes/TheHive/interfaces/LogInterface.ts
@@ -1,8 +1,12 @@
 import type { IAttachment } from './ObservableInterface';
-export const enum LogStatus {
-	OK = 'Ok',
-	DELETED = 'Deleted',
-}
+
+export const LogStatuses = {
+	OK: 'Ok',
+	DELETED: 'Deleted',
+} as const;
+
+export type LogStatus = (typeof LogStatuses)[keyof typeof LogStatuses];
+
 export interface ILog {
 	// Required attributes
 	id?: string;
diff --git a/packages/nodes-base/nodes/TheHive/interfaces/ObservableInterface.ts b/packages/nodes-base/nodes/TheHive/interfaces/ObservableInterface.ts
index da792ba07ad..b48baf99631 100644
--- a/packages/nodes-base/nodes/TheHive/interfaces/ObservableInterface.ts
+++ b/packages/nodes-base/nodes/TheHive/interfaces/ObservableInterface.ts
@@ -1,25 +1,30 @@
 import type { TLP } from './AlertInterface';
 
-export const enum ObservableStatus {
-	OK = 'Ok',
-	DELETED = 'Deleted',
-}
-export const enum ObservableDataType {
-	domain = 'domain',
-	file = 'file',
-	filename = 'filename',
-	fqdn = 'fqdn',
-	hash = 'hash',
-	ip = 'ip',
-	mail = 'mail',
-	mail_subject = 'mail_subject',
-	other = 'other',
-	regexp = 'regexp',
-	registry = 'registry',
-	uri_path = 'uri_path',
-	url = 'url',
-	'user-agent' = 'user-agent',
-}
+export const ObservableStatuses = {
+	OK: 'Ok',
+	DELETED: 'Deleted',
+} as const;
+
+export type ObservableStatus = (typeof ObservableStatuses)[keyof typeof ObservableStatuses];
+
+export const ObservableDataTypes = {
+	domain: 'domain',
+	file: 'file',
+	filename: 'filename',
+	fqdn: 'fqdn',
+	hash: 'hash',
+	ip: 'ip',
+	mail: 'mail',
+	mail_subject: 'mail_subject',
+	other: 'other',
+	regexp: 'regexp',
+	registry: 'registry',
+	uri_path: 'uri_path',
+	url: 'url',
+	'user-agent': 'user-agent',
+} as const;
+
+export type ObservableDataType = (typeof ObservableDataTypes)[keyof typeof ObservableDataTypes];
 
 export interface IAttachment {
 	name?: string;
diff --git a/packages/nodes-base/nodes/TheHive/interfaces/TaskInterface.ts b/packages/nodes-base/nodes/TheHive/interfaces/TaskInterface.ts
index daff422198e..89766f43608 100644
--- a/packages/nodes-base/nodes/TheHive/interfaces/TaskInterface.ts
+++ b/packages/nodes-base/nodes/TheHive/interfaces/TaskInterface.ts
@@ -17,9 +17,11 @@ export interface ITask {
 	upadtedAt?: Date;
 }
 
-export const enum TaskStatus {
-	WAITING = 'Waiting',
-	INPROGRESS = 'InProgress',
-	COMPLETED = 'Completed',
-	CANCEL = 'Cancel',
-}
+export const TaskStatuses = {
+	WAITING: 'Waiting',
+	INPROGRESS: 'InProgress',
+	COMPLETED: 'Completed',
+	CANCEL: 'Cancel',
+} as const;
+
+export type TaskStatus = (typeof TaskStatuses)[keyof typeof TaskStatuses];
diff --git a/packages/nodes-base/nodes/TheHiveProject/descriptions/common.description.ts b/packages/nodes-base/nodes/TheHiveProject/descriptions/common.description.ts
index 5653375dd46..64352491a59 100644
--- a/packages/nodes-base/nodes/TheHiveProject/descriptions/common.description.ts
+++ b/packages/nodes-base/nodes/TheHiveProject/descriptions/common.description.ts
@@ -1,6 +1,6 @@
 import type { INodeProperties } from 'n8n-workflow';
 
-import { TLP } from '../helpers/interfaces';
+import { TLPs } from '../helpers/interfaces';
 
 export const returnAllAndLimit: INodeProperties[] = [
 	{
@@ -54,19 +54,19 @@ export const tlpOptions: INodeProperties = {
 	options: [
 		{
 			name: 'White',
-			value: TLP.white,
+			value: TLPs.white,
 		},
 		{
 			name: 'Green',
-			value: TLP.green,
+			value: TLPs.green,
 		},
 		{
 			name: 'Amber',
-			value: TLP.amber,
+			value: TLPs.amber,
 		},
 		{
 			name: 'Red',
-			value: TLP.red,
+			value: TLPs.red,
 		},
 	],
 };
diff --git a/packages/nodes-base/nodes/TheHiveProject/helpers/constants.ts b/packages/nodes-base/nodes/TheHiveProject/helpers/constants.ts
index 33553fe1271..3d67f4f0857 100644
--- a/packages/nodes-base/nodes/TheHiveProject/helpers/constants.ts
+++ b/packages/nodes-base/nodes/TheHiveProject/helpers/constants.ts
@@ -1,4 +1,4 @@
-import { TLP } from './interfaces';
+import { TLPs } from './interfaces';
 
 export const alertCommonFields = [
 	{
@@ -98,19 +98,19 @@ export const alertCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: true,
@@ -122,19 +122,19 @@ export const alertCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: true,
@@ -241,19 +241,19 @@ export const caseCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: false,
@@ -265,19 +265,19 @@ export const caseCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: false,
@@ -451,19 +451,19 @@ export const observableCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: false,
@@ -475,19 +475,19 @@ export const observableCommonFields = [
 		options: [
 			{
 				name: 'White',
-				value: TLP.white,
+				value: TLPs.white,
 			},
 			{
 				name: 'Green',
-				value: TLP.green,
+				value: TLPs.green,
 			},
 			{
 				name: 'Amber',
-				value: TLP.amber,
+				value: TLPs.amber,
 			},
 			{
 				name: 'Red',
-				value: TLP.red,
+				value: TLPs.red,
 			},
 		],
 		removed: false,
diff --git a/packages/nodes-base/nodes/TheHiveProject/helpers/interfaces.ts b/packages/nodes-base/nodes/TheHiveProject/helpers/interfaces.ts
index ebd508251f9..cb48c997ef6 100644
--- a/packages/nodes-base/nodes/TheHiveProject/helpers/interfaces.ts
+++ b/packages/nodes-base/nodes/TheHiveProject/helpers/interfaces.ts
@@ -1,8 +1,10 @@
-export const enum TLP {
-	white,
-	green,
-	amber,
-	red,
-}
+export const TLPs = {
+	white: 0,
+	green: 1,
+	amber: 2,
+	red: 3,
+};
+
+export type TLP = (typeof TLPs)[keyof typeof TLPs];
 
 export type QueryScope = { query: string; id?: string; restrictTo?: string };
diff --git a/packages/nodes-base/nodes/Todoist/v1/OperationHandler.ts b/packages/nodes-base/nodes/Todoist/v1/OperationHandler.ts
index d2c48a5d072..c1ac012d5c1 100644
--- a/packages/nodes-base/nodes/Todoist/v1/OperationHandler.ts
+++ b/packages/nodes-base/nodes/Todoist/v1/OperationHandler.ts
@@ -43,14 +43,16 @@ export interface Command {
 	};
 }
 
-export const enum CommandType {
-	ITEM_MOVE = 'item_move',
-	ITEM_ADD = 'item_add',
-	ITEM_UPDATE = 'item_update',
-	ITEM_REORDER = 'item_reorder',
-	ITEM_DELETE = 'item_delete',
-	ITEM_COMPLETE = 'item_complete',
-}
+export const CommandTypes = {
+	ITEM_MOVE: 'item_move',
+	ITEM_ADD: 'item_add',
+	ITEM_UPDATE: 'item_update',
+	ITEM_REORDER: 'item_reorder',
+	ITEM_DELETE: 'item_delete',
+	ITEM_COMPLETE: 'item_complete',
+} as const;
+
+export type CommandType = (typeof CommandTypes)[keyof typeof CommandTypes];
 
 async function getLabelNameFromId(ctx: Context, labelIds: number[]): Promise<string[]> {
 	const labelList = [];
@@ -263,7 +265,7 @@ export class MoveHandler implements OperationHandler {
 		const body: SyncRequest = {
 			commands: [
 				{
-					type: CommandType.ITEM_MOVE,
+					type: CommandTypes.ITEM_MOVE,
 					uuid: uuid(),
 					args: {
 						id: taskId,
@@ -339,7 +341,7 @@ export class SyncHandler implements OperationHandler {
 	}
 
 	private requiresProjectId(command: Command) {
-		return command.type === CommandType.ITEM_ADD;
+		return command.type === CommandTypes.ITEM_ADD;
 	}
 
 	private enrichTempId(command: Command, tempIdMapping: Map<string, string>, projectId: number) {
@@ -350,6 +352,6 @@ export class SyncHandler implements OperationHandler {
 	}
 
 	private requiresTempId(command: Command) {
-		return command.type === CommandType.ITEM_ADD;
+		return command.type === CommandTypes.ITEM_ADD;
 	}
 }
diff --git a/packages/nodes-base/nodes/Todoist/v2/OperationHandler.ts b/packages/nodes-base/nodes/Todoist/v2/OperationHandler.ts
index d1b3009a9fb..b5c03935104 100644
--- a/packages/nodes-base/nodes/Todoist/v2/OperationHandler.ts
+++ b/packages/nodes-base/nodes/Todoist/v2/OperationHandler.ts
@@ -44,14 +44,16 @@ export interface Command {
 	};
 }
 
-export const enum CommandType {
-	ITEM_MOVE = 'item_move',
-	ITEM_ADD = 'item_add',
-	ITEM_UPDATE = 'item_update',
-	ITEM_REORDER = 'item_reorder',
-	ITEM_DELETE = 'item_delete',
-	ITEM_COMPLETE = 'item_complete',
-}
+export const CommandTypes = {
+	ITEM_MOVE: 'item_move',
+	ITEM_ADD: 'item_add',
+	ITEM_UPDATE: 'item_update',
+	ITEM_REORDER: 'item_reorder',
+	ITEM_DELETE: 'item_delete',
+	ITEM_COMPLETE: 'item_complete',
+} as const;
+
+export type CommandType = (typeof CommandTypes)[keyof typeof CommandTypes];
 
 export class CreateHandler implements OperationHandler {
 	async handleOperation(ctx: Context, itemIndex: number): Promise<TodoistResponse> {
@@ -261,7 +263,7 @@ export class MoveHandler implements OperationHandler {
 		const body: SyncRequest = {
 			commands: [
 				{
-					type: CommandType.ITEM_MOVE,
+					type: CommandTypes.ITEM_MOVE,
 					uuid: uuid(),
 					args: {
 						id: taskId,
@@ -351,7 +353,7 @@ export class SyncHandler implements OperationHandler {
 	}
 
 	private requiresProjectId(command: Command) {
-		return command.type === CommandType.ITEM_ADD;
+		return command.type === CommandTypes.ITEM_ADD;
 	}
 
 	private enrichTempId(command: Command, tempIdMapping: Map<string, string>, projectId: number) {
@@ -362,6 +364,6 @@ export class SyncHandler implements OperationHandler {
 	}
 
 	private requiresTempId(command: Command) {
-		return command.type === CommandType.ITEM_ADD;
+		return command.type === CommandTypes.ITEM_ADD;
 	}
 }

From 743b63e97a9a96dfaf35f138a79eddaad9bb2dbb Mon Sep 17 00:00:00 2001
From: shortstacked <declan@n8n.io>
Date: Mon, 24 Mar 2025 13:02:49 +0000
Subject: [PATCH 08/33] feat: Cat 720 improve pre merge ci (#14116)

---
 .github/workflows/e2e-reusable.yml     | 37 +++++++++++++-------------
 .github/workflows/linting-reusable.yml |  4 +--
 2 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/e2e-reusable.yml b/.github/workflows/e2e-reusable.yml
index dfd8fc93363..c8247051a0e 100644
--- a/.github/workflows/e2e-reusable.yml
+++ b/.github/workflows/e2e-reusable.yml
@@ -65,11 +65,9 @@ jobs:
         run: echo "value=sha-$GITHUB_SHA-time-$(date +"%s")" >> $GITHUB_OUTPUT
 
   install:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     needs: ['prepare']
-    container:
-      image: cypress/${{ inputs.run-env }}
-      options: --user 1001
+
     steps:
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
@@ -83,10 +81,22 @@ jobs:
 
       - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
 
+      - name: Cache build artifacts
+        id: cache-build-artifacts
+        uses: actions/cache@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+        with:
+          path: |
+            /home/runner/.cache/Cypress
+            /github/home/.pnpm-store
+            ./packages/**/dist
+          key: ${{ github.sha }}:build-artifacts
+
       - name: Install dependencies
+        if: steps.cache-build-artifacts.outputs.cache-hit != 'true'
         run: pnpm install --frozen-lockfile
 
       - name: Cypress build
+        if: steps.cache-build-artifacts.outputs.cache-hit != 'true'
         uses: cypress-io/github-action@1b70233146622b69e789ccdd4f9452adc638d25a # v6.6.1
         with:
           # Disable running of tests within install job
@@ -95,23 +105,13 @@ jobs:
           build: pnpm build
 
       - name: Cypress install
+        if: steps.cache-build-artifacts.outputs.cache-hit != 'true'
         working-directory: cypress
         run: pnpm cypress:install
 
-      - name: Cache build artifacts
-        uses: actions/cache/save@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
-        with:
-          path: |
-            /github/home/.cache
-            /github/home/.pnpm-store
-            ./packages/**/dist
-          key: ${{ github.sha }}-e2e
 
   testing:
     runs-on: ubuntu-latest
-    container:
-      image: cypress/${{ inputs.run-env }}
-      options: --user 1001
     needs: ['prepare', 'install']
     strategy:
       fail-fast: false
@@ -133,13 +133,14 @@ jobs:
       - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
 
       - name: Restore cached pnpm modules
-        uses: actions/cache/restore@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
+        id: cache-build-artifacts
+        uses: actions/cache@1bd1e32a3bdc45362d1e726936510720a7c30a57 # v4.2.0
         with:
           path: |
-            /github/home/.cache
+            /home/runner/.cache/Cypress
             /github/home/.pnpm-store
             ./packages/**/dist
-          key: ${{ github.sha }}-e2e
+          key: ${{ github.sha }}:build-artifacts
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
diff --git a/.github/workflows/linting-reusable.yml b/.github/workflows/linting-reusable.yml
index 03e4257c45e..32db6d1e483 100644
--- a/.github/workflows/linting-reusable.yml
+++ b/.github/workflows/linting-reusable.yml
@@ -17,9 +17,7 @@ on:
 jobs:
   lint:
     name: Lint
-    runs-on: blacksmith-2vcpu-ubuntu-2204
-    env:
-      NODE_OPTIONS: '--max-old-space-size=4096'
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:

From b616ceb08b712ecd350114acc48a9a0f35843c0a Mon Sep 17 00:00:00 2001
From: Danny Martini <danny@n8n.io>
Date: Mon, 24 Mar 2025 14:10:24 +0100
Subject: [PATCH 09/33] feat(core): Implement API to retrieve summary metrics
 (#13927)

Co-authored-by: Guillaume Jacquart <jacquart.guillaume@gmail.com>
---
 .../__tests__/insights.controller.test.ts     | 93 ++++++++++++++++++
 .../__tests__/insights.service.test.ts        | 96 +++++++++++++++---
 .../insights/entities/__tests__/db-utils.ts   |  2 -
 .../__tests__/insights-by-period.test.ts      |  6 +-
 .../entities/__tests__/insights-raw.test.ts   |  4 +-
 .../insights/entities/insights-by-period.ts   |  4 +-
 .../insights/entities/insights-shared.ts      | 20 ++--
 .../modules/insights/insights.controller.ts   | 16 +++
 .../src/modules/insights/insights.module.ts   |  2 +
 .../src/modules/insights/insights.service.ts  | 98 ++++++++++++++++++-
 .../insights-by-period.repository.ts          | 79 +++++++++++++--
 .../cli/src/permissions.ee/global-roles.ts    |  1 +
 12 files changed, 384 insertions(+), 37 deletions(-)
 create mode 100644 packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
 create mode 100644 packages/cli/src/modules/insights/insights.controller.ts

diff --git a/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts b/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
new file mode 100644
index 00000000000..82f7696b955
--- /dev/null
+++ b/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
@@ -0,0 +1,93 @@
+import { Container } from '@n8n/di';
+
+import { mockInstance } from '@test/mocking';
+import * as testDb from '@test-integration/test-db';
+
+import { TypeToNumber } from '../entities/insights-shared';
+import { InsightsController } from '../insights.controller';
+import { InsightsByPeriodRepository } from '../repositories/insights-by-period.repository';
+
+// Initialize DB once for all tests
+beforeAll(async () => {
+	await testDb.init();
+});
+
+// Terminate DB once after all tests complete
+afterAll(async () => {
+	await testDb.terminate();
+});
+
+describe('InsightsController', () => {
+	const insightsByPeriodRepository = mockInstance(InsightsByPeriodRepository);
+	let controller: InsightsController;
+	beforeAll(async () => {
+		controller = Container.get(InsightsController);
+	});
+
+	describe('getInsightsSummary', () => {
+		it('should return default insights if no data', async () => {
+			// ARRANGE
+			insightsByPeriodRepository.getPreviousAndCurrentPeriodTypeAggregates.mockResolvedValue([]);
+
+			// ACT
+			const response = await controller.getInsightsSummary();
+
+			// ASSERT
+			expect(response).toEqual({
+				total: { deviation: 0, unit: 'count', value: 0 },
+				failed: { deviation: 0, unit: 'count', value: 0 },
+				failureRate: { deviation: 0, unit: 'ratio', value: 0 },
+				averageRunTime: { deviation: 0, unit: 'time', value: 0 },
+				timeSaved: { deviation: 0, unit: 'time', value: 0 },
+			});
+		});
+
+		it('should return the insights summary with deviation = current if insights exist only for current period', async () => {
+			// ARRANGE
+			insightsByPeriodRepository.getPreviousAndCurrentPeriodTypeAggregates.mockResolvedValue([
+				{ period: 'current', type: TypeToNumber.success, total_value: 20 },
+				{ period: 'current', type: TypeToNumber.failure, total_value: 10 },
+				{ period: 'current', type: TypeToNumber.runtime_ms, total_value: 300 },
+				{ period: 'current', type: TypeToNumber.time_saved_min, total_value: 10 },
+			]);
+
+			// ACT
+			const response = await controller.getInsightsSummary();
+
+			// ASSERT
+			expect(response).toEqual({
+				total: { deviation: 30, unit: 'count', value: 30 },
+				failed: { deviation: 10, unit: 'count', value: 10 },
+				failureRate: { deviation: 0.33, unit: 'ratio', value: 0.33 },
+				averageRunTime: { deviation: 10, unit: 'time', value: 10 },
+				timeSaved: { deviation: 10, unit: 'time', value: 10 },
+			});
+		});
+
+		it('should return the insights summary if insights exist for both periods', async () => {
+			// ARRANGE
+			insightsByPeriodRepository.getPreviousAndCurrentPeriodTypeAggregates.mockResolvedValue([
+				{ period: 'previous', type: TypeToNumber.success, total_value: 16 },
+				{ period: 'previous', type: TypeToNumber.failure, total_value: 4 },
+				{ period: 'previous', type: TypeToNumber.runtime_ms, total_value: 40 },
+				{ period: 'previous', type: TypeToNumber.time_saved_min, total_value: 5 },
+				{ period: 'current', type: TypeToNumber.success, total_value: 20 },
+				{ period: 'current', type: TypeToNumber.failure, total_value: 10 },
+				{ period: 'current', type: TypeToNumber.runtime_ms, total_value: 300 },
+				{ period: 'current', type: TypeToNumber.time_saved_min, total_value: 10 },
+			]);
+
+			// ACT
+			const response = await controller.getInsightsSummary();
+
+			// ASSERT
+			expect(response).toEqual({
+				total: { deviation: 10, unit: 'count', value: 30 },
+				failed: { deviation: 6, unit: 'count', value: 10 },
+				failureRate: { deviation: 0.33 - 0.2, unit: 'ratio', value: 0.33 },
+				averageRunTime: { deviation: 300 / 30 - 40 / 20, unit: 'time', value: 10 },
+				timeSaved: { deviation: 5, unit: 'time', value: 10 },
+			});
+		});
+	});
+});
diff --git a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
index f6010511d6c..36bb41c5c92 100644
--- a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
+++ b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
@@ -7,7 +7,7 @@ import type { ExecutionStatus, IRun, WorkflowExecuteMode } from 'n8n-workflow';
 import type { Project } from '@/databases/entities/project';
 import type { WorkflowEntity } from '@/databases/entities/workflow-entity';
 import type { IWorkflowDb } from '@/interfaces';
-import type { TypeUnits } from '@/modules/insights/entities/insights-shared';
+import type { TypeUnit } from '@/modules/insights/entities/insights-shared';
 import { InsightsMetadataRepository } from '@/modules/insights/repositories/insights-metadata.repository';
 import { InsightsRawRepository } from '@/modules/insights/repositories/insights-raw.repository';
 import { createTeamProject } from '@test-integration/db/projects';
@@ -38,7 +38,6 @@ async function truncateAll() {
 
 // Initialize DB once for all tests
 beforeAll(async () => {
-	jest.useFakeTimers();
 	await testDb.init();
 });
 
@@ -74,7 +73,7 @@ describe('workflowExecuteAfterHandler', () => {
 		);
 	});
 
-	test.each<{ status: ExecutionStatus; type: TypeUnits }>([
+	test.each<{ status: ExecutionStatus; type: TypeUnit }>([
 		{ status: 'success', type: 'success' },
 		{ status: 'error', type: 'failure' },
 		{ status: 'crashed', type: 'failure' },
@@ -524,20 +523,28 @@ describe('compaction', () => {
 			const accumulatedValues = allCompacted.reduce((acc, event) => acc + event.value, 0);
 			expect(accumulatedValues).toBe(batchSize);
 		});
+	});
 
+	describe('compactionSchedule', () => {
 		test('compaction is running on schedule', async () => {
-			// ARRANGE
-			const insightsService = Container.get(InsightsService);
+			jest.useFakeTimers();
+			try {
+				// ARRANGE
+				const insightsService = Container.get(InsightsService);
+				insightsService.initializeCompaction();
 
-			// spy on the compactInsights method to check if it's called
-			insightsService.compactInsights = jest.fn();
+				// spy on the compactInsights method to check if it's called
+				insightsService.compactInsights = jest.fn();
 
-			// ACT
-			// advance by 1 hour and 1 minute
-			jest.advanceTimersByTime(1000 * 60 * 60);
+				// ACT
+				// advance by 1 hour and 1 minute
+				jest.advanceTimersByTime(1000 * 60 * 61);
 
-			// ASSERT
-			expect(insightsService.compactInsights).toHaveBeenCalledTimes(1);
+				// ASSERT
+				expect(insightsService.compactInsights).toHaveBeenCalledTimes(1);
+			} finally {
+				jest.useRealTimers();
+			}
 		});
 	});
 
@@ -602,3 +609,68 @@ describe('compaction', () => {
 		});
 	});
 });
+
+describe('getInsightsSummary', () => {
+	let insightsService: InsightsService;
+	beforeAll(async () => {
+		insightsService = Container.get(InsightsService);
+	});
+
+	let project: Project;
+	let workflow: IWorkflowDb & WorkflowEntity;
+
+	beforeEach(async () => {
+		await truncateAll();
+
+		project = await createTeamProject();
+		workflow = await createWorkflow({}, project);
+	});
+
+	test('compacted data are summarized correctly', async () => {
+		// ARRANGE
+		// last 7 days
+		await createCompactedInsightsEvent(workflow, {
+			type: 'success',
+			value: 1,
+			periodUnit: 'day',
+			periodStart: DateTime.utc(),
+		});
+		await createCompactedInsightsEvent(workflow, {
+			type: 'success',
+			value: 1,
+			periodUnit: 'day',
+			periodStart: DateTime.utc().minus({ day: 2 }),
+		});
+		await createCompactedInsightsEvent(workflow, {
+			type: 'failure',
+			value: 2,
+			periodUnit: 'day',
+			periodStart: DateTime.utc(),
+		});
+		// last 14 days
+		await createCompactedInsightsEvent(workflow, {
+			type: 'success',
+			value: 1,
+			periodUnit: 'day',
+			periodStart: DateTime.utc().minus({ days: 10 }),
+		});
+		await createCompactedInsightsEvent(workflow, {
+			type: 'runtime_ms',
+			value: 123,
+			periodUnit: 'day',
+			periodStart: DateTime.utc().minus({ days: 10 }),
+		});
+
+		// ACT
+		const summary = await insightsService.getInsightsSummary();
+
+		// ASSERT
+		expect(summary).toEqual({
+			averageRunTime: { deviation: -123, unit: 'time', value: 0 },
+			failed: { deviation: 2, unit: 'count', value: 2 },
+			failureRate: { deviation: 0.5, unit: 'ratio', value: 0.5 },
+			timeSaved: { deviation: 0, unit: 'time', value: 0 },
+			total: { deviation: 3, unit: 'count', value: 4 },
+		});
+	});
+});
diff --git a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts b/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
index 38a06eb800b..84e1e203c20 100644
--- a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
+++ b/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
@@ -1,4 +1,3 @@
-import { GlobalConfig } from '@n8n/config';
 import { Container } from '@n8n/di';
 import type { DateTime } from 'luxon';
 import type { IWorkflowBase } from 'n8n-workflow';
@@ -19,7 +18,6 @@ async function getWorkflowSharing(workflow: IWorkflowBase) {
 		relations: { project: true },
 	});
 }
-export const { type: dbType } = Container.get(GlobalConfig).database;
 
 export async function createMetadata(workflow: WorkflowEntity) {
 	const insightsMetadataRepository = Container.get(InsightsMetadataRepository);
diff --git a/packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts b/packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts
index 33af07ad561..3b5a05f7e79 100644
--- a/packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts
+++ b/packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts
@@ -4,7 +4,7 @@ import * as testDb from '@test-integration/test-db';
 
 import { InsightsRawRepository } from '../../repositories/insights-raw.repository';
 import { InsightsByPeriod } from '../insights-by-period';
-import type { PeriodUnits, TypeUnits } from '../insights-shared';
+import type { PeriodUnit, TypeUnit } from '../insights-shared';
 
 let insightsRawRepository: InsightsRawRepository;
 
@@ -22,7 +22,7 @@ afterAll(async () => {
 });
 
 describe('Insights By Period', () => {
-	test.each(['time_saved_min', 'runtime_ms', 'failure', 'success'] satisfies TypeUnits[])(
+	test.each(['time_saved_min', 'runtime_ms', 'failure', 'success'] satisfies TypeUnit[])(
 		'`%s` can be serialized and deserialized correctly',
 		(typeUnit) => {
 			// ARRANGE
@@ -35,7 +35,7 @@ describe('Insights By Period', () => {
 			expect(insightByPeriod.type).toBe(typeUnit);
 		},
 	);
-	test.each(['hour', 'day', 'week'] satisfies PeriodUnits[])(
+	test.each(['hour', 'day', 'week'] satisfies PeriodUnit[])(
 		'`%s` can be serialized and deserialized correctly',
 		(periodUnit) => {
 			// ARRANGE
diff --git a/packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts b/packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts
index 848e0870e0d..fd29a094150 100644
--- a/packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts
+++ b/packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts
@@ -8,7 +8,7 @@ import * as testDb from '@test-integration/test-db';
 import { createMetadata, createRawInsightsEvent } from './db-utils';
 import { InsightsRawRepository } from '../../repositories/insights-raw.repository';
 import { InsightsRaw } from '../insights-raw';
-import type { TypeUnits } from '../insights-shared';
+import type { TypeUnit } from '../insights-shared';
 
 let insightsRawRepository: InsightsRawRepository;
 
@@ -26,7 +26,7 @@ afterAll(async () => {
 });
 
 describe('Insights Raw Entity', () => {
-	test.each(['success', 'failure', 'runtime_ms', 'time_saved_min'] satisfies TypeUnits[])(
+	test.each(['success', 'failure', 'runtime_ms', 'time_saved_min'] satisfies TypeUnit[])(
 		'`%s` can be serialized and deserialized correctly',
 		(typeUnit) => {
 			// ARRANGE
diff --git a/packages/cli/src/modules/insights/entities/insights-by-period.ts b/packages/cli/src/modules/insights/entities/insights-by-period.ts
index b2e532be33b..34b7abb15b8 100644
--- a/packages/cli/src/modules/insights/entities/insights-by-period.ts
+++ b/packages/cli/src/modules/insights/entities/insights-by-period.ts
@@ -1,7 +1,7 @@
 import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from '@n8n/typeorm';
 import { UnexpectedError } from 'n8n-workflow';
 
-import type { PeriodUnits } from './insights-shared';
+import type { PeriodUnit } from './insights-shared';
 import {
 	isValidPeriodNumber,
 	isValidTypeNumber,
@@ -53,7 +53,7 @@ export class InsightsByPeriod extends BaseEntity {
 		return NumberToPeriodUnit[this.periodUnit_];
 	}
 
-	set periodUnit(value: PeriodUnits) {
+	set periodUnit(value: PeriodUnit) {
 		this.periodUnit_ = PeriodUnitToNumber[value];
 	}
 
diff --git a/packages/cli/src/modules/insights/entities/insights-shared.ts b/packages/cli/src/modules/insights/entities/insights-shared.ts
index 14260dd69e5..3e12622e850 100644
--- a/packages/cli/src/modules/insights/entities/insights-shared.ts
+++ b/packages/cli/src/modules/insights/entities/insights-shared.ts
@@ -11,14 +11,16 @@ export const PeriodUnitToNumber = {
 	day: 1,
 	week: 2,
 } as const;
-export type PeriodUnits = keyof typeof PeriodUnitToNumber;
-export type PeriodUnitNumbers = (typeof PeriodUnitToNumber)[PeriodUnits];
+
+export type PeriodUnit = keyof typeof PeriodUnitToNumber;
+
+export type PeriodUnitNumber = (typeof PeriodUnitToNumber)[PeriodUnit];
 export const NumberToPeriodUnit = Object.entries(PeriodUnitToNumber).reduce(
-	(acc, [key, value]: [PeriodUnits, PeriodUnitNumbers]) => {
+	(acc, [key, value]: [PeriodUnit, PeriodUnitNumber]) => {
 		acc[value] = key;
 		return acc;
 	},
-	{} as Record<PeriodUnitNumbers, PeriodUnits>,
+	{} as Record<PeriodUnitNumber, PeriodUnit>,
 );
 export function isValidPeriodNumber(value: number) {
 	return isValid(value, NumberToPeriodUnit);
@@ -31,14 +33,16 @@ export const TypeToNumber = {
 	success: 2,
 	failure: 3,
 } as const;
-export type TypeUnits = keyof typeof TypeToNumber;
-export type TypeUnitNumbers = (typeof TypeToNumber)[TypeUnits];
+
+export type TypeUnit = keyof typeof TypeToNumber;
+
+export type TypeUnitNumber = (typeof TypeToNumber)[TypeUnit];
 export const NumberToType = Object.entries(TypeToNumber).reduce(
-	(acc, [key, value]: [TypeUnits, TypeUnitNumbers]) => {
+	(acc, [key, value]: [TypeUnit, TypeUnitNumber]) => {
 		acc[value] = key;
 		return acc;
 	},
-	{} as Record<TypeUnitNumbers, TypeUnits>,
+	{} as Record<TypeUnitNumber, TypeUnit>,
 );
 
 export function isValidTypeNumber(value: number) {
diff --git a/packages/cli/src/modules/insights/insights.controller.ts b/packages/cli/src/modules/insights/insights.controller.ts
new file mode 100644
index 00000000000..95cfa728363
--- /dev/null
+++ b/packages/cli/src/modules/insights/insights.controller.ts
@@ -0,0 +1,16 @@
+import type { InsightsSummary } from '@n8n/api-types';
+
+import { Get, GlobalScope, RestController } from '@/decorators';
+
+import { InsightsService } from './insights.service';
+
+@RestController('/insights')
+export class InsightsController {
+	constructor(private readonly insightsService: InsightsService) {}
+
+	@Get('/summary')
+	@GlobalScope('insights:list')
+	async getInsightsSummary(): Promise<InsightsSummary> {
+		return await this.insightsService.getInsightsSummary();
+	}
+}
diff --git a/packages/cli/src/modules/insights/insights.module.ts b/packages/cli/src/modules/insights/insights.module.ts
index 0c7920cf3d4..85d638b466e 100644
--- a/packages/cli/src/modules/insights/insights.module.ts
+++ b/packages/cli/src/modules/insights/insights.module.ts
@@ -6,6 +6,8 @@ import { N8nModule } from '@/decorators/module';
 
 import { InsightsService } from './insights.service';
 
+import './insights.controller';
+
 @N8nModule()
 export class InsightsModule implements BaseN8nModule {
 	constructor(
diff --git a/packages/cli/src/modules/insights/insights.service.ts b/packages/cli/src/modules/insights/insights.service.ts
index a2d86e262b7..0462efd3ca6 100644
--- a/packages/cli/src/modules/insights/insights.service.ts
+++ b/packages/cli/src/modules/insights/insights.service.ts
@@ -1,7 +1,12 @@
+import type { InsightsSummary } from '@n8n/api-types';
 import { Container, Service } from '@n8n/di';
 import type { ExecutionLifecycleHooks } from 'n8n-core';
-import type { ExecutionStatus, IRun, WorkflowExecuteMode } from 'n8n-workflow';
-import { UnexpectedError } from 'n8n-workflow';
+import {
+	UnexpectedError,
+	type ExecutionStatus,
+	type IRun,
+	type WorkflowExecuteMode,
+} from 'n8n-workflow';
 
 import { SharedWorkflow } from '@/databases/entities/shared-workflow';
 import { SharedWorkflowRepository } from '@/databases/repositories/shared-workflow.repository';
@@ -9,6 +14,8 @@ import { OnShutdown } from '@/decorators/on-shutdown';
 import { InsightsMetadata } from '@/modules/insights/entities/insights-metadata';
 import { InsightsRaw } from '@/modules/insights/entities/insights-raw';
 
+import type { TypeUnit } from './entities/insights-shared';
+import { NumberToType } from './entities/insights-shared';
 import { InsightsConfig } from './insights.config';
 import { InsightsByPeriodRepository } from './repositories/insights-by-period.repository';
 import { InsightsRawRepository } from './repositories/insights-raw.repository';
@@ -49,6 +56,13 @@ export class InsightsService {
 		private readonly insightsByPeriodRepository: InsightsByPeriodRepository,
 		private readonly insightsRawRepository: InsightsRawRepository,
 	) {
+		this.initializeCompaction();
+	}
+
+	initializeCompaction() {
+		if (this.compactInsightsTimer !== undefined) {
+			clearInterval(this.compactInsightsTimer);
+		}
 		const intervalMilliseconds = config.compactionIntervalMinutes * 60 * 1000;
 		this.compactInsightsTimer = setInterval(
 			async () => await this.compactInsights(),
@@ -178,4 +192,84 @@ export class InsightsService {
 			periodUnit: 'day',
 		});
 	}
+
+	// TODO: add return type once rebased on master and InsightsSummary is
+	// available
+	async getInsightsSummary(): Promise<InsightsSummary> {
+		const rows = await this.insightsByPeriodRepository.getPreviousAndCurrentPeriodTypeAggregates();
+
+		// Initialize data structures for both periods
+		const data = {
+			current: { byType: {} as Record<TypeUnit, number> },
+			previous: { byType: {} as Record<TypeUnit, number> },
+		};
+
+		// Organize data by period and type
+		rows.forEach((row) => {
+			const { period, type, total_value } = row;
+			if (!data[period]) return;
+
+			data[period].byType[NumberToType[type]] = total_value ? Number(total_value) : 0;
+		});
+
+		// Get values with defaults for missing data
+		const getValueByType = (period: 'current' | 'previous', type: TypeUnit) =>
+			data[period]?.byType[type] ?? 0;
+
+		// Calculate metrics
+		const currentSuccesses = getValueByType('current', 'success');
+		const currentFailures = getValueByType('current', 'failure');
+		const previousSuccesses = getValueByType('previous', 'success');
+		const previousFailures = getValueByType('previous', 'failure');
+
+		const currentTotal = currentSuccesses + currentFailures;
+		const previousTotal = previousSuccesses + previousFailures;
+
+		const currentFailureRate =
+			currentTotal > 0 ? Math.round((currentFailures / currentTotal) * 100) / 100 : 0;
+		const previousFailureRate =
+			previousTotal > 0 ? Math.round((previousFailures / previousTotal) * 100) / 100 : 0;
+
+		const currentTotalRuntime = getValueByType('current', 'runtime_ms') ?? 0;
+		const previousTotalRuntime = getValueByType('previous', 'runtime_ms') ?? 0;
+
+		const currentAvgRuntime =
+			currentTotal > 0 ? Math.round((currentTotalRuntime / currentTotal) * 100) / 100 : 0;
+		const previousAvgRuntime =
+			previousTotal > 0 ? Math.round((previousTotalRuntime / previousTotal) * 100) / 100 : 0;
+
+		const currentTimeSaved = getValueByType('current', 'time_saved_min');
+		const previousTimeSaved = getValueByType('previous', 'time_saved_min');
+
+		// Return the formatted result
+		const result: InsightsSummary = {
+			averageRunTime: {
+				value: currentAvgRuntime,
+				unit: 'time',
+				deviation: currentAvgRuntime - previousAvgRuntime,
+			},
+			failed: {
+				value: currentFailures,
+				unit: 'count',
+				deviation: currentFailures - previousFailures,
+			},
+			failureRate: {
+				value: currentFailureRate,
+				unit: 'ratio',
+				deviation: currentFailureRate - previousFailureRate,
+			},
+			timeSaved: {
+				value: currentTimeSaved,
+				unit: 'time',
+				deviation: currentTimeSaved - previousTimeSaved,
+			},
+			total: {
+				value: currentTotal,
+				unit: 'count',
+				deviation: currentTotal - previousTotal,
+			},
+		};
+
+		return result;
+	}
 }
diff --git a/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts b/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
index e8a911f0564..c4caa960f41 100644
--- a/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
+++ b/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
@@ -1,15 +1,26 @@
 import { GlobalConfig } from '@n8n/config';
 import { Container, Service } from '@n8n/di';
 import { DataSource, Repository } from '@n8n/typeorm';
+import { z } from 'zod';
 
 import { sql } from '@/utils/sql';
 
 import { InsightsByPeriod } from '../entities/insights-by-period';
-import type { PeriodUnits } from '../entities/insights-shared';
+import type { PeriodUnit } from '../entities/insights-shared';
 import { PeriodUnitToNumber } from '../entities/insights-shared';
 
 const dbType = Container.get(GlobalConfig).database.type;
 
+const summaryParser = z
+	.object({
+		period: z.enum(['previous', 'current']),
+		type: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]),
+
+		// depending on db engine, sum(value) can be a number or a string - because of big numbers
+		total_value: z.union([z.number(), z.string()]),
+	})
+	.array();
+
 @Service()
 export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 	constructor(dataSource: DataSource) {
@@ -20,7 +31,7 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 		return this.manager.connection.driver.escape(fieldName);
 	}
 
-	private getPeriodFilterExpr(periodUnit: PeriodUnits) {
+	private getPeriodFilterExpr(periodUnit: PeriodUnit) {
 		const daysAgo = periodUnit === 'day' ? 90 : 180;
 		// Database-specific period start expression to filter out data to compact by days matching the periodUnit
 		let periodStartExpr = `date('now', '-${daysAgo} days')`;
@@ -33,7 +44,7 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 		return periodStartExpr;
 	}
 
-	private getPeriodStartExpr(periodUnit: PeriodUnits) {
+	private getPeriodStartExpr(periodUnit: PeriodUnit) {
 		// Database-specific period start expression to truncate timestamp to the periodUnit
 		// SQLite by default
 		let periodStartExpr = `strftime('%Y-%m-%d ${periodUnit === 'hour' ? '%H' : '00'}:00:00.000', periodStart)`;
@@ -49,7 +60,7 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 		return periodStartExpr;
 	}
 
-	getPeriodInsightsBatchQuery(periodUnit: PeriodUnits, compactionBatchSize: number) {
+	getPeriodInsightsBatchQuery(periodUnit: PeriodUnit, compactionBatchSize: number) {
 		// Build the query to gather period insights data for the batch
 		const batchQuery = this.createQueryBuilder()
 			.select(
@@ -64,7 +75,7 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 		return batchQuery;
 	}
 
-	getAggregationQuery(periodUnit: PeriodUnits) {
+	getAggregationQuery(periodUnit: PeriodUnit) {
 		// Get the start period expression depending on the period unit and database type
 		const periodStartExpr = this.getPeriodStartExpr(periodUnit);
 
@@ -91,7 +102,7 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 	}: {
 		sourceBatchQuery: string;
 		sourceTableName?: string;
-		periodUnit: PeriodUnits;
+		periodUnit: PeriodUnit;
 	}): Promise<number> {
 		// Create temp table that only exists in this transaction for rows to compact
 		const getBatchAndStoreInTemporaryTable = sql`
@@ -161,4 +172,60 @@ export class InsightsByPeriodRepository extends Repository<InsightsByPeriod> {
 
 		return result;
 	}
+
+	async getPreviousAndCurrentPeriodTypeAggregates(): Promise<
+		Array<{
+			period: 'previous' | 'current';
+			type: 0 | 1 | 2 | 3;
+			total_value: string | number;
+		}>
+	> {
+		const cte =
+			dbType === 'sqlite'
+				? sql`
+						SELECT
+							datetime('now', '-7 days') AS current_start,
+							datetime('now') AS current_end,
+							datetime('now', '-14 days') AS previous_start
+					`
+				: dbType === 'postgresdb'
+					? sql`
+								SELECT
+								(CURRENT_DATE - INTERVAL '7 days')::timestamptz AS current_start,
+								CURRENT_DATE::timestamptz AS current_end,
+								(CURRENT_DATE - INTERVAL '14 days')::timestamptz AS previous_start
+							`
+					: sql`
+								SELECT
+									DATE_SUB(CURDATE(), INTERVAL 7 DAY) AS current_start,
+									CURDATE() AS current_end,
+									DATE_SUB(CURDATE(), INTERVAL 14 DAY) AS previous_start
+							`;
+
+		const rawRows = await this.createQueryBuilder('insights')
+			.addCommonTableExpression(cte, 'date_ranges')
+			.select(
+				sql`
+						CASE
+							WHEN insights.periodStart >= date_ranges.current_start AND insights.periodStart <= date_ranges.current_end
+							THEN 'current'
+							ELSE 'previous'
+						END
+					`,
+				'period',
+			)
+			.addSelect('insights.type', 'type')
+			.addSelect('SUM(value)', 'total_value')
+			// Use a cross join with the CTE
+			.innerJoin('date_ranges', 'date_ranges', '1=1')
+			// Filter to only include data from the last 14 days
+			.where('insights.periodStart >= date_ranges.previous_start')
+			.andWhere('insights.periodStart <= date_ranges.current_end')
+			// Group by both period and type
+			.groupBy('period')
+			.addGroupBy('insights.type')
+			.getRawMany();
+
+		return summaryParser.parse(rawRows);
+	}
 }
diff --git a/packages/cli/src/permissions.ee/global-roles.ts b/packages/cli/src/permissions.ee/global-roles.ts
index 7ea1b575da9..e15153ffba0 100644
--- a/packages/cli/src/permissions.ee/global-roles.ts
+++ b/packages/cli/src/permissions.ee/global-roles.ts
@@ -75,6 +75,7 @@ export const GLOBAL_OWNER_SCOPES: Scope[] = [
 	'project:read',
 	'project:update',
 	'project:delete',
+	'insights:list',
 ];
 
 export const GLOBAL_ADMIN_SCOPES = GLOBAL_OWNER_SCOPES.concat();

From 22ddf1b644dcddfff3a97bd7953823f63ab7c41a Mon Sep 17 00:00:00 2001
From: Elias Meire <elias@meire.dev>
Date: Mon, 24 Mar 2025 14:40:48 +0100
Subject: [PATCH 10/33] feat(editor): Improve schema view empty state when node
 has binary data (#14044)

---
 .../src/components/VirtualSchema.test.ts      | 110 +++++++++++-------
 .../src/components/VirtualSchema.vue          |  24 ++--
 .../src/composables/useDataSchema.ts          |  14 ++-
 .../src/plugins/i18n/locales/en.json          |   1 +
 4 files changed, 87 insertions(+), 62 deletions(-)

diff --git a/packages/frontend/editor-ui/src/components/VirtualSchema.test.ts b/packages/frontend/editor-ui/src/components/VirtualSchema.test.ts
index fa1f9490c86..3ac4bd83fcb 100644
--- a/packages/frontend/editor-ui/src/components/VirtualSchema.test.ts
+++ b/packages/frontend/editor-ui/src/components/VirtualSchema.test.ts
@@ -1,33 +1,33 @@
-import { createComponentRenderer } from '@/__tests__/render';
-import VirtualSchema from '@/components/VirtualSchema.vue';
-import { useWorkflowsStore } from '@/stores/workflows.store';
-import { userEvent } from '@testing-library/user-event';
-import { cleanup, waitFor } from '@testing-library/vue';
-import { createPinia, setActivePinia } from 'pinia';
 import {
 	createTestNode,
 	defaultNodeDescriptions,
 	mockNodeTypeDescription,
 } from '@/__tests__/mocks';
-import { IF_NODE_TYPE, SET_NODE_TYPE, MANUAL_TRIGGER_NODE_TYPE } from '@/constants';
-import { useNodeTypesStore } from '@/stores/nodeTypes.store';
-import { mock } from 'vitest-mock-extended';
+import { createComponentRenderer } from '@/__tests__/render';
+import VirtualSchema from '@/components/VirtualSchema.vue';
+import * as nodeHelpers from '@/composables/useNodeHelpers';
+import { useTelemetry } from '@/composables/useTelemetry';
+import { IF_NODE_TYPE, MANUAL_TRIGGER_NODE_TYPE, SET_NODE_TYPE } from '@/constants';
 import type { IWorkflowDb } from '@/Interface';
+import { useNDVStore } from '@/stores/ndv.store';
+import { useNodeTypesStore } from '@/stores/nodeTypes.store';
+import { useWorkflowsStore } from '@/stores/workflows.store';
+import { createTestingPinia } from '@pinia/testing';
+import { fireEvent } from '@testing-library/dom';
+import { userEvent } from '@testing-library/user-event';
+import { cleanup, waitFor } from '@testing-library/vue';
 import {
 	createResultOk,
 	NodeConnectionTypes,
-	type IDataObject,
+	type IBinaryData,
 	type INodeExecutionData,
 } from 'n8n-workflow';
-import * as nodeHelpers from '@/composables/useNodeHelpers';
-import * as workflowHelpers from '@/composables/useWorkflowHelpers';
-import { useNDVStore } from '@/stores/ndv.store';
-import { fireEvent } from '@testing-library/dom';
-import { useTelemetry } from '@/composables/useTelemetry';
-import { useSchemaPreviewStore } from '../stores/schemaPreview.store';
-import { usePostHog } from '../stores/posthog.store';
-import { useSettingsStore } from '../stores/settings.store';
+import { setActivePinia } from 'pinia';
+import { mock } from 'vitest-mock-extended';
 import { defaultSettings } from '../__tests__/defaults';
+import { usePostHog } from '../stores/posthog.store';
+import { useSchemaPreviewStore } from '../stores/schemaPreview.store';
+import { useSettingsStore } from '../stores/settings.store';
 
 const mockNode1 = createTestNode({
 	name: 'Manual Trigger',
@@ -65,6 +65,14 @@ const aiTool = createTestNode({
 	disabled: false,
 });
 
+const nodeWithCredential = createTestNode({
+	name: 'Notion',
+	type: 'n8n-nodes-base.notion',
+	typeVersion: 1,
+	credentials: { notionApi: { id: 'testId', name: 'testName' } },
+	disabled: false,
+});
+
 const unknownNodeType = createTestNode({
 	name: 'Unknown Node Type',
 	type: 'unknown',
@@ -76,15 +84,23 @@ const defaultNodes = [
 ];
 
 async function setupStore() {
-	const workflow = mock<IWorkflowDb>({
+	const workflow = {
 		id: '123',
 		name: 'Test Workflow',
 		connections: {},
 		active: true,
-		nodes: [mockNode1, mockNode2, disabledNode, ifNode, aiTool, unknownNodeType],
-	});
+		nodes: [
+			mockNode1,
+			mockNode2,
+			disabledNode,
+			ifNode,
+			aiTool,
+			unknownNodeType,
+			nodeWithCredential,
+		],
+	};
 
-	const pinia = createPinia();
+	const pinia = createTestingPinia({ stubActions: false });
 	setActivePinia(pinia);
 
 	const workflowsStore = useWorkflowsStore();
@@ -102,20 +118,24 @@ async function setupStore() {
 			name: IF_NODE_TYPE,
 			outputs: [NodeConnectionTypes.Main, NodeConnectionTypes.Main],
 		}),
+		mockNodeTypeDescription({
+			name: 'n8n-nodes-base.notion',
+			outputs: [NodeConnectionTypes.Main],
+		}),
 	]);
-	workflowsStore.workflow = workflow;
+	workflowsStore.workflow = workflow as IWorkflowDb;
 
 	return pinia;
 }
 
-function mockNodeOutputData(nodeName: string, data: IDataObject[], outputIndex = 0) {
+function mockNodeOutputData(nodeName: string, data: INodeExecutionData[], outputIndex = 0) {
 	const originalNodeHelpers = nodeHelpers.useNodeHelpers();
 	vi.spyOn(nodeHelpers, 'useNodeHelpers').mockImplementation(() => {
 		return {
 			...originalNodeHelpers,
 			getNodeInputData: vi.fn((node, _, output) => {
 				if (node.name === nodeName && output === outputIndex) {
-					return data.map((json) => ({ json }));
+					return data;
 				}
 				return [];
 			}),
@@ -146,7 +166,7 @@ describe('VirtualSchema.vue', () => {
 
 	beforeEach(async () => {
 		cleanup();
-		vi.spyOn(workflowHelpers, 'resolveParameter').mockReturnValue(123);
+		vi.resetAllMocks();
 		vi.setSystemTime('2025-01-01');
 		renderComponent = createComponentRenderer(VirtualSchema, {
 			global: {
@@ -183,6 +203,20 @@ describe('VirtualSchema.vue', () => {
 		expect(getAllByText("No fields - item(s) exist, but they're empty").length).toBe(1);
 	});
 
+	it('renders schema for empty data with binary', async () => {
+		mockNodeOutputData(mockNode1.name, [{ json: {}, binary: { data: mock<IBinaryData>() } }]);
+
+		const { getByText } = renderComponent({
+			props: { nodes: [{ name: mockNode1.name, indicies: [], depth: 1 }] },
+		});
+
+		await waitFor(() =>
+			expect(
+				getByText("Only binary data exists. View it using the 'Binary' tab"),
+			).toBeInTheDocument(),
+		);
+	});
+
 	it('renders schema for data', async () => {
 		useWorkflowsStore().pinData({
 			node: mockNode1,
@@ -307,10 +341,7 @@ describe('VirtualSchema.vue', () => {
 	it('renders schema for correct output branch', async () => {
 		mockNodeOutputData(
 			'If',
-			[
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Jane' },
-			],
+			[{ json: { id: 1, name: 'John' } }, { json: { id: 2, name: 'Jane' } }],
 			1,
 		);
 		const { getAllByTestId } = renderComponent({
@@ -330,10 +361,7 @@ describe('VirtualSchema.vue', () => {
 	it('renders previous nodes schema for AI tools', async () => {
 		mockNodeOutputData(
 			'If',
-			[
-				{ id: 1, name: 'John' },
-				{ id: 2, name: 'Jane' },
-			],
+			[{ json: { id: 1, name: 'John' } }, { json: { id: 2, name: 'Jane' } }],
 			0,
 		);
 		const { getAllByTestId } = renderComponent({
@@ -481,14 +509,6 @@ describe('VirtualSchema.vue', () => {
 		});
 
 		it('should track data pill drag and drop for schema preview', async () => {
-			useWorkflowsStore().pinData({
-				node: {
-					...mockNode2,
-					credentials: { myCredential: { id: 'myCredential', name: 'myCredential' } },
-				},
-				data: [],
-			});
-
 			const telemetry = useTelemetry();
 			const trackSpy = vi.spyOn(telemetry, 'track');
 			const posthogStore = usePostHog();
@@ -513,7 +533,7 @@ describe('VirtualSchema.vue', () => {
 
 			const { getAllByTestId } = renderComponent({
 				props: {
-					nodes: [{ name: mockNode2.name, indicies: [], depth: 1 }],
+					nodes: [{ name: nodeWithCredential.name, indicies: [], depth: 1 }],
 				},
 			});
 
@@ -639,4 +659,8 @@ describe('VirtualSchema.vue', () => {
 
 		expect(container).toMatchSnapshot();
 	});
+
+	it('should do something', () => {
+		expect(true).toBe(true);
+	});
 });
diff --git a/packages/frontend/editor-ui/src/components/VirtualSchema.vue b/packages/frontend/editor-ui/src/components/VirtualSchema.vue
index bc8017adfd5..ea5c16584e4 100644
--- a/packages/frontend/editor-ui/src/components/VirtualSchema.vue
+++ b/packages/frontend/editor-ui/src/components/VirtualSchema.vue
@@ -105,21 +105,11 @@ const toggleNodeAndScrollTop = (id: string) => {
 const getNodeSchema = async (fullNode: INodeUi, connectedNode: IConnectedNode) => {
 	const pinData = workflowsStore.pinDataByNodeName(connectedNode.name);
 	const connectedOutputIndexes = connectedNode.indicies.length > 0 ? connectedNode.indicies : [0];
-	const data =
-		pinData ??
-		connectedOutputIndexes
-			.map((outputIndex) =>
-				executionDataToJson(
-					getNodeInputData(
-						fullNode,
-						props.runIndex,
-						outputIndex,
-						props.paneType,
-						props.connectionType,
-					),
-				),
-			)
-			.flat();
+	const nodeData = connectedOutputIndexes.map((outputIndex) =>
+		getNodeInputData(fullNode, props.runIndex, outputIndex, props.paneType, props.connectionType),
+	);
+	const hasBinary = nodeData.flat().some((data) => !isEmpty(data.binary));
+	const data = pinData ?? nodeData.map(executionDataToJson).flat();
 
 	let schema = getSchemaForExecutionData(data);
 	let preview = false;
@@ -137,6 +127,7 @@ const getNodeSchema = async (fullNode: INodeUi, connectedNode: IConnectedNode) =
 		connectedOutputIndexes,
 		itemsCount: data.length,
 		preview,
+		hasBinary,
 	};
 };
 
@@ -251,7 +242,7 @@ const nodesSchemas = asyncComputed<SchemaNode[]>(async () => {
 		const nodeType = nodeTypesStore.getNodeType(fullNode.type, fullNode.typeVersion);
 		if (!nodeType) continue;
 
-		const { schema, connectedOutputIndexes, itemsCount, preview } = await getNodeSchema(
+		const { schema, connectedOutputIndexes, itemsCount, preview, hasBinary } = await getNodeSchema(
 			fullNode,
 			node,
 		);
@@ -268,6 +259,7 @@ const nodesSchemas = asyncComputed<SchemaNode[]>(async () => {
 			nodeType,
 			schema: filteredSchema,
 			preview,
+			hasBinary,
 		});
 	}
 
diff --git a/packages/frontend/editor-ui/src/composables/useDataSchema.ts b/packages/frontend/editor-ui/src/composables/useDataSchema.ts
index 44197c18f2d..32420280a3c 100644
--- a/packages/frontend/editor-ui/src/composables/useDataSchema.ts
+++ b/packages/frontend/editor-ui/src/composables/useDataSchema.ts
@@ -233,6 +233,7 @@ export type SchemaNode = {
 	itemsCount: number;
 	schema: Schema;
 	preview: boolean;
+	hasBinary: boolean;
 };
 
 export type RenderItem = {
@@ -295,10 +296,12 @@ const icons = {
 
 const getIconBySchemaType = (type: Schema['type']): string => icons[type];
 
-const emptyItem = (): RenderItem => ({
+const emptyItem = (
+	message = useI18n().baseText('dataMapping.schemaView.emptyData'),
+): RenderItem => ({
 	id: `empty-${window.crypto.randomUUID()}`,
 	icon: '',
-	value: useI18n().baseText('dataMapping.schemaView.emptyData'),
+	value: message,
 	type: 'item',
 });
 
@@ -457,7 +460,12 @@ export const useFlattenSchema = () => {
 			}
 
 			if (isDataEmpty(item.schema)) {
-				acc.push(emptyItem());
+				const message = useI18n().baseText(
+					item.hasBinary
+						? 'dataMapping.schemaView.emptyDataWithBinary'
+						: 'dataMapping.schemaView.emptyData',
+				);
+				acc.push(emptyItem(message));
 				return acc;
 			}
 
diff --git a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
index bf512ebf806..2a619732437 100644
--- a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
+++ b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
@@ -667,6 +667,7 @@
 	"dataMapping.tableView.tableColumnsExceeded.tooltip": "Your data has more than {columnLimit} columns so some are hidden. Switch to {link} to see all data.",
 	"dataMapping.tableView.tableColumnsExceeded.tooltip.link": "JSON view",
 	"dataMapping.schemaView.emptyData": "No fields - item(s) exist, but they're empty",
+	"dataMapping.schemaView.emptyDataWithBinary": "Only binary data exists. View it using the 'Binary' tab",
 	"dataMapping.schemaView.disabled": "This node is disabled and will just pass data through",
 	"dataMapping.schemaView.noMatches": "No results for '{search}'",
 	"dataMapping.schemaView.preview": "Usually outputs the following fields. Execute the node to see the actual ones. {link}",

From 380d032d9af0433e5c45b907c7a4fc68066bd013 Mon Sep 17 00:00:00 2001
From: Elias Meire <elias@meire.dev>
Date: Mon, 24 Mar 2025 14:42:43 +0100
Subject: [PATCH 11/33] refactor: Support rendering NodeIcon without a full
 node type object (no-changelog) (#14097)

---
 .../frontend/editor-ui/src/__tests__/mocks.ts |   1 +
 .../Node/NodeCreator/Modes/NodesMode.vue      |  30 +---
 .../Node/NodeCreator/Panel/NodesListPanel.vue |   8 +-
 .../NodeCreator/composables/useViewStacks.ts  |  25 ++--
 .../editor-ui/src/components/NodeIcon.vue     | 115 +++++---------
 .../__snapshots__/VirtualSchema.test.ts.snap  |   7 +
 .../canvas/elements/nodes/CanvasNode.vue      |  27 +---
 .../elements/nodes/CanvasNodeRenderer.vue     |  14 +-
 .../nodes/render-types/CanvasNodeDefault.vue  |   7 +-
 .../CanvasNodeDefault.test.ts.snap            | 100 +++++++++++--
 .../src/composables/useCanvasMapping.test.ts  |  12 ++
 .../src/composables/useCanvasMapping.ts       |   4 +
 .../frontend/editor-ui/src/types/canvas.ts    |   2 +
 .../editor-ui/src/utils/nodeIcon.test.ts      | 140 ++++++++++++++++++
 .../frontend/editor-ui/src/utils/nodeIcon.ts  | 109 ++++++++++++++
 .../editor-ui/src/utils/nodeTypesUtils.ts     |  32 ----
 16 files changed, 431 insertions(+), 202 deletions(-)
 create mode 100644 packages/frontend/editor-ui/src/utils/nodeIcon.test.ts
 create mode 100644 packages/frontend/editor-ui/src/utils/nodeIcon.ts

diff --git a/packages/frontend/editor-ui/src/__tests__/mocks.ts b/packages/frontend/editor-ui/src/__tests__/mocks.ts
index 80e8de9fb66..c59fa6f893b 100644
--- a/packages/frontend/editor-ui/src/__tests__/mocks.ts
+++ b/packages/frontend/editor-ui/src/__tests__/mocks.ts
@@ -82,6 +82,7 @@ export const mockNodeTypeDescription = ({
 		codex,
 		credentials,
 		documentationUrl: 'https://docs',
+		iconUrl: 'nodes/test-node/icon.svg',
 		webhooks: undefined,
 	});
 
diff --git a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue
index 1cba28c4eda..d74e5599457 100644
--- a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue
+++ b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Modes/NodesMode.vue
@@ -18,7 +18,6 @@ import {
 } from '@/constants';
 
 import type { BaseTextKey } from '@/plugins/i18n';
-import { useRootStore } from '@/stores/root.store';
 import { useNodeCreatorStore } from '@/stores/nodeCreator.store';
 
 import { TriggerView, RegularView, AIView, AINodesView } from '../viewsData';
@@ -29,8 +28,7 @@ import ItemsRenderer from '../Renderers/ItemsRenderer.vue';
 import CategorizedItemsRenderer from '../Renderers/CategorizedItemsRenderer.vue';
 import NoResults from '../Panel/NoResults.vue';
 import { useI18n } from '@/composables/useI18n';
-import { getNodeIcon, getNodeIconColor, getNodeIconUrl } from '@/utils/nodeTypesUtils';
-import { useUIStore } from '@/stores/ui.store';
+import { getNodeIconSource } from '@/utils/nodeIcon';
 import { useActions } from '../composables/useActions';
 import { SEND_AND_WAIT_OPERATION, type INodeParameters } from 'n8n-workflow';
 
@@ -43,8 +41,6 @@ const emit = defineEmits<{
 }>();
 
 const i18n = useI18n();
-const uiStore = useUIStore();
-const rootStore = useRootStore();
 
 const { mergedNodes, actions, onSubcategorySelected } = useNodeCreatorStore();
 const { pushViewStack, popViewStack } = useViewStacks();
@@ -83,20 +79,16 @@ function onSelected(item: INodeCreateElement) {
 		const infoKey = `nodeCreator.subcategoryInfos.${subcategoryKey}` as BaseTextKey;
 		const info = i18n.baseText(infoKey);
 		const extendedInfo = info !== infoKey ? { info } : {};
+		const nodeIcon = item.properties.icon
+			? ({ type: 'icon', name: item.properties.icon } as const)
+			: undefined;
 
 		pushViewStack({
 			subcategory: item.key,
 			mode: 'nodes',
 			title,
+			nodeIcon,
 			...extendedInfo,
-			...(item.properties.icon
-				? {
-						nodeIcon: {
-							icon: item.properties.icon,
-							iconType: 'icon',
-						},
-					}
-				: {}),
 			...(item.properties.panelClass ? { panelClass: item.properties.panelClass } : {}),
 			rootView: activeViewStack.value.rootView,
 			forceIncludeNodes: item.properties.forceIncludeNodes,
@@ -130,11 +122,6 @@ function onSelected(item: INodeCreateElement) {
 			return;
 		}
 
-		const iconUrl = getNodeIconUrl(item.properties, uiStore.appliedTheme);
-		const icon = iconUrl
-			? rootStore.baseUrl + iconUrl
-			: getNodeIcon(item.properties, uiStore.appliedTheme)?.split(':')[1];
-
 		const transformedActions = nodeActions?.map((a) =>
 			transformNodeType(a, item.properties.displayName, 'action'),
 		);
@@ -142,12 +129,7 @@ function onSelected(item: INodeCreateElement) {
 		pushViewStack({
 			subcategory: item.properties.displayName,
 			title: item.properties.displayName,
-			nodeIcon: {
-				color: getNodeIconColor(item.properties),
-				icon,
-				iconType: iconUrl ? 'file' : 'icon',
-			},
-
+			nodeIcon: getNodeIconSource(item.properties),
 			rootView: activeViewStack.value.rootView,
 			hasSearch: true,
 			mode: 'actions',
diff --git a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/NodesListPanel.vue b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/NodesListPanel.vue
index 061c6ea2444..e70711ff603 100644
--- a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/NodesListPanel.vue
+++ b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/NodesListPanel.vue
@@ -19,6 +19,7 @@ import ActionsRenderer from '../Modes/ActionsMode.vue';
 import NodesRenderer from '../Modes/NodesMode.vue';
 import { useI18n } from '@/composables/useI18n';
 import { useDebounce } from '@/composables/useDebounce';
+import NodeIcon from '@/components/NodeIcon.vue';
 
 const i18n = useI18n();
 const { callDebounced } = useDebounce();
@@ -155,13 +156,10 @@ function onBackButton() {
 					>
 						<font-awesome-icon :class="$style.backButtonIcon" icon="arrow-left" size="2x" />
 					</button>
-					<n8n-node-icon
+					<NodeIcon
 						v-if="activeViewStack.nodeIcon"
 						:class="$style.nodeIcon"
-						:type="activeViewStack.nodeIcon.iconType || 'unknown'"
-						:src="activeViewStack.nodeIcon.icon"
-						:name="activeViewStack.nodeIcon.icon"
-						:color="activeViewStack.nodeIcon.color"
+						:icon-source="activeViewStack.nodeIcon"
 						:circle="false"
 						:show-tooltip="false"
 						:size="20"
diff --git a/packages/frontend/editor-ui/src/components/Node/NodeCreator/composables/useViewStacks.ts b/packages/frontend/editor-ui/src/components/Node/NodeCreator/composables/useViewStacks.ts
index 7ec71cc8404..ed206d82efb 100644
--- a/packages/frontend/editor-ui/src/components/Node/NodeCreator/composables/useViewStacks.ts
+++ b/packages/frontend/editor-ui/src/components/Node/NodeCreator/composables/useViewStacks.ts
@@ -39,9 +39,12 @@ import { useKeyboardNavigation } from './useKeyboardNavigation';
 
 import { useNodeTypesStore } from '@/stores/nodeTypes.store';
 import { AI_TRANSFORM_NODE_TYPE } from 'n8n-workflow';
-import type { NodeConnectionType, INodeInputFilter, Themed } from 'n8n-workflow';
+import type { NodeConnectionType, INodeInputFilter } from 'n8n-workflow';
 import { useCanvasStore } from '@/stores/canvas.store';
 import { useSettingsStore } from '@/stores/settings.store';
+import { useUIStore } from '@/stores/ui.store';
+import { type NodeIconSource } from '@/utils/nodeIcon';
+import { getThemedValue } from '@/utils/nodeTypesUtils';
 
 interface ViewStack {
 	uuid?: string;
@@ -50,12 +53,7 @@ interface ViewStack {
 	search?: string;
 	subcategory?: string;
 	info?: string;
-	nodeIcon?: {
-		iconType?: string;
-		icon?: Themed<string>;
-		color?: string;
-	};
-	iconUrl?: string;
+	nodeIcon?: NodeIconSource;
 	rootView?: NodeFilterType;
 	activeIndex?: number;
 	transitionDirection?: 'in' | 'out';
@@ -314,6 +312,7 @@ export const useViewStacks = defineStore('nodeCreatorViewStacks', () => {
 
 		await nextTick();
 
+		const iconName = getThemedValue(relatedAIView?.properties.icon, useUIStore().appliedTheme);
 		pushViewStack(
 			{
 				title: relatedAIView?.properties.title,
@@ -321,11 +320,13 @@ export const useViewStacks = defineStore('nodeCreatorViewStacks', () => {
 				rootView: AI_OTHERS_NODE_CREATOR_VIEW,
 				mode: 'nodes',
 				items: nodeCreatorStore.allNodeCreatorNodes,
-				nodeIcon: {
-					iconType: 'icon',
-					icon: relatedAIView?.properties.icon,
-					color: relatedAIView?.properties.iconProps?.color,
-				},
+				nodeIcon: iconName
+					? {
+							type: 'icon',
+							name: iconName,
+							color: relatedAIView?.properties.iconProps?.color,
+						}
+					: undefined,
 				panelClass: relatedAIView?.properties.panelClass,
 				baseFilter: (i: INodeCreateElement) => {
 					// AI Code node could have any connection type so we don't want to display it
diff --git a/packages/frontend/editor-ui/src/components/NodeIcon.vue b/packages/frontend/editor-ui/src/components/NodeIcon.vue
index 62631cca4a3..9a534d915cc 100644
--- a/packages/frontend/editor-ui/src/components/NodeIcon.vue
+++ b/packages/frontend/editor-ui/src/components/NodeIcon.vue
@@ -1,24 +1,10 @@
 <script setup lang="ts">
 import type { IVersionNode, SimplifiedNodeType } from '@/Interface';
-import { useRootStore } from '@/stores/root.store';
-import { useUIStore } from '@/stores/ui.store';
-import {
-	getBadgeIconUrl,
-	getNodeIcon,
-	getNodeIconColor,
-	getNodeIconUrl,
-} from '@/utils/nodeTypesUtils';
-import type { INodeTypeDescription } from 'n8n-workflow';
+import { getNodeIconSource, type NodeIconSource } from '@/utils/nodeIcon';
+import { N8nNodeIcon } from '@n8n/design-system';
 import { computed } from 'vue';
 
-interface NodeIconSource {
-	path?: string;
-	fileBuffer?: string;
-	icon?: string;
-}
-
 type Props = {
-	nodeType?: INodeTypeDescription | SimplifiedNodeType | IVersionNode | null;
 	size?: number;
 	disabled?: boolean;
 	circle?: boolean;
@@ -26,10 +12,15 @@ type Props = {
 	showTooltip?: boolean;
 	tooltipPosition?: 'top' | 'bottom' | 'left' | 'right';
 	nodeName?: string;
+	// NodeIcon needs iconSource OR nodeType, would be better with an intersection type
+	// but it breaks Vue template type checking
+	iconSource?: NodeIconSource;
+	nodeType?: SimplifiedNodeType | IVersionNode | null;
 };
 
 const props = withDefaults(defineProps<Props>(), {
 	nodeType: undefined,
+	iconSource: undefined,
 	size: undefined,
 	circle: false,
 	disabled: false,
@@ -37,97 +28,57 @@ const props = withDefaults(defineProps<Props>(), {
 	tooltipPosition: 'top',
 	colorDefault: '',
 	nodeName: '',
+	badgeIconUrl: undefined,
 });
 
 const emit = defineEmits<{
 	click: [];
 }>();
 
-const rootStore = useRootStore();
-const uiStore = useUIStore();
-
-const iconType = computed(() => {
-	const nodeType = props.nodeType;
-
-	if (nodeType) {
-		if (nodeType.iconUrl) return 'file';
-		if ('iconData' in nodeType && nodeType.iconData) {
-			return nodeType.iconData.type;
-		}
-		if (nodeType.icon) {
-			const icon = getNodeIcon(nodeType, uiStore.appliedTheme);
-			return icon && icon.split(':')[0] === 'file' ? 'file' : 'icon';
-		}
-	}
-
-	return 'unknown';
+const iconSource = computed(() => {
+	if (props.iconSource) return props.iconSource;
+	return getNodeIconSource(props.nodeType);
 });
 
-const color = computed(() => getNodeIconColor(props.nodeType) ?? props.colorDefault ?? '');
+const iconType = computed(() => iconSource.value?.type ?? 'unknown');
+const src = computed(() => {
+	if (iconSource.value?.type !== 'file') return;
+	return iconSource.value.src;
+});
 
-const iconSource = computed<NodeIconSource>(() => {
-	const nodeType = props.nodeType;
-	const baseUrl = rootStore.baseUrl;
+const iconName = computed(() => {
+	if (iconSource.value?.type !== 'icon') return;
+	return iconSource.value.name;
+});
 
-	if (nodeType) {
-		// If node type has icon data, use it
-		if ('iconData' in nodeType && nodeType.iconData) {
-			return {
-				icon: nodeType.iconData.icon,
-				fileBuffer: nodeType.iconData.fileBuffer,
-			};
-		}
-
-		const iconUrl = getNodeIconUrl(nodeType, uiStore.appliedTheme);
-		if (iconUrl) {
-			return { path: baseUrl + iconUrl };
-		}
-		// Otherwise, extract it from icon prop
-		if (nodeType.icon) {
-			const icon = getNodeIcon(nodeType, uiStore.appliedTheme);
-
-			if (icon) {
-				const [type, path] = icon.split(':');
-				if (type === 'file') {
-					throw new Error(`Unexpected icon: ${icon}`);
-				}
-
-				return { icon: path };
-			}
-		}
-	}
-
-	return {};
+const iconColor = computed(() => {
+	if (iconSource.value?.type !== 'icon') return;
+	return iconSource.value.color ?? props.colorDefault;
 });
 
 const badge = computed(() => {
-	const nodeType = props.nodeType;
-	if (nodeType && 'badgeIconUrl' in nodeType && nodeType.badgeIconUrl) {
-		return {
-			type: 'file',
-			src: rootStore.baseUrl + getBadgeIconUrl(nodeType, uiStore.appliedTheme),
-		};
-	}
-
-	return undefined;
+	if (iconSource.value?.badge?.type !== 'file') return;
+	return iconSource.value.badge;
 });
+
+const nodeTypeName = computed(() => props.nodeName ?? props.nodeType?.displayName);
 </script>
 
 <template>
-	<n8n-node-icon
+	<N8nNodeIcon
 		:type="iconType"
-		:src="iconSource.path || iconSource.fileBuffer"
-		:name="iconSource.icon"
-		:color="color"
+		:src="src"
+		:name="iconName"
+		:color="iconColor"
 		:disabled="disabled"
 		:size="size"
 		:circle="circle"
-		:node-type-name="nodeName ? nodeName : nodeType?.displayName"
+		:node-type-name="nodeTypeName"
 		:show-tooltip="showTooltip"
 		:tooltip-position="tooltipPosition"
 		:badge="badge"
 		@click="emit('click')"
-	></n8n-node-icon>
+	></N8nNodeIcon>
 </template>
 
 <style lang="scss" module></style>
diff --git a/packages/frontend/editor-ui/src/components/__snapshots__/VirtualSchema.test.ts.snap b/packages/frontend/editor-ui/src/components/__snapshots__/VirtualSchema.test.ts.snap
index 6f4d10bf69d..638a1feffbd 100644
--- a/packages/frontend/editor-ui/src/components/__snapshots__/VirtualSchema.test.ts.snap
+++ b/packages/frontend/editor-ui/src/components/__snapshots__/VirtualSchema.test.ts.snap
@@ -74,6 +74,7 @@ exports[`VirtualSchema.vue > renders preview schema when enabled and available 1
                 >
                   <img
                     class="nodeIconImage"
+                    src="/nodes/test-node/icon.svg"
                   />
                   <!--v-if-->
                 </div>
@@ -424,6 +425,7 @@ exports[`VirtualSchema.vue > renders preview schema when enabled and available 1
                 >
                   <img
                     class="nodeIconImage"
+                    src="/nodes/test-node/icon.svg"
                   />
                   <!--v-if-->
                 </div>
@@ -810,6 +812,7 @@ exports[`VirtualSchema.vue > renders previous nodes schema for AI tools 1`] = `
       >
         <img
           class="nodeIconImage"
+          src="/nodes/test-node/icon.svg"
         />
         <!--v-if-->
       </div>
@@ -882,6 +885,7 @@ exports[`VirtualSchema.vue > renders schema for correct output branch 1`] = `
       >
         <img
           class="nodeIconImage"
+          src="/nodes/test-node/icon.svg"
         />
         <!--v-if-->
       </div>
@@ -1414,6 +1418,7 @@ exports[`VirtualSchema.vue > renders schema with spaces and dots 1`] = `
                 >
                   <img
                     class="nodeIconImage"
+                    src="/nodes/test-node/icon.svg"
                   />
                   <!--v-if-->
                 </div>
@@ -1976,6 +1981,7 @@ exports[`VirtualSchema.vue > renders schema with spaces and dots 1`] = `
                 >
                   <img
                     class="nodeIconImage"
+                    src="/nodes/test-node/icon.svg"
                   />
                   <!--v-if-->
                 </div>
@@ -2168,6 +2174,7 @@ exports[`VirtualSchema.vue > renders variables and context section 1`] = `
                 >
                   <img
                     class="nodeIconImage"
+                    src="/nodes/test-node/icon.svg"
                   />
                   <!--v-if-->
                 </div>
diff --git a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNode.vue b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNode.vue
index f0ac39c9f7a..326c05d97b8 100644
--- a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNode.vue
+++ b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNode.vue
@@ -17,8 +17,6 @@ import type {
 	CanvasEventBusEvents,
 } from '@/types';
 import { CanvasConnectionMode, CanvasNodeRenderType } from '@/types';
-import NodeIcon from '@/components/NodeIcon.vue';
-import { useNodeTypesStore } from '@/stores/nodeTypes.store';
 import CanvasNodeToolbar from '@/components/canvas/elements/nodes/CanvasNodeToolbar.vue';
 import CanvasNodeRenderer from '@/components/canvas/elements/nodes/CanvasNodeRenderer.vue';
 import CanvasHandleRenderer from '@/components/canvas/elements/handles/CanvasHandleRenderer.vue';
@@ -71,7 +69,6 @@ const style = useCssModule();
 
 const props = defineProps<Props>();
 
-const nodeTypesStore = useNodeTypesStore();
 const contextMenu = useContextMenu();
 
 const { connectingHandle } = useCanvas();
@@ -98,10 +95,6 @@ const {
 
 const isDisabled = computed(() => props.data.disabled);
 
-const nodeTypeDescription = computed(() => {
-	return nodeTypesStore.getNodeType(props.data.type, props.data.typeVersion);
-});
-
 const classes = computed(() => ({
 	[style.canvasNode]: true,
 	[style.showToolbar]: showToolbar.value,
@@ -156,14 +149,6 @@ const mappedOutputs = computed(() => {
 	].filter((endpoint) => !!endpoint);
 });
 
-/**
- * Node icon
- */
-
-const nodeIconSize = computed(() =>
-	'configuration' in data.value.render.options && data.value.render.options.configuration ? 30 : 40,
-);
-
 /**
  * Endpoints
  */
@@ -388,7 +373,7 @@ onBeforeUnmount(() => {
 		</template>
 
 		<CanvasNodeToolbar
-			v-else-if="nodeTypeDescription"
+			v-else
 			data-test-id="canvas-node-toolbar"
 			:read-only="readOnly"
 			:class="$style.canvasNodeToolbar"
@@ -405,15 +390,7 @@ onBeforeUnmount(() => {
 			@move="onMove"
 			@update="onUpdate"
 			@open:contextmenu="onOpenContextMenuFromNode"
-		>
-			<NodeIcon
-				:node-type="nodeTypeDescription"
-				:size="nodeIconSize"
-				:shrink="false"
-				:disabled="isDisabled"
-			/>
-			<!-- @TODO :color-default="iconColorDefault"-->
-		</CanvasNodeRenderer>
+		/>
 
 		<CanvasNodeTrigger
 			v-if="
diff --git a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNodeRenderer.vue b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNodeRenderer.vue
index 27cc433d2e8..da3abb77365 100644
--- a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNodeRenderer.vue
+++ b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/CanvasNodeRenderer.vue
@@ -8,10 +8,6 @@ import { CanvasNodeRenderType } from '@/types';
 
 const node = inject(CanvasNodeKey);
 
-const slots = defineSlots<{
-	default?: () => unknown;
-}>();
-
 const Render = () => {
 	const renderType = node?.data.value.render.type ?? CanvasNodeRenderType.Default;
 	let Component;
@@ -27,13 +23,9 @@ const Render = () => {
 			Component = CanvasNodeDefault;
 	}
 
-	return h(
-		Component,
-		{
-			'data-canvas-node-render-type': renderType,
-		},
-		slots.default,
-	);
+	return h(Component, {
+		'data-canvas-node-render-type': renderType,
+	});
 };
 </script>
 
diff --git a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/CanvasNodeDefault.vue b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/CanvasNodeDefault.vue
index a6366de606a..2c9aab41b83 100644
--- a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/CanvasNodeDefault.vue
+++ b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/CanvasNodeDefault.vue
@@ -107,6 +107,10 @@ const isStrikethroughVisible = computed(() => {
 	return isDisabled.value && isSingleMainInputNode && isSingleMainOutputNode;
 });
 
+const iconSize = computed(() => (renderOptions.value.configuration ? 30 : 40));
+
+const iconSource = computed(() => renderOptions.value.icon);
+
 const showTooltip = ref(false);
 
 watch(initialized, () => {
@@ -140,7 +144,7 @@ function onActivate() {
 		@dblclick.stop="onActivate"
 	>
 		<CanvasNodeTooltip v-if="renderOptions.tooltip" :visible="showTooltip" />
-		<slot />
+		<NodeIcon :icon-source="iconSource" :size="iconSize" :shrink="false" :disabled="isDisabled" />
 		<CanvasNodeStatusIcons v-if="!isDisabled" :class="$style.statusIcons" />
 		<CanvasNodeDisabledStrikeThrough v-if="isStrikethroughVisible" />
 		<div :class="$style.description">
@@ -171,6 +175,7 @@ function onActivate() {
 	--configurable-node--icon-size: 30px;
 	--trigger-node--border-radius: 36px;
 	--canvas-node--status-icons-offset: var(--spacing-3xs);
+	--node-icon-color: var(--color-foreground-dark);
 
 	position: relative;
 	height: var(--canvas-node--height);
diff --git a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/__snapshots__/CanvasNodeDefault.test.ts.snap b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/__snapshots__/CanvasNodeDefault.test.ts.snap
index 71b7c37c5c3..cd5075b450b 100644
--- a/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/__snapshots__/CanvasNodeDefault.test.ts.snap
+++ b/packages/frontend/editor-ui/src/components/canvas/elements/nodes/render-types/__snapshots__/CanvasNodeDefault.test.ts.snap
@@ -7,8 +7,24 @@ exports[`CanvasNodeDefault > configurable > should render configurable node corr
   style="--configurable-node--input-count: 0; --canvas-node--main-input-count: 0; --canvas-node--main-output-count: 0;"
 >
   <!--v-if-->
-  
-  
+  <div
+    class="n8n-node-icon"
+    shrink="false"
+  >
+    <div
+      class="nodeIconWrapper"
+      style="width: 40px; height: 40px; font-size: 40px; line-height: 40px;"
+    >
+      <!-- ElementUI tooltip is prone to memory-leaking so we only render it if we really need it -->
+      
+      <div
+        class="nodeIconPlaceholder"
+      >
+        ?
+      </div>
+      
+    </div>
+  </div>
   <!--v-if-->
   <!--v-if-->
   <div
@@ -36,8 +52,24 @@ exports[`CanvasNodeDefault > configuration > should render configurable configur
   style="--configurable-node--input-count: 0; --canvas-node--main-input-count: 0; --canvas-node--main-output-count: 0;"
 >
   <!--v-if-->
-  
-  
+  <div
+    class="n8n-node-icon"
+    shrink="false"
+  >
+    <div
+      class="nodeIconWrapper"
+      style="width: 30px; height: 30px; font-size: 30px; line-height: 30px;"
+    >
+      <!-- ElementUI tooltip is prone to memory-leaking so we only render it if we really need it -->
+      
+      <div
+        class="nodeIconPlaceholder"
+      >
+        ?
+      </div>
+      
+    </div>
+  </div>
   <!--v-if-->
   <!--v-if-->
   <div
@@ -65,8 +97,24 @@ exports[`CanvasNodeDefault > configuration > should render configuration node co
   style="--canvas-node--main-input-count: 0; --canvas-node--main-output-count: 0;"
 >
   <!--v-if-->
-  
-  
+  <div
+    class="n8n-node-icon"
+    shrink="false"
+  >
+    <div
+      class="nodeIconWrapper"
+      style="width: 30px; height: 30px; font-size: 30px; line-height: 30px;"
+    >
+      <!-- ElementUI tooltip is prone to memory-leaking so we only render it if we really need it -->
+      
+      <div
+        class="nodeIconPlaceholder"
+      >
+        ?
+      </div>
+      
+    </div>
+  </div>
   <!--v-if-->
   <!--v-if-->
   <div
@@ -94,8 +142,24 @@ exports[`CanvasNodeDefault > should render node correctly 1`] = `
   style="--canvas-node--main-input-count: 0; --canvas-node--main-output-count: 0;"
 >
   <!--v-if-->
-  
-  
+  <div
+    class="n8n-node-icon"
+    shrink="false"
+  >
+    <div
+      class="nodeIconWrapper"
+      style="width: 40px; height: 40px; font-size: 40px; line-height: 40px;"
+    >
+      <!-- ElementUI tooltip is prone to memory-leaking so we only render it if we really need it -->
+      
+      <div
+        class="nodeIconPlaceholder"
+      >
+        ?
+      </div>
+      
+    </div>
+  </div>
   <!--v-if-->
   <!--v-if-->
   <div
@@ -123,8 +187,24 @@ exports[`CanvasNodeDefault > trigger > should render trigger node correctly 1`]
   style="--canvas-node--main-input-count: 0; --canvas-node--main-output-count: 0;"
 >
   <!--v-if-->
-  
-  
+  <div
+    class="n8n-node-icon"
+    shrink="false"
+  >
+    <div
+      class="nodeIconWrapper"
+      style="width: 40px; height: 40px; font-size: 40px; line-height: 40px;"
+    >
+      <!-- ElementUI tooltip is prone to memory-leaking so we only render it if we really need it -->
+      
+      <div
+        class="nodeIconPlaceholder"
+      >
+        ?
+      </div>
+      
+    </div>
+  </div>
   <!--v-if-->
   <!--v-if-->
   <div
diff --git a/packages/frontend/editor-ui/src/composables/useCanvasMapping.test.ts b/packages/frontend/editor-ui/src/composables/useCanvasMapping.test.ts
index 04d039a64bd..3708ef81e63 100644
--- a/packages/frontend/editor-ui/src/composables/useCanvasMapping.test.ts
+++ b/packages/frontend/editor-ui/src/composables/useCanvasMapping.test.ts
@@ -21,6 +21,7 @@ import { MarkerType } from '@vue-flow/core';
 import { createTestingPinia } from '@pinia/testing';
 import { mockedStore } from '@/__tests__/utils';
 import { mock } from 'vitest-mock-extended';
+import { useRootStore } from '../stores/root.store';
 
 beforeEach(() => {
 	const pinia = createTestingPinia({
@@ -147,6 +148,10 @@ describe('useCanvasMapping', () => {
 							options: {
 								configurable: false,
 								configuration: false,
+								icon: {
+									src: '/nodes/test-node/icon.svg',
+									type: 'file',
+								},
 								trigger: true,
 								inputs: {
 									labelSize: 'small',
@@ -280,12 +285,19 @@ describe('useCanvasMapping', () => {
 					workflowObject: ref(workflowObject) as Ref<Workflow>,
 				});
 
+				const rootStore = mockedStore(useRootStore);
+				rootStore.baseUrl = 'http://test.local/';
+
 				expect(mappedNodes.value[0]?.data?.render).toEqual({
 					type: CanvasNodeRenderType.Default,
 					options: {
 						configurable: false,
 						configuration: false,
 						trigger: true,
+						icon: {
+							src: 'http://test.local/nodes/test-node/icon.svg',
+							type: 'file',
+						},
 						inputs: {
 							labelSize: 'small',
 						},
diff --git a/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts b/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
index 4cc9d1d2948..ceff397debe 100644
--- a/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
+++ b/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
@@ -50,6 +50,7 @@ import { MarkerType } from '@vue-flow/core';
 import { useNodeHelpers } from './useNodeHelpers';
 import { getTriggerNodeServiceName } from '@/utils/nodeTypesUtils';
 import { useNodeDirtiness } from '@/composables/useNodeDirtiness';
+import { getNodeIconSource } from '../utils/nodeIcon';
 
 export function useCanvasMapping({
 	nodes,
@@ -86,6 +87,8 @@ export function useCanvasMapping({
 	}
 
 	function createDefaultNodeRenderType(node: INodeUi): CanvasNodeDefaultRender {
+		const nodeType = nodeTypeDescriptionByNodeId.value[node.id];
+		const icon = getNodeIconSource(nodeType);
 		return {
 			type: CanvasNodeRenderType.Default,
 			options: {
@@ -100,6 +103,7 @@ export function useCanvasMapping({
 				},
 				tooltip: nodeTooltipById.value[node.id],
 				dirtiness: dirtinessByName.value[node.name],
+				icon,
 			},
 		};
 	}
diff --git a/packages/frontend/editor-ui/src/types/canvas.ts b/packages/frontend/editor-ui/src/types/canvas.ts
index c1c05e49666..0fe29d33e60 100644
--- a/packages/frontend/editor-ui/src/types/canvas.ts
+++ b/packages/frontend/editor-ui/src/types/canvas.ts
@@ -11,6 +11,7 @@ import type {
 import type { IExecutionResponse, INodeUi } from '@/Interface';
 import type { ComputedRef, Ref } from 'vue';
 import type { EventBus } from '@n8n/utils/event-bus';
+import type { NodeIconSource } from '../utils/nodeIcon';
 
 export const enum CanvasConnectionMode {
 	Input = 'inputs',
@@ -71,6 +72,7 @@ export type CanvasNodeDefaultRender = {
 		};
 		tooltip?: string;
 		dirtiness?: CanvasNodeDirtinessType;
+		icon?: NodeIconSource;
 	}>;
 };
 
diff --git a/packages/frontend/editor-ui/src/utils/nodeIcon.test.ts b/packages/frontend/editor-ui/src/utils/nodeIcon.test.ts
new file mode 100644
index 00000000000..906d8568c5f
--- /dev/null
+++ b/packages/frontend/editor-ui/src/utils/nodeIcon.test.ts
@@ -0,0 +1,140 @@
+import { mock } from 'vitest-mock-extended';
+import {
+	getNodeIcon,
+	getNodeIconUrl,
+	getBadgeIconUrl,
+	getNodeIconSource,
+	type IconNodeType,
+} from './nodeIcon';
+
+vi.mock('../stores/root.store', () => ({
+	useRootStore: vi.fn(() => ({
+		baseUrl: 'https://example.com/',
+	})),
+}));
+
+vi.mock('../stores/ui.store', () => ({
+	useUIStore: vi.fn(() => ({
+		appliedTheme: 'light',
+	})),
+}));
+
+vi.mock('./nodeTypesUtils', () => ({
+	getThemedValue: vi.fn((value, theme) => {
+		if (typeof value === 'object' && value !== null) {
+			return value[theme] || value.dark || value.light || null;
+		}
+		return value;
+	}),
+}));
+
+describe('util: Node Icon', () => {
+	describe('getNodeIcon', () => {
+		it('should return the icon from nodeType', () => {
+			expect(getNodeIcon(mock<IconNodeType>({ icon: 'user', iconUrl: undefined }))).toBe('user');
+		});
+
+		it('should return null if no icon is present', () => {
+			expect(
+				getNodeIcon(mock<IconNodeType>({ icon: undefined, iconUrl: '/test.svg' })),
+			).toBeUndefined();
+		});
+	});
+
+	describe('getNodeIconUrl', () => {
+		it('should return the iconUrl from nodeType', () => {
+			expect(
+				getNodeIconUrl(
+					mock<IconNodeType>({
+						iconUrl: { light: 'images/light-icon.svg', dark: 'images/dark-icon.svg' },
+					}),
+				),
+			).toBe('images/light-icon.svg');
+		});
+
+		it('should return null if no iconUrl is present', () => {
+			expect(
+				getNodeIconUrl(mock<IconNodeType>({ icon: 'foo', iconUrl: undefined })),
+			).toBeUndefined();
+		});
+	});
+
+	describe('getBadgeIconUrl', () => {
+		it('should return the badgeIconUrl from nodeType', () => {
+			expect(getBadgeIconUrl({ badgeIconUrl: 'images/badge.svg' })).toBe('images/badge.svg');
+		});
+
+		it('should return null if no badgeIconUrl is present', () => {
+			expect(getBadgeIconUrl({ badgeIconUrl: undefined })).toBeUndefined();
+		});
+	});
+
+	describe('getNodeIconSource', () => {
+		it('should return undefined if nodeType is null or undefined', () => {
+			expect(getNodeIconSource(null)).toBeUndefined();
+			expect(getNodeIconSource(undefined)).toBeUndefined();
+		});
+
+		it('should create an icon source from iconData.icon if available', () => {
+			const result = getNodeIconSource(
+				mock<IconNodeType>({ iconData: { type: 'icon', icon: 'pencil' } }),
+			);
+			expect(result).toEqual({
+				type: 'icon',
+				name: 'pencil',
+				color: undefined,
+				badge: undefined,
+			});
+		});
+
+		it('should create a file source from iconData.fileBuffer if available', () => {
+			const result = getNodeIconSource(
+				mock<IconNodeType>({
+					iconData: {
+						type: 'file',
+						icon: undefined,
+						fileBuffer: 'data://foo',
+					},
+				}),
+			);
+			expect(result).toEqual({
+				type: 'file',
+				src: 'data://foo',
+				badge: undefined,
+			});
+		});
+
+		it('should create a file source from iconUrl if available', () => {
+			const result = getNodeIconSource(mock<IconNodeType>({ iconUrl: 'images/node-icon.svg' }));
+			expect(result).toEqual({
+				type: 'file',
+				src: 'https://example.com/images/node-icon.svg',
+				badge: undefined,
+			});
+		});
+
+		it('should create an icon source from icon if available', () => {
+			const result = getNodeIconSource(
+				mock<IconNodeType>({
+					icon: 'icon:user',
+					iconColor: 'blue',
+					iconData: undefined,
+					iconUrl: undefined,
+				}),
+			);
+			expect(result).toEqual({
+				type: 'icon',
+				name: 'user',
+				color: 'var(--color-node-icon-blue)',
+			});
+		});
+
+		it('should include badge if available', () => {
+			const result = getNodeIconSource(mock<IconNodeType>({ badgeIconUrl: 'images/badge.svg' }));
+			expect(result?.badge).toEqual({
+				type: 'file',
+				src: 'https://example.com/images/badge.svg',
+			});
+		});
+	});
+});
diff --git a/packages/frontend/editor-ui/src/utils/nodeIcon.ts b/packages/frontend/editor-ui/src/utils/nodeIcon.ts
new file mode 100644
index 00000000000..1f79f1fd4e3
--- /dev/null
+++ b/packages/frontend/editor-ui/src/utils/nodeIcon.ts
@@ -0,0 +1,109 @@
+import { type INodeTypeDescription } from 'n8n-workflow';
+import type { IVersionNode } from '../Interface';
+import { useRootStore } from '../stores/root.store';
+import { useUIStore } from '../stores/ui.store';
+import { getThemedValue } from './nodeTypesUtils';
+
+type NodeIconSourceIcon = { type: 'icon'; name: string; color?: string };
+type NodeIconSourceFile = {
+	type: 'file';
+	src: string;
+};
+
+type BaseNodeIconSource = NodeIconSourceIcon | NodeIconSourceFile;
+export type NodeIconSource = BaseNodeIconSource & { badge?: BaseNodeIconSource };
+
+export type NodeIconType = 'file' | 'icon' | 'unknown';
+
+type IconNodeTypeDescription = Pick<
+	INodeTypeDescription,
+	'icon' | 'iconUrl' | 'iconColor' | 'defaults' | 'badgeIconUrl'
+>;
+type IconVersionNode = Pick<IVersionNode, 'icon' | 'iconUrl' | 'iconData' | 'defaults'>;
+export type IconNodeType = IconNodeTypeDescription | IconVersionNode;
+
+export const getNodeIcon = (nodeType: IconNodeType): string | null => {
+	return getThemedValue(nodeType.icon, useUIStore().appliedTheme);
+};
+
+export const getNodeIconUrl = (nodeType: IconNodeType): string | null => {
+	return getThemedValue(nodeType.iconUrl, useUIStore().appliedTheme);
+};
+
+export const getBadgeIconUrl = (
+	nodeType: Pick<IconNodeTypeDescription, 'badgeIconUrl'>,
+): string | null => {
+	return getThemedValue(nodeType.badgeIconUrl, useUIStore().appliedTheme);
+};
+
+function getNodeIconColor(nodeType: IconNodeType) {
+	if ('iconColor' in nodeType && nodeType.iconColor) {
+		return `var(--color-node-icon-${nodeType.iconColor})`;
+	}
+	return nodeType?.defaults?.color?.toString();
+}
+
+function prefixBaseUrl(url: string) {
+	return useRootStore().baseUrl + url;
+}
+
+export function getNodeIconSource(nodeType?: IconNodeType | null): NodeIconSource | undefined {
+	if (!nodeType) return undefined;
+	const createFileIconSource = (src: string): NodeIconSource => ({
+		type: 'file',
+		src,
+		badge: getNodeBadgeIconSource(nodeType),
+	});
+	const createNamedIconSource = (name: string): NodeIconSource => ({
+		type: 'icon',
+		name,
+		color: getNodeIconColor(nodeType),
+		badge: getNodeBadgeIconSource(nodeType),
+	});
+
+	// If node type has icon data, use it
+	if ('iconData' in nodeType && nodeType.iconData) {
+		if (nodeType.iconData.icon) {
+			return createNamedIconSource(nodeType.iconData.icon);
+		}
+
+		if (nodeType.iconData.fileBuffer) {
+			return createFileIconSource(nodeType.iconData.fileBuffer);
+		}
+	}
+
+	const iconUrl = getNodeIconUrl(nodeType);
+	if (iconUrl) {
+		return createFileIconSource(prefixBaseUrl(iconUrl));
+	}
+
+	// Otherwise, extract it from icon prop
+	if (nodeType.icon) {
+		const icon = getNodeIcon(nodeType);
+
+		if (icon) {
+			const [type, iconName] = icon.split(':');
+			if (type === 'file') {
+				return undefined;
+			}
+
+			return createNamedIconSource(iconName);
+		}
+	}
+
+	return undefined;
+}
+
+function getNodeBadgeIconSource(nodeType: IconNodeType): BaseNodeIconSource | undefined {
+	if (nodeType && 'badgeIconUrl' in nodeType && nodeType.badgeIconUrl) {
+		const badgeUrl = getBadgeIconUrl(nodeType);
+
+		if (!badgeUrl) return undefined;
+		return {
+			type: 'file',
+			src: prefixBaseUrl(badgeUrl),
+		};
+	}
+
+	return undefined;
+}
diff --git a/packages/frontend/editor-ui/src/utils/nodeTypesUtils.ts b/packages/frontend/editor-ui/src/utils/nodeTypesUtils.ts
index 3b732dcda62..8ced5b02423 100644
--- a/packages/frontend/editor-ui/src/utils/nodeTypesUtils.ts
+++ b/packages/frontend/editor-ui/src/utils/nodeTypesUtils.ts
@@ -3,9 +3,7 @@ import type {
 	INodeUi,
 	INodeUpdatePropertiesInformation,
 	ITemplatesNode,
-	IVersionNode,
 	NodeAuthenticationOption,
-	SimplifiedNodeType,
 } from '@/Interface';
 import {
 	CORE_NODES_CATEGORY,
@@ -502,33 +500,3 @@ export const getThemedValue = <T extends string>(
 
 	return value[theme];
 };
-
-export const getNodeIcon = (
-	nodeType: INodeTypeDescription | SimplifiedNodeType | IVersionNode,
-	theme: AppliedThemeOption = 'light',
-): string | null => {
-	return getThemedValue(nodeType.icon, theme);
-};
-
-export const getNodeIconUrl = (
-	nodeType: INodeTypeDescription | SimplifiedNodeType | IVersionNode,
-	theme: AppliedThemeOption = 'light',
-): string | null => {
-	return getThemedValue(nodeType.iconUrl, theme);
-};
-
-export const getBadgeIconUrl = (
-	nodeType: INodeTypeDescription | SimplifiedNodeType,
-	theme: AppliedThemeOption = 'light',
-): string | null => {
-	return getThemedValue(nodeType.badgeIconUrl, theme);
-};
-
-export const getNodeIconColor = (
-	nodeType?: INodeTypeDescription | SimplifiedNodeType | IVersionNode | null,
-) => {
-	if (nodeType && 'iconColor' in nodeType && nodeType.iconColor) {
-		return `var(--color-node-icon-${nodeType.iconColor})`;
-	}
-	return nodeType?.defaults?.color?.toString();
-};

From ef66518c92d976ccb575818d38da02aadad66fcc Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 24 Mar 2025 14:47:49 +0100
Subject: [PATCH 12/33] :rocket: Release 1.85.0 (#14135)

Co-authored-by: CharlieKolb <13814565+CharlieKolb@users.noreply.github.com>
---
 CHANGELOG.md                                  | 44 +++++++++++++++++++
 package.json                                  |  2 +-
 packages/@n8n/api-types/package.json          |  2 +-
 packages/@n8n/config/package.json             |  2 +-
 packages/@n8n/nodes-langchain/package.json    |  2 +-
 packages/@n8n/permissions/package.json        |  2 +-
 packages/@n8n/task-runner/package.json        |  2 +-
 packages/@n8n/utils/package.json              |  2 +-
 packages/cli/package.json                     |  2 +-
 packages/core/package.json                    |  2 +-
 packages/frontend/@n8n/chat/package.json      |  2 +-
 .../frontend/@n8n/design-system/package.json  |  2 +-
 packages/frontend/editor-ui/package.json      |  2 +-
 packages/node-dev/package.json                |  2 +-
 packages/nodes-base/package.json              |  2 +-
 packages/workflow/package.json                |  2 +-
 16 files changed, 59 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ebc41d7386f..fb5f8b3eb16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,47 @@
+# [1.85.0](https://github.com/n8n-io/n8n/compare/n8n@1.84.0...n8n@1.85.0) (2025-03-24)
+
+
+### Bug Fixes
+
+* Allow saved credenitals types of up to 64 characters instead of 32 ([#13985](https://github.com/n8n-io/n8n/issues/13985)) ([bc15bb1](https://github.com/n8n-io/n8n/commit/bc15bb18d9f33abdeed24e26826e7f3308d3eef2))
+* Allow username to be set in Redis chat memory ([#13926](https://github.com/n8n-io/n8n/issues/13926)) ([b2e359a](https://github.com/n8n-io/n8n/commit/b2e359ac1c2dfdf79f8d50fe83998eda5fc34dd2))
+* **core:** Allow running webhook servers in multi-main mode ([#13989](https://github.com/n8n-io/n8n/issues/13989)) ([e0fd505](https://github.com/n8n-io/n8n/commit/e0fd50554d48c873c8f77169d1a17438391dd973))
+* **core:** Bring back the missing GMT and UTC timezone for workflow settings ([#13999](https://github.com/n8n-io/n8n/issues/13999)) ([bda0688](https://github.com/n8n-io/n8n/commit/bda068880ea7a44718e01a156e97f09c9ec2bc46))
+* **core:** Do not use `url.includes` to check for domain names ([#13802](https://github.com/n8n-io/n8n/issues/13802)) ([d3bc80c](https://github.com/n8n-io/n8n/commit/d3bc80c22bbbf0ae39c88a6f085d5f80aa8a0e82))
+* **core:** Don't fail partial execution when an unrelated node is dirty ([#13925](https://github.com/n8n-io/n8n/issues/13925)) ([918cc51](https://github.com/n8n-io/n8n/commit/918cc51abc79bbcfb6a333d5ecafa07a9e986b6f))
+* **core:** Ensure frontend sentry releases also follow semver ([#14019](https://github.com/n8n-io/n8n/issues/14019)) ([401ed2c](https://github.com/n8n-io/n8n/commit/401ed2ce1194ad7ff238debff418f0db77eb06e6))
+* **editor:** Add "time saved per execution" workflow setting ([#13369](https://github.com/n8n-io/n8n/issues/13369)) ([6992c36](https://github.com/n8n-io/n8n/commit/6992c36ebb3aa608ce31396f9b7ed0aa10c80299))
+* **editor:** Add smart decimals directive ([#14054](https://github.com/n8n-io/n8n/issues/14054)) ([1a26fc2](https://github.com/n8n-io/n8n/commit/1a26fc2762dee366d2ce7ccf24e173cdc761c70c))
+* **editor:** Fix routing between workflow editing and new workflow pages ([#14031](https://github.com/n8n-io/n8n/issues/14031)) ([6817abe](https://github.com/n8n-io/n8n/commit/6817abe47facd7ff0e42a66599827d42c4df757c))
+
+
+### Features
+
+* Add appendN8nAttribution option to sendAndWait operation ([#13697](https://github.com/n8n-io/n8n/issues/13697)) ([d6d5a66](https://github.com/n8n-io/n8n/commit/d6d5a66f5dc28d926755ca8153f91c7be0742cf5))
+* Add xAiGrok Chat Model node and credentials ([#13670](https://github.com/n8n-io/n8n/issues/13670)) ([cc502fb](https://github.com/n8n-io/n8n/commit/cc502fb8c34b65d569b4abe4603cc8ef1eadc7a7))
+* Allow custom scopes for Entra credential ([#13796](https://github.com/n8n-io/n8n/issues/13796)) ([7e10361](https://github.com/n8n-io/n8n/commit/7e1036187ff7bd5be990f191a3ac8ef002e7812a))
+* **API:** Fix generation strategy for mysql/mariadb ([#14028](https://github.com/n8n-io/n8n/issues/14028)) ([24d8eac](https://github.com/n8n-io/n8n/commit/24d8eac85d8ce95671aabf8500139b3ef3e19a56))
+* **API:** Implement compaction logic for insights ([#14062](https://github.com/n8n-io/n8n/issues/14062)) ([d8433d2](https://github.com/n8n-io/n8n/commit/d8433d289543c40854e59b0384be356a3d7b947d))
+* Cat 720 improve pre merge ci ([#14116](https://github.com/n8n-io/n8n/issues/14116)) ([743b63e](https://github.com/n8n-io/n8n/commit/743b63e97a9a96dfaf35f138a79eddaad9bb2dbb))
+* **core:** Add folder synchronization to environments feature ([#14005](https://github.com/n8n-io/n8n/issues/14005)) ([198f17d](https://github.com/n8n-io/n8n/commit/198f17dbcf0b21e579f9a68466494662257dbe44))
+* **core:** Add tool to uninstall a community node ([#14026](https://github.com/n8n-io/n8n/issues/14026)) ([e0f9506](https://github.com/n8n-io/n8n/commit/e0f9506912aa6a129df332185063291f0627f9ca))
+* **core:** Allow community nodes to be used as tools ([#14042](https://github.com/n8n-io/n8n/issues/14042)) ([9d698ed](https://github.com/n8n-io/n8n/commit/9d698edcebc8cdbf9fefc3bf89a13f9daa32f40b))
+* **core:** Allow customizing auth cookie samesite attribute and CSP headers ([#13855](https://github.com/n8n-io/n8n/issues/13855)) ([17fc5c1](https://github.com/n8n-io/n8n/commit/17fc5c148b99b8f346abf2142a1d2bee567b2621))
+* **core:** Enable folders feature via license server ([#13942](https://github.com/n8n-io/n8n/issues/13942)) ([fa7e7ac](https://github.com/n8n-io/n8n/commit/fa7e7ac2e7b38418619ebe1f3839d47c491419d2))
+* **core:** Implement API to retrieve summary metrics ([#13927](https://github.com/n8n-io/n8n/issues/13927)) ([b616ceb](https://github.com/n8n-io/n8n/commit/b616ceb08b712ecd350114acc48a9a0f35843c0a))
+* **core:** Support importing a singular workflow object ([#14041](https://github.com/n8n-io/n8n/issues/14041)) ([91b2796](https://github.com/n8n-io/n8n/commit/91b27964d80309ce493200289b31a83ef6051b4d))
+* **core:** Update endpoint to update a workflow, to support updating the workflow parent folder (no-chagelog) ([#13906](https://github.com/n8n-io/n8n/issues/13906)) ([3a5cc4a](https://github.com/n8n-io/n8n/commit/3a5cc4ae957ea5f370472f08d2af4ac29c3b21b2))
+* **editor:** Add variables and context section to schema view ([#13875](https://github.com/n8n-io/n8n/issues/13875)) ([c06ce76](https://github.com/n8n-io/n8n/commit/c06ce765f11dcde4731d3739e1aa5f27351c3cc2))
+* **editor:** Always show collapsed panel at the bottom of canvas ([#13715](https://github.com/n8n-io/n8n/issues/13715)) ([2e9d3ad](https://github.com/n8n-io/n8n/commit/2e9d3ad3e14da7aa2f3b3b9577858791e9128908))
+* **editor:** Insights summary banner ([#13424](https://github.com/n8n-io/n8n/issues/13424)) ([df474f3](https://github.com/n8n-io/n8n/commit/df474f3ccbc629a8e308359e6a4973cc00b86e17))
+* **Extract from File Node:** Add relax_quote option ([#13607](https://github.com/n8n-io/n8n/issues/13607)) ([830d2c5](https://github.com/n8n-io/n8n/commit/830d2c5df53c5436f89868dfe23cf55c41585a46))
+* **n8n Form Trigger Node:** Respond with File ([#13507](https://github.com/n8n-io/n8n/issues/13507)) ([8f46371](https://github.com/n8n-io/n8n/commit/8f46371d77262aa0a924e1c58cf9691327e0f193))
+* **Salesforce Node:** Add support for PKCE ([#14082](https://github.com/n8n-io/n8n/issues/14082)) ([defeb2e](https://github.com/n8n-io/n8n/commit/defeb2e817dbc559844124f20e6bebf7717d878a))
+* **SeaTable Node:** Update node with new options ([#11431](https://github.com/n8n-io/n8n/issues/11431)) ([d0fdb11](https://github.com/n8n-io/n8n/commit/d0fdb11499de2e5fb1602b7cc86f2b24543ce50f))
+* **Simple Vector Store Node:** Implement store cleaning based on age/used memory ([#13986](https://github.com/n8n-io/n8n/issues/13986)) ([e06c552](https://github.com/n8n-io/n8n/commit/e06c552a6a0471ec60862247f6a597b8ab5f9cd3))
+
+
+
 # [1.84.0](https://github.com/n8n-io/n8n/compare/n8n@1.83.0...n8n@1.84.0) (2025-03-17)
 
 
diff --git a/package.json b/package.json
index 9908102a61e..f9fdc2828ba 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-monorepo",
-  "version": "1.84.0",
+  "version": "1.85.0",
   "private": true,
   "engines": {
     "node": ">=20.15",
diff --git a/packages/@n8n/api-types/package.json b/packages/@n8n/api-types/package.json
index 27d63519b60..bf91088a52a 100644
--- a/packages/@n8n/api-types/package.json
+++ b/packages/@n8n/api-types/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/api-types",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "scripts": {
     "clean": "rimraf dist .turbo",
     "dev": "pnpm watch",
diff --git a/packages/@n8n/config/package.json b/packages/@n8n/config/package.json
index 48eac78ba61..87968268cba 100644
--- a/packages/@n8n/config/package.json
+++ b/packages/@n8n/config/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/config",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "scripts": {
     "clean": "rimraf dist .turbo",
     "dev": "pnpm watch",
diff --git a/packages/@n8n/nodes-langchain/package.json b/packages/@n8n/nodes-langchain/package.json
index 76be1524899..00a8e9862b9 100644
--- a/packages/@n8n/nodes-langchain/package.json
+++ b/packages/@n8n/nodes-langchain/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/n8n-nodes-langchain",
-  "version": "1.84.0",
+  "version": "1.85.0",
   "description": "",
   "main": "index.js",
   "scripts": {
diff --git a/packages/@n8n/permissions/package.json b/packages/@n8n/permissions/package.json
index d96e13234cd..021bfc00930 100644
--- a/packages/@n8n/permissions/package.json
+++ b/packages/@n8n/permissions/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/permissions",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "scripts": {
     "clean": "rimraf dist .turbo",
     "dev": "pnpm watch",
diff --git a/packages/@n8n/task-runner/package.json b/packages/@n8n/task-runner/package.json
index 87ab8c0015a..d521acfb799 100644
--- a/packages/@n8n/task-runner/package.json
+++ b/packages/@n8n/task-runner/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/task-runner",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "scripts": {
     "clean": "rimraf dist .turbo",
     "start": "node dist/start.js",
diff --git a/packages/@n8n/utils/package.json b/packages/@n8n/utils/package.json
index a95ae83ac83..aee911b2058 100644
--- a/packages/@n8n/utils/package.json
+++ b/packages/@n8n/utils/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@n8n/utils",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "files": [
     "dist"
   ],
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 12fa4323532..88d4c2f07e3 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n",
-  "version": "1.84.0",
+  "version": "1.85.0",
   "description": "n8n Workflow Automation Tool",
   "main": "dist/index",
   "types": "dist/index.d.ts",
diff --git a/packages/core/package.json b/packages/core/package.json
index b973ea296fb..323f0e2ed8b 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-core",
-  "version": "1.83.0",
+  "version": "1.84.0",
   "description": "Core functionality of n8n",
   "main": "dist/index",
   "types": "dist/index.d.ts",
diff --git a/packages/frontend/@n8n/chat/package.json b/packages/frontend/@n8n/chat/package.json
index 0825aff00e0..2330ab58ef8 100644
--- a/packages/frontend/@n8n/chat/package.json
+++ b/packages/frontend/@n8n/chat/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/chat",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "scripts": {
     "dev": "pnpm run storybook",
     "build": "pnpm build:vite && pnpm build:bundle",
diff --git a/packages/frontend/@n8n/design-system/package.json b/packages/frontend/@n8n/design-system/package.json
index 42ac372a0be..aabcc2b90bf 100644
--- a/packages/frontend/@n8n/design-system/package.json
+++ b/packages/frontend/@n8n/design-system/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@n8n/design-system",
-  "version": "1.72.0",
+  "version": "1.73.0",
   "main": "src/index.ts",
   "import": "src/index.ts",
   "scripts": {
diff --git a/packages/frontend/editor-ui/package.json b/packages/frontend/editor-ui/package.json
index 785c4df536a..7399676bd2c 100644
--- a/packages/frontend/editor-ui/package.json
+++ b/packages/frontend/editor-ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-editor-ui",
-  "version": "1.84.0",
+  "version": "1.85.0",
   "description": "Workflow Editor UI for n8n",
   "main": "index.js",
   "scripts": {
diff --git a/packages/node-dev/package.json b/packages/node-dev/package.json
index 5bd699538ac..ce069a6ff3e 100644
--- a/packages/node-dev/package.json
+++ b/packages/node-dev/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-node-dev",
-  "version": "1.83.0",
+  "version": "1.84.0",
   "description": "CLI to simplify n8n credentials/node development",
   "main": "dist/src/index",
   "types": "dist/src/index.d.ts",
diff --git a/packages/nodes-base/package.json b/packages/nodes-base/package.json
index 618827c4f15..715f4afaa8e 100644
--- a/packages/nodes-base/package.json
+++ b/packages/nodes-base/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-base",
-  "version": "1.83.0",
+  "version": "1.84.0",
   "description": "Base nodes of n8n",
   "main": "index.js",
   "scripts": {
diff --git a/packages/workflow/package.json b/packages/workflow/package.json
index 7eec64ef4c4..9ed91665f24 100644
--- a/packages/workflow/package.json
+++ b/packages/workflow/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-workflow",
-  "version": "1.82.0",
+  "version": "1.83.0",
   "description": "Workflow base code of n8n",
   "main": "dist/index.js",
   "module": "src/index.ts",

From fdcca1d0ed7f7c32aa6c40f4751f554826064619 Mon Sep 17 00:00:00 2001
From: Charlie Kolb <charlie@n8n.io>
Date: Mon, 24 Mar 2025 15:52:37 +0100
Subject: [PATCH 13/33] fix(editor): Adjust URL on lost change warning Cancel
 or failed save (#13683)

---
 .../composables/modals/save-changes-modal.ts  | 10 ++++
 cypress/composables/workflowsPage.ts          |  4 ++
 cypress/e2e/44-routing.cy.ts                  | 55 +++++++++++++++----
 .../src/composables/useWorkflowHelpers.ts     | 32 ++++++++---
 4 files changed, 83 insertions(+), 18 deletions(-)

diff --git a/cypress/composables/modals/save-changes-modal.ts b/cypress/composables/modals/save-changes-modal.ts
index d44b09bd460..e2a629a63ec 100644
--- a/cypress/composables/modals/save-changes-modal.ts
+++ b/cypress/composables/modals/save-changes-modal.ts
@@ -1,3 +1,13 @@
 export function getSaveChangesModal() {
 	return cy.get('.el-overlay').contains('Save changes before leaving?');
 }
+
+// this is the button next to 'Save Changes'
+export function getCancelSaveChangesButton() {
+	return cy.get('.btn--cancel');
+}
+
+// This is the top right 'x'
+export function getCloseSaveChangesButton() {
+	return cy.get('.el-message-box__headerbtn');
+}
diff --git a/cypress/composables/workflowsPage.ts b/cypress/composables/workflowsPage.ts
index c7bcf398886..cbab641de21 100644
--- a/cypress/composables/workflowsPage.ts
+++ b/cypress/composables/workflowsPage.ts
@@ -6,6 +6,10 @@ export function getWorkflowsPageUrl() {
 	return '/home/workflows';
 }
 
+export const getCreateWorkflowButton = () => cy.getByTestId('add-resource-workflow');
+
+export const getNewWorkflowCardButton = () => cy.getByTestId('new-workflow-card');
+
 /**
  * Actions
  */
diff --git a/cypress/e2e/44-routing.cy.ts b/cypress/e2e/44-routing.cy.ts
index 1d3a8746a93..c3129c4e9d5 100644
--- a/cypress/e2e/44-routing.cy.ts
+++ b/cypress/e2e/44-routing.cy.ts
@@ -1,26 +1,59 @@
-import { getSaveChangesModal } from '../composables/modals/save-changes-modal';
+import {
+	getCancelSaveChangesButton,
+	getCloseSaveChangesButton,
+	getSaveChangesModal,
+} from '../composables/modals/save-changes-modal';
+import { getHomeButton } from '../composables/projects';
+import { addNodeToCanvas } from '../composables/workflow';
+import {
+	getCreateWorkflowButton,
+	getNewWorkflowCardButton,
+	getWorkflowsPageUrl,
+	visitWorkflowsPage,
+} from '../composables/workflowsPage';
 import { EDIT_FIELDS_SET_NODE_NAME } from '../constants';
-import { WorkflowPage as WorkflowPageClass } from '../pages/workflow';
-import { WorkflowsPage as WorkflowsPageClass } from '../pages/workflows';
-
-const WorkflowsPage = new WorkflowsPageClass();
-const WorkflowPage = new WorkflowPageClass();
 
 describe('Workflows', () => {
 	beforeEach(() => {
-		cy.visit(WorkflowsPage.url);
+		visitWorkflowsPage();
 	});
 
 	it('should ask to save unsaved changes before leaving route', () => {
-		WorkflowsPage.getters.newWorkflowButtonCard().should('be.visible');
-		WorkflowsPage.getters.newWorkflowButtonCard().click();
+		getNewWorkflowCardButton().should('be.visible');
+		getNewWorkflowCardButton().click();
 
 		cy.createFixtureWorkflow('Test_workflow_1.json', 'Empty State Card Workflow');
 
-		WorkflowPage.actions.addNodeToCanvas(EDIT_FIELDS_SET_NODE_NAME);
+		addNodeToCanvas(EDIT_FIELDS_SET_NODE_NAME);
 
-		cy.getByTestId('project-home-menu-item').click();
+		getHomeButton().click();
+
+		// We expect to still be on the workflow route here
+		cy.url().should('include', '/workflow/');
 
 		getSaveChangesModal().should('be.visible');
+		getCancelSaveChangesButton().click();
+
+		// Only now do we switch
+		cy.url().should('include', getWorkflowsPageUrl());
+	});
+
+	it('should correct route after cancelling saveChangesModal', () => {
+		getCreateWorkflowButton().click();
+
+		cy.createFixtureWorkflow('Test_workflow_1.json', 'Empty State Card Workflow');
+		addNodeToCanvas(EDIT_FIELDS_SET_NODE_NAME);
+
+		// Here we go back via browser rather than the home button
+		// As this already updates the route
+		cy.go(-1);
+
+		cy.url().should('include', getWorkflowsPageUrl());
+
+		getSaveChangesModal().should('be.visible');
+		getCloseSaveChangesButton().click();
+
+		// Confirm the url is back to the workflow
+		cy.url().should('include', '/workflow/');
 	});
 });
diff --git a/packages/frontend/editor-ui/src/composables/useWorkflowHelpers.ts b/packages/frontend/editor-ui/src/composables/useWorkflowHelpers.ts
index cb1d8871b3a..5652851931a 100644
--- a/packages/frontend/editor-ui/src/composables/useWorkflowHelpers.ts
+++ b/packages/frontend/editor-ui/src/composables/useWorkflowHelpers.ts
@@ -1,6 +1,7 @@
 import {
 	HTTP_REQUEST_NODE_TYPE,
 	MODAL_CANCEL,
+	MODAL_CLOSE,
 	MODAL_CONFIRM,
 	PLACEHOLDER_EMPTY_WORKFLOW_ID,
 	PLACEHOLDER_FILLED_AT_EXECUTION_TIME,
@@ -827,6 +828,12 @@ export function useWorkflowHelpers(options: { router: ReturnType<typeof useRoute
 
 			const workflowDataRequest: IWorkflowDataUpdate = await getWorkflowDataToSave();
 
+			// This can happen if the user has another workflow in the browser history and navigates
+			// via the browser back button, encountering our warning dialog with the new route already set
+			if (workflowDataRequest.id !== currentWorkflow) {
+				throw new Error('Attempted to save a workflow different from the current workflow');
+			}
+
 			if (name) {
 				workflowDataRequest.name = name.trim();
 			}
@@ -1134,23 +1141,34 @@ export function useWorkflowHelpers(options: { router: ReturnType<typeof useRoute
 					showClose: true,
 				},
 			);
-
 			if (confirmModal === MODAL_CONFIRM) {
 				const saved = await saveCurrentWorkflow({}, false);
 				if (saved) {
 					await npsSurveyStore.fetchPromptsData();
-				}
-				uiStore.stateIsDirty = false;
-
-				const goToNext = await confirm();
-				if (goToNext) {
-					next();
+					uiStore.stateIsDirty = false;
+					const goToNext = await confirm();
+					next(goToNext);
+				} else {
+					next(
+						router.resolve({
+							name: VIEWS.WORKFLOW,
+							params: { name: workflowsStore.workflow.id },
+						}),
+					);
 				}
 			} else if (confirmModal === MODAL_CANCEL) {
 				await cancel();
 
 				uiStore.stateIsDirty = false;
 				next();
+			} else if (confirmModal === MODAL_CLOSE) {
+				// The route may have already changed due to the browser back button, so let's restore it
+				next(
+					router.resolve({
+						name: VIEWS.WORKFLOW,
+						params: { name: workflowsStore.workflow.id },
+					}),
+				);
 			}
 		} else {
 			next();

From 10f6c3b1d35db31376419da0e6e791f9f903d266 Mon Sep 17 00:00:00 2001
From: Jon <jonathan.bennetts@gmail.com>
Date: Mon, 24 Mar 2025 15:08:25 +0000
Subject: [PATCH 14/33] fix(Baserow Node): Fix issue where database selection
 was returning other types (#14115)

---
 .../nodes-base/nodes/Baserow/Baserow.node.ts  |   4 +-
 .../__tests__/GenericFunctions.test.ts        | 141 ++++++++
 .../__tests__/workflow/apiResponses.ts        |  85 +++++
 .../Baserow/__tests__/workflow/workflow.json  | 328 ++++++++++++++++++
 .../__tests__/workflow/workflow.test.ts       |  63 ++++
 packages/nodes-base/nodes/Baserow/types.ts    |   1 +
 .../test/nodes/FakeCredentialsMap.ts          |   5 +
 7 files changed, 626 insertions(+), 1 deletion(-)
 create mode 100644 packages/nodes-base/nodes/Baserow/__tests__/GenericFunctions.test.ts
 create mode 100644 packages/nodes-base/nodes/Baserow/__tests__/workflow/apiResponses.ts
 create mode 100644 packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.json
 create mode 100644 packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.test.ts

diff --git a/packages/nodes-base/nodes/Baserow/Baserow.node.ts b/packages/nodes-base/nodes/Baserow/Baserow.node.ts
index 27cd84e3f80..19398d43510 100644
--- a/packages/nodes-base/nodes/Baserow/Baserow.node.ts
+++ b/packages/nodes-base/nodes/Baserow/Baserow.node.ts
@@ -120,7 +120,9 @@ export class Baserow implements INodeType {
 					endpoint,
 					jwtToken,
 				)) as LoadedResource[];
-				return toOptions(databases);
+				// Baserow has different types of applications, we only want the databases
+				// https://api.baserow.io/api/redoc/#tag/Applications/operation/list_all_applications
+				return toOptions(databases.filter((database) => database.type === 'database'));
 			},
 
 			async getTableIds(this: ILoadOptionsFunctions) {
diff --git a/packages/nodes-base/nodes/Baserow/__tests__/GenericFunctions.test.ts b/packages/nodes-base/nodes/Baserow/__tests__/GenericFunctions.test.ts
new file mode 100644
index 00000000000..6a6170407f1
--- /dev/null
+++ b/packages/nodes-base/nodes/Baserow/__tests__/GenericFunctions.test.ts
@@ -0,0 +1,141 @@
+/* eslint-disable n8n-nodes-base/node-param-display-name-miscased */
+import { NodeApiError } from 'n8n-workflow';
+
+import {
+	baserowApiRequest,
+	baserowApiRequestAllItems,
+	getJwtToken,
+	getFieldNamesAndIds,
+	toOptions,
+	TableFieldMapper,
+} from '../GenericFunctions';
+
+describe('Baserow > GenericFunctions', () => {
+	const mockExecuteFunctions: any = {
+		helpers: {
+			request: jest.fn(),
+		},
+		getCredentials: jest.fn().mockResolvedValue({
+			username: 'nathan@n8n.io',
+			password: 'this-is-a-fake-password',
+			host: 'https://api.baserow.io',
+		}),
+		getNodeParameter: jest.fn(),
+		getNode: jest.fn(),
+	};
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe('baserowApiRequest', () => {
+		it('should return data on success', async () => {
+			mockExecuteFunctions.helpers.request.mockResolvedValue({ success: true });
+			const result = await baserowApiRequest.call(
+				mockExecuteFunctions,
+				'GET',
+				'/endpoint',
+				'testJwt',
+			);
+			expect(result).toEqual({ success: true });
+			expect(mockExecuteFunctions.helpers.request).toHaveBeenCalled();
+		});
+
+		it('should throw NodeApiError on failure', async () => {
+			mockExecuteFunctions.helpers.request.mockRejectedValue({ error: 'fail' });
+			await expect(
+				baserowApiRequest.call(mockExecuteFunctions, 'GET', '/endpoint', 'testJwt'),
+			).rejects.toThrow(NodeApiError);
+		});
+	});
+
+	describe('baserowApiRequestAllItems', () => {
+		it('should accumulate all pages', async () => {
+			mockExecuteFunctions.getNodeParameter
+				.mockReturnValueOnce(true) // returnAll
+				.mockReturnValue(1000); // limit
+			mockExecuteFunctions.helpers.request
+				.mockResolvedValueOnce({ results: [{ data: 1 }], next: 'page2' })
+				.mockResolvedValueOnce({ results: [{ data: 2 }], next: null });
+
+			const result = await baserowApiRequestAllItems.call(
+				mockExecuteFunctions,
+				'GET',
+				'/endpoint',
+				'testJwt',
+				{},
+				{},
+			);
+
+			expect(result).toEqual([{ data: 1 }, { data: 2 }]);
+		});
+	});
+
+	describe('getJwtToken', () => {
+		it('should return a token', async () => {
+			mockExecuteFunctions.helpers.request.mockResolvedValue({ token: 'mockToken' });
+			const result = await getJwtToken.call(mockExecuteFunctions, {
+				username: 'nathan@n8n.io',
+				password: 'this-is-a-fake-password',
+				host: 'https://api.baserow.io',
+			});
+			expect(result).toBe('mockToken');
+		});
+
+		it('should throw NodeApiError if request fails', async () => {
+			mockExecuteFunctions.helpers.request.mockRejectedValue({ error: 'fail' });
+			await expect(
+				getJwtToken.call(mockExecuteFunctions, {
+					username: 'nathan@n8n.io',
+					password: 'this-is-a-fake-password',
+					host: 'https://api.baserow.io',
+				}),
+			).rejects.toThrow(NodeApiError);
+		});
+	});
+
+	describe('getFieldNamesAndIds', () => {
+		it('should return field names and ids', async () => {
+			mockExecuteFunctions.helpers.request.mockResolvedValue([
+				{ id: 1, name: 'field1' },
+				{ id: 2, name: 'field2' },
+			]);
+			const result = await getFieldNamesAndIds.call(mockExecuteFunctions, '1', 'testJwt');
+			expect(result).toEqual({
+				names: ['field1', 'field2'],
+				ids: ['field_1', 'field_2'],
+			});
+		});
+	});
+
+	describe('toOptions', () => {
+		it('should map items to options', () => {
+			const result = toOptions([
+				{ id: 1, name: 'field1' },
+				{ id: 2, name: 'field2' },
+			]);
+			expect(result).toEqual([
+				{ name: 'field1', value: 1 },
+				{ name: 'field2', value: 2 },
+			]);
+		});
+	});
+
+	describe('TableFieldMapper', () => {
+		it('should create name-to-id and id-to-name mappings', () => {
+			const mapper = new TableFieldMapper();
+			mapper.createMappings([
+				{ id: 1, name: 'field1' },
+				{ id: 2, name: 'field2' },
+			]);
+			expect(mapper.nameToIdMapping).toEqual({
+				field1: 'field_1',
+				field2: 'field_2',
+			});
+			expect(mapper.idToNameMapping).toEqual({
+				field_1: 'field1',
+				field_2: 'field2',
+			});
+		});
+	});
+});
diff --git a/packages/nodes-base/nodes/Baserow/__tests__/workflow/apiResponses.ts b/packages/nodes-base/nodes/Baserow/__tests__/workflow/apiResponses.ts
new file mode 100644
index 00000000000..61ea2d22a91
--- /dev/null
+++ b/packages/nodes-base/nodes/Baserow/__tests__/workflow/apiResponses.ts
@@ -0,0 +1,85 @@
+export const fieldsResponse = [
+	{
+		id: 3799030,
+		table_id: 482710,
+		name: 'Name',
+		order: 0,
+		type: 'text',
+		primary: true,
+		read_only: false,
+		immutable_type: false,
+		immutable_properties: false,
+		description: null,
+		text_default: '',
+	},
+	{
+		id: 3799031,
+		table_id: 482710,
+		name: 'Notes',
+		order: 1,
+		type: 'long_text',
+		primary: false,
+		read_only: false,
+		immutable_type: false,
+		immutable_properties: false,
+		description: null,
+		long_text_enable_rich_text: false,
+	},
+	{
+		id: 3799032,
+		table_id: 482710,
+		name: 'Active',
+		order: 2,
+		type: 'boolean',
+		primary: false,
+		read_only: false,
+		immutable_type: false,
+		immutable_properties: false,
+		description: null,
+	},
+];
+export const getResponse = {
+	id: 1,
+	order: '1.00000000000000000000',
+	field_3799030: 'Foo',
+	field_3799031: 'bar',
+	field_3799032: false,
+};
+
+export const getAllResponse = {
+	count: 2,
+	next: null,
+	previous: null,
+	results: [
+		{
+			id: 1,
+			order: '1.00000000000000000000',
+			field_3799030: 'Foo',
+			field_3799031: 'bar',
+			field_3799032: false,
+		},
+		{
+			id: 2,
+			order: '2.00000000000000000000',
+			field_3799030: 'Bar',
+			field_3799031: 'foo',
+			field_3799032: true,
+		},
+	],
+};
+
+export const createResponse = {
+	id: 3,
+	order: '3.00000000000000000000',
+	field_3799030: 'Nathan',
+	field_3799031: 'testing',
+	field_3799032: false,
+};
+
+export const updateResponse = {
+	id: 3,
+	order: '3.00000000000000000000',
+	field_3799030: 'Nathan',
+	field_3799031: 'testing',
+	field_3799032: true,
+};
diff --git a/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.json b/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.json
new file mode 100644
index 00000000000..2414c4b6905
--- /dev/null
+++ b/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.json
@@ -0,0 +1,328 @@
+{
+	"name": "Baserow Test Workflow",
+	"nodes": [
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.manualTrigger",
+			"typeVersion": 1,
+			"position": [-20, 400],
+			"id": "fccdbab1-aa37-4606-8744-520e19a90a01",
+			"name": "When clicking ‘Test workflow’"
+		},
+		{
+			"parameters": {
+				"operation": "get",
+				"databaseId": 199364,
+				"tableId": 482710,
+				"rowId": "1"
+			},
+			"type": "n8n-nodes-base.baserow",
+			"typeVersion": 1,
+			"position": [200, 0],
+			"id": "56b90399-9400-4fff-84b5-75430102119d",
+			"name": "Baserow > Get",
+			"credentials": {
+				"baserowApi": {
+					"id": "SWSFqWDWdnC74WMJ",
+					"name": "NodeQA"
+				}
+			}
+		},
+		{
+			"parameters": {
+				"databaseId": 199364,
+				"tableId": 482710,
+				"limit": 2,
+				"additionalOptions": {}
+			},
+			"type": "n8n-nodes-base.baserow",
+			"typeVersion": 1,
+			"position": [200, 200],
+			"id": "8a183257-3297-4ec9-bcae-aefb1f563355",
+			"name": "Baserow > Get Many",
+			"credentials": {
+				"baserowApi": {
+					"id": "SWSFqWDWdnC74WMJ",
+					"name": "NodeQA"
+				}
+			}
+		},
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.noOp",
+			"typeVersion": 1,
+			"position": [420, 0],
+			"id": "5afa3206-a796-41dc-a2c5-54b5b9f2fbf4",
+			"name": "GetResponse"
+		},
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.noOp",
+			"typeVersion": 1,
+			"position": [420, 200],
+			"id": "d61f9e61-856a-4590-aad1-d7ef88e7185b",
+			"name": "GetMany Response"
+		},
+		{
+			"parameters": {
+				"operation": "create",
+				"databaseId": 199364,
+				"tableId": 482710,
+				"fieldsUi": {
+					"fieldValues": [
+						{
+							"fieldId": 3799030,
+							"fieldValue": "Nathan"
+						},
+						{
+							"fieldId": 3799031,
+							"fieldValue": "testing"
+						}
+					]
+				}
+			},
+			"type": "n8n-nodes-base.baserow",
+			"typeVersion": 1,
+			"position": [200, 400],
+			"id": "e3c5b6c4-b4b3-40ac-8d12-2a240c174e81",
+			"name": "Baserow > Create",
+			"credentials": {
+				"baserowApi": {
+					"id": "SWSFqWDWdnC74WMJ",
+					"name": "NodeQA"
+				}
+			}
+		},
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.noOp",
+			"typeVersion": 1,
+			"position": [420, 400],
+			"id": "bb7648a4-1d81-421f-927d-0942325db4c9",
+			"name": "Create Response"
+		},
+		{
+			"parameters": {
+				"operation": "update",
+				"databaseId": 199364,
+				"tableId": 482710,
+				"rowId": "3",
+				"fieldsUi": {
+					"fieldValues": [
+						{
+							"fieldId": 3799032,
+							"fieldValue": "true"
+						}
+					]
+				}
+			},
+			"type": "n8n-nodes-base.baserow",
+			"typeVersion": 1,
+			"position": [200, 600],
+			"id": "557a163a-0d60-4dbf-b4e0-342533b56ad5",
+			"name": "Baserow > Update",
+			"credentials": {
+				"baserowApi": {
+					"id": "SWSFqWDWdnC74WMJ",
+					"name": "NodeQA"
+				}
+			}
+		},
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.noOp",
+			"typeVersion": 1,
+			"position": [420, 600],
+			"id": "34992c77-25d1-4af4-a667-ca452049908d",
+			"name": "Update Response"
+		},
+		{
+			"parameters": {},
+			"type": "n8n-nodes-base.noOp",
+			"typeVersion": 1,
+			"position": [420, 800],
+			"id": "76e75c2a-2c6e-4307-ad67-fbc3d442ea53",
+			"name": "Delete Response"
+		},
+		{
+			"parameters": {
+				"operation": "delete",
+				"databaseId": 199364,
+				"tableId": 482710,
+				"rowId": "3"
+			},
+			"type": "n8n-nodes-base.baserow",
+			"typeVersion": 1,
+			"position": [200, 800],
+			"id": "f1c84a01-f514-49c2-a54e-548b15dc91fd",
+			"name": "Baserow > Delete",
+			"credentials": {
+				"baserowApi": {
+					"id": "SWSFqWDWdnC74WMJ",
+					"name": "NodeQA"
+				}
+			}
+		}
+	],
+	"pinData": {
+		"GetResponse": [
+			{
+				"json": {
+					"id": 1,
+					"order": "1.00000000000000000000",
+					"Name": "Foo",
+					"Notes": "bar",
+					"Active": false
+				}
+			}
+		],
+		"GetMany Response": [
+			{
+				"json": {
+					"id": 1,
+					"order": "1.00000000000000000000",
+					"Name": "Foo",
+					"Notes": "bar",
+					"Active": false
+				}
+			},
+			{
+				"json": {
+					"id": 2,
+					"order": "2.00000000000000000000",
+					"Name": "Bar",
+					"Notes": "foo",
+					"Active": true
+				}
+			}
+		],
+		"Create Response": [
+			{
+				"json": {
+					"id": 3,
+					"order": "3.00000000000000000000",
+					"Name": "Nathan",
+					"Notes": "testing",
+					"Active": false
+				}
+			}
+		],
+		"Update Response": [
+			{
+				"json": {
+					"id": 3,
+					"order": "3.00000000000000000000",
+					"Name": "Nathan",
+					"Notes": "testing",
+					"Active": true
+				}
+			}
+		],
+		"Delete Response": [
+			{
+				"json": {
+					"success": true
+				}
+			}
+		]
+	},
+	"connections": {
+		"When clicking ‘Test workflow’": {
+			"main": [
+				[
+					{
+						"node": "Baserow > Get",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Baserow > Get Many",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Baserow > Create",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Baserow > Update",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Baserow > Delete",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Baserow > Get": {
+			"main": [
+				[
+					{
+						"node": "GetResponse",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Baserow > Get Many": {
+			"main": [
+				[
+					{
+						"node": "GetMany Response",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Baserow > Create": {
+			"main": [
+				[
+					{
+						"node": "Create Response",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Baserow > Update": {
+			"main": [
+				[
+					{
+						"node": "Update Response",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Baserow > Delete": {
+			"main": [
+				[
+					{
+						"node": "Delete Response",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		}
+	},
+	"active": false,
+	"settings": {
+		"executionOrder": "v1"
+	},
+	"versionId": "72dbd4c1-80b9-4a22-a298-7bcd577e2f0c",
+	"meta": {
+		"templateCredsSetupCompleted": true,
+		"instanceId": "0fa937d34dcabeff4bd6480d3b42cc95edf3bc20e6810819086ef1ce2623639d"
+	},
+	"id": "2IrLMcqSSFfSyj76",
+	"tags": []
+}
diff --git a/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.test.ts b/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.test.ts
new file mode 100644
index 00000000000..7d6863153f1
--- /dev/null
+++ b/packages/nodes-base/nodes/Baserow/__tests__/workflow/workflow.test.ts
@@ -0,0 +1,63 @@
+import nock from 'nock';
+
+import {
+	createResponse,
+	fieldsResponse,
+	getAllResponse,
+	getResponse,
+	updateResponse,
+} from './apiResponses';
+import {
+	setup,
+	equalityTest,
+	workflowToTests,
+	getWorkflowFilenames,
+} from '../../../../test/nodes/Helpers';
+
+describe('Baserow > Workflows', () => {
+	describe('Run workflow', () => {
+		const workflows = getWorkflowFilenames(__dirname);
+		const tests = workflowToTests(workflows);
+
+		beforeAll(() => {
+			const mock = nock('https://api.baserow.io');
+			// Baserow > Get Token
+			mock
+				.persist()
+				.post('/api/user/token-auth/', { username: 'nathan@n8n.io', password: 'fake-password' })
+				.reply(200, {
+					token: 'fake-jwt-token',
+				});
+			// Baserow > Get Fields
+			mock.get('/api/database/fields/table/482710/').reply(200, fieldsResponse);
+			// Baserow > Get Row
+			mock.get('/api/database/rows/table/482710/1/').reply(200, getResponse);
+			// Baserow > Get all rows
+			mock
+				.get('/api/database/rows/table/482710/')
+				.query({ page: 1, size: 100 })
+				.reply(200, getAllResponse);
+			// Baserow > Create Row
+			mock
+				.post('/api/database/rows/table/482710/', {
+					field_3799030: 'Nathan',
+					field_3799031: 'testing',
+				})
+				.reply(200, createResponse);
+			// Baserow > Update Row
+			mock
+				.patch('/api/database/rows/table/482710/3/', {
+					field_3799032: 'true',
+				})
+				.reply(200, updateResponse);
+			// Baserow > Delete Row
+			mock.delete('/api/database/rows/table/482710/3/').reply(200, {});
+		});
+
+		const nodeTypes = setup(tests);
+
+		for (const testData of tests) {
+			test(testData.description, async () => await equalityTest(testData, nodeTypes));
+		}
+	});
+});
diff --git a/packages/nodes-base/nodes/Baserow/types.ts b/packages/nodes-base/nodes/Baserow/types.ts
index bb340d3231e..65b5b0a09d0 100644
--- a/packages/nodes-base/nodes/Baserow/types.ts
+++ b/packages/nodes-base/nodes/Baserow/types.ts
@@ -25,6 +25,7 @@ export type GetAllAdditionalOptions = {
 export type LoadedResource = {
 	id: number;
 	name: string;
+	type?: string;
 };
 
 export type Accumulator = {
diff --git a/packages/nodes-base/test/nodes/FakeCredentialsMap.ts b/packages/nodes-base/test/nodes/FakeCredentialsMap.ts
index 48ee3762183..9a00879bb38 100644
--- a/packages/nodes-base/test/nodes/FakeCredentialsMap.ts
+++ b/packages/nodes-base/test/nodes/FakeCredentialsMap.ts
@@ -234,4 +234,9 @@ BQIDAQAB
 			'user-read-playback-state playlist-read-collaborative user-modify-playback-state playlist-modify-public user-read-currently-playing playlist-read-private user-read-recently-played playlist-modify-private user-library-read user-follow-read',
 		server: 'https://api.spotify.com/',
 	},
+	baserowApi: {
+		host: 'https://api.baserow.io',
+		username: 'nathan@n8n.io',
+		password: 'fake-password',
+	},
 } as const;

From cb01f2dd0d018ef54fc63b255abc0a054d01b6ed Mon Sep 17 00:00:00 2001
From: Timothy Degryse <24565568+ownerer@users.noreply.github.com>
Date: Mon, 24 Mar 2025 19:04:00 +0200
Subject: [PATCH 15/33] feat(Matrix Node): Add audio and video media types
 (#14057)

---
 packages/nodes-base/nodes/Matrix/MediaDescription.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/packages/nodes-base/nodes/Matrix/MediaDescription.ts b/packages/nodes-base/nodes/Matrix/MediaDescription.ts
index 3830981641d..06778882f0c 100644
--- a/packages/nodes-base/nodes/Matrix/MediaDescription.ts
+++ b/packages/nodes-base/nodes/Matrix/MediaDescription.ts
@@ -81,6 +81,16 @@ export const mediaFields: INodeProperties[] = [
 				value: 'image',
 				description: 'Image media type',
 			},
+			{
+				name: 'Audio',
+				value: 'audio',
+				description: 'Audio media type',
+			},
+			{
+				name: 'Video',
+				value: 'video',
+				description: 'Video media type',
+			},
 		],
 		description: 'Type of file being uploaded',
 		placeholder: 'mxc://matrix.org/uploaded-media-uri',

From 5bf10cdb4abe364a8f914362fb94841530aa02c9 Mon Sep 17 00:00:00 2001
From: jeanpaul <jeanpaul@users.noreply.github.com>
Date: Mon, 24 Mar 2025 19:45:53 +0100
Subject: [PATCH 16/33] fix(OpenAI Node): Show correct inputs for AI node
 (#14142)

---
 .../vendors/OpenAi/actions/versionDescription.ts  | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/actions/versionDescription.ts b/packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/actions/versionDescription.ts
index 64d2c105971..00263163a6f 100644
--- a/packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/actions/versionDescription.ts
+++ b/packages/@n8n/nodes-langchain/nodes/vendors/OpenAi/actions/versionDescription.ts
@@ -50,25 +50,22 @@ const configureNodeInputs = (
 ) => {
 	if (resource === 'assistant' && operation === 'message') {
 		const inputs: INodeInputConfiguration[] = [
-			{ type: NodeConnectionTypes.Main },
-			{ type: NodeConnectionTypes.AiTool, displayName: 'Tools' },
+			{ type: 'main' },
+			{ type: 'ai_tool', displayName: 'Tools' },
 		];
 		if (memory !== 'threadId') {
-			inputs.push({ type: NodeConnectionTypes.AiMemory, displayName: 'Memory', maxConnections: 1 });
+			inputs.push({ type: 'ai_memory', displayName: 'Memory', maxConnections: 1 });
 		}
 		return inputs;
 	}
 	if (resource === 'text' && operation === 'message') {
 		if (hideTools === 'hide') {
-			return [NodeConnectionTypes.Main];
+			return ['main'];
 		}
-		return [
-			{ type: NodeConnectionTypes.Main },
-			{ type: NodeConnectionTypes.AiTool, displayName: 'Tools' },
-		];
+		return [{ type: 'main' }, { type: 'ai_tool', displayName: 'Tools' }];
 	}
 
-	return [NodeConnectionTypes.Main];
+	return ['main'];
 };
 
 // eslint-disable-next-line n8n-nodes-base/node-class-description-missing-subtitle

From 70764a02589c146bf8e863c9c652ac30858841af Mon Sep 17 00:00:00 2001
From: Charlie Kolb <charlie@n8n.io>
Date: Tue, 25 Mar 2025 09:08:33 +0100
Subject: [PATCH 17/33] fix: Correct connections in SentimentAnalysis and
 TextClassifier (#14155)

---
 .../nodes/chains/SentimentAnalysis/SentimentAnalysis.node.ts  | 2 +-
 .../nodes/chains/TextClassifier/TextClassifier.node.ts        | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/@n8n/nodes-langchain/nodes/chains/SentimentAnalysis/SentimentAnalysis.node.ts b/packages/@n8n/nodes-langchain/nodes/chains/SentimentAnalysis/SentimentAnalysis.node.ts
index 577634ca98f..ac232eeee46 100644
--- a/packages/@n8n/nodes-langchain/nodes/chains/SentimentAnalysis/SentimentAnalysis.node.ts
+++ b/packages/@n8n/nodes-langchain/nodes/chains/SentimentAnalysis/SentimentAnalysis.node.ts
@@ -24,7 +24,7 @@ const configuredOutputs = (parameters: INodeParameters, defaultCategories: strin
 	const categories = (options?.categories as string) ?? defaultCategories;
 	const categoriesArray = categories.split(',').map((cat) => cat.trim());
 
-	const ret = categoriesArray.map((cat) => ({ type: NodeConnectionTypes.Main, displayName: cat }));
+	const ret = categoriesArray.map((cat) => ({ type: 'main', displayName: cat }));
 	return ret;
 };
 
diff --git a/packages/@n8n/nodes-langchain/nodes/chains/TextClassifier/TextClassifier.node.ts b/packages/@n8n/nodes-langchain/nodes/chains/TextClassifier/TextClassifier.node.ts
index 8cc241c294e..bfbaa4c635f 100644
--- a/packages/@n8n/nodes-langchain/nodes/chains/TextClassifier/TextClassifier.node.ts
+++ b/packages/@n8n/nodes-langchain/nodes/chains/TextClassifier/TextClassifier.node.ts
@@ -22,9 +22,9 @@ const configuredOutputs = (parameters: INodeParameters) => {
 	const categories = ((parameters.categories as IDataObject)?.categories as IDataObject[]) ?? [];
 	const fallback = (parameters.options as IDataObject)?.fallback as string;
 	const ret = categories.map((cat) => {
-		return { type: NodeConnectionTypes.Main, displayName: cat.category };
+		return { type: 'main', displayName: cat.category };
 	});
-	if (fallback === 'other') ret.push({ type: NodeConnectionTypes.Main, displayName: 'Other' });
+	if (fallback === 'other') ret.push({ type: 'main', displayName: 'Other' });
 	return ret;
 };
 

From a082a16c5d785d87ea334bb2285000bd3f44c157 Mon Sep 17 00:00:00 2001
From: Jon <jonathan.bennetts@gmail.com>
Date: Tue, 25 Mar 2025 08:12:17 +0000
Subject: [PATCH 18/33] fix(Microsoft SQL Node): Fix maximum call stack on
 execute query (#13940)

---
 packages/nodes-base/nodes/Microsoft/Sql/MicrosoftSql.node.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/nodes-base/nodes/Microsoft/Sql/MicrosoftSql.node.ts b/packages/nodes-base/nodes/Microsoft/Sql/MicrosoftSql.node.ts
index 1e9f081ca1a..e1056ed5298 100644
--- a/packages/nodes-base/nodes/Microsoft/Sql/MicrosoftSql.node.ts
+++ b/packages/nodes-base/nodes/Microsoft/Sql/MicrosoftSql.node.ts
@@ -269,7 +269,7 @@ export class MicrosoftSql implements INodeType {
 						);
 					}
 					const results = await executeSqlQueryAndPrepareResults(pool, rawQuery, i);
-					returnData.push(...results);
+					returnData = returnData.concat(results);
 				} catch (error) {
 					if (this.continueOnFail()) {
 						returnData.push({

From 71f281b90da6f71db04c9b22dee9e5976b0abab4 Mon Sep 17 00:00:00 2001
From: jeanpaul <jeanpaul@users.noreply.github.com>
Date: Tue, 25 Mar 2025 09:13:28 +0100
Subject: [PATCH 19/33] fix(editor): Show left-hand NDV floating nodes in
 correct order (#14126)

---
 cypress/e2e/5-ndv.cy.ts                       | 43 +++++++++-
 cypress/fixtures/Floating_Nodes.json          | 81 +++++++++++++++++++
 .../src/components/NDVFloatingNodes.vue       |  2 +-
 3 files changed, 124 insertions(+), 2 deletions(-)

diff --git a/cypress/e2e/5-ndv.cy.ts b/cypress/e2e/5-ndv.cy.ts
index be784cdc466..4b67a0d9887 100644
--- a/cypress/e2e/5-ndv.cy.ts
+++ b/cypress/e2e/5-ndv.cy.ts
@@ -1,5 +1,10 @@
 import { setCredentialValues } from '../composables/modals/credential-modal';
-import { clickCreateNewCredential, setParameterSelectByContent } from '../composables/ndv';
+import {
+	clickCreateNewCredential,
+	clickGetBackToCanvas,
+	setParameterSelectByContent,
+} from '../composables/ndv';
+import { openNode } from '../composables/workflow';
 import {
 	EDIT_FIELDS_SET_NODE_NAME,
 	MANUAL_TRIGGER_NODE_DISPLAY_NAME,
@@ -617,6 +622,42 @@ describe('NDV', () => {
 			// Sinse code tool require alphanumeric tool name it would also show an error(2 errors, 1 for each tool node)
 			cy.get('[class*=hasIssues]').should('have.length', 3);
 		});
+
+		it('should have the floating nodes in correct order', () => {
+			cy.createFixtureWorkflow('Floating_Nodes.json', 'Floating Nodes');
+
+			cy.ifCanvasVersion(
+				() => {},
+				() => {
+					// Needed in V2 as all nodes remain selected when clicking on a selected node
+					workflowPage.actions.deselectAll();
+				},
+			);
+
+			// The first merge node has the wires crossed, so `Edit Fields1` is first in the order of connected nodes
+			openNode('Merge');
+			getFloatingNodeByPosition('inputMain').should('exist');
+			getFloatingNodeByPosition('inputMain').should('have.length', 2);
+			getFloatingNodeByPosition('inputMain')
+				.first()
+				.should('have.attr', 'data-node-name', 'Edit Fields1');
+			getFloatingNodeByPosition('inputMain')
+				.last()
+				.should('have.attr', 'data-node-name', 'Edit Fields0');
+
+			clickGetBackToCanvas();
+
+			// The second merge node does not have wires crossed, so `Edit Fields0` is first
+			openNode('Merge1');
+			getFloatingNodeByPosition('inputMain').should('exist');
+			getFloatingNodeByPosition('inputMain').should('have.length', 2);
+			getFloatingNodeByPosition('inputMain')
+				.first()
+				.should('have.attr', 'data-node-name', 'Edit Fields0');
+			getFloatingNodeByPosition('inputMain')
+				.last()
+				.should('have.attr', 'data-node-name', 'Edit Fields1');
+		});
 	});
 
 	it('should show node name and version in settings', () => {
diff --git a/cypress/fixtures/Floating_Nodes.json b/cypress/fixtures/Floating_Nodes.json
index 6624c53ac66..01b715e0271 100644
--- a/cypress/fixtures/Floating_Nodes.json
+++ b/cypress/fixtures/Floating_Nodes.json
@@ -87,6 +87,54 @@
         1600,
         740
       ]
+    },
+    {
+      "parameters": {},
+      "type": "n8n-nodes-base.merge",
+      "typeVersion": 3.1,
+      "position": [
+        440,
+        -140
+      ],
+      "id": "a00959d3-8d4b-40af-b4f2-35ca3d73fd84",
+      "name": "Merge"
+    },
+    {
+      "parameters": {
+        "options": {}
+      },
+      "type": "n8n-nodes-base.set",
+      "typeVersion": 3.4,
+      "position": [
+        -20,
+        -120
+      ],
+      "id": "a5cbc221-ccfd-4034-a648-6a192834af81",
+      "name": "Edit Fields0"
+    },
+    {
+      "parameters": {
+        "options": {}
+      },
+      "type": "n8n-nodes-base.set",
+      "typeVersion": 3.4,
+      "position": [
+        0,
+        100
+      ],
+      "id": "d3b4c17a-bee8-418b-a721-5debafd1ce11",
+      "name": "Edit Fields1"
+    },
+    {
+      "parameters": {},
+      "type": "n8n-nodes-base.merge",
+      "typeVersion": 3.1,
+      "position": [
+        440,
+        100
+      ],
+      "id": "b23a2a43-ffac-41a5-a265-054e21a57d70",
+      "name": "Merge1"
     }
   ],
   "pinData": {},
@@ -161,7 +209,40 @@
           }
         ]
       ]
+    },
+    "Edit Fields0": {
+      "main": [
+        [
+          {
+            "node": "Merge",
+            "type": "main",
+            "index": 1
+          },
+          {
+            "node": "Merge1",
+            "type": "main",
+            "index": 0
+          }
+        ]
+      ]
+    },
+    "Edit Fields1": {
+      "main": [
+        [
+          {
+            "node": "Merge",
+            "type": "main",
+            "index": 0
+          },
+          {
+            "node": "Merge1",
+            "type": "main",
+            "index": 1
+          }
+        ]
+      ]
     }
+
   },
   "active": false,
   "settings": {
diff --git a/packages/frontend/editor-ui/src/components/NDVFloatingNodes.vue b/packages/frontend/editor-ui/src/components/NDVFloatingNodes.vue
index 0265bdb955c..1b76a8def15 100644
--- a/packages/frontend/editor-ui/src/components/NDVFloatingNodes.vue
+++ b/packages/frontend/editor-ui/src/components/NDVFloatingNodes.vue
@@ -76,7 +76,7 @@ const connectedNodes = computed<
 		).reverse(),
 		[FloatingNodePosition.left]: getINodesFromNames(
 			workflow.getParentNodes(rootName, NodeConnectionTypes.Main, 1),
-		),
+		).reverse(),
 	};
 });
 

From 6f60d657eb0dc6ec9e99fe91d5b5cd99662d7ef8 Mon Sep 17 00:00:00 2001
From: Guillaume Jacquart <jacquart.guillaume@gmail.com>
Date: Tue, 25 Mar 2025 09:21:33 +0100
Subject: [PATCH 20/33] fix(API): Fix import config import (#14137)

---
 packages/cli/src/modules/insights/insights.config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/cli/src/modules/insights/insights.config.ts b/packages/cli/src/modules/insights/insights.config.ts
index f273f0e11c9..e8f44984826 100644
--- a/packages/cli/src/modules/insights/insights.config.ts
+++ b/packages/cli/src/modules/insights/insights.config.ts
@@ -1,4 +1,4 @@
-import { Config, Env } from '@n8n/config/src/decorators';
+import { Config, Env } from '@n8n/config';
 
 @Config
 export class InsightsConfig {

From 4bd42e2f3a8a79c33a20f992e2727f8bb3dae101 Mon Sep 17 00:00:00 2001
From: Csaba Tuncsik <csaba@n8n.io>
Date: Tue, 25 Mar 2025 10:48:49 +0100
Subject: [PATCH 21/33] fix(editor): Remove title icon on Overview subpages
 (#14128)

---
 .../components/Projects/ProjectHeader.test.ts | 30 +++++++++++++++++++
 .../src/components/Projects/ProjectHeader.vue | 23 ++++++++++++--
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.test.ts b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.test.ts
index 3fca181e4c8..57f5c2cd621 100644
--- a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.test.ts
+++ b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.test.ts
@@ -12,6 +12,7 @@ import { VIEWS } from '@/constants';
 import userEvent from '@testing-library/user-event';
 import { waitFor, within } from '@testing-library/vue';
 import { useSettingsStore } from '@/stores/settings.store';
+import { useOverview } from '@/composables/useOverview';
 
 const mockPush = vi.fn();
 vi.mock('vue-router', async () => {
@@ -30,6 +31,12 @@ vi.mock('vue-router', async () => {
 	};
 });
 
+vi.mock('@/composables/useOverview', () => ({
+	useOverview: vi.fn().mockReturnValue({
+		isOverviewSubPage: false,
+	}),
+}));
+
 const projectTabsSpy = vi.fn().mockReturnValue({
 	render: vi.fn(),
 });
@@ -45,6 +52,7 @@ const renderComponent = createComponentRenderer(ProjectHeader, {
 let route: ReturnType<typeof router.useRoute>;
 let projectsStore: ReturnType<typeof mockedStore<typeof useProjectsStore>>;
 let settingsStore: ReturnType<typeof mockedStore<typeof useSettingsStore>>;
+let overview: ReturnType<typeof useOverview>;
 
 describe('ProjectHeader', () => {
 	beforeEach(() => {
@@ -52,6 +60,7 @@ describe('ProjectHeader', () => {
 		route = router.useRoute();
 		projectsStore = mockedStore(useProjectsStore);
 		settingsStore = mockedStore(useSettingsStore);
+		overview = useOverview();
 
 		projectsStore.teamProjectsLimit = -1;
 		settingsStore.settings.folders = { enabled: false };
@@ -61,6 +70,27 @@ describe('ProjectHeader', () => {
 		vi.clearAllMocks();
 	});
 
+	it('should not render title icon on overview page', async () => {
+		vi.spyOn(overview, 'isOverviewSubPage', 'get').mockReturnValue(true);
+		const { container } = renderComponent();
+
+		expect(container.querySelector('.fa-home')).not.toBeInTheDocument();
+	});
+
+	it('should render the correct icon', async () => {
+		vi.spyOn(overview, 'isOverviewSubPage', 'get').mockReturnValue(false);
+		const { container, rerender } = renderComponent();
+
+		projectsStore.currentProject = { type: ProjectTypes.Personal } as Project;
+		await rerender({});
+		expect(container.querySelector('.fa-user')).toBeVisible();
+
+		const projectName = 'My Project';
+		projectsStore.currentProject = { name: projectName } as Project;
+		await rerender({});
+		expect(container.querySelector('.fa-layer-group')).toBeVisible();
+	});
+
 	it('should render the correct title and subtitle', async () => {
 		const { getByText, queryByText, rerender } = renderComponent();
 		const subtitle = 'All the workflows, credentials and executions you have access to';
diff --git a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
index 5cd8f35f877..d21fe6591b8 100644
--- a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
+++ b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
@@ -4,14 +4,16 @@ import { useRoute, useRouter } from 'vue-router';
 import type { UserAction } from '@n8n/design-system';
 import { N8nButton, N8nTooltip } from '@n8n/design-system';
 import { useI18n } from '@/composables/useI18n';
-import { ProjectTypes } from '@/types/projects.types';
+import { type ProjectIcon as ProjectIconType, ProjectTypes } from '@/types/projects.types';
 import { useProjectsStore } from '@/stores/projects.store';
 import ProjectTabs from '@/components/Projects/ProjectTabs.vue';
+import ProjectIcon from '@/components/Projects/ProjectIcon.vue';
 import { getResourcePermissions } from '@/permissions';
 import { VIEWS } from '@/constants';
 import { useSourceControlStore } from '@/stores/sourceControl.store';
 import ProjectCreateResource from '@/components/Projects/ProjectCreateResource.vue';
 import { useSettingsStore } from '@/stores/settings.store';
+import { useOverview } from '@/composables/useOverview';
 
 const route = useRoute();
 const router = useRouter();
@@ -19,11 +21,22 @@ const i18n = useI18n();
 const projectsStore = useProjectsStore();
 const sourceControlStore = useSourceControlStore();
 const settingsStore = useSettingsStore();
+const overview = useOverview();
 
 const emit = defineEmits<{
 	createFolder: [];
 }>();
 
+const headerIcon = computed((): ProjectIconType => {
+	if (projectsStore.currentProject?.type === ProjectTypes.Personal) {
+		return { type: 'icon', value: 'user' };
+	} else if (projectsStore.currentProject?.name) {
+		return projectsStore.currentProject.icon ?? { type: 'icon', value: 'layer-group' };
+	} else {
+		return { type: 'icon', value: 'home' };
+	}
+});
+
 const projectName = computed(() => {
 	if (!projectsStore.currentProject) {
 		return i18n.baseText('projects.menu.overview');
@@ -126,6 +139,12 @@ const onSelect = (action: string) => {
 	<div>
 		<div :class="$style.projectHeader">
 			<div :class="$style.projectDetails">
+				<ProjectIcon
+					v-if="!overview.isOverviewSubPage"
+					:icon="headerIcon"
+					:border-less="true"
+					size="medium"
+				/>
 				<div :class="$style.headerActions">
 					<N8nHeading bold tag="h2" size="xlarge">{{ projectName }}</N8nHeading>
 					<N8nText color="text-light">
@@ -168,7 +187,7 @@ const onSelect = (action: string) => {
 .projectHeader,
 .projectDescription {
 	display: flex;
-	align-items: center;
+	align-items: flex-start;
 	justify-content: space-between;
 	padding-bottom: var(--spacing-m);
 	min-height: var(--spacing-3xl);

From 9e3bfe23f67dca8d31bcff8758ed5d076477f9f3 Mon Sep 17 00:00:00 2001
From: Ricardo Espinoza <ricardo@n8n.io>
Date: Tue, 25 Mar 2025 05:49:21 -0400
Subject: [PATCH 22/33] fix(editor): Check for when to show the community+
 modal for the folder's feature (#14146)

Co-authored-by: Milorad Filipovic <milorad@n8n.io>
---
 .../frontend/editor-ui/src/views/WorkflowsView.vue  | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/frontend/editor-ui/src/views/WorkflowsView.vue b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
index 107eafb4131..ef5f4737f8b 100644
--- a/packages/frontend/editor-ui/src/views/WorkflowsView.vue
+++ b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
@@ -327,11 +327,16 @@ const hasFilters = computed(() => {
 	);
 });
 
-const isCommunity = computed(() => usageStore.planName.toLowerCase() === 'community');
+const isSelfHostedDeployment = computed(() => settingsStore.deploymentType === 'default');
+
 const canUserRegisterCommunityPlus = computed(
 	() => getResourcePermissions(usersStore.currentUser?.globalScopes).community.register,
 );
 
+const showRegisteredCommunityCTA = computed(
+	() => isSelfHostedDeployment.value && !foldersEnabled.value && canUserRegisterCommunityPlus.value,
+);
+
 /**
  * WATCHERS, STORE SUBSCRIPTIONS AND EVENT BUS HANDLERS
  */
@@ -1042,8 +1047,8 @@ const renameFolder = async (folderId: string) => {
 };
 
 const createFolderInCurrent = async () => {
-	// Show the community plus enrollment modal if the user is in a community plan
-	if (isCommunity.value && canUserRegisterCommunityPlus.value) {
+	// Show the community plus enrollment modal if the user is self-hosted, and hasn't enabled folders
+	if (showRegisteredCommunityCTA.value) {
 		uiStore.openModalWithData({
 			name: COMMUNITY_PLUS_ENROLLMENT_MODAL,
 			data: { customHeading: i18n.baseText('folders.registeredCommunity.cta.heading') },
@@ -1125,7 +1130,7 @@ const moveWorkflowToFolder = async (payload: {
 	name: string;
 	parentFolderId?: string;
 }) => {
-	if (isCommunity.value && canUserRegisterCommunityPlus.value) {
+	if (showRegisteredCommunityCTA.value) {
 		uiStore.openModalWithData({
 			name: COMMUNITY_PLUS_ENROLLMENT_MODAL,
 			data: { customHeading: i18n.baseText('folders.registeredCommunity.cta.heading') },

From 30e2df321889109743dcb8e9c7ba696892c57904 Mon Sep 17 00:00:00 2001
From: Alex Grozav <alex@grozav.com>
Date: Tue, 25 Mar 2025 12:15:03 +0200
Subject: [PATCH 23/33] feat(editor): Add support for Simulate nodes in new
 canvas (no-changelog) (#13675)

---
 .../editor-ui/src/__tests__/data/canvas.ts    |  2 +-
 .../frontend/editor-ui/src/__tests__/mocks.ts |  5 +++
 .../src/components/canvas/Canvas.test.ts      | 27 ++++++++++++++
 .../src/components/canvas/Canvas.vue          |  7 ++--
 .../src/composables/useCanvasMapping.ts       | 36 +++++++++++++++++--
 5 files changed, 69 insertions(+), 8 deletions(-)

diff --git a/packages/frontend/editor-ui/src/__tests__/data/canvas.ts b/packages/frontend/editor-ui/src/__tests__/data/canvas.ts
index ed7a6dc6707..520508fca11 100644
--- a/packages/frontend/editor-ui/src/__tests__/data/canvas.ts
+++ b/packages/frontend/editor-ui/src/__tests__/data/canvas.ts
@@ -56,7 +56,7 @@ export function createCanvasNodeData({
 
 export function createCanvasNodeElement({
 	id = '1',
-	type = 'default',
+	type = 'canvas-node',
 	label = 'Node',
 	position = { x: 100, y: 100 },
 	data,
diff --git a/packages/frontend/editor-ui/src/__tests__/mocks.ts b/packages/frontend/editor-ui/src/__tests__/mocks.ts
index c59fa6f893b..8ef9ad3637f 100644
--- a/packages/frontend/editor-ui/src/__tests__/mocks.ts
+++ b/packages/frontend/editor-ui/src/__tests__/mocks.ts
@@ -23,6 +23,7 @@ import {
 	MANUAL_TRIGGER_NODE_TYPE,
 	NO_OP_NODE_TYPE,
 	SET_NODE_TYPE,
+	SIMULATE_NODE_TYPE,
 	STICKY_NODE_TYPE,
 } from '@/constants';
 import type { INodeUi, IWorkflowDb } from '@/Interface';
@@ -50,6 +51,7 @@ export const mockNode = ({
 
 export const mockNodeTypeDescription = ({
 	name = SET_NODE_TYPE,
+	icon = 'fa:pen',
 	version = 1,
 	credentials = [],
 	inputs = [NodeConnectionTypes.Main],
@@ -58,6 +60,7 @@ export const mockNodeTypeDescription = ({
 	properties = [],
 }: {
 	name?: INodeTypeDescription['name'];
+	icon?: INodeTypeDescription['icon'];
 	version?: INodeTypeDescription['version'];
 	credentials?: INodeTypeDescription['credentials'];
 	inputs?: INodeTypeDescription['inputs'];
@@ -67,6 +70,7 @@ export const mockNodeTypeDescription = ({
 } = {}) =>
 	mock<INodeTypeDescription>({
 		name,
+		icon,
 		displayName: name,
 		description: '',
 		version,
@@ -102,6 +106,7 @@ export const mockNodes = [
 	mockNode({ name: 'Chat Trigger', type: CHAT_TRIGGER_NODE_TYPE }),
 	mockNode({ name: 'Agent', type: AGENT_NODE_TYPE }),
 	mockNode({ name: 'Sticky', type: STICKY_NODE_TYPE }),
+	mockNode({ name: 'Simulate', type: SIMULATE_NODE_TYPE }),
 	mockNode({ name: CanvasNodeRenderType.AddNodes, type: CanvasNodeRenderType.AddNodes }),
 	mockNode({ name: 'End', type: NO_OP_NODE_TYPE }),
 ];
diff --git a/packages/frontend/editor-ui/src/components/canvas/Canvas.test.ts b/packages/frontend/editor-ui/src/components/canvas/Canvas.test.ts
index 1ef938faec2..57e273aed6a 100644
--- a/packages/frontend/editor-ui/src/components/canvas/Canvas.test.ts
+++ b/packages/frontend/editor-ui/src/components/canvas/Canvas.test.ts
@@ -8,6 +8,7 @@ import { createCanvasConnection, createCanvasNodeElement } from '@/__tests__/dat
 import { NodeConnectionTypes } from 'n8n-workflow';
 import type { useDeviceSupport } from '@n8n/composables/useDeviceSupport';
 import { useVueFlow } from '@vue-flow/core';
+import { SIMULATE_NODE_TYPE } from '@/constants';
 
 const matchMedia = global.window.matchMedia;
 // @ts-expect-error Initialize window object
@@ -273,4 +274,30 @@ describe('Canvas', () => {
 			expect(patternCanvas?.innerHTML).not.toContain('<circle');
 		});
 	});
+
+	describe('simulate', () => {
+		it('should render simulate node', async () => {
+			const nodes = [
+				createCanvasNodeElement({
+					id: '1',
+					label: 'Node',
+					position: { x: 200, y: 200 },
+					data: {
+						type: SIMULATE_NODE_TYPE,
+						typeVersion: 1,
+					},
+				}),
+			];
+
+			const { container } = renderComponent({
+				props: {
+					nodes,
+				},
+			});
+
+			await waitFor(() => expect(container.querySelectorAll('.vue-flow__node')).toHaveLength(1));
+
+			expect(container.querySelector('.icon')).toBeInTheDocument();
+		});
+	});
 });
diff --git a/packages/frontend/editor-ui/src/components/canvas/Canvas.vue b/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
index 5808e6ce9c9..f538c0082d5 100644
--- a/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
+++ b/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
@@ -1,10 +1,7 @@
 <script lang="ts" setup>
 import ContextMenu from '@/components/ContextMenu/ContextMenu.vue';
-import {
-	type CanvasLayoutEvent,
-	type CanvasLayoutSource,
-	useCanvasLayout,
-} from '@/composables/useCanvasLayout';
+import type { CanvasLayoutEvent, CanvasLayoutSource } from '@/composables/useCanvasLayout';
+import { useCanvasLayout } from '@/composables/useCanvasLayout';
 import { useCanvasNodeHover } from '@/composables/useCanvasNodeHover';
 import { useCanvasTraversal } from '@/composables/useCanvasTraversal';
 import { type ContextMenuAction, useContextMenu } from '@/composables/useContextMenu';
diff --git a/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts b/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
index ceff397debe..ae92ec6c4dd 100644
--- a/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
+++ b/packages/frontend/editor-ui/src/composables/useCanvasMapping.ts
@@ -44,7 +44,14 @@ import {
 	WAIT_INDEFINITELY,
 } from 'n8n-workflow';
 import type { INodeUi } from '@/Interface';
-import { CUSTOM_API_CALL_KEY, FORM_NODE_TYPE, STICKY_NODE_TYPE, WAIT_NODE_TYPE } from '@/constants';
+import {
+	CUSTOM_API_CALL_KEY,
+	FORM_NODE_TYPE,
+	SIMULATE_NODE_TYPE,
+	SIMULATE_TRIGGER_NODE_TYPE,
+	STICKY_NODE_TYPE,
+	WAIT_NODE_TYPE,
+} from '@/constants';
 import { sanitizeHtml } from '@/utils/htmlUtils';
 import { MarkerType } from '@vue-flow/core';
 import { useNodeHelpers } from './useNodeHelpers';
@@ -88,7 +95,12 @@ export function useCanvasMapping({
 
 	function createDefaultNodeRenderType(node: INodeUi): CanvasNodeDefaultRender {
 		const nodeType = nodeTypeDescriptionByNodeId.value[node.id];
-		const icon = getNodeIconSource(nodeType);
+		const icon = getNodeIconSource(
+			simulatedNodeTypeDescriptionByNodeId.value[node.id]
+				? simulatedNodeTypeDescriptionByNodeId.value[node.id]
+				: nodeType,
+		);
+
 		return {
 			type: CanvasNodeRenderType.Default,
 			options: {
@@ -514,6 +526,26 @@ export function useCanvasMapping({
 		);
 	});
 
+	const simulatedNodeTypeDescriptionByNodeId = computed(() => {
+		return nodes.value.reduce<Record<string, INodeTypeDescription | null>>((acc, node) => {
+			if ([SIMULATE_NODE_TYPE, SIMULATE_TRIGGER_NODE_TYPE].includes(node.type)) {
+				const icon = node.parameters?.icon as string;
+				const iconValue = workflowObject.value.expression.getSimpleParameterValue(
+					node,
+					icon,
+					'internal',
+					{},
+				);
+
+				if (iconValue && typeof iconValue === 'string') {
+					acc[node.id] = nodeTypesStore.getNodeType(iconValue);
+				}
+			}
+
+			return acc;
+		}, {});
+	});
+
 	const mappedNodes = computed<CanvasNode[]>(() => [
 		...nodes.value.map<CanvasNode>((node) => {
 			const inputConnections = workflowObject.value.connectionsByDestinationNode[node.name] ?? {};

From acbaec550f1ebf560262d6a6492651ebaf72d78d Mon Sep 17 00:00:00 2001
From: Alex Grozav <alex@grozav.com>
Date: Tue, 25 Mar 2025 12:29:14 +0200
Subject: [PATCH 24/33] fix(editor): Remove selection box when only one node
 selected using selection rectangle (#14160)

---
 .../frontend/editor-ui/src/components/canvas/Canvas.vue   | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/packages/frontend/editor-ui/src/components/canvas/Canvas.vue b/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
index f538c0082d5..d23c09e3fb1 100644
--- a/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
+++ b/packages/frontend/editor-ui/src/components/canvas/Canvas.vue
@@ -139,6 +139,7 @@ const {
 	onNodesInitialized,
 	findNode,
 	viewport,
+	nodesSelectionActive,
 	onEdgeMouseLeave,
 	onEdgeMouseEnter,
 	onEdgeMouseMove,
@@ -357,6 +358,12 @@ function onSelectionDragStop(event: NodeDragEvent) {
 	onUpdateNodesPosition(event.nodes.map(({ id, position }) => ({ id, position })));
 }
 
+function onSelectionEnd() {
+	if (selectedNodes.value.length === 1) {
+		nodesSelectionActive.value = false;
+	}
+}
+
 function onSetNodeActivated(id: string) {
 	props.eventBus.emit('nodes:action', { ids: [id], action: 'update:node:activated' });
 	emit('update:node:activated', id);
@@ -796,6 +803,7 @@ provide(CanvasKey, {
 		@node-drag-stop="onNodeDragStop"
 		@node-click="onNodeClick"
 		@selection-drag-stop="onSelectionDragStop"
+		@selection-end="onSelectionEnd"
 		@selection-context-menu="onOpenSelectionContextMenu"
 		@dragover="onDragOver"
 		@drop="onDrop"

From ca01236dd11b3c021358671ed99cbada4a34e325 Mon Sep 17 00:00:00 2001
From: Charlie Kolb <charlie@n8n.io>
Date: Tue, 25 Mar 2025 11:30:20 +0100
Subject: [PATCH 25/33] fix(editor): Change freeAiCredits success text size
 (#14161)

---
 .../editor-ui/src/components/FreeAiCreditsCallout.vue         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/frontend/editor-ui/src/components/FreeAiCreditsCallout.vue b/packages/frontend/editor-ui/src/components/FreeAiCreditsCallout.vue
index 97dd4eb9dbe..c45eaf0f401 100644
--- a/packages/frontend/editor-ui/src/components/FreeAiCreditsCallout.vue
+++ b/packages/frontend/editor-ui/src/components/FreeAiCreditsCallout.vue
@@ -111,14 +111,14 @@ const onClaimCreditsClicked = async () => {
 			</template>
 		</n8n-callout>
 		<n8n-callout v-else-if="showSuccessCallout" theme="success" icon="check-circle">
-			<n8n-text>
+			<n8n-text size="small">
 				{{
 					i18n.baseText('freeAi.credits.callout.success.title.part1', {
 						interpolate: { credits: settingsStore.aiCreditsQuota },
 					})
 				}}</n8n-text
 			>&nbsp;
-			<n8n-text :bold="true">
+			<n8n-text size="small" bold="true">
 				{{ i18n.baseText('freeAi.credits.callout.success.title.part2') }}</n8n-text
 			>
 		</n8n-callout>

From 1ff3049ffbc46c862e36e303205a419d6eacf47f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milorad=20FIlipovi=C4=87?= <milorad@n8n.io>
Date: Tue, 25 Mar 2025 11:56:37 +0100
Subject: [PATCH 26/33] fix(editor): Fix folders UI for different plans
 (no-changelog) (#14159)

---
 cypress/composables/folders.ts                           | 5 +++++
 cypress/e2e/49-folders.cy.ts                             | 9 +++++++++
 .../editor-ui/src/components/Projects/ProjectHeader.vue  | 5 ++++-
 packages/frontend/editor-ui/src/views/WorkflowsView.vue  | 8 ++++----
 4 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/cypress/composables/folders.ts b/cypress/composables/folders.ts
index 56085c0a3e2..ab710a279de 100644
--- a/cypress/composables/folders.ts
+++ b/cypress/composables/folders.ts
@@ -212,6 +212,11 @@ export function getNewFolderNameInput() {
 export function getNewFolderModalErrorMessage() {
 	return cy.get('.el-message-box__errormsg').filter(':visible');
 }
+
+export function getProjectTab(tabId: string) {
+	return cy.getByTestId('project-tabs').find(`#${tabId}`);
+}
+
 /**
  * Actions
  */
diff --git a/cypress/e2e/49-folders.cy.ts b/cypress/e2e/49-folders.cy.ts
index a0ee846c1c7..1cf4f17d857 100644
--- a/cypress/e2e/49-folders.cy.ts
+++ b/cypress/e2e/49-folders.cy.ts
@@ -32,6 +32,7 @@ import {
 	getPersonalProjectMenuItem,
 	getProjectEmptyState,
 	getProjectMenuItem,
+	getProjectTab,
 	getVisibleListBreadcrumbs,
 	getWorkflowCard,
 	getWorkflowCardBreadcrumbs,
@@ -64,12 +65,16 @@ describe('Folders', () => {
 
 	describe('Create and navigate folders', () => {
 		it('should create folder from the project header', () => {
+			// 1. In project root
 			getPersonalProjectMenuItem().click();
 			createFolderFromProjectHeader('My Folder');
 			getFolderCards().should('have.length.greaterThan', 0);
 			// Clicking on the success toast should navigate to the folder
 			successToast().find('a').click();
 			getCurrentBreadcrumb().should('contain.text', 'My Folder');
+			// 2. In a folder
+			createFolderFromListHeaderButton('My Folder 2');
+			getFolderCard('My Folder 2').should('exist');
 		});
 
 		it('should not allow illegal folder names', () => {
@@ -217,6 +222,10 @@ describe('Folders', () => {
 			cy.getByTestId('action-folder').should('exist');
 			createFolderFromProjectHeader('Personal Folder');
 			getFolderCards().should('exist');
+			// Create folder option should not be available on credentials tab
+			getProjectTab('ProjectsCredentials').click();
+			getAddResourceDropdown().click();
+			cy.getByTestId('action-folder').should('not.exist');
 		});
 	});
 
diff --git a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
index d21fe6591b8..0450e200b63 100644
--- a/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
+++ b/packages/frontend/editor-ui/src/components/Projects/ProjectHeader.vue
@@ -61,7 +61,10 @@ const showSettings = computed(
 const homeProject = computed(() => projectsStore.currentProject ?? projectsStore.personalProject);
 
 const showFolders = computed(() => {
-	return settingsStore.isFoldersFeatureEnabled && route.name !== VIEWS.WORKFLOWS;
+	return (
+		settingsStore.isFoldersFeatureEnabled &&
+		[VIEWS.PROJECTS_WORKFLOWS, VIEWS.PROJECTS_FOLDERS].includes(route.name as VIEWS)
+	);
 });
 
 const ACTION_TYPES = {
diff --git a/packages/frontend/editor-ui/src/views/WorkflowsView.vue b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
index ef5f4737f8b..3bbbbca12ca 100644
--- a/packages/frontend/editor-ui/src/views/WorkflowsView.vue
+++ b/packages/frontend/editor-ui/src/views/WorkflowsView.vue
@@ -1231,13 +1231,13 @@ const onCreateWorkflowClick = () => {
 				/>
 			</ProjectHeader>
 		</template>
-		<template v-if="foldersEnabled" #add-button>
+		<template v-if="foldersEnabled || showRegisteredCommunityCTA" #add-button>
 			<N8nTooltip
 				placement="top"
 				:disabled="!(isOverviewPage || (!readOnlyEnv && hasPermissionToCreateFolders))"
 			>
 				<template #content>
-					<span v-if="isOverviewPage">
+					<span v-if="isOverviewPage && !showRegisteredCommunityCTA">
 						<span v-if="teamProjectsEnabled">
 							{{ i18n.baseText('folders.add.overview.withProjects.message') }}
 						</span>
@@ -1245,7 +1245,7 @@ const onCreateWorkflowClick = () => {
 							{{ i18n.baseText('folders.add.overview.community.message') }}
 						</span>
 					</span>
-					<span v-else-if="!readOnlyEnv && hasPermissionToCreateFolders">
+					<span v-else>
 						{{
 							currentParentName
 								? i18n.baseText('folders.add.to.parent.message', {
@@ -1261,7 +1261,7 @@ const onCreateWorkflowClick = () => {
 					type="tertiary"
 					data-test-id="add-folder-button"
 					:class="$style['add-folder-button']"
-					:disabled="readOnlyEnv || !hasPermissionToCreateFolders"
+					:disabled="!showRegisteredCommunityCTA && (readOnlyEnv || !hasPermissionToCreateFolders)"
 					@click="createFolderInCurrent"
 				/>
 			</N8nTooltip>

From 6eee081cf3f99e7cf925a0daef0728e5537e1e57 Mon Sep 17 00:00:00 2001
From: Guillaume Jacquart <jacquart.guillaume@gmail.com>
Date: Tue, 25 Mar 2025 12:37:58 +0100
Subject: [PATCH 27/33] feat(API): Create schema and dto types for insights
 dashboard query param and api responses (#14163)

---
 packages/@n8n/api-types/src/dto/index.ts      |   2 +
 .../__tests__/list-workflow-query.dto.test.ts |  94 ++++++++++
 .../dto/insights/list-workflow-query.dto.ts   |  50 ++++++
 .../schemas/__tests__/insights.schema.test.ts | 165 +++++++++++++++++-
 .../api-types/src/schemas/insights.schema.ts  |  41 +++++
 5 files changed, 351 insertions(+), 1 deletion(-)
 create mode 100644 packages/@n8n/api-types/src/dto/insights/__tests__/list-workflow-query.dto.test.ts
 create mode 100644 packages/@n8n/api-types/src/dto/insights/list-workflow-query.dto.ts

diff --git a/packages/@n8n/api-types/src/dto/index.ts b/packages/@n8n/api-types/src/dto/index.ts
index a71042048ed..3fd35441b8b 100644
--- a/packages/@n8n/api-types/src/dto/index.ts
+++ b/packages/@n8n/api-types/src/dto/index.ts
@@ -59,3 +59,5 @@ export { CreateFolderDto } from './folders/create-folder.dto';
 export { UpdateFolderDto } from './folders/update-folder.dto';
 export { DeleteFolderDto } from './folders/delete-folder.dto';
 export { ListFolderQueryDto } from './folders/list-folder-query.dto';
+
+export { ListInsightsWorkflowQueryDto } from './insights/list-workflow-query.dto';
diff --git a/packages/@n8n/api-types/src/dto/insights/__tests__/list-workflow-query.dto.test.ts b/packages/@n8n/api-types/src/dto/insights/__tests__/list-workflow-query.dto.test.ts
new file mode 100644
index 00000000000..70455a56ce2
--- /dev/null
+++ b/packages/@n8n/api-types/src/dto/insights/__tests__/list-workflow-query.dto.test.ts
@@ -0,0 +1,94 @@
+import { ListInsightsWorkflowQueryDto } from '../list-workflow-query.dto';
+
+const DEFAULT_PAGINATION = { skip: 0, take: 10 };
+
+describe('ListInsightsWorkflowQueryDto', () => {
+	describe('Valid requests', () => {
+		test.each([
+			{
+				name: 'empty object (no filters)',
+				request: {},
+				parsedResult: DEFAULT_PAGINATION,
+			},
+			{
+				name: 'valid sortBy',
+				request: {
+					sortBy: 'total:asc',
+				},
+				parsedResult: {
+					...DEFAULT_PAGINATION,
+					sortBy: 'total:asc',
+				},
+			},
+			{
+				name: 'valid skip and take',
+				request: {
+					skip: '0',
+					take: '20',
+				},
+				parsedResult: {
+					skip: 0,
+					take: 20,
+				},
+			},
+			{
+				name: 'full query parameters',
+				request: {
+					skip: '0',
+					take: '10',
+					sortBy: 'total:desc',
+				},
+				parsedResult: {
+					skip: 0,
+					take: 10,
+					sortBy: 'total:desc',
+				},
+			},
+		])('should validate $name', ({ request, parsedResult }) => {
+			const result = ListInsightsWorkflowQueryDto.safeParse(request);
+			expect(result.success).toBe(true);
+			if (parsedResult) {
+				expect(result.data).toMatchObject(parsedResult);
+			}
+		});
+	});
+
+	describe('Invalid requests', () => {
+		test.each([
+			{
+				name: 'invalid skip format',
+				request: {
+					skip: 'not-a-number',
+					take: '10',
+				},
+				expectedErrorPath: ['skip'],
+			},
+			{
+				name: 'invalid take format',
+				request: {
+					skip: '0',
+					take: 'not-a-number',
+				},
+				expectedErrorPath: ['take'],
+			},
+			{
+				name: 'invalid sortBy value',
+				request: {
+					sortBy: 'invalid-value',
+				},
+				expectedErrorPath: ['sortBy'],
+			},
+		])('should fail validation for $name', ({ request, expectedErrorPath }) => {
+			const result = ListInsightsWorkflowQueryDto.safeParse(request);
+
+			expect(result.success).toBe(false);
+
+			if (expectedErrorPath && !result.success) {
+				if (Array.isArray(expectedErrorPath)) {
+					const errorPaths = result.error.issues[0].path;
+					expect(errorPaths).toContain(expectedErrorPath[0]);
+				}
+			}
+		});
+	});
+});
diff --git a/packages/@n8n/api-types/src/dto/insights/list-workflow-query.dto.ts b/packages/@n8n/api-types/src/dto/insights/list-workflow-query.dto.ts
new file mode 100644
index 00000000000..9ed00a6550d
--- /dev/null
+++ b/packages/@n8n/api-types/src/dto/insights/list-workflow-query.dto.ts
@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Z } from 'zod-class';
+
+const VALID_SORT_OPTIONS = [
+	'total:asc',
+	'total:desc',
+	'succeeded:asc',
+	'succeeded:desc',
+	'failed:asc',
+	'failed:desc',
+	'timeSaved:asc',
+	'timeSaved:desc',
+	'runTime:asc',
+	'runTime:desc',
+	'averageRunTime:asc',
+	'averageRunTime:desc',
+] as const;
+
+// ---------------------
+// Parameter Validators
+// ---------------------
+
+// Skip parameter validation
+const skipValidator = z
+	.string()
+	.optional()
+	.transform((val) => (val ? parseInt(val, 10) : 0))
+	.refine((val) => !isNaN(val), {
+		message: 'Skip must be a valid number',
+	});
+
+// Take parameter validation
+const takeValidator = z
+	.string()
+	.optional()
+	.transform((val) => (val ? parseInt(val, 10) : 10))
+	.refine((val) => !isNaN(val), {
+		message: 'Take must be a valid number',
+	});
+
+// SortBy parameter validation
+const sortByValidator = z
+	.enum(VALID_SORT_OPTIONS, { message: `sortBy must be one of: ${VALID_SORT_OPTIONS.join(', ')}` })
+	.optional();
+
+export class ListInsightsWorkflowQueryDto extends Z.class({
+	skip: skipValidator,
+	take: takeValidator,
+	sortBy: sortByValidator,
+}) {}
diff --git a/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts b/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
index 020b3df5408..266fb5562ac 100644
--- a/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
+++ b/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
@@ -1,4 +1,8 @@
-import { insightsSummarySchema } from '../insights.schema';
+import {
+	insightsByTimeSchema,
+	insightsByWorkflowSchema,
+	insightsSummarySchema,
+} from '../insights.schema';
 
 describe('insightsSummarySchema', () => {
 	test.each([
@@ -62,3 +66,162 @@ describe('insightsSummarySchema', () => {
 		expect(result.success).toBe(expected);
 	});
 });
+
+describe('insightsByWorkflowSchema', () => {
+	test.each([
+		{
+			name: 'valid workflow insights',
+			value: {
+				count: 2,
+				data: [
+					{
+						workflowId: 'w1',
+						workflowName: 'Test Workflow',
+						projectId: 'p1',
+						projectName: 'Test Project',
+						total: 100,
+						succeeded: 90,
+						failed: 10,
+						failureRate: 0.56,
+						runTime: 300,
+						averageRunTime: 30.5,
+						timeSaved: 50,
+					},
+				],
+			},
+			expected: true,
+		},
+		{
+			name: 'wrong data type',
+			value: {
+				count: 2,
+				data: [
+					{
+						workflowId: 'w1',
+						total: '100',
+						succeeded: 90,
+						failed: 10,
+						failureRate: 10,
+						runTime: 300,
+						averageRunTime: 30,
+						timeSaved: 50,
+					},
+				],
+			},
+			expected: false,
+		},
+		{
+			name: 'missing required field',
+			value: {
+				count: 2,
+				data: [
+					{
+						workflowId: 'w1',
+						total: 100,
+						succeeded: 90,
+						failed: 10,
+						failureRate: 10,
+						runTime: 300,
+						averageRunTime: 30,
+					},
+				],
+			},
+			expected: false,
+		},
+		{
+			name: 'unexpected key',
+			value: {
+				count: 2,
+				data: [
+					{
+						workflowId: 'w1',
+						total: 100,
+						succeeded: 90,
+						failed: 10,
+						failureRate: 10,
+						runTime: 300,
+						averageRunTime: 30,
+						timeSaved: 50,
+						extraKey: 'value',
+					},
+				],
+			},
+			expected: false,
+		},
+	])('should validate $name', ({ value, expected }) => {
+		const result = insightsByWorkflowSchema.safeParse(value);
+		expect(result.success).toBe(expected);
+	});
+});
+
+describe('insightsByTimeSchema', () => {
+	test.each([
+		{
+			name: 'valid insights by time',
+			value: {
+				date: '2025-03-25T10:34:36.484Z',
+				values: {
+					total: 200,
+					failureRate: 10,
+					averageRunTime: 40,
+					timeSaved: 100,
+				},
+			},
+			expected: true,
+		},
+		{
+			name: 'invalid date format',
+			value: {
+				date: '20240325', // Should be a string
+				values: {
+					total: 200,
+					failureRate: 10,
+					averageRunTime: 40,
+					timeSaved: 100,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: 'invalid field type',
+			value: {
+				date: 20240325, // Should be a string
+				values: {
+					total: 200,
+					failureRate: 10,
+					averageRunTime: 40,
+					timeSaved: 100,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: 'missing required key',
+			value: {
+				date: '2025-03-25T10:34:36.484Z',
+				values: {
+					total: 200,
+					failureRate: 10,
+					averageRunTime: 40,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: 'unexpected key',
+			value: {
+				date: '2025-03-25T10:34:36.484Z',
+				values: {
+					total: 200,
+					failureRate: 10,
+					averageRunTime: 40,
+					extraKey: 'value',
+				},
+			},
+			expected: false,
+		},
+	])('should validate $name', ({ value, expected }) => {
+		const result = insightsByTimeSchema.safeParse(value);
+		expect(result.success).toBe(expected);
+	});
+});
diff --git a/packages/@n8n/api-types/src/schemas/insights.schema.ts b/packages/@n8n/api-types/src/schemas/insights.schema.ts
index 170a74abfe8..8dda1000ca3 100644
--- a/packages/@n8n/api-types/src/schemas/insights.schema.ts
+++ b/packages/@n8n/api-types/src/schemas/insights.schema.ts
@@ -42,3 +42,44 @@ export const insightsSummaryDataSchemas = {
 
 export const insightsSummarySchema = z.object(insightsSummaryDataSchemas).strict();
 export type InsightsSummary = z.infer<typeof insightsSummarySchema>;
+
+export const insightsByWorkflowDataSchemas = {
+	count: z.number(),
+	data: z.array(
+		z
+			.object({
+				workflowId: z.string(),
+				workflowName: z.string().optional(),
+				projectId: z.string().optional(),
+				projectName: z.string().optional(),
+				total: z.number(),
+				succeeded: z.number(),
+				failed: z.number(),
+				failureRate: z.number(),
+				runTime: z.number(),
+				averageRunTime: z.number(),
+				timeSaved: z.number(),
+			})
+			.strict(),
+	),
+} as const;
+
+export const insightsByWorkflowSchema = z.object(insightsByWorkflowDataSchemas).strict();
+export type InsightsByWorkflow = z.infer<typeof insightsByWorkflowSchema>;
+
+export const insightsByTimeDataSchemas = {
+	date: z.string().refine((val) => !isNaN(Date.parse(val)) && new Date(val).toISOString() === val, {
+		message: 'Invalid date format, must be ISO 8601 format',
+	}),
+	values: z
+		.object({
+			total: z.number(),
+			failureRate: z.number(),
+			averageRunTime: z.number(),
+			timeSaved: z.number(),
+		})
+		.strict(),
+} as const;
+
+export const insightsByTimeSchema = z.object(insightsByTimeDataSchemas).strict();
+export type InsightsByTime = z.infer<typeof insightsByTimeSchema>;

From 8aad7dbaf69d7e2826f8798b6682d269c6c6f37f Mon Sep 17 00:00:00 2001
From: Eti Ijeoma <53005190+Aijeyomah@users.noreply.github.com>
Date: Tue, 25 Mar 2025 14:31:12 +0100
Subject: [PATCH 28/33] fix(editor): Handle Leading Spaces in Workflow Search
 (#13889)

---
 .../Node/NodeCreator/NodesListPanel.test.ts      | 16 ++++++++++++++++
 .../Node/NodeCreator/Panel/SearchBar.vue         |  2 +-
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/packages/frontend/editor-ui/src/components/Node/NodeCreator/NodesListPanel.test.ts b/packages/frontend/editor-ui/src/components/Node/NodeCreator/NodesListPanel.test.ts
index bdc2b868162..4bd7e98baf0 100644
--- a/packages/frontend/editor-ui/src/components/Node/NodeCreator/NodesListPanel.test.ts
+++ b/packages/frontend/editor-ui/src/components/Node/NodeCreator/NodesListPanel.test.ts
@@ -247,5 +247,21 @@ describe('NodesListPanel', () => {
 			await nextTick();
 			expect(screen.queryAllByTestId('item-iterator-item')).toHaveLength(9);
 		});
+
+		it('should trim search input before emitting update', async () => {
+			renderComponent();
+			await nextTick();
+
+			expect(screen.queryByTestId('node-creator-search-bar')).toBeInTheDocument();
+			await fireEvent.input(screen.getByTestId('node-creator-search-bar'), {
+				target: { value: '    Node 1' },
+			});
+			await nextTick();
+
+			expect(screen.queryAllByTestId('item-iterator-item')).toHaveLength(1);
+			expect(screen.queryByText('Node 1')).toBeInTheDocument();
+
+			expect(screen.getByTestId('node-creator-search-bar')).toHaveValue('Node 1');
+		});
 	});
 });
diff --git a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/SearchBar.vue b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/SearchBar.vue
index 57b0184340e..d7a9f224bfd 100644
--- a/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/SearchBar.vue
+++ b/packages/frontend/editor-ui/src/components/Node/NodeCreator/Panel/SearchBar.vue
@@ -28,7 +28,7 @@ function focus() {
 
 function onInput(event: Event) {
 	const input = event.target as HTMLInputElement;
-	emit('update:modelValue', input.value);
+	emit('update:modelValue', input.value.trim());
 }
 
 function clear() {

From 22e6569f7eb88b31e2eaba7f508520afbd15dbdd Mon Sep 17 00:00:00 2001
From: oleg <me@olegivaniv.com>
Date: Tue, 25 Mar 2025 14:45:20 +0100
Subject: [PATCH 29/33] feat(Evaluation Metrics Node): Add Evaluation Metrics
 node (no-changelog) (#14050)

---
 .../AssignmentCollection/Assignment.vue       |   3 +-
 .../AssignmentCollection.test.ts              |  65 ++++++++++
 .../AssignmentCollection.vue                  |  14 ++-
 .../src/components/ParameterInputList.vue     |   2 +
 .../editor-ui/src/plugins/icons/index.ts      |   2 +
 .../EvaluationMetrics.node.json               |  14 +++
 .../EvaluationMetrics.node.test.ts            | 111 ++++++++++++++++++
 .../EvaluationMetrics.node.ts                 | 109 +++++++++++++++++
 packages/nodes-base/package.json              |   1 +
 packages/workflow/src/Interfaces.ts           |   2 +
 10 files changed, 319 insertions(+), 4 deletions(-)
 create mode 100644 packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.json
 create mode 100644 packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.test.ts
 create mode 100644 packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.ts

diff --git a/packages/frontend/editor-ui/src/components/AssignmentCollection/Assignment.vue b/packages/frontend/editor-ui/src/components/AssignmentCollection/Assignment.vue
index 96f940711eb..5e9512fb213 100644
--- a/packages/frontend/editor-ui/src/components/AssignmentCollection/Assignment.vue
+++ b/packages/frontend/editor-ui/src/components/AssignmentCollection/Assignment.vue
@@ -17,6 +17,7 @@ interface Props {
 	modelValue: AssignmentValue;
 	issues: string[];
 	hideType?: boolean;
+	disableType?: boolean;
 	isReadOnly?: boolean;
 	index?: number;
 }
@@ -163,7 +164,7 @@ const onBlur = (): void => {
 					<TypeSelect
 						:class="$style.select"
 						:model-value="assignment.type ?? 'string'"
-						:is-read-only="isReadOnly"
+						:is-read-only="disableType || isReadOnly"
 						@update:model-value="onAssignmentTypeChange"
 					>
 					</TypeSelect>
diff --git a/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.test.ts b/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.test.ts
index 39a9638fa00..43c31c1e0ff 100644
--- a/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.test.ts
+++ b/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.test.ts
@@ -151,4 +151,69 @@ describe('AssignmentCollection.vue', () => {
 		expect(getAssignmentType(assignments[3])).toEqual('Object');
 		expect(getAssignmentType(assignments[4])).toEqual('Array');
 	});
+
+	describe('defaultType prop', () => {
+		it('should use string as default type when no defaultType is specified', async () => {
+			const { getByTestId, findAllByTestId } = renderComponent();
+
+			await userEvent.click(getByTestId('assignment-collection-drop-area'));
+
+			const assignments = await findAllByTestId('assignment');
+			expect(assignments.length).toBe(1);
+			expect(getAssignmentType(assignments[0])).toEqual('String');
+		});
+
+		it('should use specified defaultType when adding a new assignment manually', async () => {
+			const { getByTestId, findAllByTestId } = renderComponent({
+				props: {
+					defaultType: 'number',
+				},
+			});
+
+			await userEvent.click(getByTestId('assignment-collection-drop-area'));
+
+			const assignments = await findAllByTestId('assignment');
+			expect(assignments.length).toBe(1);
+			expect(getAssignmentType(assignments[0])).toEqual('Number');
+		});
+
+		it('should use defaultType for drag and drop when disableType is true', async () => {
+			const { getByTestId, findAllByTestId } = renderComponent({
+				props: {
+					defaultType: 'number',
+					disableType: true,
+				},
+			});
+
+			const dropArea = getByTestId('drop-area');
+
+			// Even though we're dropping a string value, it should use number type because of defaultType
+			await dropAssignment({ key: 'stringKey', value: 'stringValue', dropArea });
+
+			const assignments = await findAllByTestId('assignment');
+			expect(assignments.length).toBe(1);
+			expect(getAssignmentType(assignments[0])).toEqual('Number');
+		});
+
+		it('should respect defaultType for all assignments when provided', async () => {
+			const { getByTestId, findAllByTestId } = renderComponent({
+				props: {
+					defaultType: 'boolean',
+				},
+			});
+
+			const dropArea = getByTestId('drop-area');
+
+			await userEvent.click(getByTestId('assignment-collection-drop-area'));
+
+			await dropAssignment({ key: 'stringKey', value: 'stringValue', dropArea });
+			await dropAssignment({ key: 'numberKey', value: 25, dropArea });
+
+			const assignments = await findAllByTestId('assignment');
+			expect(assignments.length).toBe(3);
+			expect(getAssignmentType(assignments[0])).toEqual('Boolean');
+			expect(getAssignmentType(assignments[1])).toEqual('Boolean');
+			expect(getAssignmentType(assignments[2])).toEqual('Boolean');
+		});
+	});
 });
diff --git a/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.vue b/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.vue
index 213269ab2f3..6d0d3bfcbd3 100644
--- a/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.vue
+++ b/packages/frontend/editor-ui/src/components/AssignmentCollection/AssignmentCollection.vue
@@ -5,6 +5,7 @@ import { useNDVStore } from '@/stores/ndv.store';
 import type {
 	AssignmentCollectionValue,
 	AssignmentValue,
+	FieldTypeMap,
 	INode,
 	INodeProperties,
 } from 'n8n-workflow';
@@ -20,11 +21,17 @@ interface Props {
 	parameter: INodeProperties;
 	value: AssignmentCollectionValue;
 	path: string;
+	defaultType?: keyof FieldTypeMap;
+	disableType?: boolean;
 	node: INode | null;
 	isReadOnly?: boolean;
 }
 
-const props = withDefaults(defineProps<Props>(), { isReadOnly: false });
+const props = withDefaults(defineProps<Props>(), {
+	isReadOnly: false,
+	defaultType: undefined,
+	disableType: false,
+});
 
 const emit = defineEmits<{
 	valueChanged: [value: { name: string; node: string; value: AssignmentCollectionValue }];
@@ -82,7 +89,7 @@ function addAssignment(): void {
 		id: crypto.randomUUID(),
 		name: '',
 		value: '',
-		type: 'string',
+		type: props.defaultType ?? 'string',
 	});
 }
 
@@ -91,7 +98,7 @@ function dropAssignment(expression: string): void {
 		id: crypto.randomUUID(),
 		name: propertyNameFromExpression(expression),
 		value: `=${expression}`,
-		type: typeFromExpression(expression),
+		type: props.defaultType ?? typeFromExpression(expression),
 	});
 }
 
@@ -157,6 +164,7 @@ function optionSelected(action: string) {
 							:issues="getIssues(index)"
 							:class="$style.assignment"
 							:is-read-only="isReadOnly"
+							:disable-type="disableType"
 							@update:model-value="(value) => onAssignmentUpdate(index, value)"
 							@remove="() => onAssignmentRemove(index)"
 						>
diff --git a/packages/frontend/editor-ui/src/components/ParameterInputList.vue b/packages/frontend/editor-ui/src/components/ParameterInputList.vue
index 740e4de47cb..8c625b348d8 100644
--- a/packages/frontend/editor-ui/src/components/ParameterInputList.vue
+++ b/packages/frontend/editor-ui/src/components/ParameterInputList.vue
@@ -665,6 +665,8 @@ function getParameterValue<T extends NodeParameterValueType = NodeParameterValue
 				:path="getPath(parameter.name)"
 				:node="node"
 				:is-read-only="isReadOnly"
+				:default-type="parameter.typeOptions?.assignment?.defaultType"
+				:disable-type="parameter.typeOptions?.assignment?.disableType"
 				@value-changed="valueChanged"
 			/>
 			<div v-else-if="credentialsParameterIndex !== index" class="parameter-item">
diff --git a/packages/frontend/editor-ui/src/plugins/icons/index.ts b/packages/frontend/editor-ui/src/plugins/icons/index.ts
index cb526515c47..ef2d11a2cc3 100644
--- a/packages/frontend/editor-ui/src/plugins/icons/index.ts
+++ b/packages/frontend/editor-ui/src/plugins/icons/index.ts
@@ -29,6 +29,7 @@ import {
 	faChartBar,
 	faCheck,
 	faCheckCircle,
+	faCheckDouble,
 	faCheckSquare,
 	faChevronDown,
 	faChevronUp,
@@ -225,6 +226,7 @@ export const FontAwesomePlugin: Plugin = {
 		addIcon(faChartBar);
 		addIcon(faCheck);
 		addIcon(faCheckCircle);
+		addIcon(faCheckDouble);
 		addIcon(faCheckSquare);
 		addIcon(faChevronLeft);
 		addIcon(faChevronRight);
diff --git a/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.json b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.json
new file mode 100644
index 00000000000..19343f021cb
--- /dev/null
+++ b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.json
@@ -0,0 +1,14 @@
+{
+	"node": "n8n-nodes-base.evaluationMetrics",
+	"nodeVersion": "1.0",
+	"codexVersion": "1.0",
+	"categories": ["Evaluation", "Core Nodes"],
+	"resources": {
+		"primaryDocumentation": [
+			{
+				"url": "https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.evaluationmetrics/"
+			}
+		]
+	},
+	"alias": ["Metric"]
+}
diff --git a/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.test.ts b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.test.ts
new file mode 100644
index 00000000000..9d5e2155200
--- /dev/null
+++ b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.test.ts
@@ -0,0 +1,111 @@
+import { mock } from 'jest-mock-extended';
+import type { INodeTypes, IExecuteFunctions, AssignmentCollectionValue } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import { EvaluationMetrics } from './EvaluationMetrics.node';
+
+describe('EvaluationMetrics Node', () => {
+	const nodeTypes = mock<INodeTypes>();
+	const evaluationMetricsNode = new EvaluationMetrics();
+
+	let mockExecuteFunction: IExecuteFunctions;
+
+	function getMockExecuteFunction(metrics: AssignmentCollectionValue['assignments']) {
+		return {
+			getInputData: jest.fn().mockReturnValue([{}]),
+
+			getNodeParameter: jest.fn().mockReturnValueOnce({
+				assignments: metrics,
+			}),
+
+			getNode: jest.fn().mockReturnValue({
+				typeVersion: 1,
+			}),
+		} as unknown as IExecuteFunctions;
+	}
+
+	beforeAll(() => {
+		mockExecuteFunction = getMockExecuteFunction([
+			{
+				id: '1',
+				name: 'Accuracy',
+				value: 0.95,
+				type: 'number',
+			},
+			{
+				id: '2',
+				name: 'Latency',
+				value: 100,
+				type: 'number',
+			},
+		]);
+		nodeTypes.getByName.mockReturnValue(evaluationMetricsNode);
+		jest.clearAllMocks();
+	});
+
+	describe('execute', () => {
+		it('should output the defined metrics', async () => {
+			const result = await evaluationMetricsNode.execute.call(mockExecuteFunction);
+
+			expect(result).toHaveLength(1);
+			expect(result[0]).toHaveLength(1);
+
+			const outputItem = result[0][0].json;
+			expect(outputItem).toEqual({
+				Accuracy: 0.95,
+				Latency: 100,
+			});
+		});
+
+		it('should handle no metrics defined', async () => {
+			const result = await evaluationMetricsNode.execute.call(mockExecuteFunction);
+
+			expect(result).toHaveLength(1);
+			expect(result[0]).toHaveLength(1);
+			expect(result[0][0].json).toEqual({});
+		});
+
+		it('should convert string values to numbers', async () => {
+			const mockExecuteWithStringValues = getMockExecuteFunction([
+				{
+					id: '1',
+					name: 'Accuracy',
+					value: '0.95',
+					type: 'number',
+				},
+				{
+					id: '2',
+					name: 'Latency',
+					value: '100',
+					type: 'number',
+				},
+			]);
+
+			const result = await evaluationMetricsNode.execute.call(mockExecuteWithStringValues);
+
+			expect(result).toHaveLength(1);
+			expect(result[0]).toHaveLength(1);
+
+			const outputItem = result[0][0].json;
+			expect(outputItem).toEqual({
+				Accuracy: 0.95,
+				Latency: 100,
+			});
+		});
+
+		it('should throw error for non-numeric string values', async () => {
+			const mockExecuteWithInvalidValue = getMockExecuteFunction([
+				{
+					id: '1',
+					name: 'Accuracy',
+					value: 'not-a-number',
+					type: 'number',
+				},
+			]);
+
+			await expect(evaluationMetricsNode.execute.call(mockExecuteWithInvalidValue)).rejects.toThrow(
+				NodeOperationError,
+			);
+		});
+	});
+});
diff --git a/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.ts b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.ts
new file mode 100644
index 00000000000..2ca86b626c5
--- /dev/null
+++ b/packages/nodes-base/nodes/EvaluationMetrics/EvaluationMetrics.node.ts
@@ -0,0 +1,109 @@
+import type {
+	AssignmentCollectionValue,
+	FieldType,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+import { NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';
+
+import { composeReturnItem, validateEntry } from '../Set/v2/helpers/utils';
+
+export class EvaluationMetrics implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Evaluation Metrics',
+		name: 'evaluationMetrics',
+		icon: 'fa:check-double',
+		group: ['input'],
+		iconColor: 'light-green',
+		version: 1,
+		description: 'Define the metrics returned for workflow evaluation',
+		defaults: {
+			name: 'Evaluation Metrics',
+			color: '#29A568',
+		},
+		inputs: [NodeConnectionTypes.Main],
+		outputs: [NodeConnectionTypes.Main],
+		properties: [
+			{
+				displayName:
+					"Define the evaluation metrics returned in your report. Only numeric values are supported. <a href='https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.evaluationmetric/' target='_blank'>More Info</a>",
+				name: 'notice',
+				type: 'notice',
+				default: '',
+			},
+			{
+				displayName: 'Metrics to Return',
+				name: 'metrics',
+				type: 'assignmentCollection',
+				default: {
+					assignments: [
+						{
+							name: '',
+							value: '',
+							type: 'number',
+						},
+					],
+				},
+				typeOptions: {
+					assignment: {
+						disableType: true,
+						defaultType: 'number',
+					},
+				},
+			},
+		],
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const metrics: INodeExecutionData[] = [];
+
+		for (let i = 0; i < items.length; i++) {
+			const dataToSave = this.getNodeParameter('metrics', i, {}) as AssignmentCollectionValue;
+
+			const newItem: INodeExecutionData = {
+				json: {},
+				pairedItem: { item: i },
+			};
+			const newData = Object.fromEntries(
+				(dataToSave?.assignments ?? []).map((assignment) => {
+					const assignmentValue =
+						typeof assignment.value === 'number' ? assignment.value : Number(assignment.value);
+
+					if (isNaN(assignmentValue)) {
+						throw new NodeOperationError(
+							this.getNode(),
+							`Invalid numeric value: "${assignment.value}". Please provide a valid number.`,
+						);
+					}
+
+					const { name, value } = validateEntry(
+						assignment.name,
+						assignment.type as FieldType,
+						assignmentValue,
+						this.getNode(),
+						i,
+						false,
+						1,
+					);
+
+					return [name, value];
+				}),
+			);
+
+			const returnItem = composeReturnItem.call(
+				this,
+				i,
+				newItem,
+				newData,
+				{ dotNotation: false, include: 'none' },
+				1,
+			);
+			metrics.push(returnItem);
+		}
+
+		return [metrics];
+	}
+}
diff --git a/packages/nodes-base/package.json b/packages/nodes-base/package.json
index 715f4afaa8e..beb4670c92e 100644
--- a/packages/nodes-base/package.json
+++ b/packages/nodes-base/package.json
@@ -504,6 +504,7 @@
       "dist/nodes/ExecuteWorkflow/ExecuteWorkflow/ExecuteWorkflow.node.js",
       "dist/nodes/ExecuteWorkflow/ExecuteWorkflowTrigger/ExecuteWorkflowTrigger.node.js",
       "dist/nodes/ExecutionData/ExecutionData.node.js",
+      "dist/nodes/EvaluationMetrics/EvaluationMetrics.node.js",
       "dist/nodes/Facebook/FacebookGraphApi.node.js",
       "dist/nodes/Facebook/FacebookTrigger.node.js",
       "dist/nodes/FacebookLeadAds/FacebookLeadAdsTrigger.node.js",
diff --git a/packages/workflow/src/Interfaces.ts b/packages/workflow/src/Interfaces.ts
index 426d08d34fd..4244feb6cab 100644
--- a/packages/workflow/src/Interfaces.ts
+++ b/packages/workflow/src/Interfaces.ts
@@ -1352,6 +1352,8 @@ export type FilterTypeOptions = {
 
 export type AssignmentTypeOptions = Partial<{
 	hideType?: boolean; // visible by default
+	defaultType?: FieldType | 'string';
+	disableType?: boolean; // visible by default
 }>;
 
 export type DisplayCondition =

From 53e11b19adf8bae2036229f19ee881bc4bf2ea4b Mon Sep 17 00:00:00 2001
From: oleg <me@olegivaniv.com>
Date: Tue, 25 Mar 2025 15:43:19 +0100
Subject: [PATCH 30/33] feat(core): Automatically extract evaluation metrics
 (no-changelog) (#14051)

---
 packages/cli/src/constants.ts                 |   2 +
 .../src/evaluation.ee/metrics.controller.ts   | 141 -------
 .../test-definitions.types.ee.ts              |  30 --
 .../__tests__/evaluation-metrics.ee.test.ts   |   8 -
 .../mock-data/workflow.evaluation-middle.json |  85 ++++
 .../mock-data/workflow.evaluation.json        |  12 +-
 .../__tests__/test-runner.service.ee.test.ts  | 282 ++++++++++++-
 .../evaluation.ee/test-runner/errors.ee.ts    |   2 -
 .../test-runner/evaluation-metrics.ee.ts      |  11 -
 .../test-runner/test-runner.service.ee.ts     | 116 ++++--
 packages/cli/src/server.ts                    |   1 -
 .../evaluation/metrics.api.test.ts            | 381 ------------------
 .../integration/shared/utils/test-server.ts   |   1 -
 .../editor-ui/src/api/testDefinition.ee.ts    |  82 ----
 .../EditDefinition/MetricsInput.vue           |  70 ----
 .../EditDefinition/sections/ConfigSection.vue |  23 --
 .../composables/useTestDefinitionForm.ts      |  37 --
 .../TestDefinition/shared/TableStatusCell.vue |   2 -
 .../TestDefinition/tests/MetricsInput.test.ts | 142 -------
 .../tests/useTestDefinitionForm.test.ts       |  75 ----
 .../src/components/TestDefinition/types.ts    |   2 -
 .../editor-ui/src/constants.workflows.ts      |   9 +-
 .../src/plugins/i18n/locales/en.json          |  12 -
 .../stores/testDefinition.store.ee.test.ts    |  94 -----
 .../src/stores/testDefinition.store.ee.ts     |  76 ----
 .../TestDefinition/TestDefinitionEditView.vue |  29 +-
 .../TestDefinitionRunDetailView.vue           |  18 -
 .../tests/TestDefinitionEditView.test.ts      |   3 -
 28 files changed, 460 insertions(+), 1286 deletions(-)
 delete mode 100644 packages/cli/src/evaluation.ee/metrics.controller.ts
 create mode 100644 packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation-middle.json
 delete mode 100644 packages/cli/test/integration/evaluation/metrics.api.test.ts
 delete mode 100644 packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/MetricsInput.vue
 delete mode 100644 packages/frontend/editor-ui/src/components/TestDefinition/tests/MetricsInput.test.ts

diff --git a/packages/cli/src/constants.ts b/packages/cli/src/constants.ts
index fe662c9ddf3..dc557dec767 100644
--- a/packages/cli/src/constants.ts
+++ b/packages/cli/src/constants.ts
@@ -195,3 +195,5 @@ export const WsStatusCodes = {
 } as const;
 
 export const FREE_AI_CREDITS_CREDENTIAL_NAME = 'n8n free OpenAI API credits';
+
+export const EVALUATION_METRICS_NODE = `${NODE_PACKAGE_PREFIX}base.evaluationMetrics`;
diff --git a/packages/cli/src/evaluation.ee/metrics.controller.ts b/packages/cli/src/evaluation.ee/metrics.controller.ts
deleted file mode 100644
index 5d279311666..00000000000
--- a/packages/cli/src/evaluation.ee/metrics.controller.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import express from 'express';
-
-import { TestMetricRepository } from '@/databases/repositories/test-metric.repository.ee';
-import { Delete, Get, Patch, Post, RestController } from '@/decorators';
-import { NotFoundError } from '@/errors/response-errors/not-found.error';
-import {
-	testMetricCreateRequestBodySchema,
-	testMetricPatchRequestBodySchema,
-} from '@/evaluation.ee/metric.schema';
-import { getSharedWorkflowIds } from '@/public-api/v1/handlers/workflows/workflows.service';
-import { Telemetry } from '@/telemetry';
-
-import { TestDefinitionService } from './test-definition.service.ee';
-import { TestMetricsRequest } from './test-definitions.types.ee';
-
-@RestController('/evaluation/test-definitions')
-export class TestMetricsController {
-	constructor(
-		private readonly testDefinitionService: TestDefinitionService,
-		private readonly testMetricRepository: TestMetricRepository,
-		private readonly telemetry: Telemetry,
-	) {}
-
-	// This method is used in multiple places in the controller to get the test definition
-	// (or just check that it exists and the user has access to it).
-	private async getTestDefinition(
-		req:
-			| TestMetricsRequest.GetOne
-			| TestMetricsRequest.GetMany
-			| TestMetricsRequest.Patch
-			| TestMetricsRequest.Delete
-			| TestMetricsRequest.Create,
-	) {
-		const { testDefinitionId } = req.params;
-
-		const userAccessibleWorkflowIds = await getSharedWorkflowIds(req.user, ['workflow:read']);
-
-		const testDefinition = await this.testDefinitionService.findOne(
-			testDefinitionId,
-			userAccessibleWorkflowIds,
-		);
-
-		if (!testDefinition) throw new NotFoundError('Test definition not found');
-
-		return testDefinition;
-	}
-
-	@Get('/:testDefinitionId/metrics')
-	async getMany(req: TestMetricsRequest.GetMany) {
-		const { testDefinitionId } = req.params;
-
-		await this.getTestDefinition(req);
-
-		return await this.testMetricRepository.find({
-			where: { testDefinition: { id: testDefinitionId } },
-		});
-	}
-
-	@Get('/:testDefinitionId/metrics/:id')
-	async getOne(req: TestMetricsRequest.GetOne) {
-		const { id: metricId, testDefinitionId } = req.params;
-
-		await this.getTestDefinition(req);
-
-		const metric = await this.testMetricRepository.findOne({
-			where: { id: metricId, testDefinition: { id: testDefinitionId } },
-		});
-
-		if (!metric) throw new NotFoundError('Metric not found');
-
-		return metric;
-	}
-
-	@Post('/:testDefinitionId/metrics')
-	async create(req: TestMetricsRequest.Create, res: express.Response) {
-		const bodyParseResult = testMetricCreateRequestBodySchema.safeParse(req.body);
-		if (!bodyParseResult.success) {
-			res.status(400).json({ errors: bodyParseResult.error.errors });
-			return;
-		}
-
-		const testDefinition = await this.getTestDefinition(req);
-
-		const metric = this.testMetricRepository.create({
-			...req.body,
-			testDefinition,
-		});
-
-		return await this.testMetricRepository.save(metric);
-	}
-
-	@Patch('/:testDefinitionId/metrics/:id')
-	async patch(req: TestMetricsRequest.Patch, res: express.Response) {
-		const { id: metricId, testDefinitionId } = req.params;
-
-		const bodyParseResult = testMetricPatchRequestBodySchema.safeParse(req.body);
-		if (!bodyParseResult.success) {
-			res.status(400).json({ errors: bodyParseResult.error.errors });
-			return;
-		}
-
-		await this.getTestDefinition(req);
-
-		const metric = await this.testMetricRepository.findOne({
-			where: { id: metricId, testDefinition: { id: testDefinitionId } },
-		});
-
-		if (!metric) throw new NotFoundError('Metric not found');
-
-		const updateResult = await this.testMetricRepository.update(metricId, bodyParseResult.data);
-
-		// Send telemetry event if the metric was updated
-		if (updateResult.affected === 1 && metric.name !== bodyParseResult.data.name) {
-			this.telemetry.track('User added metrics to test', {
-				metric_id: metricId,
-				metric_name: bodyParseResult.data.name,
-				test_id: testDefinitionId,
-			});
-		}
-
-		// Respond with the updated metric
-		return await this.testMetricRepository.findOneBy({ id: metricId });
-	}
-
-	@Delete('/:testDefinitionId/metrics/:id')
-	async delete(req: TestMetricsRequest.Delete) {
-		const { id: metricId, testDefinitionId } = req.params;
-
-		await this.getTestDefinition(req);
-
-		const metric = await this.testMetricRepository.findOne({
-			where: { id: metricId, testDefinition: { id: testDefinitionId } },
-		});
-
-		if (!metric) throw new NotFoundError('Metric not found');
-
-		await this.testMetricRepository.delete(metricId);
-
-		return { success: true };
-	}
-}
diff --git a/packages/cli/src/evaluation.ee/test-definitions.types.ee.ts b/packages/cli/src/evaluation.ee/test-definitions.types.ee.ts
index 98feea7e5d8..eb19f964f7c 100644
--- a/packages/cli/src/evaluation.ee/test-definitions.types.ee.ts
+++ b/packages/cli/src/evaluation.ee/test-definitions.types.ee.ts
@@ -47,36 +47,6 @@ export declare namespace TestDefinitionsRequest {
 	>;
 }
 
-// ----------------------------------
-//             /test-definitions/:testDefinitionId/metrics
-// ----------------------------------
-
-export declare namespace TestMetricsRequest {
-	namespace RouteParams {
-		type TestDefinitionId = {
-			testDefinitionId: string;
-		};
-
-		type TestMetricId = {
-			id: string;
-		};
-	}
-
-	type GetOne = AuthenticatedRequest<RouteParams.TestDefinitionId & RouteParams.TestMetricId>;
-
-	type GetMany = AuthenticatedRequest<RouteParams.TestDefinitionId>;
-
-	type Create = AuthenticatedRequest<RouteParams.TestDefinitionId, {}, { name: string }>;
-
-	type Patch = AuthenticatedRequest<
-		RouteParams.TestDefinitionId & RouteParams.TestMetricId,
-		{},
-		{ name: string }
-	>;
-
-	type Delete = AuthenticatedRequest<RouteParams.TestDefinitionId & RouteParams.TestMetricId>;
-}
-
 // ----------------------------------
 // 					 /test-definitions/:testDefinitionId/runs
 // ----------------------------------
diff --git a/packages/cli/src/evaluation.ee/test-runner/__tests__/evaluation-metrics.ee.test.ts b/packages/cli/src/evaluation.ee/test-runner/__tests__/evaluation-metrics.ee.test.ts
index d7bb9ec910d..d9ddbde162a 100644
--- a/packages/cli/src/evaluation.ee/test-runner/__tests__/evaluation-metrics.ee.test.ts
+++ b/packages/cli/src/evaluation.ee/test-runner/__tests__/evaluation-metrics.ee.test.ts
@@ -24,14 +24,6 @@ describe('EvaluationMetrics', () => {
 		);
 	});
 
-	test('should throw when missing values', () => {
-		const testMetricNames = new Set(['metric1', 'metric2']);
-		const metrics = new EvaluationMetrics(testMetricNames);
-
-		expect(() => metrics.addResults({ metric1: 1 })).toThrow('METRICS_MISSING');
-		expect(() => metrics.addResults({ metric2: 0.2 })).toThrow('METRICS_MISSING');
-	});
-
 	test('should handle empty metrics', () => {
 		const testMetricNames = new Set(['metric1', 'metric2']);
 		const metrics = new EvaluationMetrics(testMetricNames);
diff --git a/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation-middle.json b/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation-middle.json
new file mode 100644
index 00000000000..ba203bbac53
--- /dev/null
+++ b/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation-middle.json
@@ -0,0 +1,85 @@
+{
+	"nodes": [
+		{
+			"parameters": {},
+			"id": "6dde1608-135f-441d-8438-40f605e4dae3",
+			"name": "Execute Workflow Trigger",
+			"type": "n8n-nodes-base.executeWorkflowTrigger",
+			"typeVersion": 1,
+			"position": [-180, -40]
+		},
+		{
+			"parameters": {
+				"metrics": {
+					"assignments": [
+						{
+							"id": "f1cab1e4-dabc-4750-a1f7-6669a60213c9",
+							"name": "metric1",
+							"value": 20,
+							"type": "number"
+						},
+						{
+							"id": "a66ed953-5341-47f6-8565-47640d987f5f",
+							"name": "metric2",
+							"value": 30,
+							"type": "number"
+						}
+					]
+				}
+			},
+			"id": "dfc71b70-7b7a-4dde-914f-cc4ffc99b18c",
+			"name": "Success",
+			"type": "n8n-nodes-base.evaluationMetrics",
+			"typeVersion": 1,
+			"position": [620, -40]
+		},
+		{
+			"parameters": {
+				"metrics": {
+					"assignments": [
+						{
+							"id": "1e1153da-77c0-4cb5-804a-3f4bc40833dd",
+							"name": "metric2",
+							"value": 10,
+							"type": "number"
+						}
+					]
+				}
+			},
+			"id": "5ef5be33-37e0-4c95-81c8-3fd677bdca88",
+			"name": "First Metric",
+			"type": "n8n-nodes-base.evaluationMetrics",
+			"typeVersion": 1,
+			"position": [160, -40]
+		}
+	],
+	"connections": {
+		"Execute Workflow Trigger": {
+			"main": [
+				[
+					{
+						"node": "First Metric",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"First Metric": {
+			"main": [
+				[
+					{
+						"node": "Success",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		}
+	},
+	"pinData": {},
+	"meta": {
+		"templateCredsSetupCompleted": true,
+		"instanceId": "27cc9b56542ad45b38725555722c50a1c3fee1670bbb67980558314ee08517c4"
+	}
+}
diff --git a/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation.json b/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation.json
index 6ec7f2c3861..4db9e2bd6dc 100644
--- a/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation.json
+++ b/packages/cli/src/evaluation.ee/test-runner/__tests__/mock-data/workflow.evaluation.json
@@ -50,7 +50,7 @@
 		},
 		{
 			"parameters": {
-				"assignments": {
+				"metrics": {
 					"assignments": [
 						{
 							"id": "3b65d55a-158f-40c6-9853-a1c44b7ba1e5",
@@ -70,13 +70,13 @@
 			},
 			"id": "0c7a1ee8-0cf0-4d7f-99a3-186bbcd8815a",
 			"name": "Success",
-			"type": "n8n-nodes-base.set",
-			"typeVersion": 3.4,
+			"type": "n8n-nodes-base.evaluationMetrics",
+			"typeVersion": 1,
 			"position": [980, 220]
 		},
 		{
 			"parameters": {
-				"assignments": {
+				"metrics": {
 					"assignments": [
 						{
 							"id": "6cc8b402-4a30-4873-b825-963a1f1b8b82",
@@ -90,8 +90,8 @@
 			},
 			"id": "50d3f84a-d99f-4e04-bdbd-3e8c2668e708",
 			"name": "Fail",
-			"type": "n8n-nodes-base.set",
-			"typeVersion": 3.4,
+			"type": "n8n-nodes-base.evaluationMetrics",
+			"typeVersion": 1,
 			"position": [980, 420]
 		}
 	],
diff --git a/packages/cli/src/evaluation.ee/test-runner/__tests__/test-runner.service.ee.test.ts b/packages/cli/src/evaluation.ee/test-runner/__tests__/test-runner.service.ee.test.ts
index d91a2d0ee75..8d61fcb9019 100644
--- a/packages/cli/src/evaluation.ee/test-runner/__tests__/test-runner.service.ee.test.ts
+++ b/packages/cli/src/evaluation.ee/test-runner/__tests__/test-runner.service.ee.test.ts
@@ -46,6 +46,12 @@ const wfEvaluationJson = JSON.parse(
 	readFileSync(path.join(__dirname, './mock-data/workflow.evaluation.json'), { encoding: 'utf-8' }),
 );
 
+const wfEvaluationMiddleJson = JSON.parse(
+	readFileSync(path.join(__dirname, './mock-data/workflow.evaluation-middle.json'), {
+		encoding: 'utf-8',
+	}),
+);
+
 const wfMultipleTriggersJson = JSON.parse(
 	readFileSync(path.join(__dirname, './mock-data/workflow.multiple-triggers.json'), {
 		encoding: 'utf-8',
@@ -131,9 +137,22 @@ function mockEvaluationExecutionData(metrics: Record<string, GenericValue>) {
 	return mock<IRun>({
 		data: {
 			resultData: {
-				lastNodeExecuted: 'lastNode',
+				lastNodeExecuted: 'Success',
 				runData: {
-					lastNode: [
+					Success: [
+						{
+							data: {
+								main: [
+									[
+										{
+											json: metrics,
+										},
+									],
+								],
+							},
+						},
+					],
+					Fail: [
 						{
 							data: {
 								main: [
@@ -155,6 +174,52 @@ function mockEvaluationExecutionData(metrics: Record<string, GenericValue>) {
 	});
 }
 
+function mockEvaluationMiddleExecutionData(
+	firstMetrics: Record<string, GenericValue>,
+	secondMetrics: Record<string, GenericValue>,
+) {
+	// Clone the metrics to avoid modifying the passed object
+	// For test assertions, these run-data need special handling
+	const runData: Record<string, any> = {
+		'First Metric': [
+			{
+				data: {
+					main: [
+						[
+							{
+								json: firstMetrics,
+							},
+						],
+					],
+				},
+			},
+		],
+		Success: [
+			{
+				data: {
+					main: [
+						[
+							{
+								json: secondMetrics,
+							},
+						],
+					],
+				},
+			},
+		],
+	};
+
+	return mock<IRun>({
+		data: {
+			resultData: {
+				lastNodeExecuted: 'Success',
+				runData,
+				error: undefined,
+			},
+		},
+	});
+}
+
 const errorReporter = mock<ErrorReporter>();
 const logger = mockLogger();
 const telemetry = mock<Telemetry>();
@@ -363,7 +428,6 @@ describe('TestRunnerService', () => {
 		expect(testRunRepository.markAsCompleted).toHaveBeenCalledTimes(1);
 		expect(testRunRepository.markAsCompleted).toHaveBeenCalledWith('test-run-id', {
 			metric1: 0.75,
-			metric2: 50,
 		});
 
 		expect(testRunRepository.incrementPassed).toHaveBeenCalledTimes(2);
@@ -868,6 +932,218 @@ describe('TestRunnerService', () => {
 		expect(workflowRunner.run).toHaveBeenCalledTimes(1);
 	});
 
+	test('should run workflow with metrics defined in the middle of the workflow', async () => {
+		const testRunnerService = new TestRunnerService(
+			logger,
+			telemetry,
+			workflowRepository,
+			workflowRunner,
+			executionRepository,
+			activeExecutions,
+			testRunRepository,
+			testCaseExecutionRepository,
+			testMetricRepository,
+			mockNodeTypes,
+			errorReporter,
+		);
+
+		workflowRepository.findById.calledWith('workflow-under-test-id').mockResolvedValueOnce({
+			id: 'workflow-under-test-id',
+			...wfUnderTestJson,
+		});
+
+		workflowRepository.findById.calledWith('evaluation-workflow-id').mockResolvedValueOnce({
+			id: 'evaluation-workflow-id',
+			...wfEvaluationMiddleJson,
+		});
+
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-2');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-3');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-4');
+
+		// Mock executions of workflow under test
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id')
+			.mockResolvedValue(mockExecutionData());
+
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-3')
+			.mockResolvedValue(mockExecutionData());
+
+		// Mock executions of evaluation workflow
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-2')
+			.mockResolvedValue(mockEvaluationMiddleExecutionData({ metric2: 1 }, { metric1: 1 }));
+
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-4')
+			.mockResolvedValue(mockEvaluationMiddleExecutionData({ metric2: 2 }, { metric1: 0.5 }));
+
+		await testRunnerService.runTest(
+			mock<User>(),
+			mock<TestDefinition>({
+				workflowId: 'workflow-under-test-id',
+				evaluationWorkflowId: 'evaluation-workflow-id',
+				mockedNodes: [{ id: '72256d90-3a67-4e29-b032-47df4e5768af' }],
+			}),
+		);
+
+		expect(workflowRunner.run).toHaveBeenCalledTimes(4);
+
+		// Check workflow under test was executed
+		expect(workflowRunner.run).toHaveBeenCalledWith(
+			expect.objectContaining({
+				executionMode: 'evaluation',
+				pinData: {
+					'When clicking ‘Test workflow’':
+						executionDataJson.resultData.runData['When clicking ‘Test workflow’'][0].data.main[0],
+				},
+				workflowData: expect.objectContaining({
+					id: 'workflow-under-test-id',
+				}),
+			}),
+		);
+
+		// Check evaluation workflow was executed
+		expect(workflowRunner.run).toHaveBeenCalledWith(
+			expect.objectContaining({
+				executionMode: 'integrated',
+				executionData: expect.objectContaining({
+					executionData: expect.objectContaining({
+						nodeExecutionStack: expect.arrayContaining([
+							expect.objectContaining({ data: expect.anything() }),
+						]),
+					}),
+				}),
+				workflowData: expect.objectContaining({
+					id: 'evaluation-workflow-id',
+				}),
+			}),
+		);
+
+		// Check Test Run status was updated correctly
+		expect(testRunRepository.createTestRun).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsRunning).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsRunning).toHaveBeenCalledWith('test-run-id', expect.any(Number));
+		expect(testRunRepository.markAsCompleted).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsCompleted).toHaveBeenCalledWith('test-run-id', {
+			metric1: 0.75,
+			metric2: 1.5,
+		});
+
+		expect(testRunRepository.incrementPassed).toHaveBeenCalledTimes(2);
+		expect(testRunRepository.incrementFailed).not.toHaveBeenCalled();
+	});
+
+	test('should properly override metrics from earlier nodes with later ones', async () => {
+		const testRunnerService = new TestRunnerService(
+			logger,
+			telemetry,
+			workflowRepository,
+			workflowRunner,
+			executionRepository,
+			activeExecutions,
+			testRunRepository,
+			testCaseExecutionRepository,
+			testMetricRepository,
+			mockNodeTypes,
+			errorReporter,
+		);
+
+		workflowRepository.findById.calledWith('workflow-under-test-id').mockResolvedValueOnce({
+			id: 'workflow-under-test-id',
+			...wfUnderTestJson,
+		});
+
+		workflowRepository.findById.calledWith('evaluation-workflow-id').mockResolvedValueOnce({
+			id: 'evaluation-workflow-id',
+			...wfEvaluationMiddleJson,
+		});
+
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-2');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-3');
+		workflowRunner.run.mockResolvedValueOnce('some-execution-id-4');
+
+		// Mock executions of workflow under test
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id')
+			.mockResolvedValue(mockExecutionData());
+
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-3')
+			.mockResolvedValue(mockExecutionData());
+
+		// Mock executions of evaluation workflow
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-2')
+			.mockResolvedValue(
+				mockEvaluationMiddleExecutionData({ metric2: 5 }, { metric1: 1, metric2: 5 }),
+			);
+
+		activeExecutions.getPostExecutePromise
+			.calledWith('some-execution-id-4')
+			.mockResolvedValue(
+				mockEvaluationMiddleExecutionData({ metric2: 10 }, { metric1: 0.5, metric2: 10 }),
+			);
+
+		await testRunnerService.runTest(
+			mock<User>(),
+			mock<TestDefinition>({
+				workflowId: 'workflow-under-test-id',
+				evaluationWorkflowId: 'evaluation-workflow-id',
+				mockedNodes: [{ id: '72256d90-3a67-4e29-b032-47df4e5768af' }],
+			}),
+		);
+
+		expect(workflowRunner.run).toHaveBeenCalledTimes(4);
+
+		// Check workflow under test was executed
+		expect(workflowRunner.run).toHaveBeenCalledWith(
+			expect.objectContaining({
+				executionMode: 'evaluation',
+				pinData: {
+					'When clicking ‘Test workflow’':
+						executionDataJson.resultData.runData['When clicking ‘Test workflow’'][0].data.main[0],
+				},
+				workflowData: expect.objectContaining({
+					id: 'workflow-under-test-id',
+				}),
+			}),
+		);
+
+		// Check evaluation workflow was executed
+		expect(workflowRunner.run).toHaveBeenCalledWith(
+			expect.objectContaining({
+				executionMode: 'integrated',
+				executionData: expect.objectContaining({
+					executionData: expect.objectContaining({
+						nodeExecutionStack: expect.arrayContaining([
+							expect.objectContaining({ data: expect.anything() }),
+						]),
+					}),
+				}),
+				workflowData: expect.objectContaining({
+					id: 'evaluation-workflow-id',
+				}),
+			}),
+		);
+
+		// Check Test Run status was updated correctly
+		expect(testRunRepository.createTestRun).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsRunning).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsRunning).toHaveBeenCalledWith('test-run-id', expect.any(Number));
+		expect(testRunRepository.markAsCompleted).toHaveBeenCalledTimes(1);
+		expect(testRunRepository.markAsCompleted).toHaveBeenCalledWith('test-run-id', {
+			metric1: 0.75,
+			metric2: 7.5,
+		});
+
+		expect(testRunRepository.incrementPassed).toHaveBeenCalledTimes(2);
+		expect(testRunRepository.incrementFailed).not.toHaveBeenCalled();
+	});
+
 	describe('Test Run cancellation', () => {
 		beforeAll(() => {
 			jest.useFakeTimers();
diff --git a/packages/cli/src/evaluation.ee/test-runner/errors.ee.ts b/packages/cli/src/evaluation.ee/test-runner/errors.ee.ts
index 0b2df294b2c..bd11ba479ee 100644
--- a/packages/cli/src/evaluation.ee/test-runner/errors.ee.ts
+++ b/packages/cli/src/evaluation.ee/test-runner/errors.ee.ts
@@ -6,8 +6,6 @@ export type TestCaseExecutionErrorCode =
 	| 'FAILED_TO_EXECUTE_WORKFLOW'
 	| 'EVALUATION_WORKFLOW_DOES_NOT_EXIST'
 	| 'FAILED_TO_EXECUTE_EVALUATION_WORKFLOW'
-	| 'METRICS_MISSING'
-	| 'UNKNOWN_METRICS'
 	| 'INVALID_METRICS'
 	| 'PAYLOAD_LIMIT_EXCEEDED'
 	| 'UNKNOWN_ERROR';
diff --git a/packages/cli/src/evaluation.ee/test-runner/evaluation-metrics.ee.ts b/packages/cli/src/evaluation.ee/test-runner/evaluation-metrics.ee.ts
index b2422f4b6b7..1e063e262a5 100644
--- a/packages/cli/src/evaluation.ee/test-runner/evaluation-metrics.ee.ts
+++ b/packages/cli/src/evaluation.ee/test-runner/evaluation-metrics.ee.ts
@@ -1,4 +1,3 @@
-import difference from 'lodash/difference';
 import type { IDataObject } from 'n8n-workflow';
 
 import { TestCaseExecutionError } from '@/evaluation.ee/test-runner/errors.ee';
@@ -43,16 +42,6 @@ export class EvaluationMetrics {
 			}
 		}
 
-		// Check that result contains all expected metrics
-		if (
-			difference(Array.from(this.metricNames), Object.keys(addResultsInfo.addedMetrics)).length > 0
-		) {
-			throw new TestCaseExecutionError('METRICS_MISSING', {
-				expectedMetrics: Array.from(this.metricNames).sort(),
-				receivedMetrics: Object.keys(addResultsInfo.addedMetrics).sort(),
-			});
-		}
-
 		return addResultsInfo;
 	}
 
diff --git a/packages/cli/src/evaluation.ee/test-runner/test-runner.service.ee.ts b/packages/cli/src/evaluation.ee/test-runner/test-runner.service.ee.ts
index 628349bf85a..c987523a7d1 100644
--- a/packages/cli/src/evaluation.ee/test-runner/test-runner.service.ee.ts
+++ b/packages/cli/src/evaluation.ee/test-runner/test-runner.service.ee.ts
@@ -1,8 +1,10 @@
 import { Service } from '@n8n/di';
 import { parse } from 'flatted';
+import difference from 'lodash/difference';
 import { ErrorReporter, Logger } from 'n8n-core';
 import { ExecutionCancelledError, NodeConnectionTypes, Workflow } from 'n8n-workflow';
 import type {
+	AssignmentCollectionValue,
 	IDataObject,
 	IRun,
 	IRunExecutionData,
@@ -13,6 +15,7 @@ import assert from 'node:assert';
 
 import { ActiveExecutions } from '@/active-executions';
 import config from '@/config';
+import { EVALUATION_METRICS_NODE } from '@/constants';
 import type { ExecutionEntity } from '@/databases/entities/execution-entity';
 import type { MockedNodeItem, TestDefinition } from '@/databases/entities/test-definition.ee';
 import type { TestRun } from '@/databases/entities/test-run.ee';
@@ -225,6 +228,50 @@ export class TestRunnerService {
 		return await executePromise;
 	}
 
+	/**
+	 * Sync the metrics of the test definition with the evaluation workflow.
+	 */
+	async syncMetrics(
+		testDefinitionId: string,
+		evaluationWorkflow: IWorkflowBase,
+	): Promise<Set<string>> {
+		const usedTestMetricNames = await this.getUsedTestMetricNames(evaluationWorkflow);
+		const existingTestMetrics = await this.testMetricRepository.find({
+			where: {
+				testDefinition: { id: testDefinitionId },
+			},
+		});
+
+		const existingMetricNames = new Set(existingTestMetrics.map((metric) => metric.name));
+		const metricsToAdd = difference(
+			Array.from(usedTestMetricNames),
+			Array.from(existingMetricNames),
+		);
+		const metricsToRemove = difference(
+			Array.from(existingMetricNames),
+			Array.from(usedTestMetricNames),
+		);
+
+		// Add new metrics
+		const metricsToAddEntities = metricsToAdd.map((metricName) =>
+			this.testMetricRepository.create({
+				name: metricName,
+				testDefinition: { id: testDefinitionId },
+			}),
+		);
+		await this.testMetricRepository.save(metricsToAddEntities);
+
+		// Remove no longer used metrics
+		metricsToRemove.forEach(async (metricName) => {
+			const metric = existingTestMetrics.find((m) => m.name === metricName);
+			assert(metric, 'Existing metric not found');
+
+			await this.testMetricRepository.delete(metric.id);
+		});
+
+		return usedTestMetricNames;
+	}
+
 	/**
 	 * Run the evaluation workflow with the expected and actual run data.
 	 */
@@ -265,35 +312,45 @@ export class TestRunnerService {
 		return await executePromise;
 	}
 
+	/**
+	 * Get the evaluation metrics nodes from a workflow.
+	 */
+	static getEvaluationMetricsNodes(workflow: IWorkflowBase) {
+		return workflow.nodes.filter((node) => node.type === EVALUATION_METRICS_NODE);
+	}
+
 	/**
 	 * Evaluation result is the first item in the output of the last node
 	 * executed in the evaluation workflow. Defaults to an empty object
 	 * in case the node doesn't produce any output items.
 	 */
-	private extractEvaluationResult(execution: IRun): IDataObject {
+	private extractEvaluationResult(execution: IRun, evaluationWorkflow: IWorkflowBase): IDataObject {
 		const lastNodeExecuted = execution.data.resultData.lastNodeExecuted;
 		assert(lastNodeExecuted, 'Could not find the last node executed in evaluation workflow');
+		const metricsNodes = TestRunnerService.getEvaluationMetricsNodes(evaluationWorkflow);
+		const metricsRunData = metricsNodes.flatMap(
+			(node) => execution.data.resultData.runData[node.name],
+		);
+		const metricsData = metricsRunData.reverse().map((data) => data.data?.main?.[0]?.[0]?.json);
+		const metricsResult = metricsData.reduce((acc, curr) => ({ ...acc, ...curr }), {}) ?? {};
 
-		// Extract the output of the last node executed in the evaluation workflow
-		// We use only the first item of a first main output
-		const lastNodeTaskData = execution.data.resultData.runData[lastNodeExecuted]?.[0];
-		const mainConnectionData = lastNodeTaskData?.data?.main?.[0];
-		return mainConnectionData?.[0]?.json ?? {};
+		return metricsResult;
 	}
 
 	/**
 	 * Get the metrics to collect from the evaluation workflow execution results.
 	 */
-	private async getTestMetricNames(testDefinitionId: string) {
-		const metrics = await this.testMetricRepository.find({
-			where: {
-				testDefinition: {
-					id: testDefinitionId,
-				},
-			},
+	private async getUsedTestMetricNames(evaluationWorkflow: IWorkflowBase) {
+		const metricsNodes = TestRunnerService.getEvaluationMetricsNodes(evaluationWorkflow);
+		const metrics = metricsNodes.map((node) => {
+			const metricsParameter = node.parameters?.metrics as AssignmentCollectionValue;
+			assert(metricsParameter, 'Metrics parameter not found');
+
+			const metricsNames = metricsParameter.assignments.map((assignment) => assignment.name);
+			return metricsNames;
 		});
 
-		return new Set(metrics.map((m) => m.name));
+		return new Set(metrics.flat());
 	}
 
 	/**
@@ -329,7 +386,6 @@ export class TestRunnerService {
 			if (!evaluationWorkflow) {
 				throw new TestRunError('EVALUATION_WORKFLOW_NOT_FOUND');
 			}
-
 			///
 			// 1. Make test cases from previous executions
 			///
@@ -359,8 +415,8 @@ export class TestRunnerService {
 				pastExecutions.map((e) => e.id),
 			);
 
-			// Get the metrics to collect from the evaluation workflow
-			const testMetricNames = await this.getTestMetricNames(test.id);
+			// Sync the metrics of the test definition with the evaluation workflow
+			const testMetricNames = await this.syncMetrics(test.id, evaluationWorkflow);
 
 			// 2. Run over all the test cases
 			const pastExecutionIds = pastExecutions.map((e) => e.id);
@@ -465,8 +521,8 @@ export class TestRunnerService {
 					this.logger.debug('Evaluation execution finished', { pastExecutionId });
 
 					// Extract the output of the last node executed in the evaluation workflow
-					const { addedMetrics, unknownMetrics } = metrics.addResults(
-						this.extractEvaluationResult(evalExecution),
+					const { addedMetrics } = metrics.addResults(
+						this.extractEvaluationResult(evalExecution, evaluationWorkflow),
 					);
 
 					if (evalExecution.data.resultData.error) {
@@ -483,22 +539,12 @@ export class TestRunnerService {
 						await Db.transaction(async (trx) => {
 							await this.testRunRepository.incrementPassed(testRun.id, trx);
 
-							// Add warning if the evaluation workflow produced an unknown metric
-							if (unknownMetrics.size > 0) {
-								await this.testCaseExecutionRepository.markAsWarning({
-									testRunId: testRun.id,
-									pastExecutionId,
-									errorCode: 'UNKNOWN_METRICS',
-									errorDetails: { unknownMetrics: Array.from(unknownMetrics) },
-								});
-							} else {
-								await this.testCaseExecutionRepository.markAsCompleted({
-									testRunId: testRun.id,
-									pastExecutionId,
-									metrics: addedMetrics,
-									trx,
-								});
-							}
+							await this.testCaseExecutionRepository.markAsCompleted({
+								testRunId: testRun.id,
+								pastExecutionId,
+								metrics: addedMetrics,
+								trx,
+							});
 						});
 					}
 				} catch (e) {
diff --git a/packages/cli/src/server.ts b/packages/cli/src/server.ts
index 9ba7aa930cf..e2d05f2a662 100644
--- a/packages/cli/src/server.ts
+++ b/packages/cli/src/server.ts
@@ -66,7 +66,6 @@ import '@/executions/executions.controller';
 import '@/external-secrets.ee/external-secrets.controller.ee';
 import '@/license/license.controller';
 import '@/evaluation.ee/test-definitions.controller.ee';
-import '@/evaluation.ee/metrics.controller';
 import '@/evaluation.ee/test-runs.controller.ee';
 import '@/workflows/workflow-history.ee/workflow-history.controller.ee';
 import '@/workflows/workflows.controller';
diff --git a/packages/cli/test/integration/evaluation/metrics.api.test.ts b/packages/cli/test/integration/evaluation/metrics.api.test.ts
deleted file mode 100644
index ff04aedf124..00000000000
--- a/packages/cli/test/integration/evaluation/metrics.api.test.ts
+++ /dev/null
@@ -1,381 +0,0 @@
-import { Container } from '@n8n/di';
-import type { IWorkflowBase } from 'n8n-workflow';
-
-import type { TestDefinition } from '@/databases/entities/test-definition.ee';
-import type { User } from '@/databases/entities/user';
-import { TestDefinitionRepository } from '@/databases/repositories/test-definition.repository.ee';
-import { TestMetricRepository } from '@/databases/repositories/test-metric.repository.ee';
-import { createUserShell } from '@test-integration/db/users';
-import { createWorkflow } from '@test-integration/db/workflows';
-import * as testDb from '@test-integration/test-db';
-import type { SuperAgentTest } from '@test-integration/types';
-import * as utils from '@test-integration/utils';
-
-let authOwnerAgent: SuperAgentTest;
-let workflowUnderTest: IWorkflowBase;
-let otherWorkflow: IWorkflowBase;
-let testDefinition: TestDefinition;
-let otherTestDefinition: TestDefinition;
-let ownerShell: User;
-
-const testServer = utils.setupTestServer({ endpointGroups: ['evaluation'] });
-
-beforeAll(async () => {
-	ownerShell = await createUserShell('global:owner');
-	authOwnerAgent = testServer.authAgentFor(ownerShell);
-});
-
-beforeEach(async () => {
-	await testDb.truncate(['TestDefinition', 'TestMetric']);
-
-	workflowUnderTest = await createWorkflow({ name: 'workflow-under-test' }, ownerShell);
-
-	testDefinition = Container.get(TestDefinitionRepository).create({
-		name: 'test',
-		workflow: { id: workflowUnderTest.id },
-	});
-	await Container.get(TestDefinitionRepository).save(testDefinition);
-
-	otherWorkflow = await createWorkflow({ name: 'other-workflow' });
-
-	otherTestDefinition = Container.get(TestDefinitionRepository).create({
-		name: 'other-test',
-		workflow: { id: otherWorkflow.id },
-	});
-	await Container.get(TestDefinitionRepository).save(otherTestDefinition);
-});
-
-describe('GET /evaluation/test-definitions/:testDefinitionId/metrics', () => {
-	test('should retrieve empty list of metrics for a test definition', async () => {
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics`,
-		);
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data.length).toBe(0);
-	});
-
-	test('should retrieve metrics for a test definition', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const newMetric2 = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-2',
-		});
-		await Container.get(TestMetricRepository).save(newMetric2);
-
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics`,
-		);
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data.length).toBe(2);
-		expect(resp.body.data).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					id: expect.any(String),
-					name: 'metric-1',
-				}),
-				expect.objectContaining({
-					id: expect.any(String),
-					name: 'metric-2',
-				}),
-			]),
-		);
-	});
-
-	test('should return 404 if test definition does not exist', async () => {
-		const resp = await authOwnerAgent.get('/evaluation/test-definitions/999/metrics');
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if test definition is not accessible to the user', async () => {
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${otherTestDefinition.id}/metrics`,
-		);
-
-		expect(resp.statusCode).toBe(404);
-	});
-});
-
-describe('GET /evaluation/test-definitions/:testDefinitionId/metrics/:id', () => {
-	test('should retrieve a metric for a test definition', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics/${newMetric.id}`,
-		);
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data).toEqual(
-			expect.objectContaining({
-				id: newMetric.id,
-				name: 'metric-1',
-			}),
-		);
-	});
-
-	test('should return 404 if metric does not exist', async () => {
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics/999`,
-		);
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if metric is not accessible to the user', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: otherTestDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent.get(
-			`/evaluation/test-definitions/${otherTestDefinition.id}/metrics/${newMetric.id}`,
-		);
-
-		expect(resp.statusCode).toBe(404);
-	});
-});
-
-describe('POST /evaluation/test-definitions/:testDefinitionId/metrics', () => {
-	test('should create a metric for a test definition', async () => {
-		const resp = await authOwnerAgent
-			.post(`/evaluation/test-definitions/${testDefinition.id}/metrics`)
-			.send({
-				name: 'metric-1',
-			});
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data).toEqual(
-			expect.objectContaining({
-				id: expect.any(String),
-				name: 'metric-1',
-			}),
-		);
-
-		const metrics = await Container.get(TestMetricRepository).find({
-			where: { testDefinition: { id: testDefinition.id } },
-		});
-		expect(metrics.length).toBe(1);
-		expect(metrics[0].name).toBe('metric-1');
-	});
-
-	test('should return 400 if name is missing', async () => {
-		const resp = await authOwnerAgent
-			.post(`/evaluation/test-definitions/${testDefinition.id}/metrics`)
-			.send({});
-
-		expect(resp.statusCode).toBe(400);
-		expect(resp.body.errors).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					code: 'invalid_type',
-					message: 'Required',
-					path: ['name'],
-				}),
-			]),
-		);
-	});
-
-	test('should return 400 if name is not a string', async () => {
-		const resp = await authOwnerAgent
-			.post(`/evaluation/test-definitions/${testDefinition.id}/metrics`)
-			.send({
-				name: 123,
-			});
-
-		expect(resp.statusCode).toBe(400);
-		expect(resp.body.errors).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					code: 'invalid_type',
-					message: 'Expected string, received number',
-					path: ['name'],
-				}),
-			]),
-		);
-	});
-
-	test('should return 404 if test definition does not exist', async () => {
-		const resp = await authOwnerAgent.post('/evaluation/test-definitions/999/metrics').send({
-			name: 'metric-1',
-		});
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if test definition is not accessible to the user', async () => {
-		const resp = await authOwnerAgent
-			.post(`/evaluation/test-definitions/${otherTestDefinition.id}/metrics`)
-			.send({
-				name: 'metric-1',
-			});
-
-		expect(resp.statusCode).toBe(404);
-	});
-});
-
-describe('PATCH /evaluation/test-definitions/:testDefinitionId/metrics/:id', () => {
-	test('should update a metric for a test definition', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent
-			.patch(`/evaluation/test-definitions/${testDefinition.id}/metrics/${newMetric.id}`)
-			.send({
-				name: 'metric-2',
-			});
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data).toEqual(
-			expect.objectContaining({
-				id: newMetric.id,
-				name: 'metric-2',
-			}),
-		);
-
-		const metrics = await Container.get(TestMetricRepository).find({
-			where: { testDefinition: { id: testDefinition.id } },
-		});
-		expect(metrics.length).toBe(1);
-		expect(metrics[0].name).toBe('metric-2');
-	});
-
-	test('should return 400 if name is missing', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent
-			.patch(`/evaluation/test-definitions/${testDefinition.id}/metrics/${newMetric.id}`)
-			.send({});
-
-		expect(resp.statusCode).toBe(400);
-		expect(resp.body.errors).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					code: 'invalid_type',
-					message: 'Required',
-					path: ['name'],
-				}),
-			]),
-		);
-	});
-
-	test('should return 400 if name is not a string', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent
-			.patch(`/evaluation/test-definitions/${testDefinition.id}/metrics/${newMetric.id}`)
-			.send({
-				name: 123,
-			});
-
-		expect(resp.statusCode).toBe(400);
-		expect(resp.body.errors).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({
-					code: 'invalid_type',
-					message: 'Expected string, received number',
-				}),
-			]),
-		);
-	});
-
-	test('should return 404 if metric does not exist', async () => {
-		const resp = await authOwnerAgent
-			.patch(`/evaluation/test-definitions/${testDefinition.id}/metrics/999`)
-			.send({
-				name: 'metric-1',
-			});
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if test definition does not exist', async () => {
-		const resp = await authOwnerAgent.patch('/evaluation/test-definitions/999/metrics/999').send({
-			name: 'metric-1',
-		});
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if metric is not accessible to the user', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: otherTestDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent
-			.patch(`/evaluation/test-definitions/${otherTestDefinition.id}/metrics/${newMetric.id}`)
-			.send({
-				name: 'metric-2',
-			});
-
-		expect(resp.statusCode).toBe(404);
-	});
-});
-
-describe('DELETE /evaluation/test-definitions/:testDefinitionId/metrics/:id', () => {
-	test('should delete a metric for a test definition', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: testDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent.delete(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics/${newMetric.id}`,
-		);
-
-		expect(resp.statusCode).toBe(200);
-		expect(resp.body.data).toEqual({ success: true });
-
-		const metrics = await Container.get(TestMetricRepository).find({
-			where: { testDefinition: { id: testDefinition.id } },
-		});
-		expect(metrics.length).toBe(0);
-	});
-
-	test('should return 404 if metric does not exist', async () => {
-		const resp = await authOwnerAgent.delete(
-			`/evaluation/test-definitions/${testDefinition.id}/metrics/999`,
-		);
-
-		expect(resp.statusCode).toBe(404);
-	});
-
-	test('should return 404 if metric is not accessible to the user', async () => {
-		const newMetric = Container.get(TestMetricRepository).create({
-			testDefinition: { id: otherTestDefinition.id },
-			name: 'metric-1',
-		});
-		await Container.get(TestMetricRepository).save(newMetric);
-
-		const resp = await authOwnerAgent.delete(
-			`/evaluation/test-definitions/${otherTestDefinition.id}/metrics/${newMetric.id}`,
-		);
-
-		expect(resp.statusCode).toBe(404);
-	});
-});
diff --git a/packages/cli/test/integration/shared/utils/test-server.ts b/packages/cli/test/integration/shared/utils/test-server.ts
index b242915c922..739a89305c4 100644
--- a/packages/cli/test/integration/shared/utils/test-server.ts
+++ b/packages/cli/test/integration/shared/utils/test-server.ts
@@ -281,7 +281,6 @@ export const setupTestServer = ({
 						break;
 
 					case 'evaluation':
-						await import('@/evaluation.ee/metrics.controller');
 						await import('@/evaluation.ee/test-definitions.controller.ee');
 						await import('@/evaluation.ee/test-runs.controller.ee');
 						break;
diff --git a/packages/frontend/editor-ui/src/api/testDefinition.ee.ts b/packages/frontend/editor-ui/src/api/testDefinition.ee.ts
index c15b2bc9d3e..cf4a123b10a 100644
--- a/packages/frontend/editor-ui/src/api/testDefinition.ee.ts
+++ b/packages/frontend/editor-ui/src/api/testDefinition.ee.ts
@@ -83,8 +83,6 @@ export interface TestCaseExecutionRecord {
 }
 
 const endpoint = '/evaluation/test-definitions';
-const getMetricsEndpoint = (testDefinitionId: string, metricId?: string) =>
-	`${endpoint}/${testDefinitionId}/metrics${metricId ? `/${metricId}` : ''}`;
 
 export async function getTestDefinitions(
 	context: IRestApiContext,
@@ -141,86 +139,6 @@ export async function getExampleEvaluationInput(
 	);
 }
 
-// Metrics
-export interface TestMetricRecord {
-	id: string;
-	name: string;
-	testDefinitionId: string;
-	createdAt?: string;
-	updatedAt?: string;
-}
-
-export interface CreateTestMetricParams {
-	testDefinitionId: string;
-	name: string;
-}
-
-export interface UpdateTestMetricParams {
-	name: string;
-	id: string;
-	testDefinitionId: string;
-}
-
-export interface DeleteTestMetricParams {
-	testDefinitionId: string;
-	id: string;
-}
-
-export const getTestMetrics = async (context: IRestApiContext, testDefinitionId: string) => {
-	return await makeRestApiRequest<TestMetricRecord[]>(
-		context,
-		'GET',
-		getMetricsEndpoint(testDefinitionId),
-	);
-};
-
-export const getTestMetric = async (
-	context: IRestApiContext,
-	testDefinitionId: string,
-	id: string,
-) => {
-	return await makeRestApiRequest<TestMetricRecord>(
-		context,
-		'GET',
-		getMetricsEndpoint(testDefinitionId, id),
-	);
-};
-
-export const createTestMetric = async (
-	context: IRestApiContext,
-	params: CreateTestMetricParams,
-) => {
-	return await makeRestApiRequest<TestMetricRecord>(
-		context,
-		'POST',
-		getMetricsEndpoint(params.testDefinitionId),
-		{ name: params.name },
-	);
-};
-
-export const updateTestMetric = async (
-	context: IRestApiContext,
-	params: UpdateTestMetricParams,
-) => {
-	return await makeRestApiRequest<TestMetricRecord>(
-		context,
-		'PATCH',
-		getMetricsEndpoint(params.testDefinitionId, params.id),
-		{ name: params.name },
-	);
-};
-
-export const deleteTestMetric = async (
-	context: IRestApiContext,
-	params: DeleteTestMetricParams,
-) => {
-	return await makeRestApiRequest(
-		context,
-		'DELETE',
-		getMetricsEndpoint(params.testDefinitionId, params.id),
-	);
-};
-
 const getRunsEndpoint = (testDefinitionId: string, runId?: string) =>
 	`${endpoint}/${testDefinitionId}/runs${runId ? `/${runId}` : ''}`;
 
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/MetricsInput.vue b/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/MetricsInput.vue
deleted file mode 100644
index f679b6cdfa9..00000000000
--- a/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/MetricsInput.vue
+++ /dev/null
@@ -1,70 +0,0 @@
-<script setup lang="ts">
-import { useTemplateRef, nextTick } from 'vue';
-import type { TestMetricRecord } from '@/api/testDefinition.ee';
-import { useI18n } from '@/composables/useI18n';
-import { N8nInput, N8nButton, N8nIconButton } from '@n8n/design-system';
-
-export interface MetricsInputProps {
-	modelValue: Array<Partial<TestMetricRecord>>;
-}
-const props = defineProps<MetricsInputProps>();
-const emit = defineEmits<{
-	'update:modelValue': [value: MetricsInputProps['modelValue']];
-	deleteMetric: [metric: TestMetricRecord];
-}>();
-const locale = useI18n();
-const metricsRefs = useTemplateRef<Array<InstanceType<typeof N8nInput>>>('metric');
-
-function addNewMetric() {
-	emit('update:modelValue', [...props.modelValue, { name: '' }]);
-	void nextTick(() => metricsRefs.value?.at(-1)?.focus());
-}
-
-function updateMetric(index: number, name: string) {
-	const newMetrics = [...props.modelValue];
-	newMetrics[index].name = name;
-	emit('update:modelValue', newMetrics);
-}
-
-function onDeleteMetric(metric: Partial<TestMetricRecord>, index: number) {
-	if (!metric.id) {
-		const newMetrics = [...props.modelValue];
-		newMetrics.splice(index, 1);
-		emit('update:modelValue', newMetrics);
-	} else {
-		emit('deleteMetric', metric as TestMetricRecord);
-	}
-}
-</script>
-
-<template>
-	<div>
-		<div
-			v-for="(metric, index) in modelValue"
-			:key="index"
-			:class="$style.metricItem"
-			class="mb-xs"
-		>
-			<N8nInput
-				ref="metric"
-				data-test-id="evaluation-metric-item"
-				:model-value="metric.name"
-				:placeholder="locale.baseText('testDefinition.edit.metricsPlaceholder')"
-				@update:model-value="(value: string) => updateMetric(index, value)"
-			/>
-			<N8nIconButton icon="trash" type="secondary" text @click="onDeleteMetric(metric, index)" />
-		</div>
-		<N8nButton
-			type="secondary"
-			:label="locale.baseText('testDefinition.edit.metricsNew')"
-			@click="addNewMetric"
-		/>
-	</div>
-</template>
-
-<style module lang="scss">
-.metricItem {
-	display: flex;
-	align-items: center;
-}
-</style>
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/sections/ConfigSection.vue b/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/sections/ConfigSection.vue
index 038bbf71f30..c02d02064da 100644
--- a/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/sections/ConfigSection.vue
+++ b/packages/frontend/editor-ui/src/components/TestDefinition/EditDefinition/sections/ConfigSection.vue
@@ -1,8 +1,6 @@
 <script setup lang="ts">
-import type { TestMetricRecord } from '@/api/testDefinition.ee';
 import BlockArrow from '@/components/TestDefinition/EditDefinition/BlockArrow.vue';
 import EvaluationStep from '@/components/TestDefinition/EditDefinition/EvaluationStep.vue';
-import MetricsInput from '@/components/TestDefinition/EditDefinition/MetricsInput.vue';
 import NodesPinning from '@/components/TestDefinition/EditDefinition/NodesPinning.vue';
 import WorkflowSelector from '@/components/TestDefinition/EditDefinition/WorkflowSelector.vue';
 import type { EditableFormState, EvaluationFormState } from '@/components/TestDefinition/types';
@@ -27,7 +25,6 @@ const props = defineProps<{
 }>();
 const emit = defineEmits<{
 	openPinningModal: [];
-	deleteMetric: [metric: TestMetricRecord];
 	openExecutionsViewForTag: [];
 	renameTag: [tag: string];
 	evaluationWorkflowCreated: [workflowId: string];
@@ -64,7 +61,6 @@ const evaluationWorkflow = defineModel<EvaluationFormState['evaluationWorkflow']
 	'evaluationWorkflow',
 	{ required: true },
 );
-const metrics = defineModel<EvaluationFormState['metrics']>('metrics', { required: true });
 const mockedNodes = defineModel<EvaluationFormState['mockedNodes']>('mockedNodes', {
 	required: true,
 });
@@ -177,25 +173,6 @@ function openExecutionsView() {
 					/>
 				</template>
 			</EvaluationStep>
-
-			<BlockArrow class="mt-5xs mb-5xs" />
-			<!-- Metrics -->
-			<EvaluationStep
-				:title="locale.baseText('testDefinition.edit.step.metrics')"
-				:issues="getFieldIssues('metrics')"
-				:description="locale.baseText('testDefinition.edit.step.metrics.description')"
-				:tooltip="locale.baseText('testDefinition.edit.step.metrics.tooltip')"
-				:external-tooltip="!hasRuns"
-			>
-				<template #cardContent>
-					<MetricsInput
-						v-model="metrics"
-						:class="{ 'has-issues': getFieldIssues('metrics').length > 0 }"
-						class="mt-xs"
-						@delete-metric="(metric) => emit('deleteMetric', metric)"
-					/>
-				</template>
-			</EvaluationStep>
 		</div>
 		<Modal
 			width="calc(100% - (48px * 2))"
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/composables/useTestDefinitionForm.ts b/packages/frontend/editor-ui/src/components/TestDefinition/composables/useTestDefinitionForm.ts
index efccf32148e..5e14a6996b5 100644
--- a/packages/frontend/editor-ui/src/components/TestDefinition/composables/useTestDefinitionForm.ts
+++ b/packages/frontend/editor-ui/src/components/TestDefinition/composables/useTestDefinitionForm.ts
@@ -36,7 +36,6 @@ export function useTestDefinitionForm() {
 			value: '',
 			__rl: true,
 		},
-		metrics: [],
 		mockedNodes: [],
 	});
 
@@ -62,8 +61,6 @@ export function useTestDefinitionForm() {
 			const testDefinition = evaluationsStore.testDefinitionsById[testId];
 
 			if (testDefinition) {
-				const metrics = await evaluationsStore.fetchMetrics(testId);
-
 				state.value.description = {
 					value: testDefinition.description ?? '',
 					isEditing: false,
@@ -84,7 +81,6 @@ export function useTestDefinitionForm() {
 					value: testDefinition.evaluationWorkflowId ?? '',
 					__rl: true,
 				};
-				state.value.metrics = metrics;
 				state.value.mockedNodes = testDefinition.mockedNodes ?? [];
 				evaluationsStore.updateRunFieldIssues(testDefinition.id);
 			}
@@ -110,37 +106,6 @@ export function useTestDefinitionForm() {
 		}
 	};
 
-	const deleteMetric = async (metricId: string, testId: string) => {
-		await evaluationsStore.deleteMetric({ id: metricId, testDefinitionId: testId });
-		state.value.metrics = state.value.metrics.filter((metric) => metric.id !== metricId);
-	};
-
-	/**
-	 * This method would perform unnecessary updates on the BE
-	 * it's a performance degradation candidate if metrics reach certain amount
-	 */
-	const updateMetrics = async (testId: string) => {
-		const promises = state.value.metrics.map(async (metric) => {
-			if (!metric.name) return;
-			if (!metric.id) {
-				const createdMetric = await evaluationsStore.createMetric({
-					name: metric.name,
-					testDefinitionId: testId,
-				});
-				metric.id = createdMetric.id;
-			} else {
-				await evaluationsStore.updateMetric({
-					name: metric.name,
-					id: metric.id,
-					testDefinitionId: testId,
-				});
-			}
-		});
-		isSaving.value = true;
-		await Promise.all(promises);
-		isSaving.value = false;
-	};
-
 	const updateTest = async (testId: string) => {
 		if (isSaving.value) return;
 
@@ -230,8 +195,6 @@ export function useTestDefinitionForm() {
 		state,
 		fields,
 		isSaving: computed(() => isSaving.value),
-		deleteMetric,
-		updateMetrics,
 		loadTestData,
 		createTest,
 		updateTest,
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/shared/TableStatusCell.vue b/packages/frontend/editor-ui/src/components/TestDefinition/shared/TableStatusCell.vue
index 97f718b0835..72877554fed 100644
--- a/packages/frontend/editor-ui/src/components/TestDefinition/shared/TableStatusCell.vue
+++ b/packages/frontend/editor-ui/src/components/TestDefinition/shared/TableStatusCell.vue
@@ -27,8 +27,6 @@ const errorTooltipMap: Record<string, BaseTextKey> = {
 	FAILED_TO_EXECUTE_EVALUATION_WORKFLOW: 'testDefinition.runDetail.error.evaluationFailed',
 	FAILED_TO_EXECUTE_WORKFLOW: 'testDefinition.runDetail.error.executionFailed',
 	TRIGGER_NO_LONGER_EXISTS: 'testDefinition.runDetail.error.triggerNoLongerExists',
-	METRICS_MISSING: 'testDefinition.runDetail.error.metricsMissing',
-	UNKNOWN_METRICS: 'testDefinition.runDetail.error.unknownMetrics',
 	INVALID_METRICS: 'testDefinition.runDetail.error.invalidMetrics',
 
 	// Test run errors
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/tests/MetricsInput.test.ts b/packages/frontend/editor-ui/src/components/TestDefinition/tests/MetricsInput.test.ts
deleted file mode 100644
index 7d6545a5c50..00000000000
--- a/packages/frontend/editor-ui/src/components/TestDefinition/tests/MetricsInput.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createComponentRenderer } from '@/__tests__/render';
-import MetricsInput from '../EditDefinition/MetricsInput.vue';
-import userEvent from '@testing-library/user-event';
-
-const renderComponent = createComponentRenderer(MetricsInput);
-
-describe('MetricsInput', () => {
-	let props: { modelValue: Array<{ id?: string; name: string }> };
-
-	beforeEach(() => {
-		props = {
-			modelValue: [
-				{ name: 'Metric 1', id: 'metric-1' },
-				{ name: 'Metric 2', id: 'metric-2' },
-			],
-		};
-	});
-
-	it('should render correctly with initial metrics', () => {
-		const { getAllByPlaceholderText } = renderComponent({ props });
-		const inputs = getAllByPlaceholderText('e.g. latency');
-		expect(inputs).toHaveLength(2);
-		expect(inputs[0]).toHaveValue('Metric 1');
-		expect(inputs[1]).toHaveValue('Metric 2');
-	});
-
-	it('should update a metric when typing in the input', async () => {
-		const { getAllByPlaceholderText, emitted } = renderComponent({
-			props: {
-				modelValue: [{ name: '' }],
-			},
-		});
-		const inputs = getAllByPlaceholderText('e.g. latency');
-		await userEvent.type(inputs[0], 'Updated Metric 1');
-
-		// Every character typed triggers an update event. Let's check the last emission.
-		const allEmits = emitted('update:modelValue');
-		expect(allEmits).toBeTruthy();
-		// The last emission should contain the fully updated name
-		const lastEmission = allEmits[allEmits.length - 1];
-		expect(lastEmission).toEqual([[{ name: 'Updated Metric 1' }]]);
-	});
-
-	it('should render correctly with no initial metrics', () => {
-		props.modelValue = [];
-		const { queryAllByRole, getByText } = renderComponent({ props });
-		const inputs = queryAllByRole('textbox');
-		expect(inputs).toHaveLength(0);
-		expect(getByText('New metric')).toBeInTheDocument();
-	});
-
-	it('should handle adding multiple metrics', async () => {
-		const { getByText, emitted } = renderComponent({ props });
-		const addButton = getByText('New metric');
-
-		await userEvent.click(addButton);
-		await userEvent.click(addButton);
-		await userEvent.click(addButton);
-
-		// Each click adds a new metric
-		const updateEvents = emitted('update:modelValue');
-		expect(updateEvents).toHaveLength(3);
-
-		// Check the structure of one of the emissions
-		// Initial: [{ name: 'Metric 1' }, { name: 'Metric 2' }]
-		// After first click: [{ name: 'Metric 1' }, { name: 'Metric 2' }, { name: '' }]
-		expect(updateEvents[0]).toEqual([[...props.modelValue, { name: '' }]]);
-	});
-
-	it('should emit "deleteMetric" event when a delete button is clicked', async () => {
-		const { getAllByRole, emitted } = renderComponent({ props });
-
-		// Each metric row has a delete button, identified by "button"
-		const deleteButtons = getAllByRole('button', { name: '' });
-		expect(deleteButtons).toHaveLength(props.modelValue.length);
-
-		// Click on the delete button for the second metric
-		await userEvent.click(deleteButtons[1]);
-
-		expect(emitted('deleteMetric')).toBeTruthy();
-		expect(emitted('deleteMetric')[0]).toEqual([props.modelValue[1]]);
-	});
-
-	it('should emit multiple update events as the user types and reflect the final name correctly', async () => {
-		const { getAllByPlaceholderText, emitted } = renderComponent({
-			props: {
-				modelValue: [{ name: '' }],
-			},
-		});
-		const inputs = getAllByPlaceholderText('e.g. latency');
-		await userEvent.type(inputs[0], 'ABC');
-
-		const allEmits = emitted('update:modelValue');
-		expect(allEmits).toBeTruthy();
-		// Each character typed should emit a new value
-		expect(allEmits.length).toBe(3);
-		expect(allEmits[2]).toEqual([[{ name: 'ABC' }]]);
-	});
-
-	it('should not break if metrics are empty and still allow adding a new metric', async () => {
-		props.modelValue = [];
-		const { queryAllByRole, getByText, emitted } = renderComponent({ props });
-
-		// No metrics initially
-		const inputs = queryAllByRole('textbox');
-		expect(inputs).toHaveLength(0);
-
-		const addButton = getByText('New metric');
-		await userEvent.click(addButton);
-
-		const updates = emitted('update:modelValue');
-		expect(updates).toBeTruthy();
-		expect(updates[0]).toEqual([[{ name: '' }]]);
-
-		// After adding one metric, we should now have an input
-		const { getAllByPlaceholderText } = renderComponent({
-			props: { modelValue: [{ name: '' }] },
-		});
-		const updatedInputs = getAllByPlaceholderText('e.g. latency');
-		expect(updatedInputs).toHaveLength(1);
-	});
-
-	it('should handle deleting the first metric and still display remaining metrics correctly', async () => {
-		const { getAllByPlaceholderText, getAllByRole, rerender, emitted } = renderComponent({
-			props,
-		});
-		const inputs = getAllByPlaceholderText('e.g. latency');
-		expect(inputs).toHaveLength(2);
-
-		const deleteButtons = getAllByRole('button', { name: '' });
-		await userEvent.click(deleteButtons[0]);
-
-		expect(emitted('deleteMetric')).toBeTruthy();
-		expect(emitted('deleteMetric')[0]).toEqual([props.modelValue[0]]);
-
-		await rerender({ modelValue: [{ name: 'Metric 2' }] });
-		const updatedInputs = getAllByPlaceholderText('e.g. latency');
-		expect(updatedInputs).toHaveLength(1);
-		expect(updatedInputs[0]).toHaveValue('Metric 2');
-	});
-});
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/tests/useTestDefinitionForm.test.ts b/packages/frontend/editor-ui/src/components/TestDefinition/tests/useTestDefinitionForm.test.ts
index a89db28b8e5..b81a7dec7fa 100644
--- a/packages/frontend/editor-ui/src/components/TestDefinition/tests/useTestDefinitionForm.test.ts
+++ b/packages/frontend/editor-ui/src/components/TestDefinition/tests/useTestDefinitionForm.test.ts
@@ -48,20 +48,12 @@ describe('useTestDefinitionForm', () => {
 		expect(state.value.description.value).toBe('');
 		expect(state.value.name.value).toContain('My Test');
 		expect(state.value.tags.value).toEqual([]);
-		expect(state.value.metrics).toEqual([]);
 		expect(state.value.evaluationWorkflow.value).toBe('');
 	});
 
 	it('should load test data', async () => {
 		const { loadTestData, state } = useTestDefinitionForm();
 		const fetchSpy = vi.spyOn(useTestDefinitionStore(), 'fetchAll');
-		const fetchMetricsSpy = vi.spyOn(useTestDefinitionStore(), 'fetchMetrics').mockResolvedValue([
-			{
-				id: 'metric1',
-				name: 'Metric 1',
-				testDefinitionId: TEST_DEF_A.id,
-			},
-		]);
 		const evaluationsStore = mockedStore(useTestDefinitionStore);
 
 		evaluationsStore.testDefinitionsById = {
@@ -71,14 +63,10 @@ describe('useTestDefinitionForm', () => {
 
 		await loadTestData(TEST_DEF_A.id, '123');
 		expect(fetchSpy).toBeCalled();
-		expect(fetchMetricsSpy).toBeCalledWith(TEST_DEF_A.id);
 		expect(state.value.name.value).toEqual(TEST_DEF_A.name);
 		expect(state.value.description.value).toEqual(TEST_DEF_A.description);
 		expect(state.value.tags.value).toEqual([TEST_DEF_A.annotationTagId]);
 		expect(state.value.evaluationWorkflow.value).toEqual(TEST_DEF_A.evaluationWorkflowId);
-		expect(state.value.metrics).toEqual([
-			{ id: 'metric1', name: 'Metric 1', testDefinitionId: TEST_DEF_A.id },
-		]);
 	});
 
 	it('should gracefully handle loadTestData when no test definition found', async () => {
@@ -94,7 +82,6 @@ describe('useTestDefinitionForm', () => {
 		expect(state.value.description.value).toBe('');
 		expect(state.value.name.value).toContain('My Test');
 		expect(state.value.tags.value).toEqual([]);
-		expect(state.value.metrics).toEqual([]);
 	});
 
 	it('should handle errors while loading test data', async () => {
@@ -176,68 +163,6 @@ describe('useTestDefinitionForm', () => {
 		expect(updateSpy).toBeCalled();
 	});
 
-	it('should delete a metric', async () => {
-		const { state, deleteMetric } = useTestDefinitionForm();
-		const evaluationsStore = mockedStore(useTestDefinitionStore);
-		const deleteMetricSpy = vi.spyOn(evaluationsStore, 'deleteMetric');
-
-		state.value.metrics = [
-			{
-				id: 'metric1',
-				name: 'Metric 1',
-				testDefinitionId: '1',
-			},
-			{
-				id: 'metric2',
-				name: 'Metric 2',
-				testDefinitionId: '1',
-			},
-		];
-
-		await deleteMetric('metric1', TEST_DEF_A.id);
-		expect(deleteMetricSpy).toBeCalledWith({ id: 'metric1', testDefinitionId: TEST_DEF_A.id });
-		expect(state.value.metrics).toEqual([
-			{ id: 'metric2', name: 'Metric 2', testDefinitionId: '1' },
-		]);
-	});
-
-	it('should update metrics', async () => {
-		const { state, updateMetrics } = useTestDefinitionForm();
-		const evaluationsStore = mockedStore(useTestDefinitionStore);
-		const updateMetricSpy = vi.spyOn(evaluationsStore, 'updateMetric');
-		const createMetricSpy = vi
-			.spyOn(evaluationsStore, 'createMetric')
-			.mockResolvedValue({ id: 'metric_new', name: 'Metric 2', testDefinitionId: TEST_DEF_A.id });
-
-		state.value.metrics = [
-			{
-				id: 'metric1',
-				name: 'Metric 1',
-				testDefinitionId: TEST_DEF_A.id,
-			},
-			{
-				id: '',
-				name: 'Metric 2',
-				testDefinitionId: TEST_DEF_A.id,
-			}, // New metric that needs creation
-		];
-
-		await updateMetrics(TEST_DEF_A.id);
-		expect(createMetricSpy).toHaveBeenCalledWith({
-			name: 'Metric 2',
-			testDefinitionId: TEST_DEF_A.id,
-		});
-		expect(updateMetricSpy).toHaveBeenCalledWith({
-			name: 'Metric 1',
-			id: 'metric1',
-			testDefinitionId: TEST_DEF_A.id,
-		});
-		expect(state.value.metrics).toEqual([
-			{ id: 'metric1', name: 'Metric 1', testDefinitionId: TEST_DEF_A.id },
-			{ id: 'metric_new', name: 'Metric 2', testDefinitionId: TEST_DEF_A.id },
-		]);
-	});
-
 	it('should start editing a field', () => {
 		const { state, startEditing } = useTestDefinitionForm();
 
diff --git a/packages/frontend/editor-ui/src/components/TestDefinition/types.ts b/packages/frontend/editor-ui/src/components/TestDefinition/types.ts
index 36c74de9c4b..f52cf136904 100644
--- a/packages/frontend/editor-ui/src/components/TestDefinition/types.ts
+++ b/packages/frontend/editor-ui/src/components/TestDefinition/types.ts
@@ -1,4 +1,3 @@
-import type { TestMetricRecord } from '@/api/testDefinition.ee';
 import type { INodeParameterResourceLocator } from 'n8n-workflow';
 
 export interface EditableField<T = string> {
@@ -14,6 +13,5 @@ export interface EditableFormState {
 
 export interface EvaluationFormState extends EditableFormState {
 	evaluationWorkflow: INodeParameterResourceLocator;
-	metrics: TestMetricRecord[];
 	mockedNodes: Array<{ name: string; id: string }>;
 }
diff --git a/packages/frontend/editor-ui/src/constants.workflows.ts b/packages/frontend/editor-ui/src/constants.workflows.ts
index 582e0dc2aaf..4f5fa865968 100644
--- a/packages/frontend/editor-ui/src/constants.workflows.ts
+++ b/packages/frontend/editor-ui/src/constants.workflows.ts
@@ -62,23 +62,22 @@ export const SAMPLE_EVALUATION_WORKFLOW: IWorkflowDataCreate = {
 		},
 		{
 			parameters: {
-				assignments: {
+				metrics: {
 					assignments: [
 						{
-							id: 'a748051d-ebdb-4fcf-aaed-02756130ce2a',
 							name: 'latency',
 							value:
 								'={{(() => {\n  const newExecutionRuns = Object.values($json.newExecution)\n    .reduce((acc, node) => {\n      acc.push(node.runs.filter(run => run.output.main !== undefined))\n      return acc\n    }, []).flat()\n\n  const latency = newExecutionRuns.reduce((acc, run) => acc + run.executionTime, 0)\n\n  return latency\n})()}}',
 							type: 'number',
+							id: '1ebc15e9-f079-4d1f-a08d-d4880ea0ddb5',
 						},
 					],
 				},
-				options: {},
 			},
+			type: 'n8n-nodes-base.evaluationMetrics',
 			id: '33e2e94a-ec48-4e7b-b750-f56718d5105c',
 			name: 'Return metric(s)',
-			type: 'n8n-nodes-base.set',
-			typeVersion: 3.4,
+			typeVersion: 1,
 			position: [600, 440],
 		},
 		{
diff --git a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
index 2a619732437..2b39e92dec3 100644
--- a/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
+++ b/packages/frontend/editor-ui/src/plugins/i18n/locales/en.json
@@ -2918,11 +2918,6 @@
 	"testDefinition.edit.hideConfig": "Hide config",
 	"testDefinition.edit.backButtonTitle": "Back to Workflow Evaluation",
 	"testDefinition.edit.namePlaceholder": "Enter test name",
-	"testDefinition.edit.metricsTitle": "Metrics",
-	"testDefinition.edit.metricsHelpText": "The output field of the last node in the evaluation workflow. Metrics will be averaged across all test cases.",
-	"testDefinition.edit.metricsFields": "Output fields to use as metrics",
-	"testDefinition.edit.metricsPlaceholder": "e.g. latency",
-	"testDefinition.edit.metricsNew": "New metric",
 	"testDefinition.edit.selectTag": "Select tag...",
 	"testDefinition.edit.tagsHelpText": "Executions with this tag will be added as test cases to this test.",
 	"testDefinition.edit.workflowSelectorLabel": "Use a second workflow to make the comparison",
@@ -2952,9 +2947,6 @@
 	"testDefinition.edit.step.reRunExecutions.tooltip": "Each past execution is re-run using the latest version of the workflow being tested",
 	"testDefinition.edit.step.compareExecutions": "4. Compare each past and new execution",
 	"testDefinition.edit.step.compareExecutions.tooltip": "Each past execution is compared with its new equivalent to check how similar they are. This is done using a separate evaluation workflow: it receives the two execution versions as input, and outputs metrics.",
-	"testDefinition.edit.step.metrics": "5. Summarise metrics",
-	"testDefinition.edit.step.metrics.tooltip": "Metrics returned by the evaluation workflow (defined above). If included in this section, they are displayed in the test run results and averaged to give a score for the entire test run.",
-	"testDefinition.edit.step.metrics.description": "The names of fields output by your evaluation workflow in the step above.",
 	"testDefinition.edit.step.collapse": "Collapse",
 	"testDefinition.edit.step.configure": "Configure",
 	"testDefinition.edit.selectNodes": "Pin nodes to mock them",
@@ -3025,10 +3017,6 @@
 	"testDefinition.runDetail.error.evaluationFailed.solution": "View evaluation execution",
 	"testDefinition.runDetail.error.triggerNoLongerExists": "Trigger in benchmark execution no longer exists in workflow.{link}.",
 	"testDefinition.runDetail.error.triggerNoLongerExists.solution": "View benchmark",
-	"testDefinition.runDetail.error.metricsMissing": "Metrics defined in test were not returned by evaluation workflow {link}.",
-	"testDefinition.runDetail.error.metricsMissing.solution": "Fix test configuration",
-	"testDefinition.runDetail.error.unknownMetrics": "Evaluation workflow defined metrics that are not defined in the test. {link}.",
-	"testDefinition.runDetail.error.unknownMetrics.solution": "Fix test configuration",
 	"testDefinition.runDetail.error.invalidMetrics": "Evaluation workflow returned invalid metrics. Only numeric values are expected. View evaluation execution. {link}.",
 	"testDefinition.runDetail.error.invalidMetrics.solution": "View evaluation execution",
 	"testDefinition.runTest": "Run Test",
diff --git a/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.test.ts b/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.test.ts
index 6f43a939bb0..ed055a85b34 100644
--- a/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.test.ts
+++ b/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.test.ts
@@ -11,10 +11,6 @@ const {
 	deleteTestDefinition,
 	getTestDefinitions,
 	updateTestDefinition,
-	getTestMetrics,
-	createTestMetric,
-	updateTestMetric,
-	deleteTestMetric,
 	getTestRuns,
 	getTestRun,
 	startTestRun,
@@ -24,10 +20,6 @@ const {
 	createTestDefinition: vi.fn(),
 	updateTestDefinition: vi.fn(),
 	deleteTestDefinition: vi.fn(),
-	getTestMetrics: vi.fn(),
-	createTestMetric: vi.fn(),
-	updateTestMetric: vi.fn(),
-	deleteTestMetric: vi.fn(),
 	getTestRuns: vi.fn(),
 	getTestRun: vi.fn(),
 	startTestRun: vi.fn(),
@@ -39,10 +31,6 @@ vi.mock('@/api/testDefinition.ee', () => ({
 	deleteTestDefinition,
 	getTestDefinitions,
 	updateTestDefinition,
-	getTestMetrics,
-	createTestMetric,
-	updateTestMetric,
-	deleteTestMetric,
 	getTestRuns,
 	getTestRun,
 	startTestRun,
@@ -77,13 +65,6 @@ const TEST_DEF_NEW: TestDefinitionRecord = {
 	createdAt: '2023-01-01T00:00:00.000Z',
 };
 
-const TEST_METRIC = {
-	id: 'metric1',
-	name: 'Test Metric',
-	testDefinitionId: '1',
-	createdAt: '2023-01-01T00:00:00.000Z',
-};
-
 const TEST_RUN: TestRunRecord = {
 	id: 'run1',
 	testDefinitionId: '1',
@@ -124,7 +105,6 @@ describe('testDefinition.store.ee', () => {
 		getTestRun.mockResolvedValue(TEST_RUN);
 		startTestRun.mockResolvedValue({ success: true });
 		deleteTestRun.mockResolvedValue({ success: true });
-		getTestMetrics.mockResolvedValue([TEST_METRIC]);
 	});
 
 	test('Initialization', () => {
@@ -280,80 +260,6 @@ describe('testDefinition.store.ee', () => {
 		});
 	});
 
-	describe('Metrics', () => {
-		test('Fetching Metrics for a Test Definition', async () => {
-			const metrics = await store.fetchMetrics('1');
-
-			expect(getTestMetrics).toHaveBeenCalledWith(rootStoreMock.restApiContext, '1');
-			expect(store.metricsById).toEqual({
-				metric1: TEST_METRIC,
-			});
-			expect(metrics).toEqual([TEST_METRIC]);
-		});
-
-		test('Creating a Metric', async () => {
-			createTestMetric.mockResolvedValue(TEST_METRIC);
-
-			const params = {
-				name: 'Test Metric',
-				testDefinitionId: '1',
-			};
-
-			const result = await store.createMetric(params);
-
-			expect(createTestMetric).toHaveBeenCalledWith(rootStoreMock.restApiContext, params);
-			expect(store.metricsById).toEqual({
-				metric1: TEST_METRIC,
-			});
-			expect(result).toEqual(TEST_METRIC);
-		});
-
-		test('Updating a Metric', async () => {
-			const updatedMetric = { ...TEST_METRIC, name: 'Updated Metric' };
-			updateTestMetric.mockResolvedValue(updatedMetric);
-
-			const result = await store.updateMetric(updatedMetric);
-
-			expect(updateTestMetric).toHaveBeenCalledWith(rootStoreMock.restApiContext, updatedMetric);
-			expect(store.metricsById).toEqual({
-				metric1: updatedMetric,
-			});
-			expect(result).toEqual(updatedMetric);
-		});
-
-		test('Deleting a Metric', async () => {
-			store.metricsById = {
-				metric1: TEST_METRIC,
-			};
-
-			const params = { id: 'metric1', testDefinitionId: '1' };
-			deleteTestMetric.mockResolvedValue(undefined);
-
-			await store.deleteMetric(params);
-
-			expect(deleteTestMetric).toHaveBeenCalledWith(rootStoreMock.restApiContext, params);
-			expect(store.metricsById).toEqual({});
-		});
-
-		test('Getting Metrics by Test ID', () => {
-			const metric1 = { ...TEST_METRIC, id: 'metric1', testDefinitionId: '1' };
-			const metric2 = { ...TEST_METRIC, id: 'metric2', testDefinitionId: '1' };
-			const metric3 = { ...TEST_METRIC, id: 'metric3', testDefinitionId: '2' };
-
-			store.metricsById = {
-				metric1,
-				metric2,
-				metric3,
-			};
-
-			const metricsForTest1 = store.metricsByTestId['1'];
-			expect(metricsForTest1).toEqual([metric1, metric2]);
-
-			const metricsForTest2 = store.metricsByTestId['2'];
-			expect(metricsForTest2).toEqual([metric3]);
-		});
-	});
-
 	describe('Computed Properties', () => {
 		test('hasTestDefinitions', () => {
 			store.testDefinitionsById = {};
diff --git a/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.ts b/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.ts
index 283947f4be8..9206044bd9b 100644
--- a/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.ts
+++ b/packages/frontend/editor-ui/src/stores/testDefinition.store.ee.ts
@@ -21,7 +21,6 @@ export const useTestDefinitionStore = defineStore(
 		const testDefinitionsById = ref<Record<string, TestDefinitionRecord>>({});
 		const loading = ref(false);
 		const fetchedAll = ref(false);
-		const metricsById = ref<Record<string, testDefinitionsApi.TestMetricRecord>>({});
 		const testRunsById = ref<Record<string, TestRunRecord>>({});
 		const testCaseExecutionsById = ref<Record<string, TestCaseExecutionRecord>>({});
 		const pollingTimeouts = ref<Record<string, NodeJS.Timeout>>({});
@@ -61,19 +60,6 @@ export const useTestDefinitionStore = defineStore(
 
 		const hasTestDefinitions = computed(() => Object.keys(testDefinitionsById.value).length > 0);
 
-		const metricsByTestId = computed(() => {
-			return Object.values(metricsById.value).reduce(
-				(acc: Record<string, testDefinitionsApi.TestMetricRecord[]>, metric) => {
-					if (!acc[metric.testDefinitionId]) {
-						acc[metric.testDefinitionId] = [];
-					}
-					acc[metric.testDefinitionId].push(metric);
-					return acc;
-				},
-				{},
-			);
-		});
-
 		const testRunsByTestId = computed(() => {
 			return Object.values(testRunsById.value).reduce(
 				(acc: Record<string, TestRunRecord[]>, run) => {
@@ -157,11 +143,6 @@ export const useTestDefinitionStore = defineStore(
 			}
 		};
 
-		const fetchMetricsForAllTests = async () => {
-			const testDefinitions = Object.values(testDefinitionsById.value);
-			await Promise.all(testDefinitions.map(async (testDef) => await fetchMetrics(testDef.id)));
-		};
-
 		const fetchTestDefinition = async (id: string) => {
 			const testDefinition = await testDefinitionsApi.getTestDefinition(
 				rootStore.restApiContext,
@@ -221,7 +202,6 @@ export const useTestDefinitionStore = defineStore(
 				await Promise.all([
 					tagsStore.fetchAll({ force: true, withUsageCount: true }),
 					fetchRunsForAllTests(),
-					fetchMetricsForAllTests(),
 				]);
 				return retrievedDefinitions;
 			} finally {
@@ -289,48 +269,6 @@ export const useTestDefinitionStore = defineStore(
 			return result.success;
 		};
 
-		const fetchMetrics = async (testId: string) => {
-			loading.value = true;
-			try {
-				const metrics = await testDefinitionsApi.getTestMetrics(rootStore.restApiContext, testId);
-				metrics.forEach((metric) => {
-					metricsById.value[metric.id] = { ...metric, testDefinitionId: testId };
-				});
-				return metrics.map((metric) => ({ ...metric, testDefinitionId: testId }));
-			} finally {
-				loading.value = false;
-			}
-		};
-
-		const createMetric = async (params: {
-			name: string;
-			testDefinitionId: string;
-		}): Promise<testDefinitionsApi.TestMetricRecord> => {
-			const metric = await testDefinitionsApi.createTestMetric(rootStore.restApiContext, params);
-			metricsById.value[metric.id] = { ...metric, testDefinitionId: params.testDefinitionId };
-			return metric;
-		};
-
-		const updateMetric = async (
-			params: testDefinitionsApi.TestMetricRecord,
-		): Promise<testDefinitionsApi.TestMetricRecord> => {
-			const metric = await testDefinitionsApi.updateTestMetric(rootStore.restApiContext, params);
-			metricsById.value[metric.id] = { ...metric, testDefinitionId: params.testDefinitionId };
-
-			updateRunFieldIssues(params.testDefinitionId);
-			return metric;
-		};
-
-		const deleteMetric = async (
-			params: testDefinitionsApi.DeleteTestMetricParams,
-		): Promise<void> => {
-			await testDefinitionsApi.deleteTestMetric(rootStore.restApiContext, params);
-			const { [params.id]: deleted, ...rest } = metricsById.value;
-			metricsById.value = rest;
-
-			updateRunFieldIssues(params.testDefinitionId);
-		};
-
 		// Test Runs Methods
 		const fetchTestRuns = async (testDefinitionId: string) => {
 			loading.value = true;
@@ -436,14 +374,6 @@ export const useTestDefinitionStore = defineStore(
 				});
 			}
 
-			const metrics = metricsByTestId.value[testId] || [];
-			if (metrics.filter((metric) => metric.name).length === 0) {
-				issues.push({
-					field: 'metrics',
-					message: locale.baseText('testDefinition.configError.noMetrics'),
-				});
-			}
-
 			fieldsIssues.value = {
 				...fieldsIssues.value,
 				[testId]: issues,
@@ -464,8 +394,6 @@ export const useTestDefinitionStore = defineStore(
 			isLoading,
 			hasTestDefinitions,
 			isFeatureEnabled,
-			metricsById,
-			metricsByTestId,
 			testRunsByTestId,
 			lastRunByTestId,
 
@@ -480,10 +408,6 @@ export const useTestDefinitionStore = defineStore(
 			deleteById,
 			upsertTestDefinitions,
 			deleteTestDefinition,
-			fetchMetrics,
-			createMetric,
-			updateMetric,
-			deleteMetric,
 			fetchTestRuns,
 			getTestRun,
 			startTestRun,
diff --git a/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionEditView.vue b/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionEditView.vue
index 719f5605ac1..45a89c405e2 100644
--- a/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionEditView.vue
+++ b/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionEditView.vue
@@ -9,7 +9,7 @@ import { useAnnotationTagsStore } from '@/stores/tags.store';
 import { computed, ref, watch } from 'vue';
 import { useRouter } from 'vue-router';
 
-import type { TestMetricRecord, TestRunRecord } from '@/api/testDefinition.ee';
+import type { TestRunRecord } from '@/api/testDefinition.ee';
 import InlineNameEdit from '@/components/InlineNameEdit.vue';
 import ConfigSection from '@/components/TestDefinition/EditDefinition/sections/ConfigSection.vue';
 import RunsSection from '@/components/TestDefinition/EditDefinition/sections/RunsSection.vue';
@@ -44,17 +44,8 @@ watch(visibility, async () => {
 	testDefinitionStore.updateRunFieldIssues(props.testId);
 });
 
-const {
-	state,
-	isSaving,
-	cancelEditing,
-	loadTestData,
-	updateTest,
-	startEditing,
-	saveChanges,
-	deleteMetric,
-	updateMetrics,
-} = useTestDefinitionForm();
+const { state, isSaving, cancelEditing, loadTestData, updateTest, startEditing, saveChanges } =
+	useTestDefinitionForm();
 
 const isLoading = computed(() => tagsStore.isLoading);
 const tagsById = computed(() => tagsStore.tagsById);
@@ -79,22 +70,11 @@ const handleUpdateTest = async () => {
 };
 
 const handleUpdateTestDebounced = debounce(handleUpdateTest, { debounceTime: 400, trailing: true });
-const handleUpdateMetricsDebounced = debounce(
-	async (testId: string) => {
-		await updateMetrics(testId);
-		testDefinitionStore.updateRunFieldIssues(testId);
-	},
-	{ debounceTime: 400, trailing: true },
-);
 
 function getFieldIssues(key: string) {
 	return fieldsIssues.value.filter((issue) => issue.field === key);
 }
 
-async function onDeleteMetric(deletedMetric: TestMetricRecord) {
-	await deleteMetric(deletedMetric.id, props.testId);
-}
-
 async function openPinningModal() {
 	uiStore.openModal(NODE_PINNING_MODAL_KEY);
 }
@@ -253,7 +233,6 @@ function onEvaluationWorkflowCreated(workflowId: string) {
 					v-if="showConfig"
 					v-model:tags="state.tags"
 					v-model:evaluationWorkflow="state.evaluationWorkflow"
-					v-model:metrics="state.metrics"
 					v-model:mockedNodes="state.mockedNodes"
 					:class="$style.config"
 					:cancel-editing="cancelEditing"
@@ -266,11 +245,9 @@ function onEvaluationWorkflowCreated(workflowId: string) {
 					:example-pinned-data="examplePinnedData"
 					:sample-workflow-name="workflowName"
 					@rename-tag="renameTag"
-					@update:metrics="() => handleUpdateMetricsDebounced(testId)"
 					@update:evaluation-workflow="handleUpdateTestDebounced"
 					@update:mocked-nodes="handleUpdateTestDebounced"
 					@open-pinning-modal="openPinningModal"
-					@delete-metric="onDeleteMetric"
 					@open-executions-view-for-tag="openExecutionsViewForTag"
 					@evaluation-workflow-created="onEvaluationWorkflowCreated($event)"
 				/>
diff --git a/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionRunDetailView.vue b/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionRunDetailView.vue
index 11d242a8bf6..aaffda172ff 100644
--- a/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionRunDetailView.vue
+++ b/packages/frontend/editor-ui/src/views/TestDefinition/TestDefinitionRunDetailView.vue
@@ -19,8 +19,6 @@ const TEST_CASE_EXECUTION_ERROR_CODE = {
 	FAILED_TO_EXECUTE_WORKFLOW: 'FAILED_TO_EXECUTE_WORKFLOW',
 	EVALUATION_WORKFLOW_DOES_NOT_EXIST: 'EVALUATION_WORKFLOW_DOES_NOT_EXIST',
 	FAILED_TO_EXECUTE_EVALUATION_WORKFLOW: 'FAILED_TO_EXECUTE_EVALUATION_WORKFLOW',
-	METRICS_MISSING: 'METRICS_MISSING',
-	UNKNOWN_METRICS: 'UNKNOWN_METRICS',
 	INVALID_METRICS: 'INVALID_METRICS',
 	PAYLOAD_LIMIT_EXCEEDED: 'PAYLOAD_LIMIT_EXCEEDED',
 	UNKNOWN_ERROR: 'UNKNOWN_ERROR',
@@ -97,8 +95,6 @@ const testCaseErrorDictionary: Partial<Record<TestCaseExecutionErrorCodes, BaseT
 	FAILED_TO_EXECUTE_EVALUATION_WORKFLOW: 'testDefinition.runDetail.error.evaluationFailed',
 	FAILED_TO_EXECUTE_WORKFLOW: 'testDefinition.runDetail.error.executionFailed',
 	TRIGGER_NO_LONGER_EXISTS: 'testDefinition.runDetail.error.triggerNoLongerExists',
-	METRICS_MISSING: 'testDefinition.runDetail.error.metricsMissing',
-	UNKNOWN_METRICS: 'testDefinition.runDetail.error.unknownMetrics',
 	INVALID_METRICS: 'testDefinition.runDetail.error.invalidMetrics',
 } as const;
 
@@ -143,20 +139,6 @@ const getErrorTooltipLinkRoute = (row: TestCaseExecutionRecord) => {
 				executionId: row.pastExecutionId,
 			},
 		};
-	} else if (row.errorCode === TEST_CASE_EXECUTION_ERROR_CODE.METRICS_MISSING) {
-		return {
-			name: VIEWS.TEST_DEFINITION_EDIT,
-			params: {
-				testId: testId.value,
-			},
-		};
-	} else if (row.errorCode === TEST_CASE_EXECUTION_ERROR_CODE.UNKNOWN_METRICS) {
-		return {
-			name: VIEWS.TEST_DEFINITION_EDIT,
-			params: {
-				testId: testId.value,
-			},
-		};
 	} else if (row.errorCode === TEST_CASE_EXECUTION_ERROR_CODE.INVALID_METRICS) {
 		return {
 			name: VIEWS.EXECUTION_PREVIEW,
diff --git a/packages/frontend/editor-ui/src/views/TestDefinition/tests/TestDefinitionEditView.test.ts b/packages/frontend/editor-ui/src/views/TestDefinition/tests/TestDefinitionEditView.test.ts
index e900649e924..7f709a332eb 100644
--- a/packages/frontend/editor-ui/src/views/TestDefinition/tests/TestDefinitionEditView.test.ts
+++ b/packages/frontend/editor-ui/src/views/TestDefinition/tests/TestDefinitionEditView.test.ts
@@ -14,7 +14,6 @@ const form: Partial<ReturnType<typeof useTestDefinitionForm>> = {
 		description: { value: '', isEditing: false, tempValue: '' },
 		tags: { value: [], tempValue: [], isEditing: false },
 		evaluationWorkflow: { mode: 'list', value: '', __rl: true },
-		metrics: [],
 		mockedNodes: [],
 	}),
 	loadTestData: vi.fn(),
@@ -22,8 +21,6 @@ const form: Partial<ReturnType<typeof useTestDefinitionForm>> = {
 	updateTest: vi.fn(),
 	startEditing: vi.fn(),
 	saveChanges: vi.fn(),
-	deleteMetric: vi.fn(),
-	updateMetrics: vi.fn(),
 	createTest: vi.fn(),
 };
 vi.mock('@/components/TestDefinition/composables/useTestDefinitionForm', () => ({

From f5f8abbbecd3f5dd6ff4033d88d07ba37347b6d4 Mon Sep 17 00:00:00 2001
From: Alex Grozav <alex@grozav.com>
Date: Tue, 25 Mar 2025 17:32:24 +0200
Subject: [PATCH 31/33] fix: Support relative tsconfig paths on multiple levels
 in jest config (no-changelog) (#14162)

---
 jest.config.js | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/jest.config.js b/jest.config.js
index 5c14b7800a5..e0892381419 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -1,4 +1,5 @@
-const { compilerOptions } = require('./tsconfig.json');
+const { pathsToModuleNameMapper } = require('ts-jest')
+const { compilerOptions } = require('get-tsconfig').getTsconfig().config;
 
 /** @type {import('ts-jest').TsJestGlobalOptions} */
 const tsJestOptions = {
@@ -10,7 +11,6 @@ const tsJestOptions = {
 	},
 };
 
-const { baseUrl, paths } = require('get-tsconfig').getTsconfig().config?.compilerOptions;
 
 const isCoverageEnabled = process.env.COVERAGE_ENABLED === 'true';
 
@@ -24,15 +24,7 @@ const config = {
 		'^.+\\.ts$': ['ts-jest', tsJestOptions],
 	},
 	// This resolve the path mappings from the tsconfig relative to each jest.config.js
-	moduleNameMapper: Object.entries(paths || {}).reduce((acc, [path, [mapping]]) => {
-		path = `^${path.replace(/\/\*$/, '/(.*)$')}`;
-		mapping = mapping.replace(/^\.?\.\/(?:(.*)\/)?\*$/, '$1');
-		mapping = mapping ? `/${mapping}` : '';
-		acc[path] = mapping.startsWith('/test')
-			? '<rootDir>' + mapping + '/$1'
-			: '<rootDir>' + (baseUrl ? `/${baseUrl.replace(/^\.\//, '')}` : '') + mapping + '/$1';
-		return acc;
-	}, {}),
+	moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: `<rootDir>${compilerOptions.baseUrl ? `/${compilerOptions.baseUrl.replace(/^\.\//, '')}` : ''}` }),
 	setupFilesAfterEnv: ['jest-expect-message'],
 	collectCoverage: isCoverageEnabled,
 	coverageReporters: ['text-summary', 'lcov', 'html-spa'],

From 7fb6eb1488e6103e82dbf2f2a1270c36f41c8546 Mon Sep 17 00:00:00 2001
From: Danny Martini <danny@n8n.io>
Date: Tue, 25 Mar 2025 16:41:48 +0100
Subject: [PATCH 32/33] ci: Also run MySQL and PG tests when modules have
 changes in repos or entities (#14170)

---
 .github/workflows/ci-postgres-mysql.yml              |  1 +
 packages/cli/src/databases/entities/index.ts         |  6 +++---
 .../insights/__tests__/insights.controller.test.ts   |  4 ++--
 .../insights/__tests__/insights.service.test.ts      | 10 +++++-----
 .../{ => database}/entities/__tests__/db-utils.ts    |  4 ++--
 .../entities/__tests__/insights-by-period.test.ts    |  0
 .../entities/__tests__/insights-raw.test.ts          |  0
 .../{ => database}/entities/insights-by-period.ts    |  2 +-
 .../{ => database}/entities/insights-metadata.ts     |  0
 .../insights/{ => database}/entities/insights-raw.ts |  2 +-
 .../{ => database}/entities/insights-shared.ts       |  0
 .../repositories/insights-by-period.repository.ts    |  0
 .../repositories/insights-metadata.repository.ts     |  0
 .../repositories/insights-raw.repository.ts          |  0
 .../cli/src/modules/insights/insights.service.ts     | 12 ++++++------
 15 files changed, 21 insertions(+), 20 deletions(-)
 rename packages/cli/src/modules/insights/{ => database}/entities/__tests__/db-utils.ts (96%)
 rename packages/cli/src/modules/insights/{ => database}/entities/__tests__/insights-by-period.test.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/entities/__tests__/insights-raw.test.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/entities/insights-by-period.ts (93%)
 rename packages/cli/src/modules/insights/{ => database}/entities/insights-metadata.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/entities/insights-raw.ts (92%)
 rename packages/cli/src/modules/insights/{ => database}/entities/insights-shared.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/repositories/insights-by-period.repository.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/repositories/insights-metadata.repository.ts (100%)
 rename packages/cli/src/modules/insights/{ => database}/repositories/insights-raw.repository.ts (100%)

diff --git a/.github/workflows/ci-postgres-mysql.yml b/.github/workflows/ci-postgres-mysql.yml
index 07ac7543565..f3464a24674 100644
--- a/.github/workflows/ci-postgres-mysql.yml
+++ b/.github/workflows/ci-postgres-mysql.yml
@@ -7,6 +7,7 @@ on:
   pull_request:
     paths:
       - packages/cli/src/databases/**
+      - packages/cli/src/modules/*/database/**
       - .github/workflows/ci-postgres-mysql.yml
       - .github/docker-compose.yml
   pull_request_review:
diff --git a/packages/cli/src/databases/entities/index.ts b/packages/cli/src/databases/entities/index.ts
index 1066aa059c6..aab1044abf3 100644
--- a/packages/cli/src/databases/entities/index.ts
+++ b/packages/cli/src/databases/entities/index.ts
@@ -33,9 +33,9 @@ import { WorkflowEntity } from './workflow-entity';
 import { WorkflowHistory } from './workflow-history';
 import { WorkflowStatistics } from './workflow-statistics';
 import { WorkflowTagMapping } from './workflow-tag-mapping';
-import { InsightsByPeriod } from '../../modules/insights/entities/insights-by-period';
-import { InsightsMetadata } from '../../modules/insights/entities/insights-metadata';
-import { InsightsRaw } from '../../modules/insights/entities/insights-raw';
+import { InsightsByPeriod } from '../../modules/insights/database/entities/insights-by-period';
+import { InsightsMetadata } from '../../modules/insights/database/entities/insights-metadata';
+import { InsightsRaw } from '../../modules/insights/database/entities/insights-raw';
 
 export const entities = {
 	AnnotationTagEntity,
diff --git a/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts b/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
index 82f7696b955..c13f0b8f437 100644
--- a/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
+++ b/packages/cli/src/modules/insights/__tests__/insights.controller.test.ts
@@ -3,9 +3,9 @@ import { Container } from '@n8n/di';
 import { mockInstance } from '@test/mocking';
 import * as testDb from '@test-integration/test-db';
 
-import { TypeToNumber } from '../entities/insights-shared';
+import { TypeToNumber } from '../database/entities/insights-shared';
+import { InsightsByPeriodRepository } from '../database/repositories/insights-by-period.repository';
 import { InsightsController } from '../insights.controller';
-import { InsightsByPeriodRepository } from '../repositories/insights-by-period.repository';
 
 // Initialize DB once for all tests
 beforeAll(async () => {
diff --git a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
index 36bb41c5c92..0805d190c25 100644
--- a/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
+++ b/packages/cli/src/modules/insights/__tests__/insights.service.test.ts
@@ -7,9 +7,9 @@ import type { ExecutionStatus, IRun, WorkflowExecuteMode } from 'n8n-workflow';
 import type { Project } from '@/databases/entities/project';
 import type { WorkflowEntity } from '@/databases/entities/workflow-entity';
 import type { IWorkflowDb } from '@/interfaces';
-import type { TypeUnit } from '@/modules/insights/entities/insights-shared';
-import { InsightsMetadataRepository } from '@/modules/insights/repositories/insights-metadata.repository';
-import { InsightsRawRepository } from '@/modules/insights/repositories/insights-raw.repository';
+import type { TypeUnit } from '@/modules/insights/database/entities/insights-shared';
+import { InsightsMetadataRepository } from '@/modules/insights/database/repositories/insights-metadata.repository';
+import { InsightsRawRepository } from '@/modules/insights/database/repositories/insights-raw.repository';
 import { createTeamProject } from '@test-integration/db/projects';
 import { createWorkflow } from '@test-integration/db/workflows';
 import * as testDb from '@test-integration/test-db';
@@ -19,9 +19,9 @@ import {
 	createRawInsightsEvent,
 	createCompactedInsightsEvent,
 	createRawInsightsEvents,
-} from '../entities/__tests__/db-utils';
+} from '../database/entities/__tests__/db-utils';
+import { InsightsByPeriodRepository } from '../database/repositories/insights-by-period.repository';
 import { InsightsService } from '../insights.service';
-import { InsightsByPeriodRepository } from '../repositories/insights-by-period.repository';
 
 async function truncateAll() {
 	const insightsRawRepository = Container.get(InsightsRawRepository);
diff --git a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts b/packages/cli/src/modules/insights/database/entities/__tests__/db-utils.ts
similarity index 96%
rename from packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
rename to packages/cli/src/modules/insights/database/entities/__tests__/db-utils.ts
index 84e1e203c20..03c4b0f31cf 100644
--- a/packages/cli/src/modules/insights/entities/__tests__/db-utils.ts
+++ b/packages/cli/src/modules/insights/database/entities/__tests__/db-utils.ts
@@ -5,12 +5,12 @@ import type { IWorkflowBase } from 'n8n-workflow';
 import type { WorkflowEntity } from '@/databases/entities/workflow-entity';
 import { SharedWorkflowRepository } from '@/databases/repositories/shared-workflow.repository';
 
-import { InsightsMetadata } from '../../entities/insights-metadata';
-import { InsightsRaw } from '../../entities/insights-raw';
 import { InsightsByPeriodRepository } from '../../repositories/insights-by-period.repository';
 import { InsightsMetadataRepository } from '../../repositories/insights-metadata.repository';
 import { InsightsRawRepository } from '../../repositories/insights-raw.repository';
 import { InsightsByPeriod } from '../insights-by-period';
+import { InsightsMetadata } from '../insights-metadata';
+import { InsightsRaw } from '../insights-raw';
 
 async function getWorkflowSharing(workflow: IWorkflowBase) {
 	return await Container.get(SharedWorkflowRepository).find({
diff --git a/packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts b/packages/cli/src/modules/insights/database/entities/__tests__/insights-by-period.test.ts
similarity index 100%
rename from packages/cli/src/modules/insights/entities/__tests__/insights-by-period.test.ts
rename to packages/cli/src/modules/insights/database/entities/__tests__/insights-by-period.test.ts
diff --git a/packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts b/packages/cli/src/modules/insights/database/entities/__tests__/insights-raw.test.ts
similarity index 100%
rename from packages/cli/src/modules/insights/entities/__tests__/insights-raw.test.ts
rename to packages/cli/src/modules/insights/database/entities/__tests__/insights-raw.test.ts
diff --git a/packages/cli/src/modules/insights/entities/insights-by-period.ts b/packages/cli/src/modules/insights/database/entities/insights-by-period.ts
similarity index 93%
rename from packages/cli/src/modules/insights/entities/insights-by-period.ts
rename to packages/cli/src/modules/insights/database/entities/insights-by-period.ts
index 34b7abb15b8..25c8ae6cc06 100644
--- a/packages/cli/src/modules/insights/entities/insights-by-period.ts
+++ b/packages/cli/src/modules/insights/database/entities/insights-by-period.ts
@@ -10,7 +10,7 @@ import {
 	PeriodUnitToNumber,
 	TypeToNumber,
 } from './insights-shared';
-import { datetimeColumnType } from '../../../databases/entities/abstract-entity';
+import { datetimeColumnType } from '../../../../databases/entities/abstract-entity';
 
 @Entity()
 export class InsightsByPeriod extends BaseEntity {
diff --git a/packages/cli/src/modules/insights/entities/insights-metadata.ts b/packages/cli/src/modules/insights/database/entities/insights-metadata.ts
similarity index 100%
rename from packages/cli/src/modules/insights/entities/insights-metadata.ts
rename to packages/cli/src/modules/insights/database/entities/insights-metadata.ts
diff --git a/packages/cli/src/modules/insights/entities/insights-raw.ts b/packages/cli/src/modules/insights/database/entities/insights-raw.ts
similarity index 92%
rename from packages/cli/src/modules/insights/entities/insights-raw.ts
rename to packages/cli/src/modules/insights/database/entities/insights-raw.ts
index ceff552a985..4c20e04e64c 100644
--- a/packages/cli/src/modules/insights/entities/insights-raw.ts
+++ b/packages/cli/src/modules/insights/database/entities/insights-raw.ts
@@ -4,7 +4,7 @@ import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from '@n8n/typeorm
 import { UnexpectedError } from 'n8n-workflow';
 
 import { isValidTypeNumber, NumberToType, TypeToNumber } from './insights-shared';
-import { datetimeColumnType } from '../../../databases/entities/abstract-entity';
+import { datetimeColumnType } from '../../../../databases/entities/abstract-entity';
 
 export const { type: dbType } = Container.get(GlobalConfig).database;
 
diff --git a/packages/cli/src/modules/insights/entities/insights-shared.ts b/packages/cli/src/modules/insights/database/entities/insights-shared.ts
similarity index 100%
rename from packages/cli/src/modules/insights/entities/insights-shared.ts
rename to packages/cli/src/modules/insights/database/entities/insights-shared.ts
diff --git a/packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts b/packages/cli/src/modules/insights/database/repositories/insights-by-period.repository.ts
similarity index 100%
rename from packages/cli/src/modules/insights/repositories/insights-by-period.repository.ts
rename to packages/cli/src/modules/insights/database/repositories/insights-by-period.repository.ts
diff --git a/packages/cli/src/modules/insights/repositories/insights-metadata.repository.ts b/packages/cli/src/modules/insights/database/repositories/insights-metadata.repository.ts
similarity index 100%
rename from packages/cli/src/modules/insights/repositories/insights-metadata.repository.ts
rename to packages/cli/src/modules/insights/database/repositories/insights-metadata.repository.ts
diff --git a/packages/cli/src/modules/insights/repositories/insights-raw.repository.ts b/packages/cli/src/modules/insights/database/repositories/insights-raw.repository.ts
similarity index 100%
rename from packages/cli/src/modules/insights/repositories/insights-raw.repository.ts
rename to packages/cli/src/modules/insights/database/repositories/insights-raw.repository.ts
diff --git a/packages/cli/src/modules/insights/insights.service.ts b/packages/cli/src/modules/insights/insights.service.ts
index 0462efd3ca6..1bcd06e9164 100644
--- a/packages/cli/src/modules/insights/insights.service.ts
+++ b/packages/cli/src/modules/insights/insights.service.ts
@@ -11,14 +11,14 @@ import {
 import { SharedWorkflow } from '@/databases/entities/shared-workflow';
 import { SharedWorkflowRepository } from '@/databases/repositories/shared-workflow.repository';
 import { OnShutdown } from '@/decorators/on-shutdown';
-import { InsightsMetadata } from '@/modules/insights/entities/insights-metadata';
-import { InsightsRaw } from '@/modules/insights/entities/insights-raw';
+import { InsightsMetadata } from '@/modules/insights/database/entities/insights-metadata';
+import { InsightsRaw } from '@/modules/insights/database/entities/insights-raw';
 
-import type { TypeUnit } from './entities/insights-shared';
-import { NumberToType } from './entities/insights-shared';
+import type { TypeUnit } from './database/entities/insights-shared';
+import { NumberToType } from './database/entities/insights-shared';
+import { InsightsByPeriodRepository } from './database/repositories/insights-by-period.repository';
+import { InsightsRawRepository } from './database/repositories/insights-raw.repository';
 import { InsightsConfig } from './insights.config';
-import { InsightsByPeriodRepository } from './repositories/insights-by-period.repository';
-import { InsightsRawRepository } from './repositories/insights-raw.repository';
 
 const config = Container.get(InsightsConfig);
 

From 3d332ab04fa0de9873cd8944514afa4e2bf7907b Mon Sep 17 00:00:00 2001
From: Guillaume Jacquart <jacquart.guillaume@gmail.com>
Date: Tue, 25 Mar 2025 16:48:06 +0100
Subject: [PATCH 33/33] feat(API): Add fields to insight by time type and
 export types from index (#14172)

---
 packages/@n8n/api-types/src/index.ts                      | 2 ++
 .../src/schemas/__tests__/insights.schema.test.ts         | 8 ++++++++
 packages/@n8n/api-types/src/schemas/insights.schema.ts    | 2 ++
 3 files changed, 12 insertions(+)

diff --git a/packages/@n8n/api-types/src/index.ts b/packages/@n8n/api-types/src/index.ts
index 6b8a4d53168..c0bc13020ee 100644
--- a/packages/@n8n/api-types/src/index.ts
+++ b/packages/@n8n/api-types/src/index.ts
@@ -32,4 +32,6 @@ export type {
 	InsightsSummaryType,
 	InsightsSummaryUnit,
 	InsightsSummary,
+	InsightsByWorkflow,
+	InsightsByTime,
 } from './schemas/insights.schema';
diff --git a/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts b/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
index 266fb5562ac..2c2a8737b23 100644
--- a/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
+++ b/packages/@n8n/api-types/src/schemas/__tests__/insights.schema.test.ts
@@ -162,6 +162,8 @@ describe('insightsByTimeSchema', () => {
 				date: '2025-03-25T10:34:36.484Z',
 				values: {
 					total: 200,
+					succeeded: 180,
+					failed: 20,
 					failureRate: 10,
 					averageRunTime: 40,
 					timeSaved: 100,
@@ -175,6 +177,8 @@ describe('insightsByTimeSchema', () => {
 				date: '20240325', // Should be a string
 				values: {
 					total: 200,
+					succeeded: 180,
+					failed: 20,
 					failureRate: 10,
 					averageRunTime: 40,
 					timeSaved: 100,
@@ -188,6 +192,8 @@ describe('insightsByTimeSchema', () => {
 				date: 20240325, // Should be a string
 				values: {
 					total: 200,
+					succeeded: 180,
+					failed: 20,
 					failureRate: 10,
 					averageRunTime: 40,
 					timeSaved: 100,
@@ -201,6 +207,8 @@ describe('insightsByTimeSchema', () => {
 				date: '2025-03-25T10:34:36.484Z',
 				values: {
 					total: 200,
+					succeeded: 180,
+					failed: 20,
 					failureRate: 10,
 					averageRunTime: 40,
 				},
diff --git a/packages/@n8n/api-types/src/schemas/insights.schema.ts b/packages/@n8n/api-types/src/schemas/insights.schema.ts
index 8dda1000ca3..57f2608769f 100644
--- a/packages/@n8n/api-types/src/schemas/insights.schema.ts
+++ b/packages/@n8n/api-types/src/schemas/insights.schema.ts
@@ -74,6 +74,8 @@ export const insightsByTimeDataSchemas = {
 	values: z
 		.object({
 			total: z.number(),
+			succeeded: z.number(),
+			failed: z.number(),
 			failureRate: z.number(),
 			averageRunTime: z.number(),
 			timeSaved: z.number(),