[REQUIRES_FULL_CACHE_FLUSH_WHEN_RELEASED] Refactor FlatEntity to be UniversalFlatEntity superset (#17452)

# Introduction In this PR we're refactoring the `FlatEntity` type to become a superset of the `UniversalFlatEntity`. Right now we're storing all the extra properties in `__universal` property, at some point it might just be sibling to other entity and we might rely on the `propertiesToCompare` constants and TypeScript allowing passing a superset type into a smaller subset type ## FromTo utils The entity to flat entity method now computes the universal information, standardized a typing and pattern to do ## Example Also strictly type ```ts "bbb019ea-6205-498c-aea5-67bc53bce8a9": { "workspaceId": "20202020-1c25-4d02-bf25-6aeccf7ea419", "universalIdentifier": "20202020-d111-4d11-8d11-da5ab0a11002", "applicationId": "d01b010d-b984-465b-b40b-370e954e5188", "id": "bbb019ea-6205-498c-aea5-67bc53bce8a9", "pageLayoutTabId": "791a512f-169f-4209-b731-aa86716668c6", "title": "Deals by Company", "type": "GRAPH", "objectMetadataId": "9e14efea-df5b-4c0e-aba9-cfe455f32397", "gridPosition": { "row": 0, "column": 6, "rowSpan": 6, "columnSpan": 6 }, "configuration": { "color": "orange", "orderBy": "FIELD_ASC", "timezone": "UTC", "displayLegend": true, "displayDataLabel": false, "showCenterMetric": true, "configurationType": "PIE_CHART", "firstDayOfTheWeek": 0, "aggregateOperation": "COUNT", "groupBySubFieldName": "name", "groupByFieldMetadataId": "6673ff18-63d2-47a1-8f85-2b9b09ca27a5", "aggregateFieldMetadataId": "8d64ee41-5dd4-4de6-945a-7c0c18399715" }, "createdAt": "2026-01-28T14:08:52.140Z", "updatedAt": "2026-01-28T14:08:52.140Z", "deletedAt": null, "__universal": { "universalIdentifier": "20202020-d111-4d11-8d11-da5ab0a11002", "applicationUniversalIdentifier": "20202020-64aa-4b6f-b003-9c74b97cee20", "pageLayoutTabUniversalIdentifier": "20202020-d011-4d11-8d11-da5ab0a01001", "objectMetadataUniversalIdentifier": "20202020-9549-49dd-b2b2-883999db8938", "gridPosition": { "row": 0, "column": 6, "rowSpan": 6, "columnSpan": 6 }, "configuration": { "color": "orange", "orderBy": "FIELD_ASC", "timezone": "UTC", "displayLegend": true, "displayDataLabel": false, "showCenterMetric": true, "configurationType": "PIE_CHART", "firstDayOfTheWeek": 0, "aggregateOperation": "COUNT", "groupBySubFieldName": "name", "aggregateFieldMetadataUniversalIdentifier": "20202020-d01a-4131-8a31-f123456789ab", "groupByFieldMetadataUniversalIdentifier": "20202020-cbac-457e-b565-adece5fc815f" } } }, ```
2026-01-28 17:46:34 +01:00
parent 81eaee81a8
commit fe9d6f34ff
90 changed files with 3058 additions and 538 deletions
@@ -1,7 +1,10 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';

+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { WorkspaceFlatViewMapCacheService } from 'src/engine/metadata-modules/flat-view/services/workspace-flat-view-map-cache.service';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
@@ -11,6 +14,9 @@ import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entit
@Module({
  imports: [
    TypeOrmModule.forFeature([
+      ApplicationEntity,
+      FieldMetadataEntity,
+      ObjectMetadataEntity,
      ViewEntity,
      ViewFieldEntity,
      ViewFilterEntity,
@@ -5,15 +5,19 @@ import { type Repository } from 'typeorm';

 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';

+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
 import { type FlatViewMaps } from 'src/engine/metadata-modules/flat-view/types/flat-view-maps.type';
 import { fromViewEntityToFlatView } from 'src/engine/metadata-modules/flat-view/utils/from-view-entity-to-flat-view.util';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
+import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';

@@ -23,6 +27,12 @@ export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<Fla
  constructor(
    @InjectRepository(ViewEntity)
    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectRepository(ApplicationEntity)
+    private readonly applicationRepository: Repository<ApplicationEntity>,
+    @InjectRepository(ObjectMetadataEntity)
+    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
+    @InjectRepository(FieldMetadataEntity)
+    private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
    @InjectRepository(ViewFieldEntity)
    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
    @InjectRepository(ViewFilterEntity)
@@ -36,33 +46,56 @@ export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<Fla
  }

  async computeForCache(workspaceId: string): Promise<FlatViewMaps> {
-    const [views, viewFields, viewFilters, viewGroups, viewFilterGroups] =
-      await Promise.all([
-        this.viewRepository.find({
-          where: { workspaceId },
-          withDeleted: true,
-        }),
-        this.viewFieldRepository.find({
-          where: { workspaceId },
-          select: ['id', 'viewId'],
-          withDeleted: true,
-        }),
-        this.viewFilterRepository.find({
-          where: { workspaceId },
-          select: ['id', 'viewId'],
-          withDeleted: true,
-        }),
-        this.viewGroupRepository.find({
-          where: { workspaceId },
-          select: ['id', 'viewId'],
-          withDeleted: true,
-        }),
-        this.viewFilterGroupRepository.find({
-          where: { workspaceId },
-          select: ['id', 'viewId'],
-          withDeleted: true,
-        }),
-      ]);
+    const [
+      views,
+      applications,
+      objectMetadatas,
+      fieldMetadatas,
+      viewFields,
+      viewFilters,
+      viewGroups,
+      viewFilterGroups,
+    ] = await Promise.all([
+      this.viewRepository.find({
+        where: { workspaceId },
+        withDeleted: true,
+      }),
+      this.applicationRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier'],
+        withDeleted: true,
+      }),
+      this.objectMetadataRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier'],
+        withDeleted: true,
+      }),
+      this.fieldMetadataRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier'],
+        withDeleted: true,
+      }),
+      this.viewFieldRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier', 'viewId'],
+        withDeleted: true,
+      }),
+      this.viewFilterRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier', 'viewId'],
+        withDeleted: true,
+      }),
+      this.viewGroupRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier', 'viewId'],
+        withDeleted: true,
+      }),
+      this.viewFilterGroupRepository.find({
+        where: { workspaceId },
+        select: ['id', 'universalIdentifier', 'viewId'],
+        withDeleted: true,
+      }),
+    ]);

    const [
      viewFieldsByViewId,
@@ -90,16 +123,28 @@ export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<Fla
      ] as const
    ).map(regroupEntitiesByRelatedEntityId);

+    const applicationIdToUniversalIdentifierMap =
+      createIdToUniversalIdentifierMap(applications);
+    const objectMetadataIdToUniversalIdentifierMap =
+      createIdToUniversalIdentifierMap(objectMetadatas);
+    const fieldMetadataIdToUniversalIdentifierMap =
+      createIdToUniversalIdentifierMap(fieldMetadatas);
+
    const flatViewMaps = createEmptyFlatEntityMaps();

    for (const viewEntity of views) {
      const flatView = fromViewEntityToFlatView({
-        ...viewEntity,
-        viewFields: viewFieldsByViewId.get(viewEntity.id) || [],
-        viewFilters: viewFiltersByViewId.get(viewEntity.id) || [],
-        viewGroups: viewGroupsByViewId.get(viewEntity.id) || [],
-        viewFilterGroups: viewFilterGroupsByViewId.get(viewEntity.id) || [],
-      } as ViewEntity);
+        entity: {
+          ...viewEntity,
+          viewFields: viewFieldsByViewId.get(viewEntity.id) || [],
+          viewFilters: viewFiltersByViewId.get(viewEntity.id) || [],
+          viewGroups: viewGroupsByViewId.get(viewEntity.id) || [],
+          viewFilterGroups: viewFilterGroupsByViewId.get(viewEntity.id) || [],
+        },
+        applicationIdToUniversalIdentifierMap,
+        objectMetadataIdToUniversalIdentifierMap,
+        fieldMetadataIdToUniversalIdentifierMap,
+      });

      addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
        flatEntity: flatView,
@@ -1,27 +1,123 @@
-import { removePropertiesFromRecord } from 'twenty-shared/utils';
+import { isDefined, removePropertiesFromRecord } from 'twenty-shared/utils';

+import {
+  FlatEntityMapsException,
+  FlatEntityMapsExceptionCode,
+} from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
 import { getMetadataEntityRelationProperties } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-entity-relation-properties.util';
 import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
-import { type ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { type FromEntityToFlatEntityArgs } from 'src/engine/workspace-cache/types/from-entity-to-flat-entity-args.type';

-export const fromViewEntityToFlatView = (viewEntity: ViewEntity): FlatView => {
+export const fromViewEntityToFlatView = ({
+  entity: viewEntity,
+  applicationIdToUniversalIdentifierMap,
+  objectMetadataIdToUniversalIdentifierMap,
+  fieldMetadataIdToUniversalIdentifierMap,
+}: FromEntityToFlatEntityArgs<'view'>): FlatView => {
  const viewEntityWithoutRelations = removePropertiesFromRecord(
    viewEntity,
    getMetadataEntityRelationProperties('view'),
  );

+  const applicationUniversalIdentifier =
+    applicationIdToUniversalIdentifierMap.get(viewEntity.applicationId);
+
+  if (!isDefined(applicationUniversalIdentifier)) {
+    throw new FlatEntityMapsException(
+      `Application with id ${viewEntity.applicationId} not found for view ${viewEntity.id}`,
+      FlatEntityMapsExceptionCode.ENTITY_NOT_FOUND,
+    );
+  }
+
+  const objectMetadataUniversalIdentifier =
+    objectMetadataIdToUniversalIdentifierMap.get(viewEntity.objectMetadataId);
+
+  if (!isDefined(objectMetadataUniversalIdentifier)) {
+    throw new FlatEntityMapsException(
+      `ObjectMetadata with id ${viewEntity.objectMetadataId} not found for view ${viewEntity.id}`,
+      FlatEntityMapsExceptionCode.ENTITY_NOT_FOUND,
+    );
+  }
+
+  let kanbanAggregateOperationFieldMetadataUniversalIdentifier: string | null =
+    null;
+
+  if (isDefined(viewEntity.kanbanAggregateOperationFieldMetadataId)) {
+    kanbanAggregateOperationFieldMetadataUniversalIdentifier =
+      fieldMetadataIdToUniversalIdentifierMap.get(
+        viewEntity.kanbanAggregateOperationFieldMetadataId,
+      ) ?? null;
+
+    if (!isDefined(kanbanAggregateOperationFieldMetadataUniversalIdentifier)) {
+      throw new FlatEntityMapsException(
+        `FieldMetadata with id ${viewEntity.kanbanAggregateOperationFieldMetadataId} not found for view ${viewEntity.id}`,
+        FlatEntityMapsExceptionCode.ENTITY_NOT_FOUND,
+      );
+    }
+  }
+
+  let calendarFieldMetadataUniversalIdentifier: string | null = null;
+
+  if (isDefined(viewEntity.calendarFieldMetadataId)) {
+    calendarFieldMetadataUniversalIdentifier =
+      fieldMetadataIdToUniversalIdentifierMap.get(
+        viewEntity.calendarFieldMetadataId,
+      ) ?? null;
+
+    if (!isDefined(calendarFieldMetadataUniversalIdentifier)) {
+      throw new FlatEntityMapsException(
+        `FieldMetadata with id ${viewEntity.calendarFieldMetadataId} not found for view ${viewEntity.id}`,
+        FlatEntityMapsExceptionCode.ENTITY_NOT_FOUND,
+      );
+    }
+  }
+
+  let mainGroupByFieldMetadataUniversalIdentifier: string | null = null;
+
+  if (isDefined(viewEntity.mainGroupByFieldMetadataId)) {
+    mainGroupByFieldMetadataUniversalIdentifier =
+      fieldMetadataIdToUniversalIdentifierMap.get(
+        viewEntity.mainGroupByFieldMetadataId,
+      ) ?? null;
+
+    if (!isDefined(mainGroupByFieldMetadataUniversalIdentifier)) {
+      throw new FlatEntityMapsException(
+        `FieldMetadata with id ${viewEntity.mainGroupByFieldMetadataId} not found for view ${viewEntity.id}`,
+        FlatEntityMapsExceptionCode.ENTITY_NOT_FOUND,
+      );
+    }
+  }
+
  return {
    ...viewEntityWithoutRelations,
    createdAt: viewEntity.createdAt.toISOString(),
    updatedAt: viewEntity.updatedAt.toISOString(),
    deletedAt: viewEntity.deletedAt?.toISOString() ?? null,
    universalIdentifier: viewEntityWithoutRelations.universalIdentifier,
-    viewFieldIds: viewEntity.viewFields.map((viewField) => viewField.id),
-    viewFilterIds: viewEntity.viewFilters.map((viewFilter) => viewFilter.id),
-    viewGroupIds: viewEntity.viewGroups.map((viewGroup) => viewGroup.id),
-    viewFilterGroupIds:
-      viewEntity.viewFilterGroups?.map(
-        (viewFilterGroup) => viewFilterGroup.id,
-      ) ?? [],
+    viewFieldIds: viewEntity.viewFields.map(({ id }) => id),
+    viewFilterIds: viewEntity.viewFilters.map(({ id }) => id),
+    viewGroupIds: viewEntity.viewGroups.map(({ id }) => id),
+    viewFilterGroupIds: viewEntity.viewFilterGroups?.map(({ id }) => id) ?? [],
+    __universal: {
+      universalIdentifier: viewEntity.universalIdentifier,
+      applicationUniversalIdentifier,
+      objectMetadataUniversalIdentifier,
+      kanbanAggregateOperationFieldMetadataUniversalIdentifier,
+      calendarFieldMetadataUniversalIdentifier,
+      mainGroupByFieldMetadataUniversalIdentifier,
+      viewFieldUniversalIdentifiers: viewEntity.viewFields.map(
+        ({ universalIdentifier }) => universalIdentifier,
+      ),
+      viewFilterUniversalIdentifiers: viewEntity.viewFilters.map(
+        ({ universalIdentifier }) => universalIdentifier,
+      ),
+      viewGroupUniversalIdentifiers: viewEntity.viewGroups.map(
+        ({ universalIdentifier }) => universalIdentifier,
+      ),
+      viewFilterGroupUniversalIdentifiers:
+        viewEntity.viewFilterGroups?.map(
+          ({ universalIdentifier }) => universalIdentifier,
+        ) ?? [],
+    },
  };
 };