Skip to content

The open alternative to Salesforce, designed for AI.

Make chat threads private records and stop reading object readability (#29379)

Charles Bochete71ed014d2ae
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
index 02b6e945fe4..965aad97042 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
@@ -7,6 +7,7 @@ import { SyncAccessGroupObjectCommand } from 'src/database/commands/upgrade-vers
import { AddAccessGroupStorageColumnsCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command';
import { AddPrivateRecordColumnCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command';
import { MakeRestrictedRecordsPrivateCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793457458179-make-restricted-records-private.command';
+import { MakeChatThreadsPrivateRecordsCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793460623155-make-chat-threads-private-records.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@@ -27,6 +28,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
AddAccessGroupStorageColumnsCommand,
AddPrivateRecordColumnCommand,
MakeRestrictedRecordsPrivateCommand,
+ MakeChatThreadsPrivateRecordsCommand,
],
})
export class V2_55_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793460623155-make-chat-threads-private-records.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793460623155-make-chat-threads-private-records.command.ts
new file mode 100644
index 00000000000..fa726a0f3a6
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793460623155-make-chat-threads-private-records.command.ts
@@ -0,0 +1,130 @@
+import { Command } from 'nest-commander';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+import { type QueryRunner } from 'typeorm';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
+import { isPrivateByDefaultObject } from 'src/engine/permissions/private-record/utils/is-private-by-default-object.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
+import { getWorkspaceSchemaContextForMigration } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/get-workspace-schema-context-for-migration.util';
+
+@RegisteredWorkspaceCommand('2.55.0', 1793460623155)
+@Command({
+ name: 'upgrade:2-55:make-chat-threads-private-records',
+ description: 'Make every chat thread and chat participant a private record',
+})
+export class MakeChatThreadsPrivateRecordsCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ dataSource,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.log(`No data source for workspace ${workspaceId}, skipping`);
+
+ return;
+ }
+
+ const { flatObjectMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ ]);
+
+ const schemaName = getWorkspaceSchemaName(workspaceId);
+ const queryRunner = dataSource.createQueryRunner('master');
+ let isQueryRunnerConnected = false;
+
+ try {
+ await queryRunner.connect();
+ isQueryRunnerConnected = true;
+
+ const tableNamesWithColumn = await this.findTableNamesWithColumn({
+ queryRunner,
+ schemaName,
+ });
+ const chatTables = Object.values(
+ flatObjectMetadataMaps.byUniversalIdentifier,
+ )
+ .filter(isDefined)
+ .filter(isPrivateByDefaultObject)
+ .map((flatObjectMetadata) => ({
+ objectMetadataId: flatObjectMetadata.id,
+ tableName: getWorkspaceSchemaContextForMigration({
+ workspaceId,
+ objectMetadata: flatObjectMetadata,
+ }).tableName,
+ }))
+ .filter(({ tableName }) => tableNamesWithColumn.has(tableName));
+
+ if (!isNonEmptyArray(chatTables)) {
+ return;
+ }
+
+ const buildTableExpression = (tableName: string) =>
+ `${escapeIdentifier(schemaName)}.${escapeIdentifier(tableName)}`;
+
+ const isPrivateColumn = escapeIdentifier(IS_PRIVATE_COLUMN_NAME);
+
+ if (options.dryRun) {
+ const [{ count }] = await queryRunner.query(
+ `SELECT ${chatTables
+ .map(
+ ({ tableName }) =>
+ `(SELECT COUNT(*) FROM ${buildTableExpression(tableName)} WHERE NOT ${isPrivateColumn})`,
+ )
+ .join(' + ')} AS count`,
+ );
+
+ this.logger.log(
+ `[DRY RUN] Would make ${count} chat record(s) private for workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ for (const { tableName } of chatTables) {
+ await queryRunner.query(
+ `UPDATE ${buildTableExpression(tableName)} SET ${isPrivateColumn} = true WHERE NOT ${isPrivateColumn}`,
+ );
+ }
+
+ await queryRunner.query(
+ `DELETE FROM ${buildTableExpression('recordShare')}
+ WHERE "objectMetadataId" = ANY($1::uuid[]) AND "principalType" = 'EVERYONE' AND "rowCause" = 'MANUAL'`,
+ [chatTables.map(({ objectMetadataId }) => objectMetadataId)],
+ );
+ } finally {
+ if (isQueryRunnerConnected) {
+ await queryRunner.release();
+ }
+ }
+ }
+
+ private async findTableNamesWithColumn({
+ queryRunner,
+ schemaName,
+ }: {
+ queryRunner: QueryRunner;
+ schemaName: string;
+ }): Promise<Set<string>> {
+ const columns: { tableName: string }[] = await queryRunner.query(
+ `SELECT table_name AS "tableName" FROM information_schema.columns
+ WHERE table_schema = $1 AND column_name = $2`,
+ [schemaName, IS_PRIVATE_COLUMN_NAME],
+ );
+
+ return new Set(columns.map(({ tableName }) => tableName));
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-inbox.service.open-thread.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-inbox.service.open-thread.spec.ts
deleted file mode 100644
index 513a950e5ca..00000000000
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/__tests__/agent-inbox.service.open-thread.spec.ts
+++ /dev/null
@@ -1,295 +0,0 @@
-import { QueryFailedError } from 'typeorm';
-
-import { AgentInboxService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service';
-import { buildInboxThreadId } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-inbox-thread-id.util';
-import {
- AiException,
- AiExceptionCode,
-} from 'src/engine/metadata-modules/ai/ai.exception';
-
-const SENDER = {
- type: 'workflow' as const,
- workflowId: 'workflow-id',
- workflowName: 'New deals',
-};
-
-const OPEN_ARGS = {
- workspaceId: 'workspace-id',
- sender: SENDER,
- threadKey: 'run-id',
- title: 'Draft the quote',
-};
-
-const buildUniqueViolation = () =>
- Object.assign(new QueryFailedError('INSERT', [], new Error('duplicate')), {
- code: '23505',
- });
-
-const buildService = () => {
- const threadRepository = {
- findOne: jest.fn().mockResolvedValue(null),
- findOneOrFail: jest
- .fn()
- .mockImplementation(
- (_workspaceId: string, { where }: { where: { id: string } }) =>
- Promise.resolve({ id: where.id, workspaceMemberId: null }),
- ),
- insert: jest.fn().mockResolvedValue(undefined),
- };
- const threadService = {
- createThread: jest
- .fn()
- .mockImplementation(({ id, workspaceMemberId }) =>
- Promise.resolve({ id, workspaceMemberId }),
- ),
- deliverToParticipants: jest
- .fn()
- .mockImplementation(({ participantWorkspaceMemberIds }) =>
- Promise.resolve(participantWorkspaceMemberIds),
- ),
- };
- const sharingService = {
- getAuthContext: jest.fn().mockResolvedValue({}),
- };
- const messageRepository = {
- findOne: jest.fn().mockResolvedValue(null),
- };
-
- const service = new AgentInboxService(
- threadRepository as never,
- messageRepository as never,
- {} as never,
- threadService as never,
- sharingService as never,
- {} as never,
- {} as never,
- );
-
- return {
- service,
- threadRepository,
- threadService,
- sharingService,
- messageRepository,
- };
-};
-
-const THREAD_ID = buildInboxThreadId({
- senderKey: 'workflow:workflow-id',
- threadKey: 'run-id',
-});
-
-describe('AgentInboxService.openThread', () => {
- it('continues the conversation the sender already has under that key', async () => {
- const { service, threadRepository, threadService } = buildService();
- const existingThread = {
- id: 'existing-thread-id',
- workspaceMemberId: 'member-id',
- };
-
- threadRepository.findOne.mockResolvedValue(existingThread);
-
- await expect(
- service.openThread({ ...OPEN_ARGS, workspaceMemberIds: ['member-id'] }),
- ).resolves.toEqual({ thread: existingThread, isCreated: false });
- expect(threadService.createThread).not.toHaveBeenCalled();
- expect(threadService.deliverToParticipants).not.toHaveBeenCalled();
- });
-
- it('creates the conversation owned by the first member and adds the others', async () => {
- const { service, threadService } = buildService();
-
- const { thread, isCreated } = await service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: ['member-id', 'other-member-id'],
- isArchivedOnCreate: true,
- });
-
- expect(isCreated).toBe(true);
- expect(thread.id).toBe(THREAD_ID);
- expect(threadService.createThread).toHaveBeenCalledWith({
- workspaceId: 'workspace-id',
- workspaceMemberId: 'member-id',
- id: THREAD_ID,
- title: 'Draft the quote',
- isArchived: true,
- });
- expect(threadService.deliverToParticipants).toHaveBeenCalledWith({
- workspaceId: 'workspace-id',
- threadId: THREAD_ID,
- workspaceMemberId: 'member-id',
- participantWorkspaceMemberIds: ['other-member-id'],
- });
- });
-
- it('adds only the members the conversation does not have yet', async () => {
- const { service, threadRepository, threadService, sharingService } =
- buildService();
-
- threadRepository.findOne.mockResolvedValue({
- id: THREAD_ID,
- workspaceMemberId: 'member-id',
- writerWorkspaceMemberIds: ['second-member-id'],
- });
-
- await service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: [
- 'member-id',
- 'second-member-id',
- 'third-member-id',
- 'third-member-id',
- ],
- });
-
- expect(threadService.deliverToParticipants).toHaveBeenCalledWith(
- expect.objectContaining({
- participantWorkspaceMemberIds: ['third-member-id'],
- }),
- );
- expect(sharingService.getAuthContext).toHaveBeenCalledTimes(1);
- expect(sharingService.getAuthContext).toHaveBeenCalledWith({
- workspaceId: 'workspace-id',
- workspaceMemberId: 'third-member-id',
- });
- });
-
- it('neither creates nor shares the conversation when a member cannot have it', async () => {
- const { service, threadService, sharingService } = buildService();
-
- sharingService.getAuthContext.mockImplementation(
- ({ workspaceMemberId }: { workspaceMemberId: string }) =>
- workspaceMemberId === 'invalid-member-id'
- ? Promise.reject(
- new AiException(
- 'Thread not found',
- AiExceptionCode.THREAD_NOT_FOUND,
- ),
- )
- : Promise.resolve({}),
- );
-
- await expect(
- service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: ['member-id', 'invalid-member-id'],
- }),
- ).rejects.toMatchObject({ code: AiExceptionCode.THREAD_NOT_FOUND });
- expect(threadService.createThread).not.toHaveBeenCalled();
- expect(threadService.deliverToParticipants).not.toHaveBeenCalled();
- });
-
- it('fails when a member cannot join the conversation', async () => {
- const { service, threadService } = buildService();
-
- threadService.deliverToParticipants.mockResolvedValue([]);
-
- await expect(
- service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: ['member-id', 'other-member-id'],
- }),
- ).rejects.toMatchObject({ code: AiExceptionCode.THREAD_NOT_FOUND });
- });
-
- it('keeps a conversation with no member out of every inbox, under the same key', async () => {
- const { service, threadRepository, threadService } = buildService();
-
- const { thread, isCreated } = await service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: [],
- });
-
- expect(isCreated).toBe(true);
- expect(thread.id).toBe(THREAD_ID);
- expect(threadService.createThread).not.toHaveBeenCalled();
- expect(threadRepository.insert).toHaveBeenCalledWith('workspace-id', {
- id: THREAD_ID,
- title: 'Draft the quote',
- });
- });
-
- it('refuses to give members a conversation no inbox receives', async () => {
- const { service, threadRepository, threadService } = buildService();
-
- threadRepository.findOne.mockResolvedValue({
- id: THREAD_ID,
- workspaceMemberId: null,
- });
-
- await expect(
- service.openThread({ ...OPEN_ARGS, workspaceMemberIds: ['member-id'] }),
- ).rejects.toMatchObject({ code: AiExceptionCode.THREAD_NOT_FOUND });
- expect(threadService.deliverToParticipants).not.toHaveBeenCalled();
- });
-
- it('returns a deleted conversation without adding anyone to it', async () => {
- const { service, threadRepository, threadService } = buildService();
- const deletedThread = {
- id: THREAD_ID,
- workspaceMemberId: 'member-id',
- deletedAt: '2026-01-01',
- };
-
- threadRepository.findOne.mockResolvedValue(deletedThread);
-
- await expect(
- service.openThread({
- ...OPEN_ARGS,
- workspaceMemberIds: ['member-id', 'other-member-id'],
- }),
- ).resolves.toEqual({ thread: deletedThread, isCreated: false });
- expect(threadService.deliverToParticipants).not.toHaveBeenCalled();
- });
-
- it('returns the conversation a concurrent open created first', async () => {
- const { service, threadRepository, threadService } = buildService();
- const concurrentThread = {
- id: 'concurrent-thread-id',
- workspaceMemberId: 'member-id',
- };
-
- threadService.createThread.mockRejectedValue(buildUniqueViolation());
- threadRepository.findOne
- .mockResolvedValueOnce(null)
- .mockResolvedValueOnce(concurrentThread);
-
- await expect(
- service.openThread({ ...OPEN_ARGS, workspaceMemberIds: ['member-id'] }),
- ).resolves.toEqual({ thread: concurrentThread, isCreated: false });
- });
-});
-
-describe('AgentInboxService.sendMessage', () => {
- it('adds the members a repeated message lists without writing it again', async () => {
- const { service, threadRepository, threadService, messageRepository } =
- buildService();
-
- threadRepository.findOne.mockResolvedValue({
- id: THREAD_ID,
- workspaceMemberId: 'member-id',
- });
- messageRepository.findOne.mockResolvedValue({ id: 'message-id' });
-
- await expect(
- service.sendMessage({
- workspaceId: 'workspace-id',
- sender: SENDER,
- input: {
- workspaceMemberIds: ['member-id', 'other-member-id'],
- threadKey: 'run-id',
- idempotencyKey: 'step-id',
- title: 'Draft the quote',
- text: 'Here is the quote',
- },
- }),
- ).resolves.toMatchObject({ threadId: THREAD_ID, isDismissed: false });
- expect(threadService.createThread).not.toHaveBeenCalled();
- expect(threadService.deliverToParticipants).toHaveBeenCalledWith(
- expect.objectContaining({
- threadId: THREAD_ID,
- participantWorkspaceMemberIds: ['other-member-id'],
- }),
- );
- });
-});
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts
index c6affa18194..5af2221e717 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-sharing.service.ts
@@ -1,4 +1,9 @@
import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import {
+ buildPrivateRecordInsertSql,
+ type PrivateRecordInsertSql,
+} from 'src/engine/permissions/private-record/utils/build-private-record-insert-sql.util';
+import { isPrivateRecordEnabled } from 'src/engine/permissions/private-record/utils/is-private-record-enabled.util';
import { AgentChatChannelGrantService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-channel-grant.service';
import { AuthException } from 'src/engine/core-modules/auth/auth.exception';
import { randomUUID } from 'node:crypto';
@@ -374,6 +379,19 @@ export class AgentChatSharingService {
}, authContext);
}
+ async getPrivateRecordInsertSql(
+ workspaceId: string,
+ ): Promise<PrivateRecordInsertSql> {
+ const { featureFlagsMap } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['featureFlagsMap'],
+ );
+
+ return buildPrivateRecordInsertSql({
+ isPrivateRecordEnabled: isPrivateRecordEnabled(featureFlagsMap),
+ });
+ }
+
async createThread(args: {
workspaceId: string;
workspaceMemberId: string;
@@ -394,6 +412,8 @@ export class AgentChatSharingService {
authContext,
updatedColumns: isDefined(args.title) ? ['title'] : [],
});
+ const { privateColumn, privateValue } =
+ await this.getPrivateRecordInsertSql(args.workspaceId);
return this.threadRepository.query(
args.workspaceId,
@@ -411,8 +431,8 @@ export class AgentChatSharingService {
channelIds: [args.channelId],
});
const records = await manager.query<AgentChatThreadWorkspaceEntity[]>(
- `INSERT INTO ${table('agentChatThread')} (id, title, "workspaceMemberId"${isDefined(args.channelId) ? ', "channelId"' : ''})
- VALUES ($1, $2, $3${isDefined(args.channelId) ? ', $4' : ''}) RETURNING *`,
+ `INSERT INTO ${table('agentChatThread')} (id, title, "workspaceMemberId"${privateColumn}${isDefined(args.channelId) ? ', "channelId"' : ''})
+ VALUES ($1, $2, $3${privateValue}${isDefined(args.channelId) ? ', $4' : ''}) RETURNING *`,
[
args.id ?? randomUUID(),
args.title ?? null,
@@ -494,6 +514,8 @@ export class AgentChatSharingService {
const participantObjectMetadataId =
await this.getParticipantObjectMetadataId(args.workspaceId);
+ const { privateColumn, privateValue } =
+ await this.getPrivateRecordInsertSql(args.workspaceId);
return this.threadRepository.query(
args.workspaceId,
@@ -536,8 +558,8 @@ export class AgentChatSharingService {
}
await manager.query(
`WITH participant AS (
- INSERT INTO ${getAgentChatThreadParticipantTable(args.workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "isSubscribed")
- VALUES ($1, $2, clock_timestamp(), false)
+ INSERT INTO ${getAgentChatThreadParticipantTable(args.workspaceId)} ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt", "isSubscribed")
+ VALUES ($1, $2${privateValue}, clock_timestamp(), false)
ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING
RETURNING id, "workspaceMemberId"
), owner_share AS (
@@ -580,6 +602,9 @@ export class AgentChatSharingService {
isArchived?: boolean;
isSubscribed?: boolean;
}): Promise<AgentChatThreadWorkspaceEntity[]> {
+ const { privateColumn, privateValue } =
+ await this.getPrivateRecordInsertSql(workspaceId);
+
return manager.query<AgentChatThreadWorkspaceEntity[]>(
`WITH thread AS (
UPDATE ${table('agentChatThread')}
@@ -587,8 +612,8 @@ export class AgentChatSharingService {
WHERE id = ANY($1::uuid[]) AND "lastActivityAt" IS NULL
RETURNING *
), participant AS (
- INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt", "archivedAt", "isSubscribed")
- SELECT thread.id, $2, thread."lastActivityAt", CASE WHEN $4::boolean THEN clock_timestamp() END, $5::boolean
+ INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt", "archivedAt", "isSubscribed")
+ SELECT thread.id, $2${privateValue}, thread."lastActivityAt", CASE WHEN $4::boolean THEN clock_timestamp() END, $5::boolean
FROM thread
ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING
RETURNING id, "workspaceMemberId"
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-participant.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-participant.service.ts
index c9d8953eb15..0f2275e4c90 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-participant.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-chat-thread-participant.service.ts
@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
import { type EntityManager } from 'typeorm';
+import { type PrivateRecordInsertSql } from 'src/engine/permissions/private-record/utils/build-private-record-insert-sql.util';
import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
@@ -41,10 +42,12 @@ import {
} from 'src/engine/permissions/permissions.exception';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
-type BuildParticipantWriteQuery = (tables: {
- participantTable: string;
- threadTable: string;
-}) => string;
+type BuildParticipantWriteQuery = (
+ tables: {
+ participantTable: string;
+ threadTable: string;
+ } & PrivateRecordInsertSql,
+) => string;
const NEXT_PARTICIPANT_UPDATED_AT = `GREATEST(clock_timestamp(), participant."updatedAt" + interval '1 millisecond')`;
@@ -56,9 +59,13 @@ const PARTICIPANT_LOCK_QUERY =
'SELECT pg_advisory_xact_lock(hashtextextended($1, 0))';
// Saved as ended when already due, since its queued end may have run before this write
-const buildSnoozeQuery: BuildParticipantWriteQuery = ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "archivedAt", "snoozedUntil", "isSubscribed")
- VALUES ($1, $2, CASE WHEN $3::timestamptz <= clock_timestamp() THEN NULL ELSE clock_timestamp() END, $3, true)
+const buildSnoozeQuery: BuildParticipantWriteQuery = ({
+ participantTable,
+ privateColumn,
+ privateValue,
+}) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "archivedAt", "snoozedUntil", "isSubscribed")
+ VALUES ($1, $2${privateValue}, CASE WHEN $3::timestamptz <= clock_timestamp() THEN NULL ELSE clock_timestamp() END, $3, true)
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"archivedAt" = EXCLUDED."archivedAt",
"snoozedUntil" = EXCLUDED."snoozedUntil",
@@ -84,24 +91,37 @@ const INBOX_ACTION_QUERIES: Record<
> = {
// Read up to what the thread holds now, never past it, and never back.
// Reading or marking unread tracks a chat without following it
- [AgentChatInboxAction.READ]: ({ participantTable, threadTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "lastReadAt", "isSubscribed")
- SELECT thread.id, $2, thread."lastActivityAt", false FROM ${threadTable} thread WHERE thread.id = $1
+ [AgentChatInboxAction.READ]: ({
+ participantTable,
+ threadTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt", "isSubscribed")
+ SELECT thread.id, $2${privateValue}, thread."lastActivityAt", false FROM ${threadTable} thread WHERE thread.id = $1
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = GREATEST(participant."lastReadAt", EXCLUDED."lastReadAt"),
"mentionsResolvedAt" = ${ALL_MENTIONS_RESOLVED_AT},
"updatedAt" = ${NEXT_PARTICIPANT_UPDATED_AT}
RETURNING *`,
- [AgentChatInboxAction.UNREAD]: ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "lastReadAt", "isSubscribed")
- VALUES ($1, $2, NULL, false)
+ [AgentChatInboxAction.UNREAD]: ({
+ participantTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt", "isSubscribed")
+ VALUES ($1, $2${privateValue}, NULL, false)
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = NULL,
"updatedAt" = ${NEXT_PARTICIPANT_UPDATED_AT}
RETURNING *`,
- [AgentChatInboxAction.ARCHIVE]: ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "archivedAt", "isSubscribed")
- VALUES ($1, $2, clock_timestamp(), true)
+ [AgentChatInboxAction.ARCHIVE]: ({
+ participantTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "archivedAt", "isSubscribed")
+ VALUES ($1, $2${privateValue}, clock_timestamp(), true)
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"archivedAt" = EXCLUDED."archivedAt",
"snoozedUntil" = NULL,
@@ -110,27 +130,39 @@ const INBOX_ACTION_QUERIES: Record<
"updatedAt" = ${NEXT_PARTICIPANT_UPDATED_AT}
RETURNING *`,
[AgentChatInboxAction.SNOOZE]: buildSnoozeQuery,
- [AgentChatInboxAction.MOVE_TO_INBOX]: ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId")
- VALUES ($1, $2)
+ [AgentChatInboxAction.MOVE_TO_INBOX]: ({
+ participantTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn})
+ VALUES ($1, $2${privateValue})
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"archivedAt" = NULL,
"snoozedUntil" = NULL,
"isSubscribed" = true,
"updatedAt" = ${NEXT_PARTICIPANT_UPDATED_AT}
RETURNING *`,
- [AgentChatInboxAction.SUBSCRIBE]: ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId")
- VALUES ($1, $2)
+ [AgentChatInboxAction.SUBSCRIBE]: ({
+ participantTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn})
+ VALUES ($1, $2${privateValue})
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"isSubscribed" = true,
"updatedAt" = ${NEXT_PARTICIPANT_UPDATED_AT}
RETURNING *`,
// Files the chat under done and keeps it there whatever happens in it,
// until the member is mentioned or writes in it again
- [AgentChatInboxAction.UNSUBSCRIBE]: ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "isSubscribed", "archivedAt")
- VALUES ($1, $2, false, clock_timestamp())
+ [AgentChatInboxAction.UNSUBSCRIBE]: ({
+ participantTable,
+ privateColumn,
+ privateValue,
+ }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "isSubscribed", "archivedAt")
+ VALUES ($1, $2${privateValue}, false, clock_timestamp())
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"isSubscribed" = false,
"archivedAt" = EXCLUDED."archivedAt",
@@ -248,9 +280,9 @@ export class AgentChatThreadParticipantService {
}: AgentChatThreadAccessArgs): Promise<void> {
await this.write(
{ ...args, threadIds: [threadId] },
- ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "lastMentionedAt")
- VALUES ($1, $2, clock_timestamp())
+ ({ participantTable, privateColumn, privateValue }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "lastMentionedAt")
+ VALUES ($1, $2${privateValue}, clock_timestamp())
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = NULL,
"archivedAt" = NULL,
@@ -269,9 +301,9 @@ export class AgentChatThreadParticipantService {
async deliverToInbox(args: AgentChatThreadAccessArgs): Promise<void> {
await this.write(
{ ...args, threadIds: [args.threadId] },
- ({ participantTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId")
- VALUES ($1, $2)
+ ({ participantTable, privateColumn, privateValue }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn})
+ VALUES ($1, $2${privateValue})
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = NULL,
"archivedAt" = NULL,
@@ -332,9 +364,9 @@ export class AgentChatThreadParticipantService {
}): Promise<void> {
await this.write(
{ ...args, threadIds: [threadId] },
- ({ participantTable, threadTable }) =>
- `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "lastReadAt")
- SELECT thread.id, $2, CASE WHEN $3::boolean THEN thread."lastActivityAt" END
+ ({ participantTable, threadTable, privateColumn, privateValue }) =>
+ `INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt")
+ SELECT thread.id, $2${privateValue}, CASE WHEN $3::boolean THEN thread."lastActivityAt" END
FROM ${threadTable} thread WHERE thread.id = $1
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = CASE WHEN $3::boolean THEN participant."lastReadAt" END,
@@ -449,6 +481,8 @@ export class AgentChatThreadParticipantService {
const participantTable = getAgentChatThreadParticipantTable(workspaceId);
const participantObjectMetadataId =
await this.sharingService.getParticipantObjectMetadataId(workspaceId);
+ const { privateColumn, privateValue } =
+ await this.sharingService.getPrivateRecordInsertSql(workspaceId);
const { rows, before, after } = await this.threadRepository.query(
workspaceId,
@@ -473,8 +507,8 @@ export class AgentChatThreadParticipantService {
WHERE id = $1
RETURNING id, ${AGENT_CHAT_THREAD_ACTIVITY_COLUMNS}
), participant AS (
- INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId", "lastReadAt")
- SELECT thread.id, $2, thread."lastActivityAt" FROM thread
+ INSERT INTO ${participantTable} AS participant ("threadId", "workspaceMemberId"${privateColumn}, "lastReadAt")
+ SELECT thread.id, $2${privateValue}, thread."lastActivityAt" FROM thread
ON CONFLICT ("threadId", "workspaceMemberId") DO UPDATE SET
"lastReadAt" = GREATEST(participant."lastReadAt", EXCLUDED."lastReadAt"),
"archivedAt" = NULL,
@@ -707,6 +741,8 @@ export class AgentChatThreadParticipantService {
): Promise<AgentChatThreadParticipantRow[]> {
const objectMetadataId =
await this.sharingService.getParticipantObjectMetadataId(workspaceId);
+ const privateRecordInsertSql =
+ await this.sharingService.getPrivateRecordInsertSql(workspaceId);
const writes = await this.threadRepository.query(
workspaceId,
@@ -717,6 +753,7 @@ export class AgentChatThreadParticipantService {
participantTable:
getAgentChatThreadParticipantTable(workspaceId),
threadTable: table('agentChatThread'),
+ ...privateRecordInsertSql,
})}
), owner_share AS (
${buildAgentChatThreadParticipantOwnerShareInsert({
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
index 288d6b36346..8f651e4d9a3 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/services/agent-inbox.service.ts
@@ -416,7 +416,15 @@ export class AgentInboxService {
threadId: string;
title: string;
}): Promise<AgentChatThreadWorkspaceEntity> {
- await this.threadRepository.insert(workspaceId, { id: threadId, title });
+ const { privateColumn, privateValue } =
+ await this.sharingService.getPrivateRecordInsertSql(workspaceId);
+
+ await this.threadRepository.query(workspaceId, ({ manager, table }) =>
+ manager.query(
+ `INSERT INTO ${table('agentChatThread')} (id, title${privateColumn}) VALUES ($1, $2${privateValue})`,
+ [threadId, title],
+ ),
+ );
return this.threadRepository.findOneOrFail(workspaceId, {
where: { id: threadId },
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/constants/updatable-object-readabilities.constant.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/constants/updatable-object-readabilities.constant.ts
index 0bb0052ddcf..40fea615999 100644
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/constants/updatable-object-readabilities.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/constants/updatable-object-readabilities.constant.ts
@@ -4,5 +4,4 @@ import { MetadataReadability } from 'twenty-shared/types';
// needs parent fields this API cannot set yet, so those stay manifest-only
export const UPDATABLE_OBJECT_READABILITIES = [
MetadataReadability.OPEN,
- MetadataReadability.PRIVATE,
] as const;
diff --git a/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/build-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/build-row-access-policy.util.spec.ts
index d4ffb2367f9..958a9ed0976 100644
--- a/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/build-row-access-policy.util.spec.ts
+++ b/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/build-row-access-policy.util.spec.ts
@@ -1,8 +1,8 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
import {
FeatureFlagKey,
FieldMetadataType,
- MetadataReadability,
RecordShareAccessLevel,
} from 'twenty-shared/types';
@@ -41,7 +41,7 @@ const buildObject = ({ id }: { id: string }): FlatObjectMetadata =>
const note = buildObject({ id: 'note' });
const person: FlatObjectMetadata = {
...buildObject({ id: 'person' }),
- readability: MetadataReadability.PRIVATE,
+ universalIdentifier: STANDARD_OBJECTS.agentChatThread.universalIdentifier,
};
const environment: RowAccessPolicyEnvironment &
diff --git a/packages/twenty-server/src/engine/permissions/private-record/constants/private-by-default-object-universal-identifiers.constant.ts b/packages/twenty-server/src/engine/permissions/private-record/constants/private-by-default-object-universal-identifiers.constant.ts
new file mode 100644
index 00000000000..fe13fb560d7
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/constants/private-by-default-object-universal-identifiers.constant.ts
@@ -0,0 +1,8 @@
+/* @license Enterprise */
+
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+export const PRIVATE_BY_DEFAULT_OBJECT_UNIVERSAL_IDENTIFIERS: string[] = [
+ STANDARD_OBJECTS.agentChatThread.universalIdentifier,
+ STANDARD_OBJECTS.agentChatThreadParticipant.universalIdentifier,
+];
diff --git a/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-insert-sql.util.ts b/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-insert-sql.util.ts
new file mode 100644
index 00000000000..bc55e4c2fce
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-insert-sql.util.ts
@@ -0,0 +1,17 @@
+/* @license Enterprise */
+
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
+
+export type PrivateRecordInsertSql = {
+ privateColumn: string;
+ privateValue: string;
+};
+
+export const buildPrivateRecordInsertSql = ({
+ isPrivateRecordEnabled,
+}: {
+ isPrivateRecordEnabled: boolean;
+}): PrivateRecordInsertSql =>
+ isPrivateRecordEnabled
+ ? { privateColumn: `, "${IS_PRIVATE_COLUMN_NAME}"`, privateValue: ', true' }
+ : { privateColumn: '', privateValue: '' };
diff --git a/packages/twenty-server/src/engine/permissions/private-record/utils/is-private-by-default-object.util.ts b/packages/twenty-server/src/engine/permissions/private-record/utils/is-private-by-default-object.util.ts
new file mode 100644
index 00000000000..92d1efaaac5
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/utils/is-private-by-default-object.util.ts
@@ -0,0 +1,11 @@
+/* @license Enterprise */
+
+import { PRIVATE_BY_DEFAULT_OBJECT_UNIVERSAL_IDENTIFIERS } from 'src/engine/permissions/private-record/constants/private-by-default-object-universal-identifiers.constant';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export const isPrivateByDefaultObject = (
+ objectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>,
+): boolean =>
+ PRIVATE_BY_DEFAULT_OBJECT_UNIVERSAL_IDENTIFIERS.includes(
+ objectMetadata.universalIdentifier,
+ );
diff --git a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-ownership-transfer.service.ts b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-ownership-transfer.service.ts
index 366b0f02564..713b8dbd01a 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-ownership-transfer.service.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-ownership-transfer.service.ts
@@ -77,14 +77,14 @@ export class RecordShareOwnershipTransferService {
.filter(isDefined)
// Rows written while sharing was enabled still need a custodian
.filter((flatObjectMetadata) => {
- const { isShareable, isShareRequired } = resolveObjectSharing({
+ const { isShareable, isPrivateByDefault } = resolveObjectSharing({
flatObjectMetadata,
featureFlagsMap: {
[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED]: true,
},
});
- return isShareable && !isShareRequired;
+ return isShareable && !isPrivateByDefault;
})
);
}
diff --git a/packages/twenty-server/src/engine/permissions/record-share/services/record-sharing.service.ts b/packages/twenty-server/src/engine/permissions/record-share/services/record-sharing.service.ts
index 248cde03ea6..5a2e5a4e894 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/services/record-sharing.service.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/services/record-sharing.service.ts
@@ -268,6 +268,7 @@ export class RecordSharingService {
sharingObject: {
flatObjectMetadata,
isShareRequired,
+ isPrivateByDefault,
defaultGeneralAccessLevel,
},
creatorWorkspaceMemberId,
@@ -293,7 +294,10 @@ export class RecordSharingService {
return;
}
- if (args.accessLevel === RecordShareAccessLevel.READ) {
+ if (
+ args.accessLevel === RecordShareAccessLevel.READ ||
+ (isPrivateByDefault && args.accessLevel !== RecordShareAccessLevel.NONE)
+ ) {
throw new RecordShareException(
'A record is either private or follows the roles of its object',
RecordShareExceptionCode.INVALID_SHARE_WITH,
@@ -328,6 +332,19 @@ export class RecordSharingService {
return;
}
+ await this.recordShareStorageService.deleteMatching({
+ workspaceId,
+ transactionScope,
+ criteria: [
+ {
+ objectMetadataId: args.objectMetadataId,
+ recordId: args.recordId,
+ principalType: RecordSharePrincipalType.EVERYONE,
+ rowCause: RecordShareRowCause.MANUAL,
+ },
+ ],
+ });
+
if (args.authContext.workspaceMemberId === creatorWorkspaceMemberId) {
return;
}
diff --git a/packages/twenty-server/src/engine/permissions/record-share/services/share-with.service.ts b/packages/twenty-server/src/engine/permissions/record-share/services/share-with.service.ts
index a12f4a2f155..d7fc3a5b4a2 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/services/share-with.service.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/services/share-with.service.ts
@@ -93,6 +93,7 @@ export class ShareWithService {
apiKeyRoleMap,
shareWith,
isShareRequired: objectSharing.isShareRequired,
+ isPrivateByDefault: objectSharing.isPrivateByDefault,
isPrivate,
}),
transactionScope,
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
index d5a7190db90..aa6f48ee46f 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
@@ -55,6 +55,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
authContext: userAuthContext,
apiKeyRoleMap,
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -94,6 +95,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
},
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -130,6 +132,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.READ },
],
isShareRequired: false,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -154,6 +157,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
apiKeyRoleMap,
shareWith: [],
isShareRequired: false,
+ isPrivateByDefault: false,
isPrivate: true,
}),
).toEqual([]);
@@ -168,6 +172,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
apiKeyRoleMap,
shareWith: [],
isShareRequired: false,
+ isPrivateByDefault: false,
isPrivate: true,
}),
).toEqual([
@@ -194,6 +199,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -229,6 +235,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -250,6 +257,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.FULL },
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -288,6 +296,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
},
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -317,6 +326,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.FULL },
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([expect.objectContaining({ principalId: ROLE_ID })]);
@@ -333,6 +343,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -359,6 +370,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
apiKeyRoleMap,
shareWith: null,
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -377,6 +389,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
authContext: apiKeyAuthContext,
apiKeyRoleMap,
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
@@ -402,6 +415,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
apiKeyRoleMap,
shareWith: [],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([]);
@@ -421,6 +435,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
},
],
isShareRequired: true,
+ isPrivateByDefault: false,
isPrivate: false,
}),
).toEqual([
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-created-record-sharing-or-throw.util.spec.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-created-record-sharing-or-throw.util.spec.ts
index ee7196f1c7f..4264f22fd28 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-created-record-sharing-or-throw.util.spec.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-created-record-sharing-or-throw.util.spec.ts
@@ -23,16 +23,23 @@ const EVERYONE_AT_DEFAULT = {
const SHARE_REQUIRED_OBJECT = {
isShareable: true,
isShareRequired: true,
+ isPrivateByDefault: true,
defaultGeneralAccessLevel: RecordShareAccessLevel.NONE,
};
const SHAREABLE_OBJECT = {
isShareable: true,
isShareRequired: false,
+ isPrivateByDefault: false,
defaultGeneralAccessLevel: RecordShareAccessLevel.READ_WRITE,
};
+const PRIVATE_BY_DEFAULT_OBJECT = {
+ ...SHAREABLE_OBJECT,
+ isPrivateByDefault: true,
+};
const ROLE_ONLY_OBJECT = {
isShareable: false,
isShareRequired: false,
+ isPrivateByDefault: false,
defaultGeneralAccessLevel: null,
};
@@ -116,4 +123,19 @@ describe('resolveCreatedRecordSharingOrThrow', () => {
}),
).toBeNull();
});
+
+ it('should always create a record of a private-by-default object private', () => {
+ expect(
+ resolveCreatedRecordSharingOrThrow({
+ objectSharing: PRIVATE_BY_DEFAULT_OBJECT,
+ shareWith: [ROLE_GRANT],
+ }),
+ ).toEqual({ shareWith: [ROLE_GRANT], isPrivate: true });
+ expect(
+ resolveCreatedRecordSharingOrThrow({
+ objectSharing: PRIVATE_BY_DEFAULT_OBJECT,
+ shareWith: [EVERYONE_AT_DEFAULT],
+ }),
+ ).toEqual({ shareWith: [], isPrivate: true });
+ });
});
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-object-sharing.util.spec.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-object-sharing.util.spec.ts
index be7300fe9e4..aa917f1e2d1 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-object-sharing.util.spec.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/__tests__/resolve-object-sharing.util.spec.ts
@@ -1,32 +1,33 @@
/* @license Enterprise */
-import {
- FeatureFlagKey,
- MetadataReadability,
- RecordShareAccessLevel,
-} from 'twenty-shared/types';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { FeatureFlagKey, RecordShareAccessLevel } from 'twenty-shared/types';
import { resolveObjectSharing } from 'src/engine/permissions/record-share/utils/resolve-object-sharing.util';
const OBJECT = {
- readability: MetadataReadability.OPEN,
+ universalIdentifier: 'custom-object',
isSystem: false,
disabledObjectPermissionActions: null,
};
const OPEN_BY_DEFAULT = {
isShareable: true,
isShareRequired: false,
+ isPrivateByDefault: false,
defaultGeneralAccessLevel: RecordShareAccessLevel.READ_WRITE,
};
const ROLE_ONLY = {
isShareable: false,
isShareRequired: false,
+ isPrivateByDefault: false,
defaultGeneralAccessLevel: null,
};
-const PRIVATE = {
- isShareable: true,
- isShareRequired: true,
- defaultGeneralAccessLevel: RecordShareAccessLevel.NONE,
+const CHAT_THREAD = {
+ ...OBJECT,
+ universalIdentifier: STANDARD_OBJECTS.agentChatThread.universalIdentifier,
+};
+const PRIVATE_CHAT_THREAD = {
+ [FeatureFlagKey.IS_PRIVATE_RECORD_ENABLED]: true,
};
const RECORD_SHARING = {
[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED]: true,
@@ -95,42 +96,35 @@ describe('resolveObjectSharing', () => {
});
});
- it.each([
- { isSystem: false, featureFlagsMap: {} },
- { isSystem: true, featureFlagsMap: RECORD_SHARING },
- ])(
- 'should keep private records private for %o',
- ({ isSystem, featureFlagsMap }) => {
- expect(
- resolveObjectSharing({
- flatObjectMetadata: {
- ...OBJECT,
- readability: MetadataReadability.PRIVATE,
- isSystem,
- },
- featureFlagsMap,
- }),
- ).toEqual({
- ...PRIVATE,
- canShareBeyondRole: false,
- operationTypesGrantedBeyondRole: [],
- });
- },
- );
+ it('should reach chat threads through their shares until private records are enabled', () => {
+ expect(
+ resolveObjectSharing({
+ flatObjectMetadata: CHAT_THREAD,
+ featureFlagsMap: {},
+ }),
+ ).toEqual({
+ isShareable: true,
+ isShareRequired: true,
+ isPrivateByDefault: true,
+ defaultGeneralAccessLevel: RecordShareAccessLevel.NONE,
+ canShareBeyondRole: false,
+ operationTypesGrantedBeyondRole: [],
+ });
+ });
- it('should let a grant on a private object view or edit beyond the role', () => {
+ it('should make chat threads shareable private records once private records are enabled, whatever the sharing flag', () => {
expect(
resolveObjectSharing({
- flatObjectMetadata: {
- ...OBJECT,
- readability: MetadataReadability.PRIVATE,
- },
- featureFlagsMap: RECORD_SHARING,
+ flatObjectMetadata: CHAT_THREAD,
+ featureFlagsMap: PRIVATE_CHAT_THREAD,
}),
).toEqual({
- ...PRIVATE,
- canShareBeyondRole: true,
- operationTypesGrantedBeyondRole: ['select', 'update'],
+ isShareable: true,
+ isShareRequired: false,
+ isPrivateByDefault: true,
+ defaultGeneralAccessLevel: RecordShareAccessLevel.NONE,
+ canShareBeyondRole: false,
+ operationTypesGrantedBeyondRole: [],
});
});
});
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/build-record-share-inputs-for-created-records.util.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/build-record-share-inputs-for-created-records.util.ts
index 9f419559667..b6e0469aac1 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/build-record-share-inputs-for-created-records.util.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/build-record-share-inputs-for-created-records.util.ts
@@ -113,6 +113,7 @@ export const buildRecordShareInputsForCreatedRecords = ({
apiKeyRoleMap,
shareWith,
isShareRequired,
+ isPrivateByDefault,
isPrivate,
}: {
recordIds: string[];
@@ -121,6 +122,7 @@ export const buildRecordShareInputsForCreatedRecords = ({
apiKeyRoleMap: Record<string, string>;
shareWith?: ShareWithInput[] | null;
isShareRequired: boolean;
+ isPrivateByDefault: boolean;
isPrivate: boolean;
}): RecordShareInput[] => {
const shareWithEntries = shareWith ?? [];
@@ -135,7 +137,9 @@ export const buildRecordShareInputsForCreatedRecords = ({
// An application or API key has no createdBy member to keep its private records through
const shouldWriteCreatorRows =
- isShareRequired || (isPrivate && !isUserAuthContext(authContext));
+ isShareRequired ||
+ isPrivateByDefault ||
+ (isPrivate && !isUserAuthContext(authContext));
return [
...recordIds.flatMap((recordId) => [
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util.ts
index 506dfb03fab..b5d6ec65916 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util.ts
@@ -13,7 +13,7 @@ export const isOperationGrantedBeyondRole = ({
}: {
flatObjectMetadata: Pick<
FlatObjectMetadata,
- 'readability' | 'isSystem' | 'disabledObjectPermissionActions'
+ 'universalIdentifier' | 'isSystem' | 'disabledObjectPermissionActions'
>;
featureFlagsMap: Partial<Record<FeatureFlagKey, boolean>>;
operationType: OperationType;
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-created-record-sharing-or-throw.util.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-created-record-sharing-or-throw.util.ts
index fb2e584c9bc..a3dd7505d45 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-created-record-sharing-or-throw.util.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-created-record-sharing-or-throw.util.ts
@@ -18,12 +18,20 @@ export type CreatedRecordSharing = {
// shareWith also reaches records created through nested relations, whose objects may not be shareable
export const resolveCreatedRecordSharingOrThrow = ({
- objectSharing: { isShareable, isShareRequired, defaultGeneralAccessLevel },
+ objectSharing: {
+ isShareable,
+ isShareRequired,
+ isPrivateByDefault,
+ defaultGeneralAccessLevel,
+ },
shareWith,
}: {
objectSharing: Pick<
ObjectSharing,
- 'isShareable' | 'isShareRequired' | 'defaultGeneralAccessLevel'
+ | 'isShareable'
+ | 'isShareRequired'
+ | 'isPrivateByDefault'
+ | 'defaultGeneralAccessLevel'
>;
shareWith?: ShareWithInput[] | null;
}): CreatedRecordSharing | null => {
@@ -58,9 +66,11 @@ export const resolveCreatedRecordSharingOrThrow = ({
}
const namedEntries = entries.filter((entry) => !entry.everyone);
- const isPrivate = everyoneEntries.some(
- (entry) => entry.accessLevel === RecordShareAccessLevel.NONE,
- );
+ const isPrivate =
+ isPrivateByDefault ||
+ everyoneEntries.some(
+ (entry) => entry.accessLevel === RecordShareAccessLevel.NONE,
+ );
return isPrivate || isNonEmptyArray(namedEntries)
? { shareWith: namedEntries, isPrivate }
diff --git a/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-object-sharing.util.ts b/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-object-sharing.util.ts
index 40416d46ea9..f01cbef2147 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-object-sharing.util.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/utils/resolve-object-sharing.util.ts
@@ -1,14 +1,12 @@
/* @license Enterprise */
import { type ObjectPermissionAction } from 'twenty-shared/application';
-import {
- FeatureFlagKey,
- MetadataReadability,
- RecordShareAccessLevel,
-} from 'twenty-shared/types';
+import { FeatureFlagKey, RecordShareAccessLevel } from 'twenty-shared/types';
import { isNonEmptyArray } from 'twenty-shared/utils';
+import { isPrivateRecordEnabled } from 'src/engine/permissions/private-record/utils/is-private-record-enabled.util';
+import { isPrivateByDefaultObject } from 'src/engine/permissions/private-record/utils/is-private-by-default-object.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
@@ -26,6 +24,7 @@ const OPERATIONS_GRANTABLE_BEYOND_ROLE: {
export type ObjectSharing = {
isShareable: boolean;
isShareRequired: boolean;
+ isPrivateByDefault: boolean;
defaultGeneralAccessLevel: RecordShareAccessLevel | null;
canShareBeyondRole: boolean;
operationTypesGrantedBeyondRole: OperationType[];
@@ -34,11 +33,12 @@ export type ObjectSharing = {
const resolveDefaultGeneralAccessLevel = ({
isShareable,
isShareRequired,
+ isPrivateByDefault,
}: Pick<
ObjectSharing,
- 'isShareable' | 'isShareRequired'
+ 'isShareable' | 'isShareRequired' | 'isPrivateByDefault'
>): RecordShareAccessLevel | null => {
- if (isShareRequired) {
+ if (isShareRequired || isPrivateByDefault) {
return RecordShareAccessLevel.NONE;
}
@@ -62,18 +62,18 @@ export const resolveObjectSharing = ({
}: {
flatObjectMetadata: Pick<
FlatObjectMetadata,
- 'readability' | 'isSystem' | 'disabledObjectPermissionActions'
+ 'universalIdentifier' | 'isSystem' | 'disabledObjectPermissionActions'
>;
featureFlagsMap: Partial<Record<FeatureFlagKey, boolean>>;
}): ObjectSharing => {
const isRecordSharingEnabled =
featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ?? false;
- // Private records are only reached through their shares, whatever the flag
+ const isPrivateByDefault = isPrivateByDefaultObject(flatObjectMetadata);
const isShareRequired =
- flatObjectMetadata.readability === MetadataReadability.PRIVATE;
+ isPrivateByDefault && !isPrivateRecordEnabled(featureFlagsMap);
const canBeShared = isRecordSharingEnabled && !flatObjectMetadata.isSystem;
- const isShareable = isShareRequired || canBeShared;
+ const isShareable = isPrivateByDefault || canBeShared;
const operationTypesGrantedBeyondRole = canBeShared
? resolveOperationTypesGrantableBeyondRole(flatObjectMetadata)
@@ -82,9 +82,11 @@ export const resolveObjectSharing = ({
return {
isShareable,
isShareRequired,
+ isPrivateByDefault,
defaultGeneralAccessLevel: resolveDefaultGeneralAccessLevel({
isShareable,
isShareRequired,
+ isPrivateByDefault,
}),
canShareBeyondRole: isNonEmptyArray(operationTypesGrantedBeyondRole),
operationTypesGrantedBeyondRole,
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-agent-chat-thread-inbox-state.util.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-agent-chat-thread-inbox-state.util.ts
index c4388a22747..8fc058db9ee 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-agent-chat-thread-inbox-state.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-agent-chat-thread-inbox-state.util.ts
@@ -3,6 +3,7 @@ import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { AGENT_CHAT_THREAD_LAST_MESSAGE_TEXT_MAX_LENGTH } from 'src/engine/metadata-modules/ai/ai-chat/constants/agent-chat-thread-last-message-text-max-length.constant';
import { buildAgentChatThreadParticipantOwnerShareInsert } from 'src/engine/metadata-modules/ai/ai-chat/utils/build-agent-chat-thread-participant-owner-share-insert.util';
import { getAgentChatThreadParticipantTable } from 'src/engine/metadata-modules/ai/ai-chat/utils/get-agent-chat-thread-participant-table.util';
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
import { type AgentHistoryStorageContext } from 'src/engine/metadata-modules/ai/ai-history/services/agent-history-workspace-storage.service';
// Seeded chats are inserted directly, so they get the last activity, last
@@ -64,8 +65,8 @@ export const seedAgentChatThreadInboxState = async ({
);
await manager.query(
- `INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId", "lastReadAt")
- SELECT thread.id, thread."workspaceMemberId", thread."lastActivityAt"
+ `INSERT INTO ${getAgentChatThreadParticipantTable(workspaceId)} ("threadId", "workspaceMemberId", "${IS_PRIVATE_COLUMN_NAME}", "lastReadAt")
+ SELECT thread.id, thread."workspaceMemberId", true, thread."lastActivityAt"
FROM ${table('agentChatThread')} thread
WHERE thread."workspaceMemberId" IS NOT NULL
ON CONFLICT ("threadId", "workspaceMemberId") DO NOTHING`,
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-channel.workspace-service.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-channel.workspace-service.ts
index fbeb245657a..63db2f8d39d 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-channel.workspace-service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-channel.workspace-service.ts
@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
import { isDefined } from 'twenty-shared/utils';
import { v5 } from 'uuid';
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
import { AgentChatChannelGrantService } from 'src/engine/metadata-modules/ai/ai-chat/services/agent-chat-channel-grant.service';
import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';
import { AgentTurnStatus } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-turn-status.enum';
@@ -134,6 +135,12 @@ export class DevSeederAgentChatChannelWorkspaceService {
assigneeId: conversation.assigneeId,
channelId,
});
+ await this.threadRepository.query(workspaceId, ({ manager, table }) =>
+ manager.query(
+ `UPDATE ${table('agentChatThread')} SET "${IS_PRIVATE_COLUMN_NAME}" = true WHERE id = $1`,
+ [threadId],
+ ),
+ );
await this.conversationWriterService.insertTurn({
workspaceId,
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
index bfae4130424..248e244d8f2 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/services/dev-seeder-agent-chat-pending-input.workspace-service.ts
@@ -11,6 +11,7 @@ import {
import { isDefined } from 'twenty-shared/utils';
import { v5 } from 'uuid';
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
import { RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
import { AgentMessageRole } from 'src/engine/metadata-modules/ai/ai-history/enums/agent-message-role.enum';
import { PAUSING_TOOLS } from 'src/engine/metadata-modules/ai/ai-agent-execution/pausing-tools/constants/pausing-tools.constant';
@@ -414,6 +415,12 @@ export class DevSeederAgentChatPendingInputWorkspaceService {
? null
: seedId('assistantMessage'),
});
+ await this.threadRepository.query(workspaceId, ({ manager, table }) =>
+ manager.query(
+ `UPDATE ${table('agentChatThread')} SET "${IS_PRIVATE_COLUMN_NAME}" = true WHERE id = $1`,
+ [threadId],
+ ),
+ );
const questionTurnId = seedId('questionTurn');
diff --git a/packages/twenty-server/test/integration/graphql/suites/chat-shared-api-boundaries.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/chat-shared-api-boundaries.integration-spec.ts
index cdb12ac7384..3fdf6347c1c 100644
--- a/packages/twenty-server/test/integration/graphql/suites/chat-shared-api-boundaries.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/chat-shared-api-boundaries.integration-spec.ts
@@ -443,7 +443,7 @@ describe('Shared conversation API boundaries', () => {
const [{ backendProcessId }]: { backendProcessId: number }[] =
await runner.query('SELECT pg_backend_pid() AS "backendProcessId"');
await runner.query(
- `INSERT INTO "${context.schema}"."agentChatThread" (id, "workspaceMemberId") VALUES ($1, $2)`,
+ `INSERT INTO "${context.schema}"."agentChatThread" (id, "workspaceMemberId", "_isPrivate") VALUES ($1, $2, true)`,
[threadId, context.workspaceMemberId],
);
const sending = sendChatParticipationMessage({
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
index d89c6c92b96..04e6b428a6c 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/chat-thread-sharing.integration-spec.ts
@@ -190,7 +190,7 @@ const shareThread = ({
};
describe('Conversation sharing through the authenticated API', () => {
- it.each(['member', 'role', 'everyone', 'setup'])(
+ it.each(['member', 'role'])(
'grants read-only %s access and denies it immediately after revocation',
async (audience) => {
const workspaceId = SEED_APPLE_WORKSPACE_ID;
@@ -361,7 +361,7 @@ describe('Conversation sharing through the authenticated API', () => {
},
);
- it.each(['member', 'role', 'everyone'])(
+ it.each(['member', 'role'])(
'executes as an invited %s editor and denies further work after downgrade',
async (audience) => {
const workspaceId = SEED_APPLE_WORKSPACE_ID;
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
index eef4a1b9a2d..821c3828353 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
@@ -5,22 +5,18 @@ import { randomUUID } from 'node:crypto';
import gql from 'graphql-tag';
import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
-import { makeGraphqlApiRequestWithApiKey } from 'test/integration/graphql/utils/make-graphql-api-request-with-api-key.util';
import { makeGraphqlApiRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util';
import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';
import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
-import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';
import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
-import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
import {
FeatureFlagKey,
FieldMetadataType,
@@ -39,11 +35,6 @@ import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev
const OBJECT_SINGULAR = 'shareWithTestObject';
const OBJECT_PLURAL = 'shareWithTestObjects';
-const SHARE_WITH_REQUIRED_MESSAGE =
- 'Creating a record of a private object requires the shareWith argument';
-const SHARE_WITH_SINGLE_TARGET_MESSAGE =
- 'Each shareWith entry must target exactly one of workspaceMemberId, roleId or everyone';
-
const createOneOperation = ({
data,
shareWith,
@@ -64,57 +55,6 @@ const createOneOperation = ({
variables: { data, shareWith },
});
-const createManyOperation = ({
- data,
- shareWith,
-}: {
- data: { id: string; name: string }[];
- shareWith?: ShareWithInput[];
-}) => ({
- query: gql`
- mutation CreateManyShareWithTestObjects(
- $data: [ShareWithTestObjectCreateInput!]!
- $shareWith: [ShareWithInput!]
- ) {
- createShareWithTestObjects(data: $data, shareWith: $shareWith) {
- id
- }
- }
- `,
- variables: { data, shareWith },
-});
-
-const createOnePersonWithNestedRecordOperation = ({
- personId,
- nestedRecord,
- shareWith,
-}: {
- personId: string;
- nestedRecord: { id: string; name: string };
- shareWith?: ShareWithInput[];
-}) => ({
- query: gql`
- mutation CreateOnePersonWithNestedShareWithTestObject(
- $data: PersonCreateInput!
- $shareWith: [ShareWithInput!]
- ) {
- createPerson(data: $data, shareWith: $shareWith) {
- id
- shareWithTestObject {
- id
- }
- }
- }
- `,
- variables: {
- data: {
- id: personId,
- [OBJECT_SINGULAR]: { create: nestedRecord },
- },
- shareWith,
- },
-});
-
const findManyOperation = (recordId: string) =>
findManyOperationFactory({
objectMetadataSingularName: OBJECT_SINGULAR,
@@ -123,30 +63,10 @@ const findManyOperation = (recordId: string) =>
filter: { id: { eq: recordId } },
});
-const ownerRowFor = (recordId: string, workspaceMemberId: string) => ({
- recordId,
- principalId: workspaceMemberId,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.OWNER,
- sourceId: recordId,
-});
-
-const apiKeyRoleRowFor = (recordId: string, roleId: string) => ({
- recordId,
- principalId: roleId,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: recordId,
-});
-
describe('createShareWithObjectRecordsPermissions', () => {
let recordShareStorageService: RecordShareStorageService;
let objectMetadataId: string;
let personRelationFieldMetadataId: string;
- let memberRoleId: string;
- let adminRoleId: string;
const createdRecordIds: string[] = [];
const createdPersonIds: string[] = [];
@@ -218,9 +138,6 @@ describe('createShareWithObjectRecordsPermissions', () => {
});
personRelationFieldMetadataId = personRelationFieldData.createOneField.id;
-
- memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
- adminRoleId = (await findOneRoleByLabel({ label: 'Admin' })).id;
});
afterAll(async () => {
@@ -256,523 +173,6 @@ describe('createShareWithObjectRecordsPermissions', () => {
});
});
- describe('PRIVATE readability', () => {
- beforeAll(async () => {
- await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
- });
-
- it('should give the creating member a FULL owner row when no shareWith is passed', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequest(
- createOneOperation({ data: { id: recordId, name: 'owner only' } }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createShareWithTestObject.id).toBe(recordId);
-
- expect(await findRecordShares(recordId)).toEqual([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- ]);
- });
-
- it('should drop the rows of a destroyed record whose id is reused', async () => {
- const recordId = trackRecordId();
-
- const firstResponse = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'first record with this id' },
- shareWith: [
- { roleId: memberRoleId, accessLevel: RecordShareAccessLevel.READ },
- ],
- }),
- );
-
- expect(firstResponse.body.errors).toBeUndefined();
- expect(await findRecordShares(recordId)).toHaveLength(2);
-
- const destroyResponse = await makeGraphqlApiRequest(
- destroyManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: 'id',
- filter: { id: { eq: recordId } },
- }),
- );
-
- expect(destroyResponse.body.errors).toBeUndefined();
- expect(await findRecordShares(recordId)).toHaveLength(2);
-
- const secondResponse = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'second record with this id' },
- }),
- );
-
- expect(secondResponse.body.errors).toBeUndefined();
- expect(await findRecordShares(recordId)).toEqual([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- ]);
- });
-
- it('should treat a null shareWith as omitted for a member', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'null shareWith' },
- shareWith: null,
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(await findRecordShares(recordId)).toEqual([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- ]);
- });
-
- it('should refuse a shareWith naming the same principal twice', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'duplicate principal' },
- shareWith: [
- { roleId: memberRoleId, accessLevel: RecordShareAccessLevel.READ },
- { roleId: memberRoleId, accessLevel: RecordShareAccessLevel.FULL },
- ],
- }),
- );
-
- expect(JSON.stringify(response.body.errors)).toContain(
- 'shareWith names the same principal more than once',
- );
- expect(await findRecordShares(recordId)).toEqual([]);
- });
-
- it('should add a MANUAL role row next to the owner row', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'shared with member role' },
- shareWith: [
- { roleId: memberRoleId, accessLevel: RecordShareAccessLevel.READ },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- expect.objectContaining({
- recordId,
- principalId: memberRoleId,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.READ,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- }),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
- });
-
- it('should reject an api key create without shareWith', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({ data: { id: recordId, name: 'api key' } }),
- );
-
- expect(response.body.data).toStrictEqual({
- createShareWithTestObject: null,
- });
- expect(response.body.errors[0].message).toBe(SHARE_WITH_REQUIRED_MESSAGE);
- expect(await findRecordShares(recordId)).toEqual([]);
- });
-
- it('should write an EVERYONE row next to the api key role row for an api key create sharing with everyone', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'api key shared with everyone' },
- shareWith: [
- { everyone: true, accessLevel: RecordShareAccessLevel.READ },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createShareWithTestObject.id).toBe(recordId);
-
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(apiKeyRoleRowFor(recordId, adminRoleId)),
- expect.objectContaining({
- recordId,
- principalId: EVERYONE_PRINCIPAL_ID,
- principalType: RecordSharePrincipalType.EVERYONE,
- accessLevel: RecordShareAccessLevel.READ,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: recordId,
- }),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
- });
-
- it('should keep the api key role at FULL when shareWith names it at a lower level', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'api key shared with its own role' },
- shareWith: [
- { roleId: adminRoleId, accessLevel: RecordShareAccessLevel.READ },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- expect(await findRecordShares(recordId)).toEqual([
- expect.objectContaining({
- recordId,
- principalId: adminRoleId,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: recordId,
- }),
- ]);
- });
-
- it('should let an api key that shared a record with a member only read and update it', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'api key shared with jony only' },
- shareWith: [
- {
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- accessLevel: RecordShareAccessLevel.FULL,
- },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createShareWithTestObject.id).toBe(recordId);
-
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(apiKeyRoleRowFor(recordId, adminRoleId)),
- expect.objectContaining({
- recordId,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: recordId,
- }),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
-
- const apiKeyReadResponse = await makeGraphqlApiRequestWithApiKey(
- findManyOperation(recordId),
- );
-
- expect(apiKeyReadResponse.body.errors).toBeUndefined();
- expect(
- apiKeyReadResponse.body.data[OBJECT_PLURAL].edges.map(
- (edge: { node: { id: string } }) => edge.node.id,
- ),
- ).toEqual([recordId]);
-
- const apiKeyUpdateResponse = await makeGraphqlApiRequestWithApiKey(
- updateOneOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- gqlFields: 'id name',
- recordId,
- data: { name: 'renamed by api key' },
- }),
- );
-
- expect(apiKeyUpdateResponse.body.errors).toBeUndefined();
- expect(apiKeyUpdateResponse.body.data.updateShareWithTestObject).toEqual({
- id: recordId,
- name: 'renamed by api key',
- });
-
- const jonyReadResponse = await makeGraphqlApiRequestWithMemberRole(
- findManyOperation(recordId),
- );
-
- expect(jonyReadResponse.body.errors).toBeUndefined();
- expect(
- jonyReadResponse.body.data[OBJECT_PLURAL].edges.map(
- (edge: { node: { id: string } }) => edge.node.id,
- ),
- ).toEqual([recordId]);
- });
-
- it('should give the creating member the owner row on a nested create', async () => {
- const personId = randomUUID();
- const nestedRecordId = trackRecordId();
-
- createdPersonIds.push(personId);
-
- const response = await makeGraphqlApiRequest(
- createOnePersonWithNestedRecordOperation({
- personId,
- nestedRecord: { id: nestedRecordId, name: 'nested by member' },
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createPerson[OBJECT_SINGULAR].id).toBe(
- nestedRecordId,
- );
-
- expect(await findRecordShares(nestedRecordId)).toEqual([
- expect.objectContaining(
- ownerRowFor(nestedRecordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- ]);
- });
-
- it('should forward shareWith to a nested create by an api key', async () => {
- const personId = randomUUID();
- const nestedRecordId = trackRecordId();
-
- createdPersonIds.push(personId);
-
- const response = await makeGraphqlApiRequestWithApiKey(
- createOnePersonWithNestedRecordOperation({
- personId,
- nestedRecord: { id: nestedRecordId, name: 'nested by api key' },
- shareWith: [
- { everyone: true, accessLevel: RecordShareAccessLevel.READ },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createPerson[OBJECT_SINGULAR].id).toBe(
- nestedRecordId,
- );
-
- expect(await findRecordShares(nestedRecordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(
- apiKeyRoleRowFor(nestedRecordId, adminRoleId),
- ),
- expect.objectContaining({
- recordId: nestedRecordId,
- principalId: EVERYONE_PRINCIPAL_ID,
- principalType: RecordSharePrincipalType.EVERYONE,
- accessLevel: RecordShareAccessLevel.READ,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: nestedRecordId,
- }),
- ]),
- );
- expect(await findRecordShares(nestedRecordId)).toHaveLength(2);
- });
-
- it('should write the owner row and the shared row for every record of a createMany', async () => {
- const recordIds = [trackRecordId(), trackRecordId(), trackRecordId()];
-
- const response = await makeGraphqlApiRequest(
- createManyOperation({
- data: recordIds.map((id, index) => ({ id, name: `batch ${index}` })),
- shareWith: [
- {
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- accessLevel: RecordShareAccessLevel.READ_WRITE,
- },
- ],
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createShareWithTestObjects).toHaveLength(3);
-
- for (const recordId of recordIds) {
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- expect.objectContaining({
- recordId,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.READ_WRITE,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- }),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
- }
- });
-
- it('should reject an entry targeting two principals', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'two targets' },
- shareWith: [
- {
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- roleId: memberRoleId,
- accessLevel: RecordShareAccessLevel.READ,
- },
- ],
- }),
- );
-
- expect(response.body.data).toStrictEqual({
- createShareWithTestObject: null,
- });
- expect(response.body.errors[0].message).toBe(
- SHARE_WITH_SINGLE_TARGET_MESSAGE,
- );
- expect(await findRecordShares(recordId)).toEqual([]);
- });
- });
-
- describe.each([MetadataReadability.PRIVATE])(
- 'PRIVATE creates with conversation readability %s',
- (conversationReadability) => {
- let conversationObjectMetadata: ObjectMetadataEntity;
-
- beforeAll(async () => {
- conversationObjectMetadata =
- await getCoreRepository<ObjectMetadataEntity>(
- ObjectMetadataEntity,
- ).findOneOrFail({
- where: {
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- nameSingular: 'agentChatThread',
- },
- });
- await setObjectReadability(
- conversationObjectMetadata.id,
- conversationReadability,
- );
- await setObjectReadability(
- objectMetadataId,
- MetadataReadability.PRIVATE,
- );
- });
-
- afterAll(async () => {
- await setObjectReadability(
- conversationObjectMetadata.id,
- conversationObjectMetadata.readability,
- );
- });
-
- it('requires an explicit API sharing target', async () => {
- const recordId = trackRecordId();
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'API create without shareWith' },
- }),
- );
-
- expect(response.body.errors[0].message).toBe(
- SHARE_WITH_REQUIRED_MESSAGE,
- );
- expect(await findRecordShares(recordId)).toEqual([]);
- });
-
- it('keeps new member records private', async () => {
- const recordId = trackRecordId();
- const response = await makeGraphqlApiRequest(
- createOneOperation({
- data: { id: recordId, name: 'Member create' },
- }),
- );
- expect(response.body.errors).toBeUndefined();
- const shares = await findRecordShares(recordId);
- expect(shares).toEqual(
- expect.arrayContaining([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- ]),
- );
- expect(shares).toHaveLength(1);
-
- const otherMemberResponse = await makeGraphqlApiRequestWithMemberRole(
- findManyOperation(recordId),
- );
- expect(otherMemberResponse.body.errors).toBeUndefined();
- expect(
- otherMemberResponse.body.data.shareWithTestObjects.edges,
- ).toHaveLength(0);
- const ownerResponse = await makeGraphqlApiRequest(
- findManyOperation(recordId),
- );
- expect(ownerResponse.body.errors).toBeUndefined();
- expect(ownerResponse.body.data.shareWithTestObjects.edges).toHaveLength(
- 1,
- );
- });
-
- it('honors explicit API targets without creating an everyone grant', async () => {
- const recordId = trackRecordId();
- const response = await makeGraphqlApiRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'API create with explicit sharing' },
- shareWith: [
- {
- roleId: memberRoleId,
- accessLevel: RecordShareAccessLevel.READ,
- },
- ],
- }),
- );
- expect(response.body.errors).toBeUndefined();
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(apiKeyRoleRowFor(recordId, adminRoleId)),
- expect.objectContaining({
- principalId: memberRoleId,
- accessLevel: RecordShareAccessLevel.READ,
- }),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
- const readerResponse = await makeGraphqlApiRequestWithMemberRole(
- findManyOperation(recordId),
- );
- expect(readerResponse.body.errors).toBeUndefined();
- expect(
- readerResponse.body.data.shareWithTestObjects.edges,
- ).toHaveLength(1);
- });
- },
- );
-
describe('OPEN readability', () => {
beforeAll(async () => {
await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts
deleted file mode 100644
index 5f401937550..00000000000
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts
+++ /dev/null
@@ -1,547 +0,0 @@
-/* @license Enterprise */
-
-import { randomUUID } from 'node:crypto';
-
-import gql from 'graphql-tag';
-import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
-import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
-import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
-import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
-import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one-operation-factory.util';
-import { groupByOperationFactory } from 'test/integration/graphql/utils/group-by-operation-factory.util';
-import { makeGraphqlApiRequestWithApiKey } from 'test/integration/graphql/utils/make-graphql-api-request-with-api-key.util';
-import { makeGraphqlApiRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
-import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
-import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
-import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
-import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util';
-import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
-import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';
-import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
-import { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';
-import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
-import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
-import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
-import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
-import {
- FieldMetadataType,
- MetadataReadability,
- RecordShareAccessLevel,
- RecordSharePrincipalType,
- RecordShareRowCause,
-} from 'twenty-shared/types';
-import { capitalize } from 'twenty-shared/utils';
-
-import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { type RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
-import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
-import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
-
-const OBJECT_SINGULAR = 'readabilityTestObject';
-const OBJECT_PLURAL = 'readabilityTestObjects';
-const UPDATE_RESPONSE_KEY = `update${capitalize(OBJECT_PLURAL)}`;
-const DELETE_RESPONSE_KEY = `delete${capitalize(OBJECT_PLURAL)}`;
-const RESTORE_RESPONSE_KEY = `restore${capitalize(OBJECT_PLURAL)}`;
-const DESTROY_RESPONSE_KEY = `destroy${capitalize(OBJECT_PLURAL)}`;
-const GROUP_BY_RESPONSE_KEY = `${OBJECT_PLURAL}GroupBy`;
-const RECORD_GQL_FIELDS = `
- id
- name
-`;
-
-const RECORD_IDS = {
- SHARED_READ_WITH_JONY: randomUUID(),
- SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),
- SHARED_FULL_WITH_EVERYONE: randomUUID(),
- SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),
- UNSHARED: randomUUID(),
-};
-
-const PERSON_IDS = {
- SHARED_READ_WITH_JONY: randomUUID(),
- SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),
- SHARED_FULL_WITH_EVERYONE: randomUUID(),
- SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),
- UNSHARED: randomUUID(),
-};
-
-const ALL_RECORD_IDS = Object.values(RECORD_IDS);
-const ALL_PERSON_IDS = Object.values(PERSON_IDS);
-
-const ALL_RECORDS_FILTER = { id: { in: ALL_RECORD_IDS } };
-const ALL_PEOPLE_FILTER = { id: { in: ALL_PERSON_IDS } };
-
-const collectIds = (edges: { node: { id: string } }[]): string[] =>
- edges.map((edge) => edge.node.id).sort();
-
-const collectRecordIds = (records: { id: string }[]): string[] =>
- records.map((record) => record.id).sort();
-
-const findManyOperation = findManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- filter: ALL_RECORDS_FILTER,
-});
-
-const totalCountOperation = {
- query: gql`
- query ReadabilityTestObjectsTotalCount(
- $filter: ReadabilityTestObjectFilterInput
- ) {
- readabilityTestObjects(filter: $filter) {
- totalCount
- }
- }
- `,
- variables: { filter: ALL_RECORDS_FILTER },
-};
-
-describe('readabilityObjectRecordsPermissions', () => {
- let recordShareStorageService: RecordShareStorageService;
- let objectMetadataId: string;
- let personRelationFieldMetadataId: string;
-
- const sourceId = randomUUID();
-
- beforeAll(async () => {
- recordShareStorageService =
- getAppProviderByClassName<RecordShareStorageService>(
- 'RecordShareStorageService',
- );
-
- const { data } = await createOneObjectMetadata({
- input: {
- nameSingular: OBJECT_SINGULAR,
- namePlural: OBJECT_PLURAL,
- labelSingular: 'Readability Test Object',
- labelPlural: 'Readability Test Objects',
- icon: 'IconLock',
- isLabelSyncedWithName: false,
- },
- });
-
- objectMetadataId = data.createOneObject.id;
-
- await createOneFieldMetadata({
- input: {
- name: 'name',
- label: 'Name',
- type: FieldMetadataType.TEXT,
- objectMetadataId,
- isLabelSyncedWithName: false,
- },
- });
-
- const personObjectMetadata = await getCoreRepository<ObjectMetadataEntity>(
- ObjectMetadataEntity,
- ).findOneOrFail({
- where: { workspaceId: SEED_APPLE_WORKSPACE_ID, nameSingular: 'person' },
- });
-
- const { data: personRelationFieldData } = await createOneFieldMetadata({
- input: {
- name: OBJECT_SINGULAR,
- label: 'Readability Test Object',
- type: FieldMetadataType.RELATION,
- objectMetadataId: personObjectMetadata.id,
- isLabelSyncedWithName: false,
- relationCreationPayload: {
- targetObjectMetadataId: objectMetadataId,
- targetFieldLabel: 'People',
- targetFieldIcon: 'IconUser',
- type: RelationType.MANY_TO_ONE,
- },
- },
- });
-
- personRelationFieldMetadataId = personRelationFieldData.createOneField.id;
-
- for (const [name, id] of Object.entries(RECORD_IDS)) {
- const response = await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- gqlFields: RECORD_GQL_FIELDS,
- data: { id, name },
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- }
-
- for (const [name, id] of Object.entries(PERSON_IDS)) {
- const response = await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: 'person',
- gqlFields: 'id',
- data: {
- id,
- name: { firstName: name },
- [`${OBJECT_SINGULAR}Id`]:
- RECORD_IDS[name as keyof typeof RECORD_IDS],
- },
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- }
-
- const memberRole = await findOneRoleByLabel({ label: 'Member' });
- const adminRole = await findOneRoleByLabel({ label: 'Admin' });
-
- const buildRecordShare = ({
- recordId,
- principalId,
- principalType,
- accessLevel,
- }: {
- recordId: string;
- principalId: string;
- principalType: RecordSharePrincipalType;
- accessLevel: RecordShareAccessLevel;
- }) => ({
- recordId,
- objectMetadataId,
- principalId,
- principalType,
- accessLevel,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId,
- });
-
- await recordShareStorageService.insertMany({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- recordShares: [
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_READ_WITH_JONY,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.READ,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- principalId: memberRole.id,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.READ_WRITE,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- principalId: EVERYONE_PRINCIPAL_ID,
- principalType: RecordSharePrincipalType.EVERYONE,
- accessLevel: RecordShareAccessLevel.FULL,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
- principalId: adminRole.id,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.FULL,
- }),
- ],
- });
- });
-
- afterAll(async () => {
- await recordShareStorageService.deleteBySourceId({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- sourceId,
- });
- await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);
- await makeGraphqlApiRequest(
- destroyManyOperationFactory({
- objectMetadataSingularName: 'person',
- objectMetadataPluralName: 'people',
- gqlFields: 'id',
- filter: ALL_PEOPLE_FILTER,
- }),
- );
- await deleteOneFieldMetadata({
- input: { idToDelete: personRelationFieldMetadataId },
- expectToFail: false,
- });
- await updateOneObjectMetadata({
- expectToFail: false,
- input: {
- idToUpdate: objectMetadataId,
- updatePayload: { isActive: false },
- },
- });
- await deleteOneObjectMetadata({
- input: { idToDelete: objectMetadataId },
- });
- });
-
- describe('PRIVATE readability', () => {
- beforeAll(async () => {
- await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
- });
-
- it('should only return records shared with the admin principals', async () => {
- const response = await makeGraphqlApiRequest(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
- [
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
- ].sort(),
- );
- });
-
- it('should only return records shared with the member, their role or everyone', async () => {
- const response =
- await makeGraphqlApiRequestWithMemberRole(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
- [
- RECORD_IDS.SHARED_READ_WITH_JONY,
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- ].sort(),
- );
- });
-
- it('should keep the role as the ceiling: a share row grants nothing the role refuses', async () => {
- const memberRole = await findOneRoleByLabel({ label: 'Member' });
- const setMemberCanReadObjectRecords = (canReadObjectRecords: boolean) =>
- upsertObjectPermissions({
- expectToFail: false,
- input: {
- roleId: memberRole.id,
- objectPermissions: [
- {
- objectMetadataId,
- canReadObjectRecords,
- canUpdateObjectRecords: canReadObjectRecords,
- canSoftDeleteObjectRecords: canReadObjectRecords,
- canDestroyObjectRecords: canReadObjectRecords,
- },
- ],
- },
- });
-
- await setMemberCanReadObjectRecords(false);
-
- try {
- const response =
- await makeGraphqlApiRequestWithMemberRole(findManyOperation);
-
- expect(response.body.errors).toBeDefined();
- expect(response.body.data?.[OBJECT_PLURAL] ?? null).toBeNull();
- } finally {
- await setMemberCanReadObjectRecords(true);
- }
-
- const restoredResponse =
- await makeGraphqlApiRequestWithMemberRole(findManyOperation);
-
- expect(restoredResponse.body.errors).toBeUndefined();
- expect(
- collectIds(restoredResponse.body.data[OBJECT_PLURAL].edges),
- ).toEqual(
- [
- RECORD_IDS.SHARED_READ_WITH_JONY,
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- ].sort(),
- );
- });
-
- it('should only return records shared with the api key role or everyone', async () => {
- const response = await makeGraphqlApiRequestWithApiKey(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
- [
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
- ].sort(),
- );
- });
-
- it('should count only the records visible to the member', async () => {
- const response =
- await makeGraphqlApiRequestWithMemberRole(totalCountOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data[OBJECT_PLURAL].totalCount).toBe(3);
- });
-
- it('should group only the records visible to the member', async () => {
- const response = await makeGraphqlApiRequestWithMemberRole(
- groupByOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- groupBy: [{ name: true }],
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- const groupedNames = response.body.data[GROUP_BY_RESPONSE_KEY]
- .flatMap(
- (group: { groupByDimensionValues: string[] }) =>
- group.groupByDimensionValues,
- )
- .sort();
-
- expect(groupedNames).toEqual([
- 'SHARED_FULL_WITH_EVERYONE',
- 'SHARED_READ_WITH_JONY',
- 'SHARED_READ_WRITE_WITH_MEMBER_ROLE',
- ]);
- });
-
- it('should only hydrate the visible records on a nested relation read', async () => {
- const response = await makeGraphqlApiRequestWithMemberRole(
- findManyOperationFactory({
- objectMetadataSingularName: 'person',
- objectMetadataPluralName: 'people',
- gqlFields: `
- id
- ${OBJECT_SINGULAR} {
- id
- }
- `,
- filter: ALL_PEOPLE_FILTER,
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- const relatedRecordIdByPersonId = Object.fromEntries(
- response.body.data.people.edges.map(
- (edge: {
- node: { id: string; [OBJECT_SINGULAR]: { id: string } };
- }) => [edge.node.id, edge.node[OBJECT_SINGULAR]?.id ?? null],
- ),
- );
-
- expect(relatedRecordIdByPersonId).toEqual({
- [PERSON_IDS.SHARED_READ_WITH_JONY]: RECORD_IDS.SHARED_READ_WITH_JONY,
- [PERSON_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE]:
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- [PERSON_IDS.SHARED_FULL_WITH_EVERYONE]:
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- [PERSON_IDS.SHARED_FULL_WITH_ADMIN_ROLE]: null,
- [PERSON_IDS.UNSHARED]: null,
- });
- });
-
- it('should only match relation filters through the visible records', async () => {
- const findPeopleThroughRecordName = (name: string) =>
- makeGraphqlApiRequestWithMemberRole(
- findManyOperationFactory({
- objectMetadataSingularName: 'person',
- objectMetadataPluralName: 'people',
- gqlFields: 'id',
- filter: { [OBJECT_SINGULAR]: { name: { eq: name } } },
- }),
- );
-
- const hiddenResponse = await findPeopleThroughRecordName('UNSHARED');
- const visibleResponse = await findPeopleThroughRecordName(
- 'SHARED_READ_WITH_JONY',
- );
-
- expect(hiddenResponse.body.errors).toBeUndefined();
- expect(hiddenResponse.body.data.people.edges).toHaveLength(0);
- expect(visibleResponse.body.errors).toBeUndefined();
- expect(collectIds(visibleResponse.body.data.people.edges)).toEqual([
- PERSON_IDS.SHARED_READ_WITH_JONY,
- ]);
- });
-
- it('should only update the records shared with at least READ_WRITE access', async () => {
- const response = await makeGraphqlApiRequestWithMemberRole(
- updateManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- data: { name: 'updated by member' },
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(collectRecordIds(response.body.data[UPDATE_RESPONSE_KEY])).toEqual(
- [
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- ].sort(),
- );
-
- const readOnlyRecordResponse = await makeGraphqlApiRequestWithMemberRole(
- findOneOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- gqlFields: RECORD_GQL_FIELDS,
- filter: { id: { eq: RECORD_IDS.SHARED_READ_WITH_JONY } },
- }),
- );
-
- expect(readOnlyRecordResponse.body.data[OBJECT_SINGULAR].name).toBe(
- 'SHARED_READ_WITH_JONY',
- );
- });
-
- it('should only soft delete, restore and destroy the records shared with FULL access', async () => {
- const deleteResponse = await makeGraphqlApiRequestWithMemberRole(
- deleteManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(deleteResponse.body.errors).toBeUndefined();
- expect(
- collectRecordIds(deleteResponse.body.data[DELETE_RESPONSE_KEY]),
- ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
-
- const restoreResponse = await makeGraphqlApiRequestWithMemberRole(
- restoreManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(restoreResponse.body.errors).toBeUndefined();
- expect(
- collectRecordIds(restoreResponse.body.data[RESTORE_RESPONSE_KEY]),
- ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
-
- const destroyResponse = await makeGraphqlApiRequestWithMemberRole(
- destroyManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(destroyResponse.body.errors).toBeUndefined();
- expect(
- collectRecordIds(destroyResponse.body.data[DESTROY_RESPONSE_KEY]),
- ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
-
- const remainingResponse =
- await makeGraphqlApiRequestWithMemberRole(findManyOperation);
-
- expect(
- collectIds(remainingResponse.body.data[OBJECT_PLURAL].edges),
- ).toEqual(
- [
- RECORD_IDS.SHARED_READ_WITH_JONY,
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- ].sort(),
- );
- });
- });
-});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts
deleted file mode 100644
index 50e8a8da7f9..00000000000
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-/* @license Enterprise */
-
-import { randomUUID } from 'node:crypto';
-
-import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
-import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
-import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
-import { makeGraphqlApiRequestWithApiKey } from 'test/integration/graphql/utils/make-graphql-api-request-with-api-key.util';
-import { makeGraphqlApiRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
-import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
-import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
-import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
-import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';
-import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
-import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
-import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
-import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
-import {
- FieldMetadataType,
- MetadataReadability,
- RecordShareAccessLevel,
- RecordSharePrincipalType,
- RecordShareRowCause,
-} from 'twenty-shared/types';
-import { capitalize } from 'twenty-shared/utils';
-
-import { type RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
-import { type RecordShare } from 'src/engine/permissions/record-share/types/record-share.type';
-import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/permissions/record-share/utils/resolve-record-ids-shared-with-principals.util';
-import { resolveRequiredRecordShareAccessLevels } from 'src/engine/permissions/record-share/utils/resolve-required-record-share-access-levels.util';
-import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
-import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
-
-const OBJECT_SINGULAR = 'recordShareTwinObject';
-const OBJECT_PLURAL = 'recordShareTwinObjects';
-const UPDATE_RESPONSE_KEY = `update${capitalize(OBJECT_PLURAL)}`;
-const RECORD_GQL_FIELDS = `
- id
- name
-`;
-
-const RECORD_IDS = {
- SHARED_READ_WITH_JONY: randomUUID(),
- SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),
- SHARED_FULL_WITH_EVERYONE: randomUUID(),
- SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),
- UNSHARED: randomUUID(),
-};
-
-const ALL_RECORD_IDS = Object.values(RECORD_IDS);
-const ALL_RECORDS_FILTER = { id: { in: ALL_RECORD_IDS } };
-
-const collectIds = (edges: { node: { id: string } }[]): string[] =>
- edges.map((edge) => edge.node.id).sort();
-
-const collectRecordIds = (records: { id: string }[]): string[] =>
- records.map((record) => record.id).sort();
-
-const findManyOperation = findManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- filter: ALL_RECORDS_FILTER,
-});
-
-describe('recordShareTwinObjectRecordsPermissions', () => {
- let recordShareStorageService: RecordShareStorageService;
- let objectMetadataId: string;
- let recordShares: RecordShare[];
- let memberRoleId: string;
- let adminRoleId: string;
-
- const sourceId = randomUUID();
-
- const recordIdsSharedInMemory = ({
- principalIds,
- operationType,
- }: {
- principalIds: string[];
- operationType: 'select' | 'update';
- }) => {
- const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({
- recordShares,
- principalIds,
- accessLevels: resolveRequiredRecordShareAccessLevels(operationType),
- });
-
- return ALL_RECORD_IDS.filter((recordId) =>
- sharedRecordIds.has(recordId),
- ).sort();
- };
-
- beforeAll(async () => {
- recordShareStorageService =
- getAppProviderByClassName<RecordShareStorageService>(
- 'RecordShareStorageService',
- );
-
- const { data } = await createOneObjectMetadata({
- input: {
- nameSingular: OBJECT_SINGULAR,
- namePlural: OBJECT_PLURAL,
- labelSingular: 'Record Share Twin Object',
- labelPlural: 'Record Share Twin Objects',
- icon: 'IconLock',
- isLabelSyncedWithName: false,
- },
- });
-
- objectMetadataId = data.createOneObject.id;
-
- await createOneFieldMetadata({
- input: {
- name: 'name',
- label: 'Name',
- type: FieldMetadataType.TEXT,
- objectMetadataId,
- isLabelSyncedWithName: false,
- },
- });
-
- for (const [name, id] of Object.entries(RECORD_IDS)) {
- const response = await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- gqlFields: RECORD_GQL_FIELDS,
- data: { id, name },
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
- }
-
- memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
- adminRoleId = (await findOneRoleByLabel({ label: 'Admin' })).id;
-
- const buildRecordShare = ({
- recordId,
- principalId,
- principalType,
- accessLevel,
- }: {
- recordId: string;
- principalId: string;
- principalType: RecordSharePrincipalType;
- accessLevel: RecordShareAccessLevel;
- }) => ({
- recordId,
- objectMetadataId,
- principalId,
- principalType,
- accessLevel,
- rowCause: RecordShareRowCause.MANUAL,
- sourceId,
- });
-
- await recordShareStorageService.insertMany({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- recordShares: [
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_READ_WITH_JONY,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.READ,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- principalId: memberRoleId,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.READ_WRITE,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- principalId: EVERYONE_PRINCIPAL_ID,
- principalType: RecordSharePrincipalType.EVERYONE,
- accessLevel: RecordShareAccessLevel.FULL,
- }),
- buildRecordShare({
- recordId: RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
- principalId: adminRoleId,
- principalType: RecordSharePrincipalType.ROLE,
- accessLevel: RecordShareAccessLevel.FULL,
- }),
- ],
- });
-
- recordShares = await recordShareStorageService.findByRecordIds({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- objectMetadataId,
- recordIds: ALL_RECORD_IDS,
- });
-
- await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
- });
-
- afterAll(async () => {
- await recordShareStorageService.deleteBySourceId({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- sourceId,
- });
- await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);
- await makeGraphqlApiRequest(
- destroyManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: 'id',
- filter: ALL_RECORDS_FILTER,
- }),
- );
- await updateOneObjectMetadata({
- expectToFail: false,
- input: {
- idToUpdate: objectMetadataId,
- updatePayload: { isActive: false },
- },
- });
- await deleteOneObjectMetadata({
- input: { idToDelete: objectMetadataId },
- });
- });
-
- it('should fetch one row per share of the batch', () => {
- expect(recordShares).toHaveLength(4);
- expect(
- recordShares.every(
- (recordShare) => recordShare.objectMetadataId === objectMetadataId,
- ),
- ).toBe(true);
- });
-
- it('should read the same records in memory as the SQL gate for the admin', async () => {
- const response = await makeGraphqlApiRequest(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
- recordIdsSharedInMemory({
- principalIds: [
- EVERYONE_PRINCIPAL_ID,
- WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- adminRoleId,
- ],
- operationType: 'select',
- }),
- );
- });
-
- it('should read the same records in memory as the SQL gate for the member', async () => {
- const response =
- await makeGraphqlApiRequestWithMemberRole(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
-
- const readRecordIds = collectIds(response.body.data[OBJECT_PLURAL].edges);
-
- expect(readRecordIds).toEqual(
- [
- RECORD_IDS.SHARED_READ_WITH_JONY,
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- ].sort(),
- );
- expect(readRecordIds).toEqual(
- recordIdsSharedInMemory({
- principalIds: [
- EVERYONE_PRINCIPAL_ID,
- WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- memberRoleId,
- ],
- operationType: 'select',
- }),
- );
- });
-
- it('should read the same records in memory as the SQL gate for the api key', async () => {
- const response = await makeGraphqlApiRequestWithApiKey(findManyOperation);
-
- expect(response.body.errors).toBeUndefined();
- expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
- recordIdsSharedInMemory({
- principalIds: [EVERYONE_PRINCIPAL_ID, adminRoleId],
- operationType: 'select',
- }),
- );
- });
-
- it('should update the same records in memory as the SQL gate for the member', async () => {
- const response = await makeGraphqlApiRequestWithMemberRole(
- updateManyOperationFactory({
- objectMetadataSingularName: OBJECT_SINGULAR,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: RECORD_GQL_FIELDS,
- data: { name: 'updated by member' },
- filter: ALL_RECORDS_FILTER,
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- const updatedRecordIds = collectRecordIds(
- response.body.data[UPDATE_RESPONSE_KEY],
- );
-
- expect(updatedRecordIds).toEqual(
- [
- RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
- RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
- ].sort(),
- );
- expect(updatedRecordIds).toEqual(
- recordIdsSharedInMemory({
- principalIds: [
- EVERYONE_PRINCIPAL_ID,
- WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- memberRoleId,
- ],
- operationType: 'update',
- }),
- );
- });
-});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts
deleted file mode 100644
index 12422548994..00000000000
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts
+++ /dev/null
@@ -1,785 +0,0 @@
-import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
-import { restoreOneOperationFactory } from 'test/integration/graphql/utils/restore-one-operation-factory.util';
-import { preserveLegacyRecordAccess } from 'src/database/commands/upgrade-version-command/2-43/utils/preserve-legacy-record-access.util';
-import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
-import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
-import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
-import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
-import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
-import { randomUUID } from 'node:crypto';
-import { parse } from 'graphql';
-import {
- FieldMetadataType,
- MetadataReadability,
- RecordShareAccessLevel,
- RecordSharePrincipalType,
- RecordShareRowCause,
-} from 'twenty-shared/types';
-
-import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
-import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
-import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
-import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
-import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
-import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
-import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';
-import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
-import { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';
-import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
-import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
-import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
-
-import { GRANTABLE_RECORD_SHARE_ACCESS_LEVELS } from 'src/engine/permissions/record-share/constants/grantable-record-share-access-levels.constant';
-import { type RecordSharePrincipalInput } from 'src/engine/permissions/record-share/dtos/record-sharing.dto';
-import { type RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
-import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
-import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
-import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
-
-const OBJECT_NAME = 'sharingPolicyRecord';
-const OBJECT_PLURAL = 'sharingPolicyRecords';
-const RECORD_ID = randomUUID();
-const workspaceId = SEED_APPLE_WORKSPACE_ID;
-const fields =
- 'sharingMode canManageSharing generalAccessLevel permissions { canRead canUpdate canDelete canSoftDelete } roles { id canRead canUpdate } shares { principalId principalRoleId rowCause accessLevel }';
-const READ_SHARING = parse(
- `query RecordSharing($target: RecordTargetInput!) { recordSharing(target: $target) { ${fields} } }`,
-);
-const SET_SHARE = parse(
- `mutation SetShare($target: RecordTargetInput!, $principal: RecordSharePrincipalInput!, $accessLevel: RecordShareAccessLevel!) { sharing: setRecordShare(target: $target, principal: $principal, accessLevel: $accessLevel) { ${fields} } }`,
-);
-const REMOVE_SHARE = parse(
- `mutation RemoveShare($target: RecordTargetInput!, $principal: RecordSharePrincipalInput!) { sharing: removeRecordShare(target: $target, principal: $principal) { ${fields} } }`,
-);
-const SET_GENERAL_ACCESS = parse(
- `mutation SetGeneralAccess($target: RecordTargetInput!, $accessLevel: RecordShareAccessLevel!) { sharing: setRecordGeneralAccess(target: $target, accessLevel: $accessLevel) { ${fields} } }`,
-);
-
-describe('Generic sharing API on an ordinary private object', () => {
- let objectMetadataId: string;
- let memberRoleId: string;
- let shares: RecordShareStorageService;
- const target = () => ({ objectMetadataId, recordId: RECORD_ID });
- const grant = async (
- accessLevel: RecordShareAccessLevel,
- rowCause = RecordShareRowCause.MANUAL,
- ) =>
- shares.insertMany({
- workspaceId,
- recordShares: [
- {
- objectMetadataId,
- recordId: RECORD_ID,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel,
- rowCause,
- sourceId: RECORD_ID,
- },
- ],
- });
- const settings = (token = APPLE_JONY_MEMBER_ACCESS_TOKEN) =>
- makeMetadataApiRequest(
- { query: READ_SHARING, variables: { target: target() } },
- token,
- );
- const share = (
- principal: RecordSharePrincipalInput,
- accessLevel = RecordShareAccessLevel.READ,
- token = APPLE_JONY_MEMBER_ACCESS_TOKEN,
- ) =>
- makeMetadataApiRequest(
- {
- query: SET_SHARE,
- variables: { target: target(), principal, accessLevel },
- },
- token,
- );
- const unshare = (
- principal: RecordSharePrincipalInput,
- token = APPLE_JONY_MEMBER_ACCESS_TOKEN,
- ) =>
- makeMetadataApiRequest(
- { query: REMOVE_SHARE, variables: { target: target(), principal } },
- token,
- );
- const setGeneralAccess = (
- accessLevel: RecordShareAccessLevel,
- token = APPLE_JONY_MEMBER_ACCESS_TOKEN,
- ) =>
- makeMetadataApiRequest(
- {
- query: SET_GENERAL_ACCESS,
- variables: { target: target(), accessLevel },
- },
- token,
- );
- const read = () =>
- makeGraphqlApiRequest(
- findManyOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: 'id',
- filter: { id: { eq: RECORD_ID } },
- }),
- APPLE_JONY_MEMBER_ACCESS_TOKEN,
- );
- const setRoleUpdate = (canUpdateObjectRecords: boolean) =>
- upsertObjectPermissions({
- input: {
- roleId: memberRoleId,
- objectPermissions: [
- {
- objectMetadataId,
- canReadObjectRecords: true,
- canUpdateObjectRecords,
- canSoftDeleteObjectRecords: true,
- canDestroyObjectRecords: true,
- },
- ],
- },
- expectToFail: false,
- });
-
- it('grants edit and full access through the reusable API while preserving role restrictions', async () => {
- const principal = {
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- };
- const invite = (accessLevel: RecordShareAccessLevel) =>
- share(principal, accessLevel, APPLE_JANE_ADMIN_ACCESS_TOKEN);
- expect(
- (await invite(RecordShareAccessLevel.READ_WRITE)).body.errors,
- ).toBeUndefined();
- expect(
- (await settings()).body.data.recordSharing.permissions.canUpdate,
- ).toBe(true);
- await setRoleUpdate(false);
- expect(
- (await settings()).body.data.recordSharing.permissions.canUpdate,
- ).toBe(false);
- await setRoleUpdate(true);
- expect(
- (await invite(RecordShareAccessLevel.FULL)).body.errors,
- ).toBeUndefined();
- expect((await settings()).body.data.recordSharing.canManageSharing).toBe(
- true,
- );
- });
-
- beforeAll(async () => {
- shares = getAppProviderByClassName<RecordShareStorageService>(
- 'RecordShareStorageService',
- );
- const { data } = await createOneObjectMetadata({
- input: {
- nameSingular: OBJECT_NAME,
- namePlural: OBJECT_PLURAL,
- labelSingular: 'Sharing policy record',
- labelPlural: 'Sharing policy records',
- icon: 'IconLock',
- isLabelSyncedWithName: false,
- },
- });
- objectMetadataId = data.createOneObject.id;
- await createOneFieldMetadata({
- input: {
- name: 'name',
- label: 'Name',
- type: FieldMetadataType.TEXT,
- objectMetadataId,
- isLabelSyncedWithName: false,
- },
- });
- expect(
- (
- await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- gqlFields: 'id',
- data: { id: RECORD_ID, name: 'Private' },
- }),
- )
- ).body.errors,
- ).toBeUndefined();
- memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
- await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
- });
-
- beforeEach(async () => {
- await shares.deleteByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- });
- await shares.insertMany({
- workspaceId,
- recordShares: [
- {
- objectMetadataId,
- recordId: RECORD_ID,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.OWNER,
- sourceId: RECORD_ID,
- },
- ],
- });
- });
-
- afterAll(async () => {
- await shares.deleteByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- });
- await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);
- await makeGraphqlApiRequest(
- destroyManyOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: 'id',
- filter: { id: { eq: RECORD_ID } },
- }),
- );
- await updateOneObjectMetadata({
- input: {
- idToUpdate: objectMetadataId,
- updatePayload: { isActive: false },
- },
- expectToFail: false,
- });
- await deleteOneObjectMetadata({ input: { idToDelete: objectMetadataId } });
- });
-
- it('keeps creates private', async () => {
- const recordId = randomUUID();
- const created = await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- gqlFields: 'id',
- data: { id: recordId, name: 'Private create' },
- }),
- );
- expect(created.body.errors).toBeUndefined();
- const recordTarget = { objectMetadataId, recordId };
- try {
- const readSettings = (token: string) =>
- makeMetadataApiRequest(
- { query: READ_SHARING, variables: { target: recordTarget } },
- token,
- );
- expect(
- (await readSettings(APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.errors,
- ).toBeDefined();
- expect(
- (await readSettings(APPLE_JANE_ADMIN_ACCESS_TOKEN)).body.data
- .recordSharing,
- ).toMatchObject({
- sharingMode: 'PRIVATE',
- canManageSharing: true,
- generalAccessLevel: RecordShareAccessLevel.NONE,
- permissions: { canRead: true, canUpdate: true },
- shares: [
- expect.objectContaining({
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- rowCause: 'OWNER',
- accessLevel: 'FULL',
- }),
- ],
- });
- } finally {
- await makeGraphqlApiRequest(
- destroyManyOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- objectMetadataPluralName: OBJECT_PLURAL,
- gqlFields: 'id',
- filter: { id: { eq: recordId } },
- }),
- );
- }
- });
-
- it('batches effective permissions without exposing absent or inaccessible records', async () => {
- const missingTarget = { objectMetadataId, recordId: randomUUID() };
- const foreignTarget = {
- objectMetadataId: randomUUID(),
- recordId: RECORD_ID,
- };
- const query = () =>
- makeMetadataApiRequest(
- {
- query: parse(
- `query Permissions($targets: [RecordTargetInput!]!) { recordPermissions(targets: $targets) { objectMetadataId recordId permissions { canRead canUpdate canDelete canSoftDelete } } }`,
- ),
- variables: { targets: [target(), missingTarget, foreignTarget] },
- },
- APPLE_JONY_MEMBER_ACCESS_TOKEN,
- );
- const denied = {
- canRead: false,
- canUpdate: false,
- canDelete: false,
- canSoftDelete: false,
- };
- const initial = await query();
- expect(initial.body.errors).toBeUndefined();
- expect(initial.body.data.recordPermissions).toEqual(
- [target(), missingTarget, foreignTarget].map((record) => ({
- ...record,
- permissions: denied,
- })),
- );
- await grant(RecordShareAccessLevel.READ_WRITE);
- const granted = await query();
- expect(granted.body.errors).toBeUndefined();
- expect(granted.body.data.recordPermissions).toEqual([
- {
- ...target(),
- permissions: { ...denied, canRead: true, canUpdate: true },
- },
- { ...missingTarget, permissions: denied },
- { ...foreignTarget, permissions: denied },
- ]);
- await setRoleUpdate(false);
- try {
- expect(
- (await query()).body.data.recordPermissions[0].permissions,
- ).toEqual({ ...denied, canRead: true });
- } finally {
- await setRoleUpdate(true);
- }
- });
-
- it('keeps deleted-record sharing available without bypassing grants or role restrictions', async () => {
- const operation = {
- objectMetadataSingularName: OBJECT_NAME,
- recordId: RECORD_ID,
- gqlFields: 'id',
- };
- const deleted = await makeGraphqlApiRequest(
- deleteOneOperationFactory(operation),
- );
- expect(deleted.body.errors).toBeUndefined();
- try {
- expect((await settings()).body.errors).toBeDefined();
- await grant(RecordShareAccessLevel.FULL);
- expect((await settings()).body.data.recordSharing).toMatchObject({
- canManageSharing: true,
- permissions: { canRead: true, canUpdate: true },
- });
- const permissions = await makeMetadataApiRequest(
- {
- query: parse(
- `query Permissions($targets: [RecordTargetInput!]!) { recordPermissions(targets: $targets) { permissions { canRead canUpdate } } }`,
- ),
- variables: { targets: [target()] },
- },
- APPLE_JONY_MEMBER_ACCESS_TOKEN,
- );
- expect(permissions.body.data.recordPermissions[0].permissions).toEqual({
- canRead: true,
- canUpdate: true,
- });
- expect(
- (await setGeneralAccess(RecordShareAccessLevel.READ)).body.errors,
- ).toBeUndefined();
- await setRoleUpdate(false);
- expect(
- (await setGeneralAccess(RecordShareAccessLevel.NONE)).body.errors,
- ).toBeDefined();
- } finally {
- await setRoleUpdate(true);
- const restored = await makeGraphqlApiRequest(
- restoreOneOperationFactory(operation),
- );
- expect(restored.body.errors).toBeUndefined();
- }
- });
-
- it('matches ordinary read permissions and hides sharing audience from viewers', async () => {
- expect((await read()).body.data[OBJECT_PLURAL].edges).toEqual([]);
- expect((await settings()).body.errors).toBeDefined();
- await grant(RecordShareAccessLevel.READ);
- expect(
- (await read()).body.data[OBJECT_PLURAL].edges.map(
- ({ node }: { node: { id: string } }) => node.id,
- ),
- ).toEqual([RECORD_ID]);
- expect((await settings()).body.data.recordSharing).toMatchObject({
- permissions: { canRead: true, canUpdate: false, canDelete: false },
- canManageSharing: false,
- shares: [],
- roles: [],
- });
- expect(
- (await setGeneralAccess(RecordShareAccessLevel.READ)).body.errors,
- ).toBeDefined();
- });
-
- it.each([RecordShareAccessLevel.READ, RecordShareAccessLevel.READ_WRITE])(
- 'refuses additions, changes, removals and self-escalation by %s recipients',
- async (accessLevel) => {
- await grant(accessLevel);
- await setGeneralAccess(
- RecordShareAccessLevel.READ,
- APPLE_JANE_ADMIN_ACCESS_TOKEN,
- );
- const before = await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- });
- const jony = { workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY };
- for (const attempt of [
- () => share({ roleId: memberRoleId }, RecordShareAccessLevel.READ),
- () => setGeneralAccess(RecordShareAccessLevel.READ_WRITE),
- () => setGeneralAccess(RecordShareAccessLevel.NONE),
- () => share(jony, RecordShareAccessLevel.FULL),
- () => unshare(jony),
- ]) {
- expect((await attempt()).body.errors).toBeDefined();
- }
- expect(
- await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- }),
- ).toEqual(before);
- expect((await settings()).body.data.recordSharing).toMatchObject({
- canManageSharing: false,
- shares: [],
- roles: [],
- permissions: {
- canUpdate: accessLevel === RecordShareAccessLevel.READ_WRITE,
- },
- });
- if (accessLevel === RecordShareAccessLevel.READ_WRITE) {
- const updated = await makeGraphqlApiRequest(
- updateOneOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- gqlFields: 'id',
- recordId: RECORD_ID,
- data: { name: 'Updated by editor' },
- }),
- APPLE_JONY_MEMBER_ACCESS_TOKEN,
- );
- expect(updated.body.errors).toBeUndefined();
- }
- },
- );
-
- it.each(['member', 'role', 'everyone'])(
- 'allows FULL from a %s grant to manage every manual level without changing managed grants',
- async (audience) => {
- await shares.insertMany({
- workspaceId,
- recordShares: [
- {
- objectMetadataId,
- recordId: RECORD_ID,
- sourceId: RECORD_ID,
- rowCause: RecordShareRowCause.MANUAL,
- accessLevel: RecordShareAccessLevel.FULL,
- principalType:
- audience === 'member'
- ? RecordSharePrincipalType.WORKSPACE_MEMBER
- : audience === 'role'
- ? RecordSharePrincipalType.ROLE
- : RecordSharePrincipalType.EVERYONE,
- principalId:
- audience === 'member'
- ? WORKSPACE_MEMBER_DATA_SEED_IDS.JONY
- : audience === 'role'
- ? memberRoleId
- : EVERYONE_PRINCIPAL_ID,
- },
- ...[RecordShareRowCause.RULE, RecordShareRowCause.APPLICATION].map(
- (rowCause) => ({
- objectMetadataId,
- recordId: RECORD_ID,
- sourceId: RECORD_ID,
- rowCause,
- accessLevel: RecordShareAccessLevel.READ,
- principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- }),
- ),
- ],
- });
- const principal = {
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
- };
- for (const accessLevel of GRANTABLE_RECORD_SHARE_ACCESS_LEVELS) {
- const response = await share(principal, accessLevel);
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.sharing.canManageSharing).toBe(true);
- expect(response.body.data.sharing.shares).toEqual(
- expect.arrayContaining([
- expect.objectContaining({
- principalId: principal.workspaceMemberId,
- rowCause: 'MANUAL',
- accessLevel,
- }),
- ]),
- );
- }
- expect((await unshare(principal)).body.errors).toBeUndefined();
- const remaining = await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- });
- expect(
- remaining
- .filter((share) => share.principalId === principal.workspaceMemberId)
- .map((share) => share.rowCause)
- .sort(),
- ).toEqual(['APPLICATION', 'OWNER', 'RULE']);
- },
- );
-
- it('commits self-downgrade but immediately removes grant management', async () => {
- await grant(RecordShareAccessLevel.FULL);
- const response = await share(
- { workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY },
- RecordShareAccessLevel.READ_WRITE,
- );
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.sharing).toMatchObject({
- canManageSharing: false,
- permissions: { canRead: true, canUpdate: true },
- shares: [],
- roles: [],
- });
- expect(
- (await setGeneralAccess(RecordShareAccessLevel.READ)).body.errors,
- ).toBeDefined();
- });
-
- it('keeps object role permissions above even FULL record grants', async () => {
- await grant(RecordShareAccessLevel.FULL);
- await setRoleUpdate(false);
- try {
- expect(
- (await settings()).body.data.recordSharing.permissions.canUpdate,
- ).toBe(false);
- expect(
- (await setGeneralAccess(RecordShareAccessLevel.READ)).body.errors,
- ).toBeDefined();
- const result = await makeGraphqlApiRequest(
- updateOneOperationFactory({
- objectMetadataSingularName: OBJECT_NAME,
- gqlFields: 'id',
- recordId: RECORD_ID,
- data: { name: 'Forbidden' },
- }),
- APPLE_JONY_MEMBER_ACCESS_TOKEN,
- );
- expect(result.body.errors).toBeDefined();
- } finally {
- await setRoleUpdate(true);
- }
- });
-
- it('enforces saved grants', async () => {
- await grant(RecordShareAccessLevel.READ);
- expect((await read()).body.data[OBJECT_PLURAL].edges).toHaveLength(1);
- expect(
- (await settings(APPLE_JANE_ADMIN_ACCESS_TOKEN)).body.data.recordSharing,
- ).toMatchObject({
- sharingMode: 'PRIVATE',
- canManageSharing: true,
- permissions: { canUpdate: true },
- });
- await grant(RecordShareAccessLevel.READ, RecordShareRowCause.APPLICATION);
- expect((await read()).body.data[OBJECT_PLURAL].edges).toHaveLength(1);
- expect(
- (
- await unshare(
- { workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY },
- APPLE_JANE_ADMIN_ACCESS_TOKEN,
- )
- ).body.errors,
- ).toBeUndefined();
- const remaining = await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- });
- expect(remaining.map(({ rowCause }) => rowCause).sort()).toEqual([
- 'APPLICATION',
- 'OWNER',
- ]);
- });
-
- it('reports the role behind each member grant and what each role can do on the object', async () => {
- await grant(RecordShareAccessLevel.READ);
- const readRoles = async () => {
- const response = await settings(APPLE_JANE_ADMIN_ACCESS_TOKEN);
- expect(response.body.errors).toBeUndefined();
- return response.body.data.recordSharing;
- };
- const sharing = await readRoles();
- expect(sharing.shares).toEqual(
- expect.arrayContaining([
- expect.objectContaining({
- principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- principalRoleId: memberRoleId,
- }),
- ]),
- );
- expect(sharing.roles).toEqual(
- expect.arrayContaining([
- { id: memberRoleId, canRead: true, canUpdate: true },
- ]),
- );
- await setRoleUpdate(false);
- try {
- expect((await readRoles()).roles).toEqual(
- expect.arrayContaining([
- { id: memberRoleId, canRead: true, canUpdate: false },
- ]),
- );
- } finally {
- await setRoleUpdate(true);
- }
- });
-
- it('commits self-revocation and returns a redacted response', async () => {
- await grant(RecordShareAccessLevel.FULL);
- const response = await unshare({
- workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
- });
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.sharing).toMatchObject({
- sharingMode: 'PRIVATE',
- canManageSharing: false,
- generalAccessLevel: null,
- permissions: { canRead: false, canUpdate: false },
- shares: [],
- roles: [],
- });
- expect((await read()).body.data[OBJECT_PLURAL].edges).toEqual([]);
- });
-
- it('serializes repeated grants and rejects missing target records', async () => {
- await grant(RecordShareAccessLevel.FULL);
- const responses = await Promise.all(
- Array.from({ length: 5 }, () =>
- setGeneralAccess(RecordShareAccessLevel.READ),
- ),
- );
- for (const response of responses)
- expect(response.body.errors).toBeUndefined();
- expect(
- (
- await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [RECORD_ID],
- })
- ).filter(
- ({ principalType }) =>
- principalType === RecordSharePrincipalType.EVERYONE,
- ),
- ).toHaveLength(1);
- const missingId = randomUUID();
- const missing = await makeMetadataApiRequest({
- query: SET_GENERAL_ACCESS,
- variables: {
- target: { objectMetadataId, recordId: missingId },
- accessLevel: RecordShareAccessLevel.READ,
- },
- });
- expect(missing.body.errors).toBeDefined();
- expect(
- await shares.findByRecordIds({
- workspaceId,
- objectMetadataId,
- recordIds: [missingId],
- }),
- ).toEqual([]);
- });
- it('preserves legacy access once without sharing records created after the migration', async () => {
- const cache = getAppProviderByClassName<WorkspaceCacheService>(
- 'WorkspaceCacheService',
- );
- const { flatObjectMetadataMaps } = await cache.getOrRecompute(workspaceId, [
- 'flatObjectMetadataMaps',
- ]);
- const objects = Object.values(flatObjectMetadataMaps.byUniversalIdentifier)
- .filter(
- (object) =>
- object?.id === objectMetadataId ||
- object?.universalIdentifier ===
- STANDARD_OBJECTS.agentChatThread.universalIdentifier,
- )
- .map((object) => ({
- ...object!,
- readability:
- object!.id === objectMetadataId
- ? MetadataReadability.PRIVATE
- : MetadataReadability.SYSTEM,
- }));
- const object = objects.find((item) => item.id === objectMetadataId)!;
- const schema = escapeIdentifier(getWorkspaceSchemaName(workspaceId));
- const runner = global.testDataSource.createQueryRunner();
- await runner.connect();
- await runner.startTransaction();
- try {
- await runner.query(
- `DELETE FROM core."keyValuePair" WHERE "workspaceId" = $1 AND "key" = 'COMMON_RECORD_SHARING_LEGACY_ACCESS_MIGRATED'`,
- [workspaceId],
- );
- const migration = () =>
- preserveLegacyRecordAccess({
- manager: runner.manager,
- workspaceId,
- objects,
- wasRecordSharingEnabled: false,
- });
- const threadObject = objects.find(
- (item) =>
- item.universalIdentifier ===
- STANDARD_OBJECTS.agentChatThread.universalIdentifier,
- )!;
- const threadGrantsBefore = await runner.query(
- `SELECT id FROM ${schema}."recordShare" WHERE "objectMetadataId" = $1 AND "principalId" = $2 ORDER BY id`,
- [threadObject.id, EVERYONE_PRINCIPAL_ID],
- );
- await migration();
- expect(
- await runner.query(
- `SELECT id FROM ${schema}."recordShare" WHERE "objectMetadataId" = $1 AND "principalId" = $2 ORDER BY id`,
- [threadObject.id, EVERYONE_PRINCIPAL_ID],
- ),
- ).toEqual(threadGrantsBefore);
- const grants = await runner.query(
- `SELECT "accessLevel", "rowCause" FROM ${schema}."recordShare" WHERE "objectMetadataId" = $1 AND "recordId" = $2 AND "principalId" = $3`,
- [objectMetadataId, RECORD_ID, EVERYONE_PRINCIPAL_ID],
- );
- expect(grants).toEqual([
- { accessLevel: 'FULL', rowCause: 'APPLICATION' },
- ]);
- const newId = randomUUID();
- await runner.query(
- `INSERT INTO ${schema}.${escapeIdentifier(computeObjectTargetTable(object))} (id, "createdByName", "createdBySource", "updatedByName", "updatedBySource") SELECT $1, "createdByName", "createdBySource", "updatedByName", "updatedBySource" FROM ${schema}.${escapeIdentifier(computeObjectTargetTable(object))} record WHERE id = $2`,
- [newId, RECORD_ID],
- );
- await migration();
- expect(
- await runner.query(
- `SELECT id FROM ${schema}."recordShare" WHERE "recordId" = $1`,
- [newId],
- ),
- ).toEqual([]);
- } finally {
- await runner.rollbackTransaction();
- await runner.release();
- }
- });
-});
diff --git a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
index bd801300f76..850e9c67fdf 100644
--- a/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/workflow/core-workflow-visibility.integration-spec.ts
@@ -28,7 +28,6 @@ import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { EngineComponentKey } from 'src/engine/metadata-modules/command-menu-item/enums/engine-component-key.enum';
-import { type UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';
import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
@@ -198,34 +197,6 @@ const createActiveManualWorkflow = async (name: string) => {
return createdWorkflow;
};
-// The record API the run pages read, not the core workflow API #26243 already gates.
-const findRecordIds = async (
- requester: (query: string, variables?: object) => request.Test,
- objectNamePlural: 'workflowRuns',
- id: string,
-) => {
- const response = await requester(
- `
- query FindRecords($id: UUID!) {
- ${objectNamePlural}(filter: { id: { eq: $id } }) {
- edges {
- node {
- id
- }
- }
- }
- }
- `,
- { id },
- );
-
- expect(response.body.errors).toBeUndefined();
-
- return response.body.data[objectNamePlural].edges.map(
- ({ node }: { node: { id: string } }) => node.id,
- );
-};
-
describe('core workflow visibility (e2e)', () => {
let workspaceWorkflowId: string;
let coreWorkflowId: string;
@@ -657,88 +628,6 @@ describe('core workflow visibility (e2e)', () => {
});
});
- describe('the runs of a workflow', () => {
- let runsCoreWorkflowId: string;
- let runsCoreWorkflowVersionId: string;
- let workflowRunId: string;
-
- const runWorkflow = () =>
- runCoreWorkflowVersion({
- coreWorkflowVersionId: runsCoreWorkflowVersionId,
- });
-
- beforeAll(async () => {
- ({
- coreWorkflowId: runsCoreWorkflowId,
- coreWorkflowVersionId: runsCoreWorkflowVersionId,
- } = await createActiveManualWorkflow('Workflow With Runs'));
-
- workflowRunId = await runWorkflow();
- });
-
- afterAll(async () => {
- if (isDefined(runsCoreWorkflowId)) {
- await setVisibility(runsCoreWorkflowId, WorkflowVisibility.WORKSPACE);
- await deleteCoreWorkflows({ coreWorkflowIds: [runsCoreWorkflowId] });
- }
- });
-
- it('lets another member read them while the workflow is visible to the workspace', async () => {
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', workflowRunId),
- ).toEqual([workflowRunId]);
- });
-
- it('hides them from another member once the workflow is private', async () => {
- const response = await setVisibility(
- runsCoreWorkflowId,
- WorkflowVisibility.PRIVATE,
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', workflowRunId),
- ).toEqual([]);
- });
-
- it('keeps them readable by its creator while private', async () => {
- expect(
- await findRecordIds(
- workflowGraphqlRequest,
- 'workflowRuns',
- workflowRunId,
- ),
- ).toEqual([workflowRunId]);
- });
-
- it('keeps a run started while private to its creator', async () => {
- const privateRunId = await runWorkflow();
-
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', privateRunId),
- ).toEqual([]);
- expect(
- await findRecordIds(
- workflowGraphqlRequest,
- 'workflowRuns',
- privateRunId,
- ),
- ).toEqual([privateRunId]);
- });
-
- it('gives them back to another member once the workflow is visible to the workspace again', async () => {
- const response = await setVisibility(
- runsCoreWorkflowId,
- WorkflowVisibility.WORKSPACE,
- );
-
- expect(response.body.errors).toBeUndefined();
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', workflowRunId),
- ).toEqual([workflowRunId]);
- });
- });
-
// An agent step's conversation belongs to its recipient, or else the workflow's creator, whatever the workflow's visibility.
describe('the conversation an agent step records on a run', () => {
let conversationCoreWorkflowId: string;
@@ -869,85 +758,4 @@ describe('core workflow visibility (e2e)', () => {
});
// Removing a member deletes the membership, which nulls the creator of every workflow they created.
- describe('the runs of a private workflow whose creator is removed from the workspace', () => {
- const removedUserId = randomUUID();
- const removedUserWorkspaceId = randomUUID();
- let orphanedCoreWorkflowId: string;
- let orphanedRunId: string;
-
- beforeAll(async () => {
- let orphanedCoreWorkflowVersionId: string;
-
- ({
- coreWorkflowId: orphanedCoreWorkflowId,
- coreWorkflowVersionId: orphanedCoreWorkflowVersionId,
- } = await createActiveManualWorkflow('Workflow Of A Removed Member'));
-
- expect(
- (
- await setVisibility(
- orphanedCoreWorkflowId,
- WorkflowVisibility.PRIVATE,
- )
- ).body.errors,
- ).toBeUndefined();
-
- orphanedRunId = await runCoreWorkflowVersion({
- coreWorkflowVersionId: orphanedCoreWorkflowVersionId,
- });
-
- await global.testDataSource.query(
- `INSERT INTO core."user" (id, email) VALUES ($1, $2)`,
- [removedUserId, `removed-${removedUserId}@apple.dev`],
- );
- await global.testDataSource.query(
- `INSERT INTO core."userWorkspace" (id, "userId", "workspaceId") VALUES ($1, $2, $3)`,
- [removedUserWorkspaceId, removedUserId, SEED_APPLE_WORKSPACE_ID],
- );
- await global.testDataSource.query(
- `UPDATE core."workflow" SET "createdByUserWorkspaceId" = $2 WHERE id = $1`,
- [orphanedCoreWorkflowId, removedUserWorkspaceId],
- );
- });
-
- afterAll(async () => {
- await global.testDataSource.query(
- `DELETE FROM core."userWorkspace" WHERE id = $1`,
- [removedUserWorkspaceId],
- );
- await global.testDataSource.query(
- `DELETE FROM core."user" WHERE id = $1`,
- [removedUserId],
- );
-
- if (isDefined(orphanedCoreWorkflowId)) {
- await deleteCoreWorkflows({
- coreWorkflowIds: [orphanedCoreWorkflowId],
- });
- }
- });
-
- it('become readable to the workspace, as core now shows the workflow', async () => {
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', orphanedRunId),
- ).toEqual([]);
-
- await getAppProviderByClassName<UserWorkspaceService>(
- 'UserWorkspaceService',
- ).deleteUserWorkspace({
- userWorkspaceId: removedUserWorkspaceId,
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- });
-
- const [coreWorkflow] = await global.testDataSource.query(
- `SELECT "createdByUserWorkspaceId" FROM core."workflow" WHERE id = $1`,
- [orphanedCoreWorkflowId],
- );
-
- expect(coreWorkflow.createdByUserWorkspaceId).toBeNull();
- expect(
- await findRecordIds(asOtherMember, 'workflowRuns', orphanedRunId),
- ).toEqual([orphanedRunId]);
- });
- });
});
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/update-one-object-metadata-readability.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/update-one-object-metadata-readability.integration-spec.ts
index 6409c645849..188f9e5f606 100644
--- a/packages/twenty-server/test/integration/metadata/suites/object-metadata/update-one-object-metadata-readability.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/update-one-object-metadata-readability.integration-spec.ts
@@ -36,23 +36,7 @@ describe('Object metadata readability update', () => {
});
it('should update the readability of a custom object', async () => {
- const { data: privateData } = await updateOneObjectMetadata({
- expectToFail: false,
- input: {
- idToUpdate: customObjectMetadataId,
- updatePayload: { readability: MetadataReadability.PRIVATE },
- },
- gqlFields: `
- id
- readability
- `,
- });
-
- expect(privateData.updateOneObject.readability).toBe(
- MetadataReadability.PRIVATE,
- );
-
- const { data: openData } = await updateOneObjectMetadata({
+ const { data } = await updateOneObjectMetadata({
expectToFail: false,
input: {
idToUpdate: customObjectMetadataId,
@@ -64,10 +48,11 @@ describe('Object metadata readability update', () => {
`,
});
- expect(openData.updateOneObject.readability).toBe(MetadataReadability.OPEN);
+ expect(data.updateOneObject.readability).toBe(MetadataReadability.OPEN);
});
it.each([
+ MetadataReadability.PRIVATE,
MetadataReadability.SYSTEM,
MetadataReadability.APPLICATION,
MetadataReadability.INHERITED,
@@ -135,7 +120,7 @@ describe('Object metadata readability update', () => {
expectToFail: true,
input: {
idToUpdate: companyObject.id,
- updatePayload: { readability: MetadataReadability.PRIVATE },
+ updatePayload: { readability: MetadataReadability.OPEN },
},
});
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793460623155-make-chat-threads-private-records.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793460623155-make-chat-threads-private-records.integration-spec.ts
new file mode 100644
index 00000000000..2ae83d69392
--- /dev/null
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793460623155-make-chat-threads-private-records.integration-spec.ts
@@ -0,0 +1,99 @@
+import { randomUUID } from 'node:crypto';
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+import { type MakeChatThreadsPrivateRecordsCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793460623155-make-chat-threads-private-records.command';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const SCHEMA = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);
+
+describe('2-55 workspace command - make chat threads private records (integration)', () => {
+ let command: MakeChatThreadsPrivateRecordsCommand;
+ let threadObjectMetadataId: string;
+ let privateThreadId: string;
+ let sharedThreadId: string;
+
+ const runOnWorkspace = (options: { dryRun?: boolean } = {}) =>
+ command.runOnWorkspace({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ options,
+ index: 0,
+ total: 1,
+ dataSource: global.testDataSource,
+ });
+
+ const findPrivateThreadIds = async (): Promise<string[]> =>
+ (
+ await global.testDataSource.query(
+ `SELECT id FROM "${SCHEMA}"."agentChatThread" WHERE "_isPrivate" AND id = ANY($1)`,
+ [[privateThreadId, sharedThreadId]],
+ )
+ ).map(({ id }: { id: string }) => id);
+
+ const countEveryoneShares = async (): Promise<number> => {
+ const [{ count }] = await global.testDataSource.query(
+ `SELECT COUNT(*) AS count FROM "${SCHEMA}"."recordShare"
+ WHERE "objectMetadataId" = $1 AND "principalType" = 'EVERYONE' AND "recordId" = ANY($2)`,
+ [threadObjectMetadataId, [privateThreadId, sharedThreadId]],
+ );
+
+ return Number(count);
+ };
+
+ beforeAll(async () => {
+ command = getAppProviderByClassName<MakeChatThreadsPrivateRecordsCommand>(
+ 'MakeChatThreadsPrivateRecordsCommand',
+ );
+
+ [{ id: threadObjectMetadataId }] = await global.testDataSource.query(
+ `SELECT id FROM core."objectMetadata" WHERE "workspaceId" = $1 AND "nameSingular" = 'agentChatThread'`,
+ [SEED_APPLE_WORKSPACE_ID],
+ );
+ privateThreadId = randomUUID();
+ sharedThreadId = randomUUID();
+ await global.testDataSource.query(
+ `INSERT INTO "${SCHEMA}"."agentChatThread" (id) VALUES ($1), ($2)`,
+ [privateThreadId, sharedThreadId],
+ );
+ await global.testDataSource.query(
+ `INSERT INTO "${SCHEMA}"."recordShare"
+ ("objectMetadataId", "recordId", "principalId", "principalType", "accessLevel", "rowCause", "sourceId")
+ VALUES ($1, $2, $4, 'EVERYONE', 'NONE', 'MANUAL', $2), ($1, $3, $4, 'EVERYONE', 'READ_WRITE', 'MANUAL', $3)`,
+ [
+ threadObjectMetadataId,
+ privateThreadId,
+ sharedThreadId,
+ EVERYONE_PRINCIPAL_ID,
+ ],
+ );
+ });
+
+ afterAll(async () => {
+ await global.testDataSource.query(
+ `DELETE FROM "${SCHEMA}"."recordShare" WHERE "recordId" = ANY($1)`,
+ [[privateThreadId, sharedThreadId]],
+ );
+ await global.testDataSource.query(
+ `DELETE FROM "${SCHEMA}"."agentChatThread" WHERE id = ANY($1)`,
+ [[privateThreadId, sharedThreadId]],
+ );
+ });
+
+ it('changes nothing on a dry run', async () => {
+ await runOnWorkspace({ dryRun: true });
+
+ expect(await findPrivateThreadIds()).toEqual([]);
+ expect(await countEveryoneShares()).toBe(2);
+ });
+
+ it('makes every chat thread private and drops its everyone shares', async () => {
+ await runOnWorkspace();
+
+ expect((await findPrivateThreadIds()).sort()).toEqual(
+ [privateThreadId, sharedThreadId].sort(),
+ );
+ expect(await countEveryoneShares()).toBe(0);
+ });
+});