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, ErrorCode, isNil, PlatformId, ProjectId, SeekPage } from '@activepieces/core-utils'
import { memoryLock } from '@activepieces/server-utils'
import { CreateProjectReleaseRequestBody, DiffReleaseRequest, DiffState, FlowProjectOperation, FlowProjectOperationType, FlowSyncError, ListProjectReleasesRequest, ProjectRelease, ProjectReleaseType, ProjectState, ProjectSyncPlan } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { repoFactory } from '../../../core/db/repo-factory'
import { buildPaginator } from '../../../helper/pagination/build-paginator'
import { paginationHelper } from '../../../helper/pagination/pagination-utils'
import { projectService } from '../../../project/project-service'
import { userService } from '../../../user/user-service'
import { gitRepoService } from './git-sync/git-sync.service'
import { ProjectReleaseEntity } from './project-release.entity'
import { projectDiffService } from './project-state/project-diff.service'
import { projectStateService } from './project-state/project-state.service'
const projectReleaseRepo = repoFactory(ProjectReleaseEntity)
export const projectReleaseService = {
async create(request: CreateProjectReleaseParams): Promise<ProjectRelease> {
const { platformId, projectId, ownerId, params, log } = request
const lockKey = `project-release:${params.projectId}`
const lock = await memoryLock.acquire(lockKey)
try {
const diffs = await findDiffStates({ projectId, userId: ownerId, platformId, params, log })
const flowIdsToApply = params.selectedFlowsIds ?? diffs.flows.map((flow) => flow.flowState.id)
const filteredDiffs = await projectDiffService.filterFlows(flowIdsToApply, diffs)
await projectStateService(log).apply({
projectId,
diffs: filteredDiffs,
log,
platformId,
})
const fileId = await projectStateService(log).save(projectId, params.name, log)
const projectRelease: ProjectRelease = {
id: apId(),
created: new Date().toISOString(),
updated: new Date().toISOString(),
projectId,
importedBy: ownerId,
fileId,
name: params.name,
description: params.description,
type: params.type,
}
return await projectReleaseRepo().save(projectRelease)
}
finally {
await lock.release()
}
},
async releasePlan({ projectId, userId, platformId, params, log }: ReleasePlanParams): Promise<ProjectSyncPlan> {
const diffs = await findDiffStates({ projectId, userId, platformId, params, log })
return toResponse({
diffs,
errors: [],
})
},
async list({ projectId, request, log }: ListParams): Promise<SeekPage<ProjectRelease>> {
const decodedCursor = paginationHelper.decodeCursor(request.cursor ?? null)
const paginator = buildPaginator({
entity: ProjectReleaseEntity,
query: {
limit: request.limit ?? 10,
order: 'DESC',
afterCursor: decodedCursor.nextCursor,
beforeCursor: decodedCursor.previousCursor,
},
})
const { data, cursor } = await paginator.paginate(projectReleaseRepo()
.createQueryBuilder('project_release')
.where({
projectId,
})
.orderBy('created', 'DESC'))
const enrichedData = await Promise.all(data.map(
async (projectRelease) => this.enrich(projectRelease, log),
))
return paginationHelper.createPage<ProjectRelease>(enrichedData, cursor)
},
async enrich(projectRelease: ProjectRelease, log: FastifyBaseLogger): Promise<ProjectRelease> {
return {
...projectRelease,
importedByUser: isNil(projectRelease.importedBy) ? undefined : await userService(log).getMetaInformation({
id: projectRelease.importedBy,
}) ?? undefined,
}
},
async getOneOrThrow(params: GetOneProjectReleaseParams): Promise<ProjectRelease> {
const projectRelease = await projectReleaseRepo().findOneBy({
id: params.id,
projectId: params.projectId,
})
if (isNil(projectRelease)) {
throw new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: {
entityId: params.id,
},
})
}
return projectRelease
},
}
async function findDiffStates({ projectId, userId, platformId, params, log }: FindDiffStatesParams): Promise<DiffState> {
const [newState, currentState] = await Promise.all([
getStateFromCreateRequest({ projectId, userId, platformId, params, log }),
projectStateService(log).getProjectState(projectId, log),
])
const diffs = await projectDiffService.diff({
newState,
currentState,
})
return diffs
}
async function toResponse(params: toResponseParams): Promise<ProjectSyncPlan> {
const { diffs, errors } = params
const { flows, connections, tables } = diffs
const responsePlans: FlowProjectOperation[] = flows.map((operation) => {
switch (operation.type) {
case FlowProjectOperationType.DELETE_FLOW:
return {
type: operation.type,
flow: {
id: operation.flowState.id,
displayName: operation.flowState.version.displayName,
},
}
case FlowProjectOperationType.CREATE_FLOW:
return {
type: operation.type,
flow: {
id: operation.flowState.id,
displayName: operation.flowState.version.displayName,
},
}
case FlowProjectOperationType.UPDATE_FLOW:
return {
type: operation.type,
flow: {
id: operation.flowState.id,
displayName: operation.newFlowState.version.displayName,
},
targetFlow: {
id: operation.newFlowState.id,
displayName: operation.flowState.version.displayName,
},
}
}
})
return {
errors,
flows: responsePlans,
connections,
tables,
}
}
async function getStateFromCreateRequest({ projectId, userId, platformId, params, log }: GetStateFromCreateRequestParams): Promise<ProjectState> {
switch (params.type) {
case ProjectReleaseType.GIT: {
const gitRepo = await gitRepoService(log).getOneByProjectOrThrow({ projectId })
return gitRepoService(log).getState({ gitRepo, userId, log })
}
case ProjectReleaseType.PROJECT: {
await assertTargetProjectOwnedByPlatform({ targetProjectId: params.targetProjectId, platformId, log })
return projectStateService(log).getProjectState(params.targetProjectId, log)
}
case ProjectReleaseType.ROLLBACK: {
const projectRelease = await projectReleaseService.getOneOrThrow({
id: params.projectReleaseId,
projectId,
})
return projectStateService(log).getStateFromRelease(projectId, projectRelease.fileId, log)
}
}
}
async function assertTargetProjectOwnedByPlatform({ targetProjectId, platformId, log }: { targetProjectId: string, platformId: PlatformId, log: FastifyBaseLogger }): Promise<void> {
const targetProject = await projectService(log).getOne(targetProjectId)
if (isNil(targetProject) || targetProject.platformId !== platformId) {
throw new ActivepiecesError({
code: ErrorCode.AUTHORIZATION,
params: {
message: 'Target project does not belong to the current platform',
},
})
}
}
type CreateProjectReleaseParams = {
platformId: PlatformId
projectId: ProjectId
ownerId: ApId
params: CreateProjectReleaseRequestBody
log: FastifyBaseLogger
}
type toResponseParams = {
diffs: DiffState
errors: FlowSyncError[]
}
type ListParams = {
projectId: ProjectId
request: ListProjectReleasesRequest
log: FastifyBaseLogger
}
type ReleasePlanParams = {
projectId: ProjectId
userId: ApId
platformId: PlatformId
params: DiffReleaseRequest | CreateProjectReleaseRequestBody
log: FastifyBaseLogger
}
type FindDiffStatesParams = {
projectId: ProjectId
userId: ApId
platformId: PlatformId
params: DiffReleaseRequest | CreateProjectReleaseRequestBody
log: FastifyBaseLogger
}
type GetStateFromCreateRequestParams = {
projectId: ProjectId
userId: ApId
platformId: PlatformId
params: DiffReleaseRequest | CreateProjectReleaseRequestBody
log: FastifyBaseLogger
}
type GetOneProjectReleaseParams = {
id: ApId
projectId: ProjectId
}