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, 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
}