feat: Implement history management for chatflows and assistants

- Added history service to manage snapshots of chatflows and assistants.
- Integrated history snapshot creation on chatflow save and update operations.
- Created API endpoints for fetching, restoring, and deleting history snapshots.
- Developed UI components for displaying and managing version history in the assistant and chatflow configurations.
- Added HistoryButton and HistoryDialog components for user interaction with version history.
- Implemented flow reload functionality to update the canvas with restored chatflow data.

Author: Amrrx

packages/components/nodes/tools/MCP/core.ts

@@ -259,7 +259,7 @@ function waitForStreamingCompletion(
     return new Promise<string>((resolve) => {
         let completed = false
 
-        const completeExecution = (reason: string) => {
+        const completeExecution = (_reason: string) => {
             if (completed) return
             completed = true
 

packages/server/src/Interface.ts

@@ -70,6 +70,7 @@ export interface IChatFlow {
     category?: string
     type?: ChatflowType
     workspaceId?: string
+    currentHistoryVersion?: number
 }
 
 export interface IChatMessage {
@@ -125,6 +126,7 @@ export interface IAssistant {
     updatedDate: Date
     createdDate: Date
     workspaceId?: string
+    currentHistoryVersion?: number
 }
 
 export interface ICredential {
@@ -191,6 +193,17 @@ export interface IVariableDict {
     [key: string]: string
 }
 
+export interface IFlowHistory {
+    id: string
+    entityType: 'CHATFLOW' | 'ASSISTANT'
+    entityId: string
+    snapshotData: string
+    changeDescription?: string
+    version: number
+    createdDate: Date
+    workspaceId?: string
+}
+
 export interface INodeDependencies {
     [key: string]: number
 }

packages/server/src/controllers/history/index.ts

@@ -0,0 +1,110 @@
+import { NextFunction, Request, Response } from 'express'
+import { StatusCodes } from 'http-status-codes'
+import { EntityType } from '../../database/entities/FlowHistory'
+import { InternalFlowiseError } from '../../errors/internalFlowiseError'
+import historyService from '../../services/history'
+
+const validateEntityType = (entityType: string): EntityType => {
+    const upperType = entityType.toUpperCase()
+    if (!['CHATFLOW', 'ASSISTANT'].includes(upperType)) {
+        throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'entityType must be either CHATFLOW or ASSISTANT')
+    }
+    return upperType as EntityType
+}
+
+const getHistory = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { entityType, entityId } = req.params
+        const { page = '1', limit = '20' } = req.query
+
+        if (!entityType || !entityId) {
+            throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'entityType and entityId are required parameters')
+        }
+
+        const pageNum = Number(page)
+        const limitNum = Number(limit)
+
+        const result = await historyService.getHistory({
+            entityType: validateEntityType(entityType),
+            entityId,
+            workspaceId: req.user?.activeWorkspaceId,
+            limit: limitNum,
+            offset: (pageNum - 1) * limitNum
+        })
+
+        return res.json(result)
+    } catch (error) {
+        next(error)
+    }
+}
+
+const getSnapshotById = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { historyId } = req.params
+        if (!historyId) {
+            throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'historyId is required')
+        }
+
+        const snapshot = await historyService.getSnapshotById(historyId)
+        return res.json(snapshot)
+    } catch (error) {
+        next(error)
+    }
+}
+
+const restoreSnapshot = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { historyId } = req.params
+        if (!historyId) {
+            throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'historyId is required')
+        }
+
+        const restoredEntity = await historyService.restoreSnapshot({
+            historyId,
+            workspaceId: req.user?.activeWorkspaceId
+        })
+
+        return res.json({
+            message: 'Successfully restored from history snapshot',
+            entity: restoredEntity
+        })
+    } catch (error) {
+        next(error)
+    }
+}
+
+const deleteSnapshot = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { historyId } = req.params
+        if (!historyId) {
+            throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'historyId is required')
+        }
+
+        await historyService.deleteSnapshot(historyId, req.user?.activeWorkspaceId)
+        return res.json({ message: 'History snapshot deleted successfully' })
+    } catch (error) {
+        next(error)
+    }
+}
+
+const getSnapshotComparison = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const { historyId1, historyId2 } = req.params
+        if (!historyId1 || !historyId2) {
+            throw new InternalFlowiseError(StatusCodes.BAD_REQUEST, 'Both historyId1 and historyId2 are required')
+        }
+
+        const comparison = await historyService.getSnapshotComparison(historyId1, historyId2, req.user?.activeWorkspaceId)
+        return res.json(comparison)
+    } catch (error) {
+        next(error)
+    }
+}
+
+export default {
+    getHistory,
+    getSnapshotById,
+    restoreSnapshot,
+    deleteSnapshot,
+    getSnapshotComparison
+}

packages/server/src/database/entities/Assistant.ts

@@ -29,4 +29,7 @@ export class Assistant implements IAssistant {
 
     @Column({ nullable: true, type: 'text' })
     workspaceId?: string
+
+    @Column({ nullable: true, type: 'int' })
+    currentHistoryVersion?: number
 }

packages/server/src/database/entities/ChatFlow.ts

@@ -60,4 +60,7 @@ export class ChatFlow implements IChatFlow {
 
     @Column({ nullable: true, type: 'text' })
     workspaceId?: string
+
+    @Column({ nullable: true, type: 'int' })
+    currentHistoryVersion?: number
 }

packages/server/src/database/entities/FlowHistory.ts

@@ -0,0 +1,45 @@
+/* eslint-disable */
+import { Entity, Column, CreateDateColumn, PrimaryGeneratedColumn, Index } from 'typeorm'
+
+export type EntityType = 'CHATFLOW' | 'ASSISTANT'
+
+export interface IFlowHistory {
+    id: string
+    entityType: EntityType
+    entityId: string
+    snapshotData: string
+    changeDescription?: string
+    version: number
+    createdDate: Date
+    workspaceId?: string
+}
+
+@Entity()
+@Index(['entityType', 'entityId', 'version'])
+@Index(['entityType', 'entityId', 'createdDate'])
+export class FlowHistory implements IFlowHistory {
+    @PrimaryGeneratedColumn('uuid')
+    id: string
+
+    @Column({ type: 'varchar', length: 20 })
+    entityType: EntityType
+
+    @Column({ type: 'uuid' })
+    entityId: string
+
+    @Column({ type: 'text' })
+    snapshotData: string
+
+    @Column({ nullable: true, type: 'text' })
+    changeDescription?: string
+
+    @Column({ type: 'int' })
+    version: number
+
+    @Column({ type: 'timestamp' })
+    @CreateDateColumn()
+    createdDate: Date
+
+    @Column({ nullable: true, type: 'text' })
+    workspaceId?: string
+}

packages/server/src/database/entities/index.ts

@@ -17,6 +17,7 @@ import { Evaluator } from './Evaluator'
 import { ApiKey } from './ApiKey'
 import { CustomTemplate } from './CustomTemplate'
 import { Execution } from './Execution'
+import { FlowHistory } from './FlowHistory'
 import { LoginActivity, WorkspaceShared, WorkspaceUsers } from '../../enterprise/database/entities/EnterpriseEntities'
 import { User } from '../../enterprise/database/entities/user.entity'
 import { Organization } from '../../enterprise/database/entities/organization.entity'
@@ -50,6 +51,7 @@ export const entities = {
     WorkspaceShared,
     CustomTemplate,
     Execution,
+    FlowHistory,
     Organization,
     Role,
     OrganizationUser,

packages/server/src/database/migrations/mariadb/1750000000000-AddFlowHistoryEntity.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class AddFlowHistoryEntity1750000000000 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(
+            `CREATE TABLE IF NOT EXISTS \`flow_history\` (
+                \`id\` varchar(36) NOT NULL,
+                \`entityType\` varchar(20) NOT NULL,
+                \`entityId\` varchar(36) NOT NULL,
+                \`snapshotData\` longtext NOT NULL,
+                \`changeDescription\` text DEFAULT NULL,
+                \`version\` int NOT NULL,
+                \`createdDate\` datetime(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
+                \`workspaceId\` text DEFAULT NULL,
+                PRIMARY KEY (\`id\`),
+                INDEX \`IDX_flow_history_entity_version\` (\`entityType\`, \`entityId\`, \`version\`),
+                INDEX \`IDX_flow_history_entity_date\` (\`entityType\`, \`entityId\`, \`createdDate\`)
+              ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;`
+        )
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP TABLE flow_history`)
+    }
+}

packages/server/src/database/migrations/mariadb/1750000000001-AddCurrentHistoryVersion.ts

@@ -0,0 +1,11 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class AddCurrentHistoryVersion1750000000001 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`chat_flow\` ADD \`currentHistoryVersion\` int NULL`)
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`chat_flow\` DROP COLUMN \`currentHistoryVersion\``)
+    }
+}

packages/server/src/database/migrations/mariadb/1750000000002-AddAssistantHistoryVersion.ts

@@ -0,0 +1,11 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class AddAssistantHistoryVersion1750000000002 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`assistant\` ADD \`currentHistoryVersion\` int NULL`)
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`assistant\` DROP COLUMN \`currentHistoryVersion\``)
+    }
+}