The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsnew file mode 100644index 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.tsindex 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-cacheRecordShareModule,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.tsindex 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,);jestdiff --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.tsindex 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/aimport { 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.tsindex 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.tsindex 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.tsindex 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/utilsexport 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.tsnew file mode 100644index 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());+ });+});