Skip to content

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

3.1 KB
Raw Blame
import { inspect } from 'util'
import { formatPieceError, tryCatch } from '@activepieces/core-utils'
import { EngineOperation, EngineOperationType, EngineResponse, EngineResponseStatus, ExecuteActionOperation, ExecuteExtractPieceMetadataOperation, ExecuteFlowOperation, ExecutePropsOptions, ExecuteRefreshTokenAuthOperation, ExecuteResolveConnectionIdentifierOperation, ExecuteTriggerOperation, ExecuteValidateAuthOperation, ExecutionError, ExecutionErrorType, TriggerHookType } from '@activepieces/shared'
import { actionOperation } from './action.operation'
import { authRefreshOperation } from './auth-refresh.operation'
import { authValidationOperation } from './auth-validation.operation'
import { flowOperation } from './flow.operation'
import { pieceMetadataOperation } from './piece-metadata.operation'
import { propertyOperation } from './property.operation'
import { resolveConnectionIdentifierOperation } from './resolve-connection-identifier.operation'
import { triggerHookOperation } from './trigger-hook.operation'


export async function execute(operationType: EngineOperationType, operation: EngineOperation): Promise<EngineResponse<unknown>> {
    const result = await tryCatch(async () => {
        switch (operationType) {
            case EngineOperationType.EXTRACT_PIECE_METADATA: {
                return pieceMetadataOperation.extract(operation as ExecuteExtractPieceMetadataOperation)
            }
            case EngineOperationType.EXECUTE_FLOW: {
                return flowOperation.execute(operation as ExecuteFlowOperation)
            }
            case EngineOperationType.EXECUTE_ACTION: {
                return actionOperation.execute(operation as ExecuteActionOperation)
            }
            case EngineOperationType.EXECUTE_PROPERTY: {
                return propertyOperation.execute(operation as ExecutePropsOptions)
            }
            case EngineOperationType.EXECUTE_TRIGGER_HOOK: {
                return triggerHookOperation.execute(operation as ExecuteTriggerOperation<TriggerHookType>)
            }
            case EngineOperationType.EXECUTE_VALIDATE_AUTH: {
                return authValidationOperation.execute(operation as ExecuteValidateAuthOperation)
            }
            case EngineOperationType.EXECUTE_RESOLVE_CONNECTION_IDENTIFIER: {
                return resolveConnectionIdentifierOperation.execute(operation as ExecuteResolveConnectionIdentifierOperation)
            }
            case EngineOperationType.EXECUTE_REFRESH_TOKEN_AUTH: {
                return authRefreshOperation.execute(operation as ExecuteRefreshTokenAuthOperation)
            }
            default: {
                throw new ExecutionError('Unsupported operation type', `Unsupported operation type: ${operationType}`, ExecutionErrorType.ENGINE)
            }
        }
    })
    if (result.error) {
        console.error(result.error)
        return {
            response: undefined,
            status: EngineResponseStatus.INTERNAL_ERROR,
            error: JSON.stringify(formatPieceError(result.error, { raw: inspect(result.error) })),
        }
    }
    return result.data
}