feat(core): Use active version instead of current version (no-changelog)

packages/@n8n/backend-test-utils/src/db/workflows.ts

@@ -5,6 +5,7 @@ import {
 	ProjectRepository,
 	SharedWorkflowRepository,
 	WorkflowRepository,
+	WorkflowHistoryRepository,
 } from '@n8n/db';
 import { Container } from '@n8n/di';
 import type { WorkflowSharingRole } from '@n8n/permissions';
@@ -185,3 +186,33 @@ export async function getAllSharedWorkflows() {
 
 export const getWorkflowById = async (id: string) =>
 	await Container.get(WorkflowRepository).findOneBy({ id });
+
+/**
+ * Create a workflow history record for a workflow
+ * @param workflow workflow to create history for
+ * @param user user who created the version (optional)
+ */
+export async function createWorkflowHistory(workflow: IWorkflowDb, user?: User): Promise<void> {
+	await Container.get(WorkflowHistoryRepository).insert({
+		workflowId: workflow.id,
+		versionId: workflow.versionId,
+		nodes: workflow.nodes,
+		connections: workflow.connections,
+		authors: user?.email ?? '[email protected]',
+	});
+}
+
+/**
+ * Set the active version for a workflow
+ * @param workflowId workflow ID
+ * @param versionId version ID to set as active
+ */
+export async function setActiveVersion(workflowId: string, versionId: string): Promise<void> {
+	const workflowHistory = await Container.get(WorkflowHistoryRepository).findOneOrFail({
+		where: { workflowId, versionId },
+	});
+
+	await Container.get(WorkflowRepository).update(workflowId, {
+		activeVersion: workflowHistory,
+	});
+}

packages/@n8n/db/src/entities/workflow-entity.ts

@@ -18,6 +18,7 @@ import type { SharedWorkflow } from './shared-workflow';
 import type { TagEntity } from './tag-entity';
 import type { TestRun } from './test-run.ee';
 import type { ISimplifiedPinData, IWorkflowDb } from './types-db';
+import type { WorkflowHistory } from './workflow-history';
 import type { WorkflowStatistics } from './workflow-statistics';
 import type { WorkflowTagMapping } from './workflow-tag-mapping';
 import { objectRetriever, sqlite } from '../utils/transformers';
@@ -103,6 +104,10 @@ export class WorkflowEntity extends WithTimestampsAndStringId implements IWorkfl
 	@Column({ length: 36 })
 	versionId: string;
 
+	@ManyToOne('WorkflowHistory', { nullable: true })
+	@JoinColumn({ name: 'activeVersionId', referencedColumnName: 'versionId' })
+	activeVersion: WorkflowHistory | null;
+
 	@Column({ default: 1 })
 	versionCounter: number;
 

packages/@n8n/db/src/migrations/common/1762819200000-AddActiveVersionIdColumn.ts

@@ -0,0 +1,43 @@
+import type { MigrationContext, ReversibleMigration } from '../migration-types';
+
+const WORKFLOWS_TABLE_NAME = 'workflow_entity';
+const WORKFLOW_HISTORY_TABLE_NAME = 'workflow_history';
+
+export class AddActiveVersionIdColumn1762819200000 implements ReversibleMigration {
+	async up({
+		schemaBuilder: { addColumns, column, addForeignKey },
+		queryRunner,
+		escape,
+	}: MigrationContext) {
+		const workflowsTableName = escape.tableName(WORKFLOWS_TABLE_NAME);
+
+		await addColumns(WORKFLOWS_TABLE_NAME, [column('activeVersionId').varchar(36)]);
+
+		await addForeignKey(
+			WORKFLOWS_TABLE_NAME,
+			'activeVersionId',
+			[WORKFLOW_HISTORY_TABLE_NAME, 'versionId'],
+			undefined,
+			'SET NULL',
+		);
+
+		// For existing ACTIVE workflows, set activeVersionId = versionId
+		const versionIdColumn = escape.columnName('versionId');
+		const activeColumn = escape.columnName('active');
+		const activeVersionIdColumn = escape.columnName('activeVersionId');
+
+		await queryRunner.query(
+			`UPDATE ${workflowsTableName}
+			 SET ${activeVersionIdColumn} = ${versionIdColumn}
+			 WHERE ${activeColumn} = true`,
+		);
+	}
+
+	async down({ schemaBuilder: { dropColumns, dropForeignKey } }: MigrationContext) {
+		await dropForeignKey(WORKFLOWS_TABLE_NAME, 'activeVersionId', [
+			WORKFLOW_HISTORY_TABLE_NAME,
+			'versionId',
+		]);
+		await dropColumns(WORKFLOWS_TABLE_NAME, ['activeVersionId']);
+	}
+}

packages/@n8n/db/src/migrations/mysqldb/index.ts

@@ -111,7 +111,8 @@
 import { CreateWorkflowDependencyTable1760314000000 } from '../common/1760314000000-CreateWorkflowDependencyTable';
 import { AddWorkflowDescriptionColumn1762177736257 } from '../common/1762177736257-AddWorkflowDescriptionColumn';
 import { BackfillMissingWorkflowHistoryRecords1762763704614 } from '../common/1762763704614-BackfillMissingWorkflowHistoryRecords';
+import { AddActiveVersionIdColumn1762819200000 } from './../common/1762819200000-AddActiveVersionIdColumn';
 import type { Migration } from '../migration-types';
 
 export const mysqlMigrations: Migration[] = [
 	InitialMigration1588157391238,
@@ -227,4 +228,5 @@
 	AddWorkflowDescriptionColumn1762177736257,
 	CreateOAuthEntities1760116750277,
 	BackfillMissingWorkflowHistoryRecords1762763704614,
+	AddActiveVersionIdColumn1762819200000,
 ];

packages/@n8n/db/src/migrations/postgresdb/index.ts

@@ -110,6 +110,7 @@ import { CreateWorkflowDependencyTable1760314000000 } from '../common/1760314000
 import { DropUnusedChatHubColumns1760965142113 } from '../common/1760965142113-DropUnusedChatHubColumns';
 import { AddWorkflowDescriptionColumn1762177736257 } from '../common/1762177736257-AddWorkflowDescriptionColumn';
 import { BackfillMissingWorkflowHistoryRecords1762763704614 } from '../common/1762763704614-BackfillMissingWorkflowHistoryRecords';
+import { AddActiveVersionIdColumn1762819200000 } from '../common/1762819200000-AddActiveVersionIdColumn';
 import type { Migration } from '../migration-types';
 
 export const postgresMigrations: Migration[] = [
@@ -225,4 +226,5 @@ export const postgresMigrations: Migration[] = [
 	AddWorkflowDescriptionColumn1762177736257,
 	CreateOAuthEntities1760116750277,
 	BackfillMissingWorkflowHistoryRecords1762763704614,
+	AddActiveVersionIdColumn1762819200000,
 ];

packages/@n8n/db/src/migrations/sqlite/index.ts

@@ -107,6 +107,7 @@ import { CreateWorkflowDependencyTable1760314000000 } from '../common/1760314000
 import { DropUnusedChatHubColumns1760965142113 } from '../common/1760965142113-DropUnusedChatHubColumns';
 import { AddWorkflowDescriptionColumn1762177736257 } from '../common/1762177736257-AddWorkflowDescriptionColumn';
 import { BackfillMissingWorkflowHistoryRecords1762763704614 } from '../common/1762763704614-BackfillMissingWorkflowHistoryRecords';
+import { AddActiveVersionIdColumn1762819200000 } from '../common/1762819200000-AddActiveVersionIdColumn';
 import type { Migration } from '../migration-types';
 
 const sqliteMigrations: Migration[] = [
@@ -219,6 +220,7 @@ const sqliteMigrations: Migration[] = [
 	AddWorkflowDescriptionColumn1762177736257,
 	CreateOAuthEntities1760116750277,
 	BackfillMissingWorkflowHistoryRecords1762763704614,
+	AddActiveVersionIdColumn1762819200000,
 ];
 
 export { sqliteMigrations };

packages/@n8n/db/src/repositories/shared-workflow.repository.ts

@@ -149,13 +149,15 @@ export class SharedWorkflowRepository extends Repository<SharedWorkflow> {
 			where?: FindOptionsWhere<SharedWorkflow>;
 			includeTags?: boolean;
 			includeParentFolder?: boolean;
+			includeActiveVersion?: boolean;
 			em?: EntityManager;
 		} = {},
 	) {
 		const {
 			where = {},
 			includeTags = false,
 			includeParentFolder = false,
+			includeActiveVersion = false,
 			em = this.manager,
 		} = options;
 
@@ -169,6 +171,7 @@ export class SharedWorkflowRepository extends Repository<SharedWorkflow> {
 					shared: { project: { projectRelations: { user: true } } },
 					tags: includeTags,
 					parentFolder: includeParentFolder,
+					activeVersion: includeActiveVersion,
 				},
 			},
 		});

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

@@ -97,7 +97,7 @@ export class WorkflowRepository extends Repository<WorkflowEntity> {
 	async findById(workflowId: string) {
 		return await this.findOne({
 			where: { id: workflowId },
-			relations: { shared: { project: { projectRelations: true } } },
+			relations: { shared: { project: { projectRelations: true } }, activeVersion: true },
 		});
 	}
 
@@ -763,11 +763,12 @@ export class WorkflowRepository extends Repository<WorkflowEntity> {
 	}
 
 	async deactivateAll() {
-		return await this.update({ active: true }, { active: false });
+		return await this.update({ active: true }, { active: false, activeVersion: null });
 	}
 
+	// We're planning to remove this command in V2, so for now just set activeVersion to null so that executions would use the current version
 	async activateAll() {
-		return await this.update({ active: false }, { active: true });
+		return await this.update({ active: false }, { active: true, activeVersion: null });
 	}
 
 	async findByActiveState(activeState: boolean) {

packages/cli/src/__tests__/active-workflow-manager.test.ts

@@ -1,5 +1,5 @@
 import { mockLogger } from '@n8n/backend-test-utils';
-import type { WorkflowEntity, WorkflowRepository } from '@n8n/db';
+import type { WorkflowEntity, WorkflowHistory, WorkflowRepository } from '@n8n/db';
 import { mock } from 'jest-mock-extended';
 import type { InstanceSettings } from 'n8n-core';
 import type {
@@ -165,4 +165,75 @@ describe('ActiveWorkflowManager', () => {
 			expect(getAllActiveIds).toHaveBeenCalledTimes(1);
 		});
 	});
+
+	describe('activateWorkflow', () => {
+		beforeEach(() => {
+			// Set up as leader to allow workflow activation
+			Object.assign(instanceSettings, { isLeader: true });
+		});
+
+		test('should use active version when calling executeErrorWorkflow on activation failure', async () => {
+			// Create different nodes for draft vs active version
+			const draftNodes = [
+				{
+					id: 'draft-node-1',
+					name: 'Draft Webhook',
+					type: 'n8n-nodes-base.webhook',
+					typeVersion: 1,
+					position: [0, 0] as [number, number],
+					parameters: {},
+				},
+			];
+
+			const activeNodes = [
+				{
+					id: 'active-node-1',
+					name: 'Active Webhook',
+					type: 'n8n-nodes-base.webhook',
+					typeVersion: 1,
+					position: [0, 0] as [number, number],
+					parameters: {},
+				},
+			];
+
+			const activeVersion = mock<WorkflowHistory>({
+				versionId: 'v1',
+				workflowId: 'workflow-1',
+				nodes: activeNodes,
+				connections: {},
+				authors: 'test-user',
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			});
+
+			const workflowEntity = mock<WorkflowEntity>({
+				id: 'workflow-1',
+				name: 'Test Workflow',
+				active: true,
+				nodes: draftNodes,
+				connections: {},
+				activeVersion,
+			});
+
+			workflowRepository.findById.mockResolvedValue(workflowEntity);
+
+			// Mock the add method to throw an error (simulating activation failure)
+			jest.spyOn(activeWorkflowManager, 'add').mockRejectedValue(new Error('Authorization failed'));
+
+			const executeErrorWorkflowSpy = jest
+				.spyOn(activeWorkflowManager, 'executeErrorWorkflow')
+				.mockImplementation(() => {});
+
+			await activeWorkflowManager['activateWorkflow']('workflow-1', 'init');
+
+			expect(executeErrorWorkflowSpy).toHaveBeenCalled();
+
+			// Get the workflow data that was passed to executeErrorWorkflow
+			const callArgs = executeErrorWorkflowSpy.mock.calls[0];
+			const workflowData = callArgs[1];
+
+			expect(workflowData.nodes).toEqual(activeNodes);
+			expect(workflowData.nodes[0].name).toBe('Active Webhook');
+		});
+	});
 });

packages/cli/src/active-workflow-manager.ts

@@ -248,17 +248,26 @@ export class ActiveWorkflowManager {
 	async clearWebhooks(workflowId: WorkflowId) {
 		const workflowData = await this.workflowRepository.findOne({
 			where: { id: workflowId },
+			relations: { activeVersion: true },
 		});
 
 		if (workflowData === null) {
 			throw new UnexpectedError('Could not find workflow', { extra: { workflowId } });
 		}
 
+		if (!workflowData.activeVersion) {
+			throw new UnexpectedError('Active version not found for workflow', {
+				extra: { workflowId },
+			});
+		}
+
+		const { nodes, connections } = workflowData.activeVersion;
+
 		const workflow = new Workflow({
 			id: workflowId,
 			name: workflowData.name,
-			nodes: workflowData.nodes,
-			connections: workflowData.connections,
+			nodes,
+			connections,
 			active: workflowData.active,
 			nodeTypes: this.nodeTypes,
 			staticData: workflowData.staticData,
@@ -488,8 +497,17 @@ export class ActiveWorkflowManager {
 				},
 			);
 
+			if (!dbWorkflow.activeVersion) {
+				throw new UnexpectedError('Active version not found for workflow', {
+					extra: { workflowId: dbWorkflow.id },
+				});
+			}
+
+			const { nodes, connections } = dbWorkflow.activeVersion;
+			const workflowForError = { ...dbWorkflow, nodes, connections };
+
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-			this.executeErrorWorkflow(error, dbWorkflow, 'internal');
+			this.executeErrorWorkflow(error, workflowForError, 'internal');
 
 			// do not keep trying to activate on authorization error
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -577,11 +595,22 @@ export class ActiveWorkflowManager {
 				return added;
 			}
 
+			// Get workflow data from the active version
+			if (!dbWorkflow.activeVersion) {
+				throw new UnexpectedError('Active version not found for workflow', {
+					extra: { workflowId: dbWorkflow.id },
+				});
+			}
+
+			const { nodes, connections } = dbWorkflow.activeVersion;
+			dbWorkflow.nodes = nodes;
+			dbWorkflow.connections = connections;
+
 			workflow = new Workflow({
 				id: dbWorkflow.id,
 				name: dbWorkflow.name,
-				nodes: dbWorkflow.nodes,
-				connections: dbWorkflow.connections,
+				nodes,
+				connections,
 				active: dbWorkflow.active,
 				nodeTypes: this.nodeTypes,
 				staticData: dbWorkflow.staticData,

packages/cli/src/public-api/types.ts

@@ -82,7 +82,7 @@ export declare namespace WorkflowRequest {
 	type Get = AuthenticatedRequest<{ id: string }, {}, {}, { excludePinnedData?: boolean }>;
 	type Delete = Get;
 	type Update = AuthenticatedRequest<{ id: string }, {}, WorkflowEntity, {}>;
-	type Activate = Get;
+	type Activate = AuthenticatedRequest<{ id: string }, {}, {}, {}>;
 	type GetTags = Get;
 	type UpdateTags = AuthenticatedRequest<{ id: string }, {}, TagEntity[]>;
 	type Transfer = AuthenticatedRequest<{ id: string }, {}, { destinationProjectId: string }>;

packages/cli/src/public-api/v1/handlers/workflows/spec/schemas/activeVersion.yml

@@ -0,0 +1,35 @@
+type: object
+additionalProperties: false
+properties:
+  versionId:
+    type: string
+    readOnly: true
+    description: Unique identifier for this workflow version
+    example: 7c6b9e3f-8d4a-4b2c-9f1e-6a5d3b8c7e4f
+  workflowId:
+    type: string
+    readOnly: true
+    description: The workflow this version belongs to
+    example: 2tUt1wbLX592XDdX
+  nodes:
+    type: array
+    readOnly: true
+    items:
+      $ref: './node.yml'
+  connections:
+    type: object
+    readOnly: true
+    example: { Jira: { main: [[{ node: 'Jira', type: 'main', index: 0 }]] } }
+  authors:
+    type: string
+    readOnly: true
+    description: Comma-separated list of author IDs who contributed to this version
+    example: 1,2,3
+  createdAt:
+    type: string
+    format: date-time
+    readOnly: true
+  updatedAt:
+    type: string
+    format: date-time
+    readOnly: true