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

45.3 KB
Raw Blame
import { apId } from '@activepieces/core-utils'
import { ApEdition, FileCompression, FileLocation, FileType, Flow, FlowOperationStatus, FlowStatus, PlanName, PlatformRole, PrincipalType, UpdatePlatformRequestBody, User, UserIdentityProvider, UserStatus } from '@activepieces/shared'
import { faker } from '@faker-js/faker'
import { FastifyInstance } from 'fastify'
import { StatusCodes } from 'http-status-codes'
import { databaseConnection } from '../../../../src/app/database/database-connection'
import { system } from '../../../../src/app/helper/system/system'
import { systemJobsQueue } from '../../../../src/app/helper/system-jobs/system-job'
import { generateMockToken } from '../../../helpers/auth'
import { db } from '../../../helpers/db'
import { checkIfSolutionExistsInDb, createMockApiKey, createMockConnection, createMockFile, createMockFlow, createMockFlowRun, createMockFlowVersion, createMockSolutionAndSave, createMockUser, createMockUserIdentity, mockAndSaveBasicSetup, mockBasicUser } from '../../../helpers/mocks'
import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'

let app: FastifyInstance | null = null

async function waitForDeletionJobs(jobIds: string[], timeoutMs = 60000) {
    const start = Date.now()
    for (const jobId of jobIds) {
        while (Date.now() - start < timeoutMs) {
            const job = await systemJobsQueue?.getJob(jobId)
            if (!job) break
            const state = await job.getState()
            if (state === 'completed') break
            if (state === 'failed' && (job.attemptsMade ?? 0) >= (job.opts?.attempts ?? 2)) {
                throw new Error(`Job ${jobId} failed: ${job.failedReason}`)
            }
            if (state === 'delayed') {
                await job.promote()
            }
            await new Promise(r => setTimeout(r, 200))
        }
    }
    if (Date.now() - start >= timeoutMs) {
        throw new Error(`Deletion jobs timed out after ${timeoutMs}ms`)
    }
}

function deletionJobIds(platformId: string) {
    return [`hard-delete-platform-${platformId}`]
}

beforeAll(async () => {
    app = await setupTestEnvironment()
    process.env.AP_GOOGLE_CLIENT_ID = 'test-google-client-id'
    process.env.AP_GOOGLE_CLIENT_SECRET = 'test-google-client-secret'
})

afterAll(async () => {
    delete process.env.AP_GOOGLE_CLIENT_ID
    delete process.env.AP_GOOGLE_CLIENT_SECRET
    await teardownTestEnvironment()
})
describe('Platform API', () => {
    describe('update platform endpoint', () => {
        it('patches a platform by id', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: { id: mockPlatform.id },
            })
            const requestBody: UpdatePlatformRequestBody = {
                name: 'updated name',
                primaryColor: 'updated primary color',
                enforceAllowedAuthDomains: true,
                allowedAuthDomains: ['yahoo.com'],
                cloudAuthEnabled: false,
                emailAuthEnabled: false,
            }
            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: requestBody,
            })

            // assert
            const responseBody = response?.json()

            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.id).toBe(mockPlatform.id)
            expect(responseBody.created).toBeDefined()
            expect(responseBody.updated).toBeDefined()
            expect(responseBody.enforceAllowedAuthDomains).toBe(
                requestBody.enforceAllowedAuthDomains,
            )
            expect(responseBody.allowedAuthDomains).toEqual(
                requestBody.allowedAuthDomains,
            )
            expect(responseBody.ownerId).toBe(mockOwner.id)
            expect(responseBody.emailAuthEnabled).toBe(requestBody.emailAuthEnabled)
            expect(responseBody.name).toBe('updated name')
            expect(responseBody.primaryColor).toBe('updated primary color')
            expect(responseBody.emailAuthEnabled).toBe(false)
            expect(responseBody.federatedAuthProviders).toStrictEqual({
                saml: null,
            })
            expect(responseBody.cloudAuthEnabled).toBe(false)
        }),

        it('updates the platform logo icons', async () => {
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: { id: mockPlatform.id },
            })
            const formData = new FormData()
            formData.append('logoIcon', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('fullLogo', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('favIcon', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('name', 'updated name')
            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: formData,
            })

            // assert
            const responseBody = response?.json()

            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.id).toBe(mockPlatform.id)
            expect(responseBody.created).toBeDefined()
            expect(responseBody.updated).toBeDefined()
            expect(responseBody.name).toBe('updated name')

            const baseUrl = 'http://localhost:4200/api/v1/platforms/assets'
            expect(responseBody.logoIconUrl.startsWith(baseUrl)).toBeTruthy()
            expect(responseBody.fullLogoUrl.startsWith(baseUrl)).toBeTruthy()
            expect(responseBody.favIconUrl.startsWith(baseUrl)).toBeTruthy()
        }),

        it('updates platform with boolean and array fields via multipart form data', async () => {
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })
            const formData = new FormData()
            formData.append('logoIcon', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('fullLogo', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('favIcon', new Blob([faker.image.url()], { type: 'image/png' }))
            formData.append('cloudAuthEnabled', 'false')
            formData.append('emailAuthEnabled', 'false')
            formData.append('enforceAllowedAuthDomains', 'true')
            formData.append('allowedAuthDomains', 'example.com')
            formData.append('pinnedPieces', 'pinned-1')
            formData.append('name', 'updated name')

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: formData,
            })

            // assert
            const responseBody = response?.json()

            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.cloudAuthEnabled).toBe(false)
            expect(responseBody.emailAuthEnabled).toBe(false)
            expect(responseBody.enforceAllowedAuthDomains).toBe(true)
            expect(responseBody.allowedAuthDomains).toStrictEqual(['example.com'])
            expect(responseBody.pinnedPieces).toStrictEqual(['pinned-1'])
            expect(responseBody.name).toBe('updated name')

            const baseUrl = 'http://localhost:4200/api/v1/platforms/assets'
            expect(responseBody.logoIconUrl.startsWith(baseUrl)).toBeTruthy()
            expect(responseBody.fullLogoUrl.startsWith(baseUrl)).toBeTruthy()
            expect(responseBody.favIconUrl.startsWith(baseUrl)).toBeTruthy()
        }),

        it('updates platform theme colors', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })
            const requestBody: UpdatePlatformRequestBody = {
                themeColors: {
                    'blue-link': '#434fef',
                    danger: '#e82c51',
                    primary: {
                        dark: '#ca6716',
                    },
                    warn: {
                        default: '#fa9d52',
                    },
                },
            }

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: requestBody,
            })

            // assert
            const responseBody = response?.json()

            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.themeColors).toStrictEqual(requestBody.themeColors)
        }),

        it('updates and clears theme colors via multipart form data', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })
            const formData = new FormData()
            formData.append('name', 'updated name')
            formData.append('themeColors', JSON.stringify({ danger: '#e82c51' }))

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: formData,
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(response?.json().themeColors).toStrictEqual({ danger: '#e82c51' })

            // act - clear the overrides
            const clearFormData = new FormData()
            clearFormData.append('name', 'updated name')
            clearFormData.append('themeColors', 'null')

            const clearResponse = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: clearFormData,
            })

            // assert
            expect(clearResponse?.statusCode).toBe(StatusCodes.OK)
            expect(clearResponse?.json().themeColors).toBeNull()
        }),

        it('rejects invalid theme colors', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: {
                    themeColors: {
                        danger: 'red',
                    },
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.BAD_REQUEST)
        }),

        it('updates and clears piece selector config', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })
            const pieceSelectorConfig = {
                tabs: [
                    { id: 'EXPLORE', kind: 'BUILTIN', builtinTab: 'EXPLORE', hidden: false },
                    { id: 'APPS', kind: 'BUILTIN', builtinTab: 'APPS', hidden: true },
                    {
                        id: apId(),
                        kind: 'CUSTOM',
                        title: 'Internal Tools',
                        icon: 'Star',
                        hidden: false,
                        pieceNames: ['@activepieces/piece-internal-a', '@activepieces/piece-internal-b'],
                        sections: [
                            {
                                id: apId(),
                                title: 'CRM',
                                pieceNames: ['@activepieces/piece-internal-crm'],
                            },
                        ],
                    },
                ],
            }

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: { pieceSelectorConfig },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(response?.json().pieceSelectorConfig).toStrictEqual(pieceSelectorConfig)

            // act - clear the config
            const clearResponse = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: { pieceSelectorConfig: null },
            })

            // assert
            expect(clearResponse?.statusCode).toBe(StatusCodes.OK)
            expect(clearResponse?.json().pieceSelectorConfig).toBeNull()
        }),

        it('rejects invalid piece selector config', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: {
                    pieceSelectorConfig: {
                        tabs: [
                            { id: 'x', kind: 'BUILTIN', builtinTab: 'NOT_A_REAL_TAB', hidden: false },
                        ],
                    },
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.BAD_REQUEST)
        }),

        it('rejects a custom piece selector tab without a name', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    embeddingEnabled: false,
                },
                platform: {
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: { id: mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: {
                    pieceSelectorConfig: {
                        tabs: [
                            { id: apId(), kind: 'CUSTOM', title: '   ', hidden: false, pieceNames: [] },
                        ],
                    },
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.BAD_REQUEST)
        }),

        it('fails if user is not owner', async () => {
            // arrange
            const { mockPlatform } = await mockAndSaveBasicSetup()

            const { mockUser } = await mockBasicUser({
                user: {
                    platformId: mockPlatform.id,
                    platformRole: PlatformRole.MEMBER,
                },
            })

            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockUser.id,

                platform: { id: mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
                body: {
                    primaryColor: '#000000',
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
        })

        it('rejects cross-tenant platform update (IDOR)', async () => {
            // arrange — two independent platforms with their own admin owners
            const { mockOwner: ownerOfPlatformA, mockPlatform: platformA } = await mockAndSaveBasicSetup()
            const { mockOwner: ownerOfPlatformB, mockPlatform: platformB } = await mockAndSaveBasicSetup({
                platform: { name: 'platform-b-original-name' },
            })

            const attackerToken = await generateMockToken({
                type: PrincipalType.USER,
                id: ownerOfPlatformA.id,
                platform: { id: platformA.id },
            })

            // act — attacker (admin of platform A) points the write at platform B
            const attackResponse = await app?.inject({
                method: 'POST',
                url: `/api/v1/platforms/${platformB.id}`,
                headers: { authorization: `Bearer ${attackerToken}` },
                body: { name: 'pwned' },
            })

            // assert — request is rejected
            expect(attackResponse?.statusCode).toBe(StatusCodes.FORBIDDEN)

            // assert — platform B was NOT mutated (defense-in-depth check)
            const victimToken = await generateMockToken({
                type: PrincipalType.USER,
                id: ownerOfPlatformB.id,
                platform: { id: platformB.id },
            })
            const victimReadResponse = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${platformB.id}`,
                headers: { authorization: `Bearer ${victimToken}` },
            })
            expect(victimReadResponse?.statusCode).toBe(StatusCodes.OK)
            expect(victimReadResponse?.json().name).toBe('platform-b-original-name')
        })

    })

    describe('get platform endpoint', () => {
        it('Always Returns non-sensitive information for platform', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                platform: {
                    federatedAuthProviders: {
                        saml: {
                            idpCertificate: faker.internet.password(),
                            idpMetadata: faker.internet.password(),
                        },
                    },
                },
            })

            const mockToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: {
                    id: mockPlatform.id,
                },
            })

            // act
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${mockToken}`,
                },
            })

            const responseBody = response?.json()

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)

            expect(Object.keys(responseBody).sort()).toStrictEqual([
                'allowedAuthDomains',
                'allowedEmbedOrigins',
                'auditLogRetentionDays',
                'autoCreatePersonalProjects',
                'billingEnforced',
                'cloudAuthEnabled',
                'created',
                'defaultProjectIds',
                'emailAuthEnabled',
                'enforceAllowedAuthDomains',
                'favIconUrl',
                'federatedAuthProviders',
                'fullLogoUrl',
                'googleAuthEnabled',
                'id',
                'logoIconUrl',
                'name',
                'ownerId',
                'pieceSelectorConfig',
                'pinnedPieces',
                'plan',
                'primaryColor',
                'ssoDomain',
                'ssoDomainVerification',
                'themeColors',
                'updated',
                'usage',
            ])
            expect(responseBody.id).toBe(mockPlatform.id)
            expect(responseBody.ownerId).toBe(mockOwner.id)
            expect(responseBody.name).toBe(mockPlatform.name)
            expect(responseBody.billingEnforced).toBe(false)
            expect(responseBody.federatedAuthProviders.saml).toStrictEqual({})
            expect(responseBody.primaryColor).toBe(mockPlatform.primaryColor)
            expect(responseBody.themeColors).toBeNull()
            expect(responseBody.pieceSelectorConfig).toBeNull()
            expect(responseBody.logoIconUrl).toBe(mockPlatform.logoIconUrl)
            expect(responseBody.fullLogoUrl).toBe(mockPlatform.fullLogoUrl)
            expect(responseBody.favIconUrl).toBe(mockPlatform.favIconUrl)
            expect(responseBody.autoCreatePersonalProjects).toBe(mockPlatform.autoCreatePersonalProjects)
        })


        it('Hides license key from JWT provider (embedded) users', async () => {
            // arrange
            const { mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    licenseKey: 'test-license-key',
                },
            })

            const { mockUser: embeddedUser } = await mockBasicUser({
                userIdentity: {
                    provider: UserIdentityProvider.JWT,
                },
                user: {
                    platformId: mockPlatform.id,
                    platformRole: PlatformRole.MEMBER,
                },
            })

            const mockToken = await generateMockToken({
                type: PrincipalType.USER,
                id: embeddedUser.id,
                platform: {
                    id: mockPlatform.id,
                },
            })

            // act
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${mockToken}`,
                },
            })

            const responseBody = response?.json()

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.plan.licenseKey).toBeNull()
        })

        it('Returns license key for non-embedded users', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup({
                plan: {
                    licenseKey: 'test-license-key',
                },
            })

            const mockToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,
                platform: {
                    id: mockPlatform.id,
                },
            })

            // act
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${mockToken}`,
                },
            })

            const responseBody = response?.json()

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(responseBody.plan.licenseKey).toBe('test-license-key')
        })

        it('Fails if user is not a platform member', async () => {
            const { mockOwner: mockOwner1, mockPlatform: mockPlatform1 } = await mockAndSaveBasicSetup()
            const { mockPlatform: mockPlatform2 } = await mockAndSaveBasicSetup()

            const mockToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner1.id,
                platform: {
                    id: mockPlatform1.id,
                },
            })

            // act
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${mockPlatform2.id}`,
                headers: {
                    authorization: `Bearer ${mockToken}`,
                },
            })

            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
        })
    }),
    describe('delete platform endpoint', () => {
        const isCloud = system.getEdition() === ApEdition.CLOUD

        it('deletes a platform by id', async () => {
            if (!isCloud) return
            // arrange
            const firstAccount = await mockAndSaveBasicSetup( {
                plan: {
                    plan: PlanName.FREE,
                },
            })
            const secondAccount = await mockAndSaveBasicSetup(
                {
                    plan: {
                        plan: PlanName.FREE,
                    },
                },
            )

            const ownerSolution = await createMockSolutionAndSave({ projectId: firstAccount.mockProject.id, platformId: firstAccount.mockPlatform.id, userId: firstAccount.mockOwner.id })

            const secondSolution = await createMockSolutionAndSave({ projectId: secondAccount.mockProject.id, platformId: secondAccount.mockPlatform.id, userId: secondAccount.mockOwner.id })

            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: firstAccount.mockOwner.id,
                platform: { id: firstAccount.mockPlatform.id },
            })
            // act
            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${firstAccount.mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)
            await waitForDeletionJobs(deletionJobIds(firstAccount.mockPlatform.id))
            const secondSolutionExists = await checkIfSolutionExistsInDb(secondSolution)
            expect(secondSolutionExists).toBe(true)
            const ownerSolutionExists = await checkIfSolutionExistsInDb(ownerSolution)
            expect(ownerSolutionExists).toBe(false)
        }),
        it('fails if platform is not eligible for deletion', async () => {
            if (!isCloud) return
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup( {
                plan: {
                    plan: PlanName.ENTERPRISE,
                },
            })
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: { id: mockPlatform.id },
            })
            // act
            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.UNPROCESSABLE_ENTITY)
        }),
        it('fails if user is not owner', async () => {
            if (!isCloud) return
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup( {
                plan: {
                    plan: PlanName.FREE,
                },
            })
            const secondAccount = await mockAndSaveBasicSetup(
                {
                    plan: {
                        plan: PlanName.FREE,
                    },
                },
            )
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: { id: mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${secondAccount.mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
        }),
        it('cuts off every member, flow and api key before the purge runs', async () => {
            if (!isCloud) return
            // arrange
            const account = await mockAndSaveBasicSetup({
                plan: { plan: PlanName.FREE },
            })
            const secondMember = createMockUser({
                platformId: account.mockPlatform.id,
                platformRole: PlatformRole.ADMIN,
            })
            await db.save('user_identity', createMockUserIdentity({ id: secondMember.identityId }))
            await db.save('user', secondMember)

            const apiKey = createMockApiKey({ platformId: account.mockPlatform.id })
            await db.save('api_key', apiKey)

            const flowVersionId = apId()
            const enabledFlow = createMockFlow({
                projectId: account.mockProject.id,
                status: FlowStatus.ENABLED,
                publishedVersionId: null,
                operationStatus: FlowOperationStatus.NONE,
            })
            await databaseConnection().getRepository('flow').save([enabledFlow])
            await databaseConnection().getRepository('flow_version').save([createMockFlowVersion({
                id: flowVersionId,
                flowId: enabledFlow.id,
            })])
            await databaseConnection().getRepository('flow').update(enabledFlow.id, { publishedVersionId: flowVersionId })

            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: account.mockOwner.id,
                platform: { id: account.mockPlatform.id },
            })

            // act
            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${account.mockPlatform.id}`,
                headers: { authorization: `Bearer ${testToken}` },
            })

            // assert — everything below is true before the delayed purge job runs
            expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)

            const owner = await db.findOneBy<User>('user', { id: account.mockOwner.id })
            expect(owner?.status).toBe(UserStatus.INACTIVE)

            const otherMember = await db.findOneBy<User>('user', { id: secondMember.id })
            expect(otherMember?.status).toBe(UserStatus.INACTIVE)

            const savedFlow = await db.findOneBy<Flow>('flow', { id: enabledFlow.id })
            expect(savedFlow?.status).toBe(FlowStatus.DISABLED)

            const savedApiKey = await db.findOneBy('api_key', { id: apiKey.id })
            expect(savedApiKey).toBeNull()

            const platform = await db.findOneBy('platform', { id: account.mockPlatform.id })
            expect(platform).not.toBeNull()
        }),

        it('deletes platform, project, user, and connections atomically', async () => {
            if (!isCloud) return

            const account = await mockAndSaveBasicSetup({
                plan: { plan: PlanName.FREE },
            })

            const connection = createMockConnection(
                { projectIds: [account.mockProject.id], platformId: account.mockPlatform.id },
                account.mockOwner.id,
            )
            await databaseConnection().getRepository('app_connection').save([connection])

            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: account.mockOwner.id,
                platform: { id: account.mockPlatform.id },
            })

            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${account.mockPlatform.id}`,
                headers: { authorization: `Bearer ${testToken}` },
            })

            expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)
            await waitForDeletionJobs(deletionJobIds(account.mockPlatform.id))

            const platform = await db.findOneBy('platform', { id: account.mockPlatform.id })
            expect(platform).toBeNull()

            const project = await db.findOneBy('project', { id: account.mockProject.id })
            expect(project).toBeNull()

            const user = await db.findOneBy('user', { id: account.mockOwner.id })
            expect(user).toBeNull()

            const savedConnection = await db.findOneBy('app_connection', { id: connection.id })
            expect(savedConnection).toBeNull()

            const identity = await db.findOneBy('user_identity', { id: account.mockUserIdentity.id })
            expect(identity).toBeNull()
        }),

        it('deletes enabled flows and their related data', async () => {
            if (!isCloud) return

            const account = await mockAndSaveBasicSetup({
                plan: { plan: PlanName.FREE },
            })

            const flowVersionId = apId()
            const enabledFlow = createMockFlow({
                projectId: account.mockProject.id,
                status: FlowStatus.ENABLED,
                publishedVersionId: null,
                operationStatus: FlowOperationStatus.NONE,
            })
            const flowVersion = createMockFlowVersion({
                id: flowVersionId,
                flowId: enabledFlow.id,
            })
            const flowRun = createMockFlowRun({
                projectId: account.mockProject.id,
                flowId: enabledFlow.id,
                flowVersionId: flowVersion.id,
            })

            await databaseConnection().getRepository('flow').save([enabledFlow])
            await databaseConnection().getRepository('flow_version').save([flowVersion])
            await databaseConnection().getRepository('flow').update(enabledFlow.id, { publishedVersionId: flowVersionId })
            await databaseConnection().getRepository('flow_run').save([flowRun])

            const disabledFlow = createMockFlow({
                projectId: account.mockProject.id,
                status: FlowStatus.DISABLED,
                operationStatus: FlowOperationStatus.NONE,
            })
            const disabledFlowVersion = createMockFlowVersion({ flowId: disabledFlow.id })
            await databaseConnection().getRepository('flow').save([disabledFlow])
            await databaseConnection().getRepository('flow_version').save([disabledFlowVersion])

            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: account.mockOwner.id,
                platform: { id: account.mockPlatform.id },
            })

            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${account.mockPlatform.id}`,
                headers: { authorization: `Bearer ${testToken}` },
            })

            expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)
            await waitForDeletionJobs(deletionJobIds(account.mockPlatform.id))

            const savedEnabledFlow = await db.findOneBy('flow', { id: enabledFlow.id })
            expect(savedEnabledFlow).toBeNull()

            const savedDisabledFlow = await db.findOneBy('flow', { id: disabledFlow.id })
            expect(savedDisabledFlow).toBeNull()

            const savedFlowVersion = await db.findOneBy('flow_version', { id: flowVersion.id })
            expect(savedFlowVersion).toBeNull()

            const savedFlowRun = await db.findOneBy('flow_run', { id: flowRun.id })
            expect(savedFlowRun).toBeNull()

            const platform = await db.findOneBy('platform', { id: account.mockPlatform.id })
            expect(platform).toBeNull()

            const project = await db.findOneBy('project', { id: account.mockProject.id })
            expect(project).toBeNull()
        }),

        it('doesn\'t delete user identity if it has other users', async () => {
            if (!isCloud) return
            // arrange
            const firstAccount = await mockAndSaveBasicSetup( {
                plan: {
                    plan: PlanName.FREE,
                },
            })
            const secondPlatform = await mockAndSaveBasicSetup( {
                plan: {
                    plan: PlanName.FREE,
                },
            })
            const secondUser = createMockUser({
                platformId: secondPlatform.mockPlatform.id,
                platformRole: PlatformRole.ADMIN,
                identityId: firstAccount.mockUserIdentity.id,
            })
            await db.save('user', secondUser)
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: firstAccount.mockOwner.id,
                platform: { id: firstAccount.mockPlatform.id },
            })
            // act
            const response = await app?.inject({
                method: 'DELETE',
                url: `/api/v1/platforms/${firstAccount.mockPlatform.id}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
            })
            // assert
            expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)
            await waitForDeletionJobs(deletionJobIds(firstAccount.mockPlatform.id))
            const userIdentityExists = await db.findOneBy('user_identity', { id: firstAccount.mockUserIdentity.id })
            expect(userIdentityExists).not.toBeNull()
        })
    })
    describe('get platform endpoint', () => {
        it('fails if user is not part of the platform', async () => {
            // arrange
            const { mockOwner, mockPlatform } = await mockAndSaveBasicSetup()
            const testToken = await generateMockToken({
                type: PrincipalType.USER,
                id: mockOwner.id,

                platform: { id: mockPlatform.id },
            })
            // act
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/${apId()}`,
                headers: {
                    authorization: `Bearer ${testToken}`,
                },
            })
            // assert
            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
        })
    }),
    it('succeeds if user is part of the platform and is not admin', async () => {
        // arrange
        const { mockPlatform } = await mockAndSaveBasicSetup()
        const { mockUser } = await mockBasicUser({
            user: {
                platformId: mockPlatform.id,
                platformRole: PlatformRole.MEMBER,
            },
        })
        await db.save('user', mockUser)
        const testToken = await generateMockToken({
            type: PrincipalType.USER,
            id: mockUser.id,

            platform: { id: mockPlatform.id },
        })
        // act
        const response = await app?.inject({
            method: 'GET',
            url: `/api/v1/platforms/${mockPlatform.id}`,
            headers: {
                authorization: `Bearer ${testToken}`,
            },
        })
        // assert
        expect(response?.statusCode).toBe(StatusCodes.OK)
    })

    describe('get platform asset endpoint', () => {
        it('serves a public platform asset', async () => {
            // arrange
            const { mockPlatform } = await mockAndSaveBasicSetup()
            const assetData = Buffer.from('public-logo-bytes')
            const assetFile = createMockFile({
                platformId: mockPlatform.id,
                projectId: null,
                type: FileType.PLATFORM_ASSET,
                compression: FileCompression.NONE,
                location: FileLocation.DB,
                data: assetData,
                fileName: 'logo.png',
                metadata: { mimetype: 'image/png' },
            })
            await db.save('file', assetFile)

            // act — public endpoint, no auth
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/assets/${assetFile.id}`,
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(response?.headers['content-type']).toContain('image/png')
            expect(response?.rawPayload.equals(assetData)).toBe(true)
        })

        it('serves a public user profile picture', async () => {
            // arrange
            const { mockPlatform } = await mockAndSaveBasicSetup()
            const pictureData = Buffer.from('user-profile-picture-bytes')
            const pictureFile = createMockFile({
                platformId: mockPlatform.id,
                projectId: null,
                type: FileType.USER_PROFILE_PICTURE,
                compression: FileCompression.NONE,
                location: FileLocation.DB,
                data: pictureData,
                fileName: 'avatar.png',
                metadata: { mimetype: 'image/png' },
            })
            await db.save('file', pictureFile)

            // act — public endpoint, no auth
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/assets/${pictureFile.id}`,
            })

            // assert
            expect(response?.statusCode).toBe(StatusCodes.OK)
            expect(response?.headers['content-type']).toContain('image/png')
            expect(response?.rawPayload.equals(pictureData)).toBe(true)
        })

        it('rejects access to non-PLATFORM_ASSET files (IDOR via public asset endpoint)', async () => {
            // arrange — a sensitive flow run log file stored under a project
            const { mockProject } = await mockAndSaveBasicSetup()
            const sensitiveData = Buffer.from(JSON.stringify({ secret: 'super-secret-api-key' }))
            const sensitiveFile = createMockFile({
                projectId: mockProject.id,
                type: FileType.FLOW_RUN_LOG,
                compression: FileCompression.NONE,
                location: FileLocation.DB,
                data: sensitiveData,
                fileName: 'flow-run.json',
                metadata: { mimetype: 'application/json' },
            })
            await db.save('file', sensitiveFile)

            // act — unauthenticated attacker hits the public asset endpoint
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/assets/${sensitiveFile.id}`,
            })

            // assert — non-asset file types must NOT be served by this endpoint
            expect(response?.statusCode).toBe(StatusCodes.NOT_FOUND)
            expect(response?.rawPayload.includes(sensitiveData)).toBe(false)
        })

        it('returns 404 for unknown asset ids', async () => {
            const response = await app?.inject({
                method: 'GET',
                url: `/api/v1/platforms/assets/${apId()}`,
            })
            expect(response?.statusCode).toBe(StatusCodes.NOT_FOUND)
        })
    })
})