Skip to content

The open alternative to Salesforce, designed for AI.

Apply field read permissions to timeline activity properties (#28782)

Charles Bochet910f5fdbe1bd
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
index 263c96becf5..f9c45c013b2 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
@@ -1,7 +1,11 @@
import { Inject, Injectable, Logger } from '@nestjs/common';
import { QUERY_MAX_RECORDS_FROM_RELATION } from 'twenty-shared/constants';
-import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';
+import {
+ FieldMetadataType,
+ type ObjectRecord,
+ type ObjectsPermissions,
+} from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { type ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
@@ -71,6 +75,7 @@ import { getWorkspaceContext } from 'src/engine/twenty-orm/storage/orm-workspace
import { resolveRolePermissionConfig } from 'src/engine/twenty-orm/utils/resolve-role-permission-config.util';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { addTimelineActivityObjectColumnsToSelect } from 'src/modules/timeline/utils/add-timeline-activity-object-columns-to-select.util';
@Injectable()
export abstract class CommonBaseQueryRunnerService<
@@ -276,10 +281,26 @@ export abstract class CommonBaseQueryRunnerService<
queryRunnerContext,
);
- const results = await this.run(processedArgs, {
- ...extendedQueryRunnerContext,
- commonQueryParser,
- });
+ const results = await this.run(
+ {
+ ...processedArgs,
+ selectedFieldsResult: {
+ ...processedArgs.selectedFieldsResult,
+ select: addTimelineActivityObjectColumnsToSelect({
+ select: processedArgs.selectedFieldsResult.select,
+ flatObjectMetadata: queryRunnerContext.flatObjectMetadata,
+ objectsPermissions:
+ extendedQueryRunnerContext.repository.objectRecordsPermissions,
+ flatObjectMetadataMaps: queryRunnerContext.flatObjectMetadataMaps,
+ flatFieldMetadataMaps: queryRunnerContext.flatFieldMetadataMaps,
+ }),
+ },
+ },
+ {
+ ...extendedQueryRunnerContext,
+ commonQueryParser,
+ },
+ );
return this.enrichResultsWithGettersAndHooks({
results,
@@ -289,6 +310,8 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadataMaps: queryRunnerContext.flatObjectMetadataMaps,
flatFieldMetadataMaps: queryRunnerContext.flatFieldMetadataMaps,
transactionScope: queryRunnerContext.transactionScope,
+ objectsPermissions:
+ extendedQueryRunnerContext.repository.objectRecordsPermissions,
});
}
@@ -300,6 +323,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadataMaps,
flatFieldMetadataMaps,
transactionScope,
+ objectsPermissions,
}: {
results: Output;
operationName: CommonQueryNames;
@@ -308,6 +332,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
transactionScope: CommonBaseQueryRunnerContext['transactionScope'];
+ objectsPermissions: ObjectsPermissions;
}): Promise<Output> {
const resultWithGetters = await this.processQueryResult(
results,
@@ -323,6 +348,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadataMaps,
flatFieldMetadataMaps,
authContext,
+ objectsPermissions,
});
const executePostQueryHooks = () =>
diff --git a/packages/twenty-server/src/engine/api/common/common-record-visibility/common-record-visibility.service.ts b/packages/twenty-server/src/engine/api/common/common-record-visibility/common-record-visibility.service.ts
index 52a7db70b8e..6b37cc671ff 100644
--- a/packages/twenty-server/src/engine/api/common/common-record-visibility/common-record-visibility.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-record-visibility/common-record-visibility.service.ts
@@ -1,6 +1,9 @@
import { Injectable } from '@nestjs/common';
-import { type ObjectRecord } from 'twenty-shared/types';
+import {
+ type ObjectRecord,
+ type ObjectsPermissions,
+} from 'twenty-shared/types';
import { type RecordVisibilityRestrictionHandler } from 'src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type';
import { collectRecordsByObjectNameSingular } from 'src/engine/api/common/common-record-visibility/utils/collect-records-by-object-name-singular.util';
@@ -34,12 +37,14 @@ export class CommonRecordVisibilityService {
flatObjectMetadataMaps,
flatFieldMetadataMaps,
authContext,
+ objectsPermissions,
}: {
records: ObjectRecord[];
flatObjectMetadata: FlatObjectMetadata;
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
authContext: WorkspaceAuthContext;
+ objectsPermissions: ObjectsPermissions;
}): Promise<void> {
if (this.handlersByObjectNameSingular.size === 0 || records.length === 0) {
return;
@@ -62,6 +67,9 @@ export class CommonRecordVisibilityService {
?.applyVisibilityRestrictions({
records: collectedRecords,
authContext,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
});
}
}
diff --git a/packages/twenty-server/src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type.ts b/packages/twenty-server/src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type.ts
index 10873d01670..6cf090ddd7f 100644
--- a/packages/twenty-server/src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type.ts
+++ b/packages/twenty-server/src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type.ts
@@ -1,10 +1,19 @@
-import { type ObjectRecord } from 'twenty-shared/types';
+import {
+ type ObjectRecord,
+ type ObjectsPermissions,
+} from 'twenty-shared/types';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
export type RecordVisibilityRestrictionHandler = {
applyVisibilityRestrictions: (args: {
records: ObjectRecord[];
authContext: WorkspaceAuthContext;
+ objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
}) => Promise<void>;
};
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
index b5648d3c718..135052f1fae 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query-filter/graphql-query-filter-field.parser.ts
@@ -132,8 +132,8 @@ export class GraphqlQueryFilterFieldParser {
assertFieldIsReadableOrThrow({
objectsPermissions: outerQueryBuilder.objectRecordsPermissions,
- objectMetadataId: this.flatObjectMetadata.id,
- fieldMetadataId: fieldMetadata.id,
+ flatObjectMetadata: this.flatObjectMetadata,
+ flatFieldMetadata: fieldMetadata,
});
if (
@@ -382,8 +382,8 @@ export class GraphqlQueryFilterFieldParser {
assertFieldIsReadableOrThrow({
objectsPermissions: outerQueryBuilder.objectRecordsPermissions,
- objectMetadataId: referencedScope.flatObjectMetadata.id,
- fieldMetadataId: referencedFieldMetadata.id,
+ flatObjectMetadata: referencedScope.flatObjectMetadata,
+ flatFieldMetadata: referencedFieldMetadata,
});
const fieldColumnReference = useDirectTableReference
diff --git a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util.ts b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util.ts
index cceab9875c3..5a7eff543f0 100644
--- a/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util.ts
+++ b/packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/utils/assert-field-is-readable-or-throw.util.ts
@@ -5,24 +5,34 @@ import {
PermissionsExceptionCode,
PermissionsExceptionMessage,
} from 'src/engine/metadata-modules/permissions/permissions.exception';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { assertTimelineActivityPropertiesAreQueryableOrThrow } from 'src/modules/timeline/utils/assert-timeline-activity-properties-are-queryable-or-throw.util';
// Filtering or ordering by a non-readable field would leak its values (orderBy embeds them into cursors)
export const assertFieldIsReadableOrThrow = ({
objectsPermissions,
- objectMetadataId,
- fieldMetadataId,
+ flatObjectMetadata,
+ flatFieldMetadata,
}: {
objectsPermissions: ObjectsPermissions | undefined;
- objectMetadataId: string;
- fieldMetadataId: string;
+ flatObjectMetadata: Pick<FlatObjectMetadata, 'id' | 'nameSingular'>;
+ flatFieldMetadata: Pick<OrmFlatFieldMetadata, 'id' | 'name'>;
}): void => {
if (
- objectsPermissions?.[objectMetadataId]?.restrictedFields[fieldMetadataId]
- ?.canRead === false
+ objectsPermissions?.[flatObjectMetadata.id]?.restrictedFields[
+ flatFieldMetadata.id
+ ]?.canRead === false
) {
throw new PermissionsException(
PermissionsExceptionMessage.PERMISSION_DENIED,
PermissionsExceptionCode.PERMISSION_DENIED,
);
}
+
+ assertTimelineActivityPropertiesAreQueryableOrThrow({
+ objectNameSingular: flatObjectMetadata.nameSingular,
+ fieldName: flatFieldMetadata.name,
+ objectsPermissions,
+ });
};
diff --git a/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts b/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
index 1dd5fbffc41..73b4a632aa8 100644
--- a/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
+++ b/packages/twenty-server/src/engine/api/utils/__tests__/resolve-order-by-leaves.utils.spec.ts
@@ -1,4 +1,8 @@
-import { FieldMetadataType, OrderByDirection } from 'twenty-shared/types';
+import {
+ FieldMetadataType,
+ OrderByDirection,
+ RelationType,
+} from 'twenty-shared/types';
import { GraphqlQueryRunnerException } from 'src/engine/api/graphql/graphql-query-runner/errors/graphql-query-runner.exception';
import {
@@ -9,6 +13,7 @@ import {
} from 'src/engine/api/utils/resolve-order-by-leaves.utils';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.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';
describe('resolveOrderByLeaves', () => {
@@ -393,6 +398,74 @@ describe('resolveOrderByLeaves', () => {
}),
).toThrow('does not have permission');
});
+
+ it('should reject ordering by timelineActivity properties through a relation for a role with a restricted field', () => {
+ const activityField = createMockField({
+ id: 'activity-id',
+ type: FieldMetadataType.RELATION,
+ name: 'activity',
+ relationTargetObjectMetadataId: 'timeline-activity-object-id',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'activityId',
+ },
+ });
+ const propertiesField = createMockField({
+ id: 'properties-id',
+ type: FieldMetadataType.RAW_JSON,
+ name: 'properties',
+ objectMetadataId: 'timeline-activity-object-id',
+ });
+ const timelineActivityObjectMetadata = getFlatObjectMetadataMock({
+ id: 'timeline-activity-object-id',
+ universalIdentifier: 'timeline-activity-object-id',
+ nameSingular: 'timelineActivity',
+ fieldIds: [propertiesField.id],
+ });
+ const fieldsWithActivity = [...fields, activityField, propertiesField];
+
+ expect(() =>
+ resolveOrderByLeaves({
+ orderBy: [
+ { activity: { properties: OrderByDirection.AscNullsLast } },
+ ],
+ flatObjectMetadata: {
+ ...flatObjectMetadata,
+ fieldIds: [...flatObjectMetadata.fieldIds, activityField.id],
+ },
+ flatObjectMetadataMaps: {
+ ...flatObjectMetadataMaps,
+ byUniversalIdentifier: {
+ ...flatObjectMetadataMaps.byUniversalIdentifier,
+ 'timeline-activity-object-id': timelineActivityObjectMetadata,
+ },
+ universalIdentifierById: {
+ ...flatObjectMetadataMaps.universalIdentifierById,
+ 'timeline-activity-object-id': 'timeline-activity-object-id',
+ },
+ },
+ flatFieldMetadataMaps: {
+ ...flatFieldMetadataMaps,
+ byUniversalIdentifier: Object.fromEntries(
+ fieldsWithActivity.map((field) => [
+ field.universalIdentifier,
+ field,
+ ]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ fieldsWithActivity.map((field) => [
+ field.id,
+ field.universalIdentifier,
+ ]),
+ ),
+ },
+ objectsPermissions: permissionsRestricting(
+ 'company-name-id',
+ 'company-object-id',
+ ),
+ }),
+ ).toThrow('does not have permission');
+ });
});
it('should reject a relation entry with no valid nested direction in strict mode', () => {
diff --git a/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts b/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
index 988582600c0..4968adb25b6 100644
--- a/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
+++ b/packages/twenty-server/src/engine/api/utils/resolve-order-by-leaves.utils.ts
@@ -134,8 +134,8 @@ const resolveRelationLeaf = ({
assertFieldIsReadableOrThrow({
objectsPermissions,
- objectMetadataId: targetObjectMetadata.id,
- fieldMetadataId: targetFieldMetadata.id,
+ flatObjectMetadata: targetObjectMetadata,
+ flatFieldMetadata: targetFieldMetadata,
});
if (isCompositeFieldMetadataType(targetFieldMetadata.type)) {
@@ -247,8 +247,8 @@ export const resolveOrderByLeaves = ({
assertFieldIsReadableOrThrow({
objectsPermissions,
- objectMetadataId: flatObjectMetadata.id,
- fieldMetadataId: fieldMetadata.id,
+ flatObjectMetadata,
+ flatFieldMetadata: fieldMetadata,
});
if (
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util.ts
deleted file mode 100644
index 89a42e6b0fa..00000000000
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-import { type ObjectRecordEvent } from 'twenty-shared/database-events';
-import {
- RelationType,
- type RestrictedFieldsPermissions,
-} from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
-
-import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
-import { getJoinColumnNameForRelationField } from 'src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util';
-import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
-import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
-
-type EventProperties = {
- before?: object;
- after?: object;
- diff?: object;
- updatedFields?: string[];
-};
-
-const buildRestrictedFieldNames = ({
- restrictedFields,
- flatFieldMetadataMaps,
-}: {
- restrictedFields: RestrictedFieldsPermissions;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
-}): Set<string> => {
- const restrictedFieldNames = new Set<string>();
-
- for (const [fieldMetadataId, permissions] of Object.entries(
- restrictedFields,
- )) {
- if (permissions.canRead !== false) {
- continue;
- }
-
- const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMetadataId,
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- if (!isDefined(flatFieldMetadata)) {
- continue;
- }
-
- restrictedFieldNames.add(flatFieldMetadata.name);
-
- if (
- !isMorphOrRelationFlatFieldMetadata(flatFieldMetadata) ||
- flatFieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE
- ) {
- continue;
- }
-
- // The owning side of a relation also travels as its join column: the record
- // snapshots carry the ORM spelling, which settings can rename, while
- // computeUpdatedFieldsFromDiff always appends <name>Id.
- restrictedFieldNames.add(
- getJoinColumnNameForRelationField(flatFieldMetadata),
- );
- restrictedFieldNames.add(
- computeMorphOrRelationFieldJoinColumnName({
- name: flatFieldMetadata.name,
- }),
- );
- }
-
- return restrictedFieldNames;
-};
-
-export const omitRestrictedFieldsFromEvent = <
- TEvent extends ObjectRecordEvent,
->({
- event,
- restrictedFields,
- flatFieldMetadataMaps,
-}: {
- event: TEvent;
- restrictedFields: RestrictedFieldsPermissions | undefined;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
-}): TEvent => {
- if (!isDefined(restrictedFields)) {
- return event;
- }
-
- const restrictedFieldNames = buildRestrictedFieldNames({
- restrictedFields,
- flatFieldMetadataMaps,
- });
-
- if (restrictedFieldNames.size === 0) {
- return event;
- }
-
- const omitRestrictedFields = (record: object | undefined) =>
- isDefined(record)
- ? Object.fromEntries(
- Object.entries(record).filter(
- ([fieldName]) => !restrictedFieldNames.has(fieldName),
- ),
- )
- : undefined;
-
- const properties = event.properties as EventProperties;
- const before = omitRestrictedFields(properties.before);
- const after = omitRestrictedFields(properties.after);
- const diff = omitRestrictedFields(properties.diff);
-
- return {
- ...event,
- properties: {
- ...properties,
- ...(isDefined(before) && { before }),
- ...(isDefined(after) && { after }),
- ...(isDefined(diff) && { diff }),
- ...(isDefined(properties.updatedFields) && {
- updatedFields: properties.updatedFields.filter(
- (fieldName) => !restrictedFieldNames.has(fieldName),
- ),
- }),
- },
- };
-};
diff --git a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/jobs/call-agent-database-event-triggers.job.ts b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/jobs/call-agent-database-event-triggers.job.ts
index f017c21b483..801011e6f5e 100644
--- a/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/jobs/call-agent-database-event-triggers.job.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-trigger/jobs/call-agent-database-event-triggers.job.ts
@@ -14,7 +14,7 @@ import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/
import { buildRoleRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-role-row-access-policy-subject.util';
import { isUpdateOfHiddenFieldsOnly } from 'src/engine/core-modules/record-share/utils/is-update-of-hidden-fields-only.util';
import { omitInheritedReadabilityChildRecords } from 'src/engine/core-modules/record-share/utils/omit-inherited-readability-child-records.util';
-import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util';
import { AGENT_TRIGGER_RUN_LIMITS } from 'src/engine/metadata-modules/ai/ai-agent-trigger/constants/agent-trigger-run-limits.const';
import { RunAgentTriggerJob } from 'src/engine/metadata-modules/ai/ai-agent-trigger/jobs/run-agent-trigger.job';
import { AgentTriggerThrottlerService } from 'src/engine/metadata-modules/ai/ai-agent-trigger/services/agent-trigger-throttler.service';
@@ -103,9 +103,6 @@ export class CallAgentDatabaseEventTriggersJob {
flatObjectMetadataMaps,
}),
);
- const restrictedFields =
- agentObjectsPermissions[objectMetadata.id]?.restrictedFields;
-
const admittedEvents = workspaceEventBatch.events
.filter((event) => admittedRecordIds.has(event.recordId))
.filter(
@@ -120,7 +117,9 @@ export class CallAgentDatabaseEventTriggersJob {
omitInheritedReadabilityChildRecords(
omitRestrictedFieldsFromEvent({
event,
- restrictedFields,
+ objectMetadata,
+ objectsPermissions: agentObjectsPermissions,
+ flatObjectMetadataMaps,
flatFieldMetadataMaps,
}),
),
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
similarity index 82%
rename from packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
rename to packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
index c1cde27ba3f..ced452be732 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
@@ -1,10 +1,16 @@
import { type ObjectRecordUpdateEvent } from 'twenty-shared/database-events';
-import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+import {
+ FieldMetadataType,
+ type ObjectsPermissions,
+ RelationType,
+ type RestrictedFieldsPermissions,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
-import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util';
const OBJECT_METADATA_ID = 'company-object-id';
const SALARY_FIELD_ID = 'salary-field-id';
@@ -69,37 +75,69 @@ const updateEvent = {
},
} as unknown as ObjectRecordUpdateEvent;
+const buildObjectsPermissions = (
+ restrictedFields: RestrictedFieldsPermissions | undefined,
+): ObjectsPermissions => {
+ if (!isDefined(restrictedFields)) {
+ return {};
+ }
+
+ return {
+ [OBJECT_METADATA_ID]: {
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: true,
+ canSoftDeleteObjectRecords: true,
+ canDestroyObjectRecords: true,
+ restrictedFields,
+ rowLevelPermissionPredicates: [],
+ rowLevelPermissionPredicateGroups: [],
+ },
+ };
+};
+
+const omit = ({
+ event,
+ restrictedFields,
+}: {
+ event: ObjectRecordUpdateEvent;
+ restrictedFields: RestrictedFieldsPermissions | undefined;
+}) =>
+ omitRestrictedFieldsFromEvent({
+ event,
+ objectMetadata: { id: OBJECT_METADATA_ID, nameSingular: 'company' },
+ objectsPermissions: buildObjectsPermissions(restrictedFields),
+ flatObjectMetadataMaps: createEmptyFlatEntityMaps(),
+ flatFieldMetadataMaps,
+ });
+
describe('omitRestrictedFieldsFromEvent', () => {
it('should return the event untouched when no field is restricted', () => {
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: updateEvent,
restrictedFields: {
[SALARY_FIELD_ID]: { canRead: true, canUpdate: false },
},
- flatFieldMetadataMaps,
}),
).toBe(updateEvent);
});
it('should return the event untouched without restricted fields', () => {
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: updateEvent,
restrictedFields: undefined,
- flatFieldMetadataMaps,
}),
).toBe(updateEvent);
});
it('should drop an unreadable field from every part of the event', () => {
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: updateEvent,
restrictedFields: {
[SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
},
- flatFieldMetadataMaps,
}),
).toEqual({
recordId: 'record-1',
@@ -124,12 +162,11 @@ describe('omitRestrictedFieldsFromEvent', () => {
} as unknown as ObjectRecordUpdateEvent;
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: salaryOnlyUpdateEvent,
restrictedFields: {
[SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
},
- flatFieldMetadataMaps,
}).properties,
).toEqual({
updatedFields: [],
@@ -145,12 +182,11 @@ describe('omitRestrictedFieldsFromEvent', () => {
} as unknown as ObjectRecordUpdateEvent;
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: deleteEvent,
restrictedFields: {
[SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
},
- flatFieldMetadataMaps,
}).properties,
).toEqual({ before: { id: 'record-1', name: 'Old' } });
});
@@ -170,12 +206,11 @@ describe('omitRestrictedFieldsFromEvent', () => {
} as unknown as ObjectRecordUpdateEvent;
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: companyUpdateEvent,
restrictedFields: {
[COMPANY_FIELD_ID]: { canRead: false, canUpdate: false },
},
- flatFieldMetadataMaps,
}).properties,
).toEqual({
updatedFields: ['name'],
@@ -196,12 +231,11 @@ describe('omitRestrictedFieldsFromEvent', () => {
} as unknown as ObjectRecordUpdateEvent;
expect(
- omitRestrictedFieldsFromEvent({
+ omit({
event: ownerUpdateEvent,
restrictedFields: {
[OWNER_FIELD_ID]: { canRead: false, canUpdate: false },
},
- flatFieldMetadataMaps,
}).properties,
).toEqual({
updatedFields: [],
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/filter-field-names-in-event-properties.util.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/filter-field-names-in-event-properties.util.ts
new file mode 100644
index 00000000000..70d83067e41
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/filter-field-names-in-event-properties.util.ts
@@ -0,0 +1,43 @@
+import { isString } from '@sniptt/guards';
+import { isDefined, isPlainObject } from 'twenty-shared/utils';
+
+type EventPropertiesWithFieldNames = {
+ before?: unknown;
+ after?: unknown;
+ diff?: unknown;
+ updatedFields?: unknown;
+};
+
+export const filterFieldNamesInEventProperties = ({
+ properties,
+ isFieldNameKept,
+}: {
+ properties: EventPropertiesWithFieldNames;
+ isFieldNameKept: (fieldName: string) => boolean;
+}): EventPropertiesWithFieldNames => {
+ const keepFieldNames = (value: unknown) =>
+ isPlainObject(value)
+ ? Object.fromEntries(
+ Object.entries(value).filter(([fieldName]) =>
+ isFieldNameKept(fieldName),
+ ),
+ )
+ : undefined;
+
+ return {
+ ...(isDefined(properties.before) && {
+ before: keepFieldNames(properties.before),
+ }),
+ ...(isDefined(properties.after) && {
+ after: keepFieldNames(properties.after),
+ }),
+ ...(isDefined(properties.diff) && {
+ diff: keepFieldNames(properties.diff),
+ }),
+ ...(Array.isArray(properties.updatedFields) && {
+ updatedFields: properties.updatedFields.filter(
+ (fieldName) => isString(fieldName) && isFieldNameKept(fieldName),
+ ),
+ }),
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/get-field-names-in-event-properties.util.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/get-field-names-in-event-properties.util.ts
new file mode 100644
index 00000000000..6c7be7dfea6
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/get-field-names-in-event-properties.util.ts
@@ -0,0 +1,26 @@
+import { RelationType } from 'twenty-shared/types';
+
+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { getJoinColumnNameForRelationField } from 'src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
+
+export const getFieldNamesInEventProperties = (
+ flatFieldMetadata: OrmFlatFieldMetadata,
+): string[] => {
+ if (
+ !isMorphOrRelationFlatFieldMetadata(flatFieldMetadata) ||
+ flatFieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE
+ ) {
+ return [flatFieldMetadata.name];
+ }
+
+ // Snapshots use the ORM join column (renamable); updatedFields always use <name>Id
+ return [
+ flatFieldMetadata.name,
+ getJoinColumnNameForRelationField(flatFieldMetadata),
+ computeMorphOrRelationFieldJoinColumnName({
+ name: flatFieldMetadata.name,
+ }),
+ ];
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util.ts
new file mode 100644
index 00000000000..fd28c7eda2f
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util.ts
@@ -0,0 +1,101 @@
+import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import {
+ type ObjectsPermissions,
+ type RestrictedFieldsPermissions,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { filterFieldNamesInEventProperties } from 'src/engine/metadata-modules/permissions/utils/filter-field-names-in-event-properties.util';
+import { getFieldNamesInEventProperties } from 'src/engine/metadata-modules/permissions/utils/get-field-names-in-event-properties.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { omitRestrictedFieldsFromTimelineActivityEvent } from 'src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity-event.util';
+
+const buildRestrictedFieldNames = ({
+ restrictedFields,
+ flatFieldMetadataMaps,
+}: {
+ restrictedFields: RestrictedFieldsPermissions;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): Set<string> =>
+ new Set(
+ Object.entries(restrictedFields).flatMap(
+ ([fieldMetadataId, permissions]) => {
+ if (permissions.canRead !== false) {
+ return [];
+ }
+
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ return isDefined(flatFieldMetadata)
+ ? getFieldNamesInEventProperties(flatFieldMetadata)
+ : [];
+ },
+ ),
+ );
+
+const omitFieldNames = <TEvent extends ObjectRecordEvent>({
+ event,
+ restrictedFieldNames,
+}: {
+ event: TEvent;
+ restrictedFieldNames: Set<string>;
+}): TEvent => {
+ if (restrictedFieldNames.size === 0) {
+ return event;
+ }
+
+ return {
+ ...event,
+ properties: {
+ ...event.properties,
+ ...filterFieldNamesInEventProperties({
+ properties: event.properties,
+ isFieldNameKept: (fieldName) => !restrictedFieldNames.has(fieldName),
+ }),
+ },
+ };
+};
+
+export const omitRestrictedFieldsFromEvent = <
+ TEvent extends ObjectRecordEvent,
+>({
+ event,
+ objectMetadata,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+}: {
+ event: TEvent;
+ objectMetadata: Pick<FlatObjectMetadata, 'id' | 'nameSingular'>;
+ objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): TEvent => {
+ const restrictedFields =
+ objectsPermissions[objectMetadata.id]?.restrictedFields;
+
+ const eventWithoutRestrictedFields = isDefined(restrictedFields)
+ ? omitFieldNames({
+ event,
+ restrictedFieldNames: buildRestrictedFieldNames({
+ restrictedFields,
+ flatFieldMetadataMaps,
+ }),
+ })
+ : event;
+
+ return objectMetadata.nameSingular === 'timelineActivity'
+ ? omitRestrictedFieldsFromTimelineActivityEvent({
+ event: eventWithoutRestrictedFields,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ })
+ : eventWithoutRestrictedFields;
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-events-readable-by-role.util.ts b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-events-readable-by-role.util.ts
index 4dbad856b5a..628a951fc26 100644
--- a/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-events-readable-by-role.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/permissions/utils/resolve-events-readable-by-role.util.ts
@@ -5,7 +5,7 @@ import { isDefined } from 'twenty-shared/utils';
import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';
import { buildRoleRowAccessPolicySubject } from 'src/engine/core-modules/record-share/utils/build-role-row-access-policy-subject.util';
import { isUpdateOfHiddenFieldsOnly } from 'src/engine/core-modules/record-share/utils/is-update-of-hidden-fields-only.util';
-import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
@@ -59,15 +59,14 @@ export const resolveEventsReadableByRole = async <
flatObjectMetadataMaps,
}),
);
- const restrictedFields =
- objectsPermissions[workspaceEventBatch.objectMetadata.id]?.restrictedFields;
-
return workspaceEventBatch.events
.filter((event) => admittedRecordIds.has(event.recordId))
.map((event) =>
omitRestrictedFieldsFromEvent({
event,
- restrictedFields,
+ objectMetadata: workspaceEventBatch.objectMetadata,
+ objectsPermissions,
+ flatObjectMetadataMaps,
flatFieldMetadataMaps,
}),
)
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
index a4689cb7f80..6afce4fe598 100644
--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
@@ -34,7 +34,7 @@ import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-mo
import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';
import { omitInheritedReadabilityChildRecords } from 'src/engine/core-modules/record-share/utils/omit-inherited-readability-child-records.util';
-import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/metadata-modules/permissions/utils/omit-restricted-fields-from-event.util';
import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';
import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';
import {
@@ -227,10 +227,6 @@ export class ObjectRecordEventPublisher {
return;
}
- const restrictedFields =
- objectsPermissions[workspaceEventBatch.objectMetadata.id]
- ?.restrictedFields ?? {};
-
for (const event of workspaceEventBatch.events) {
const { action } = parseEventNameOrThrow(workspaceEventBatch.name);
@@ -242,7 +238,9 @@ export class ObjectRecordEventPublisher {
const filteredEvent = omitRestrictedFieldsFromEvent({
event: eventWithObjectName,
- restrictedFields,
+ objectMetadata: workspaceEventBatch.objectMetadata,
+ objectsPermissions,
+ flatObjectMetadataMaps: permissionsContext.flatObjectMetadataMaps,
flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,
});
diff --git a/packages/twenty-server/src/modules/timeline/query-hooks/apply-timeline-activities-visibility-restrictions.service.ts b/packages/twenty-server/src/modules/timeline/query-hooks/apply-timeline-activities-visibility-restrictions.service.ts
new file mode 100644
index 00000000000..2ce23a2a1ea
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/query-hooks/apply-timeline-activities-visibility-restrictions.service.ts
@@ -0,0 +1,44 @@
+import { Injectable, type OnModuleInit } from '@nestjs/common';
+
+import { CommonRecordVisibilityService } from 'src/engine/api/common/common-record-visibility/common-record-visibility.service';
+import { type RecordVisibilityRestrictionHandler } from 'src/engine/api/common/common-record-visibility/types/record-visibility-restriction-handler.type';
+import { omitRestrictedFieldsFromTimelineActivity } from 'src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util';
+
+@Injectable()
+export class ApplyTimelineActivitiesVisibilityRestrictionsService
+ implements RecordVisibilityRestrictionHandler, OnModuleInit
+{
+ constructor(
+ private readonly commonRecordVisibilityService: CommonRecordVisibilityService,
+ ) {}
+
+ onModuleInit() {
+ this.commonRecordVisibilityService.registerHandler({
+ objectNameSingular: 'timelineActivity',
+ handler: this,
+ });
+ }
+
+ public async applyVisibilityRestrictions({
+ records,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }: Parameters<
+ RecordVisibilityRestrictionHandler['applyVisibilityRestrictions']
+ >[0]): Promise<void> {
+ for (const timelineActivity of records) {
+ if (!('properties' in timelineActivity)) {
+ continue;
+ }
+
+ timelineActivity.properties = omitRestrictedFieldsFromTimelineActivity({
+ properties: timelineActivity.properties,
+ timelineActivity,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+ }
+ }
+}
diff --git a/packages/twenty-server/src/modules/timeline/query-hooks/timeline-query-hook.module.ts b/packages/twenty-server/src/modules/timeline/query-hooks/timeline-query-hook.module.ts
index 3afbeb7866b..e7895734d3e 100644
--- a/packages/twenty-server/src/modules/timeline/query-hooks/timeline-query-hook.module.ts
+++ b/packages/twenty-server/src/modules/timeline/query-hooks/timeline-query-hook.module.ts
@@ -1,5 +1,7 @@
import { Module } from '@nestjs/common';
+import { CommonRecordVisibilityModule } from 'src/engine/api/common/common-record-visibility/common-record-visibility.module';
+import { ApplyTimelineActivitiesVisibilityRestrictionsService } from 'src/modules/timeline/query-hooks/apply-timeline-activities-visibility-restrictions.service';
import { TimelineActivityCreateManyPreQueryHook } from 'src/modules/timeline/query-hooks/timeline-activity-create-many.pre-query-hook';
import { TimelineActivityCreateOnePreQueryHook } from 'src/modules/timeline/query-hooks/timeline-activity-create-one.pre-query-hook';
import { TimelineActivityMutationQueryHookService } from 'src/modules/timeline/query-hooks/timeline-activity-mutation-query-hook.service';
@@ -8,8 +10,9 @@ import { TimelineActivityUpdateOnePreQueryHook } from 'src/modules/timeline/quer
import { TimelineActivityModule } from 'src/modules/timeline/timeline-activity.module';
@Module({
- imports: [TimelineActivityModule],
+ imports: [CommonRecordVisibilityModule, TimelineActivityModule],
providers: [
+ ApplyTimelineActivitiesVisibilityRestrictionsService,
TimelineActivityMutationQueryHookService,
TimelineActivityCreateOnePreQueryHook,
TimelineActivityCreateManyPreQueryHook,
diff --git a/packages/twenty-server/src/modules/timeline/utils/__tests__/omit-restricted-fields-from-timeline-activity.util.spec.ts b/packages/twenty-server/src/modules/timeline/utils/__tests__/omit-restricted-fields-from-timeline-activity.util.spec.ts
new file mode 100644
index 00000000000..44af95aea4e
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/__tests__/omit-restricted-fields-from-timeline-activity.util.spec.ts
@@ -0,0 +1,224 @@
+import { type ObjectRecordUpdateEvent } from 'twenty-shared/database-events';
+import {
+ FieldMetadataType,
+ type ObjectPermissions,
+ type ObjectsPermissions,
+} from 'twenty-shared/types';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+import { omitRestrictedFieldsFromTimelineActivityEvent } from 'src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity-event.util';
+import { omitRestrictedFieldsFromTimelineActivity } from 'src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util';
+
+const PERSON_OBJECT = getFlatObjectMetadataMock({
+ id: 'person-object-id',
+ universalIdentifier: 'person-object-id',
+ nameSingular: 'person',
+ fieldIds: ['person-job-title-field-id', 'person-city-field-id'],
+});
+
+const NOTE_OBJECT = getFlatObjectMetadataMock({
+ id: 'note-object-id',
+ universalIdentifier: 'note-object-id',
+ nameSingular: 'note',
+ fieldIds: ['note-title-field-id'],
+});
+
+const flatObjectMetadataMaps = [PERSON_OBJECT, NOTE_OBJECT].reduce(
+ (maps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps: maps }),
+ createEmptyFlatEntityMaps(),
+);
+
+const flatFieldMetadataMaps = [
+ {
+ id: 'person-job-title-field-id',
+ objectMetadataId: PERSON_OBJECT.id,
+ name: 'jobTitle',
+ },
+ {
+ id: 'person-city-field-id',
+ objectMetadataId: PERSON_OBJECT.id,
+ name: 'city',
+ },
+ {
+ id: 'note-title-field-id',
+ objectMetadataId: NOTE_OBJECT.id,
+ name: 'title',
+ },
+]
+ .map(({ id, objectMetadataId, name }) =>
+ getFlatFieldMetadataMock({
+ id,
+ universalIdentifier: id,
+ objectMetadataId,
+ type: FieldMetadataType.TEXT,
+ name,
+ }),
+ )
+ .reduce(
+ (maps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity,
+ flatEntityMaps: maps,
+ }),
+ createEmptyFlatEntityMaps(),
+ );
+
+const buildObjectPermissions = (
+ overrides: Partial<ObjectPermissions>,
+): ObjectPermissions => ({
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: true,
+ canSoftDeleteObjectRecords: true,
+ canDestroyObjectRecords: true,
+ restrictedFields: {},
+ rowLevelPermissionPredicates: [],
+ rowLevelPermissionPredicateGroups: [],
+ ...overrides,
+});
+
+const PERSON_JOB_TITLE_DENIED = {
+ [PERSON_OBJECT.id]: buildObjectPermissions({
+ restrictedFields: {
+ 'person-job-title-field-id': { canRead: false, canUpdate: false },
+ },
+ }),
+ [NOTE_OBJECT.id]: buildObjectPermissions({}),
+};
+
+const DIFF = {
+ diff: {
+ jobTitle: { before: 'Engineer', after: 'Manager' },
+ city: { before: 'Paris', after: 'Lyon' },
+ title: { before: 'Old', after: 'New' },
+ },
+};
+
+type TimelineActivityFixture = {
+ linkedObjectMetadataId?: string | null;
+ targetPersonId?: string | null;
+ properties: Record<string, unknown>;
+};
+
+const omitRestrictedFields = ({
+ timelineActivity,
+ objectsPermissions = PERSON_JOB_TITLE_DENIED,
+}: {
+ timelineActivity: TimelineActivityFixture;
+ objectsPermissions?: ObjectsPermissions;
+}) =>
+ omitRestrictedFieldsFromTimelineActivity({
+ properties: timelineActivity.properties,
+ timelineActivity,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+describe('omitRestrictedFieldsFromTimelineActivity', () => {
+ it('should keep the readable fields of the target object', () => {
+ expect(
+ omitRestrictedFields({
+ timelineActivity: {
+ linkedObjectMetadataId: null,
+ targetPersonId: 'person-id',
+ properties: DIFF,
+ },
+ }),
+ ).toEqual({ diff: { city: { before: 'Paris', after: 'Lyon' } } });
+ });
+
+ it('should keep the readable fields of the linked object', () => {
+ expect(
+ omitRestrictedFields({
+ timelineActivity: {
+ linkedObjectMetadataId: NOTE_OBJECT.id,
+ targetPersonId: 'person-id',
+ properties: DIFF,
+ },
+ }),
+ ).toEqual({ diff: { title: { before: 'Old', after: 'New' } } });
+ });
+
+ it('should keep no field of a linked object the role cannot read', () => {
+ expect(
+ omitRestrictedFields({
+ timelineActivity: {
+ linkedObjectMetadataId: NOTE_OBJECT.id,
+ targetPersonId: 'person-id',
+ properties: DIFF,
+ },
+ objectsPermissions: {
+ ...PERSON_JOB_TITLE_DENIED,
+ [NOTE_OBJECT.id]: buildObjectPermissions({
+ canReadObjectRecords: false,
+ }),
+ },
+ }),
+ ).toEqual({ diff: {} });
+ });
+
+ it('should keep no field when the activity object cannot be found', () => {
+ expect(
+ omitRestrictedFields({ timelineActivity: { properties: DIFF } }),
+ ).toEqual({ diff: {} });
+ });
+
+ it('should keep no field when the linked object column was not selected', () => {
+ expect(
+ omitRestrictedFields({
+ timelineActivity: { targetPersonId: 'person-id', properties: DIFF },
+ }),
+ ).toEqual({ diff: {} });
+ });
+});
+
+type TimelineActivityRecord = {
+ id: string;
+ linkedObjectMetadataId: string | null;
+ targetPersonId: string;
+ properties: Record<string, unknown>;
+};
+
+describe('omitRestrictedFieldsFromTimelineActivityEvent', () => {
+ it('should omit restricted fields from properties in the records and in the diff', () => {
+ const before: TimelineActivityRecord = {
+ id: 'activity-id',
+ linkedObjectMetadataId: null,
+ targetPersonId: 'person-id',
+ properties: DIFF,
+ };
+ const after: TimelineActivityRecord = {
+ ...before,
+ properties: { diff: {} },
+ };
+ const event: ObjectRecordUpdateEvent<TimelineActivityRecord> = {
+ recordId: 'activity-id',
+ properties: {
+ updatedFields: ['properties'],
+ before,
+ after,
+ diff: { properties: { before: DIFF, after: { diff: {} } } },
+ },
+ };
+
+ const readableDiff = { diff: { city: { before: 'Paris', after: 'Lyon' } } };
+
+ expect(
+ omitRestrictedFieldsFromTimelineActivityEvent({
+ event,
+ objectsPermissions: PERSON_JOB_TITLE_DENIED,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }).properties,
+ ).toEqual({
+ updatedFields: ['properties'],
+ before: { ...before, properties: readableDiff },
+ after: { ...after, properties: { diff: {} } },
+ diff: { properties: { before: readableDiff, after: { diff: {} } } },
+ });
+ });
+});
diff --git a/packages/twenty-server/src/modules/timeline/utils/add-timeline-activity-object-columns-to-select.util.ts b/packages/twenty-server/src/modules/timeline/utils/add-timeline-activity-object-columns-to-select.util.ts
new file mode 100644
index 00000000000..d7056f59707
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/add-timeline-activity-object-columns-to-select.util.ts
@@ -0,0 +1,131 @@
+import {
+ FieldMetadataType,
+ type ObjectsPermissions,
+ RelationType,
+} from 'twenty-shared/types';
+import { isDefined, isMorphRelationHead } from 'twenty-shared/utils';
+
+import { type CommonSelectedFields } from 'src/engine/api/common/types/common-selected-fields-result.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+const resolveTimelineActivityObjectColumnNames = ({
+ flatObjectMetadata,
+ objectsPermissions,
+ flatFieldMetadataMaps,
+}: {
+ flatObjectMetadata: Pick<FlatObjectMetadata, 'id' | 'fieldIds'>;
+ objectsPermissions: ObjectsPermissions;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): string[] => {
+ const restrictedFields =
+ objectsPermissions[flatObjectMetadata.id]?.restrictedFields ?? {};
+
+ return flatObjectMetadata.fieldIds.flatMap((fieldId) => {
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (
+ !isDefined(flatFieldMetadata) ||
+ restrictedFields[fieldId]?.canRead === false
+ ) {
+ return [];
+ }
+
+ if (flatFieldMetadata.name === 'linkedObjectMetadataId') {
+ return [flatFieldMetadata.name];
+ }
+
+ if (
+ !isFlatFieldMetadataOfType(
+ flatFieldMetadata,
+ FieldMetadataType.MORPH_RELATION,
+ ) ||
+ isMorphRelationHead(flatFieldMetadata) ||
+ flatFieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE
+ ) {
+ return [];
+ }
+
+ return [
+ computeMorphOrRelationFieldJoinColumnName({
+ name: flatFieldMetadata.name,
+ }),
+ ];
+ });
+};
+
+export const addTimelineActivityObjectColumnsToSelect = ({
+ select,
+ flatObjectMetadata,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+}: {
+ select: CommonSelectedFields;
+ flatObjectMetadata: Pick<
+ FlatObjectMetadata,
+ 'id' | 'nameSingular' | 'fieldIds'
+ >;
+ objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): CommonSelectedFields => {
+ const extendedSelect: CommonSelectedFields = { ...select };
+
+ if (
+ flatObjectMetadata.nameSingular === 'timelineActivity' &&
+ isDefined(select.properties)
+ ) {
+ for (const columnName of resolveTimelineActivityObjectColumnNames({
+ flatObjectMetadata,
+ objectsPermissions,
+ flatFieldMetadataMaps,
+ })) {
+ extendedSelect[columnName] = true;
+ }
+ }
+
+ for (const fieldId of flatObjectMetadata.fieldIds) {
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+ const relationSelect = isDefined(flatFieldMetadata)
+ ? select[flatFieldMetadata.name]
+ : undefined;
+
+ if (
+ !isDefined(flatFieldMetadata?.relationTargetObjectMetadataId) ||
+ typeof relationSelect !== 'object'
+ ) {
+ continue;
+ }
+
+ const targetFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: flatFieldMetadata.relationTargetObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(targetFlatObjectMetadata)) {
+ continue;
+ }
+
+ extendedSelect[flatFieldMetadata.name] =
+ addTimelineActivityObjectColumnsToSelect({
+ select: relationSelect,
+ flatObjectMetadata: targetFlatObjectMetadata,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+ }
+
+ return extendedSelect;
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/assert-timeline-activity-properties-are-queryable-or-throw.util.ts b/packages/twenty-server/src/modules/timeline/utils/assert-timeline-activity-properties-are-queryable-or-throw.util.ts
new file mode 100644
index 00000000000..9e020baec1b
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/assert-timeline-activity-properties-are-queryable-or-throw.util.ts
@@ -0,0 +1,39 @@
+import { type ObjectsPermissions } from 'twenty-shared/types';
+
+import {
+ PermissionsException,
+ PermissionsExceptionCode,
+ PermissionsExceptionMessage,
+} from 'src/engine/metadata-modules/permissions/permissions.exception';
+
+// properties holds other objects' field values, so querying it reveals restricted fields
+export const assertTimelineActivityPropertiesAreQueryableOrThrow = ({
+ objectNameSingular,
+ fieldName,
+ objectsPermissions,
+}: {
+ objectNameSingular: string;
+ fieldName: string;
+ objectsPermissions: ObjectsPermissions | undefined;
+}): void => {
+ if (objectNameSingular !== 'timelineActivity' || fieldName !== 'properties') {
+ return;
+ }
+
+ const hasReadDeniedObjectOrField = Object.values(
+ objectsPermissions ?? {},
+ ).some(
+ (objectPermissions) =>
+ !objectPermissions.canReadObjectRecords ||
+ Object.values(objectPermissions.restrictedFields).some(
+ (fieldPermissions) => fieldPermissions.canRead === false,
+ ),
+ );
+
+ if (hasReadDeniedObjectOrField) {
+ throw new PermissionsException(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ );
+ }
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity-event.util.ts b/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity-event.util.ts
new file mode 100644
index 00000000000..84544a9d0f6
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity-event.util.ts
@@ -0,0 +1,90 @@
+import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import { type ObjectsPermissions } from 'twenty-shared/types';
+import { isDefined, isPlainObject } from 'twenty-shared/utils';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { omitRestrictedFieldsFromTimelineActivity } from 'src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util';
+
+export const omitRestrictedFieldsFromTimelineActivityEvent = <
+ TEvent extends ObjectRecordEvent,
+>({
+ event,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+}: {
+ event: TEvent;
+ objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): TEvent => {
+ const { properties } = event;
+ const before =
+ 'before' in properties && isPlainObject(properties.before)
+ ? properties.before
+ : undefined;
+ const after =
+ 'after' in properties && isPlainObject(properties.after)
+ ? properties.after
+ : undefined;
+
+ const omitRestrictedFields = ({
+ value,
+ timelineActivity,
+ }: {
+ value: unknown;
+ timelineActivity: Record<string, unknown> | undefined;
+ }) =>
+ omitRestrictedFieldsFromTimelineActivity({
+ properties: value,
+ timelineActivity: timelineActivity ?? {},
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+ const omitRestrictedFieldsFromRecord = (record: Record<string, unknown>) => ({
+ ...record,
+ properties: omitRestrictedFields({
+ value: record.properties,
+ timelineActivity: record,
+ }),
+ });
+
+ const diff =
+ 'diff' in properties && isPlainObject(properties.diff)
+ ? properties.diff
+ : undefined;
+ const diffProperties = isPlainObject(diff?.properties)
+ ? diff.properties
+ : undefined;
+
+ return {
+ ...event,
+ properties: {
+ ...properties,
+ ...(isDefined(before) && {
+ before: omitRestrictedFieldsFromRecord(before),
+ }),
+ ...(isDefined(after) && { after: omitRestrictedFieldsFromRecord(after) }),
+ ...(isDefined(diffProperties) && {
+ diff: {
+ ...diff,
+ properties: {
+ ...diffProperties,
+ before: omitRestrictedFields({
+ value: diffProperties.before,
+ timelineActivity: before ?? after,
+ }),
+ after: omitRestrictedFields({
+ value: diffProperties.after,
+ timelineActivity: after ?? before,
+ }),
+ },
+ },
+ }),
+ },
+ };
+};
diff --git a/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util.ts b/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util.ts
new file mode 100644
index 00000000000..5f4a4ee1b0e
--- /dev/null
+++ b/packages/twenty-server/src/modules/timeline/utils/omit-restricted-fields-from-timeline-activity.util.ts
@@ -0,0 +1,163 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { type ObjectsPermissions } from 'twenty-shared/types';
+import { isDefined, isPlainObject } from 'twenty-shared/utils';
+
+import { filterFieldNamesInEventProperties } from 'src/engine/metadata-modules/permissions/utils/filter-field-names-in-event-properties.util';
+import { getFieldNamesInEventProperties } from 'src/engine/metadata-modules/permissions/utils/get-field-names-in-event-properties.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { buildTimelineActivityRelatedMorphFieldMetadataName } from 'src/modules/timeline/utils/timeline-activity-related-morph-field-metadata-name-builder.util';
+
+const objectByTargetColumnNameCache = new WeakMap<
+ FlatEntityMaps<FlatObjectMetadata>,
+ Map<string, FlatObjectMetadata>
+>();
+
+const getObjectByTargetColumnName = (
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>,
+): Map<string, FlatObjectMetadata> => {
+ const cachedObjectByTargetColumnName = objectByTargetColumnNameCache.get(
+ flatObjectMetadataMaps,
+ );
+
+ if (isDefined(cachedObjectByTargetColumnName)) {
+ return cachedObjectByTargetColumnName;
+ }
+
+ const objectByTargetColumnName = new Map<string, FlatObjectMetadata>();
+
+ for (const flatObjectMetadata of Object.values(
+ flatObjectMetadataMaps.byUniversalIdentifier,
+ )) {
+ if (isDefined(flatObjectMetadata)) {
+ objectByTargetColumnName.set(
+ `${buildTimelineActivityRelatedMorphFieldMetadataName(flatObjectMetadata.nameSingular)}Id`,
+ flatObjectMetadata,
+ );
+ }
+ }
+
+ objectByTargetColumnNameCache.set(
+ flatObjectMetadataMaps,
+ objectByTargetColumnName,
+ );
+
+ return objectByTargetColumnName;
+};
+
+const resolveTimelineActivityObject = ({
+ timelineActivity,
+ flatObjectMetadataMaps,
+}: {
+ timelineActivity: Record<string, unknown>;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+}): FlatObjectMetadata | undefined => {
+ if (!('linkedObjectMetadataId' in timelineActivity)) {
+ return undefined;
+ }
+
+ const { linkedObjectMetadataId } = timelineActivity;
+
+ if (isNonEmptyString(linkedObjectMetadataId)) {
+ return findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: linkedObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+ }
+
+ const objectByTargetColumnName = getObjectByTargetColumnName(
+ flatObjectMetadataMaps,
+ );
+
+ for (const [columnName, value] of Object.entries(timelineActivity)) {
+ const flatObjectMetadata = objectByTargetColumnName.get(columnName);
+
+ if (isDefined(flatObjectMetadata) && isNonEmptyString(value)) {
+ return flatObjectMetadata;
+ }
+ }
+
+ return undefined;
+};
+
+const buildReadableFieldNames = ({
+ flatObjectMetadata,
+ isLinkedActivity,
+ objectsPermissions,
+ flatFieldMetadataMaps,
+}: {
+ flatObjectMetadata: Pick<FlatObjectMetadata, 'id' | 'fieldIds'>;
+ isLinkedActivity: boolean;
+ objectsPermissions: ObjectsPermissions;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): Set<string> => {
+ const objectPermissions = objectsPermissions[flatObjectMetadata.id];
+
+ if (isLinkedActivity && objectPermissions?.canReadObjectRecords === false) {
+ return new Set();
+ }
+
+ const restrictedFields = objectPermissions?.restrictedFields ?? {};
+
+ return new Set(
+ flatObjectMetadata.fieldIds.flatMap((fieldId) => {
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (
+ !isDefined(flatFieldMetadata) ||
+ restrictedFields[fieldId]?.canRead === false
+ ) {
+ return [];
+ }
+
+ return getFieldNamesInEventProperties(flatFieldMetadata);
+ }),
+ );
+};
+
+export const omitRestrictedFieldsFromTimelineActivity = ({
+ properties,
+ timelineActivity,
+ objectsPermissions,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+}: {
+ properties: unknown;
+ timelineActivity: Record<string, unknown>;
+ objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): Record<string, unknown> | null => {
+ if (!isPlainObject(properties)) {
+ return null;
+ }
+
+ const flatObjectMetadata = resolveTimelineActivityObject({
+ timelineActivity,
+ flatObjectMetadataMaps,
+ });
+
+ const readableFieldNames = isDefined(flatObjectMetadata)
+ ? buildReadableFieldNames({
+ flatObjectMetadata,
+ isLinkedActivity: isNonEmptyString(
+ timelineActivity.linkedObjectMetadataId,
+ ),
+ objectsPermissions,
+ flatFieldMetadataMaps,
+ })
+ : new Set<string>();
+
+ return {
+ ...properties,
+ ...filterFieldNamesInEventProperties({
+ properties,
+ isFieldNameKept: (fieldName) => readableFieldNames.has(fieldName),
+ }),
+ };
+};
diff --git a/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-field-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-field-permissions.integration-spec.ts
new file mode 100644
index 00000000000..e63f4518012
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/timeline/timeline-activity-field-permissions.integration-spec.ts
@@ -0,0 +1,216 @@
+import { randomUUID } from 'crypto';
+
+import request from 'supertest';
+import { createCustomRoleWithObjectPermissions } from 'test/integration/graphql/utils/create-custom-role-with-object-permissions.util';
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { deleteRole } from 'test/integration/graphql/utils/delete-one-role.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlApiRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
+import { updateWorkspaceMemberRole } from 'test/integration/graphql/utils/update-workspace-member-role.util';
+import { upsertFieldPermissions } from 'test/integration/graphql/utils/upsert-field-permissions.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
+import { assertIsDefinedOrThrow } from 'twenty-shared/utils';
+
+import { PermissionsExceptionMessage } from 'src/engine/metadata-modules/permissions/permissions.exception';
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const client = request(`http://localhost:${APP_PORT}`);
+
+const RESTRICTED_JOB_TITLE = `RESTRICTED-${randomUUID()}`;
+const READABLE_FIRST_NAME = `READABLE-${randomUUID()}`;
+
+const buildTimelineActivitiesOperation = ({
+ personId,
+ filter = {},
+}: {
+ personId: string;
+ filter?: object;
+}) =>
+ findManyOperationFactory({
+ objectMetadataSingularName: 'timelineActivity',
+ objectMetadataPluralName: 'timelineActivities',
+ gqlFields: 'id properties',
+ filter: { and: [{ targetPersonId: { eq: personId } }, filter] },
+ });
+
+describe('Timeline activity field permissions', () => {
+ let personId: string;
+ let customRoleId: string;
+ let originalMemberRoleId: string;
+ let personObjectId: string;
+ let jobTitleFieldId: string;
+ let timelineActivitiesFieldId: string;
+
+ beforeAll(async () => {
+ originalMemberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
+
+ const { objects } = await findManyObjectMetadata({
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: 'id nameSingular fieldsList { id name }',
+ expectToFail: false,
+ });
+ const personObject = objects.find(
+ (object) => object.nameSingular === 'person',
+ );
+ const jobTitleField = personObject?.fieldsList?.find(
+ (field) => field.name === 'jobTitle',
+ );
+ const timelineActivitiesField = personObject?.fieldsList?.find(
+ (field) => field.name === 'timelineActivities',
+ );
+
+ assertIsDefinedOrThrow(personObject);
+ assertIsDefinedOrThrow(jobTitleField);
+ assertIsDefinedOrThrow(timelineActivitiesField);
+
+ personObjectId = personObject.id;
+ jobTitleFieldId = jobTitleField.id;
+ timelineActivitiesFieldId = timelineActivitiesField.id;
+
+ const { roleId } = await createCustomRoleWithObjectPermissions({
+ label: 'TimelineRestrictedJobTitleRole',
+ canReadPerson: true,
+ });
+
+ customRoleId = roleId;
+
+ await upsertFieldPermissions({
+ roleId: customRoleId,
+ fieldPermissions: [
+ {
+ objectMetadataId: personObjectId,
+ fieldMetadataId: jobTitleFieldId,
+ canReadFieldValue: false,
+ canUpdateFieldValue: false,
+ },
+ ],
+ });
+
+ await updateWorkspaceMemberRole({
+ client,
+ roleId: customRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ });
+
+ personId = randomUUID();
+
+ await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: { id: personId, jobTitle: 'Initial job title' },
+ }),
+ );
+
+ await makeGraphqlApiRequest(
+ updateOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ recordId: personId,
+ data: {
+ jobTitle: RESTRICTED_JOB_TITLE,
+ name: { firstName: READABLE_FIRST_NAME, lastName: 'Person' },
+ },
+ }),
+ );
+
+ await waitForAllJobsToFinish();
+ });
+
+ afterAll(async () => {
+ await updateWorkspaceMemberRole({
+ client,
+ roleId: originalMemberRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ });
+
+ await deleteRole(client, customRoleId);
+
+ await makeGraphqlApiRequest(
+ destroyOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ recordId: personId,
+ }),
+ );
+ });
+
+ it('should keep the full diff for a role that can read every field', async () => {
+ const response = await makeGraphqlApiRequest(
+ buildTimelineActivitiesOperation({ personId }),
+ );
+
+ expect(JSON.stringify(response.body.data)).toContain(RESTRICTED_JOB_TITLE);
+ });
+
+ it('should omit the fields the role cannot read', async () => {
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildTimelineActivitiesOperation({ personId }),
+ );
+
+ const serializedData = JSON.stringify(response.body.data);
+
+ expect(serializedData).toContain(READABLE_FIRST_NAME);
+ expect(serializedData).not.toContain(RESTRICTED_JOB_TITLE);
+ });
+
+ it('should refuse a filter on properties for a role with a field it cannot read', async () => {
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ buildTimelineActivitiesOperation({
+ personId,
+ filter: { properties: { like: `%${RESTRICTED_JOB_TITLE}%` } },
+ }),
+ );
+
+ expect(response.body.errors?.[0]?.message).toContain(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ );
+ });
+
+ // Restricting person.timelineActivities is mirrored onto timelineActivity.targetPerson
+ it('should still read properties when the role cannot read the target relation', async () => {
+ const adminResponse = await makeGraphqlApiRequest(
+ buildTimelineActivitiesOperation({ personId }),
+ );
+ const activityIds = adminResponse.body.data.timelineActivities.edges.map(
+ ({ node }: { node: { id: string } }) => node.id,
+ );
+
+ await upsertFieldPermissions({
+ roleId: customRoleId,
+ fieldPermissions: [
+ {
+ objectMetadataId: personObjectId,
+ fieldMetadataId: jobTitleFieldId,
+ canReadFieldValue: false,
+ canUpdateFieldValue: false,
+ },
+ {
+ objectMetadataId: personObjectId,
+ fieldMetadataId: timelineActivitiesFieldId,
+ canReadFieldValue: false,
+ canUpdateFieldValue: false,
+ },
+ ],
+ });
+
+ const response = await makeGraphqlApiRequestWithMemberRole(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'timelineActivity',
+ objectMetadataPluralName: 'timelineActivities',
+ gqlFields: 'id properties',
+ filter: { id: { in: activityIds } },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(JSON.stringify(response.body.data)).not.toContain(
+ RESTRICTED_JOB_TITLE,
+ );
+ });
+});
diff --git a/packages/twenty-server/test/integration/workspace-data-export/workspace-data-export.integration-spec.ts b/packages/twenty-server/test/integration/workspace-data-export/workspace-data-export.integration-spec.ts
index 68977f51de0..9eb22250cd2 100644
--- a/packages/twenty-server/test/integration/workspace-data-export/workspace-data-export.integration-spec.ts
+++ b/packages/twenty-server/test/integration/workspace-data-export/workspace-data-export.integration-spec.ts
@@ -9,6 +9,8 @@ import { type CoreEntityCacheService } from 'src/engine/core-entity-cache/servic
import { type FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { createOneOperation } from 'test/integration/graphql/utils/create-one-operation.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { createWorkspaceDataExport } from 'test/integration/workspace-data-export/utils/create-workspace-data-export.util';
import { listWorkspaceDataExports } from 'test/integration/workspace-data-export/utils/list-workspace-data-exports.util';
@@ -39,14 +41,24 @@ const toRelativeUrl = (url: string) => {
describe('workspace data export (integration)', () => {
const exportIds: string[] = [];
let storage: FileStorageService;
+ let companyId: string;
- beforeAll(() => {
+ beforeAll(async () => {
storage =
getAppProviderByClassName<FileStorageService>('FileStorageService');
+
+ // Other suites in the same shard may delete the seeded companies
+ const { data } = await createOneOperation({
+ objectMetadataSingularName: 'company',
+ input: { name: 'Data export company' },
+ });
+
+ companyId = data.createOneResponse.id;
});
afterAll(async () => {
await setWorkspaceActivationStatus(WorkspaceActivationStatus.ACTIVE);
+ await deleteRecordsByIds('company', [companyId]);
for (const exportId of exportIds) {
await storage.deleteByFileId({