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 { apId, ErrorCode, RoleType } from '@activepieces/core-utils'
import { PlatformRole, PrincipalType, ProjectType } from '@activepieces/shared'
import { FastifyBaseLogger, FastifyInstance } from 'fastify'
import { StatusCodes } from 'http-status-codes'
import { databaseConnection } from '../../../../src/app/database/database-connection'
import { authenticationUtils } from '../../../../src/app/authentication/authentication-utils'
import { userService } from '../../../../src/app/user/user-service'
import { generateMockToken } from '../../../helpers/auth'
import {
createMockPlatform,
createMockProject,
createMockProjectMember,
createMockProjectRole,
createMockUser,
createMockUserIdentity,
mockAndSaveBasicSetup,
} from '../../../helpers/mocks'
import { setupTestEnvironment, teardownTestEnvironment } from '../../../helpers/test-setup'
let app: FastifyInstance | null = null
let mockLog: FastifyBaseLogger
beforeAll(async () => {
app = await setupTestEnvironment()
mockLog = app!.log!
})
afterAll(async () => {
await teardownTestEnvironment()
})
describe('Auto-create personal projects toggle', () => {
it('creates a personal project when autoCreatePersonalProjects is true (default)', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
platform: { autoCreatePersonalProjects: true },
})
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const projectsBefore = await databaseConnection().getRepository('project').count({ where: { platformId: mockPlatform.id, type: ProjectType.PERSONAL } })
await userService(mockLog).getOrCreateWithProject({
identity,
platformId: mockPlatform.id,
})
const projectsAfter = await databaseConnection().getRepository('project').count({ where: { platformId: mockPlatform.id, type: ProjectType.PERSONAL } })
expect(projectsAfter).toBe(projectsBefore + 1)
})
it('skips personal project creation when autoCreatePersonalProjects is false', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
plan: { projectRolesEnabled: true },
platform: { autoCreatePersonalProjects: false },
})
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const projectsBefore = await databaseConnection().getRepository('project').count({ where: { platformId: mockPlatform.id, type: ProjectType.PERSONAL } })
const { user } = await userService(mockLog).getOrCreateWithProject({
identity,
platformId: mockPlatform.id,
})
const projectsAfter = await databaseConnection().getRepository('project').count({ where: { platformId: mockPlatform.id, type: ProjectType.PERSONAL } })
expect(projectsAfter).toBe(projectsBefore)
const userRow = await databaseConnection().getRepository('user').findOneBy({ id: user.id })
expect(userRow).not.toBeNull()
})
it('still creates a personal project when the setting is off but the plan has no project roles', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
platform: { autoCreatePersonalProjects: false },
plan: { projectRolesEnabled: false },
})
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const { user } = await userService(mockLog).getOrCreateWithProject({ identity, platformId: mockPlatform.id })
expect(await databaseConnection().getRepository('project').countBy({ ownerId: user.id, type: ProjectType.PERSONAL })).toBe(1)
const platform = await databaseConnection().getRepository('platform').findOneByOrFail({ id: mockPlatform.id })
expect(platform.autoCreatePersonalProjects).toBe(false)
})
it('applies the saved setting again once the plan has project roles', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
platform: { autoCreatePersonalProjects: false },
plan: { projectRolesEnabled: false },
})
await databaseConnection().getRepository('platform_plan').update({ platformId: mockPlatform.id }, { projectRolesEnabled: true })
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const { user } = await userService(mockLog).getOrCreateWithProject({ identity, platformId: mockPlatform.id })
expect(await databaseConnection().getRepository('project').countBy({ ownerId: user.id, type: ProjectType.PERSONAL })).toBe(0)
})
it('refuses turning personal projects off on a plan without project roles', async () => {
const { mockPlatform, mockOwner } = await mockAndSaveBasicSetup({
plan: { projectRolesEnabled: false },
})
const token = await generateMockToken({ id: mockOwner.id, type: PrincipalType.USER, platform: { id: mockPlatform.id } })
const response = await app?.inject({
method: 'POST',
url: `/api/v1/platforms/${mockPlatform.id}`,
headers: { authorization: `Bearer ${token}` },
body: { autoCreatePersonalProjects: false },
})
expect(response?.statusCode).toBe(StatusCodes.PAYMENT_REQUIRED)
expect(response?.json().code).toBe(ErrorCode.FEATURE_DISABLED)
})
it('accepts an unchanged "off" sent back with other settings on a plan without project roles', async () => {
const { mockPlatform, mockOwner } = await mockAndSaveBasicSetup({
platform: { autoCreatePersonalProjects: false },
plan: { projectRolesEnabled: false },
})
const token = await generateMockToken({ id: mockOwner.id, type: PrincipalType.USER, platform: { id: mockPlatform.id } })
const response = await app?.inject({
method: 'POST',
url: `/api/v1/platforms/${mockPlatform.id}`,
headers: { authorization: `Bearer ${token}` },
body: { name: 'Renamed', autoCreatePersonalProjects: false },
})
expect(response?.statusCode).toBe(StatusCodes.OK)
})
it('always allows turning personal projects on, even without project roles', async () => {
const { mockPlatform, mockOwner } = await mockAndSaveBasicSetup({
platform: { autoCreatePersonalProjects: false },
plan: { projectRolesEnabled: false },
})
const token = await generateMockToken({ id: mockOwner.id, type: PrincipalType.USER, platform: { id: mockPlatform.id } })
const response = await app?.inject({
method: 'POST',
url: `/api/v1/platforms/${mockPlatform.id}`,
headers: { authorization: `Bearer ${token}` },
body: { autoCreatePersonalProjects: true },
})
expect(response?.statusCode).toBe(StatusCodes.OK)
})
it('lands a member on a team project when they have no personal project', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
plan: { projectRolesEnabled: true },
platform: { autoCreatePersonalProjects: false },
})
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const member = createMockUser({
identityId: identity.id,
platformId: mockPlatform.id,
platformRole: PlatformRole.MEMBER,
})
await databaseConnection().getRepository('user').save(member)
const teamProject = createMockProject({
ownerId: mockPlatform.ownerId,
platformId: mockPlatform.id,
type: ProjectType.TEAM,
})
await databaseConnection().getRepository('project').save(teamProject)
const projectRole = createMockProjectRole({
platformId: mockPlatform.id,
type: RoleType.DEFAULT,
})
await databaseConnection().getRepository('project_role').save(projectRole)
const projectMember = createMockProjectMember({
userId: member.id,
projectId: teamProject.id,
platformId: mockPlatform.id,
projectRoleId: projectRole.id,
})
await databaseConnection().getRepository('project_member').save(projectMember)
const response = await authenticationUtils(mockLog).getProjectAndToken({
userId: member.id,
platformId: mockPlatform.id,
projectId: null,
})
expect(response.projectId).toBe(teamProject.id)
expect(response.token).toBeDefined()
})
it('returns projectId: null when the user has zero projects', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup({
plan: { projectRolesEnabled: true },
platform: { autoCreatePersonalProjects: false },
})
const identity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(identity)
const orphanUser = createMockUser({
identityId: identity.id,
platformId: mockPlatform.id,
platformRole: PlatformRole.MEMBER,
})
await databaseConnection().getRepository('user').save(orphanUser)
const response = await authenticationUtils(mockLog).getProjectAndToken({
userId: orphanUser.id,
platformId: mockPlatform.id,
projectId: null,
})
expect(response.projectId).toBeNull()
expect(response.token).toBeDefined()
})
it('allows a platform admin to DELETE a PERSONAL project while its owner is alive', async () => {
const { mockPlatform, mockOwner } = await mockAndSaveBasicSetup()
const personalProject = createMockProject({
ownerId: mockOwner.id,
platformId: mockPlatform.id,
type: ProjectType.PERSONAL,
})
await databaseConnection().getRepository('project').save(personalProject)
const adminToken = await generateMockToken({
id: mockOwner.id,
type: PrincipalType.USER,
platform: { id: mockPlatform.id },
})
const response = await app?.inject({
method: 'DELETE',
url: `/api/v1/projects/${personalProject.id}`,
headers: { authorization: `Bearer ${adminToken}` },
})
expect(response?.statusCode).toBe(StatusCodes.NO_CONTENT)
const ownerRow = await databaseConnection().getRepository('user').findOneBy({ id: mockOwner.id })
expect(ownerRow).not.toBeNull()
})
it('user delete still tears down the personal project', async () => {
const { mockPlatform } = await mockAndSaveBasicSetup()
const memberIdentity = createMockUserIdentity({ verified: true })
await databaseConnection().getRepository('user_identity').save(memberIdentity)
const member = createMockUser({
identityId: memberIdentity.id,
platformId: mockPlatform.id,
platformRole: PlatformRole.MEMBER,
})
await databaseConnection().getRepository('user').save(member)
const personalProject = createMockProject({
id: apId(),
ownerId: member.id,
platformId: mockPlatform.id,
type: ProjectType.PERSONAL,
})
await databaseConnection().getRepository('project').save(personalProject)
await userService(mockLog).delete({
id: member.id,
platformId: mockPlatform.id,
})
const memberAfter = await databaseConnection().getRepository('user').findOneBy({ id: member.id })
expect(memberAfter).toBeNull()
const projectAfter = await databaseConnection().getRepository('project').findOne({ where: { id: personalProject.id }, withDeleted: true })
expect(projectAfter).toBeDefined()
expect(projectAfter?.deleted).not.toBeNull()
})
})