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

27.0 KB
Raw Blame
import { ActivepiecesError, apId, isNil, PlatformId, ProjectId, unique } from '@activepieces/core-utils'
import { apVersionUtil, memoryLock } from '@activepieces/server-utils'
import { AppConnectionScope, AppConnectionStatus, AppConnectionType, ConnectionAwaitingAuthorization, ConnectionOperationType, ConnectionState, FlowProjectOperationType, FolderOperationType, FolderState, InstalledPiece, PackageType, PieceInstallFailure, PieceScope, ProjectReplaceApplied, ProjectReplaceErrorKind, ProjectReplaceItemFailure, ProjectReplaceItemKind, ProjectReplaceItemOp, ProjectReplacePreflightError, ProjectReplaceRequest, ProjectReplaceResponse, ProjectState, RequiredPiece, TableOperationType } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import semver from 'semver'
import { ArrayContains, In } from 'typeorm'
import { appConnectionsRepo } from '../../../app-connection/app-connection-service/app-connection-service'
import { flowFolderService } from '../../../flows/folder/folder.service'
import { encryptUtils } from '../../../helper/encryption'
import { pieceMetadataService } from '../../../pieces/metadata/piece-metadata-service'
import { pieceInstallService } from '../../../pieces/piece-install-service'
import { fieldService } from '../../../tables/field/field.service'
import { tableService } from '../../../tables/table/table.service'
import { connectionDiffService } from '../project-release/project-state/diff/connection-diff.service'
import { flowDiffService } from '../project-release/project-state/diff/flow-diff.service'
import { folderDiffService } from '../project-release/project-state/diff/folder-diff.service'
import { tableDiffService } from '../project-release/project-state/diff/table-diff.service'
import { projectStateHelper, RepublishFlowParams } from '../project-release/project-state/project-state-helper'
import { projectStateService } from '../project-release/project-state/project-state.service'

export const projectReplaceService = {
    async replace({ projectId, platformId, request, log }: ReplaceParams): Promise<ReplaceOutcome> {
        const startedAt = Date.now()
        const lockKey = `project-replace:${projectId}`
        const lock = await memoryLock.tryAcquire(lockKey)
        if (isNil(lock)) {
            return {
                kind: 'LOCKED',
                durationMs: Date.now() - startedAt,
            }
        }
        try {
            const preflightErrors = await runPreflight({ platformId, projectId, request, log })
            if (preflightErrors.length > 0) {
                return {
                    kind: 'PREFLIGHT_FAILED',
                    errors: preflightErrors,
                    durationMs: Date.now() - startedAt,
                }
            }
            const { failures: installFailures, installed: piecesInstalled } = await runInstallPhase({ platformId, request, log })
            if (installFailures.length > 0) {
                return {
                    kind: 'INSTALL_FAILED',
                    failures: installFailures,
                    durationMs: Date.now() - startedAt,
                }
            }
            const response = await applyReplace({ projectId, platformId, request, log })
            return {
                kind: response.failed.length === 0 ? 'SUCCESS' : 'PARTIAL_FAILURE',
                response: { ...response, piecesInstalled, durationMs: Date.now() - startedAt },
                durationMs: Date.now() - startedAt,
            }
        }
        finally {
            await lock.release()
        }
    },
}

async function runInstallPhase({ platformId, request, log }: InstallPhaseParams): Promise<InstallPhaseResult> {
    const failures: PieceInstallFailure[] = []
    const installed: InstalledPiece[] = []
    for (const piece of request.requiredPieces) {
        const found = await pieceMetadataService(log).get({
            name: piece.name,
            version: piece.version,
            platformId,
        })
        if (!isNil(found) && found.version === piece.version) {
            continue
        }
        try {
            await pieceInstallService(log).installPiece(platformId, {
                packageType: PackageType.REGISTRY,
                scope: PieceScope.PLATFORM,
                pieceName: piece.name,
                pieceVersion: piece.version,
            })
            installed.push({
                name: piece.name,
                version: piece.version,
                pieceType: piece.pieceType,
            })
        }
        catch (e) {
            failures.push({
                pieceName: piece.name,
                version: piece.version,
                pieceType: piece.pieceType,
                message: errorMessage(e),
            })
        }
    }
    return { failures, installed }
}

async function runPreflight({ platformId, projectId, request, log }: PreflightParams): Promise<ProjectReplacePreflightError[]> {
    const errors: ProjectReplacePreflightError[] = []

    const destVersion = apVersionUtil.getCurrentRelease()
    checkApVersion({ sourceVersion: request.sourceActivepiecesVersion, destVersion, errors })

    for (const piece of request.requiredPieces) {
        await checkPiece({ piece, platformId, log, errors })
    }

    await checkConnections({ projectId, platformId, request, errors })

    return errors
}

function checkApVersion({ sourceVersion, destVersion, errors }: CheckApVersionParams): void {
    const source = semver.parse(sourceVersion)
    const dest = semver.parse(destVersion)
    if (source === null || dest === null) {
        errors.push({
            kind: ProjectReplaceErrorKind.AP_VERSION_MISMATCH,
            sourceVersion,
            destVersion,
            message: `Cannot parse versions (source=${sourceVersion}, dest=${destVersion})`,
        })
        return
    }
    if (source.major !== dest.major) {
        errors.push({
            kind: ProjectReplaceErrorKind.AP_VERSION_MISMATCH,
            sourceVersion,
            destVersion,
            message: `Major version mismatch (source major=${source.major}, dest major=${dest.major})`,
        })
        return
    }
    if (semver.lt(destVersion, sourceVersion)) {
        errors.push({
            kind: ProjectReplaceErrorKind.AP_VERSION_MISMATCH,
            sourceVersion,
            destVersion,
            message: `Destination Activepieces version (${destVersion}) is older than source (${sourceVersion})`,
        })
    }
}

async function checkPiece({ piece, platformId, log, errors }: CheckPieceParams): Promise<void> {
    const found = await pieceMetadataService(log).get({
        name: piece.name,
        version: piece.version,
        platformId,
    })
    if (isNil(found)) {
        return
    }
    if (found.version !== piece.version) {
        errors.push({
            kind: ProjectReplaceErrorKind.PIECE_VERSION_MISMATCH,
            pieceName: piece.name,
            sourceVersion: piece.version,
            destVersion: found.version,
        })
    }
}

async function checkConnections({ projectId, platformId, request, errors }: CheckConnectionsParams): Promise<void> {
    if (request.connections.length === 0) {
        return
    }
    const externalIds = unique(request.connections.map((c) => c.externalId))
    const existing = await appConnectionsRepo().find({
        where: {
            projectIds: ArrayContains([projectId]),
            platformId,
            externalId: In(externalIds),
        },
        select: { externalId: true, pieceName: true },
    })
    const destByExternalId = new Map(existing.map((row) => [row.externalId, row.pieceName]))
    const seen = new Set<string>()
    for (const conn of request.connections) {
        if (seen.has(conn.externalId)) continue
        seen.add(conn.externalId)
        const destPieceName = destByExternalId.get(conn.externalId)
        if (!isNil(destPieceName) && destPieceName !== conn.pieceName) {
            errors.push({
                kind: ProjectReplaceErrorKind.CONNECTION_PIECE_MISMATCH,
                externalId: conn.externalId,
                expectedPieceName: conn.pieceName,
                foundPieceName: destPieceName,
            })
        }
    }
}

// Apply phase intentionally does NOT wrap its writes in a single DB transaction.
// Three reasons:
//   1. The design supports partial success (HTTP 207 + failed[]). A single tx
//      would roll back every successfully-applied folder/table/connection just
//      because one flow's republish failed.
//   2. republishFlow triggers BullMQ jobs and trigger-source registration —
//      those can't sit inside a SQL transaction anyway.
//   3. Recovery is by re-run: every op matches by externalId, so a crashed
//      apply leaves dest in a state the next run's diff phase detects and
//      finishes. CI/CD's natural retry covers process-level failures.
async function applyReplace({ projectId, platformId, request, log }: ApplyParams): Promise<ProjectReplaceResponse> {
    const newState: ProjectState = {
        flows: request.flows,
        tables: request.tables,
        folders: request.folders,
        connections: request.connections,
    }
    const baseCurrentState = await projectStateService(log).getProjectState(projectId, log)
    const currentState: ProjectState = {
        ...baseCurrentState,
        folders: await loadCurrentFolderStates({ projectId, log }),
    }

    const flowOps = await flowDiffService.diff({ newState, currentState })
    const tableOps = tableDiffService.diff({ newState, currentState })
    const folderOps = folderDiffService.diff({ newState, currentState })
    const connectionOps = connectionDiffService.diff({ newState, currentState })

    const failed: ProjectReplaceItemFailure[] = []
    const applied: ProjectReplaceApplied = emptyAppliedCounts()

    const folderOpsCreateUpdate = folderOps.filter((op) =>
        op.type === FolderOperationType.CREATE_FOLDER || op.type === FolderOperationType.UPDATE_FOLDER,
    )
    const folderOpsDelete = folderOps.filter((op) => op.type === FolderOperationType.DELETE_FOLDER)
    const tableOpsCreateUpdate = tableOps.filter((op) =>
        op.type === TableOperationType.CREATE_TABLE || op.type === TableOperationType.UPDATE_TABLE,
    )
    const tableOpsDelete = tableOps.filter((op) => op.type === TableOperationType.DELETE_TABLE)
    const flowOpsCreateUpdate = flowOps.filter((op) =>
        op.type === FlowProjectOperationType.CREATE_FLOW || op.type === FlowProjectOperationType.UPDATE_FLOW,
    )
    const flowOpsDelete = flowOps.filter((op) => op.type === FlowProjectOperationType.DELETE_FLOW)

    for (const op of connectionOps) {
        await runConnectionOp({ op, projectId, platformId, log, applied, failed })
    }
    for (const op of folderOpsCreateUpdate) {
        await runFolderOp({ op, projectId, log, applied, failed })
    }
    for (const op of tableOpsCreateUpdate) {
        await runTableOp({ op, projectId, applied, failed })
    }
    for (const op of flowOpsCreateUpdate) {
        await runFlowOp({ op, projectId, log, applied, failed })
    }
    for (const op of flowOpsDelete) {
        await runFlowOp({ op, projectId, log, applied, failed })
    }
    for (const op of tableOpsDelete) {
        await runTableOp({ op, projectId, applied, failed })
    }
    for (const op of folderOpsDelete) {
        await runFolderOp({ op, projectId, log, applied, failed })
    }

    // Derive "unchanged" from the diff (success-independent): items in the request
    // that the diff service didn't flag as create/update are unchanged. A failed
    // CREATE/UPDATE goes into failed[] and is NOT counted as unchanged.
    applied.flowsUnchanged = Math.max(0, request.flows.length - flowOpsCreateUpdate.length)
    applied.tablesUnchanged = Math.max(0, request.tables.length - tableOpsCreateUpdate.length)
    applied.foldersUnchanged = Math.max(0, request.folders.length - folderOpsCreateUpdate.length)
    applied.connectionsUnchanged = Math.max(0, request.connections.length - connectionOps.length)

    const connectionsAwaitingAuthorization = await collectConnectionsAwaitingAuthorization({
        projectId,
        platformId,
        connections: request.connections,
    })

    return {
        applied,
        failed,
        connectionsAwaitingAuthorization,
        piecesInstalled: [],
        durationMs: 0,
    }
}

async function runConnectionOp({ op, projectId, platformId, applied, failed }: RunConnectionOpParams): Promise<void> {
    try {
        switch (op.type) {
            case ConnectionOperationType.CREATE_CONNECTION: {
                const encryptedNoAuth = await encryptUtils.encryptObject({ type: AppConnectionType.NO_AUTH })
                await appConnectionsRepo().insert({
                    id: apId(),
                    externalId: op.connectionState.externalId,
                    displayName: op.connectionState.displayName,
                    pieceName: op.connectionState.pieceName,
                    pieceVersion: '0.0.0',
                    platformId,
                    projectIds: [projectId],
                    scope: AppConnectionScope.PROJECT,
                    type: AppConnectionType.NO_AUTH,
                    status: AppConnectionStatus.MISSING,
                    value: encryptedNoAuth,
                })
                applied.connectionsCreated++
                break
            }
            case ConnectionOperationType.UPDATE_CONNECTION: {
                const existing = await appConnectionsRepo().findOne({
                    where: {
                        projectIds: ArrayContains([projectId]),
                        externalId: op.newConnectionState.externalId,
                        platformId,
                    },
                    select: { id: true },
                })
                if (!isNil(existing)) {
                    await appConnectionsRepo().update(existing.id, {
                        displayName: op.newConnectionState.displayName,
                    })
                }
                applied.connectionsUpdated++
                break
            }
        }
    }
    catch (e) {
        failed.push({
            kind: ProjectReplaceItemKind.CONNECTION,
            externalId: op.type === ConnectionOperationType.UPDATE_CONNECTION
                ? op.newConnectionState.externalId
                : op.connectionState.externalId,
            op: op.type === ConnectionOperationType.UPDATE_CONNECTION ? ProjectReplaceItemOp.UPDATE : ProjectReplaceItemOp.CREATE,
            error: errorMessage(e),
        })
    }
}

async function collectConnectionsAwaitingAuthorization({ projectId, platformId, connections }: CollectAwaitingParams): Promise<ConnectionAwaitingAuthorization[]> {
    if (connections.length === 0) return []
    const externalIds = unique(connections.map((c) => c.externalId))
    const rows = await appConnectionsRepo().find({
        where: {
            projectIds: ArrayContains([projectId]),
            platformId,
            externalId: In(externalIds),
        },
        select: { externalId: true, pieceName: true, displayName: true, status: true },
    })
    return rows
        .filter((row) => row.status !== AppConnectionStatus.ACTIVE)
        .map((row) => ({
            externalId: row.externalId,
            pieceName: row.pieceName,
            displayName: row.displayName,
        }))
}

async function loadCurrentFolderStates({ projectId, log }: LoadCurrentFolderStatesParams): Promise<FolderState[]> {
    const folders = await flowFolderService(log).listAllByProject({ projectId })
    return folders
        .filter((folder) => !isNil(folder.externalId))
        .map((folder) => ({
            externalId: folder.externalId as string,
            displayName: folder.displayName,
            displayOrder: folder.displayOrder,
        }))
}

async function runFolderOp({ op, projectId, log, applied, failed }: RunFolderOpParams): Promise<void> {
    try {
        switch (op.type) {
            case FolderOperationType.CREATE_FOLDER: {
                await flowFolderService(log).upsertByExternalId({
                    projectId,
                    externalId: op.folderState.externalId,
                    displayName: op.folderState.displayName,
                    displayOrder: op.folderState.displayOrder,
                })
                applied.foldersCreated++
                break
            }
            case FolderOperationType.UPDATE_FOLDER: {
                await flowFolderService(log).upsertByExternalId({
                    projectId,
                    externalId: op.newFolderState.externalId,
                    displayName: op.newFolderState.displayName,
                    displayOrder: op.newFolderState.displayOrder,
                })
                applied.foldersUpdated++
                break
            }
            case FolderOperationType.DELETE_FOLDER: {
                await flowFolderService(log).deleteByExternalId({
                    projectId,
                    externalId: op.folderState.externalId,
                })
                applied.foldersDeleted++
                break
            }
        }
    }
    catch (e) {
        failed.push({
            kind: ProjectReplaceItemKind.FOLDER,
            externalId: extractFolderExternalId(op),
            op: folderOpToOp(op.type),
            error: errorMessage(e),
        })
    }
}

function extractFolderExternalId(op: FolderOp): string {
    if (op.type === FolderOperationType.UPDATE_FOLDER) {
        return op.newFolderState.externalId
    }
    return op.folderState.externalId
}

function folderOpToOp(type: FolderOperationType): ProjectReplaceItemOp {
    switch (type) {
        case FolderOperationType.CREATE_FOLDER:
            return ProjectReplaceItemOp.CREATE
        case FolderOperationType.UPDATE_FOLDER:
            return ProjectReplaceItemOp.UPDATE
        case FolderOperationType.DELETE_FOLDER:
            return ProjectReplaceItemOp.DELETE
    }
}

async function runTableOp({ op, projectId, applied, failed }: RunTableOpParams): Promise<void> {
    try {
        switch (op.type) {
            case TableOperationType.CREATE_TABLE: {
                const table = await tableService.create({
                    projectId,
                    request: {
                        name: op.tableState.name,
                        externalId: op.tableState.externalId,
                        projectId,
                    },
                })
                await fieldService.validateCount({ projectId, tableId: table.id, insertCount: op.tableState.fields.length })
                await Promise.all(op.tableState.fields.map((field, position) =>
                    fieldService.createFromState({ projectId, field, tableId: table.id, position }),
                ))
                applied.tablesCreated++
                break
            }
            case TableOperationType.UPDATE_TABLE: {
                const updated = await tableService.update({
                    projectId,
                    id: op.tableState.id,
                    request: { name: op.newTableState.name },
                })
                const fields = await fieldService.getAll({ projectId, tableId: updated.id })
                const newFieldsCount = op.newTableState.fields.filter((field) => !fields.some((f) => f.externalId === field.externalId)).length
                await fieldService.validateCount({ projectId, tableId: updated.id, insertCount: newFieldsCount })
                await Promise.all(op.newTableState.fields.map((field, position) => {
                    const existingField = fields.find((f) => f.externalId === field.externalId)
                    if (!isNil(existingField)) {
                        return fieldService.update({
                            projectId,
                            id: existingField.id,
                            request: field,
                        })
                    }
                    return fieldService.createFromState({ projectId, field, tableId: updated.id, position })
                }))
                const fieldsToDelete = fields.filter((f) =>
                    !op.newTableState.fields.some((nf) => nf.externalId === f.externalId),
                )
                await Promise.all(fieldsToDelete.map((field) =>
                    fieldService.delete({ id: field.id, projectId }),
                ))
                applied.tablesUpdated++
                break
            }
            case TableOperationType.DELETE_TABLE: {
                const table = await tableService.getOneByExternalIdOrThrow({
                    externalId: op.tableState.externalId,
                    projectId,
                })
                await tableService.delete({ id: table.id, projectId })
                applied.tablesDeleted++
                break
            }
        }
    }
    catch (e) {
        failed.push({
            kind: ProjectReplaceItemKind.TABLE,
            externalId: tableExternalId(op),
            op: tableOpToOp(op.type),
            error: errorMessage(e),
        })
    }
}

function tableExternalId(op: TableOp): string {
    if (op.type === TableOperationType.UPDATE_TABLE) {
        return op.newTableState.externalId
    }
    return op.tableState.externalId
}

function tableOpToOp(type: TableOperationType): ProjectReplaceItemOp {
    switch (type) {
        case TableOperationType.CREATE_TABLE:
            return ProjectReplaceItemOp.CREATE
        case TableOperationType.UPDATE_TABLE:
            return ProjectReplaceItemOp.UPDATE
        case TableOperationType.DELETE_TABLE:
            return ProjectReplaceItemOp.DELETE
    }
}

async function runFlowOp({ op, projectId, log, applied, failed }: RunFlowOpParams): Promise<void> {
    try {
        switch (op.type) {
            case FlowProjectOperationType.CREATE_FLOW: {
                const created = await projectStateHelper(log).createFlowInProject(op.flowState, projectId)
                await republishOrThrow({ flow: created, projectId, status: op.flowState.status, log })
                applied.flowsCreated++
                break
            }
            case FlowProjectOperationType.UPDATE_FLOW: {
                const updated = await projectStateHelper(log).updateFlowInProject(op.flowState, op.newFlowState, projectId)
                // Mirror the source's published/disabled state — replace semantics are
                // "dest equals source", unlike project-releases which keeps dest's prior status.
                await republishOrThrow({ flow: updated, projectId, status: op.newFlowState.status, log })
                applied.flowsUpdated++
                break
            }
            case FlowProjectOperationType.DELETE_FLOW: {
                await projectStateHelper(log).deleteFlowFromProject(op.flowState.id, projectId)
                applied.flowsDeleted++
                break
            }
        }
    }
    catch (e) {
        failed.push({
            kind: ProjectReplaceItemKind.FLOW,
            externalId: flowExternalId(op),
            op: flowOpToOp(op.type),
            error: errorMessage(e),
        })
    }
}

async function republishOrThrow({ flow, projectId, status, log }: RepublishOrThrowParams): Promise<void> {
    const syncError = await projectStateHelper(log).republishFlow({ flow, projectId, status })
    if (!isNil(syncError)) {
        throw new Error(syncError.message)
    }
}

function flowExternalId(op: FlowOp): string {
    if (op.type === FlowProjectOperationType.UPDATE_FLOW) {
        return op.newFlowState.externalId ?? op.newFlowState.id
    }
    return op.flowState.externalId ?? op.flowState.id
}

function flowOpToOp(type: FlowProjectOperationType): ProjectReplaceItemOp {
    switch (type) {
        case FlowProjectOperationType.CREATE_FLOW:
            return ProjectReplaceItemOp.CREATE
        case FlowProjectOperationType.UPDATE_FLOW:
            return ProjectReplaceItemOp.UPDATE
        case FlowProjectOperationType.DELETE_FLOW:
            return ProjectReplaceItemOp.DELETE
    }
}

function emptyAppliedCounts(): ProjectReplaceApplied {
    return {
        flowsCreated: 0,
        flowsUpdated: 0,
        flowsDeleted: 0,
        flowsUnchanged: 0,
        tablesCreated: 0,
        tablesUpdated: 0,
        tablesDeleted: 0,
        tablesUnchanged: 0,
        foldersCreated: 0,
        foldersUpdated: 0,
        foldersDeleted: 0,
        foldersUnchanged: 0,
        connectionsCreated: 0,
        connectionsUpdated: 0,
        connectionsUnchanged: 0,
    }
}

function errorMessage(e: unknown): string {
    if (e instanceof ActivepiecesError) {
        return `${e.error.code}: ${JSON.stringify(e.error.params)}`
    }
    if (e instanceof Error) {
        return e.message
    }
    return String(e)
}

type RepublishOrThrowParams = RepublishFlowParams & {
    log: FastifyBaseLogger
}

type ReplaceOutcome =
    | { kind: 'SUCCESS', response: ProjectReplaceResponse, durationMs: number }
    | { kind: 'PARTIAL_FAILURE', response: ProjectReplaceResponse, durationMs: number }
    | { kind: 'PREFLIGHT_FAILED', errors: ProjectReplacePreflightError[], durationMs: number }
    | { kind: 'INSTALL_FAILED', failures: PieceInstallFailure[], durationMs: number }
    | { kind: 'LOCKED', durationMs: number }

type ReplaceParams = {
    projectId: ProjectId
    platformId: PlatformId
    request: ProjectReplaceRequest
    log: FastifyBaseLogger
}

type PreflightParams = {
    projectId: ProjectId
    platformId: PlatformId
    request: ProjectReplaceRequest
    log: FastifyBaseLogger
}

type CheckApVersionParams = {
    sourceVersion: string
    destVersion: string
    errors: ProjectReplacePreflightError[]
}

type CheckPieceParams = {
    piece: RequiredPiece
    platformId: PlatformId
    log: FastifyBaseLogger
    errors: ProjectReplacePreflightError[]
}

type InstallPhaseParams = {
    platformId: PlatformId
    request: ProjectReplaceRequest
    log: FastifyBaseLogger
}

type InstallPhaseResult = {
    failures: PieceInstallFailure[]
    installed: InstalledPiece[]
}

type CheckConnectionsParams = {
    projectId: ProjectId
    platformId: PlatformId
    request: ProjectReplaceRequest
    errors: ProjectReplacePreflightError[]
}

type ApplyParams = {
    projectId: ProjectId
    platformId: PlatformId
    request: ProjectReplaceRequest
    log: FastifyBaseLogger
}

type LoadCurrentFolderStatesParams = {
    projectId: ProjectId
    log: FastifyBaseLogger
}

type FolderOp = ReturnType<typeof folderDiffService.diff>[number]
type TableOp = ReturnType<typeof tableDiffService.diff>[number]
type FlowOp = Awaited<ReturnType<typeof flowDiffService.diff>>[number]
type ConnectionOp = ReturnType<typeof connectionDiffService.diff>[number]

type RunFolderOpParams = {
    op: FolderOp
    projectId: ProjectId
    log: FastifyBaseLogger
    applied: ProjectReplaceApplied
    failed: ProjectReplaceItemFailure[]
}

type RunTableOpParams = {
    op: TableOp
    projectId: ProjectId
    applied: ProjectReplaceApplied
    failed: ProjectReplaceItemFailure[]
}

type RunFlowOpParams = {
    op: FlowOp
    projectId: ProjectId
    log: FastifyBaseLogger
    applied: ProjectReplaceApplied
    failed: ProjectReplaceItemFailure[]
}

type RunConnectionOpParams = {
    op: ConnectionOp
    projectId: ProjectId
    platformId: PlatformId
    log: FastifyBaseLogger
    applied: ProjectReplaceApplied
    failed: ProjectReplaceItemFailure[]
}

type CollectAwaitingParams = {
    projectId: ProjectId
    platformId: PlatformId
    connections: ConnectionState[]
}