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, ProjectId, SeekPage } from '@activepieces/core-utils'
import { CreateFolderRequest, Folder, FolderDto, FolderId, UpdateFolderRequest } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { repoFactory } from '../../core/db/repo-factory'
import { distributedLock } from '../../database/redis-connections'
import { buildPaginator } from '../../helper/pagination/build-paginator'
import { paginationHelper } from '../../helper/pagination/pagination-utils'
import { tableService } from '../../tables/table/table.service'
import { flowService } from '../flow/flow.service'
import { FolderEntity } from './folder.entity'
export const folderRepo = repoFactory(FolderEntity)
export const flowFolderService = (log: FastifyBaseLogger) => ({
async delete(params: DeleteParams): Promise<void> {
const { projectId, folderId } = params
const folder = await this.getOneOrThrow({ projectId, folderId })
await folderRepo().delete({
id: folder.id,
projectId,
})
},
async update(params: UpdateParams): Promise<FolderDto> {
const { projectId, folderId, request } = params
const folder = await this.getOneOrThrow({ projectId, folderId })
const folderWithDisplayName = await this.getOneByDisplayNameCaseInsensitive({
projectId,
displayName: request.displayName,
})
if (folderWithDisplayName && folderWithDisplayName.id !== folderId) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'Folder displayName is used' },
})
}
await folderRepo().update(folder.id, {
displayName: request.displayName,
})
return this.getOneOrThrow({ projectId, folderId })
},
async upsert(params: UpsertParams): Promise<FolderDto> {
const { projectId, request } = params
const existingFolder = await this.getOneByDisplayNameCaseInsensitive({ projectId, displayName: request.displayName })
if (!isNil(existingFolder)) {
return this.getOneOrThrow({ projectId, folderId: existingFolder.id })
}
return distributedLock(log).runExclusive({
key: folderUpsertLockKey({ projectId, displayName: request.displayName }),
timeoutInSeconds: FOLDER_UPSERT_LOCK_TIMEOUT_SECONDS,
fn: async () => {
const folderWithDisplayName = await this.getOneByDisplayNameCaseInsensitive({
projectId,
displayName: request.displayName,
})
if (!isNil(folderWithDisplayName)) {
return this.getOneOrThrow({ projectId, folderId: folderWithDisplayName.id })
}
const folderId = apId()
await folderRepo().upsert({
id: folderId,
projectId,
displayName: request.displayName,
externalId: folderId,
}, ['projectId', 'displayName'])
const folder = await folderRepo().findOneByOrFail({ projectId, id: folderId })
return {
...folder,
numberOfFlows: 0,
numberOfTables: 0,
}
},
})
},
async listAllByProject(params: ListAllParams): Promise<Folder[]> {
const { projectId } = params
return folderRepo().find({ where: { projectId } })
},
async upsertByExternalId(params: UpsertByExternalIdParams): Promise<Folder> {
const { projectId, externalId, displayName, displayOrder } = params
const existing = await folderRepo().findOneBy({ projectId, externalId })
if (!isNil(existing)) {
await folderRepo().update(existing.id, {
displayName,
displayOrder,
})
return folderRepo().findOneByOrFail({ id: existing.id, projectId })
}
const folderId = apId()
await folderRepo().insert({
id: folderId,
projectId,
displayName,
displayOrder,
externalId,
})
return folderRepo().findOneByOrFail({ id: folderId, projectId })
},
async deleteByExternalId(params: DeleteByExternalIdParams): Promise<void> {
const { projectId, externalId } = params
const existing = await folderRepo().findOneBy({ projectId, externalId })
if (isNil(existing)) {
return
}
await folderRepo().delete({ id: existing.id, projectId })
},
async list(params: ListParams): Promise<SeekPage<FolderDto>> {
const { projectId, cursorRequest, limit } = params
const decodedCursor = paginationHelper.decodeCursor(cursorRequest)
const paginator = buildPaginator({
entity: FolderEntity,
query: {
limit,
order: 'ASC',
afterCursor: decodedCursor.nextCursor,
beforeCursor: decodedCursor.previousCursor,
},
})
const queryBuilder = folderRepo()
.createQueryBuilder('folder')
.where('folder.projectId = :projectId', { projectId })
.addSelect((subQuery) => subQuery
.select('COUNT(*)::int')
.from('flow', 'flow')
.where('flow."folderId" = folder.id'), 'numberOfFlows')
.addSelect((subQuery) => subQuery
.select('COUNT(*)::int')
.from('table', 'tbl')
.where('tbl."folderId" = folder.id'), 'numberOfTables')
const paginationResponse = await paginator.paginate<FolderDto>(queryBuilder)
return paginationHelper.createPage(paginationResponse.data, paginationResponse.cursor)
},
async getOneByDisplayNameCaseInsensitive(params: GetOneByDisplayNameParams): Promise<Folder | null> {
const { projectId, displayName } = params
return folderRepo().createQueryBuilder('folder')
.where('folder.projectId = :projectId', { projectId })
.andWhere('LOWER(folder.displayName) = LOWER(:displayName)', { displayName })
.getOne()
},
async getOneOrThrow(params: GetOneOrThrowParams): Promise<FolderDto> {
const { projectId, folderId } = params
const folder = await folderRepo().findOneBy({ projectId, id: folderId })
if (!folder) {
throw new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: {
message: `Folder ${folderId} is not found`,
},
})
}
const [numberOfFlows, numberOfTables] = await Promise.all([
flowService(log).count({ projectId, folderId }),
tableService.count({ projectId, folderId }),
])
return {
...folder,
numberOfFlows,
numberOfTables,
}
},
})
function folderUpsertLockKey({ projectId, displayName }: { projectId: ProjectId, displayName: string }): string {
return `folder-upsert-${projectId}-${displayName.trim().toLowerCase()}`
}
const FOLDER_UPSERT_LOCK_TIMEOUT_SECONDS = 30
type DeleteParams = {
projectId: ProjectId
folderId: FolderId
}
type UpdateParams = {
projectId: ProjectId
folderId: FolderId
request: UpdateFolderRequest
}
type UpsertParams = {
projectId: ProjectId
request: CreateFolderRequest
}
type ListParams = {
projectId: ProjectId
cursorRequest: Cursor | null
limit: number
}
type GetOneByDisplayNameParams = {
projectId: ProjectId
displayName: string
}
type GetOneOrThrowParams = {
projectId: ProjectId
folderId: FolderId
}
type ListAllParams = {
projectId: ProjectId
}
type UpsertByExternalIdParams = {
projectId: ProjectId
externalId: string
displayName: string
displayOrder: number
}
type DeleteByExternalIdParams = {
projectId: ProjectId
externalId: string
}