Skip to content

The open alternative to Salesforce, designed for AI.

Add hasAccessToAllRecords, hasAccessToSomeRecords and hasAccessToRecords (#29414)

Charles Bochet0715e47172da
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/__tests__/database-tool.provider.spec.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/__tests__/database-tool.provider.spec.ts
index 9f45a413ab8..ad50a94a93b 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/__tests__/database-tool.provider.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/__tests__/database-tool.provider.spec.ts
@@ -1,4 +1,5 @@
import { type ObjectPermissions } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { type I18nService } from 'src/engine/core-modules/i18n/i18n.service';
import { type ApplicationTranslationCatalogService } from 'src/engine/metadata-modules/application-translation-catalog/services/application-translation-catalog.service';
@@ -10,6 +11,8 @@ import { type WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/me
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type RecordAccessPolicyService } from 'src/engine/permissions/combine/services/record-access-policy.service';
+import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
import { type RolePermissionConfig } from 'src/engine/permissions/principal/types/role-permission-config.type';
import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@@ -51,6 +54,25 @@ type GenerateDescriptorsTestOptions = {
composedObjectPermissions?: Partial<ObjectPermissions>;
explicitPermissionRowsRoleId?: string;
rolePermissionConfig?: RolePermissionConfig;
+ sharedOperationTypes?: OperationType[];
+};
+
+const OBJECT_PERMISSION_BY_OPERATION_TYPE: Partial<
+ Record<
+ OperationType,
+ keyof Pick<
+ ObjectPermissions,
+ | 'canReadObjectRecords'
+ | 'canUpdateObjectRecords'
+ | 'canSoftDeleteObjectRecords'
+ | 'canDestroyObjectRecords'
+ >
+ >
+> = {
+ select: 'canReadObjectRecords',
+ update: 'canUpdateObjectRecords',
+ 'soft-delete': 'canSoftDeleteObjectRecords',
+ delete: 'canDestroyObjectRecords',
};
describe('DatabaseToolProvider', () => {
@@ -137,8 +159,27 @@ describe('DatabaseToolProvider', () => {
}),
} as unknown as ApplicationTranslationCatalogService;
+ const objectPermissions = {
+ ...allObjectPermissions,
+ ...options?.composedObjectPermissions,
+ };
+ const recordAccessPolicyService = {
+ hasAccessToSomeRecords: jest.fn(
+ async ({ operationType }: { operationType: OperationType }) => {
+ const objectPermission =
+ OBJECT_PERMISSION_BY_OPERATION_TYPE[operationType];
+
+ return (
+ (options?.sharedOperationTypes ?? []).includes(operationType) ||
+ (isDefined(objectPermission) && objectPermissions[objectPermission])
+ );
+ },
+ ),
+ } as unknown as RecordAccessPolicyService;
+
const provider = new DatabaseToolProvider(
workspaceCacheService,
+ recordAccessPolicyService,
flatEntityMapsCacheService,
i18nService,
applicationTranslationCatalogService,
@@ -301,6 +342,40 @@ describe('DatabaseToolProvider', () => {
expect(descriptorNames).not.toContain('merge_many_dashboards');
});
+ it('advertises read and update tools on records shared beyond the role, but no create', async () => {
+ const descriptorNames = await generateDescriptorNames(
+ [createFlatObject({ nameSingular: 'company', namePlural: 'companies' })],
+ {
+ composedObjectPermissions: {
+ canReadObjectRecords: false,
+ canUpdateObjectRecords: false,
+ canSoftDeleteObjectRecords: false,
+ canDestroyObjectRecords: false,
+ },
+ sharedOperationTypes: ['select', 'update'],
+ },
+ );
+
+ expect(descriptorNames).toEqual(
+ expect.arrayContaining([
+ 'find_many_companies',
+ 'find_one_company',
+ 'update_one_company',
+ 'update_many_companies',
+ ]),
+ );
+
+ for (const roleOnlyToolName of [
+ 'create_one_company',
+ 'create_many_companies',
+ 'upsert_many_companies',
+ 'delete_one_company',
+ 'merge_many_companies',
+ ]) {
+ expect(descriptorNames).not.toContain(roleOnlyToolName);
+ }
+ });
+
it('does not advertise merge without the destroy permission', async () => {
const descriptorNames = await generateDescriptorNames(
[createFlatObject({ nameSingular: 'company', namePlural: 'companies' })],
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
index 73c96ac452c..22daf564cdc 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
@@ -31,6 +31,10 @@ import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.
import { getDatabaseCrudToolFlatObjects } from 'src/engine/metadata-modules/ai/ai-agent/utils/get-database-crud-tool-flat-objects.util';
import { type FlatObjectPermission } from 'src/engine/metadata-modules/flat-object-permission/types/flat-object-permission.type';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { RecordAccessPolicyService } from 'src/engine/permissions/combine/services/record-access-policy.service';
+import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
+import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
import { getObjectsPermissionsFromRolePermissionConfig } from 'src/engine/permissions/role/utils/get-objects-permissions-from-role-permission-config.util';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { RECORDS_TOOL_WIDGET_NAME, ToolCategory } from 'twenty-shared/ai';
@@ -44,6 +48,7 @@ export class DatabaseToolProvider implements ToolProvider {
constructor(
private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly recordAccessPolicyService: RecordAccessPolicyService,
private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly i18nService: I18nService,
private readonly applicationTranslationCatalogService: ApplicationTranslationCatalogService,
@@ -98,6 +103,8 @@ export class DatabaseToolProvider implements ToolProvider {
return descriptors;
}
+ const principal = buildToolPermissionsPrincipal(context);
+
const { explicitObjectGrantsRoleId } = context;
const requireExplicitObjectGrants = isDefined(explicitObjectGrantsRoleId);
@@ -151,22 +158,40 @@ export class DatabaseToolProvider implements ToolProvider {
continue;
}
+ const isExplicitlyGranted = (
+ objectPermission: keyof Pick<
+ FlatObjectPermission,
+ | 'canReadObjectRecords'
+ | 'canUpdateObjectRecords'
+ | 'canSoftDeleteObjectRecords'
+ | 'canDestroyObjectRecords'
+ >,
+ ) =>
+ !requireExplicitObjectGrants ||
+ (explicitPermission?.[objectPermission] ?? false);
+ const hasAccessToSomeRecords = async (operationType: OperationType) =>
+ !isDefined(principal) ||
+ (await this.recordAccessPolicyService.hasAccessToSomeRecords({
+ principal,
+ flatObjectMetadata: flatObject,
+ operationType,
+ }));
+
+ const canCreateRecords =
+ permission.canUpdateObjectRecords &&
+ isExplicitlyGranted('canUpdateObjectRecords');
const canReadRecords =
- permission.canReadObjectRecords &&
- (!requireExplicitObjectGrants ||
- explicitPermission?.canReadObjectRecords === true);
+ isExplicitlyGranted('canReadObjectRecords') &&
+ (await hasAccessToSomeRecords('select'));
const canUpdateRecords =
- permission.canUpdateObjectRecords &&
- (!requireExplicitObjectGrants ||
- explicitPermission?.canUpdateObjectRecords === true);
+ isExplicitlyGranted('canUpdateObjectRecords') &&
+ (await hasAccessToSomeRecords('update'));
const canSoftDeleteRecords =
- permission.canSoftDeleteObjectRecords &&
- (!requireExplicitObjectGrants ||
- explicitPermission?.canSoftDeleteObjectRecords === true);
+ isExplicitlyGranted('canSoftDeleteObjectRecords') &&
+ (await hasAccessToSomeRecords('soft-delete'));
const canDestroyRecords =
- permission.canDestroyObjectRecords &&
- (!requireExplicitObjectGrants ||
- explicitPermission?.canDestroyObjectRecords === true);
+ isExplicitlyGranted('canDestroyObjectRecords') &&
+ (await hasAccessToSomeRecords('delete'));
const snakePlural = camelToSnakeCase(flatObject.namePlural);
const snakeSingular = camelToSnakeCase(flatObject.nameSingular);
@@ -270,7 +295,7 @@ export class DatabaseToolProvider implements ToolProvider {
}
}
- if (canUpdateRecords && canBeManagedByAutomation) {
+ if (canCreateRecords && canBeManagedByAutomation) {
descriptors.push({
name: `create_one_${snakeSingular}`,
...getCrudToolLabels(
@@ -323,7 +348,9 @@ export class DatabaseToolProvider implements ToolProvider {
icon: flatObject.icon ?? undefined,
operation: 'create_many',
});
+ }
+ if (canUpdateRecords && canBeManagedByAutomation) {
descriptors.push({
name: `update_one_${snakeSingular}`,
...getCrudToolLabels(
@@ -376,7 +403,9 @@ export class DatabaseToolProvider implements ToolProvider {
icon: flatObject.icon ?? undefined,
operation: 'update_many',
});
+ }
+ if (canCreateRecords && canUpdateRecords && canBeManagedByAutomation) {
descriptors.push({
name: `upsert_many_${snakePlural}`,
...getCrudToolLabels(
@@ -547,3 +576,25 @@ export class DatabaseToolProvider implements ToolProvider {
);
}
}
+
+const buildToolPermissionsPrincipal = ({
+ workspaceId,
+ rolePermissionConfig,
+ authContext,
+}: Pick<
+ ToolProviderContext,
+ 'workspaceId' | 'rolePermissionConfig' | 'authContext'
+>): PermissionsPrincipal | undefined => {
+ if (!('intersectionOf' in rolePermissionConfig)) {
+ return undefined;
+ }
+
+ return {
+ workspaceId,
+ intersectionOf: rolePermissionConfig.intersectionOf,
+ workspaceMember:
+ isDefined(authContext) && isUserAuthContext(authContext)
+ ? authContext.workspaceMember
+ : undefined,
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
index 0964eeaaee9..a96b7487a89 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tool-provider.module.ts
@@ -24,6 +24,7 @@ import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata
import { NavigationMenuItemToolsModule } from 'src/engine/metadata-modules/navigation-menu-item/tools/navigation-menu-item-tools.module';
import { MetadataToolsModule } from 'src/engine/metadata-modules/object-metadata/tools/metadata-tools.module';
import { PermissionsModule } from 'src/engine/permissions/permissions.module';
+import { RecordShareModule } from 'src/engine/permissions/record-share/record-share.module';
import { RoleToolsModule } from 'src/engine/metadata-modules/role/tools/role-tools.module';
import { UserRoleModule } from 'src/engine/permissions/role-assignment/user-role.module';
import { ViewToolsModule } from 'src/engine/metadata-modules/view/tools/view-tools.module';
@@ -47,6 +48,7 @@ import { ToolRegistryService } from './services/tool-registry.service';
FeatureFlagModule,
FilesFieldModule,
PermissionsModule,
+ RecordShareModule,
ViewToolsModule,
WorkspaceCacheModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
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 632220da9f2..dd0945d45ae 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
@@ -27,6 +27,7 @@ import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/type
import { buildRecordShareLockKey } from 'src/engine/permissions/record-share/utils/build-record-share-lock-key.util';
import { RecordShareException } from 'src/engine/permissions/record-share/record-share.exception';
import { RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
+import { RecordAccessPolicyService } from 'src/engine/permissions/combine/services/record-access-policy.service';
import { RecordSharePrincipalService } from 'src/engine/permissions/record-share/services/record-share-principal.service';
import { RecordSharingService } from 'src/engine/permissions/record-share/services/record-sharing.service';
import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/permissions/record-share/utils/resolve-record-ids-shared-with-principals.util';
@@ -80,6 +81,7 @@ export class AgentChatSharingService {
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly channelGrantService: AgentChatChannelGrantService,
private readonly recordSharePrincipalService: RecordSharePrincipalService,
+ private readonly recordAccessPolicyService: RecordAccessPolicyService,
@InjectRepository(UserWorkspaceEntity)
private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
) {}
@@ -314,16 +316,15 @@ export class AgentChatSharingService {
threadId,
authContext,
});
+ const threadFlatObjectMetadata =
+ await this.getThreadObjectMetadata(workspaceId);
+
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 hypotheticalRecordShareAccessLevel =
shouldConsiderNewShares && canManageSharing
? RecordShareAccessLevel.READ_WRITE
@@ -340,12 +341,13 @@ export class AgentChatSharingService {
const grants = await Promise.all(
AGENT_CHAT_REPLY_OPERATION_TYPES.map((operationType) =>
- repository.hasPrincipalGrantOnRecords({
+ this.recordAccessPolicyService.hasAccessToRecords({
principal: {
workspaceId,
intersectionOf: { userWorkspaceRoleId: roleId },
workspaceMember: member,
},
+ flatObjectMetadata: threadFlatObjectMetadata,
recordIds: [threadId],
operationType,
hypotheticalRecordShareAccessLevel,
diff --git a/packages/twenty-server/src/engine/permissions/combine/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/permissions/combine/services/record-access-policy.service.ts
index 4c65c565201..2b044a3cfe7 100644
--- a/packages/twenty-server/src/engine/permissions/combine/services/record-access-policy.service.ts
+++ b/packages/twenty-server/src/engine/permissions/combine/services/record-access-policy.service.ts
@@ -4,12 +4,27 @@ import { Injectable } from '@nestjs/common';
import groupBy from 'lodash.groupby';
import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { PrivateRecordStorageService } from 'src/engine/permissions/private-record/services/private-record-storage.service';
import { type PrivateRecordState } from 'src/engine/permissions/private-record/types/private-record-state.type';
import { RecordShareStorageService } from 'src/engine/permissions/record-share/services/record-share-storage.service';
import { type EventRecordAccessGate } from 'src/engine/permissions/combine/types/event-record-access-gate.type';
-import { type PermissionsMetadataMaps } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import {
+ type PermissionsMetadataMaps,
+ type PermissionsObjectAccessRequest,
+} from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
+import { getPermissionsPrincipalShareKeys } from 'src/engine/permissions/principal/utils/get-permissions-principal-share-keys.util';
+import { resolvePermissionsShareGrant } from 'src/engine/permissions/record-share/utils/resolve-permissions-share-grant.util';
+import { isObjectOperationDeniedToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util';
+import { isObjectOperationDisabledToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util';
+import { isRolePermittingOperation } from 'src/engine/permissions/role/utils/is-role-permitting-operation.util';
+import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
+import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { type RecordShare } from 'src/engine/permissions/record-share/types/record-share.type';
import { findPermissionsAdmittedRecordIds } from 'src/engine/permissions/combine/utils/find-permissions-admitted-record-ids.util';
import { resolveEventRecordSnapshots } from 'src/engine/permissions/combine/utils/resolve-event-record-snapshots.util';
@@ -18,12 +33,99 @@ import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/typ
@Injectable()
export class RecordAccessPolicyService {
+ private readonly metadataMapsByPrincipal = new WeakMap<
+ PermissionsPrincipal,
+ Promise<PermissionsMetadataMaps>
+ >();
+
+ private readonly sharedAccessLevelsByPrincipal = new WeakMap<
+ PermissionsPrincipal,
+ Promise<Map<string, RecordShareAccessLevel[]>>
+ >();
+
constructor(
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly recordShareStorageService: RecordShareStorageService,
private readonly privateRecordStorageService: PrivateRecordStorageService,
+ private readonly workspaceOrmManager: WorkspaceOrmManager,
) {}
+ // Shares only count once a row exists, so an object reached by nothing stays out of reach
+ async hasAccessToSomeRecords({
+ principal,
+ flatObjectMetadata,
+ operationType,
+ }: Omit<PermissionsObjectAccessRequest, 'metadataMaps'>): Promise<boolean> {
+ const request = {
+ principal,
+ metadataMaps: await this.findPrincipalMetadataMaps(principal),
+ flatObjectMetadata,
+ operationType,
+ };
+
+ if (
+ isObjectOperationDisabledToPrincipal(request) ||
+ isObjectOperationDeniedToPrincipal(request)
+ ) {
+ return false;
+ }
+
+ if (isRolePermittingOperation(request)) {
+ return true;
+ }
+
+ const shareGrant = resolvePermissionsShareGrant(request);
+
+ if (!isDefined(shareGrant)) {
+ return false;
+ }
+
+ const sharedAccessLevels =
+ (await this.findSharedAccessLevelsByObjectMetadataId(principal)).get(
+ flatObjectMetadata.id,
+ ) ?? [];
+
+ return sharedAccessLevels.some((accessLevel) =>
+ shareGrant.accessLevels.includes(accessLevel),
+ );
+ }
+
+ async hasAccessToRecords({
+ principal,
+ flatObjectMetadata,
+ operationType,
+ recordIds,
+ hypotheticalRecordShareAccessLevel,
+ transactionScope,
+ }: Omit<PermissionsObjectAccessRequest, 'metadataMaps'> & {
+ recordIds: string[];
+ hypotheticalRecordShareAccessLevel?: RecordShareAccessLevel;
+ transactionScope?: WorkspaceTransactionScope;
+ }): Promise<boolean> {
+ const uniqueRecordIds = [
+ ...new Set(recordIds.map((recordId) => recordId.toLowerCase())),
+ ];
+
+ if (uniqueRecordIds.length === 0) {
+ return false;
+ }
+ const findAdmittedRecordIds = (repository: WorkspaceRepository) =>
+ repository.findPrincipalAdmittedRecordIds({
+ principal,
+ recordIds: uniqueRecordIds,
+ operationType,
+ hypotheticalRecordShareAccessLevel,
+ });
+ const admittedRecordIds = await this.withBypassingRepository({
+ workspaceId: principal.workspaceId,
+ objectNameSingular: flatObjectMetadata.nameSingular,
+ transactionScope,
+ work: findAdmittedRecordIds,
+ });
+
+ return uniqueRecordIds.every((recordId) => admittedRecordIds.has(recordId));
+ }
+
async loadPermissionsMetadataMaps(
workspaceId: string,
): Promise<PermissionsMetadataMaps> {
@@ -84,7 +186,9 @@ export class RecordAccessPolicyService {
recordSharesByRecordId,
);
- const uniqueRecordIds = [...new Set(recordIds)];
+ const uniqueRecordIds = [
+ ...new Set(recordIds.map((recordId) => recordId.toLowerCase())),
+ ];
const missingRecordIds = uniqueRecordIds.filter(
(recordId) => !recordSharesByRecordId.has(recordId),
);
@@ -150,4 +254,73 @@ export class RecordAccessPolicyService {
}),
};
}
+
+ private withBypassingRepository<TResult>({
+ workspaceId,
+ objectNameSingular,
+ transactionScope,
+ work,
+ }: {
+ workspaceId: string;
+ objectNameSingular: string;
+ transactionScope?: WorkspaceTransactionScope;
+ work: (repository: WorkspaceRepository) => Promise<TResult>;
+ }): Promise<TResult> {
+ if (isDefined(transactionScope)) {
+ return work(
+ transactionScope.getRepository(objectNameSingular, {
+ shouldBypassPermissionChecks: true,
+ }),
+ );
+ }
+
+ return this.workspaceOrmManager.executeInWorkspaceContext(
+ () =>
+ work(
+ this.workspaceOrmManager.getRepository(objectNameSingular, {
+ shouldBypassPermissionChecks: true,
+ }),
+ ),
+ buildSystemAuthContext(workspaceId),
+ );
+ }
+
+ private findPrincipalMetadataMaps(
+ principal: PermissionsPrincipal,
+ ): Promise<PermissionsMetadataMaps> {
+ const cachedMetadataMaps = this.metadataMapsByPrincipal.get(principal);
+
+ if (isDefined(cachedMetadataMaps)) {
+ return cachedMetadataMaps;
+ }
+
+ const metadataMaps = this.loadPermissionsMetadataMaps(
+ principal.workspaceId,
+ );
+
+ this.metadataMapsByPrincipal.set(principal, metadataMaps);
+
+ return metadataMaps;
+ }
+
+ private findSharedAccessLevelsByObjectMetadataId(
+ principal: PermissionsPrincipal,
+ ): Promise<Map<string, RecordShareAccessLevel[]>> {
+ const cachedSharedAccessLevels =
+ this.sharedAccessLevelsByPrincipal.get(principal);
+
+ if (isDefined(cachedSharedAccessLevels)) {
+ return cachedSharedAccessLevels;
+ }
+
+ const sharedAccessLevels =
+ this.recordShareStorageService.findAccessLevelsByObjectMetadataId({
+ workspaceId: principal.workspaceId,
+ principalIds: getPermissionsPrincipalShareKeys(principal),
+ });
+
+ this.sharedAccessLevelsByPrincipal.set(principal, sharedAccessLevels);
+
+ return sharedAccessLevels;
+ }
}
diff --git a/packages/twenty-server/src/engine/permissions/combine/types/row-access-policy.type.ts b/packages/twenty-server/src/engine/permissions/combine/types/row-access-policy.type.ts
index 3ff4e0d1de7..b04ca5ad9e7 100644
--- a/packages/twenty-server/src/engine/permissions/combine/types/row-access-policy.type.ts
+++ b/packages/twenty-server/src/engine/permissions/combine/types/row-access-policy.type.ts
@@ -37,6 +37,11 @@ export type PermissionsRowAccessRequest = {
hypotheticalRecordShareAccessLevel?: RecordShareAccessLevel;
};
+export type PermissionsObjectAccessRequest = Pick<
+ PermissionsRowAccessRequest,
+ 'principal' | 'metadataMaps' | 'flatObjectMetadata' | 'operationType'
+>;
+
export type RowAccessRecord = { id: string } & Record<string, unknown>;
export type RowAccessEvaluationContext = {
diff --git a/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/has-access-to-all-records.util.spec.ts b/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/has-access-to-all-records.util.spec.ts
new file mode 100644
index 00000000000..52b03feac7a
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/combine/utils/__tests__/has-access-to-all-records.util.spec.ts
@@ -0,0 +1,131 @@
+/* @license Enterprise */
+
+import { type ObjectPermissions } from 'twenty-shared/types';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
+import { type PermissionsObjectAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { hasAccessToAllRecords } from 'src/engine/permissions/combine/utils/has-access-to-all-records.util';
+import { resolveRowLevelPermissionRecordFilter } from 'src/engine/permissions/rls/utils/resolve-row-level-permission-record-filter.util';
+import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
+
+jest.mock(
+ 'src/engine/permissions/rls/utils/resolve-row-level-permission-record-filter.util',
+);
+
+const APPLICATION_ID = 'application-id';
+const APPLICATION_ROLE_ID = 'application-role';
+const READ_ONLY_ROLE_ID = 'read-only-role';
+const OTHER_APPLICATION_ROLE_ID = 'other-application-role';
+
+const flatObjectMetadata = {
+ ...COMPANY_FLAT_OBJECT_MOCK,
+ isSystem: false,
+ applicationId: APPLICATION_ID,
+};
+
+const readOnlyPermissions: ObjectPermissions = {
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: false,
+ canSoftDeleteObjectRecords: false,
+ canDestroyObjectRecords: false,
+ restrictedFields: {},
+ rowLevelPermissionPredicates: [],
+ rowLevelPermissionPredicateGroups: [],
+};
+
+const hasAccess = ({
+ roleId = READ_ONLY_ROLE_ID,
+ operationType = 'select',
+ disabledObjectPermissionActions = [],
+}: {
+ roleId?: string;
+ operationType?: OperationType;
+ disabledObjectPermissionActions?: typeof flatObjectMetadata.disabledObjectPermissionActions;
+}) => {
+ const request: PermissionsObjectAccessRequest = {
+ principal: {
+ workspaceId: 'workspace-id',
+ intersectionOf: [APPLICATION_ROLE_ID, OTHER_APPLICATION_ROLE_ID].includes(
+ roleId,
+ )
+ ? { applicationRoleId: roleId }
+ : { userWorkspaceRoleId: roleId },
+ },
+ metadataMaps: {
+ flatFieldMetadataMaps: createEmptyFlatEntityMaps(),
+ flatObjectMetadataMaps: createEmptyFlatEntityMaps(),
+ rolesPermissions: {
+ [READ_ONLY_ROLE_ID]: { [flatObjectMetadata.id]: readOnlyPermissions },
+ [APPLICATION_ROLE_ID]: {
+ [flatObjectMetadata.id]: readOnlyPermissions,
+ },
+ [OTHER_APPLICATION_ROLE_ID]: {
+ [flatObjectMetadata.id]: readOnlyPermissions,
+ },
+ },
+ flatApplicationMaps: {
+ byId: {
+ [APPLICATION_ID]: {
+ id: APPLICATION_ID,
+ defaultRoleId: APPLICATION_ROLE_ID,
+ deletedAt: null,
+ },
+ 'other-application-id': {
+ id: 'other-application-id',
+ defaultRoleId: OTHER_APPLICATION_ROLE_ID,
+ deletedAt: null,
+ },
+ },
+ },
+ flatRowLevelPermissionPredicateMaps: createEmptyFlatEntityMaps(),
+ flatRowLevelPermissionPredicateGroupMaps: createEmptyFlatEntityMaps(),
+ featureFlagsMap: {},
+ },
+ flatObjectMetadata: {
+ ...flatObjectMetadata,
+ disabledObjectPermissionActions,
+ },
+ operationType,
+ };
+
+ return hasAccessToAllRecords(request);
+};
+
+describe('hasAccessToAllRecords', () => {
+ beforeEach(() => {
+ jest.mocked(resolveRowLevelPermissionRecordFilter).mockReturnValue(null);
+ });
+
+ it('follows the role on an object without row filter', () => {
+ expect(hasAccess({})).toBe(true);
+ expect(hasAccess({ operationType: 'update' })).toBe(false);
+ expect(hasAccess({ roleId: 'missing-role' })).toBe(false);
+ });
+
+ it('denies once a row filter limits the role', () => {
+ jest
+ .mocked(resolveRowLevelPermissionRecordFilter)
+ .mockReturnValue({ status: { eq: 'active' } });
+
+ expect(hasAccess({})).toBe(false);
+ });
+
+ it('denies a disabled operation unless the principal owns the object', () => {
+ expect(
+ hasAccess({ disabledObjectPermissionActions: ['canReadObjectRecords'] }),
+ ).toBe(false);
+ expect(
+ hasAccess({
+ roleId: APPLICATION_ROLE_ID,
+ disabledObjectPermissionActions: ['canReadObjectRecords'],
+ }),
+ ).toBe(true);
+ expect(
+ hasAccess({
+ roleId: OTHER_APPLICATION_ROLE_ID,
+ disabledObjectPermissionActions: ['canReadObjectRecords'],
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/permissions/combine/utils/has-access-to-all-records.util.ts b/packages/twenty-server/src/engine/permissions/combine/utils/has-access-to-all-records.util.ts
new file mode 100644
index 00000000000..c82964190d8
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/combine/utils/has-access-to-all-records.util.ts
@@ -0,0 +1,16 @@
+/* @license Enterprise */
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { type PermissionsObjectAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { resolveRowLevelPermissionRecordFilter } from 'src/engine/permissions/rls/utils/resolve-row-level-permission-record-filter.util';
+import { isObjectOperationDisabledToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util';
+import { isRolePermittingOperation } from 'src/engine/permissions/role/utils/is-role-permitting-operation.util';
+
+// Private records are never covered: only their creator and shares reach them
+export const hasAccessToAllRecords = (
+ request: PermissionsObjectAccessRequest,
+): boolean =>
+ !isObjectOperationDisabledToPrincipal(request) &&
+ isRolePermittingOperation(request) &&
+ !isDefined(resolveRowLevelPermissionRecordFilter(request));
diff --git a/packages/twenty-server/src/engine/permissions/combine/utils/resolve-permissions-row-access-outcome.util.ts b/packages/twenty-server/src/engine/permissions/combine/utils/resolve-permissions-row-access-outcome.util.ts
index 06ca11a17be..285d2c96691 100644
--- a/packages/twenty-server/src/engine/permissions/combine/utils/resolve-permissions-row-access-outcome.util.ts
+++ b/packages/twenty-server/src/engine/permissions/combine/utils/resolve-permissions-row-access-outcome.util.ts
@@ -1,36 +1,23 @@
/* @license Enterprise */
import { type PermissionsRowAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
-import { isPermissionsPrincipalOwningObject } from 'src/engine/permissions/principal/utils/is-permissions-principal-owning-object.util';
import { hasHypotheticalRecordShare } from 'src/engine/permissions/record-share/utils/has-hypothetical-record-share.util';
import { isOperationGrantedBeyondRole } from 'src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util';
import { isObjectOperationDeniedToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util';
-import { isObjectOperationDisabled } from 'src/engine/permissions/role/utils/is-object-operation-disabled.util';
+import { isObjectOperationDisabledToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util';
export const resolvePermissionsRowAccessOutcome = (
request: PermissionsRowAccessRequest,
): boolean | undefined => {
- const { principal, metadataMaps, flatObjectMetadata, operationType } =
- request;
+ const { metadataMaps, flatObjectMetadata, operationType } = request;
if (
- isObjectOperationDisabled({
- objectMetadata: flatObjectMetadata,
- operationType,
- }) &&
- !isPermissionsPrincipalOwningObject({
- principal,
- flatApplicationMaps: metadataMaps.flatApplicationMaps,
- flatObjectMetadata,
- })
+ isObjectOperationDisabledToPrincipal(request) ||
+ isObjectOperationDeniedToPrincipal(request)
) {
return false;
}
- if (isObjectOperationDeniedToPrincipal(request)) {
- return false;
- }
-
if (
isOperationGrantedBeyondRole({
flatObjectMetadata,
diff --git a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-principal.service.ts b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-principal.service.ts
index 37a527d9514..0ea3a86d03e 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-principal.service.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-principal.service.ts
@@ -6,6 +6,9 @@ import { msg } from '@lingui/core/macro';
import { RecordSharePrincipalType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
+import { RecordAccessPolicyService } from 'src/engine/permissions/combine/services/record-access-policy.service';
+import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
+import { isRolePermittingOperation } from 'src/engine/permissions/role/utils/is-role-permitting-operation.util';
import {
RecordShareException,
RecordShareExceptionCode,
@@ -23,7 +26,10 @@ type RecordSharePrincipal = Pick<
@Injectable()
export class RecordSharePrincipalService {
- constructor(private readonly workspaceCacheService: WorkspaceCacheService) {}
+ constructor(
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly recordAccessPolicyService: RecordAccessPolicyService,
+ ) {}
// Undefined for everyone, and for a member who left or whose membership is gone
async resolveRoleIds({
@@ -104,30 +110,33 @@ export class RecordSharePrincipalService {
workspaceId,
principals: namedPrincipals,
});
- const { rolesPermissions } =
- await this.workspaceCacheService.getOrRecompute(workspaceId, [
- 'rolesPermissions',
- ]);
- const repository = transactionScope.getRepository(
- flatObjectMetadata.nameSingular,
- { shouldBypassPermissionChecks: true },
- );
+ const metadataMaps =
+ await this.recordAccessPolicyService.loadPermissionsMetadataMaps(
+ workspaceId,
+ );
for (const [index, principal] of namedPrincipals.entries()) {
const roleId = roleIds[index];
- if (!isDefined(roleId)) {
+ if (
+ !isDefined(roleId) ||
+ !isDefined(metadataMaps.rolesPermissions[roleId])
+ ) {
continue;
}
- const roleObjectsPermissions = rolesPermissions[roleId];
+ const rolePrincipal: PermissionsPrincipal = {
+ workspaceId,
+ intersectionOf: { userWorkspaceRoleId: roleId },
+ };
if (
- isDefined(roleObjectsPermissions) &&
- !(
- roleObjectsPermissions[flatObjectMetadata.id]?.canReadObjectRecords ??
- false
- )
+ !isRolePermittingOperation({
+ principal: rolePrincipal,
+ metadataMaps,
+ flatObjectMetadata,
+ operationType: 'select',
+ })
) {
throw new RecordShareException(
`Principal ${principal.principalId} cannot access ${flatObjectMetadata.nameSingular} records through its role`,
@@ -149,13 +158,15 @@ export class RecordSharePrincipalService {
shouldBypassPermissionChecks: true,
})
.findOne({ where: { id: principal.principalId } });
- const hasGrant = await repository.hasPrincipalGrantOnRecords({
+ const hasGrant = await this.recordAccessPolicyService.hasAccessToRecords({
principal: {
- workspaceId,
- intersectionOf: { userWorkspaceRoleId: roleId },
+ ...rolePrincipal,
workspaceMember: workspaceMember ?? undefined,
},
+ flatObjectMetadata,
+ operationType: 'select',
recordIds,
+ transactionScope,
});
if (!hasGrant) {
diff --git a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-storage.service.ts b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-storage.service.ts
index 6a719b21f1a..2e420a6b516 100644
--- a/packages/twenty-server/src/engine/permissions/record-share/services/record-share-storage.service.ts
+++ b/packages/twenty-server/src/engine/permissions/record-share/services/record-share-storage.service.ts
@@ -279,6 +279,37 @@ export class RecordShareStorageService {
);
}
+ async findAccessLevelsByObjectMetadataId({
+ workspaceId,
+ principalIds,
+ }: {
+ workspaceId: string;
+ principalIds: string[];
+ }): Promise<Map<string, RecordShareAccessLevel[]>> {
+ if (principalIds.length === 0) {
+ return new Map();
+ }
+
+ const rows = await this.withRepository({ workspaceId }, (repository) =>
+ repository.executeRaw<{
+ objectMetadataId: string;
+ accessLevel: RecordShareAccessLevel;
+ }>(
+ `SELECT DISTINCT "objectMetadataId", "accessLevel" FROM ${escapeIdentifier(getWorkspaceSchemaName(workspaceId))}.${escapeIdentifier(RECORD_SHARE_OBJECT_METADATA_NAME)} WHERE "principalId" = ANY(:principalIds) AND "deletedAt" IS NULL`,
+ { principalIds },
+ ),
+ );
+
+ return rows.reduce((accessLevelsByObjectMetadataId, row) => {
+ accessLevelsByObjectMetadataId.set(row.objectMetadataId, [
+ ...(accessLevelsByObjectMetadataId.get(row.objectMetadataId) ?? []),
+ row.accessLevel,
+ ]);
+
+ return accessLevelsByObjectMetadataId;
+ }, new Map<string, RecordShareAccessLevel[]>());
+ }
+
async findByRecordIds({
workspaceId,
objectMetadataId,
diff --git a/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util.ts b/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util.ts
index be672ef24a0..26476ccea19 100644
--- a/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util.ts
+++ b/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util.ts
@@ -1,14 +1,11 @@
/* @license Enterprise */
-import { type PermissionsRowAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { type PermissionsObjectAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
import { isOperationGrantedBeyondRole } from 'src/engine/permissions/record-share/utils/is-operation-granted-beyond-role.util';
import { isRolePermittingOperation } from 'src/engine/permissions/role/utils/is-role-permitting-operation.util';
export const isObjectOperationDeniedToPrincipal = (
- request: Pick<
- PermissionsRowAccessRequest,
- 'principal' | 'metadataMaps' | 'flatObjectMetadata' | 'operationType'
- >,
+ request: PermissionsObjectAccessRequest,
): boolean =>
!isRolePermittingOperation(request) &&
!isOperationGrantedBeyondRole({
diff --git a/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util.ts b/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util.ts
new file mode 100644
index 00000000000..14f020d3c6d
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util.ts
@@ -0,0 +1,21 @@
+/* @license Enterprise */
+
+import { type PermissionsObjectAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { isPermissionsPrincipalOwningObject } from 'src/engine/permissions/principal/utils/is-permissions-principal-owning-object.util';
+import { isObjectOperationDisabled } from 'src/engine/permissions/role/utils/is-object-operation-disabled.util';
+
+export const isObjectOperationDisabledToPrincipal = ({
+ principal,
+ metadataMaps,
+ flatObjectMetadata,
+ operationType,
+}: PermissionsObjectAccessRequest): boolean =>
+ isObjectOperationDisabled({
+ objectMetadata: flatObjectMetadata,
+ operationType,
+ }) &&
+ !isPermissionsPrincipalOwningObject({
+ principal,
+ flatApplicationMaps: metadataMaps.flatApplicationMaps,
+ flatObjectMetadata,
+ });
diff --git a/packages/twenty-server/src/engine/permissions/role/utils/is-role-permitting-operation.util.ts b/packages/twenty-server/src/engine/permissions/role/utils/is-role-permitting-operation.util.ts
index cdb4367ddbd..a75cc6d7301 100644
--- a/packages/twenty-server/src/engine/permissions/role/utils/is-role-permitting-operation.util.ts
+++ b/packages/twenty-server/src/engine/permissions/role/utils/is-role-permitting-operation.util.ts
@@ -1,6 +1,6 @@
/* @license Enterprise */
-import { type PermissionsRowAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
+import { type PermissionsObjectAccessRequest } from 'src/engine/permissions/combine/types/row-access-policy.type';
import { getPermissionsPrincipalObjectsPermissions } from 'src/engine/permissions/role/utils/get-permissions-principal-objects-permissions.util';
import { isObjectOperationPermitted } from 'src/engine/permissions/role/utils/is-object-operation-permitted.util';
@@ -9,10 +9,7 @@ export const isRolePermittingOperation = ({
metadataMaps,
flatObjectMetadata,
operationType,
-}: Pick<
- PermissionsRowAccessRequest,
- 'principal' | 'metadataMaps' | 'flatObjectMetadata' | 'operationType'
->): boolean =>
+}: PermissionsObjectAccessRequest): boolean =>
isObjectOperationPermitted({
objectMetadata: flatObjectMetadata,
operationType,
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 9e5f2af4bb7..41e00ade9f6 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
@@ -46,7 +46,7 @@ import { buildPermissionsCondition } from 'src/engine/permissions/combine/utils/
import { type RecordShareGrant } from 'src/engine/permissions/record-share/types/record-share-grant.type';
import { findPermissionsAdmittedRecordIds } from 'src/engine/permissions/combine/utils/find-permissions-admitted-record-ids.util';
import { isObjectOperationDeniedToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-denied-to-principal.util';
-import { isObjectOperationDisabled } from 'src/engine/permissions/role/utils/is-object-operation-disabled.util';
+import { isObjectOperationDisabledToPrincipal } from 'src/engine/permissions/role/utils/is-object-operation-disabled-to-principal.util';
import { isObjectOperationPermitted } from 'src/engine/permissions/role/utils/is-object-operation-permitted.util';
import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
@@ -55,7 +55,6 @@ import {
getUpdateEventRecords,
mergeRecordsWithUpdateValues,
} from 'src/engine/twenty-orm/utils/merge-records-with-update-values.util';
-import { isPermissionsPrincipalOwningObject } from 'src/engine/permissions/principal/utils/is-permissions-principal-owning-object.util';
import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
import { type RolePermissionConfig } from 'src/engine/permissions/principal/types/role-permission-config.type';
import { resolveRowLevelPermissionRecordFilter } from 'src/engine/permissions/rls/utils/resolve-row-level-permission-record-filter.util';
@@ -2177,18 +2176,17 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
}
}
- async hasPrincipalGrantOnRecords({
+ async findPrincipalAdmittedRecordIds({
principal,
recordIds,
- operationType = 'select',
+ operationType,
hypotheticalRecordShareAccessLevel,
}: {
principal: PermissionsPrincipal;
recordIds: string[];
- operationType?: OperationType;
+ operationType: OperationType;
hypotheticalRecordShareAccessLevel?: RecordShareAccessLevel;
- }): Promise<boolean> {
- const uniqueRecordIds = [...new Set(recordIds)];
+ }): Promise<Set<string>> {
const condition = buildPermissionsCondition({
principal,
metadataMaps: this.resolvePermissionsMetadataMaps(),
@@ -2198,18 +2196,14 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
hypotheticalRecordShareAccessLevel,
});
- if (condition === false) {
- return false;
- }
-
- if (uniqueRecordIds.length === 0) {
- return true;
+ if (condition === false || recordIds.length === 0) {
+ return new Set();
}
const queryBuilder = this.buildBypassingEventSelectQueryBuilder(
this.options.tableShape.nameSingular,
)
- .where({ id: In(uniqueRecordIds) })
+ .where({ id: In(recordIds) })
.withDeleted()
.select(['id']);
const admittedRecords = await (
@@ -2221,7 +2215,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
: queryBuilder
).getMany<ObjectRecord>({ noFormatting: true });
- return admittedRecords.length === uniqueRecordIds.length;
+ return new Set(admittedRecords.map(({ id }) => String(id)));
}
// Whether the role alone permits the operation, regardless of any record
@@ -2288,17 +2282,12 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return false;
}
- return (
- isObjectOperationDisabled({
- objectMetadata: flatObjectMetadata,
- operationType,
- }) &&
- !isPermissionsPrincipalOwningObject({
- principal: this.resolvePermissionsPrincipal(),
- flatApplicationMaps: this.options.internalContext.flatApplicationMaps,
- flatObjectMetadata,
- })
- );
+ return isObjectOperationDisabledToPrincipal({
+ principal: this.resolvePermissionsPrincipal(),
+ metadataMaps: this.resolvePermissionsMetadataMaps(),
+ flatObjectMetadata,
+ operationType,
+ });
}
private resolvePermissionsPrincipal(): PermissionsPrincipal {
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-beyond-role.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-beyond-role.integration-spec.ts
index 06a93eeacf8..0eb46c98f88 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-beyond-role.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-beyond-role.integration-spec.ts
@@ -236,6 +236,74 @@ describe('Records shared beyond the role that can access their object', () => {
expect((await renameAsJony('Not allowed')).body.errors).toBeDefined();
});
+ it('should answer access questions for the member from their shares', async () => {
+ const recordAccessPolicyService =
+ getAppProviderByClassName<RecordAccessPolicyService>(
+ 'RecordAccessPolicyService',
+ );
+ const { flatObjectMetadataMaps } =
+ await getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ ).getOrRecompute(workspaceId, ['flatObjectMetadataMaps']);
+ const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: objectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(flatObjectMetadata)) {
+ throw new Error('The object under test is not cached');
+ }
+
+ const buildJonyPrincipal = () => ({
+ workspaceId,
+ intersectionOf: { userWorkspaceRoleId: memberRoleId },
+ workspaceMember: { id: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY },
+ });
+
+ expect(
+ await recordAccessPolicyService.hasAccessToSomeRecords({
+ principal: buildJonyPrincipal(),
+ flatObjectMetadata,
+ operationType: 'select',
+ }),
+ ).toBe(false);
+
+ await setShare({ principal: JONY });
+
+ const principal = buildJonyPrincipal();
+
+ expect(
+ await recordAccessPolicyService.hasAccessToSomeRecords({
+ principal,
+ flatObjectMetadata,
+ operationType: 'select',
+ }),
+ ).toBe(true);
+ expect(
+ await recordAccessPolicyService.hasAccessToSomeRecords({
+ principal,
+ flatObjectMetadata,
+ operationType: 'update',
+ }),
+ ).toBe(false);
+ expect(
+ await recordAccessPolicyService.hasAccessToRecords({
+ principal,
+ flatObjectMetadata,
+ operationType: 'select',
+ recordIds: [SHARED_RECORD_ID],
+ }),
+ ).toBe(true);
+ expect(
+ await recordAccessPolicyService.hasAccessToRecords({
+ principal,
+ flatObjectMetadata,
+ operationType: 'select',
+ recordIds: [SHARED_RECORD_ID, OTHER_RECORD_ID],
+ }),
+ ).toBe(false);
+ });
+
it('should let an edit grant edit, but never delete or manage access', async () => {
await setShare({
principal: JONY,
diff --git a/packages/twenty-server/test/integration/twenty-orm/has-principal-grant-on-records.integration-spec.ts b/packages/twenty-server/test/integration/twenty-orm/has-principal-grant-on-records.integration-spec.ts
deleted file mode 100644
index 1a9794835e8..00000000000
--- a/packages/twenty-server/test/integration/twenty-orm/has-principal-grant-on-records.integration-spec.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-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 { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
-import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
-import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
-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';
-import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
-
-describe('WorkspaceRepository.hasPrincipalGrantOnRecords', () => {
- const recordId = randomUUID();
- let adminPrincipal: PermissionsPrincipal;
-
- // Other suites wipe every person, so the record under test is created here
- beforeAll(async () => {
- const response = await makeGraphqlApiRequest(
- createOneOperationFactory({
- objectMetadataSingularName: 'person',
- gqlFields: 'id',
- data: {
- id: recordId,
- name: { firstName: 'Row', lastName: 'Access' },
- },
- }),
- );
-
- expect(response.body.errors).toBeUndefined();
-
- const { flatRoleMaps } =
- await getAppProviderByClassName<WorkspaceCacheService>(
- 'WorkspaceCacheService',
- ).getOrRecompute(SEED_APPLE_WORKSPACE_ID, ['flatRoleMaps']);
- const adminRoleId = findFlatEntityByUniversalIdentifier({
- flatEntityMaps: flatRoleMaps,
- universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
- })?.id;
-
- if (!isDefined(adminRoleId)) {
- throw new Error('The admin role is not seeded');
- }
-
- adminPrincipal = {
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- intersectionOf: { userWorkspaceRoleId: adminRoleId },
- };
- });
-
- afterAll(async () => {
- await makeGraphqlApiRequest(
- destroyOneOperationFactory({
- objectMetadataSingularName: 'person',
- gqlFields: 'id',
- recordId,
- }),
- );
- });
-
- const hasGrant = ({
- principal,
- recordIds,
- operationType,
- }: {
- principal: PermissionsPrincipal;
- recordIds: string[];
- operationType?: OperationType;
- }): Promise<boolean> => {
- const workspaceOrmManager = getAppProviderByClassName<WorkspaceOrmManager>(
- 'WorkspaceOrmManager',
- );
-
- return workspaceOrmManager.executeInWorkspaceContext(
- () =>
- workspaceOrmManager
- .getRepository('person', { shouldBypassPermissionChecks: true })
- .hasPrincipalGrantOnRecords({ principal, recordIds, operationType }),
- buildSystemAuthContext(SEED_APPLE_WORKSPACE_ID),
- );
- };
-
- it('grants a role every operation it permits on an existing record', async () => {
- expect(
- await hasGrant({ principal: adminPrincipal, recordIds: [recordId] }),
- ).toBe(true);
- expect(
- await hasGrant({
- principal: adminPrincipal,
- recordIds: [recordId],
- operationType: 'update',
- }),
- ).toBe(true);
- });
-
- it('denies a principal whose role does not exist', async () => {
- expect(
- await hasGrant({
- principal: {
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- intersectionOf: { userWorkspaceRoleId: randomUUID() },
- },
- recordIds: [recordId],
- }),
- ).toBe(false);
- });
-
- it('denies when one of the records does not exist', async () => {
- expect(
- await hasGrant({
- principal: adminPrincipal,
- recordIds: [recordId, randomUUID()],
- }),
- ).toBe(false);
- });
-});
diff --git a/packages/twenty-server/test/integration/twenty-orm/record-access-policy.integration-spec.ts b/packages/twenty-server/test/integration/twenty-orm/record-access-policy.integration-spec.ts
new file mode 100644
index 00000000000..6915d02c185
--- /dev/null
+++ b/packages/twenty-server/test/integration/twenty-orm/record-access-policy.integration-spec.ts
@@ -0,0 +1,160 @@
+import { randomUUID } from 'node:crypto';
+
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+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 { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type RecordAccessPolicyService } from 'src/engine/permissions/combine/services/record-access-policy.service';
+import { type PermissionsPrincipal } from 'src/engine/permissions/principal/types/permissions-principal.type';
+import { type OperationType } from 'src/engine/permissions/role/utils/validate-operation-is-permitted-or-throw.util';
+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 { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
+
+describe('RecordAccessPolicyService', () => {
+ const recordId = randomUUID();
+ let adminPrincipal: PermissionsPrincipal;
+ let personFlatObjectMetadata: FlatObjectMetadata;
+ let recordAccessPolicyService: RecordAccessPolicyService;
+ const missingRolePrincipal: PermissionsPrincipal = {
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ intersectionOf: { userWorkspaceRoleId: randomUUID() },
+ };
+
+ // Other suites wipe every person, so the record under test is created here
+ beforeAll(async () => {
+ const response = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: {
+ id: recordId,
+ name: { firstName: 'Row', lastName: 'Access' },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const { flatRoleMaps, flatObjectMetadataMaps } =
+ await getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ ).getOrRecompute(SEED_APPLE_WORKSPACE_ID, [
+ 'flatRoleMaps',
+ 'flatObjectMetadataMaps',
+ ]);
+ const person = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatObjectMetadataMaps,
+ universalIdentifier: STANDARD_OBJECTS.person.universalIdentifier,
+ });
+ const adminRoleId = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatRoleMaps,
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ })?.id;
+
+ if (!isDefined(adminRoleId) || !isDefined(person)) {
+ throw new Error('The admin role or the person object is not seeded');
+ }
+
+ personFlatObjectMetadata = person;
+ recordAccessPolicyService =
+ getAppProviderByClassName<RecordAccessPolicyService>(
+ 'RecordAccessPolicyService',
+ );
+
+ adminPrincipal = {
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ intersectionOf: { userWorkspaceRoleId: adminRoleId },
+ };
+ });
+
+ afterAll(async () => {
+ await makeGraphqlApiRequest(
+ destroyOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ recordId,
+ }),
+ );
+ });
+
+ const hasAccessToRecords = ({
+ principal,
+ recordIds,
+ operationType = 'select',
+ }: {
+ principal: PermissionsPrincipal;
+ recordIds: string[];
+ operationType?: OperationType;
+ }): Promise<boolean> =>
+ recordAccessPolicyService.hasAccessToRecords({
+ principal,
+ flatObjectMetadata: personFlatObjectMetadata,
+ operationType,
+ recordIds,
+ });
+
+ describe('hasAccessToRecords', () => {
+ it('grants a role reading and updating an existing record it permits', async () => {
+ expect(
+ await hasAccessToRecords({
+ principal: adminPrincipal,
+ recordIds: [recordId],
+ }),
+ ).toBe(true);
+ expect(
+ await hasAccessToRecords({
+ principal: adminPrincipal,
+ recordIds: [recordId],
+ operationType: 'update',
+ }),
+ ).toBe(true);
+ });
+
+ it('denies a principal whose role does not exist', async () => {
+ expect(
+ await hasAccessToRecords({
+ principal: missingRolePrincipal,
+ recordIds: [recordId],
+ }),
+ ).toBe(false);
+ });
+
+ it('denies when one of the records does not exist', async () => {
+ expect(
+ await hasAccessToRecords({
+ principal: adminPrincipal,
+ recordIds: [recordId, randomUUID()],
+ }),
+ ).toBe(false);
+ });
+ });
+
+ describe('hasAccessToSomeRecords', () => {
+ it('follows the role when it permits the operation', async () => {
+ expect(
+ await recordAccessPolicyService.hasAccessToSomeRecords({
+ principal: adminPrincipal,
+ flatObjectMetadata: personFlatObjectMetadata,
+ operationType: 'select',
+ }),
+ ).toBe(true);
+ });
+
+ it('denies a principal with no role and no share on the object', async () => {
+ expect(
+ await recordAccessPolicyService.hasAccessToSomeRecords({
+ principal: missingRolePrincipal,
+ flatObjectMetadata: personFlatObjectMetadata,
+ operationType: 'select',
+ }),
+ ).toBe(false);
+ });
+ });
+});