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

8.3 KB
Raw Blame
import { ActivepiecesError, apId, ErrorCode, isNil, SeekPage } from '@activepieces/core-utils'
import { ApEdition, ConfigureRepoRequest, GitBranchType, GitPushOperationType, GitRepo, ProjectState, PushGitRepoRequest } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { repoFactory } from '../../../../core/db/repo-factory'
import { paginationHelper } from '../../../../helper/pagination/pagination-utils'
import { system } from '../../../../helper/system/system'
import { projectStateService } from '../project-state/project-state.service'
import { gitHelper } from './git-helper'
import { gitSyncHandler } from './git-sync-handler'
import { gitSyncHelper } from './git-sync-helper'
import { GitRepoEntity } from './git-sync.entity'

const repo = repoFactory(GitRepoEntity)

export const gitRepoService = (log: FastifyBaseLogger) => ({
    async upsert(request: ConfigureRepoRequest): Promise<GitRepo> {
        await gitHelper.validateConnection({ request, log })

        const existingRepo = await repo().findOneBy({ projectId: request.projectId })
        const id = existingRepo?.id ?? apId()
        await repo().upsert(
            {
                id,
                projectId: request.projectId,
                sshPrivateKey: request.sshPrivateKey,
                branch: request.branch,
                branchType: request.branchType,
                remoteUrl: request.remoteUrl,
                slug: request.slug,
            },
            ['projectId'],
        )
        return repo().findOneByOrFail({ id })
    },
    async getOneByProjectOrThrow({ projectId }: { projectId: string }): Promise<GitRepo> {
        const gitRepo = await repo().findOneBy({ projectId })
        if (isNil(gitRepo)) {
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityType: 'git-repo',
                },
            })
        }
        return gitRepo
    },
    async getOrThrow({ id }: { id: string }): Promise<GitRepo> {
        const gitRepo = await repo().findOneByOrFail({ id })
        if (isNil(gitRepo)) {
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityId: id,
                    entityType: 'git-repo',
                },
            })
        }
        return gitRepo
    },
    async list({ projectId }: { projectId: string }): Promise<SeekPage<GitRepo>> {
        const repos = await repo().findBy({ projectId })
        return paginationHelper.createPage<GitRepo>(repos, null)
    },
    async onDeleted({ type, externalId, userId, projectId, platformId, log }: { type: GitPushOperationType, externalId: string, userId: string, projectId: string, platformId: string, log: FastifyBaseLogger }): Promise<void> {
        const edition = system.getEdition()
        if (![ApEdition.CLOUD, ApEdition.ENTERPRISE].includes(edition)) {
            return
        }
        const gitRepo = await repo().findOneBy({ projectId })
        if (isNil(gitRepo) || gitRepo.branchType === GitBranchType.PRODUCTION) {
            return
        }
        switch (type) {
            case GitPushOperationType.DELETE_FLOW: {
                await gitRepoService(log).push({
                    id: gitRepo.id,
                    platformId,
                    userId,
                    request: {
                        type: GitPushOperationType.DELETE_FLOW,
                        commitMessage: `chore: deleted flow ${externalId}`,
                        externalFlowIds: [externalId],
                    },
                    log,
                })
                break
            }
            case GitPushOperationType.DELETE_TABLE: {
                await gitRepoService(log).push({
                    id: gitRepo.id,
                    platformId,
                    userId,
                    request: {
                        type: GitPushOperationType.DELETE_TABLE,
                        commitMessage: `chore: deleted table ${externalId}`,
                        externalTableIds: [externalId],
                    },
                    log,
                })
                break
            }
            default:
                throw new ActivepiecesError({
                    code: ErrorCode.VALIDATION,
                    params: {
                        message: `Only supported operations are ${GitPushOperationType.DELETE_FLOW} and ${GitPushOperationType.DELETE_TABLE}`,
                    },
                })
        }
    },
    async push({ id, platformId, userId, request, log }: PushParams): Promise<void> {

        switch (request.type) {
            case GitPushOperationType.PUSH_EVERYTHING: {
                const gitRepo = await gitRepoService(log).getOrThrow({ id })
                const projectState = await projectStateService(log).getProjectState(gitRepo.projectId, log)
                const operations: PushGitRepoRequest[] = []
                if (!isNil(projectState.flows)) {
                    operations.push({
                        type: GitPushOperationType.PUSH_FLOW,
                        commitMessage: request.commitMessage ?? `chore: push all flows ${projectState.flows.map((flow) => flow.version.displayName).join(', ')}`,
                        externalFlowIds: projectState.flows.map((flow) => flow.externalId),
                    })
                }
                if (!isNil(projectState.tables)) {
                    operations.push({
                        type: GitPushOperationType.PUSH_TABLE,
                        commitMessage: request.commitMessage ?? `chore: push all tables ${projectState.tables.map((table) => table.name).join(', ')}`,
                        externalTableIds: projectState.tables.map((table) => table.externalId),
                    })
                }
                for (const operation of operations) {
                    await gitRepoService(log).push({
                        id,
                        platformId,
                        userId,
                        request: operation,
                        log,
                    })
                }
                break
            }
            case GitPushOperationType.PUSH_FLOW: {
                await gitSyncHandler(log).flows.push({
                    id,
                    platformId,
                    userId,
                    request,
                })
                break
            }
            case GitPushOperationType.DELETE_FLOW: {
                await gitSyncHandler(log).flows.delete({
                    id,
                    platformId,
                    userId,
                    request,
                })
                break
            }
            case GitPushOperationType.PUSH_TABLE: {
                await gitSyncHandler(log).tables.push({
                    id,
                    userId,
                    request,
                })
                break
            }
            case GitPushOperationType.DELETE_TABLE: {
                await gitSyncHandler(log).tables.delete({
                    id,
                    userId,
                    request,
                })
                break
            }
        }
    },
    async getState({ gitRepo, userId, log }: PullGitRepoRequest): Promise<ProjectState> {
        const { flowFolderPath, connectionsFolderPath, tablesFolderPath } = await gitHelper.createGitRepoAndReturnPaths(log, gitRepo, userId)
        return gitSyncHelper(log).getStateFromGit({
            flowPath: flowFolderPath,
            connectionsFolderPath,
            tablesFolderPath,
        })
    },
    async delete({ id, projectId }: DeleteParams): Promise<void> {
        const gitRepo = await repo().findOneBy({ id, projectId })
        if (isNil(gitRepo)) {
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityId: id,
                    entityType: 'git-repo',
                },
            })
        }
        await repo().delete({ id, projectId })
    },
})

type PushParams = {
    id: string
    platformId: string
    userId: string
    request: PushGitRepoRequest
    log: FastifyBaseLogger
}
type DeleteParams = {
    id: string
    projectId: string
}
type PullGitRepoRequest = {
    gitRepo: GitRepo
    userId: string
    log: FastifyBaseLogger
}