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

6.6 KB
Raw Blame
import { ActivepiecesError, apId, Cursor, ErrorCode, FlowId, isNil, ProjectId, SeekPage } from '@activepieces/core-utils'
import { EngineResponse, EngineResponseStatus, ExecuteTriggerResponse, FileCompression, FileType, FlowTrigger, FlowTriggerType, getPieceMajorAndMinorVersion, PieceTrigger, PopulatedFlow, TriggerEventWithPayload, TriggerHookType, WorkerJobType } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { repoFactory } from '../../core/db/repo-factory'
import { fileService } from '../../file/file.service'
import { flowService } from '../../flows/flow/flow.service'
import { buildPaginator } from '../../helper/pagination/build-paginator'
import { paginationHelper } from '../../helper/pagination/pagination-utils'
import { Order } from '../../helper/pagination/paginator'
import { system } from '../../helper/system/system'
import { AppSystemProp } from '../../helper/system/system-props'
import { projectService } from '../../project/project-service'
import { userInteractionWatcher } from '../../workers/user-interaction-watcher'
import { TriggerEventEntity } from './trigger-event.entity'

export const triggerEventRepo = repoFactory(TriggerEventEntity)

export const triggerEventService = (log: FastifyBaseLogger) => ({
    async saveEvent({
        projectId,
        flowId,
        payload,
    }: SaveEventParams): Promise<TriggerEventWithPayload> {
        const flow = await flowService(log).getOnePopulatedOrThrow({
            id: flowId,
            projectId,
        })

        const data = Buffer.from(JSON.stringify(payload))
        const file = await fileService(log).save({
            projectId,
            fileName: `${apId()}.json`,
            data,
            size: data.length,
            type: FileType.TRIGGER_EVENT_FILE,
            compression: FileCompression.NONE,
        })
        const sourceName = getSourceName(flow.version.trigger)

        const trigger = await triggerEventRepo().save({
            id: apId(),
            fileId: file.id,
            projectId,
            flowId: flow.id,
            sourceName,
        })
        return {
            ...trigger,
            payload,
        }
    },

    async test({
        projectId,
        flow,
    }: TestParams): Promise<SeekPage<TriggerEventWithPayload>> {
        const trigger = flow.version.trigger
        const platformId = await projectService(log).getPlatformId(projectId)
        const emptyPage = paginationHelper.createPage<TriggerEventWithPayload>([], null)
        switch (trigger.type) {
            case FlowTriggerType.PIECE: {

                const engineResponse = await userInteractionWatcher.submitAndWaitForResponse<EngineResponse<ExecuteTriggerResponse<TriggerHookType.TEST>>>({
                    hookType: TriggerHookType.TEST,
                    flowId: flow.id,
                    flowVersionId: flow.version.id,
                    test: true,
                    projectId,
                    jobType: WorkerJobType.EXECUTE_TRIGGER_HOOK,
                    platformId,
                }, log)
                if (engineResponse.status !== EngineResponseStatus.OK || isNil(engineResponse.response)) {
                    throw new ActivepiecesError({
                        code: ErrorCode.TEST_TRIGGER_FAILED,
                        params: {
                            message: engineResponse.error ?? (engineResponse.status === EngineResponseStatus.TIMEOUT
                                ? `The trigger timed out after ${system.getNumberOrThrow(AppSystemProp.TRIGGER_HOOKS_TIMEOUT_SECONDS)} seconds without responding`
                                : 'The worker skipped the trigger test hook'),
                        },
                    })
                }
                await triggerEventRepo().delete({
                    projectId,
                    flowId: flow.id,
                })

                for (const output of engineResponse.response.output) {
                    await this.saveEvent({
                        projectId,
                        flowId: flow.id,
                        payload: output,
                    })
                }

                return this.list({
                    projectId,
                    flow,
                    cursor: null,
                    limit: engineResponse.response.output.length,
                })
            }
            case FlowTriggerType.EMPTY:
                return emptyPage
        }
    },

    async list({
        projectId,
        flow,
        cursor,
        limit,
    }: ListParams): Promise<SeekPage<TriggerEventWithPayload>> {
        const decodedCursor = paginationHelper.decodeCursor(cursor)
        const sourceName = getSourceName(flow.version.trigger)
        const flowId = flow.id
        const paginator = buildPaginator({
            entity: TriggerEventEntity,
            query: {
                limit,
                order: Order.DESC,
                afterCursor: decodedCursor.nextCursor,
                beforeCursor: decodedCursor.previousCursor,
            },
        })
        const query = triggerEventRepo().createQueryBuilder('trigger_event').where({
            projectId,
            flowId,
            sourceName,
        })
        const { data, cursor: newCursor } = await paginator.paginate(query)
        const dataWithPayload = await Promise.all(data.map(async (triggerEvent) => {
            const fileData = await fileService(log).getDataOrThrow({
                fileId: triggerEvent.fileId,
            })
            const decodedPayload = JSON.parse(fileData.data.toString())
            return {
                ...triggerEvent,
                payload: decodedPayload,
            }
        }))
        return paginationHelper.createPage<TriggerEventWithPayload>(dataWithPayload, newCursor)
    },
})

function getSourceName(trigger: FlowTrigger): string {
    switch (trigger.type) {
        case FlowTriggerType.PIECE: {
            const pieceTrigger = trigger as PieceTrigger
            const pieceName = pieceTrigger.settings.pieceName
            const pieceVersion = getPieceMajorAndMinorVersion(
                pieceTrigger.settings.pieceVersion,
            )
            const triggerName = pieceTrigger.settings.triggerName
            return `${pieceName}@${pieceVersion}:${triggerName}`
        }

        case FlowTriggerType.EMPTY:
            return trigger.type
    }
}

type TestParams = {
    projectId: ProjectId
    flow: PopulatedFlow
}

type SaveEventParams = {
    projectId: ProjectId
    flowId: FlowId
    payload: unknown
}

type ListParams = {
    projectId: ProjectId
    flow: PopulatedFlow
    cursor: Cursor | null
    limit: number
}