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

17.2 KB
Raw Blame
import { ActivepiecesError, apId, Cursor, ErrorCode, isNil, Metadata, PlatformId, ProjectId, SeekPage, spreadIfDefined, UserId } from '@activepieces/core-utils'
import { apDayjs } from '@activepieces/server-utils'
import { AppConnectionScope, PiecesFilterType, PrincipalType, Project, ProjectType, ProjectWithLimits, UpdateProjectPlatformRequest } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { ArrayContains, Equal, ILike, In, IsNull } from 'typeorm'
import { appConnectionsRepo } from '../../app-connection/app-connection-service/app-connection-service'
import { repoFactory } from '../../core/db/repo-factory'
import { transaction } from '../../core/db/transaction'
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 { SystemJobName } from '../../helper/system-jobs/common'
import { systemJobsSchedule } from '../../helper/system-jobs/system-job'
import { mcpGrantRevocation } from '../../mcp/oauth/token/mcp-grant-revocation'
import { platformService } from '../../platform/platform.service'
import { ProjectEntity } from '../../project/project-entity'
import { applyProjectsAccessFilters, projectService } from '../../project/project-service'
import { userService } from '../../user/user-service'
import { concurrencyPoolService } from '../platform/concurrency-pool/concurrency-pool.service'
import { platformPlanService } from '../platform/platform-plan/platform-plan.service'
import { projectMemberService } from './project-members/project-member.service'
import { ProjectPlanEntity } from './project-plan/project-plan.entity'
import { projectLimitsService } from './project-plan/project-plan.service'
const projectRepo = repoFactory(ProjectEntity)
const projectPlanRepo = repoFactory(ProjectPlanEntity)

export const platformProjectService = (log: FastifyBaseLogger) => ({
    async getForPlatform(params: GetAllForParamsAndUser): Promise<SeekPage<ProjectWithLimits>> {
        const { cursorRequest, limit, platformId, displayName, externalId, externalUserId, userId, types, isPrivileged, principalType } = params
        const accessFilterUser = await resolveAccessFilterUser({ platformId, externalUserId, callerUserId: userId, callerIsPrivileged: isPrivileged, principalType, log })
        if (isNil(accessFilterUser)) {
            return paginationHelper.createPage<ProjectWithLimits>([], null)
        }

        const decodedCursor = paginationHelper.decodeCursor(cursorRequest)
        const paginator = buildPaginator({
            entity: ProjectEntity,
            query: {
                limit,
                afterCursor: decodedCursor.nextCursor,
                beforeCursor: decodedCursor.previousCursor,
                orderBy: [
                    { field: 'type', order: Order.ASC },
                    { field: 'displayName', order: Order.ASC },
                    { field: 'id', order: Order.ASC },
                ],
            },
        })

        const filters = {
            platformId: Equal(platformId),
            ...spreadIfDefined('displayName', displayName ? ILike(`%${displayName}%`) : undefined),
            ...spreadIfDefined('externalId', externalId),
            ...(types && types.length > 0 ? { type: In(types) } : {}),
            deleted: IsNull(),
        }

        const queryBuilder = projectRepo()
            .createQueryBuilder('project')
            .where(filters)

        await applyProjectsAccessFilters(queryBuilder, {
            platformId,
            ...accessFilterUser,
        })

        const { data, cursor } = await paginator.paginate(queryBuilder)
        const projects: ProjectWithLimits[] = await enrichProjects(data, log)
        return paginationHelper.createPage<ProjectWithLimits>(projects, cursor)
    },
    async create(params: CreateProjectParams): Promise<ProjectWithLimits> {
        const platformPlan = await platformPlanService(log).getOrCreateForPlatform(params.platformId)
        const platform = await platformService(log).getOneOrThrow(params.platformId)
        const project = await transaction(async (entityManager) => {
            const savedProject = await projectService(log).create({
                ownerId: platform.ownerId,
                displayName: params.displayName,
                platformId: params.platformId,
                externalId: params.externalId,
                metadata: params.metadata,
                maxConcurrentJobs: params.maxConcurrentJobs,
                sensitive: params.sensitive,
                type: ProjectType.TEAM,
                callPostCreateHooks: false,
                entityManager,
            })

            await projectPlanRepo(entityManager).upsert({
                id: apId(),
                projectId: savedProject.id,
                pieces: [],
                piecesFilterType: PiecesFilterType.NONE,
                locked: false,
                name: 'platform',
            }, ['projectId'])

            if (platformPlan.globalConnectionsEnabled) {
                const connectionExternalIds = params.globalConnectionExternalIds ?? []
                if (connectionExternalIds.length > 0) {
                    await appConnectionsRepo(entityManager)
                        .createQueryBuilder()
                        .update()
                        .set({
                            projectIds: () => 'array_append("projectIds", :projectId)',
                        })
                        .where({
                            externalId: In(connectionExternalIds),
                            platformId: params.platformId,
                            scope: AppConnectionScope.PLATFORM,
                        })
                        .andWhere('NOT ("projectIds" @> ARRAY[:projectId]::varchar[])')
                        .setParameter('projectId', savedProject.id)
                        .execute()
                }
            }
            return savedProject
        })

        await projectService(log).callProjectPostCreateHooks(project, {
            alertReceiverEmail: params.alertReceiverEmail,
        })

        return this.getWithPlanAndUsageOrThrow(project.id)
    },
    async update({
        projectId,
        request,
    }: UpdateParams): Promise<ProjectWithLimits> {
        const project = await projectService(log).getOneOrThrow(projectId)
        const platformPlan = await platformPlanService(log).getOrCreateForPlatform(project.platformId)
        const { globalConnectionExternalIds, maxConcurrentJobs, ...rest } = request
        let resolvedPoolId: string | null | undefined
        await transaction(async (entityManager) => {
            resolvedPoolId = await resolvePoolId({ platformId: project.platformId, projectId, maxConcurrentJobs, log })
            await projectService(log).update(projectId, {
                type: project.type,
                ...rest,
                ...(resolvedPoolId !== undefined ? { poolId: resolvedPoolId } : {}),
                ...(maxConcurrentJobs !== undefined ? { maxConcurrentJobs } : {}),
            }, entityManager)
            if (platformPlan.globalConnectionsEnabled && globalConnectionExternalIds) {
                const projectGlobalConnections = await appConnectionsRepo(entityManager).find({
                    where: {
                        projectIds: ArrayContains([projectId]),
                        scope: AppConnectionScope.PLATFORM,
                    },
                })
                const existingGlobalConnectionExternalIds = projectGlobalConnections.map(connection => connection.externalId)
                const globalConnectionsToAddProjectTo = globalConnectionExternalIds.filter(externalId => !existingGlobalConnectionExternalIds.includes(externalId)) ?? []
                const globalConnectionsToRemoveProjectFrom = existingGlobalConnectionExternalIds.filter(externalId => !globalConnectionExternalIds?.includes(externalId)) ?? []
                if (globalConnectionsToAddProjectTo.length > 0) {
                    await appConnectionsRepo(entityManager).createQueryBuilder()
                        .update()
                        .set({
                            projectIds: () => 'array_append("projectIds", :projectId)',
                        })
                        .where({
                            platformId: project.platformId,
                            externalId: In(globalConnectionsToAddProjectTo),
                            scope: AppConnectionScope.PLATFORM,
                        })
                        .andWhere('NOT ("projectIds" @> ARRAY[:projectId]::varchar[])')
                        .setParameter('projectId', projectId)
                        .execute()
                }
                if (globalConnectionsToRemoveProjectFrom.length > 0) {
                    await appConnectionsRepo(entityManager).createQueryBuilder()
                        .update()
                        .set({
                            projectIds: () => 'array_remove("projectIds", :projectId)',
                        })
                        .where({
                            platformId: project.platformId,
                            externalId: In(globalConnectionsToRemoveProjectFrom),
                            scope: AppConnectionScope.PLATFORM,
                        })
                        .andWhere('("projectIds" @> ARRAY[:projectId]::varchar[])')
                        .setParameter('projectId', projectId)
                        .execute()
                }
            }
            if (!isNil(request.plan) && request.plan.activeFlowsLimit !== undefined) {
                const platform = await platformService(log).getOneWithPlanOrThrow(project.platformId)
                if (platform.plan.billedTeamProjectsLimit !== 0) {
                    await projectLimitsService(log).updateActiveFlowsLimit({
                        projectId,
                        activeFlowsLimit: request.plan.activeFlowsLimit,
                        entityManager,
                    })
                }
            }
        })
        if (resolvedPoolId !== undefined) {
            await concurrencyPoolService(log).assignProject({ projectId, poolId: resolvedPoolId })
        }
        return this.getWithPlanAndUsageOrThrow(projectId)
    },
    async getWithPlanAndUsageOrThrow(
        projectId: string,
    ): Promise<ProjectWithLimits> {
        const project = await projectRepo().findOneByOrFail({
            id: projectId,
        })
        return (await enrichProjects([project], log))[0]
    },
    async deletePersonalProjectForUser({ userId, platformId }: DeletePersonalProjectForUserParams): Promise<void> {
        const personalProject = await projectRepo().findOneBy({
            platformId,
            ownerId: userId,
            type: ProjectType.PERSONAL,
        })
        if (isNil(personalProject)) {
            return
        }
        
        const platform = await platformService(log).getOneOrThrow(platformId)
        await transaction(async (entityManager) => {
            await projectRepo(entityManager).update({ id: personalProject.id, platformId }, { ownerId: platform.ownerId })
            await projectRepo(entityManager).softDelete({ id: personalProject.id, platformId })
        })
        await scheduleHardDeleteProjectJob({ id: personalProject.id, platformId, log })
        await mcpGrantRevocation.revokeActiveGrants({ scope: { projectId: personalProject.id, platformId }, log })
    },

    async markForDeletion({ id, platformId, enforceDefaultGuard = false }: DeleteProjectParams): Promise<void> {
        const query = projectRepo()
            .createQueryBuilder()
            .softDelete()
            .where('"id" = :id AND "platformId" = :platformId', { id, platformId })
        if (enforceDefaultGuard) {
            query.andWhere('"isDefault" = false')
        }
        const result = await query.returning('id').execute()
        const deletedRows: unknown[] = result.raw ?? []
        if (deletedRows.length === 0) {
            if (enforceDefaultGuard && await projectRepo().existsBy({ id, platformId, isDefault: true })) {
                throw new ActivepiecesError({
                    code: ErrorCode.VALIDATION,
                    params: {
                        message: 'Remove this project from default projects before deleting it',
                    },
                })
            }
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityType: 'project',
                    entityId: id,
                },
            })
        }
        await scheduleHardDeleteProjectJob({ id, platformId, log })
        await mcpGrantRevocation.revokeActiveGrants({ scope: { projectId: id, platformId }, log })
    },
})

async function scheduleHardDeleteProjectJob({ id, platformId, log }: ScheduleHardDeleteProjectJobParams): Promise<void> {
    await systemJobsSchedule(log).upsertJob({
        job: {
            name: SystemJobName.HARD_DELETE_PROJECT,
            data: {
                projectId: id,
                platformId,
                preDeletedFlowIds: [],
            },
            jobId: `hard-delete-project-${id}`,
        },
        schedule: {
            type: 'one-time',
            date: apDayjs(),
        },
        customConfig: {
            attempts: 25,
            backoff: {
                type: 'fixed',
                delay: 60000,
            },
        },
    })
}

async function enrichProjects(
    projects: Project[],
    log: FastifyBaseLogger,
): Promise<ProjectWithLimits[]> {
    if (projects.length === 0) return []
    
    const projectIds = projects.map(p => p.id)
    
    const [totalUsersMap, activeUsersMap, totalFlowsMap, activeFlowsMap, lastFlowUpdatedMap, plansMap] = await Promise.all([
        projectMemberService(log).countTotalUsersByProjects(projectIds),
        projectMemberService(log).countActiveUsersByProjects(projectIds),
        flowService(log).countFlowsByProjects(projectIds),
        flowService(log).countActiveFlowsByProjects(projectIds),
        flowService(log).getLastFlowUpdatedByProjects(projectIds),
        projectLimitsService(log).getOrCreateDefaultPlansForProjects(projectIds),
    ])

    return projects.map(project => {
        return {
            ...project,
            plan: plansMap.get(project.id)!,
            analytics: {
                activeFlows: activeFlowsMap.get(project.id) ?? 0,
                totalFlows: totalFlowsMap.get(project.id) ?? 0,
                totalUsers: totalUsersMap.get(project.id) ?? 0,
                activeUsers: activeUsersMap.get(project.id) ?? 0,
                lastFlowUpdated: lastFlowUpdatedMap.get(project.id) ?? null,
            },
        }
    })
}

async function resolveAccessFilterUser({ platformId, externalUserId, callerUserId, callerIsPrivileged, principalType, log }: ResolveAccessFilterUserParams): Promise<AccessFilterUser | null> {
    if (isNil(externalUserId)) {
        return { userId: callerUserId, isPrivileged: callerIsPrivileged }
    }
    if (principalType !== PrincipalType.SERVICE) {
        throw new ActivepiecesError({
            code: ErrorCode.AUTHORIZATION,
            params: {},
        })
    }
    const user = await userService(log).getByPlatformAndExternalId({ platformId, externalId: externalUserId })
    if (isNil(user)) {
        return null
    }
    return { userId: user.id, isPrivileged: false }
}

async function resolvePoolId({ platformId, projectId, maxConcurrentJobs, log }: ResolvePoolIdParams): Promise<string | null | undefined> {
    if (typeof maxConcurrentJobs === 'number') {
        const { poolId } = await concurrencyPoolService(log).upsertPool({
            platformId,
            key: projectId,
            maxConcurrentJobs,
        })
        return poolId
    }
    if (maxConcurrentJobs === null) {
        return null
    }
    return undefined
}

type ResolvePoolIdParams = {
    platformId: string
    projectId: string
    maxConcurrentJobs: number | null | undefined
    log: FastifyBaseLogger
}

type AccessFilterUser = {
    userId: string
    isPrivileged: boolean
}

type ResolveAccessFilterUserParams = {
    platformId: string
    externalUserId: string | undefined
    callerUserId: string
    callerIsPrivileged: boolean
    principalType?: PrincipalType
    log: FastifyBaseLogger
}

type GetAllForParamsAndUser = {
    userId: string
    platformId: string
    displayName?: string
    externalId?: string
    externalUserId?: string
    cursorRequest: Cursor | null
    limit: number
    types?: ProjectType[]
    isPrivileged: boolean
    principalType?: PrincipalType
}

type DeletePersonalProjectForUserParams = {
    userId: UserId
    platformId: PlatformId
}

type UpdateParams = {
    projectId: ProjectId
    request: UpdateProjectPlatformRequest
    platformId?: PlatformId
}

type CreateProjectParams = {
    platformId: string
    displayName: string
    externalId?: string
    metadata?: Metadata
    maxConcurrentJobs?: number
    globalConnectionExternalIds?: string[]
    alertReceiverEmail?: string | null
    sensitive?: boolean
}

type DeleteProjectParams = {
    id: ProjectId
    platformId: PlatformId
    enforceDefaultGuard?: boolean
}

type ScheduleHardDeleteProjectJobParams = {
    id: ProjectId
    platformId: PlatformId
    log: FastifyBaseLogger
}