import/export tags

packages/cli/commands/export/workflow.ts

@@ -110,8 +110,10 @@ export class ExportWorkflowsCommand extends Command {
 				findQuery.id = flags.id;
 			}
 
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const workflows = await Db.collections.Workflow.find(findQuery);
+			const workflows = await Db.collections.Workflow.find({
+				where: findQuery,
+				relations: ['tags'],
+			});
 
 			if (workflows.length === 0) {
 				throw new Error('No workflows found with specified filters.');

packages/cli/commands/import/workflow.ts

@@ -17,15 +17,24 @@ import glob from 'fast-glob';
 import { UserSettings } from 'n8n-core';
 import { EntityManager, getConnection } from 'typeorm';
 import { getLogger } from '../../src/Logger';
-import { Db, ICredentialsDb } from '../../src';
+import { Db, ICredentialsDb, IWorkflowToImport } from '../../src';
 import { SharedWorkflow } from '../../src/databases/entities/SharedWorkflow';
 import { WorkflowEntity } from '../../src/databases/entities/WorkflowEntity';
 import { Role } from '../../src/databases/entities/Role';
 import { User } from '../../src/databases/entities/User';
+import { setTagsForImport } from '../../src/TagHelpers';
 
 const FIX_INSTRUCTION =
 	'Please fix the database by running ./packages/cli/bin/n8n user-management:reset';
 
+function assertWorkflowsToImport(workflows: unknown): asserts workflows is IWorkflowToImport[] {
+	if (!Array.isArray(workflows)) {
+		throw new Error(
+			'File does not seem to contain workflows. Make sure the workflows are contained in an array.',
+		);
+	}
+}
+
 export class ImportWorkflowsCommand extends Command {
 	static description = 'Import workflows';
 
@@ -83,6 +92,7 @@ export class ImportWorkflowsCommand extends Command {
 			// Make sure the settings exist
 			await UserSettings.prepareUserSettings();
 			const credentials = (await Db.collections.Credentials.find()) ?? [];
+			const tags = (await Db.collections.Tag.find()) ?? [];
 
 			let totalImported = 0;
 
@@ -111,6 +121,10 @@ export class ImportWorkflowsCommand extends Command {
 							});
 						}
 
+						if (Object.prototype.hasOwnProperty.call(workflow, 'tags')) {
+							await setTagsForImport(transactionManager, workflow, tags);
+						}
+
 						await this.storeWorkflow(workflow, user);
 					}
 				});
@@ -123,11 +137,7 @@ export class ImportWorkflowsCommand extends Command {
 
 			totalImported = workflows.length;
 
-			if (!Array.isArray(workflows)) {
-				throw new Error(
-					'File does not seem to contain workflows. Make sure the workflows are contained in an array.',
-				);
-			}
+			assertWorkflowsToImport(workflows);
 
 			await getConnection().transaction(async (transactionManager) => {
 				this.transactionManager = transactionManager;
@@ -139,6 +149,10 @@ export class ImportWorkflowsCommand extends Command {
 						});
 					}
 
+					if (Object.prototype.hasOwnProperty.call(workflow, 'tags')) {
+						await setTagsForImport(transactionManager, workflow, tags);
+					}
+
 					await this.storeWorkflow(workflow, user);
 				}
 			});

packages/cli/src/Interfaces.ts

@@ -114,6 +114,13 @@ export interface ITagDb {
 	updatedAt: Date;
 }
 
+export interface ITagToImport {
+	id: string | number;
+	name: string;
+	createdAt?: string;
+	updatedAt?: string;
+}
+
 export type UsageCount = {
 	usageCount: number;
 };
@@ -134,6 +141,10 @@ export interface IWorkflowDb extends IWorkflowBase {
 	tags: ITagDb[];
 }
 
+export interface IWorkflowToImport extends IWorkflowBase {
+	tags: ITagToImport[];
+}
+
 export interface IWorkflowResponse extends IWorkflowBase {
 	id: string;
 }

packages/cli/src/Server.ts

@@ -1241,7 +1241,7 @@ class App {
 						return TagHelpers.getTagsWithCountDb(tablePrefix);
 					}
 
-					return Db.collections.Tag.find({ select: ['id', 'name'] });
+					return Db.collections.Tag.find({ select: ['id', 'name', 'createdAt', 'updatedAt'] });
 				},
 			),
 		);

packages/cli/src/TagHelpers.ts

@@ -1,11 +1,11 @@
 /* eslint-disable no-param-reassign */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable import/no-cycle */
-import { getConnection } from 'typeorm';
+import { EntityManager, getConnection } from 'typeorm';
 
 import { TagEntity } from './databases/entities/TagEntity';
 
-import { ITagWithCountDb } from './Interfaces';
+import { ITagToImport, ITagWithCountDb } from './Interfaces';
 
 // ----------------------------------
 //              utils
@@ -38,6 +38,8 @@ export async function getTagsWithCountDb(tablePrefix: string): Promise<ITagWithC
 		.createQueryBuilder()
 		.select(`${tablePrefix}tag_entity.id`, 'id')
 		.addSelect(`${tablePrefix}tag_entity.name`, 'name')
+		.addSelect(`${tablePrefix}tag_entity.createdAt`, 'createdAt')
+		.addSelect(`${tablePrefix}tag_entity.updatedAt`, 'updatedAt')
 		.addSelect(`COUNT(${tablePrefix}workflows_tags.workflowId)`, 'usageCount')
 		.from(`${tablePrefix}tag_entity`, 'tag_entity')
 		.leftJoin(
@@ -86,3 +88,67 @@ export async function removeRelations(workflowId: string, tablePrefix: string) {
 		.where('workflowId = :id', { id: workflowId })
 		.execute();
 }
+
+const createTag = async (transactionManager: EntityManager, name: string): Promise<TagEntity> => {
+	const tag = new TagEntity();
+	tag.name = name;
+	return transactionManager.save<TagEntity>(tag);
+};
+
+const findOrCreateTag = async (
+	transactionManager: EntityManager,
+	importTag: ITagToImport,
+	tagsEntities: TagEntity[],
+): Promise<TagEntity> => {
+	// Assume tag is identical if createdAt date is the same to preserve a changed tag name
+	const identicalMatch = tagsEntities.find(
+		(existingTag) =>
+			existingTag.id.toString() === importTag.id.toString() &&
+			existingTag.createdAt &&
+			importTag.createdAt &&
+			new Date(existingTag.createdAt) === new Date(importTag.createdAt),
+	);
+	if (identicalMatch) {
+		return identicalMatch;
+	}
+
+	// Find tag with identical name
+	const nameMatch = tagsEntities.find((existingTag) => existingTag.name === importTag.name);
+	if (nameMatch) {
+		return nameMatch;
+	}
+
+	// Create new Tag
+	const createdTag = await createTag(transactionManager, importTag.name);
+	return createdTag;
+};
+
+/**
+ * Set tag ids to use existing tags, creates a new tag if no matching tag could be found
+ *
+ * @param transactionManager
+ * @param workflow
+ * @param tagsEntities
+ * @returns
+ */
+export async function setTagsForImport(
+	transactionManager: EntityManager,
+	workflow: { tags: ITagToImport[] },
+	tags: TagEntity[],
+): Promise<void> {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+	const workflowTags = workflow.tags;
+	if (!workflowTags || !Array.isArray(workflowTags) || workflowTags.length === 0) {
+		return;
+	}
+	for (let i = 0; i < workflowTags.length; i++) {
+		if (workflowTags[i] && typeof workflowTags[i].name !== 'undefined') {
+			// eslint-disable-next-line no-await-in-loop
+			const tag = await findOrCreateTag(transactionManager, workflowTags[i], tags);
+			workflowTags[i] = {
+				id: tag.id,
+				name: tag.name,
+			};
+		}
+	}
+}

packages/editor-ui/src/Interface.ts

@@ -730,6 +730,8 @@ export interface ITag {
 	id: string;
 	name: string;
 	usageCount?: number;
+	createdAt?: string;
+	updatedAt?: string;
 }
 
 export interface ITagRow {

packages/editor-ui/src/components/MainSidebar.vue

@@ -511,10 +511,21 @@ export default mixins(
 					if (data.id && typeof data.id === 'string') {
 						data.id = parseInt(data.id, 10);
 					}
-					const blob = new Blob([JSON.stringify(data, null, 2)], {
+
+					const exportData: IWorkflowDataUpdate = {
+						...data,
+						tags: (tags || []).map(tagId => {
+							const {usageCount, ...tag} = this.$store.getters["tags/getTagById"](tagId);
+
+							return tag;
+						}),
+					};
+
+					const blob = new Blob([JSON.stringify(exportData, null, 2)], {
 						type: 'application/json;charset=utf-8',
 					});
 
+
 					let workflowName = this.$store.getters.workflowName || 'unsaved_workflow';
 
 					workflowName = workflowName.replace(/[^a-z0-9]/gi, '_');

packages/editor-ui/src/modules/tags.ts

@@ -64,10 +64,10 @@ const module: Module<ITagsState, IRootState> = {
 		},
 	},
 	actions: {
-		fetchAll: async (context: ActionContext<ITagsState, IRootState>, params?: { force?: boolean, withUsageCount?: boolean }) => {
+		fetchAll: async (context: ActionContext<ITagsState, IRootState>, params?: { force?: boolean, withUsageCount?: boolean }): Promise<ITag[]> => {
 			const { force = false, withUsageCount = false } = params || {};
 			if (!force && context.state.fetchedAll && context.state.fetchedUsageCount === withUsageCount) {
-				return context.state.tags;
+				return Object.values(context.state.tags);
 			}
 
 			context.commit('setLoading', true);
@@ -77,7 +77,7 @@ const module: Module<ITagsState, IRootState> = {
 
 			return tags;
 		},
-		create: async (context: ActionContext<ITagsState, IRootState>, name: string) => {
+		create: async (context: ActionContext<ITagsState, IRootState>, name: string): Promise<ITag> => {
 			const tag = await createTag(context.rootGetters.getRestApiContext, { name });
 			context.commit('upsertTags', [tag]);
 
@@ -88,7 +88,7 @@ const module: Module<ITagsState, IRootState> = {
 			context.commit('upsertTags', [tag]);
 
 			return tag;
-		}, 
+		},
 		delete: async (context: ActionContext<ITagsState, IRootState>, id: string) => {
 			const deleted = await deleteTag(context.rootGetters.getRestApiContext, id);
 
@@ -98,8 +98,8 @@ const module: Module<ITagsState, IRootState> = {
 			}
 
 			return deleted;
-		}, 
+		},
 	},
 };
 
-export default module;
+export default module;

packages/editor-ui/src/store.ts

@@ -611,6 +611,10 @@ export const store = new Vuex.Store({
 			Vue.set(state.workflow, 'tags', tags);
 		},
 
+		addWorkflowTagIds (state, tags: string[]) {
+			Vue.set(state.workflow, 'tags', [...(state.workflow.tags || []), ...tags]);
+		},
+
 		removeWorkflowTagId (state, tagId: string) {
 			const tags = state.workflow.tags as string[];
 			const updated = tags.filter((id: string) => id !== tagId);

packages/editor-ui/src/views/NodeView.vue

@@ -1253,6 +1253,31 @@ export default mixins(
 							this.nodeSelectedByName(node.name);
 						});
 					});
+
+					const tagsEnabled = this.$store.getters['settings/areTagsEnabled'];
+					if (Array.isArray(workflowData.tags) && tagsEnabled) {
+						const allTags: ITag[] = await this.$store.dispatch('tags/fetchAll');
+						const tagNames = new Set(allTags.map((tag) => tag.name));
+
+						const workflowTags = workflowData.tags as ITag[];
+						const notFound = workflowTags.filter((tag) => !tagNames.has(tag.name));
+						for (const tag of notFound) {
+							allTags.push(await this.$store.dispatch('tags/create', tag.name));
+						}
+
+						const tagIds = workflowTags.map((imported) => {
+							const tag = allTags.find(tag => tag.name === imported.name);
+							if (tag) {
+								return tag.id;
+							}
+
+							return undefined;
+						})
+							.filter((id) => !!id);
+
+						this.$store.commit('addWorkflowTagIds', tagIds || []);
+					}
+
 				} catch (error) {
 					this.$showError(
 						error,