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, ErrorCode, isNil, PlatformId, STEP_NAME_REGEX, unique, UserId } from '@activepieces/core-utils'
import {
PieceAuthProperty,
piecePropertiesUtils,
PiecePropertyMap,
} from '@activepieces/pieces-framework'
import { AiRouterActionSettingsWithValidation, CodeActionSettings, FlowActionType, FlowOperationRequest, FlowOperationType, flowPieceUtil, flowStructureUtil, FlowTrigger, FlowTriggerType, LoopOnItemsActionSettings, PieceActionSettings, PieceTriggerSettings, RouterActionSettingsWithValidation, SourceCode, Step } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { z } from 'zod'
import { pieceMetadataService } from '../../pieces/metadata/piece-metadata-service'
const loopSettingsValidator = LoopOnItemsActionSettings.and(z.object({
items: z.string().min(1),
}))
const routerSettingsValidator = RouterActionSettingsWithValidation
const aiRouterSettingsValidator = AiRouterActionSettingsWithValidation
const codeSettingsValidator = CodeActionSettings.and(z.object({
sourceCode: SourceCode.and(z.object({
code: z.string().min(1),
packageJson: z.string().min(1),
})),
}))
type ValidationResult = {
valid: boolean
cleanInput?: Record<string, unknown>
invalidInputs?: string[]
}
export const flowVersionValidationUtil = (log: FastifyBaseLogger) => ({
async prepareRequest({ platformId, request, userId }: PrepareRequestParams): Promise<FlowOperationRequest> {
const clonedRequest: FlowOperationRequest = JSON.parse(JSON.stringify(request))
switch (clonedRequest.type) {
case FlowOperationType.ADD_ACTION:
switch (clonedRequest.request.action.type) {
case FlowActionType.LOOP_ON_ITEMS:
clonedRequest.request.action.valid = loopSettingsValidator.safeParse(
clonedRequest.request.action.settings,
).success
break
case FlowActionType.PIECE: {
clonedRequest.request.action.settings.pieceVersion = flowPieceUtil.getExactVersion(clonedRequest.request.action.settings.pieceVersion)
const result = await validateAction(
{ settings: clonedRequest.request.action.settings, platformId, log },
)
clonedRequest.request.action.valid = result.valid
if (!isNil(result.cleanInput)) {
clonedRequest.request.action.settings.input = result.cleanInput
}
break
}
case FlowActionType.ROUTER:
clonedRequest.request.action.valid = routerSettingsValidator.safeParse(
clonedRequest.request.action.settings,
).success
break
case FlowActionType.AI_ROUTER:
clonedRequest.request.action.valid = aiRouterSettingsValidator.safeParse(
clonedRequest.request.action.settings,
).success
break
case FlowActionType.CODE:
clonedRequest.request.action.valid = codeSettingsValidator.safeParse(
clonedRequest.request.action.settings,
).success
break
}
break
case FlowOperationType.UPDATE_ACTION:
switch (clonedRequest.request.type) {
case FlowActionType.LOOP_ON_ITEMS:
clonedRequest.request.valid = loopSettingsValidator.safeParse(
clonedRequest.request.settings,
).success
break
case FlowActionType.PIECE: {
clonedRequest.request.settings.pieceVersion = flowPieceUtil.getExactVersion(clonedRequest.request.settings.pieceVersion)
const result = await validateAction(
{ settings: clonedRequest.request.settings, platformId, log },
)
clonedRequest.request.valid = result.valid
if (!isNil(result.cleanInput)) {
clonedRequest.request.settings.input = result.cleanInput
}
break
}
case FlowActionType.ROUTER:
clonedRequest.request.valid = routerSettingsValidator.safeParse(
clonedRequest.request.settings,
).success
break
case FlowActionType.AI_ROUTER:
clonedRequest.request.valid = aiRouterSettingsValidator.safeParse(
clonedRequest.request.settings,
).success
break
case FlowActionType.CODE:
clonedRequest.request.valid = codeSettingsValidator.safeParse(
clonedRequest.request.settings,
).success
break
}
break
case FlowOperationType.UPDATE_TRIGGER:
switch (clonedRequest.request.type) {
case FlowTriggerType.EMPTY:
clonedRequest.request.valid = false
break
case FlowTriggerType.PIECE: {
clonedRequest.request.settings.pieceVersion = flowPieceUtil.getExactVersion(clonedRequest.request.settings.pieceVersion)
const result = await validateTrigger(
{ settings: clonedRequest.request.settings, platformId, log },
)
clonedRequest.request.valid = result.valid
if (result.valid && result.cleanInput) {
clonedRequest.request.settings.input = result.cleanInput
}
break
}
}
break
case FlowOperationType.IMPORT_FLOW:{
assertImportedStepNamesAreSafe(clonedRequest.request.trigger)
const notes = clonedRequest.request.notes
if (!isNil(notes)) {
clonedRequest.request.notes = notes.map(note => ({
...note,
ownerId: userId,
}))
}
break
}
default:
break
}
return clonedRequest
},
async invalidPieceInputs({ platformId, step }: { platformId: PlatformId, step: Step }): Promise<string[]> {
if (step.type === FlowActionType.PIECE) {
return (await validateAction({ settings: step.settings, platformId, log })).invalidInputs ?? []
}
if (step.type === FlowTriggerType.PIECE) {
return (await validateTrigger({ settings: step.settings, platformId, log })).invalidInputs ?? []
}
return []
},
})
function assertImportedStepNamesAreSafe(trigger: FlowTrigger): void {
const invalidStep = flowStructureUtil.getAllSteps(trigger).find((step) => !STEP_NAME_REGEX.test(step.name))
if (!isNil(invalidStep)) {
throw new ActivepiecesError({
code: ErrorCode.VALIDATION,
params: { message: `Invalid step name: "${invalidStep.name}"` },
})
}
}
async function validateAction({ settings, platformId, log }: ValidateActionParams): Promise<ValidationResult> {
if (
isNil(settings.pieceName) ||
isNil(settings.pieceVersion) ||
isNil(settings.actionName) ||
isNil(settings.input)
) {
return { valid: false }
}
const piece = await pieceMetadataService(log).getOrThrow({
platformId,
name: settings.pieceName,
version: settings.pieceVersion,
})
if (isNil(piece)) {
return { valid: false }
}
const action = piece.actions[settings.actionName]
if (isNil(action)) {
return { valid: false }
}
const props = { ...action.props }
return validateProps(props, settings.input, piece.auth, action.requireAuth)
}
async function validateTrigger({ settings, platformId, log }: ValidateTriggerParams): Promise<ValidationResult> {
if (
isNil(settings.pieceName) ||
isNil(settings.pieceVersion) ||
isNil(settings.triggerName) ||
isNil(settings.input)
) {
return { valid: false }
}
const piece = await pieceMetadataService(log).getOrThrow({
platformId,
name: settings.pieceName,
version: settings.pieceVersion,
})
if (isNil(piece)) {
return { valid: false }
}
const trigger = piece.triggers[settings.triggerName]
if (isNil(trigger)) {
return { valid: false }
}
const props = { ...trigger.props }
return validateProps(props, settings.input, piece.auth, trigger.requireAuth)
}
function validateProps(
props: PiecePropertyMap,
input: Record<string, unknown> | undefined,
auth: PieceAuthProperty | PieceAuthProperty[] | undefined,
//if require auth is not defined, we default to true, because at first all auth was required
requireAuth: boolean | undefined = true,
): ValidationResult {
const propsSchema = piecePropertiesUtils.buildSchema(props, auth, requireAuth)
const schemaKeys = Object.keys((propsSchema as unknown as z.ZodObject<z.ZodRawShape>).shape)
const cleanInput = !isNil(input) ? Object.fromEntries(
schemaKeys.map(key => [key, input?.[key]]),
) : undefined
const parsed = propsSchema.safeParse(cleanInput)
return {
valid: parsed.success,
cleanInput,
invalidInputs: parsed.success ? [] : describeInvalidInputs({ issues: parsed.error.issues, input: cleanInput }),
}
}
function describeInvalidInputs({ issues, input }: { issues: z.ZodError['issues'], input: Record<string, unknown> | undefined }): string[] {
const keys = unique(issues.flatMap((issue) => typeof issue.path[0] === 'string' ? [issue.path[0]] : []))
return keys.map((key) => {
const label = key === 'auth' ? 'connection' : key
const value = input?.[key]
const missing = isNil(value) || value === ''
return missing ? `${label} is missing` : `${label} has an invalid value`
})
}
type PrepareRequestParams = {
platformId?: PlatformId
request: FlowOperationRequest
userId: UserId | null
}
type ValidateActionParams = {
settings: PieceActionSettings
platformId?: PlatformId
log: FastifyBaseLogger
}
type ValidateTriggerParams = {
settings: PieceTriggerSettings
platformId?: PlatformId
log: FastifyBaseLogger
}