Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

5.5 KB
Raw Blame
import { apId, isNil } from '@activepieces/core-utils'
import { ExecutionType, JobData, ResumeReason, StreamStepProgress, WorkerJobType } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { z } from 'zod'
import { flowVersionService } from '../../flows/flow-version/flow-version.service'

const LegacyExecuteFlowFields = z.object({
    streamStepProgress: z.enum(StreamStepProgress).optional(),
    progressUpdateType: z.string().optional(),
    workerHandlerId: z.string().nullish(),
    synchronousHandlerId: z.string().nullish(),
})

function deriveExecuteFlowMigrationFields(job: JobData): { streamStepProgress: StreamStepProgress, workerHandlerId: string | null } {
    const legacy = LegacyExecuteFlowFields.parse(job)
    return {
        streamStepProgress: legacy.streamStepProgress ?? migrateProgressUpdateType(legacy.progressUpdateType),
        workerHandlerId: legacy.workerHandlerId ?? legacy.synchronousHandlerId ?? null,
    }
}

function createMigrations(log: FastifyBaseLogger): JobMigration[] {
    const enrichFlowId: JobMigration = {
        runAtSchemaVersion: 0,
        migrate: async (job: JobData) => {
            if (job.jobType === WorkerJobType.EXECUTE_FLOW) {
                const flowVersion = await flowVersionService(log).getOne(job.flowVersionId)
                const logsFileId = 'logsFileId' in job ? job.logsFileId : apId()
                return {
                    ...job,
                    flowId: flowVersion!.flowId,
                    schemaVersion: 4,
                    logsFileId,
                }
            }
            return {
                ...job,
                schemaVersion: 4,
            }
        },
    }
    const migratePayloadToUnion: JobMigration = {
        runAtSchemaVersion: 4,
        migrate: async (job: JobData) => {
            if (job.jobType === WorkerJobType.EXECUTE_FLOW || job.jobType === WorkerJobType.EXECUTE_WEBHOOK) {
                return {
                    ...job,
                    schemaVersion: 5,
                    payload: { type: 'inline', value: job.payload },
                }
            }
            return { ...job, schemaVersion: 5 }
        },
    }
    const renameProgressAndHandlerFields: JobMigration = {
        runAtSchemaVersion: 5,
        migrate: async (job: JobData) => {
            if (job.jobType === WorkerJobType.EXECUTE_FLOW) {
                return {
                    ...job,
                    schemaVersion: 6,
                    ...deriveExecuteFlowMigrationFields(job),
                }
            }
            return { ...job, schemaVersion: 6 }
        },
    }
    const dropLogsUploadUrl: JobMigration = {
        runAtSchemaVersion: 6,
        migrate: async (job: JobData) => {
            if (job.jobType !== WorkerJobType.EXECUTE_FLOW) {
                return { ...job, schemaVersion: 7 }
            }
            const legacy = job as Record<string, unknown>
            delete legacy['logsUploadUrl']
            return {
                ...job,
                schemaVersion: 7,
            }
        },
    }
    const backfillRequiredExecuteFlowFields: JobMigration = {
        runAtSchemaVersion: 7,
        migrate: async (job: JobData) => {
            if (job.jobType !== WorkerJobType.EXECUTE_FLOW) {
                return { ...job, schemaVersion: 8 }
            }
            return {
                ...job,
                schemaVersion: 8,
                ...deriveExecuteFlowMigrationFields(job),
            }
        },
    }
    const bridgeV8ToV9: JobMigration = {
        runAtSchemaVersion: 8,
        migrate: async (job: JobData) => ({ ...job, schemaVersion: 9 }),
    }
    const addResumeReason: JobMigration = {
        runAtSchemaVersion: 9,
        migrate: async (job: JobData) => {
            if (job.jobType !== WorkerJobType.EXECUTE_FLOW || job.executionType !== ExecutionType.RESUME) {
                return { ...job, schemaVersion: 10 }
            }
            const isLegacyRetry = job.payload.type === 'inline' && isNil(job.payload.value)
            return {
                ...job,
                schemaVersion: 10,
                resumeReason: isLegacyRetry ? ResumeReason.RETRY : ResumeReason.WAITPOINT,
            }
        },
    }

    return [enrichFlowId, migratePayloadToUnion, renameProgressAndHandlerFields, dropLogsUploadUrl, backfillRequiredExecuteFlowFields, bridgeV8ToV9, addResumeReason]
}

function migrateProgressUpdateType(progressUpdateType: string | undefined): StreamStepProgress {
    if (progressUpdateType === 'TEST_FLOW' || progressUpdateType === 'WEBHOOK_RESPONSE') {
        return StreamStepProgress.WEBSOCKET
    }
    return StreamStepProgress.NONE
}

export const jobMigrations = (log: FastifyBaseLogger) => ({
    apply: async (job: Record<string, unknown>): Promise<JobData> => {
        let jobData = job as JobData
        log.info({
            schemaVersion: jobData.schemaVersion,
            job: { type: jobData.jobType },
            project: { id: jobData.projectId },
        }, '[jobMigrations] Apply migration for job')
        const migrations = createMigrations(log)
        for (const migration of migrations) {
            const schemaVersion = getSchemaVersion(jobData)
            if (schemaVersion === migration.runAtSchemaVersion) {
                jobData = await migration.migrate(jobData)
            }
        }
        return jobData
    },
})

function getSchemaVersion(job: JobData): number {
    return 'schemaVersion' in job ? job.schemaVersion : 0
}


type JobMigration = {
    runAtSchemaVersion: number
    migrate: (job: JobData) => Promise<JobData>
}