Skip to content

The open alternative to Salesforce, designed for AI.

Batch chat recipient permission checks (#28937)

Raphaël Bosiaa9ec37f20f7
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-share-principal.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-share-principal.service.ts
index 603a3528f8a..2386339822e 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-share-principal.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-share-principal.service.ts
@@ -11,7 +11,7 @@ import {
RecordShareExceptionCode,
} from 'src/engine/core-modules/record-share/record-share.exception';
import { type RecordShareInput } from 'src/engine/core-modules/record-share/types/record-share-input.type';
-import { buildRoleRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-role-row-access-policy-subject.util';
+import { buildWorkspaceMemberRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-workspace-member-row-access-policy-subject.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@@ -161,25 +161,19 @@ export class RecordSharePrincipalService {
shouldBypassPermissionChecks: true,
})
.findOne({ where: { id: principal.principalId } });
- const roleSubject = buildRoleRowAccessPolicySubject({
- roleId,
- owningApplicationId: undefined,
- rolesPermissions,
- roleIdsWithAllRecordsAccess,
- flatRowLevelPermissionPredicateMaps,
- flatRowLevelPermissionPredicateGroupMaps,
- flatFieldMetadataMaps,
- flatObjectMetadataMaps,
- workspaceMember: workspaceMember ?? undefined,
- });
const policy = repository.buildRowAccessPolicy({
- subject: {
- ...roleSubject,
- principalIds: [
- ...(roleSubject.principalIds ?? []),
- principal.principalId,
- ],
- },
+ subject: buildWorkspaceMemberRowAccessPolicySubject({
+ roleId,
+ owningApplicationId: undefined,
+ rolesPermissions,
+ roleIdsWithAllRecordsAccess,
+ flatRowLevelPermissionPredicateMaps,
+ flatRowLevelPermissionPredicateGroupMaps,
+ flatFieldMetadataMaps,
+ flatObjectMetadataMaps,
+ workspaceMemberId: principal.principalId,
+ workspaceMember: workspaceMember ?? undefined,
+ }),
operationType: 'select',
});
const reachableRecordIds =
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-workspace-member-row-access-policy-subject.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-workspace-member-row-access-policy-subject.util.ts
new file mode 100644
index 00000000000..b7e40eb2f58
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-workspace-member-row-access-policy-subject.util.ts
@@ -0,0 +1,18 @@
+/* @license Enterprise */
+
+import { buildRoleRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-role-row-access-policy-subject.util';
+import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/types/row-access-policy.type';
+
+export const buildWorkspaceMemberRowAccessPolicySubject = ({
+ workspaceMemberId,
+ ...roleSubjectArguments
+}: Parameters<typeof buildRoleRowAccessPolicySubject>[0] & {
+ workspaceMemberId: string;
+}): RowAccessPolicySubject => {
+ const roleSubject = buildRoleRowAccessPolicySubject(roleSubjectArguments);
+
+ return {
+ ...roleSubject,
+ principalIds: [...(roleSubject.principalIds ?? []), workspaceMemberId],
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module.ts
index 3026ff0c498..40392fef987 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/agent-chat-thread.module.ts
@@ -1,8 +1,10 @@
import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
import { RecordShareModule } from 'src/engine/core-modules/record-share/record-share.module';
import { RecordShareStorageModule } from 'src/engine/core-modules/record-share/record-share-storage.module';
+import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { UserWorkspaceModule } from 'src/engine/core-modules/user-workspace/user-workspace.module';
import { AgentChatThreadLifecycleModule } from 'src/engine/metadata-modules/ai/ai-chat/agent-chat-thread-lifecycle.module';
import { EndAgentChatChannelSnoozeJob } from 'src/engine/metadata-modules/ai/ai-chat/jobs/end-agent-chat-channel-snooze.job';
@@ -35,6 +37,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
RecordShareModule,
RecordShareStorageModule,
TypeORMModule,
+ TypeOrmModule.forFeature([UserWorkspaceEntity]),
UserWorkspaceModule,
WorkspaceCacheModule,
],
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts
index 7df13c7d35a..04a1f93dbe4 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-chat/query-hooks/__tests__/agent-chat-thread-create.post-query.hook.spec.ts
@@ -147,6 +147,8 @@ const buildContext = ({
{} as never,
workspaceOrmManager as never,
{} as never,
+ {} as never,
+ {} as never,
);
jest
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 c111b96d080..e8b8aa4fb2d 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
@@ -6,18 +6,26 @@ import { hasAgentChatThreadChannelField } from 'src/engine/metadata-modules/ai/a
import { getAgentChatThreadParticipantTable } from 'src/engine/metadata-modules/ai/ai-chat/utils/get-agent-chat-thread-participant-table.util';
import { backfillWorkspaceChatThreadOwnerGrants } from 'src/engine/metadata-modules/ai/ai-chat/utils/backfill-workspace-chat-thread-owner-grants.util';
import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
import chunk from 'lodash.chunk';
+import { In, Repository } from 'typeorm';
import { PermissionFlagType } from 'twenty-shared/constants';
-import { RecordShareAccessLevel } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import {
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+} from 'twenty-shared/types';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { buildRecordShareLockKey } from 'src/engine/core-modules/record-share/utils/build-record-share-lock-key.util';
import { RecordShareException } from 'src/engine/core-modules/record-share/record-share.exception';
import { RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
+import { RecordSharePrincipalService } from 'src/engine/core-modules/record-share/services/record-share-principal.service';
import { RecordSharingService } from 'src/engine/core-modules/record-share/services/record-sharing.service';
+import { buildWorkspaceMemberRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-workspace-member-row-access-policy-subject.util';
import { UserWorkspaceAuthContextService } from 'src/engine/core-modules/user-workspace/services/user-workspace-auth-context.service';
+import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { type AgentChatThreadAccessArgs } from 'src/engine/metadata-modules/ai/ai-chat/types/agent-chat-thread-access-args.type';
import { acquireAgentChatChannelGrantLocksForThreadWriteOrThrow } from 'src/engine/metadata-modules/ai/ai-chat/utils/acquire-agent-chat-channel-grant-locks-for-thread-write-or-throw.util';
import { findAgentChatFlatObjectMetadata } from 'src/engine/metadata-modules/ai/ai-chat/utils/find-agent-chat-flat-object-metadata.util';
@@ -32,13 +40,26 @@ import {
AiException,
AiExceptionCode,
} from 'src/engine/metadata-modules/ai/ai.exception';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { isPermissionFlagGrantedToFlatRole } from 'src/engine/metadata-modules/flat-role/utils/is-permission-flag-granted-to-flat-role.util';
import { PermissionsService } from 'src/engine/metadata-modules/permissions/permissions.service';
import { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';
+import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
+import {
+ type RowAccessPolicy,
+ type RowAccessPolicySubject,
+} from 'src/engine/twenty-orm/types/row-access-policy.type';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
const READABLE_THREAD_IDS_BATCH_SIZE = 1000;
+const AGENT_CHAT_REPLY_OPERATION_TYPES = [
+ 'select',
+ 'update',
+] as const satisfies OperationType[];
+
const EDIT_ACCESS_LEVELS: (RecordShareAccessLevel | null | undefined)[] = [
RecordShareAccessLevel.READ_WRITE,
RecordShareAccessLevel.FULL,
@@ -56,6 +77,9 @@ export class AgentChatSharingService {
private readonly permissionsService: PermissionsService,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly channelGrantService: AgentChatChannelGrantService,
+ private readonly recordSharePrincipalService: RecordSharePrincipalService,
+ @InjectRepository(UserWorkspaceEntity)
+ private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
) {}
// TODO(@FelixMalfait): remove once 2.51 leaves the cross-upgrade window. Until
@@ -209,6 +233,99 @@ export class AgentChatSharingService {
);
}
+ async findEligibleParticipantWorkspaceMemberIds({
+ memberIds,
+ workspaceId,
+ workspaceMemberId,
+ threadId,
+ shouldConsiderNewShares = true,
+ }: AgentChatThreadAccessArgs & {
+ memberIds: string[];
+ shouldConsiderNewShares?: boolean;
+ }): Promise<string[]> {
+ const candidateMemberIds = [...new Set(memberIds)].filter(
+ (memberId) => memberId !== workspaceMemberId,
+ );
+
+ if (!isNonEmptyArray(candidateMemberIds)) {
+ return [];
+ }
+
+ const authContext = await this.getAuthContext({
+ workspaceId,
+ workspaceMemberId,
+ });
+ const roleIdByMemberId = await this.findParticipantRoleIdsWithAiAccess({
+ workspaceId,
+ memberIds: candidateMemberIds,
+ });
+
+ if (roleIdByMemberId.size === 0) {
+ return [];
+ }
+
+ const canManageSharing = await this.canManageThreadSharing({
+ workspaceId,
+ threadId,
+ authContext,
+ });
+ const permissionMaps = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ [
+ 'rolesPermissions',
+ 'roleIdsWithAllRecordsAccess',
+ 'flatRowLevelPermissionPredicateMaps',
+ 'flatRowLevelPermissionPredicateGroupMaps',
+ 'flatFieldMetadataMaps',
+ 'flatObjectMetadataMaps',
+ ],
+ );
+
+ return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const members = await this.workspaceOrmManager
+ .getRepository<WorkspaceMemberWorkspaceEntity>('workspaceMember', {
+ shouldBypassPermissionChecks: true,
+ })
+ .find({ where: { id: In([...roleIdByMemberId.keys()]) } });
+ const repository = this.workspaceOrmManager.getRepository(
+ 'agentChatThread',
+ { shouldBypassPermissionChecks: true },
+ );
+ const policiesBySubjectId = new Map(
+ members.flatMap((member) => {
+ const roleId = roleIdByMemberId.get(member.id);
+
+ if (!isDefined(roleId)) {
+ return [];
+ }
+
+ const policy = this.buildParticipantReplyPolicy({
+ repository,
+ canManageSharing: shouldConsiderNewShares && canManageSharing,
+ subject: buildWorkspaceMemberRowAccessPolicySubject({
+ ...permissionMaps,
+ roleId,
+ owningApplicationId: undefined,
+ workspaceMemberId: member.id,
+ workspaceMember: member,
+ }),
+ });
+
+ return [[member.id, policy] as const];
+ }),
+ );
+ const admittedMemberIds =
+ await repository.findSubjectIdsAdmittedByRowAccessPolicies({
+ recordId: threadId,
+ policiesBySubjectId,
+ });
+
+ return candidateMemberIds.filter((memberId) =>
+ admittedMemberIds.has(memberId),
+ );
+ }, authContext);
+ }
+
async createThread(args: {
workspaceId: string;
workspaceMemberId: string;
@@ -556,6 +673,149 @@ export class AgentChatSharingService {
return keptMemberIds.filter(isDefined);
}
+ private async findParticipantRoleIdsWithAiAccess({
+ workspaceId,
+ memberIds,
+ }: {
+ workspaceId: string;
+ memberIds: string[];
+ }): Promise<Map<string, string>> {
+ const [
+ roleIds,
+ { flatWorkspaceMemberMaps, flatRoleMaps, flatRolePermissionFlagMaps },
+ ] = await Promise.all([
+ this.recordSharePrincipalService.resolveRoleIds({
+ workspaceId,
+ principals: memberIds.map((principalId) => ({
+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
+ principalId,
+ })),
+ }),
+ this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatWorkspaceMemberMaps',
+ 'flatRoleMaps',
+ 'flatRolePermissionFlagMaps',
+ ]),
+ ]);
+ const activeUserIds = await this.findActiveUserIds({
+ workspaceId,
+ userIds: memberIds.flatMap((memberId) => {
+ const userId = flatWorkspaceMemberMaps.byId[memberId]?.userId;
+
+ return isDefined(userId) ? [userId] : [];
+ }),
+ });
+
+ return new Map(
+ memberIds.flatMap((memberId, index) => {
+ const roleId = roleIds[index];
+ const userId = flatWorkspaceMemberMaps.byId[memberId]?.userId;
+
+ if (
+ !isDefined(roleId) ||
+ !isDefined(userId) ||
+ !activeUserIds.has(userId)
+ ) {
+ return [];
+ }
+
+ const flatRole = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: roleId,
+ flatEntityMaps: flatRoleMaps,
+ });
+ const hasAiAccess =
+ isDefined(flatRole) &&
+ isPermissionFlagGrantedToFlatRole({
+ flatRole,
+ permissionFlag: PermissionFlagType.AI,
+ flatRolePermissionFlagMaps,
+ });
+
+ return hasAiAccess ? [[memberId, roleId] as const] : [];
+ }),
+ );
+ }
+
+ private async findActiveUserIds({
+ workspaceId,
+ userIds,
+ }: {
+ workspaceId: string;
+ userIds: string[];
+ }): Promise<Set<string>> {
+ if (!isNonEmptyArray(userIds)) {
+ return new Set();
+ }
+
+ const userWorkspaces = await this.userWorkspaceRepository.find({
+ where: { workspaceId, userId: In(userIds) },
+ relations: { user: true },
+ });
+
+ return new Set(
+ userWorkspaces.flatMap(({ user, userId }) =>
+ isDefined(user) && !user.disabled && !isDefined(user.deletedAt)
+ ? [userId]
+ : [],
+ ),
+ );
+ }
+
+ private buildParticipantReplyPolicy({
+ repository,
+ subject,
+ canManageSharing,
+ }: {
+ repository: WorkspaceRepository;
+ subject: RowAccessPolicySubject;
+ canManageSharing: boolean;
+ }): RowAccessPolicy {
+ if (!isDefined(subject.objectsPermissions)) {
+ return { kind: 'denied' };
+ }
+
+ const policies = AGENT_CHAT_REPLY_OPERATION_TYPES.map((operationType) =>
+ repository.buildRowAccessPolicy({
+ subject,
+ operationType,
+ hypotheticalRecordShareAccessLevel: canManageSharing
+ ? RecordShareAccessLevel.READ_WRITE
+ : undefined,
+ }),
+ );
+
+ if (policies.some(({ kind }) => kind === 'denied')) {
+ return { kind: 'denied' };
+ }
+
+ const operands = policies.flatMap((policy) =>
+ policy.kind === 'gated' ? [policy.expression] : [],
+ );
+
+ return isNonEmptyArray(operands)
+ ? { kind: 'gated', expression: { kind: 'and', operands } }
+ : { kind: 'open' };
+ }
+
+ private async canManageThreadSharing({
+ workspaceId,
+ threadId,
+ authContext,
+ }: {
+ workspaceId: string;
+ threadId: string;
+ authContext: UserWorkspaceAuthContext;
+ }): Promise<boolean> {
+ const objectMetadata = await this.getThreadObjectMetadata(workspaceId);
+ const { canManageSharing } = await this.recordSharingService.getSharing({
+ objectMetadataId: objectMetadata.id,
+ recordId: threadId,
+ authContext,
+ });
+
+ return canManageSharing;
+ }
+
private async getThreadObjectMetadata(workspaceId: string) {
const { flatObjectMetadataMaps } =
await this.workspaceCacheService.getOrRecompute(workspaceId, [
diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
index fb85e9397fe..f12f67ec8c4 100644
--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
@@ -1,9 +1,12 @@
import { msg } from '@lingui/core/macro';
import { isNonEmptyString } from '@sniptt/guards';
+import chunk from 'lodash.chunk';
import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
+import { doNotTranslate } from 'twenty-shared/i18n';
import {
type ObjectRecord,
type ObjectsPermissions,
+ type RecordShareAccessLevel,
} from 'twenty-shared/types';
import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import {
@@ -156,6 +159,9 @@ type WorkspaceRepositoryOptions<TEntity extends ObjectLiteral> = {
) => Promise<T>;
};
+// One result column per subject, under Postgres's 1664-column limit
+const ROW_ACCESS_POLICY_SUBJECT_BATCH_SIZE = 1_000;
+
export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
readonly objectRecordsPermissions: ObjectsPermissions;
@@ -2186,6 +2192,70 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return new Set(admittedRecords.map((record) => String(record.id)));
}
+ // TODO(@charlesBochet): temporary, per-subject policy evaluation will be replaced
+ async findSubjectIdsAdmittedByRowAccessPolicies({
+ recordId,
+ policiesBySubjectId,
+ }: {
+ recordId: string;
+ policiesBySubjectId: Map<string, RowAccessPolicy>;
+ }): Promise<Set<string>> {
+ const admittedSubjectIds = new Set<string>();
+
+ for (const policies of chunk(
+ [...policiesBySubjectId],
+ ROW_ACCESS_POLICY_SUBJECT_BATCH_SIZE,
+ )) {
+ const subjectIds: string[] = [];
+ const queryBuilder = this.buildBypassingEventSelectQueryBuilder(
+ this.options.tableShape.nameSingular,
+ )
+ .where({ id: recordId })
+ .withDeleted()
+ .select([]);
+
+ for (const [subjectId, policy] of policies) {
+ if (policy.kind === 'denied') {
+ continue;
+ }
+
+ subjectIds.push(subjectId);
+
+ if (policy.kind === 'open') {
+ queryBuilder.addSelect(doNotTranslate('TRUE'), subjectId);
+
+ continue;
+ }
+
+ const condition = this.compileRowAccessExpression(policy.expression);
+ queryBuilder
+ .addSelect(
+ doNotTranslate(
+ `CASE WHEN ${condition.sql} THEN TRUE ELSE FALSE END`,
+ ),
+ subjectId,
+ )
+ .setParameters(condition.parameters);
+ }
+
+ if (subjectIds.length === 0) {
+ continue;
+ }
+
+ const [row] = await queryBuilder.getRawMany<Record<string, boolean>>();
+
+ for (const subjectId of subjectIds) {
+ if (!row?.[subjectId]) {
+ continue;
+ }
+
+ admittedSubjectIds.add(subjectId);
+ }
+ }
+
+ return admittedSubjectIds;
+ }
+
private compileRowAccessExpression(
expression: RowAccessExpression,
): SqlCondition {
@@ -2245,9 +2315,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
buildRowAccessPolicy({
subject,
operationType,
+ hypotheticalRecordShareAccessLevel,
}: {
subject: RowAccessPolicySubject;
operationType: OperationType;
+ hypotheticalRecordShareAccessLevel?: RecordShareAccessLevel;
}): RowAccessPolicy {
return buildRowAccessPolicy({
subject,
@@ -2255,6 +2327,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
tableAlias: this.options.tableShape.nameSingular,
flatObjectMetadata: this.options.flatObjectMetadata,
operationType,
+ hypotheticalRecordShareAccessLevel,
});
}
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
index 85f315ae187..941f46b514c 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
@@ -327,4 +327,110 @@ describe('buildRowAccessPolicy', () => {
expect(policy.condition.sql).toContain('recordShare');
expect(policy.condition.sql).not.toContain('rowCause');
});
+ describe('with a prospective named share', () => {
+ const prospectiveShareArguments = {
+ subject: readEverything,
+ environment: sharingEnvironment,
+ tableAlias: person.nameSingular,
+ flatObjectMetadata: person,
+ operationType: 'update',
+ hypotheticalRecordShareAccessLevel: RecordShareAccessLevel.READ_WRITE,
+ } satisfies Parameters<typeof buildCompiledRowAccessPolicy>[0];
+
+ it('requires an edit-level share to preview update access', () => {
+ expect(buildCompiledRowAccessPolicy(prospectiveShareArguments)).toEqual({
+ kind: 'open',
+ });
+ const readOnly = buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ hypotheticalRecordShareAccessLevel: RecordShareAccessLevel.READ,
+ });
+
+ expect(readOnly.kind).toBe('gated');
+ });
+
+ it('preserves the member-bound row filter when sharing cannot reach beyond the role', () => {
+ const policy = buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ environment,
+ subject: {
+ ...readEverything,
+ resolveRowLevelPermissionRecordFilter: () => NOTE_FILTER,
+ },
+ });
+
+ expect(policy).toMatchObject({
+ kind: 'gated',
+ condition: {
+ sql: expect.stringContaining('"person"."title" = :restricted'),
+ },
+ });
+ expect(policy).toMatchObject({
+ condition: { sql: expect.not.stringContaining('recordShare') },
+ });
+ });
+
+ it('preserves a disabled edit action', () => {
+ expect(
+ buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ flatObjectMetadata: {
+ ...person,
+ disabledObjectPermissionActions: [
+ 'canUpdateObjectRecords' as const,
+ ],
+ },
+ }),
+ ).toEqual({ kind: 'denied' });
+ });
+
+ it('honors ownership for an object that disables editing', () => {
+ expect(
+ buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ subject: { ...readEverything, isOwningApplication: () => true },
+ flatObjectMetadata: {
+ ...person,
+ disabledObjectPermissionActions: [
+ 'canUpdateObjectRecords' as const,
+ ],
+ },
+ }),
+ ).toEqual({ kind: 'open' });
+ });
+
+ it('does not use a prospective share to bypass a disabled read action', () => {
+ expect(
+ buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ operationType: 'select',
+ flatObjectMetadata: {
+ ...person,
+ disabledObjectPermissionActions: ['canReadObjectRecords' as const],
+ },
+ }),
+ ).toEqual({ kind: 'denied' });
+ });
+
+ it('reaches beyond missing role access only when record sharing is enabled', () => {
+ const withoutObjectPermission: RowAccessPolicySubject = {
+ ...readEverything,
+ objectsPermissions: {},
+ };
+
+ expect(
+ buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ environment,
+ subject: withoutObjectPermission,
+ }),
+ ).toEqual({ kind: 'denied' });
+ expect(
+ buildCompiledRowAccessPolicy({
+ ...prospectiveShareArguments,
+ subject: withoutObjectPermission,
+ }),
+ ).toEqual({ kind: 'open' });
+ });
+ });
});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
index c2daf72b393..915a513caa6 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
@@ -1,8 +1,10 @@
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { buildNamedRecordGrantExpression } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util';
import { buildRecordShareGate } from 'src/engine/core-modules/record-share/utils/build-record-share-gate.util';
import { resolveObjectSharing } from 'src/engine/core-modules/record-share/utils/resolve-object-sharing.util';
+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
import {
type RowAccessExpression,
type RowAccessPolicy,
@@ -16,8 +18,12 @@ import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils
export const buildRowAccessPolicy = ({
subject,
environment,
+ hypotheticalRecordShareAccessLevel,
...target
-}: RowAccessPolicyContext & RowAccessPolicyTarget): RowAccessPolicy => {
+}: RowAccessPolicyContext &
+ RowAccessPolicyTarget & {
+ hypotheticalRecordShareAccessLevel?: RecordShareAccessLevel;
+ }): RowAccessPolicy => {
if (subject.isSystemContext) {
return { kind: 'open' };
}
@@ -34,15 +40,24 @@ export const buildRowAccessPolicy = ({
return { kind: 'denied' };
}
- const namedRecordGrant = resolveObjectSharing({
+ const canGrantOperationBeyondRole = resolveObjectSharing({
flatObjectMetadata: target.flatObjectMetadata,
featureFlagsMap: environment.featureFlagsMap,
- }).operationTypesGrantedBeyondRole.includes(target.operationType)
+ }).operationTypesGrantedBeyondRole.includes(target.operationType);
+ const hasHypotheticalRecordShare =
+ isDefined(hypotheticalRecordShareAccessLevel) &&
+ resolveRequiredRecordShareAccessLevels(target.operationType).includes(
+ hypotheticalRecordShareAccessLevel,
+ );
+ const isHypotheticalRecordShareBeyondRole =
+ hasHypotheticalRecordShare && canGrantOperationBeyondRole;
+ const namedRecordGrant = canGrantOperationBeyondRole
? buildNamedRecordGrantExpression(context, target)
: undefined;
if (
isDefined(subject.objectsPermissions) &&
+ !isHypotheticalRecordShareBeyondRole &&
!isObjectOperationPermitted({
objectMetadata: target.flatObjectMetadata,
operationType: target.operationType,
@@ -54,12 +69,18 @@ export const buildRowAccessPolicy = ({
: { kind: 'denied' };
}
+ if (isHypotheticalRecordShareBeyondRole) {
+ return { kind: 'open' };
+ }
+
const recordShareGate = buildRecordShareGate({ ...context, ...target });
const roleFilter = buildRoleFilterExpression(context, target);
const operands = [
roleFilter,
- recordShareGate.kind === 'gated' ? recordShareGate.expression : undefined,
+ !hasHypotheticalRecordShare && recordShareGate.kind === 'gated'
+ ? recordShareGate.expression
+ : undefined,
].filter(isDefined);
if (operands.length === 0) {
diff --git a/packages/twenty-server/test/integration/twenty-orm/find-subject-ids-admitted-by-row-access-policies.integration-spec.ts b/packages/twenty-server/test/integration/twenty-orm/find-subject-ids-admitted-by-row-access-policies.integration-spec.ts
new file mode 100644
index 00000000000..61408428fef
--- /dev/null
+++ b/packages/twenty-server/test/integration/twenty-orm/find-subject-ids-admitted-by-row-access-policies.integration-spec.ts
@@ -0,0 +1,161 @@
+import { randomUUID } from 'node:crypto';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { getObjectMetadataIdByName } from 'src/engine/metadata-modules/flat-object-metadata/utils/get-object-metadata-id-by-name.util';
+import { type RowAccessPolicy } from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+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';
+
+const SUBJECTS_BEYOND_ONE_BATCH = 1_001;
+
+describe('WorkspaceRepository.findSubjectIdsAdmittedByRowAccessPolicies', () => {
+ const recordId = randomUUID();
+ const otherRecordId = randomUUID();
+ let personObjectMetadata: FlatObjectMetadata;
+
+ // Other suites wipe every person, so the record under test is created here
+ beforeAll(async () => {
+ for (const personId of [recordId, otherRecordId]) {
+ const response = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: {
+ id: personId,
+ name: { firstName: 'Row', lastName: 'Access' },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ }
+
+ const { flatObjectMetadataMaps } =
+ await getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ ).getOrRecompute(SEED_APPLE_WORKSPACE_ID, ['flatObjectMetadataMaps']);
+
+ const personObjectMetadataId = getObjectMetadataIdByName({
+ flatObjectMetadataMaps,
+ objectName: 'person',
+ });
+
+ if (!isDefined(personObjectMetadataId)) {
+ throw new Error('The person object is not seeded');
+ }
+
+ personObjectMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityId: personObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+ });
+
+ afterAll(async () => {
+ for (const personId of [recordId, otherRecordId]) {
+ await makeGraphqlApiRequest(
+ destroyOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ recordId: personId,
+ }),
+ );
+ }
+ });
+
+ const buildIdPolicy = (personId: string): RowAccessPolicy => {
+ const parameterName = `personId_${randomUUID().replace(/-/g, '')}`;
+
+ return {
+ kind: 'gated',
+ expression: {
+ kind: 'roleFilter',
+ tableAlias: 'person',
+ flatObjectMetadata: personObjectMetadata,
+ recordFilter: { id: { eq: personId } },
+ condition: {
+ sql: `"person"."id" = :${parameterName}`,
+ parameters: { [parameterName]: personId },
+ },
+ },
+ };
+ };
+
+ // The app's Set comes from another realm, so it is compared as a list
+ const findAdmittedSubjectIds = async ({
+ recordId,
+ policiesBySubjectId,
+ }: {
+ recordId: string;
+ policiesBySubjectId: Map<string, RowAccessPolicy>;
+ }): Promise<string[]> => {
+ const workspaceOrmManager = getAppProviderByClassName<WorkspaceOrmManager>(
+ 'WorkspaceOrmManager',
+ );
+ const admittedSubjectIds =
+ await workspaceOrmManager.executeInWorkspaceContext(
+ () =>
+ workspaceOrmManager
+ .getRepository('person', { shouldBypassPermissionChecks: true })
+ .findSubjectIdsAdmittedByRowAccessPolicies({
+ recordId,
+ policiesBySubjectId,
+ }),
+ buildSystemAuthContext(SEED_APPLE_WORKSPACE_ID),
+ );
+
+ return [...admittedSubjectIds].sort();
+ };
+
+ it('evaluates each subject against the record in one pass', async () => {
+ const openSubjectId = randomUUID();
+ const deniedSubjectId = randomUUID();
+ const admittedSubjectId = randomUUID();
+ const refusedSubjectId = randomUUID();
+
+ expect(
+ await findAdmittedSubjectIds({
+ recordId,
+ policiesBySubjectId: new Map([
+ [openSubjectId, { kind: 'open' }],
+ [deniedSubjectId, { kind: 'denied' }],
+ [admittedSubjectId, buildIdPolicy(recordId)],
+ [refusedSubjectId, buildIdPolicy(otherRecordId)],
+ ]),
+ }),
+ ).toEqual([openSubjectId, admittedSubjectId].sort());
+ });
+
+ it('admits nobody to a record that does not exist', async () => {
+ expect(
+ await findAdmittedSubjectIds({
+ recordId: randomUUID(),
+ policiesBySubjectId: new Map([[randomUUID(), { kind: 'open' }]]),
+ }),
+ ).toEqual([]);
+ });
+
+ it('checks more subjects than one query can carry', async () => {
+ const subjectIds = Array.from({ length: SUBJECTS_BEYOND_ONE_BATCH }, () =>
+ randomUUID(),
+ );
+
+ expect(
+ await findAdmittedSubjectIds({
+ recordId,
+ policiesBySubjectId: new Map(
+ subjectIds.map((subjectId) => [subjectId, buildIdPolicy(recordId)]),
+ ),
+ }),
+ ).toEqual([...subjectIds].sort());
+ });
+});