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, Cursor, ErrorCode, isNil, Metadata, PlatformId, ProjectId, SeekPage, spreadIfDefined, UserId } from '@activepieces/core-utils'
import { AppConnectionOwners, Variable, VariableWithoutSensitiveData } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { Equal, ILike } from 'typeorm'
import { repoFactory } from '../core/db/repo-factory'
import { isUniqueViolation } from '../core/db/unique-violation'
import { encryptUtils } from '../helper/encryption'
import { buildPaginator } from '../helper/pagination/build-paginator'
import { paginationHelper } from '../helper/pagination/pagination-utils'
import { mapToUserWithMetaInformation } from '../user/user-service'
import { VariableEntity, VariableSchema } from './variable.entity'
export const variableRepo = repoFactory(VariableEntity)
export const variableService = (log: FastifyBaseLogger) => ({
async create(params: CreateParams): Promise<VariableWithoutSensitiveData> {
const { projectId, platformId, name, value, ownerId, metadata } = params
const id = apId()
try {
await variableRepo().insert({
id,
projectId,
platformId,
name,
ownerId: ownerId ?? null,
value: await encryptUtils.encryptObject({ secret_text: value }),
...spreadIfDefined('metadata', metadata),
})
}
catch (error) {
if (isUniqueViolation(error)) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: 'Variable name already used' },
})
}
throw error
}
log.info({ id, project: { id: projectId }, name }, 'Variable created')
return getOneOrThrowWithoutValue({ id, projectId, platformId })
},
async update(params: UpdateParams): Promise<VariableWithoutSensitiveData> {
const { id, projectId, platformId, value, metadata } = params
await getOneOrThrowWithoutValue({ id, projectId, platformId })
await variableRepo().update({ id, projectId, platformId }, {
...(isNil(value) ? {} : { value: await encryptUtils.encryptObject({ secret_text: value }) }),
...spreadIfDefined('metadata', metadata),
})
log.info({ id, project: { id: projectId } }, 'Variable updated')
return getOneOrThrowWithoutValue({ id, projectId, platformId })
},
async list(params: ListParams): Promise<SeekPage<VariableWithoutSensitiveData>> {
const { projectId, platformId, cursor, limit, name } = params
const decodedCursor = paginationHelper.decodeCursor(cursor ?? null)
const paginator = buildPaginator({
entity: VariableEntity,
query: {
limit: limit ?? 10,
order: 'ASC',
afterCursor: decodedCursor.nextCursor,
beforeCursor: decodedCursor.previousCursor,
},
})
const queryBuilder = variableRepo()
.createQueryBuilder('variable')
.leftJoinAndSelect('variable.owner', 'owner')
.leftJoinAndSelect('owner.identity', 'owner_identity')
.where({
projectId: Equal(projectId),
platformId: Equal(platformId),
...(isNil(name) ? {} : { name: ILike(`%${name}%`) }),
})
const { data, cursor: nextCursor } = await paginator.paginate(queryBuilder)
const sanitized = data.map(stripSensitiveData)
return paginationHelper.createPage<VariableWithoutSensitiveData>(sanitized, nextCursor)
},
async getOwners(params: { projectId: ProjectId, platformId: PlatformId }): Promise<AppConnectionOwners[]> {
const { projectId, platformId } = params
return variableRepo()
.createQueryBuilder('variable')
.innerJoin('variable.owner', 'owner')
.innerJoin('owner.identity', 'owner_identity')
.select('owner_identity.firstName', 'firstName')
.addSelect('owner_identity.lastName', 'lastName')
.addSelect('owner_identity.email', 'email')
.where('variable.projectId = :projectId', { projectId })
.andWhere('variable.platformId = :platformId', { platformId })
.distinct(true)
.limit(MAX_VARIABLE_OWNERS)
.getRawMany<AppConnectionOwners>()
},
async getOneOrThrowWithoutValue(params: GetOneParams): Promise<VariableWithoutSensitiveData> {
return getOneOrThrowWithoutValue(params)
},
async getDecryptedValue(params: GetOneParams): Promise<string> {
const { id, projectId, platformId } = params
const row = await variableRepo().findOneBy({ id, projectId, platformId })
if (isNil(row)) {
throw new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: {
entityId: id,
entityType: 'Variable',
},
})
}
const decrypted = await encryptUtils.decryptObject<{ secret_text: string }>(row.value)
return decrypted.secret_text
},
async getDecryptedValueForWorker(params: GetForWorkerParams): Promise<string> {
const { projectId, name } = params
const row = await variableRepo().findOneBy({ projectId, name })
if (isNil(row)) {
throw new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: {
entityId: `name=${name}`,
entityType: 'Variable',
},
})
}
const decrypted = await encryptUtils.decryptObject<{ secret_text: string }>(row.value)
return decrypted.secret_text
},
async delete(params: GetOneParams): Promise<VariableWithoutSensitiveData> {
const target = await getOneOrThrowWithoutValue(params)
await variableRepo().delete({ id: params.id, projectId: params.projectId, platformId: params.platformId })
log.info({ id: params.id, project: { id: params.projectId } }, 'Variable deleted')
return target
},
})
async function getOneOrThrowWithoutValue(params: GetOneParams): Promise<VariableWithoutSensitiveData> {
const { id, projectId, platformId } = params
const row = await variableRepo()
.createQueryBuilder('variable')
.leftJoinAndSelect('variable.owner', 'owner')
.leftJoinAndSelect('owner.identity', 'owner_identity')
.where({ id, projectId, platformId })
.getOne()
if (isNil(row)) {
throw new ActivepiecesError({
code: ErrorCode.ENTITY_NOT_FOUND,
params: {
entityId: id,
entityType: 'Variable',
},
})
}
return stripSensitiveData(row)
}
function stripSensitiveData(row: VariableSchema): VariableWithoutSensitiveData {
return {
id: row.id,
created: row.created,
updated: row.updated,
name: row.name,
projectId: row.projectId,
platformId: row.platformId,
ownerId: row.ownerId,
owner: mapToUserWithMetaInformation(row.owner ?? null),
metadata: row.metadata,
}
}
const MAX_VARIABLE_OWNERS = 200
type CreateParams = {
projectId: string
platformId: string
name: string
value: string
ownerId: UserId | null
metadata: Metadata | undefined
}
type UpdateParams = {
id: ApId
projectId: string
platformId: string
value: string | undefined
metadata: Metadata | undefined
}
type GetOneParams = {
id: ApId
projectId: string
platformId: string
}
type GetForWorkerParams = {
projectId: string
name: string
}
type ListParams = {
projectId: string
platformId: string
cursor: Cursor | undefined
limit: number | undefined
name: string | undefined
}
export type { Variable }