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

14.6 KB
Raw Blame
import { ActivepiecesError, ApId, apId, assertNotNullOrUndefined, ErrorCode, isNil, Metadata, ProjectId, spreadIfDefined, spreadIfNotUndefined, unique, UserId } from '@activepieces/core-utils'
import { ColorName, Project, ProjectIcon, ProjectType } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { Brackets, EntityManager, IsNull, Not, ObjectLiteral, SelectQueryBuilder } from 'typeorm'
import { system } from '../helper/system/system'
import { AppSystemProp } from '../helper/system/system-props'
import { userService } from '../user/user-service'
import { projectHooks, ProjectPostCreateContext } from './project-hooks'
import { projectRepo } from './project-repo'

export { projectRepo }

export const projectService = (log: FastifyBaseLogger) => ({
    async create(params: CreateParams): Promise<Project> {
        const { callPostCreateHooks = true, entityManager, postCreateContext, ...rest } = params
        const icon = this.createProjectIcon()
        const newProject: NewProject = {
            id: apId(),
            ...rest,
            icon,
            releasesEnabled: false,
            notifyFlowOwnerOnFailure: false,
            sensitive: params.sensitive ?? false,
            isDefault: false,
        }
        const savedProject = await projectRepo(entityManager).save(newProject)
        if (callPostCreateHooks) {
            await this.callProjectPostCreateHooks(savedProject, postCreateContext)
        }
        return savedProject
    },
    async getOneByOwnerAndPlatform(params: GetOneByOwnerAndPlatformParams): Promise<Project | null> {
        return projectRepo().findOneBy({
            ownerId: params.ownerId,
            platformId: params.platformId,
        })
    },

    async getOne(projectId: ProjectId | undefined): Promise<Project | null> {
        if (isNil(projectId)) {
            return null
        }

        return projectRepo().findOneBy({
            id: projectId,
        })
    },

    async getProjectIdsByPlatform(platformId: string): Promise<string[]> {
        const projects = await projectRepo()
            .createQueryBuilder('project')
            .select('project.id')
            .where({ platformId })
            .orderBy('project.type', 'ASC')
            .addOrderBy('project.displayName', 'ASC')
            .addOrderBy('project.id', 'ASC')
            .getMany()

        return projects.map((project) => project.id)
    },

    async countByPlatformIdAndType(platformId: string, type: ProjectType): Promise<number> {
        return projectRepo().countBy({
            platformId,
            type,
        })
    },

    async update(projectId: ProjectId, request: UpdateParams, entityManager?: EntityManager): Promise<Project> {
        const externalId = request.externalId?.trim() !== '' ? request.externalId : undefined
        await assertExternalIdIsUnique(externalId, projectId)
        assertRetentionDaysWithinInstanceBounds(request.executionDataRetentionDays)

        const baseUpdate = {
            ...spreadIfDefined('externalId', externalId),
            ...spreadIfDefined('releasesEnabled', request.releasesEnabled),
            ...spreadIfDefined('notifyFlowOwnerOnFailure', request.notifyFlowOwnerOnFailure),
            ...spreadIfDefined('metadata', request.metadata),
            ...spreadIfDefined('sensitive', request.sensitive),
            ...(request.poolId !== undefined ? { poolId: request.poolId } : {}),
            ...(request.maxConcurrentJobs !== undefined ? { maxConcurrentJobs: request.maxConcurrentJobs } : {}),
            ...spreadIfNotUndefined('executionDataRetentionDays', request.executionDataRetentionDays),
        }

        const teamUpdate = request.type === ProjectType.TEAM ? {
            ...spreadIfDefined('displayName', request.displayName),
            ...spreadIfDefined('icon', request.icon),
            ...spreadIfDefined('isDefault', request.isDefault),
        } : {}

        await projectRepo(entityManager).update({ id: projectId }, { ...baseUpdate, ...teamUpdate })
        return this.getOneOrThrow(projectId)
    },

    async getPlatformId(projectId: ProjectId): Promise<string> {
        const result = await projectRepo().createQueryBuilder('project').withDeleted().select('"platformId"').where({
            id: projectId,
        }).getRawOne()
        const platformId = result?.platformId
        if (isNil(platformId)) {
            throw new Error(`Platform ID for project ${projectId} is undefined in webhook.`)
        }
        return platformId
    },
    async getOneOrThrow(projectId: ProjectId): Promise<Project> {
        const project = await this.getOne(projectId)

        if (isNil(project)) {
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityId: projectId,
                    entityType: 'project',
                },
            })
        }

        return project
    },
    async exists({ projectId, isSoftDeleted }: ExistsParams): Promise<boolean> {
        const project = await projectRepo().findOne({
            where: {
                id: projectId,
                deleted: isSoftDeleted ? Not(IsNull()) : IsNull(),
            },
            withDeleted: true,
        })
        return !isNil(project)
    },
    async getUserProjectOrThrow(userId: UserId): Promise<Project> {
        const user = await userService(log).getOneOrFail({ id: userId })
        assertNotNullOrUndefined(user.platformId, 'platformId is undefined')
        const projects = await this.getAllForUser({
            platformId: user.platformId,
            userId,
            isPrivileged: userService(log).isUserPrivileged(user),
        })
        if (isNil(projects) || projects.length === 0) {
            throw new ActivepiecesError({
                code: ErrorCode.ENTITY_NOT_FOUND,
                params: {
                    entityId: userId,
                    entityType: 'user',
                },
            })
        }
        return projects.find((p) => p.ownerId === userId && p.type === ProjectType.PERSONAL) ?? projects[0]
    },

    async getAllForUser(params: GetAllForUserParams): Promise<Project[]> {
        assertNotNullOrUndefined(params.platformId, 'platformId is undefined')

        const queryBuilder = projectRepo()
            .createQueryBuilder('project')
            .where('project."platformId" = :platformId', { platformId: params.platformId })
            .andWhere('project.deleted IS NULL')
            .orderBy('project.type', 'ASC')
            .addOrderBy('project.displayName', 'ASC')
            .addOrderBy('project.id', 'ASC')

        if (params.displayName) {
            queryBuilder.andWhere('project."displayName" ILIKE :displayName', { displayName: `%${params.displayName}%` })
        }

        await applyProjectsAccessFilters(queryBuilder, params)

        return queryBuilder.getMany()
    },
    async userHasProjects(params: GetAllForUserParams): Promise<boolean> {
        assertNotNullOrUndefined(params.platformId, 'platformId is undefined')

        const queryBuilder = projectRepo()
            .createQueryBuilder('project')
            .where('project."platformId" = :platformId', { platformId: params.platformId })

        await applyProjectsAccessFilters(queryBuilder, params)

        return queryBuilder.getExists()
    },
    async listUserIdsWithProjects({ platformId, userIds }: ListUserIdsWithProjectsParams): Promise<string[]> {
        if (userIds.length === 0) {
            return []
        }
        const [owners, members] = await Promise.all([
            projectRepo()
                .createQueryBuilder('project')
                .select('project."ownerId"', 'userId')
                .where('project."platformId" = :platformId', { platformId })
                .andWhere('project.type = :personalType', { personalType: ProjectType.PERSONAL })
                .andWhere('project."ownerId" IN (:...userIds)', { userIds })
                .getRawMany<{ userId: string }>(),
            projectRepo()
                .createQueryBuilder('project')
                .innerJoin('project_member', 'project_member', 'project_member."projectId" = project.id')
                .select('project_member."userId"', 'userId')
                .where('project."platformId" = :platformId', { platformId })
                .andWhere('project_member."userId" IN (:...userIds)', { userIds })
                .getRawMany<{ userId: string }>(),
        ])
        return unique([...owners, ...members].map((row) => row.userId))
    },
    async listPlatformIdsWhereUsersHaveProjects({ users }: ListPlatformIdsWhereUsersHaveProjectsParams): Promise<string[]> {
        const privilegedPlatformIds = users.filter((user) => user.isPrivileged).map((user) => user.platformId)
        const memberUserIds = users.filter((user) => !user.isPrivileged).map((user) => user.userId)
        if (privilegedPlatformIds.length === 0 && memberUserIds.length === 0) {
            return []
        }
        const rows = await projectRepo()
            .createQueryBuilder('project')
            .select('DISTINCT project."platformId"', 'platformId')
            .where(new Brackets((qb) => {
                if (privilegedPlatformIds.length > 0) {
                    qb.orWhere('project."platformId" IN (:...privilegedPlatformIds)', { privilegedPlatformIds })
                }
                if (memberUserIds.length > 0) {
                    qb.orWhere('(project."ownerId" IN (:...memberUserIds) AND project.type = :personalType)', { memberUserIds, personalType: ProjectType.PERSONAL })
                    qb.orWhere('project.id IN (SELECT "projectId" FROM project_member WHERE "userId" IN (:...memberUserIds))', { memberUserIds })
                }
            }))
            .getRawMany<{ platformId: string }>()
        return rows.map((row) => row.platformId)
    },
    async addProjectToPlatform({ projectId, platformId }: AddProjectToPlatformParams): Promise<void> {
        const query = {
            id: projectId,
        }

        const update = {
            platformId,
        }

        await projectRepo().update(query, update)
    },

    async getByPlatformIdAndExternalId({
        platformId,
        externalId,
    }: GetByPlatformIdAndExternalIdParams): Promise<Project | null> {
        return projectRepo().findOneBy({
            platformId,
            externalId,
        })
    },
    createProjectIcon: ()=>{
        const colors = Object.values(ColorName)
        const icon: ProjectIcon = {
            color: colors[Math.floor(Math.random() * colors.length)],
        }
        return icon
    },
    callProjectPostCreateHooks: async (savedProject: Project, context?: ProjectPostCreateContext)=>{
        await projectHooks.get(log).postCreate(savedProject, context)
    },
})


export async function applyProjectsAccessFilters<T extends ObjectLiteral>(
    queryBuilder: SelectQueryBuilder<T>,
    params: ApplyProjectsAccessFiltersParams,
): Promise<void> {
    const { platformId, userId, isPrivileged } = params
    if (isPrivileged) {
        return
    }

    queryBuilder.andWhere(new Brackets(qb => {
        qb.where(
            'project."ownerId" = :userId AND project.type = :personalType',
            { userId, personalType: ProjectType.PERSONAL },
        ).orWhere(
            'project.id IN (SELECT "projectId" FROM project_member WHERE "userId" = :userId AND "platformId" = :platformId)',
            { userId, platformId },
        )
    }))
}
async function assertExternalIdIsUnique(externalId: string | undefined | null, projectId: ProjectId): Promise<void> {
    if (!isNil(externalId)) {
        const externalIdAlreadyExists = await projectRepo().existsBy({
            id: Not(projectId),
            externalId,
        })

        if (externalIdAlreadyExists) {
            throw new ActivepiecesError({
                code: ErrorCode.PROJECT_EXTERNAL_ID_ALREADY_EXISTS,
                params: {
                    externalId,
                },
            })
        }
    }
}

function assertRetentionDaysWithinInstanceBounds(executionDataRetentionDays: number | null | undefined): void {
    if (isNil(executionDataRetentionDays)) {
        return
    }
    const instanceRetentionDays = system.getNumberOrThrow(AppSystemProp.EXECUTION_DATA_RETENTION_DAYS)
    const pausedFlowTimeoutDays = system.getNumberOrThrow(AppSystemProp.PAUSED_FLOW_TIMEOUT_DAYS)
    if (executionDataRetentionDays < pausedFlowTimeoutDays || executionDataRetentionDays > instanceRetentionDays) {
        throw new ActivepiecesError({
            code: ErrorCode.VALIDATION,
            params: {
                message: `executionDataRetentionDays must be between AP_PAUSED_FLOW_TIMEOUT_DAYS (${pausedFlowTimeoutDays}) and AP_EXECUTION_DATA_RETENTION_DAYS (${instanceRetentionDays})`,
            },
        })
    }
}

type GetAllForUserParams = {
    platformId: string
    userId: string
    isPrivileged: boolean
    displayName?: string
}

type GetOneByOwnerAndPlatformParams = {
    ownerId: UserId
    platformId: string
}

type ExistsParams = {
    projectId: ProjectId
    isSoftDeleted?: boolean
}

type UpdateTeamProjectParams = {
    type: ProjectType.TEAM
    displayName?: string
    externalId?: string
    releasesEnabled?: boolean
    notifyFlowOwnerOnFailure?: boolean
    metadata?: Metadata
    poolId?: string | null
    maxConcurrentJobs?: number | null
    executionDataRetentionDays?: number | null
    icon?: ProjectIcon
    sensitive?: boolean
    isDefault?: boolean
}

type UpdatePersonalProjectParams = {
    type: ProjectType.PERSONAL
    externalId?: string
    releasesEnabled?: boolean
    notifyFlowOwnerOnFailure?: boolean
    metadata?: Metadata
    poolId?: string | null
    maxConcurrentJobs?: number | null
    executionDataRetentionDays?: number | null
    sensitive?: boolean
}

type UpdateParams = UpdateTeamProjectParams | UpdatePersonalProjectParams

type CreateParams = {
    ownerId: UserId
    displayName: string
    type: ProjectType
    platformId: string
    externalId?: string
    metadata?: Metadata
    maxConcurrentJobs?: number
    sensitive?: boolean
    callPostCreateHooks?: boolean
    postCreateContext?: ProjectPostCreateContext
    entityManager?: EntityManager
}

type GetByPlatformIdAndExternalIdParams = {
    platformId: string
    externalId: string
}

type ListPlatformIdsWhereUsersHaveProjectsParams = {
    users: {
        userId: string
        platformId: string
        isPrivileged: boolean
    }[]
}

type ListUserIdsWithProjectsParams = {
    platformId: string
    userIds: UserId[]
}

type AddProjectToPlatformParams = {
    projectId: ProjectId
    platformId: ApId
}

type NewProject = Omit<Project, 'created' | 'updated' | 'deleted'>

type ApplyProjectsAccessFiltersParams = {
    platformId: string
    userId: string
    isPrivileged: boolean
}