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
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
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
}