Skip to content

The open alternative to Salesforce, designed for AI.

perf(api): stop expanding timeline activities in depth relations (#27162)

Charles Bochet837fa94a6a75
diff --git a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/__tests__/get-relations-select-fields.util.spec.ts b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/__tests__/get-relations-select-fields.util.spec.ts
new file mode 100644
index 00000000000..927ec193748
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/__tests__/get-relations-select-fields.util.spec.ts
@@ -0,0 +1,199 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+
+import { getRelationsSelectFields } from 'src/engine/api/common/common-select-fields/utils/get-relations-select-fields.util';
+import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+
+type GetRelationsSelectFieldsArgs = Parameters<
+ typeof getRelationsSelectFields
+>[0];
+
+type TestFlatObjectMetadata =
+ GetRelationsSelectFieldsArgs['flatObjectMetadata'];
+
+type TestFlatFieldMetadata = NonNullable<
+ GetRelationsSelectFieldsArgs['flatFieldMetadataMaps']['byUniversalIdentifier'][string]
+>;
+
+const WORKSPACE_ID = 'workspace-id';
+const APPLICATION_ID = 'application-id';
+const OPPORTUNITY_OBJECT_ID = 'opportunity-object-id';
+const COMPANY_OBJECT_ID = 'company-object-id';
+const PERSON_OBJECT_ID = 'person-object-id';
+const TIMELINE_ACTIVITY_OBJECT_ID = 'timeline-activity-object-id';
+
+const createField = ({
+ id,
+ name,
+ type,
+ relationTargetObjectMetadataId = null,
+ relationType,
+}: {
+ id: string;
+ name: string;
+ type: FieldMetadataType;
+ relationTargetObjectMetadataId?: string | null;
+ relationType?: RelationType;
+}): TestFlatFieldMetadata => ({
+ id,
+ universalIdentifier: id,
+ applicationId: APPLICATION_ID,
+ workspaceId: WORKSPACE_ID,
+ type,
+ name,
+ settings: relationType ? { relationType } : null,
+ relationTargetObjectMetadataId,
+});
+
+const createObject = ({
+ id,
+ nameSingular,
+ universalIdentifier = id,
+ fieldIds,
+}: {
+ id: string;
+ nameSingular: string;
+ universalIdentifier?: string;
+ fieldIds: string[];
+}): TestFlatObjectMetadata => ({
+ id,
+ universalIdentifier,
+ applicationId: APPLICATION_ID,
+ workspaceId: WORKSPACE_ID,
+ fieldIds,
+ nameSingular,
+ labelIdentifierFieldMetadataId: null,
+ imageIdentifierFieldMetadataId: null,
+});
+
+const buildFlatEntityMaps = <TEntity extends SyncableFlatEntity>(
+ entities: TEntity[],
+): FlatEntityMaps<TEntity> => ({
+ byUniversalIdentifier: Object.fromEntries(
+ entities.map((entity) => [entity.universalIdentifier, entity]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ entities.map((entity) => [entity.id, entity.universalIdentifier]),
+ ),
+ universalIdentifiersByApplicationId: {},
+});
+
+const buildArgs = (
+ depth: GetRelationsSelectFieldsArgs['depth'],
+): GetRelationsSelectFieldsArgs => {
+ const opportunity = createObject({
+ id: OPPORTUNITY_OBJECT_ID,
+ nameSingular: 'opportunity',
+ fieldIds: [
+ 'opportunity-name',
+ 'opportunity-company',
+ 'opportunity-timeline-activities',
+ ],
+ });
+ const company = createObject({
+ id: COMPANY_OBJECT_ID,
+ nameSingular: 'company',
+ fieldIds: [
+ 'company-name',
+ 'company-account-owner',
+ 'company-timeline-activities',
+ ],
+ });
+ const person = createObject({
+ id: PERSON_OBJECT_ID,
+ nameSingular: 'person',
+ fieldIds: ['person-name'],
+ });
+ const timelineActivity = createObject({
+ id: TIMELINE_ACTIVITY_OBJECT_ID,
+ nameSingular: 'timelineActivity',
+ universalIdentifier: STANDARD_OBJECTS.timelineActivity.universalIdentifier,
+ fieldIds: ['timeline-activity-happens-at'],
+ });
+ const objects = [opportunity, company, person, timelineActivity];
+
+ const fields = [
+ createField({
+ id: 'opportunity-name',
+ name: 'name',
+ type: FieldMetadataType.TEXT,
+ }),
+ createField({
+ id: 'opportunity-company',
+ name: 'company',
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: COMPANY_OBJECT_ID,
+ relationType: RelationType.MANY_TO_ONE,
+ }),
+ createField({
+ id: 'opportunity-timeline-activities',
+ name: 'timelineActivities',
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,
+ relationType: RelationType.ONE_TO_MANY,
+ }),
+ createField({
+ id: 'company-name',
+ name: 'name',
+ type: FieldMetadataType.TEXT,
+ }),
+ createField({
+ id: 'company-account-owner',
+ name: 'accountOwner',
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: PERSON_OBJECT_ID,
+ relationType: RelationType.MANY_TO_ONE,
+ }),
+ createField({
+ id: 'person-name',
+ name: 'name',
+ type: FieldMetadataType.TEXT,
+ }),
+ createField({
+ id: 'company-timeline-activities',
+ name: 'timelineActivities',
+ type: FieldMetadataType.RELATION,
+ relationTargetObjectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,
+ relationType: RelationType.ONE_TO_MANY,
+ }),
+ createField({
+ id: 'timeline-activity-happens-at',
+ name: 'happensAt',
+ type: FieldMetadataType.DATE_TIME,
+ }),
+ ];
+
+ return {
+ flatObjectMetadataMaps: buildFlatEntityMaps(objects),
+ flatFieldMetadataMaps: buildFlatEntityMaps(fields),
+ flatObjectMetadata: opportunity,
+ objectsPermissions: Object.fromEntries(
+ objects.map((object) => [
+ object.id,
+ { canReadObjectRecords: true, restrictedFields: {} },
+ ]),
+ ),
+ depth,
+ };
+};
+
+// A relation selected as `true` is not loaded: only object selections are expanded into nested queries
+describe('getRelationsSelectFields', () => {
+ it('should expand relations but not timeline activities at depth 1', () => {
+ expect(getRelationsSelectFields(buildArgs(1))).toEqual({
+ company: { name: true, accountOwnerId: true, timelineActivities: true },
+ });
+ });
+
+ it('should expand nested relations but not their timeline activities at depth 2', () => {
+ expect(getRelationsSelectFields(buildArgs(2))).toEqual({
+ company: {
+ name: true,
+ accountOwnerId: true,
+ timelineActivities: true,
+ accountOwner: { name: true },
+ },
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-all-selectable-fields.util.ts b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-all-selectable-fields.util.ts
index 67cc22ce958..50f19882838 100644
--- a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-all-selectable-fields.util.ts
+++ b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-all-selectable-fields.util.ts
@@ -29,8 +29,25 @@ export const getAllSelectableFields = ({
onlyUseLabelIdentifierFieldsInRelations = false,
}: {
restrictedFields: RestrictedFieldsPermissions;
- flatObjectMetadata: FlatObjectMetadata;
- flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+ flatObjectMetadata: Pick<
+ FlatObjectMetadata,
+ | 'fieldIds'
+ | 'nameSingular'
+ | 'labelIdentifierFieldMetadataId'
+ | 'imageIdentifierFieldMetadataId'
+ >;
+ flatFieldMetadataMaps: FlatEntityMaps<
+ Pick<
+ OrmFlatFieldMetadata,
+ | 'id'
+ | 'universalIdentifier'
+ | 'applicationId'
+ | 'workspaceId'
+ | 'type'
+ | 'name'
+ | 'settings'
+ >
+ >;
onlyUseLabelIdentifierFieldsInRelations?: boolean;
}): SelectableFieldsStructured => {
const result: SelectableFieldsStructured = {};
diff --git a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-relations-select-fields.util.ts b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-relations-select-fields.util.ts
index cbf6c7c21ef..f30703c6006 100644
--- a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-relations-select-fields.util.ts
+++ b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/get-relations-select-fields.util.ts
@@ -1,9 +1,10 @@
-import { FieldMetadataType, ObjectsPermissions } from 'twenty-shared/types';
+import { FieldMetadataType, type ObjectPermissions } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { getAllSelectableFields } from 'src/engine/api/common/common-select-fields/utils/get-all-selectable-fields.util';
import { getIsFlatFieldAJoinColumn } from 'src/engine/api/common/common-select-fields/utils/get-is-flat-field-a-join-column.util';
import { getIsFlatFieldAJunctionRelationField } from 'src/engine/api/common/common-select-fields/utils/get-is-flat-field-a-junction-relation-field';
+import { isRelationTargetExcludedFromSelection } from 'src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util';
import { CommonSelectedFields } from 'src/engine/api/common/types/common-selected-fields-result.type';
import { MAX_DEPTH } from 'src/engine/api/rest/input-request-parsers/constants/max-depth.constant';
import { Depth } from 'src/engine/api/rest/input-request-parsers/types/depth.type';
@@ -13,6 +14,35 @@ import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-fiel
import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
import { FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+type RelationsSelectFlatObjectMetadata = Pick<
+ FlatObjectMetadata,
+ | 'id'
+ | 'universalIdentifier'
+ | 'applicationId'
+ | 'workspaceId'
+ | 'fieldIds'
+ | 'nameSingular'
+ | 'labelIdentifierFieldMetadataId'
+ | 'imageIdentifierFieldMetadataId'
+>;
+
+type RelationsSelectFlatFieldMetadata = Pick<
+ OrmFlatFieldMetadata,
+ | 'id'
+ | 'universalIdentifier'
+ | 'applicationId'
+ | 'workspaceId'
+ | 'type'
+ | 'name'
+ | 'settings'
+ | 'relationTargetObjectMetadataId'
+>;
+
+type RelationsSelectObjectsPermissions = Record<
+ string,
+ Pick<ObjectPermissions, 'canReadObjectRecords' | 'restrictedFields'>
+>;
+
export const getRelationsSelectFields = ({
flatObjectMetadataMaps,
flatFieldMetadataMaps,
@@ -23,10 +53,10 @@ export const getRelationsSelectFields = ({
currentDepthLevelIsAJunctionTable = false,
recurseIntoJunctionTableRelations = false,
}: {
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
- flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
- flatObjectMetadata: FlatObjectMetadata;
- objectsPermissions: ObjectsPermissions;
+ flatObjectMetadataMaps: FlatEntityMaps<RelationsSelectFlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<RelationsSelectFlatFieldMetadata>;
+ flatObjectMetadata: RelationsSelectFlatObjectMetadata;
+ objectsPermissions: RelationsSelectObjectsPermissions;
depth: Depth | undefined;
onlyUseLabelIdentifierFieldsInRelations?: boolean;
currentDepthLevelIsAJunctionTable?: boolean;
@@ -78,6 +108,10 @@ export const getRelationsSelectFields = ({
continue;
}
+ if (isRelationTargetExcludedFromSelection(relationTargetObjectMetadata)) {
+ continue;
+ }
+
const relationFieldSelectFields = getAllSelectableFields({
restrictedFields:
objectsPermissions[relationTargetObjectMetadata.id].restrictedFields,
diff --git a/packages/twenty-server/src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util.ts b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util.ts
new file mode 100644
index 00000000000..178b0bc1bd8
--- /dev/null
+++ b/packages/twenty-server/src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util.ts
@@ -0,0 +1,10 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+// Timeline history grows with every update, so expanding it per record turns one page into thousands of rows
+export const isRelationTargetExcludedFromSelection = (
+ relationTargetObjectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>,
+): boolean =>
+ relationTargetObjectMetadata.universalIdentifier ===
+ STANDARD_OBJECTS.timelineActivity.universalIdentifier;
diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/__tests__/build-unselectable-relation-warnings.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/__tests__/build-unselectable-relation-warnings.util.spec.ts
new file mode 100644
index 00000000000..9f39d2a66db
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/__tests__/build-unselectable-relation-warnings.util.spec.ts
@@ -0,0 +1,121 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { buildUnselectableRelationWarningsByFieldName } from 'src/engine/core-modules/record-crud/utils/build-unselectable-relation-warnings.util';
+import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+
+type BuildUnselectableRelationWarningsArgs = Parameters<
+ typeof buildUnselectableRelationWarningsByFieldName
+>[0];
+
+type TestFlatFieldMetadata = NonNullable<
+ BuildUnselectableRelationWarningsArgs['flatFieldMetadataMaps']['byUniversalIdentifier'][string]
+>;
+
+type TestFlatObjectMetadata = NonNullable<
+ BuildUnselectableRelationWarningsArgs['flatObjectMetadataMaps']['byUniversalIdentifier'][string]
+>;
+
+const WORKSPACE_ID = 'workspace-id';
+const APPLICATION_ID = 'application-id';
+const OPPORTUNITY_OBJECT_ID = 'opportunity-object-id';
+const COMPANY_OBJECT_ID = 'company-object-id';
+const TIMELINE_ACTIVITY_OBJECT_ID = 'timeline-activity-object-id';
+
+const createRelationField = ({
+ id,
+ name,
+ relationTargetObjectMetadataId,
+}: {
+ id: string;
+ name: string;
+ relationTargetObjectMetadataId: string;
+}): TestFlatFieldMetadata => ({
+ id,
+ universalIdentifier: id,
+ applicationId: APPLICATION_ID,
+ workspaceId: WORKSPACE_ID,
+ type: FieldMetadataType.RELATION,
+ name,
+ relationTargetObjectMetadataId,
+});
+
+const createObject = ({
+ id,
+ nameSingular,
+ universalIdentifier = id,
+}: {
+ id: string;
+ nameSingular: string;
+ universalIdentifier?: string;
+}): TestFlatObjectMetadata => ({
+ id,
+ universalIdentifier,
+ applicationId: APPLICATION_ID,
+ workspaceId: WORKSPACE_ID,
+ nameSingular,
+});
+
+const buildFlatEntityMaps = <TEntity extends SyncableFlatEntity>(
+ entities: TEntity[],
+): FlatEntityMaps<TEntity> => ({
+ byUniversalIdentifier: Object.fromEntries(
+ entities.map((entity) => [entity.universalIdentifier, entity]),
+ ),
+ universalIdentifierById: Object.fromEntries(
+ entities.map((entity) => [entity.id, entity.universalIdentifier]),
+ ),
+ universalIdentifiersByApplicationId: {},
+});
+
+const buildArgs = (): BuildUnselectableRelationWarningsArgs => ({
+ objectName: 'opportunity',
+ flatObjectMetadata: {
+ id: OPPORTUNITY_OBJECT_ID,
+ fieldIds: ['opportunity-company', 'opportunity-timeline-activities'],
+ },
+ flatFieldMetadataMaps: buildFlatEntityMaps([
+ createRelationField({
+ id: 'opportunity-company',
+ name: 'company',
+ relationTargetObjectMetadataId: COMPANY_OBJECT_ID,
+ }),
+ createRelationField({
+ id: 'opportunity-timeline-activities',
+ name: 'timelineActivities',
+ relationTargetObjectMetadataId: TIMELINE_ACTIVITY_OBJECT_ID,
+ }),
+ ]),
+ flatObjectMetadataMaps: buildFlatEntityMaps([
+ createObject({ id: COMPANY_OBJECT_ID, nameSingular: 'company' }),
+ createObject({
+ id: TIMELINE_ACTIVITY_OBJECT_ID,
+ nameSingular: 'timelineActivity',
+ universalIdentifier:
+ STANDARD_OBJECTS.timelineActivity.universalIdentifier,
+ }),
+ ]),
+ selectableRelationFields: {},
+ objectsPermissions: {
+ [OPPORTUNITY_OBJECT_ID]: { restrictedFields: {} },
+ },
+});
+
+describe('buildUnselectableRelationWarningsByFieldName', () => {
+ it('should not blame read access for relations excluded from nested selection', () => {
+ const warnings = buildUnselectableRelationWarningsByFieldName(buildArgs());
+
+ expect(warnings.get('timelineActivities')).toBe(
+ "Field 'timelineActivities' on opportunity cannot be selected as a nested relation. Query timelineActivity records directly instead.",
+ );
+ });
+
+ it('should report missing read access for other unselectable relations', () => {
+ const warnings = buildUnselectableRelationWarningsByFieldName(buildArgs());
+
+ expect(warnings.get('company')).toBe(
+ "Field 'company' on opportunity cannot be selected because you do not have read access to company.",
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-unselectable-relation-warnings.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-unselectable-relation-warnings.util.ts
index 9adaa53e448..6f354bc89b4 100644
--- a/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-unselectable-relation-warnings.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-unselectable-relation-warnings.util.ts
@@ -1,12 +1,14 @@
-import { type ObjectsPermissions } from 'twenty-shared/types';
+import { type ObjectPermissions } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { isRelationTargetExcludedFromSelection } from 'src/engine/api/common/common-select-fields/utils/is-relation-target-excluded-from-selection.util';
import { type CommonSelectedFields } from 'src/engine/api/common/types/common-selected-fields-result.type';
+import { MORPH_OR_RELATION_FIELD_TYPES } from 'src/engine/metadata-modules/field-metadata/types/morph-or-relation-field-metadata-type.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 { 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';
+import { isFlatFieldMetadataOfTypes } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-types.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
-import { isDefined } from 'twenty-shared/utils';
export const buildUnselectableRelationWarningsByFieldName = ({
objectName,
@@ -17,11 +19,34 @@ export const buildUnselectableRelationWarningsByFieldName = ({
objectsPermissions,
}: {
objectName: string;
- flatObjectMetadata: FlatObjectMetadata;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatObjectMetadata: Pick<FlatObjectMetadata, 'id' | 'fieldIds'>;
+ flatFieldMetadataMaps: FlatEntityMaps<
+ Pick<
+ FlatFieldMetadata,
+ | 'id'
+ | 'universalIdentifier'
+ | 'applicationId'
+ | 'workspaceId'
+ | 'type'
+ | 'name'
+ | 'relationTargetObjectMetadataId'
+ >
+ >;
+ flatObjectMetadataMaps: FlatEntityMaps<
+ Pick<
+ FlatObjectMetadata,
+ | 'id'
+ | 'universalIdentifier'
+ | 'applicationId'
+ | 'workspaceId'
+ | 'nameSingular'
+ >
+ >;
selectableRelationFields: CommonSelectedFields;
- objectsPermissions: ObjectsPermissions;
+ objectsPermissions: Record<
+ string,
+ Pick<ObjectPermissions, 'restrictedFields'>
+ >;
}): Map<string, string> => {
const warningsByFieldName = new Map<string, string>();
@@ -36,7 +61,7 @@ export const buildUnselectableRelationWarningsByFieldName = ({
}
if (
- !isMorphOrRelationFlatFieldMetadata(field) ||
+ !isFlatFieldMetadataOfTypes(field, [...MORPH_OR_RELATION_FIELD_TYPES]) ||
isDefined(selectableRelationFields[field.name])
) {
continue;
@@ -59,6 +84,17 @@ export const buildUnselectableRelationWarningsByFieldName = ({
flatEntityMaps: flatObjectMetadataMaps,
});
+ if (
+ isDefined(targetObject) &&
+ isRelationTargetExcludedFromSelection(targetObject)
+ ) {
+ warningsByFieldName.set(
+ field.name,
+ `Field '${field.name}' on ${objectName} cannot be selected as a nested relation. Query ${targetObject.nameSingular} records directly instead.`,
+ );
+ continue;
+ }
+
const warning = isDefined(targetObject)
? `Field '${field.name}' on ${objectName} cannot be selected because you do not have read access to ${targetObject.nameSingular}.`
: `Field '${field.name}' on ${objectName} cannot be selected.`;