Add Activepieces integration for workflow automation

- Add Activepieces fork with SmoothSchedule custom piece
- Create integrations app with Activepieces service layer
- Add embed token endpoint for iframe integration
- Create Automations page with embedded workflow builder
- Add sidebar visibility fix for embed mode
- Add list inactive customers endpoint to Public API
- Include SmoothSchedule triggers: event created/updated/cancelled
- Include SmoothSchedule actions: create/update/cancel events, list resources/services/customers

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

activepieces-fork/packages/server/api/test/integration/cloud/project-role/project-role.test.ts

@@ -0,0 +1,271 @@
+import { PlatformRole, PrincipalType, ProjectRole, UpdateProjectRoleRequestBody } from '@activepieces/shared'
+import { faker } from '@faker-js/faker'
+import { FastifyInstance } from 'fastify'
+import { StatusCodes } from 'http-status-codes'
+import { initializeDatabase } from '../../../../src/app/database'
+import { databaseConnection } from '../../../../src/app/database/database-connection'
+import { setupServer } from '../../../../src/app/server'
+import { generateMockToken } from '../../../helpers/auth'
+import { createMockProjectRole, mockAndSaveBasicSetup, mockBasicUser } from '../../../helpers/mocks'
+
+let app: FastifyInstance | null = null
+
+beforeAll(async () => {
+    await initializeDatabase({ runMigrations: false })
+    app = await setupServer()
+})
+
+afterAll(async () => {
+    await databaseConnection().destroy()
+    await app?.close()
+})
+
+describe('Project Role API', () => {
+    describe('Create Project Role', () => {
+        it('should create a new project role', async () => {
+            const { mockOwner, mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockOwner.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+            
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+
+            const response = await app?.inject({
+                method: 'POST',
+                url: '/v1/project-roles',
+                body: projectRole,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+            
+            expect(response?.statusCode).toBe(StatusCodes.CREATED)
+            const responseBody = response?.json() as ProjectRole
+            expect(responseBody.id).toBeDefined()
+            expect(responseBody.platformId).toBe(mockPlatform.id)
+            expect(responseBody.name).toBe(projectRole.name)
+            expect(responseBody.permissions).toEqual(projectRole.permissions)
+        })
+
+        it('should fail to create a new project role if user is not platform owner', async () => {
+            const { mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const { mockUser } = await mockBasicUser({
+                user: {
+                    platformId: mockPlatform.id,
+                    platformRole: PlatformRole.MEMBER,
+                },
+            })
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockUser.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+
+            const response = await app?.inject({
+                method: 'POST',
+                url: '/v1/project-roles',
+                body: projectRole,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
+        })
+
+    })
+
+    describe('Get Project Role', () => {
+        it('should get all project roles', async () => {
+            const { mockOwner, mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockOwner.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const response = await app?.inject({
+                method: 'GET',
+                url: '/v1/project-roles',
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.OK)
+        })
+
+        it('should able to get all project roles if user is not platform owner', async () => {
+            const { mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const { mockUser } = await mockBasicUser({
+                user: {
+                    platformId: mockPlatform.id,
+                    platformRole: PlatformRole.MEMBER,
+                },
+            })
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockUser.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const response = await app?.inject({
+                method: 'GET',
+                url: '/v1/project-roles',
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.OK)
+        })
+    })
+
+    describe('Update Project Role', () => {
+        it('should update a project role', async () => {
+            const { mockOwner, mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockOwner.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+            await databaseConnection().getRepository('project_role').save(projectRole)
+
+            const request: UpdateProjectRoleRequestBody = {
+                name: faker.lorem.word(),
+                permissions: ['read', 'write'],
+            }
+
+            const response = await app?.inject({
+                method: 'POST',
+                url: `/v1/project-roles/${projectRole.id}`,
+                body: request,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.OK)
+        })
+
+        it('should fail to update if user is not platform owner', async () => {
+            const { mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const { mockUser } = await mockBasicUser({
+                user: {
+                    platformId: mockPlatform.id,
+                    platformRole: PlatformRole.MEMBER,
+                },
+            })
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockUser.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+            await databaseConnection().getRepository('project_role').save(projectRole)
+
+            const request: UpdateProjectRoleRequestBody = {
+                name: faker.lorem.word(),
+                permissions: ['read', 'write'],
+            }
+
+            const response = await app?.inject({
+                method: 'POST',
+                url: `/v1/project-roles/${projectRole.id}`,
+                body: request,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
+        })
+    })
+
+    describe('Delete Project Role', () => {
+        it('should delete a project role', async () => {
+            const { mockOwner, mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockOwner.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+            await databaseConnection().getRepository('project_role').save(projectRole)
+
+            const response = await app?.inject({
+                method: 'DELETE',
+                url: `/v1/project-roles/${projectRole.name}`,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.OK)
+        })
+
+        it('should fail to delete a project role if user is not platform owner', async () => {
+            const { mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const { mockUser } = await mockBasicUser({
+                user: {
+                    platformId: mockPlatform.id,
+                    platformRole: PlatformRole.MEMBER,
+                },
+            })
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockUser.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const projectRole = createMockProjectRole({ platformId: mockPlatform.id })
+            await databaseConnection().getRepository('project_role').save(projectRole)
+
+            const response = await app?.inject({
+                method: 'DELETE',
+                url: `/v1/project-roles/${projectRole.id}`,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.FORBIDDEN)
+        })
+
+        it('should fail to delete a project role if project role does not exist', async () => {
+            const { mockOwner, mockPlatform, mockProject } = await mockAndSaveBasicSetup()
+            const testToken = await generateMockToken({
+                type: PrincipalType.USER,
+                id: mockOwner.id,
+                projectId: mockProject.id,
+                platform: { id: mockPlatform.id },
+            })
+
+            const response = await app?.inject({
+                method: 'DELETE',
+                url: `/v1/project-roles/${faker.lorem.word()}`,
+                headers: {
+                    authorization: `Bearer ${testToken}`,
+                },
+            })
+
+            expect(response?.statusCode).toBe(StatusCodes.NOT_FOUND)
+        })
+    })
+})