V2 centralize relation optimistic logic (#15552)

# Introduction
This PR aims to deprecate having to manually handle optimistic side
effect foreign key addition in the whole v2 experience.
This PR implements the strong basis + builder refactor of the optimistic
computation of a given flat entity maps with its related flat entity
maps ( runner needs a small refactor on actions type definition first )
Flat entity maps updates through mutations are now only scoped to the
generic entity builder ( very isolated )

## What's next
- Refactor actions v2 type definition to gain grain over `metadataName`
and action operation ( `create` `delete` `update` ).
from `{type: 'create_view_field'}` to `{metadataName: 'view_field',
type: 'create' }`
- Use new optimistic tool computation tools
- Only invalidate impacted flat maps cache

## New tools
Strictly dynamically typed new flat entity maps tools
- `addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow`
-
`deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow`

## Unit test
Adding basic unit testing coverage to introduced tools

## `FlatEntityValidationArgs`
From 
```ts
export type FlatEntityValidationArgs<T extends AllMetadataName> = {
  flatEntityToValidate: MetadataFlatEntity<T>;
  optimisticFlatEntityMaps: MetadataFlatEntityMaps<T>;
  mutableDependencyOptimisticFlatEntityMaps: MetadataValidationRelatedFlatEntityMaps<T>;
  workspaceId: string;
  remainingFlatEntityMapsToValidate: MetadataFlatEntityMaps<T>;
  buildOptions: WorkspaceMigrationBuilderOptions;
};

```

To
```ts
export type FlatEntityValidationArgs<T extends AllMetadataName> = {
  flatEntityToValidate: MetadataFlatEntity<T>;
  optimisticFlatEntityMapsAndRelatedFlatEntityMaps: MetadataFlatEntityAndRelatedFlatEntityMapsForValidation<T>;
  workspaceId: string;
  remainingFlatEntityMapsToValidate: MetadataFlatEntityMaps<T>;
  buildOptions: WorkspaceMigrationBuilderOptions;
};

```

packages/twenty-server/src/engine/core-modules/serverless/drivers/interfaces/serverless-driver.interface.ts

@@ -1,5 +1,5 @@
-import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 import { type ServerlessFunctionExecutionStatus } from 'src/engine/metadata-modules/serverless-function/dtos/serverless-function-execution-result.dto';
+import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 
 export type ServerlessExecuteError = {
   errorType: string;
@@ -15,6 +15,7 @@ export type ServerlessExecuteResult = {
   error?: ServerlessExecuteError;
 };
 
+// TODO refactor to be using FlatServerlessFunction
 export interface ServerlessDriver {
   delete(serverlessFunction: ServerlessFunctionEntity): Promise<void>;
   execute(

packages/twenty-server/src/engine/metadata-modules/flat-entity/constant/all-metadata-many-to-one-relations.constant.ts

@@ -2,6 +2,7 @@ import { type AllMetadataName } from 'twenty-shared/metadata';
 import { type ExtractPropertiesThatEndsWithId } from 'twenty-shared/types';
 
 import { type MetadataEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-entity.type';
+import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
 
 type ExtractEntityRelations<TEntity extends MetadataEntity<AllMetadataName>> = {
   [K in ExtractPropertiesThatEndsWithId<TEntity, 'id' | 'workspaceId'>]: K;
@@ -11,46 +12,93 @@ type MetadataRelatedMetadataNames<T extends AllMetadataName> =
   keyof ExtractEntityRelations<MetadataEntity<T>>;
 
 type MetadataNameAndRelations = {
-  [T in AllMetadataName]: MetadataRelatedMetadataNames<T> extends never
+  [TSourceMetadataName in AllMetadataName]: MetadataRelatedMetadataNames<TSourceMetadataName> extends never
     ? Record<string, never>
     : {
-        [P in MetadataRelatedMetadataNames<T>]?: AllMetadataName;
+        [K in MetadataRelatedMetadataNames<TSourceMetadataName>]?: {
+          [TTargetMetadataName in AllMetadataName]?: {
+            metadataName: TTargetMetadataName;
+            flatEntityForeignKeyAggregator: keyof MetadataFlatEntity<TTargetMetadataName>;
+          };
+        }[AllMetadataName];
       };
 };
 
 export const ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY = {
   fieldMetadata: {
-    objectMetadataId: 'objectMetadata',
+    objectMetadataId: {
+      metadataName: 'objectMetadata',
+      flatEntityForeignKeyAggregator: 'fieldMetadataIds',
+    },
   },
   objectMetadata: {},
   view: {
-    kanbanAggregateOperationFieldMetadataId: 'fieldMetadata',
-    calendarFieldMetadataId: 'fieldMetadata',
-    objectMetadataId: 'objectMetadata',
+    kanbanAggregateOperationFieldMetadataId: {
+      metadataName: 'fieldMetadata',
+      flatEntityForeignKeyAggregator: 'kanbanAggregateOperationViewIds',
+    },
+    calendarFieldMetadataId: {
+      metadataName: 'fieldMetadata',
+      flatEntityForeignKeyAggregator: 'calendarViewIds',
+    },
+    objectMetadataId: {
+      metadataName: 'objectMetadata',
+      flatEntityForeignKeyAggregator: 'viewIds',
+    },
   },
   viewField: {
-    viewId: 'view',
-    fieldMetadataId: 'fieldMetadata',
+    viewId: {
+      metadataName: 'view',
+      flatEntityForeignKeyAggregator: 'viewFieldIds',
+    },
+    fieldMetadataId: {
+      metadataName: 'fieldMetadata',
+      flatEntityForeignKeyAggregator: 'viewFieldIds',
+    },
   },
   viewGroup: {
-    viewId: 'view',
-    fieldMetadataId: 'fieldMetadata',
+    viewId: {
+      metadataName: 'view',
+      flatEntityForeignKeyAggregator: 'viewGroupIds',
+    },
+    fieldMetadataId: {
+      metadataName: 'fieldMetadata',
+      flatEntityForeignKeyAggregator: 'viewGroupIds',
+    },
   },
   index: {
-    objectMetadataId: 'objectMetadata',
+    objectMetadataId: {
+      metadataName: 'objectMetadata',
+      flatEntityForeignKeyAggregator: 'indexMetadataIds',
+    },
   },
   serverlessFunction: {},
   cronTrigger: {
-    serverlessFunctionId: 'serverlessFunction',
+    serverlessFunctionId: {
+      metadataName: 'serverlessFunction',
+      flatEntityForeignKeyAggregator: 'cronTriggerIds',
+    },
   },
   databaseEventTrigger: {
-    serverlessFunctionId: 'serverlessFunction',
+    serverlessFunctionId: {
+      metadataName: 'serverlessFunction',
+      flatEntityForeignKeyAggregator: 'databaseEventTriggerIds',
+    },
   },
   routeTrigger: {
-    serverlessFunctionId: 'serverlessFunction',
+    serverlessFunctionId: {
+      metadataName: 'serverlessFunction',
+      flatEntityForeignKeyAggregator: 'routeTriggerIds',
+    },
   },
   viewFilter: {
-    viewId: 'view',
-    fieldMetadataId: 'fieldMetadata',
+    viewId: {
+      metadataName: 'view',
+      flatEntityForeignKeyAggregator: 'viewFilterIds',
+    },
+    fieldMetadataId: {
+      metadataName: 'fieldMetadata',
+      flatEntityForeignKeyAggregator: 'viewFilterIds',
+    },
   },
 } as const satisfies MetadataNameAndRelations;

packages/twenty-server/src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-and-related-flat-entity-maps-for-validation.type.ts

@@ -0,0 +1,15 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { type MetadataRelatedFlatEntityMapsKeys } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-flat-entity-maps-keys.type';
+import { type MetadataToFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/types/metadata-to-flat-entity-maps-key';
+import { type MetadataValidationRelatedMetadataNames } from 'src/engine/metadata-modules/flat-entity/types/metadata-validation-related-metadata-names.type';
+
+export type MetadataFlatEntityAndRelatedFlatEntityMapsForValidation<
+  T extends AllMetadataName,
+> = Pick<
+  AllFlatEntityMaps,
+  | MetadataRelatedFlatEntityMapsKeys<T>
+  | MetadataToFlatEntityMapsKey<T>
+  | MetadataToFlatEntityMapsKey<MetadataValidationRelatedMetadataNames<T>>
+>;

packages/twenty-server/src/engine/metadata-modules/flat-entity/types/metadata-many-to-one-related-metadata-names.type.ts

@@ -6,5 +6,5 @@ import { type MetadataManyToOneJoinColumn } from 'src/engine/metadata-modules/fl
 export type MetadataManyToOneRelatedMetadataNames<T extends AllMetadataName> =
   Extract<
     (typeof ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY)[T][MetadataManyToOneJoinColumn<T>],
-    AllMetadataName
-  >;
+    { metadataName: AllMetadataName }
+  >['metadataName'];

packages/twenty-server/src/engine/metadata-modules/flat-entity/types/metadata-validation-related-metadata-names.type.ts

@@ -1,16 +1,9 @@
-import { type IsEmptyRecord } from 'twenty-shared/types';
 import { type AllMetadataName } from 'twenty-shared/metadata';
 
 import { type ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant';
 
 export type MetadataValidationRelatedMetadataNames<T extends AllMetadataName> =
-  IsEmptyRecord<
-    (typeof ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION)[T]
-  > extends true
-    ? undefined
-    : NonNullable<
-        Extract<
-          keyof (typeof ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION)[T],
-          AllMetadataName
-        >
-      >;
+  Extract<
+    keyof (typeof ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION)[T],
+    AllMetadataName
+  >;

packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/add-flat-entity-to-flat-entity-and-related-entity-maps-through-mutation-or-throw.spec.ts

@@ -0,0 +1,94 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-and-related-entity-maps-through-mutation-or-throw.util';
+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 { 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';
+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
+
+describe('addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow', () => {
+  it('should add a view and update related objectMetadata with viewId', () => {
+    const objectMetadataId = 'object-1';
+    const viewId = 'view-1';
+    const applicationId = '20202020-f3ad-452e-b5b6-2d49d3ea88b1';
+    const workspaceId = '20202020-bc64-4148-8a79-b3144f743694';
+    const mockObjectMetadata = getFlatObjectMetadataMock({
+      id: objectMetadataId,
+      universalIdentifier: 'object-universal-1',
+      viewIds: [],
+      fieldMetadataIds: [],
+      workspaceId,
+      imageIdentifierFieldMetadataId: '20202020-9d65-415f-b0e1-216a2e257ea4',
+      labelIdentifierFieldMetadataId: '20202020-1a62-405c-87fa-4d4fd215851b',
+      applicationId,
+    });
+
+    const mockFieldMEtadata = getFlatFieldMetadataMock({
+      objectMetadataId,
+      id: '202020-71a3-4856-a3d0-d08cea0ecec6',
+      type: FieldMetadataType.DATE,
+      workspaceId,
+      applicationId,
+      universalIdentifier: 'field-universal-1',
+      viewFieldIds: [],
+      viewGroupIds: [],
+      viewFilterIds: [],
+      calendarViewIds: [],
+    });
+
+    const mockView: Pick<FlatView, 'id'> & Partial<FlatView> = {
+      id: viewId,
+      workspaceId,
+      universalIdentifier: 'view-universal-1',
+      objectMetadataId: objectMetadataId,
+      viewFieldIds: [],
+      viewFilterIds: [],
+      viewGroupIds: [],
+      applicationId,
+      calendarFieldMetadataId: mockFieldMEtadata.id,
+    };
+
+    const flatEntityAndRelatedMapsToMutate: MetadataFlatEntityAndRelatedFlatEntityMaps<'view'> =
+      {
+        flatFieldMetadataMaps: addFlatEntityToFlatEntityMapsOrThrow({
+          flatEntity: mockFieldMEtadata,
+          flatEntityMaps: createEmptyFlatEntityMaps(),
+        }),
+        flatObjectMetadataMaps: addFlatEntityToFlatEntityMapsOrThrow({
+          flatEntity: mockObjectMetadata,
+          flatEntityMaps: createEmptyFlatEntityMaps(),
+        }),
+        flatViewMaps: createEmptyFlatEntityMaps(),
+      };
+
+    addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow({
+      metadataName: 'view',
+      flatEntity: mockView as FlatView,
+      flatEntityAndRelatedMapsToMutate,
+    });
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatViewMaps.byId[mockView.id],
+    ).toMatchObject(mockView);
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatObjectMetadataMaps.byId[
+        objectMetadataId
+      ],
+    ).toMatchObject<Partial<FlatObjectMetadata>>({
+      viewIds: [mockView.id],
+    });
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatFieldMetadataMaps.byId[
+        mockFieldMEtadata.id
+      ],
+    ).toMatchObject<Partial<FlatFieldMetadata>>({
+      calendarViewIds: [mockView.id],
+    });
+  });
+});

packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/__tests__/delete-flat-entity-from-flat-entity-and-related-entity-maps-through-mutation-or-throw.spec.ts

@@ -0,0 +1,104 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/delete-flat-entity-from-flat-entity-and-related-entity-maps-through-mutation-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+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';
+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
+
+describe('deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow', () => {
+  it('should delete a view and update related objectMetadata and fieldMetadata by removing viewId', () => {
+    const objectMetadataId = 'object-1';
+    const viewId = 'view-1';
+    const applicationId = '20202020-f3ad-452e-b5b6-2d49d3ea88b1';
+    const workspaceId = '20202020-bc64-4148-8a79-b3144f743694';
+
+    const mockObjectMetadata = getFlatObjectMetadataMock({
+      id: objectMetadataId,
+      universalIdentifier: 'object-universal-1',
+      viewIds: [viewId, 'something-else'],
+      fieldMetadataIds: [],
+      workspaceId,
+      imageIdentifierFieldMetadataId: '20202020-9d65-415f-b0e1-216a2e257ea4',
+      labelIdentifierFieldMetadataId: '20202020-1a62-405c-87fa-4d4fd215851b',
+      applicationId,
+    });
+
+    const mockFieldMetadata = getFlatFieldMetadataMock({
+      objectMetadataId,
+      id: '20202020-4087-423b-852a-91f91acf2df2',
+      type: FieldMetadataType.DATE,
+      universalIdentifier: 'field-universal-1',
+      viewFieldIds: [],
+      viewGroupIds: [],
+      viewFilterIds: [],
+      workspaceId,
+      calendarViewIds: [viewId],
+      applicationId,
+    });
+
+    const mockView: Partial<FlatView> = {
+      id: viewId,
+      universalIdentifier: 'view-universal-1',
+      objectMetadataId: objectMetadataId,
+      viewFieldIds: [],
+      viewFilterIds: [],
+      viewGroupIds: [],
+      workspaceId,
+      calendarFieldMetadataId: mockFieldMetadata.id,
+      createdAt: new Date('2024-01-01'),
+      updatedAt: new Date('2024-01-01'),
+      icon: 'icon',
+      isCompact: false,
+      name: 'View Name',
+      position: 0,
+      applicationId,
+    };
+
+    const flatEntityAndRelatedMapsToMutate: MetadataFlatEntityAndRelatedFlatEntityMaps<'view'> =
+      {
+        flatFieldMetadataMaps: addFlatEntityToFlatEntityMapsOrThrow({
+          flatEntity: mockFieldMetadata,
+          flatEntityMaps: createEmptyFlatEntityMaps(),
+        }),
+        flatObjectMetadataMaps: addFlatEntityToFlatEntityMapsOrThrow({
+          flatEntity: mockObjectMetadata,
+          flatEntityMaps: createEmptyFlatEntityMaps(),
+        }),
+        flatViewMaps: addFlatEntityToFlatEntityMapsOrThrow({
+          flatEntity: mockView as FlatView,
+          flatEntityMaps: createEmptyFlatEntityMaps(),
+        }),
+      };
+
+    deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow({
+      metadataName: 'view',
+      flatEntity: mockView as FlatView,
+      flatEntityAndRelatedMapsToMutate,
+    });
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatViewMaps.byId[viewId],
+    ).toBeUndefined();
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatObjectMetadataMaps.byId[
+        objectMetadataId
+      ],
+    ).toMatchObject<Partial<FlatObjectMetadata>>({
+      viewIds: ['something-else'],
+    });
+
+    expect(
+      flatEntityAndRelatedMapsToMutate.flatFieldMetadataMaps.byId[
+        mockFieldMetadata.id
+      ],
+    ).toMatchObject<Partial<FlatFieldMetadata>>({
+      calendarViewIds: [],
+    });
+  });
+});

packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-and-related-entity-maps-or-throw.util.ts

@@ -1,90 +0,0 @@
-import { type AllMetadataName } from 'twenty-shared/metadata';
-
-import { ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-many-to-one-relations.constant';
-import {
-  FlatEntityMapsException,
-  FlatEntityMapsExceptionCode,
-} from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
-import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
-import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
-import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
-
-type AddFlatEntityToFlatEntityAndRelatedEntityMapsOrThrowArgs<
-  T extends AllMetadataName,
-> = {
-  metadataName: T;
-  flatEntity: MetadataFlatEntity<T>;
-  flatEntityAndRelatedMaps: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
-};
-export const addFlatEntityToFlatEntityAndRelatedEntityMapsOrThrow = <
-  T extends AllMetadataName,
->({
-  metadataName,
-  flatEntity,
-  flatEntityAndRelatedMaps: initialFlatEntityAndRelatedMaps,
-}: AddFlatEntityToFlatEntityAndRelatedEntityMapsOrThrowArgs<T>): MetadataFlatEntityAndRelatedFlatEntityMaps<T> => {
-  const flatEntityMapsKey: keyof MetadataFlatEntityAndRelatedFlatEntityMaps<T> =
-    getMetadataFlatEntityMapsKey(metadataName);
-
-  const updatedFlatEntityMaps = addFlatEntityToFlatEntityMapsOrThrow({
-    flatEntity,
-    flatEntityMaps: initialFlatEntityAndRelatedMaps[flatEntityMapsKey],
-  });
-
-  // TODO refactor
-  const manyToOneRelatedMetadataName = Object.entries(
-    ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY[metadataName],
-  );
-
-  return manyToOneRelatedMetadataName.reduce(
-    (flatEntityAndRelatedMaps, [relatedMetadataName, foreignKey]) => {
-      const relatedFlatEntityMapsKey = getMetadataFlatEntityMapsKey(
-        relatedMetadataName as AllMetadataName,
-      );
-      const relatedFLatEntityMetadataMaps =
-        flatEntityAndRelatedMaps[relatedFlatEntityMapsKey];
-
-      const relatedFlatEntity = findFlatEntityByIdInFlatEntityMapsOrThrow({
-        flatEntityId: flatEntity[
-          foreignKey as keyof MetadataFlatEntity<T>
-        ] as string,
-        flatEntityMaps: relatedFLatEntityMetadataMaps,
-      });
-
-      const foreignKeyAggregatorProperty = `${metadataName}Ids`;
-
-      if (
-        !Object.prototype.hasOwnProperty.call(
-          relatedFlatEntity,
-          foreignKeyAggregatorProperty,
-        )
-      ) {
-        throw new FlatEntityMapsException(
-          'Should never occur, invalid cached format',
-          FlatEntityMapsExceptionCode.ENTITY_MALFORMED,
-        );
-      }
-
-      const updatedRelatedFlatEntityMetadataMaps = {
-        ...relatedFlatEntity,
-        [foreignKeyAggregatorProperty]: [
-          ...(relatedFlatEntity[
-            foreignKeyAggregatorProperty as keyof MetadataFlatEntity<T>
-          ] as string[]),
-          flatEntity.id,
-        ],
-      };
-
-      return {
-        ...flatEntityAndRelatedMaps,
-        [relatedFlatEntityMapsKey]: updatedRelatedFlatEntityMetadataMaps,
-      };
-    },
-    {
-      ...initialFlatEntityAndRelatedMaps,
-      [flatEntityMapsKey]: updatedFlatEntityMaps,
-    },
-  );
-};

packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-and-related-entity-maps-through-mutation-or-throw.util.ts

@@ -0,0 +1,101 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-many-to-one-relations.constant';
+import {
+  FlatEntityMapsException,
+  FlatEntityMapsExceptionCode,
+} from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
+import { type MetadataRelatedFlatEntityMapsKeys } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-flat-entity-maps-keys.type';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
+import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
+import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
+
+type AddFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrowArgs<
+  T extends AllMetadataName,
+> = {
+  metadataName: T;
+  flatEntity: MetadataFlatEntity<T>;
+  flatEntityAndRelatedMapsToMutate: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
+};
+export const addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow =
+  <T extends AllMetadataName>({
+    metadataName,
+    flatEntity,
+    flatEntityAndRelatedMapsToMutate,
+  }: AddFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrowArgs<T>) => {
+    const flatEntityMapsKey = getMetadataFlatEntityMapsKey(metadataName);
+
+    addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
+      flatEntity,
+      flatEntityMapsToMutate:
+        flatEntityAndRelatedMapsToMutate[flatEntityMapsKey],
+    });
+
+    const manyToOneRelatedMetadataName = Object.entries(
+      ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY[metadataName],
+    ) as Array<
+      [
+        keyof MetadataFlatEntity<T>,
+        {
+          metadataName: AllMetadataName;
+          flatEntityForeignKeyAggregator: keyof MetadataFlatEntity<AllMetadataName>;
+        },
+      ]
+    >;
+
+    for (const [
+      foreignKey,
+      { metadataName: relatedMetadataName, flatEntityForeignKeyAggregator },
+    ] of manyToOneRelatedMetadataName) {
+      const relatedFlatEntityMapsKey =
+        getMetadataFlatEntityMapsKey(relatedMetadataName);
+      const relatedFlatEntityMetadataMaps = flatEntityAndRelatedMapsToMutate[
+        relatedFlatEntityMapsKey as MetadataRelatedFlatEntityMapsKeys<T>
+      ] as FlatEntityMaps<MetadataFlatEntity<typeof relatedMetadataName>>;
+
+      const flatEntityRelatedEntityForeignKeyValue = flatEntity[foreignKey] as
+        | string
+        | undefined;
+
+      if (!isDefined(flatEntityRelatedEntityForeignKeyValue)) {
+        continue;
+      }
+
+      const relatedFlatEntity = findFlatEntityByIdInFlatEntityMapsOrThrow({
+        flatEntityId: flatEntityRelatedEntityForeignKeyValue,
+        flatEntityMaps: relatedFlatEntityMetadataMaps,
+      });
+
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          relatedFlatEntity,
+          flatEntityForeignKeyAggregator,
+        )
+      ) {
+        throw new FlatEntityMapsException(
+          `Should never occur, invalid flat entity typing. flat ${metadataName} should contain ${flatEntityForeignKeyAggregator}`,
+          FlatEntityMapsExceptionCode.ENTITY_MALFORMED,
+        );
+      }
+
+      const updatedRelatedEntity = {
+        ...relatedFlatEntity,
+        [flatEntityForeignKeyAggregator]: [
+          ...(relatedFlatEntity[
+            flatEntityForeignKeyAggregator
+          ] as unknown as string[]),
+          flatEntity.id,
+        ],
+      };
+
+      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
+        flatEntity: updatedRelatedEntity,
+        flatEntityMapsToMutate: relatedFlatEntityMetadataMaps,
+      });
+    }
+  };

packages/twenty-server/src/engine/metadata-modules/flat-entity/utils/delete-flat-entity-from-flat-entity-and-related-entity-maps-through-mutation-or-throw.util.ts

@@ -0,0 +1,107 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-many-to-one-relations.constant';
+import {
+  FlatEntityMapsException,
+  FlatEntityMapsExceptionCode,
+} from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
+import { type MetadataRelatedFlatEntityMapsKeys } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-flat-entity-maps-keys.type';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
+import { deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/delete-flat-entity-from-flat-entity-maps-through-mutation-or-throw.util';
+import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
+
+type DeleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrowArgs<
+  T extends AllMetadataName,
+> = {
+  metadataName: T;
+  flatEntity: MetadataFlatEntity<T>;
+  flatEntityAndRelatedMapsToMutate: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
+};
+export const deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow =
+  <T extends AllMetadataName>({
+    metadataName,
+    flatEntity,
+    flatEntityAndRelatedMapsToMutate,
+  }: DeleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrowArgs<T>) => {
+    const flatEntityMapsKey = getMetadataFlatEntityMapsKey(metadataName);
+
+    deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow<
+      MetadataFlatEntity<T>
+    >({
+      entityToDeleteId: flatEntity.id,
+      flatEntityMapsToMutate:
+        flatEntityAndRelatedMapsToMutate[flatEntityMapsKey],
+    });
+
+    const manyToOneRelatedMetadataName = Object.entries(
+      ALL_METADATA_RELATED_METADATA_BY_FOREIGN_KEY[metadataName],
+    ) as Array<
+      [
+        keyof MetadataFlatEntity<T>,
+        {
+          metadataName: AllMetadataName;
+          flatEntityForeignKeyAggregator: keyof MetadataFlatEntity<AllMetadataName>;
+        },
+      ]
+    >;
+
+    for (const [
+      foreignKey,
+      { metadataName: relatedMetadataName, flatEntityForeignKeyAggregator },
+    ] of manyToOneRelatedMetadataName) {
+      const relatedFlatEntityMapsKey =
+        getMetadataFlatEntityMapsKey(relatedMetadataName);
+
+      const relatedFlatEntityMetadataMaps = flatEntityAndRelatedMapsToMutate[
+        relatedFlatEntityMapsKey as MetadataRelatedFlatEntityMapsKeys<T>
+      ] as FlatEntityMaps<MetadataFlatEntity<typeof relatedMetadataName>>;
+
+      const flatEntityRelatedEntityForeignKeyValue = flatEntity[foreignKey] as
+        | string
+        | undefined;
+
+      if (!isDefined(flatEntityRelatedEntityForeignKeyValue)) {
+        continue;
+      }
+
+      const relatedFlatEntity = findFlatEntityByIdInFlatEntityMaps({
+        flatEntityId: flatEntityRelatedEntityForeignKeyValue,
+        flatEntityMaps: relatedFlatEntityMetadataMaps,
+      });
+
+      if (!isDefined(relatedFlatEntity)) {
+        continue;
+      }
+
+      if (
+        !Object.prototype.hasOwnProperty.call(
+          relatedFlatEntity,
+          flatEntityForeignKeyAggregator,
+        )
+      ) {
+        throw new FlatEntityMapsException(
+          `Should never occur, invalid flat entity typing. flat ${metadataName} should contain ${flatEntityForeignKeyAggregator}`,
+          FlatEntityMapsExceptionCode.ENTITY_MALFORMED,
+        );
+      }
+
+      const updatedRelatedEntity = {
+        ...relatedFlatEntity,
+        [flatEntityForeignKeyAggregator]: (
+          relatedFlatEntity[
+            flatEntityForeignKeyAggregator
+          ] as unknown as string[]
+        ).filter((id) => id !== flatEntity.id),
+      };
+
+      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
+        flatEntity: updatedRelatedEntity,
+        flatEntityMapsToMutate: relatedFlatEntityMetadataMaps,
+      });
+    }
+  };

packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/validators/utils/validate-morph-or-relation-flat-field-metadata.util.ts

@@ -7,9 +7,11 @@ import { type FlatFieldMetadataTypeValidationArgs } from 'src/engine/metadata-mo
 import { type FlatFieldMetadataValidationError } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata-validation-error.type';
 
 export const validateMorphOrRelationFlatFieldMetadata = async ({
-  mutableDependencyOptimisticFlatEntityMaps: { flatObjectMetadataMaps },
   flatEntityToValidate: flatFieldMetadataToValidate,
-  optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
+  optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+    flatFieldMetadataMaps,
+    flatObjectMetadataMaps,
+  },
   remainingFlatEntityMapsToValidate,
 }: FlatFieldMetadataTypeValidationArgs<MorphOrRelationFieldMetadataType>): Promise<
   FlatFieldMetadataValidationError[]
@@ -50,7 +52,7 @@ export const validateMorphOrRelationFlatFieldMetadata = async ({
 
   const targetRelationFlatFieldMetadata =
     remainingFlatEntityMapsToValidate?.byId[relationTargetFieldMetadataId] ??
-    optimisticFlatFieldMetadataMaps.byId[relationTargetFieldMetadataId];
+    flatFieldMetadataMaps.byId[relationTargetFieldMetadataId];
 
   if (
     isDefined(targetRelationFlatObjectMetadata) &&

packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.module.ts

@@ -9,7 +9,10 @@ import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-
 import { FileUploadModule } from 'src/engine/core-modules/file/file-upload/file-upload.module';
 import { FileModule } from 'src/engine/core-modules/file/file.module';
 import { ThrottlerModule } from 'src/engine/core-modules/throttler/throttler.module';
+import { CronTriggerEntity } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { DatabaseEventTriggerEntity } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { RouteTriggerEntity } from 'src/engine/metadata-modules/route-trigger/route-trigger.entity';
 import { ServerlessFunctionLayerModule } from 'src/engine/metadata-modules/serverless-function-layer/serverless-function-layer.module';
 import { ServerlessFunctionTriggerJob } from 'src/engine/metadata-modules/serverless-function/jobs/serverless-function-trigger.job';
 import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
@@ -23,7 +26,12 @@ import { WorkspaceMigrationV2Module } from 'src/engine/workspace-manager/workspa
   imports: [
     FileUploadModule,
     NestjsQueryTypeOrmModule.forFeature([ServerlessFunctionEntity]),
-    TypeOrmModule.forFeature([FeatureFlagEntity]),
+    TypeOrmModule.forFeature([
+      FeatureFlagEntity,
+      DatabaseEventTriggerEntity,
+      CronTriggerEntity,
+      RouteTriggerEntity,
+    ]),
     FileModule,
     ThrottlerModule,
     AuditModule,

packages/twenty-server/src/engine/metadata-modules/serverless-function/services/workspace-flat-serverless-function-map-cache.service.ts

@@ -1,21 +1,22 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 
-import { removePropertiesFromRecord } from 'twenty-shared/utils';
 import { Repository } from 'typeorm';
 
 import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
+import { CronTriggerEntity } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { DatabaseEventTriggerEntity } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
 import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
 import { FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import {
-  SERVERLESS_FUNCTION_ENTITY_RELATION_PROPERTIES,
-  ServerlessFunctionEntity,
-} from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
+import { RouteTriggerEntity } from 'src/engine/metadata-modules/route-trigger/route-trigger.entity';
+import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 import { FlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
+import { fromServerlessFunctionEntityToFlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/utils/from-serverless-function-entity-to-flat-serverless-function.type';
 import { WorkspaceFlatMapCache } from 'src/engine/workspace-flat-map-cache/decorators/workspace-flat-map-cache.decorator';
 import { WorkspaceFlatMapCacheService } from 'src/engine/workspace-flat-map-cache/services/workspace-flat-map-cache.service';
+import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-flat-map-cache/utils/regroup-entities-by-related-entity-id';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
 
 @Injectable()
@@ -28,6 +29,12 @@ export class WorkspaceFlatServerlessFunctionMapCacheService extends WorkspaceFla
     cacheStorageService: CacheStorageService,
     @InjectRepository(ServerlessFunctionEntity)
     private readonly serverlessFunctionRepository: Repository<ServerlessFunctionEntity>,
+    @InjectRepository(DatabaseEventTriggerEntity)
+    private readonly databaseEventTriggerRepository: Repository<DatabaseEventTriggerEntity>,
+    @InjectRepository(CronTriggerEntity)
+    private readonly cronTriggerRepository: Repository<CronTriggerEntity>,
+    @InjectRepository(RouteTriggerEntity)
+    private readonly routeTriggerRepository: Repository<RouteTriggerEntity>,
   ) {
     super(cacheStorageService);
   }
@@ -37,24 +44,73 @@ export class WorkspaceFlatServerlessFunctionMapCacheService extends WorkspaceFla
   }: {
     workspaceId: string;
   }): Promise<FlatEntityMaps<FlatServerlessFunction>> {
-    const serverlessFunctions = await this.serverlessFunctionRepository.find({
-      where: {
-        workspaceId,
-      },
-      withDeleted: true,
-    });
+    const [
+      serverlessFunctions,
+      routeTriggers,
+      cronTriggers,
+      databaseEventTriggers,
+    ] = await Promise.all([
+      this.serverlessFunctionRepository.find({
+        where: { workspaceId },
+        withDeleted: true,
+      }),
+      this.cronTriggerRepository.find({
+        where: { workspaceId },
+        select: ['id', 'serverlessFunctionId'],
+        withDeleted: true,
+      }),
+      this.routeTriggerRepository.find({
+        where: { workspaceId },
+        select: ['id', 'serverlessFunctionId'],
+        withDeleted: true,
+      }),
+      this.databaseEventTriggerRepository.find({
+        where: { workspaceId },
+        select: ['id', 'serverlessFunctionId'],
+        withDeleted: true,
+      }),
+    ]);
+
+    const [
+      routeTriggersByServerlessFunctionId,
+      cronTriggersByServerlessFunctionId,
+      databaseEventTriggersByServerlessFunctionId,
+    ] = (
+      [
+        {
+          entities: routeTriggers,
+          foreignKey: 'serverlessFunctionId',
+        },
+        {
+          entities: cronTriggers,
+          foreignKey: 'serverlessFunctionId',
+        },
+        {
+          entities: databaseEventTriggers,
+          foreignKey: 'serverlessFunctionId',
+        },
+      ] as const
+    ).map(regroupEntitiesByRelatedEntityId);
 
     const flatServerlessFunctionMaps = createEmptyFlatEntityMaps();
 
     for (const serverlessFunctionEntity of serverlessFunctions) {
-      const flatServerlessFunction = {
-        ...removePropertiesFromRecord(serverlessFunctionEntity, [
-          ...SERVERLESS_FUNCTION_ENTITY_RELATION_PROPERTIES,
-        ]),
-        universalIdentifier:
-          serverlessFunctionEntity.universalIdentifier ??
-          serverlessFunctionEntity.id,
-      } satisfies FlatServerlessFunction;
+      const flatServerlessFunction =
+        fromServerlessFunctionEntityToFlatServerlessFunction({
+          ...serverlessFunctionEntity,
+          routeTriggers:
+            routeTriggersByServerlessFunctionId.get(
+              serverlessFunctionEntity.id,
+            ) || [],
+          cronTriggers:
+            cronTriggersByServerlessFunctionId.get(
+              serverlessFunctionEntity.id,
+            ) || [],
+          databaseEventTriggers:
+            databaseEventTriggersByServerlessFunctionId.get(
+              serverlessFunctionEntity.id,
+            ) || [],
+        } as ServerlessFunctionEntity);
 
       addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
         flatEntity: flatServerlessFunction,

packages/twenty-server/src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type.ts

@@ -1,3 +1,4 @@
+import { type Sources } from 'src/engine/core-modules/file-storage/types/source.type';
 import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { type CronTriggerEntity } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
 import { type DatabaseEventTriggerEntity } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
@@ -6,7 +7,6 @@ import { type RouteTriggerEntity } from 'src/engine/metadata-modules/route-trigg
 import { type ServerlessFunctionLayerEntity } from 'src/engine/metadata-modules/serverless-function-layer/serverless-function-layer.entity';
 import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 import { type ExtractRecordTypeOrmRelationProperties } from 'src/engine/workspace-manager/workspace-migration-v2/types/extract-record-typeorm-relation-properties.type';
-import { type Sources } from 'src/engine/core-modules/file-storage/types/source.type';
 
 export type ServerlessFunctionEntityRelationProperties =
   ExtractRecordTypeOrmRelationProperties<
@@ -22,5 +22,8 @@ export type FlatServerlessFunction = FlatEntityFrom<
   ServerlessFunctionEntity,
   ServerlessFunctionEntityRelationProperties
 > & {
+  databaseEventTriggerIds: string[];
+  cronTriggerIds: string[];
+  routeTriggerIds: string[];
   code?: Sources;
 };

packages/twenty-server/src/engine/metadata-modules/serverless-function/utils/from-create-serverless-function-input-to-flat-serverless-function.util.ts

@@ -24,6 +24,9 @@ export const fromCreateServerlessFunctionInputToFlatServerlessFunction = ({
   const currentDate = new Date();
 
   return {
+    cronTriggerIds: [],
+    databaseEventTriggerIds: [],
+    routeTriggerIds: [],
     id,
     name: rawCreateServerlessFunctionInput.name,
     description: rawCreateServerlessFunctionInput.description ?? null,

packages/twenty-server/src/engine/metadata-modules/serverless-function/utils/from-serverless-function-entity-to-flat-serverless-function.type.ts

@@ -0,0 +1,32 @@
+import { removePropertiesFromRecord } from 'twenty-shared/utils';
+
+import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
+import { type FlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
+
+export const fromServerlessFunctionEntityToFlatServerlessFunction = (
+  serverlessFunctionEntity: ServerlessFunctionEntity,
+): FlatServerlessFunction => {
+  const serverlessFunctionWithoutRelations = removePropertiesFromRecord(
+    serverlessFunctionEntity,
+    [
+      'databaseEventTriggers',
+      'routeTriggers',
+      'cronTriggers',
+      'serverlessFunctionLayer',
+      'application',
+    ],
+  );
+
+  return {
+    ...serverlessFunctionWithoutRelations,
+    cronTriggerIds:
+      serverlessFunctionEntity.cronTriggers.map((el) => el.id) ?? [],
+    routeTriggerIds:
+      serverlessFunctionEntity.routeTriggers.map((el) => el.id) ?? [],
+    databaseEventTriggerIds:
+      serverlessFunctionEntity.databaseEventTriggers.map((el) => el.id) ?? [],
+    universalIdentifier:
+      serverlessFunctionEntity.universalIdentifier ??
+      serverlessFunctionEntity.id,
+  };
+};

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/services/workspace-migration-build-orchestrator.service.ts

@@ -1,9 +1,11 @@
 import { Injectable } from '@nestjs/common';
 
+import { AllMetadataName } from 'twenty-shared/metadata';
 import { isDefined } from 'twenty-shared/utils';
 
 import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
 import { AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
 import { createEmptyOrchestratorActionsReport } from 'src/engine/workspace-manager/workspace-migration-v2/constant/empty-orchestrator-actions-report.constant';
 import { EMPTY_ORCHESTRATOR_FAILURE_REPORT } from 'src/engine/workspace-manager/workspace-migration-v2/constant/empty-orchestrator-failure-report.constant';
 import {
@@ -71,6 +73,26 @@ export class WorkspaceMigrationBuildOrchestratorService {
     );
   }
 
+  private mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation<
+    T extends AllMetadataName,
+  >({
+    allFlatEntityMaps,
+    flatEntityMapsAndRelatedFlatEntityMaps,
+  }: {
+    flatEntityMapsAndRelatedFlatEntityMaps: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
+    allFlatEntityMaps: AllFlatEntityMaps;
+  }) {
+    const flatEntityMapsKeys = Object.keys(
+      flatEntityMapsAndRelatedFlatEntityMaps,
+    ) as (keyof MetadataFlatEntityAndRelatedFlatEntityMaps<T>)[];
+
+    for (const flatEntityMapsKey of flatEntityMapsKeys) {
+      // @ts-expect-error TODO improve
+      allFlatEntityMaps[flatEntityMapsKey] =
+        flatEntityMapsAndRelatedFlatEntityMaps[flatEntityMapsKey];
+    }
+  }
+
   public async buildWorkspaceMigration({
     workspaceId,
     buildOptions,
@@ -144,8 +166,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatObjectMetadataMaps =
-        objectResult.optimisticFlatEntityMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            objectResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (objectResult.status === 'fail') {
         orchestratorFailureReport.objectMetadata.push(...objectResult.errors);
@@ -171,10 +198,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatFieldMetadataMaps =
-        fieldResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatObjectMetadataMaps =
-        fieldResult.dependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            fieldResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (fieldResult.status === 'fail') {
         orchestratorFailureReport.fieldMetadata.push(...fieldResult.errors);
@@ -201,10 +231,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatIndexMaps =
-        indexResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatObjectMetadataMaps =
-        indexResult.dependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            indexResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (indexResult.status === 'fail') {
         orchestratorFailureReport.index.push(...indexResult.errors);
@@ -231,10 +264,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatViewMaps =
-        viewResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatObjectMetadataMaps =
-        viewResult.dependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            viewResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (viewResult.status === 'fail') {
         orchestratorFailureReport.view.push(...viewResult.errors);
@@ -263,12 +299,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatViewFieldMaps =
-        viewFieldResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatViewMaps =
-        viewFieldResult.dependencyOptimisticFlatEntityMaps.flatViewMaps;
-      optimisticAllFlatEntityMaps.flatFieldMetadataMaps =
-        viewFieldResult.dependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            viewFieldResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (viewFieldResult.status === 'fail') {
         orchestratorFailureReport.viewField.push(...viewFieldResult.errors);
@@ -295,10 +332,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatViewFilterMaps =
-        viewFilterResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatViewMaps =
-        viewFilterResult.dependencyOptimisticFlatEntityMaps.flatViewMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            viewFilterResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (viewFilterResult.status === 'fail') {
         orchestratorFailureReport.viewFilter.push(...viewFilterResult.errors);
@@ -325,10 +365,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatViewGroupMaps =
-        viewGroupResult.optimisticFlatEntityMaps;
-      optimisticAllFlatEntityMaps.flatViewMaps =
-        viewGroupResult.dependencyOptimisticFlatEntityMaps.flatViewMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            viewGroupResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (viewGroupResult.status === 'fail') {
         orchestratorFailureReport.viewGroup.push(...viewGroupResult.errors);
@@ -354,8 +397,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatServerlessFunctionMaps =
-        serverlessFunctionResult.optimisticFlatEntityMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            serverlessFunctionResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (serverlessFunctionResult.status === 'fail') {
         orchestratorFailureReport.serverlessFunction.push(
@@ -387,8 +435,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatDatabaseEventTriggerMaps =
-        databaseEventTriggerResult.optimisticFlatEntityMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            databaseEventTriggerResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (databaseEventTriggerResult.status === 'fail') {
         orchestratorFailureReport.databaseEventTrigger.push(
@@ -418,8 +471,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatCronTriggerMaps =
-        cronTriggerResult.optimisticFlatEntityMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            cronTriggerResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (cronTriggerResult.status === 'fail') {
         orchestratorFailureReport.cronTrigger.push(...cronTriggerResult.errors);
@@ -446,8 +504,13 @@ export class WorkspaceMigrationBuildOrchestratorService {
           },
         );
 
-      optimisticAllFlatEntityMaps.flatRouteTriggerMaps =
-        routeTriggerResult.optimisticFlatEntityMaps;
+      this.mergeFlatEntityMapsAndRelatedFlatEntityMapsInAllFlatEntityMapsThroughMutation(
+        {
+          allFlatEntityMaps: optimisticAllFlatEntityMaps,
+          flatEntityMapsAndRelatedFlatEntityMaps:
+            routeTriggerResult.optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        },
+      );
 
       if (routeTriggerResult.status === 'fail') {
         orchestratorFailureReport.routeTrigger.push(

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/field/workspace-migration-v2-field-actions-builder.service.ts

@@ -1,11 +1,8 @@
 import { Injectable } from '@nestjs/common';
 
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
 
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { UpdateFieldAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/field/types/workspace-migration-field-action-v2';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
@@ -43,28 +40,7 @@ export class WorkspaceMigrationV2FieldActionsBuilderService extends WorkspaceEnt
       };
     }
 
-    const {
-      flatEntityToValidate: flatFieldMetadataToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatFieldMetadataToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatObjectMetadata,
-        fieldMetadataIds: [
-          ...flatObjectMetadata.fieldMetadataIds,
-          flatFieldMetadataToValidate.id,
-        ],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
+    const { flatEntityToValidate: flatFieldMetadataToValidate } = args;
 
     return {
       status: 'success',
@@ -94,29 +70,7 @@ export class WorkspaceMigrationV2FieldActionsBuilderService extends WorkspaceEnt
       };
     }
 
-    const {
-      flatEntityToValidate: flatFieldMetadataToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatFieldMetadataToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    if (isDefined(flatObjectMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatObjectMetadata,
-          fieldMetadataIds: flatObjectMetadata.fieldMetadataIds.filter(
-            (id) => id !== flatFieldMetadataToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-      });
-    }
+    const { flatEntityToValidate: flatFieldMetadataToValidate } = args;
 
     return {
       status: 'success',
@@ -150,11 +104,16 @@ export class WorkspaceMigrationV2FieldActionsBuilderService extends WorkspaceEnt
       };
     }
 
-    const { flatEntityId, flatEntityUpdates, optimisticFlatEntityMaps } = args;
+    const {
+      flatEntityId,
+      flatEntityUpdates,
+      optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+    } = args;
 
     const flatFieldMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
       flatEntityId: flatEntityId,
-      flatEntityMaps: optimisticFlatEntityMaps,
+      flatEntityMaps:
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps.flatFieldMetadataMaps,
     });
 
     const updateFieldAction: UpdateFieldAction = {

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/index/workspace-migration-v2-index-actions-builder.service.ts

@@ -6,10 +6,8 @@ import { isDefined } from 'twenty-shared/utils';
 
 import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
 import { FlatEntityMapsExceptionCode } from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
 import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
 import { deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/delete-flat-entity-from-flat-entity-maps-through-mutation-or-throw.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
 import { FlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-validation-args.type';
@@ -42,28 +40,7 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
       };
     }
 
-    const {
-      flatEntityToValidate: flatIndexToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatIndexToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatObjectMetadata,
-        indexMetadataIds: [
-          ...flatObjectMetadata.indexMetadataIds,
-          flatIndexToValidate.id,
-        ],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
+    const { flatEntityToValidate: flatIndexToValidate } = args;
 
     return {
       status: 'success',
@@ -89,29 +66,7 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
       };
     }
 
-    const {
-      flatEntityToValidate: flatIndexToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatIndexToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    if (isDefined(flatObjectMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatObjectMetadata,
-          indexMetadataIds: flatObjectMetadata.indexMetadataIds.filter(
-            (id) => id !== flatIndexToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-      });
-    }
+    const { flatEntityToValidate: flatIndexToValidate } = args;
 
     return {
       status: 'success',
@@ -123,10 +78,9 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
   }
 
   protected async validateFlatEntityUpdate({
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatIndexMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
     buildOptions,
     workspaceId,
   }: FlatEntityUpdateValidationArgs<typeof ALL_METADATA_NAME.index>): Promise<
@@ -134,7 +88,8 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
   > {
     const flatEntity = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId,
-      flatEntityMaps: optimisticFlatIndexMaps,
+      flatEntityMaps:
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps.flatIndexMaps,
     });
 
     if (!isDefined(flatEntity)) {
@@ -153,8 +108,7 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
     const deletionValidationResult =
       this.flatIndexValidatorService.validateFlatIndexDeletion({
         buildOptions,
-        mutableDependencyOptimisticFlatEntityMaps,
-        optimisticFlatEntityMaps: optimisticFlatIndexMaps,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
         workspaceId,
         flatEntityToValidate: flatEntity,
         remainingFlatEntityMapsToValidate: createEmptyFlatEntityMaps(),
@@ -175,7 +129,7 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
     };
 
     const tempOptimisticFlatIndexMaps = structuredClone(
-      optimisticFlatIndexMaps,
+      optimisticFlatEntityMapsAndRelatedFlatEntityMaps.flatIndexMaps,
     );
 
     deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow({
@@ -186,10 +140,12 @@ export class WorkspaceMigrationV2IndexActionsBuilderService extends WorkspaceEnt
     const creationValidationResult =
       this.flatIndexValidatorService.validateFlatIndexCreation({
         buildOptions,
-        mutableDependencyOptimisticFlatEntityMaps,
         workspaceId,
         flatEntityToValidate: updatedFlatIndex,
-        optimisticFlatEntityMaps: tempOptimisticFlatIndexMaps,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+          ...optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+          flatIndexMaps: tempOptimisticFlatIndexMaps,
+        },
         remainingFlatEntityMapsToValidate: createEmptyFlatEntityMaps(),
       });
 

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-field/workspace-migration-v2-view-field-actions-builder.service.ts

@@ -1,11 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
 
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { UpdateViewFieldAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-field/types/workspace-migration-view-field-action-v2.type';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
@@ -41,48 +37,11 @@ export class WorkspaceMigrationV2ViewFieldActionsBuilderService extends Workspac
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewFieldToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatFieldMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewFieldToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatFieldMetadata,
-        viewFieldIds: [
-          ...flatFieldMetadata.viewFieldIds,
-          flatViewFieldToValidate.id,
-        ],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    const flatView = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewFieldToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatView,
-        viewFieldIds: [...flatView.viewFieldIds, flatViewFieldToValidate.id],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
     return {
       status: 'success',
       action: {
         type: 'create_view_field',
-        viewField: flatViewFieldToValidate,
+        viewField: args.flatEntityToValidate,
       },
     };
   }
@@ -105,47 +64,7 @@ export class WorkspaceMigrationV2ViewFieldActionsBuilderService extends Workspac
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewFieldToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewFieldToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    if (isDefined(flatFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatFieldMetadata,
-          viewFieldIds: flatFieldMetadata.viewFieldIds.filter(
-            (id) => id !== flatViewFieldToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
-
-    const flatView = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewFieldToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    if (isDefined(flatView)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatView,
-          viewFieldIds: flatView.viewFieldIds.filter(
-            (id) => id !== flatViewFieldToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-      });
-    }
+    const { flatEntityToValidate: flatViewFieldToValidate } = args;
 
     return {
       status: 'success',

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-filter/workspace-migration-v2-view-filter-actions-builder.service.ts

@@ -1,11 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
 
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { UpdateViewFilterAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-filter/types/workspace-migration-view-filter-action-v2.type';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
@@ -41,42 +37,7 @@ export class WorkspaceMigrationV2ViewFilterActionsBuilderService extends Workspa
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewFilterToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatView = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewFilterToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatView,
-        viewFilterIds: [...flatView.viewFilterIds, flatViewFilterToValidate.id],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    const flatFieldMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewFilterToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatFieldMetadata,
-        viewFilterIds: [
-          ...flatFieldMetadata.viewFilterIds,
-          flatViewFilterToValidate.id,
-        ],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
+    const { flatEntityToValidate: flatViewFilterToValidate } = args;
 
     return {
       status: 'success',
@@ -105,28 +66,7 @@ export class WorkspaceMigrationV2ViewFilterActionsBuilderService extends Workspa
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewFilterToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatView = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewFilterToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    if (isDefined(flatView)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatView,
-          viewFilterIds: flatView.viewFilterIds.filter(
-            (id) => id !== flatViewFilterToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-      });
-    }
+    const { flatEntityToValidate: flatViewFilterToValidate } = args;
 
     return {
       status: 'success',

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-group/workspace-migration-v2-view-group-actions-builder.service.ts

@@ -1,11 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
 
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { UpdateViewGroupAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view-group/types/workspace-migration-view-group-action-v2.type';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
@@ -41,42 +37,7 @@ export class WorkspaceMigrationV2ViewGroupActionsBuilderService extends Workspac
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewGroupToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatView = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewGroupToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatView,
-        viewGroupIds: [...flatView.viewGroupIds, flatViewGroupToValidate.id],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    const flatFieldMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewGroupToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatFieldMetadata,
-        viewGroupIds: [
-          ...flatFieldMetadata.viewGroupIds,
-          flatViewGroupToValidate.id,
-        ],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
+    const { flatEntityToValidate: flatViewGroupToValidate } = args;
 
     return {
       status: 'success',
@@ -105,47 +66,7 @@ export class WorkspaceMigrationV2ViewGroupActionsBuilderService extends Workspac
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewGroupToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatView = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewGroupToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-    });
-
-    if (isDefined(flatView)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatView,
-          viewGroupIds: flatView.viewGroupIds.filter(
-            (id) => id !== flatViewGroupToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
-      });
-    }
-
-    const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewGroupToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-    });
-
-    if (isDefined(flatFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatFieldMetadata,
-          viewGroupIds: flatFieldMetadata.viewGroupIds.filter(
-            (id) => id !== flatViewGroupToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
+    const { flatEntityToValidate: flatViewGroupToValidate } = args;
 
     return {
       status: 'success',

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view/workspace-migration-v2-view-actions-builder.service.ts

@@ -1,11 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
 
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/replace-flat-entity-in-flat-entity-maps-through-mutation-or-throw.util';
 import { UpdateViewAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/view/types/workspace-migration-view-action-v2.type';
 import { WorkspaceEntityMigrationBuilderV2Service } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service';
 import { FlatEntityUpdateValidationArgs } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-update-validation-args.type';
@@ -38,74 +34,7 @@ export class WorkspaceMigrationV2ViewActionsBuilderService extends WorkspaceEnti
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-      flatEntity: {
-        ...flatObjectMetadata,
-        viewIds: [...flatObjectMetadata.viewIds, flatViewToValidate.id],
-      },
-      flatEntityMapsToMutate:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    const kanbanFieldMetadata = isDefined(
-      flatViewToValidate.kanbanAggregateOperationFieldMetadataId,
-    )
-      ? findFlatEntityByIdInFlatEntityMapsOrThrow({
-          flatEntityId:
-            flatViewToValidate.kanbanAggregateOperationFieldMetadataId,
-          flatEntityMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-        })
-      : undefined;
-
-    if (isDefined(kanbanFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...kanbanFieldMetadata,
-          kanbanAggregateOperationViewIds: [
-            ...kanbanFieldMetadata.kanbanAggregateOperationViewIds,
-            flatViewToValidate.id,
-          ],
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
-
-    const calendarFieldMetadata = isDefined(
-      flatViewToValidate.calendarFieldMetadataId,
-    )
-      ? findFlatEntityByIdInFlatEntityMapsOrThrow({
-          flatEntityId: flatViewToValidate.calendarFieldMetadataId,
-          flatEntityMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-        })
-      : undefined;
-
-    if (isDefined(calendarFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...calendarFieldMetadata,
-          calendarViewIds: [
-            ...calendarFieldMetadata.calendarViewIds,
-            flatViewToValidate.id,
-          ],
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
+    const { flatEntityToValidate: flatViewToValidate } = args;
 
     return {
       status: 'success',
@@ -131,77 +60,7 @@ export class WorkspaceMigrationV2ViewActionsBuilderService extends WorkspaceEnti
       };
     }
 
-    const {
-      flatEntityToValidate: flatViewToValidate,
-      mutableDependencyOptimisticFlatEntityMaps,
-    } = args;
-
-    const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityId: flatViewToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-    });
-
-    if (isDefined(flatObjectMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...flatObjectMetadata,
-          viewIds: flatObjectMetadata.viewIds.filter(
-            (id) => id !== flatViewToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
-      });
-    }
-
-    const kanbanFieldMetadata = isDefined(
-      flatViewToValidate.kanbanAggregateOperationFieldMetadataId,
-    )
-      ? findFlatEntityByIdInFlatEntityMaps({
-          flatEntityId:
-            flatViewToValidate.kanbanAggregateOperationFieldMetadataId,
-          flatEntityMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-        })
-      : undefined;
-
-    if (isDefined(kanbanFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...kanbanFieldMetadata,
-          kanbanAggregateOperationViewIds:
-            kanbanFieldMetadata.kanbanAggregateOperationViewIds.filter(
-              (id) => id !== flatViewToValidate.id,
-            ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
-
-    const calendarFieldMetadata = isDefined(
-      flatViewToValidate.calendarFieldMetadataId,
-    )
-      ? findFlatEntityByIdInFlatEntityMaps({
-          flatEntityId: flatViewToValidate.calendarFieldMetadataId,
-          flatEntityMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-        })
-      : undefined;
-
-    if (isDefined(calendarFieldMetadata)) {
-      replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
-        flatEntity: {
-          ...calendarFieldMetadata,
-          calendarViewIds: calendarFieldMetadata.calendarViewIds.filter(
-            (id) => id !== flatViewToValidate.id,
-          ),
-        },
-        flatEntityMapsToMutate:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
-      });
-    }
+    const { flatEntityToValidate: flatViewToValidate } = args;
 
     return {
       status: 'success',

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/services/workspace-entity-migration-builder-v2.service.ts

@@ -9,10 +9,13 @@ import {
   FlatEntityMapsException,
   FlatEntityMapsExceptionCode,
 } from 'src/engine/metadata-modules/flat-entity/exceptions/flat-entity-maps.exception';
+import { MetadataFlatEntityAndRelatedFlatEntityMapsForValidation } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-and-related-flat-entity-maps-for-validation.type';
 import { MetadataFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-maps.type';
 import { MetadataValidationRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-and-related-entity-maps-through-mutation-or-throw.util';
+import { deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/delete-flat-entity-from-flat-entity-and-related-entity-maps-through-mutation-or-throw.util';
 import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
-import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
+import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
 import { deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration-v2/utils/delete-flat-entity-from-flat-entity-maps-through-mutation-or-throw.util';
 import { flatEntityDeletedCreatedUpdatedMatrixDispatcher } from 'src/engine/workspace-manager/workspace-migration-v2/utils/flat-entity-deleted-created-updated-matrix-dispatcher.util';
 import { getMetadataEmptyWorkspaceMigrationActionRecord } from 'src/engine/workspace-manager/workspace-migration-v2/utils/get-metadata-empty-workspace-migration-action-record.util';
@@ -53,10 +56,6 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
     to: toFlatEntityMaps,
     workspaceId,
   }: ValidateAndBuildArgs<T>): Promise<ValidateAndBuildReturnType<T>> {
-    const mutableDependencyOptimisticFlatEntityMaps = structuredClone(
-      inputDependencyOptimisticFlatEntityMaps,
-    );
-
     this.logger.time(`EntityBuilder ${this.metadataName}`, 'validateAndBuild');
     this.logger.time(
       `EntityBuilder ${this.metadataName}`,
@@ -87,7 +86,12 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
     );
     this.logger.time(`EntityBuilder ${this.metadataName}`, 'entity processing');
 
-    const optimisticFlatEntityMaps = structuredClone(fromFlatEntityMaps);
+    const flatEntityMapsKey = getMetadataFlatEntityMapsKey(this.metadataName);
+    const optimisticFlatEntityMapsAndRelatedFlatEntityMaps = {
+      [flatEntityMapsKey]: structuredClone(fromFlatEntityMaps),
+      ...structuredClone(inputDependencyOptimisticFlatEntityMaps),
+    } as MetadataFlatEntityAndRelatedFlatEntityMapsForValidation<T>;
+
     const actionsResult = getMetadataEmptyWorkspaceMigrationActionRecord(
       this.metadataName,
     );
@@ -118,10 +122,9 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
       });
 
       const validationResult = await this.validateFlatEntityCreation({
-        mutableDependencyOptimisticFlatEntityMaps,
         flatEntityToValidate: flatEntityToCreate,
-        optimisticFlatEntityMaps,
         workspaceId,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
         remainingFlatEntityMapsToValidate: remainingFlatEntityMapsToCreate,
         buildOptions,
       });
@@ -131,9 +134,11 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
         continue;
       }
 
-      addFlatEntityToFlatEntityMapsThroughMutationOrThrow({
+      addFlatEntityToFlatEntityAndRelatedEntityMapsThroughMutationOrThrow({
         flatEntity: flatEntityToCreate,
-        flatEntityMapsToMutate: optimisticFlatEntityMaps,
+        flatEntityAndRelatedMapsToMutate:
+          optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        metadataName: this.metadataName,
       });
 
       actionsResult.created.push(
@@ -176,12 +181,11 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
       });
 
       const validationResult = await this.validateFlatEntityDeletion({
-        mutableDependencyOptimisticFlatEntityMaps,
         flatEntityToValidate: flatEntityToDelete,
-        optimisticFlatEntityMaps: optimisticFlatEntityMaps,
         workspaceId,
         remainingFlatEntityMapsToValidate: remainingFlatEntityMapsToDelete,
         buildOptions,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
       });
 
       if (validationResult.status === 'fail') {
@@ -189,9 +193,11 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
         continue;
       }
 
-      deleteFlatEntityFromFlatEntityMapsThroughMutationOrThrow({
-        entityToDeleteId: flatEntityToDelete.id,
-        flatEntityMapsToMutate: optimisticFlatEntityMaps,
+      deleteFlatEntityFromFlatEntityAndRelatedEntityMapsThroughMutationOrThrow({
+        flatEntity: flatEntityToDelete,
+        flatEntityAndRelatedMapsToMutate:
+          optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
+        metadataName: this.metadataName,
       });
 
       actionsResult.deleted.push(
@@ -221,8 +227,7 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
       const validationResult = await this.validateFlatEntityUpdate({
         flatEntityUpdates: flatEntityToUpdate.updates,
         flatEntityId: flatEntityToUpdateId,
-        mutableDependencyOptimisticFlatEntityMaps,
-        optimisticFlatEntityMaps: optimisticFlatEntityMaps,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
         workspaceId,
         buildOptions,
       });
@@ -234,7 +239,9 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
 
       const existingFlatEntity = findFlatEntityByIdInFlatEntityMaps({
         flatEntityId: flatEntityToUpdateId,
-        flatEntityMaps: optimisticFlatEntityMaps,
+        flatEntityMaps: optimisticFlatEntityMapsAndRelatedFlatEntityMaps[
+          flatEntityMapsKey
+        ] as MetadataFlatEntityMaps<T>,
       });
 
       if (!isDefined(existingFlatEntity)) {
@@ -253,7 +260,8 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
 
       replaceFlatEntityInFlatEntityMapsThroughMutationOrThrow({
         flatEntity: updatedFlatEntity,
-        flatEntityMapsToMutate: optimisticFlatEntityMaps,
+        flatEntityMapsToMutate:
+          optimisticFlatEntityMapsAndRelatedFlatEntityMaps[flatEntityMapsKey],
       });
 
       actionsResult.updated.push(
@@ -276,9 +284,7 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
       return {
         status: 'fail',
         errors: allValidationResult,
-        optimisticFlatEntityMaps,
-        dependencyOptimisticFlatEntityMaps:
-          mutableDependencyOptimisticFlatEntityMaps,
+        optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
       };
     }
 
@@ -290,9 +296,7 @@ export abstract class WorkspaceEntityMigrationBuilderV2Service<
     return {
       status: 'success',
       actions: actionsResult,
-      optimisticFlatEntityMaps,
-      dependencyOptimisticFlatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps,
+      optimisticFlatEntityMapsAndRelatedFlatEntityMaps,
     };
   }
 

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/failed-flat-entity-validate-and-build.type.ts

@@ -1,13 +1,11 @@
 import { type AllMetadataName } from 'twenty-shared/metadata';
 
-import { type MetadataFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-maps.type';
 import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
-import { type MetadataValidationRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
 import { type FailedFlatEntityValidation } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/builders/types/failed-flat-entity-validation.type';
 
 export type FailedFlatEntityValidateAndBuild<T extends AllMetadataName> = {
   status: 'fail';
   errors: FailedFlatEntityValidation<MetadataFlatEntity<T>>[];
-  optimisticFlatEntityMaps: MetadataFlatEntityMaps<T>;
-  dependencyOptimisticFlatEntityMaps: MetadataValidationRelatedFlatEntityMaps<T>;
+  optimisticFlatEntityMapsAndRelatedFlatEntityMaps: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
 };

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/flat-entity-validation-args.type.ts

@@ -1,14 +1,13 @@
 import { type AllMetadataName } from 'twenty-shared/metadata';
 
+import { type MetadataFlatEntityAndRelatedFlatEntityMapsForValidation } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-and-related-flat-entity-maps-for-validation.type';
 import { type MetadataFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-maps.type';
 import { type MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
-import { type MetadataValidationRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
 import { type WorkspaceMigrationBuilderOptions } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/workspace-migration-builder-options.type';
 
 export type FlatEntityValidationArgs<T extends AllMetadataName> = {
   flatEntityToValidate: MetadataFlatEntity<T>;
-  optimisticFlatEntityMaps: MetadataFlatEntityMaps<T>;
-  mutableDependencyOptimisticFlatEntityMaps: MetadataValidationRelatedFlatEntityMaps<T>;
+  optimisticFlatEntityMapsAndRelatedFlatEntityMaps: MetadataFlatEntityAndRelatedFlatEntityMapsForValidation<T>;
   workspaceId: string;
   remainingFlatEntityMapsToValidate: MetadataFlatEntityMaps<T>;
   buildOptions: WorkspaceMigrationBuilderOptions;

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/successful-flat-entity-validate-and-build.type.ts

@@ -1,12 +1,10 @@
 import { type AllMetadataName } from 'twenty-shared/metadata';
 
-import { type MetadataFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity-maps.type';
-import { type MetadataValidationRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
+import { type MetadataFlatEntityAndRelatedFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-types.type';
 import { type MetadataWorkspaceMigrationActionsRecord } from 'src/engine/metadata-modules/flat-entity/types/metadata-workspace-migration-action.type';
 
 export type SuccessfulFlatEntityValidateAndBuild<T extends AllMetadataName> = {
   status: 'success';
   actions: MetadataWorkspaceMigrationActionsRecord<T>;
-  optimisticFlatEntityMaps: MetadataFlatEntityMaps<T>;
-  dependencyOptimisticFlatEntityMaps: MetadataValidationRelatedFlatEntityMaps<T>;
+  optimisticFlatEntityMapsAndRelatedFlatEntityMaps: MetadataFlatEntityAndRelatedFlatEntityMaps<T>;
 };

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-cron-trigger-validator.service.ts

@@ -18,8 +18,10 @@ export class FlatCronTriggerValidatorService {
   public validateFlatCronTriggerUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatCronTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatCronTriggerMaps: optimisticFlatCronTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.cronTrigger
   >): FailedFlatEntityValidation<FlatCronTrigger> {
@@ -52,7 +54,7 @@ export class FlatCronTriggerValidatorService {
     };
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps.byId[
+      flatServerlessFunctionMaps.byId[
         updatedFlatCronTrigger.serverlessFunctionId
       ];
 
@@ -69,7 +71,9 @@ export class FlatCronTriggerValidatorService {
 
   public validateFlatCronTriggerDeletion({
     flatEntityToValidate: { id: cronTriggerIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatCronTriggerMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatCronTriggerMaps: optimisticFlatCronTriggerMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.cronTrigger
   >): FailedFlatEntityValidation<FlatCronTrigger> {
@@ -97,8 +101,10 @@ export class FlatCronTriggerValidatorService {
 
   public async validateFlatCronTriggerCreation({
     flatEntityToValidate: flatCronTriggerToValidate,
-    optimisticFlatEntityMaps: optimisticFlatCronTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatCronTriggerMaps: optimisticFlatCronTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.cronTrigger>): Promise<
     FailedFlatEntityValidation<FlatCronTrigger>
   > {
@@ -123,8 +129,9 @@ export class FlatCronTriggerValidatorService {
     }
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps
-        ?.byId?.[flatCronTriggerToValidate.serverlessFunctionId];
+      flatServerlessFunctionMaps.byId[
+        flatCronTriggerToValidate.serverlessFunctionId
+      ];
 
     if (!isDefined(serverlessFunction)) {
       validationResult.errors.push({

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-database-event-trigger-validator.service.ts

@@ -19,8 +19,10 @@ export class FlatDatabaseEventTriggerValidatorService {
   public validateFlatDatabaseEventTriggerUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatDatabaseEventTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatDatabaseEventTriggerMaps: optimisticFlatDatabaseEventTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.databaseEventTrigger
   >): FailedFlatEntityValidation<FlatDatabaseEventTrigger> {
@@ -54,8 +56,9 @@ export class FlatDatabaseEventTriggerValidatorService {
     };
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps
-        ?.byId?.[updatedFlatDatabaseEventTrigger.serverlessFunctionId];
+      flatServerlessFunctionMaps.byId[
+        updatedFlatDatabaseEventTrigger.serverlessFunctionId
+      ];
 
     if (!isDefined(serverlessFunction)) {
       validationResult.errors.push({
@@ -70,7 +73,9 @@ export class FlatDatabaseEventTriggerValidatorService {
 
   public validateFlatDatabaseEventTriggerDeletion({
     flatEntityToValidate: { id: databaseEventTriggerIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatDatabaseEventTriggerMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatDatabaseEventTriggerMaps: optimisticFlatDatabaseEventTriggerMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.databaseEventTrigger
   >): FailedFlatEntityValidation<FlatDatabaseEventTrigger> {
@@ -101,8 +106,10 @@ export class FlatDatabaseEventTriggerValidatorService {
 
   public async validateFlatDatabaseEventTriggerCreation({
     flatEntityToValidate: flatDatabaseEventTriggerToValidate,
-    optimisticFlatEntityMaps: optimisticFlatDatabaseEventTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatDatabaseEventTriggerMaps: optimisticFlatDatabaseEventTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.databaseEventTrigger
   >): Promise<FailedFlatEntityValidation<FlatDatabaseEventTrigger>> {
@@ -130,8 +137,9 @@ export class FlatDatabaseEventTriggerValidatorService {
     }
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps
-        ?.byId?.[flatDatabaseEventTriggerToValidate.serverlessFunctionId];
+      flatServerlessFunctionMaps?.byId?.[
+        flatDatabaseEventTriggerToValidate.serverlessFunctionId
+      ];
 
     if (!isDefined(serverlessFunction)) {
       validationResult.errors.push({

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-field-metadata-validator.service.ts

@@ -30,8 +30,10 @@ export class FlatFieldMetadataValidatorService {
   async validateFlatFieldMetadataUpdate({
     flatEntityId,
     flatEntityUpdates: updates,
-    optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatFieldMetadataMaps: optimisticFlatFieldMetadataMaps,
+      flatObjectMetadataMaps,
+    },
     workspaceId,
     buildOptions,
   }: FlatEntityUpdateValidationArgs<
@@ -70,9 +72,7 @@ export class FlatFieldMetadataValidatorService {
     };
 
     const flatObjectMetadata =
-      mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps.byId[
-        flatFieldMetadataToValidate.objectMetadataId
-      ];
+      flatObjectMetadataMaps.byId[flatFieldMetadataToValidate.objectMetadataId];
 
     if (!isDefined(flatObjectMetadata)) {
       validationResult.errors.push({
@@ -152,11 +152,10 @@ export class FlatFieldMetadataValidatorService {
     const fieldMetadataTypeValidationErrors =
       await this.flatFieldMetadataTypeValidatorService.validateFlatFieldMetadataTypeSpecificities(
         {
-          mutableDependencyOptimisticFlatEntityMaps: {
-            flatObjectMetadataMaps:
-              mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
+          optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+            flatFieldMetadataMaps: optimisticFlatFieldMetadataMaps,
+            flatObjectMetadataMaps,
           },
-          optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
           flatEntityToValidate: flatFieldMetadataToValidate,
           buildOptions,
           remainingFlatEntityMapsToValidate: createEmptyFlatEntityMaps(),
@@ -173,8 +172,10 @@ export class FlatFieldMetadataValidatorService {
 
   validateFlatFieldMetadataDeletion({
     flatEntityToValidate: { id: flatFieldMetadataToDeleteId },
-    optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatFieldMetadataMaps: optimisticFlatFieldMetadataMaps,
+      flatObjectMetadataMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.fieldMetadata
   >): FailedFlatEntityValidation<FlatFieldMetadata> {
@@ -205,9 +206,7 @@ export class FlatFieldMetadataValidatorService {
     };
 
     const relatedFlatObjectMetadata =
-      mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps.byId[
-        flatFieldMetadataToDelete.objectMetadataId
-      ];
+      flatObjectMetadataMaps.byId[flatFieldMetadataToDelete.objectMetadataId];
 
     if (
       isDefined(relatedFlatObjectMetadata) &&
@@ -225,14 +224,12 @@ export class FlatFieldMetadataValidatorService {
     const relationTargetObjectMetadataHasBeenDeleted =
       isMorphOrRelationFlatFieldMetadata(flatFieldMetadataToDelete) &&
       !isDefined(
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps.byId[
+        flatObjectMetadataMaps.byId[
           flatFieldMetadataToDelete.relationTargetObjectMetadataId
         ],
       );
     const parentObjectMetadataHasBeenDeleted = !isDefined(
-      mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps.byId[
-        flatFieldMetadataToDelete.objectMetadataId
-      ],
+      flatObjectMetadataMaps.byId[flatFieldMetadataToDelete.objectMetadataId],
     );
 
     if (
@@ -264,8 +261,10 @@ export class FlatFieldMetadataValidatorService {
 
   async validateFlatFieldMetadataCreation({
     flatEntityToValidate: flatFieldMetadataToValidate,
-    optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatFieldMetadataMaps: optimisticFlatFieldMetadataMaps,
+      flatObjectMetadataMaps,
+    },
     workspaceId,
     buildOptions,
     remainingFlatEntityMapsToValidate,
@@ -283,9 +282,7 @@ export class FlatFieldMetadataValidatorService {
     };
 
     const parentFlatObjectMetadata =
-      mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps.byId[
-        flatFieldMetadataToValidate.objectMetadataId
-      ];
+      flatObjectMetadataMaps.byId[flatFieldMetadataToValidate.objectMetadataId];
 
     if (!isDefined(parentFlatObjectMetadata)) {
       validationResult.errors.push({
@@ -343,10 +340,12 @@ export class FlatFieldMetadataValidatorService {
     validationResult.errors.push(
       ...(await this.flatFieldMetadataTypeValidatorService.validateFlatFieldMetadataTypeSpecificities(
         {
-          mutableDependencyOptimisticFlatEntityMaps,
+          optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+            flatFieldMetadataMaps: optimisticFlatFieldMetadataMaps,
+            flatObjectMetadataMaps,
+          },
           flatEntityToValidate: flatFieldMetadataToValidate,
           buildOptions,
-          optimisticFlatEntityMaps: optimisticFlatFieldMetadataMaps,
           workspaceId,
           remainingFlatEntityMapsToValidate,
         },

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-index-metadata-validator.service.ts

@@ -18,7 +18,9 @@ import { FlatEntityValidationArgs } from 'src/engine/workspace-manager/workspace
 @Injectable()
 export class FlatIndexValidatorService {
   public validateFlatIndexDeletion({
-    optimisticFlatEntityMaps: optimisticFlatIndexMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatIndexMaps: optimisticFlatIndexMaps,
+    },
     flatEntityToValidate: { id: indexIdToDelete },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.index
@@ -48,8 +50,11 @@ export class FlatIndexValidatorService {
 
   public validateFlatIndexCreation({
     flatEntityToValidate: flatIndexToValidate,
-    optimisticFlatEntityMaps: optimisticFlatIndexMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatIndexMaps: optimisticFlatIndexMaps,
+      flatObjectMetadataMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.index
   >): FailedFlatEntityValidation<FlatIndexMetadata> {
@@ -77,8 +82,7 @@ export class FlatIndexValidatorService {
 
     const relatedObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatIndexToValidate.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
+      flatEntityMaps: flatObjectMetadataMaps,
     });
 
     if (!isDefined(relatedObjectMetadata)) {
@@ -117,8 +121,7 @@ export class FlatIndexValidatorService {
       flatIndexToValidate.flatIndexFieldMetadatas.forEach((flatIndexField) => {
         const relatedFlatField = findFlatEntityByIdInFlatEntityMaps({
           flatEntityId: flatIndexField.fieldMetadataId,
-          flatEntityMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+          flatEntityMaps: flatFieldMetadataMaps,
         });
 
         if (!isDefined(relatedFlatField)) {

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-object-metadata-validator.service.ts

@@ -19,8 +19,10 @@ export class FlatObjectMetadataValidatorService {
   public validateFlatObjectMetadataUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatObjectMetadataMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatObjectMetadataMaps: optimisticFlatObjectMetadataMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.objectMetadata
   >): FailedFlatEntityValidation<FlatObjectMetadata> {
@@ -82,8 +84,7 @@ export class FlatObjectMetadataValidatorService {
       validationResult.errors.push(
         ...validateFlatObjectMetadataIdentifiers({
           flatObjectMetadata: updatedFlatObjectMetadata,
-          flatFieldMetadataMaps:
-            mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+          flatFieldMetadataMaps,
         }),
       );
     }
@@ -93,7 +94,9 @@ export class FlatObjectMetadataValidatorService {
 
   public validateFlatObjectMetadataDeletion({
     flatEntityToValidate: { id: objectMetadataToDeleteId },
-    optimisticFlatEntityMaps: optimisticFlatObjectMetadataMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatObjectMetadataMaps: optimisticFlatObjectMetadataMaps,
+    },
     buildOptions,
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.objectMetadata
@@ -155,8 +158,10 @@ export class FlatObjectMetadataValidatorService {
 
   public async validateFlatObjectMetadataCreation({
     flatEntityToValidate: flatObjectMetadataToValidate,
-    optimisticFlatEntityMaps: optimisticFlatObjectMetadataMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatObjectMetadataMaps: optimisticFlatObjectMetadataMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.objectMetadata
   >): Promise<FailedFlatEntityValidation<FlatObjectMetadata>> {
@@ -194,8 +199,7 @@ export class FlatObjectMetadataValidatorService {
     objectValidationResult.errors.push(
       ...validateFlatObjectMetadataIdentifiers({
         flatObjectMetadata: flatObjectMetadataToValidate,
-        flatFieldMetadataMaps:
-          mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+        flatFieldMetadataMaps,
       }),
     );
     objectValidationResult.errors.push(

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-route-trigger-validator.service.ts

@@ -18,8 +18,10 @@ export class FlatRouteTriggerValidatorService {
   public validateFlatRouteTriggerUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatRouteTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatRouteTriggerMaps: optimisticFlatRouteTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.routeTrigger
   >): FailedFlatEntityValidation<FlatRouteTrigger> {
@@ -52,7 +54,7 @@ export class FlatRouteTriggerValidatorService {
     };
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps.byId[
+      flatServerlessFunctionMaps.byId[
         updatedFlatRouteTrigger.serverlessFunctionId
       ];
 
@@ -69,7 +71,9 @@ export class FlatRouteTriggerValidatorService {
 
   public validateFlatRouteTriggerDeletion({
     flatEntityToValidate: { id: routeTriggerIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatRouteTriggerMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatRouteTriggerMaps: optimisticFlatRouteTriggerMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.routeTrigger
   >): FailedFlatEntityValidation<FlatRouteTrigger> {
@@ -97,8 +101,10 @@ export class FlatRouteTriggerValidatorService {
 
   public async validateFlatRouteTriggerCreation({
     flatEntityToValidate: flatRouteTriggerToValidate,
-    optimisticFlatEntityMaps: optimisticFlatRouteTriggerMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatRouteTriggerMaps: optimisticFlatRouteTriggerMaps,
+      flatServerlessFunctionMaps,
+    },
   }: FlatEntityValidationArgs<typeof ALL_METADATA_NAME.routeTrigger>): Promise<
     FailedFlatEntityValidation<FlatRouteTrigger>
   > {
@@ -140,7 +146,7 @@ export class FlatRouteTriggerValidatorService {
     }
 
     const serverlessFunction =
-      mutableDependencyOptimisticFlatEntityMaps.flatServerlessFunctionMaps.byId[
+      flatServerlessFunctionMaps.byId[
         flatRouteTriggerToValidate.serverlessFunctionId
       ];
 

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-serverless-function-validator.service.ts

@@ -1,8 +1,8 @@
 import { Injectable } from '@nestjs/common';
 
 import { msg, t } from '@lingui/core/macro';
-import { isDefined } from 'twenty-shared/utils';
 import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
 
 import { ServerlessFunctionExceptionCode } from 'src/engine/metadata-modules/serverless-function/serverless-function.exception';
 import { FlatServerlessFunction } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
@@ -16,7 +16,9 @@ export class FlatServerlessFunctionValidatorService {
 
   public validateFlatServerlessFunctionUpdate({
     flatEntityId,
-    optimisticFlatEntityMaps: optimisticFlatServerlessFunctionMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.serverlessFunction
   >): FailedFlatEntityValidation<FlatServerlessFunction> {
@@ -45,7 +47,9 @@ export class FlatServerlessFunctionValidatorService {
 
   public validateFlatServerlessFunctionDeletion({
     flatEntityToValidate: { id: serverlessFunctionIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatServerlessFunctionMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.serverlessFunction
   >): FailedFlatEntityValidation<FlatServerlessFunction> {
@@ -74,7 +78,9 @@ export class FlatServerlessFunctionValidatorService {
 
   public async validateFlatServerlessFunctionCreation({
     flatEntityToValidate: flatServerlessFunctionToValidate,
-    optimisticFlatEntityMaps: optimisticFlatServerlessFunctionMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatServerlessFunctionMaps: optimisticFlatServerlessFunctionMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.serverlessFunction
   >): Promise<FailedFlatEntityValidation<FlatServerlessFunction>> {

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-view-field-validator.service.ts

@@ -22,8 +22,11 @@ export class FlatViewFieldValidatorService {
   public validateFlatViewFieldUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatViewFieldMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFieldMaps: optimisticFlatViewFieldMaps,
+      flatViewMaps,
+      flatObjectMetadataMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.viewField
   >): FailedFlatEntityValidation<FlatViewField> {
@@ -63,7 +66,7 @@ export class FlatViewFieldValidatorService {
 
     const flatView = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: updatedFlatViewField.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
+      flatEntityMaps: flatViewMaps,
     });
 
     if (!isDefined(flatView)) {
@@ -78,8 +81,7 @@ export class FlatViewFieldValidatorService {
 
     const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatView.objectMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
+      flatEntityMaps: flatObjectMetadataMaps,
     });
 
     if (!isDefined(flatObjectMetadata)) {
@@ -118,8 +120,8 @@ export class FlatViewFieldValidatorService {
 
   public validateFlatViewFieldDeletion({
     flatEntityToValidate: { id: viewFieldIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatViewFieldMaps,
-    mutableDependencyOptimisticFlatEntityMaps: {
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFieldMaps: optimisticFlatViewFieldMaps,
       flatFieldMetadataMaps,
       flatObjectMetadataMaps,
     },
@@ -181,8 +183,12 @@ export class FlatViewFieldValidatorService {
 
   public validateFlatViewFieldCreation({
     flatEntityToValidate: flatViewFieldToValidate,
-    optimisticFlatEntityMaps: optimisticFlatViewFieldMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFieldMaps: optimisticFlatViewFieldMaps,
+      flatFieldMetadataMaps,
+      flatViewMaps,
+      flatObjectMetadataMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.viewField
   >): FailedFlatEntityValidation<FlatViewField> {
@@ -211,8 +217,7 @@ export class FlatViewFieldValidatorService {
 
     const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatViewFieldToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+      flatEntityMaps: flatFieldMetadataMaps,
     });
 
     if (!isDefined(flatFieldMetadata)) {
@@ -223,10 +228,7 @@ export class FlatViewFieldValidatorService {
       });
     }
 
-    const flatView =
-      mutableDependencyOptimisticFlatEntityMaps.flatViewMaps.byId[
-        flatViewFieldToValidate.viewId
-      ];
+    const flatView = flatViewMaps.byId[flatViewFieldToValidate.viewId];
 
     if (!isDefined(flatView)) {
       validationResult.errors.push({
@@ -258,8 +260,7 @@ export class FlatViewFieldValidatorService {
     }
 
     const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatObjectMetadataMaps,
+      flatEntityMaps: flatObjectMetadataMaps,
       flatEntityId: flatView.objectMetadataId,
     });
 

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-view-filter-validator.service.ts

@@ -18,8 +18,11 @@ export class FlatViewFilterValidatorService {
 
   validateFlatViewFilterCreation({
     flatEntityToValidate: flatViewFilterToValidate,
-    optimisticFlatEntityMaps: optimisticFlatViewFilterMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFilterMaps: optimisticFlatViewFilterMaps,
+      flatViewMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.viewFilter
   >): FailedFlatEntityValidation<FlatViewFilter> {
@@ -46,7 +49,7 @@ export class FlatViewFilterValidatorService {
 
     const referencedView = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatViewFilterToValidate.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
+      flatEntityMaps: flatViewMaps,
     });
 
     if (!isDefined(referencedView)) {
@@ -59,8 +62,7 @@ export class FlatViewFilterValidatorService {
 
     const referencedFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatViewFilterToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+      flatEntityMaps: flatFieldMetadataMaps,
     });
 
     if (!isDefined(referencedFieldMetadata)) {
@@ -76,7 +78,9 @@ export class FlatViewFilterValidatorService {
 
   validateFlatViewFilterDeletion({
     flatEntityToValidate: flatViewFilterToValidate,
-    optimisticFlatEntityMaps: optimisticFlatViewFilterMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFilterMaps: optimisticFlatViewFilterMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.viewFilter
   >): FailedFlatEntityValidation<FlatViewFilter> {
@@ -109,8 +113,10 @@ export class FlatViewFilterValidatorService {
   validateFlatViewFilterUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatViewFilterMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewFilterMaps: optimisticFlatViewFilterMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.viewFilter
   >): FailedFlatEntityValidation<FlatViewFilter> {
@@ -143,8 +149,7 @@ export class FlatViewFilterValidatorService {
 
     const referencedFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: updatedFlatViewFilter.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+      flatEntityMaps: flatFieldMetadataMaps,
     });
 
     if (!isDefined(referencedFieldMetadata)) {

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-view-group-validator.service.ts

@@ -17,8 +17,11 @@ export class FlatViewGroupValidatorService {
   public validateFlatViewGroupUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatViewGroupMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewGroupMaps: optimisticFlatViewGroupMaps,
+      flatViewMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.viewGroup
   >): FailedFlatEntityValidation<FlatViewGroup> {
@@ -58,7 +61,7 @@ export class FlatViewGroupValidatorService {
 
     const flatView = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: updatedFlatViewGroup.viewId,
-      flatEntityMaps: mutableDependencyOptimisticFlatEntityMaps.flatViewMaps,
+      flatEntityMaps: flatViewMaps,
     });
 
     if (!isDefined(flatView)) {
@@ -71,8 +74,7 @@ export class FlatViewGroupValidatorService {
 
     const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: updatedFlatViewGroup.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+      flatEntityMaps: flatFieldMetadataMaps,
     });
 
     if (!isDefined(flatFieldMetadata)) {
@@ -88,7 +90,9 @@ export class FlatViewGroupValidatorService {
 
   public validateFlatViewGroupDeletion({
     flatEntityToValidate: { id: viewGroupIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatViewGroupMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewGroupMaps: optimisticFlatViewGroupMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.viewGroup
   >): FailedFlatEntityValidation<FlatViewGroup> {
@@ -116,8 +120,11 @@ export class FlatViewGroupValidatorService {
 
   public validateFlatViewGroupCreation({
     flatEntityToValidate: flatViewGroupToValidate,
-    optimisticFlatEntityMaps: optimisticFlatViewGroupMaps,
-    mutableDependencyOptimisticFlatEntityMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewGroupMaps: optimisticFlatViewGroupMaps,
+      flatFieldMetadataMaps,
+      flatViewMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.viewGroup
   >): FailedFlatEntityValidation<FlatViewGroup> {
@@ -146,8 +153,7 @@ export class FlatViewGroupValidatorService {
 
     const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
       flatEntityId: flatViewGroupToValidate.fieldMetadataId,
-      flatEntityMaps:
-        mutableDependencyOptimisticFlatEntityMaps.flatFieldMetadataMaps,
+      flatEntityMaps: flatFieldMetadataMaps,
     });
 
     if (!isDefined(flatFieldMetadata)) {
@@ -158,10 +164,7 @@ export class FlatViewGroupValidatorService {
       });
     }
 
-    const flatView =
-      mutableDependencyOptimisticFlatEntityMaps.flatViewMaps.byId[
-        flatViewGroupToValidate.viewId
-      ];
+    const flatView = flatViewMaps.byId[flatViewGroupToValidate.viewId];
 
     if (!isDefined(flatView)) {
       validationResult.errors.push({

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/validators/services/flat-view-validator.service.ts

@@ -16,8 +16,10 @@ export class FlatViewValidatorService {
   public validateFlatViewUpdate({
     flatEntityId,
     flatEntityUpdates,
-    optimisticFlatEntityMaps: optimisticFlatViewMaps,
-    mutableDependencyOptimisticFlatEntityMaps: { flatFieldMetadataMaps },
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewMaps: optimisticFlatViewMaps,
+      flatFieldMetadataMaps,
+    },
   }: FlatEntityUpdateValidationArgs<
     typeof ALL_METADATA_NAME.view
   >): FailedFlatEntityValidation<FlatView> {
@@ -67,7 +69,9 @@ export class FlatViewValidatorService {
 
   public validateFlatViewDeletion({
     flatEntityToValidate: { id: viewIdToDelete },
-    optimisticFlatEntityMaps: optimisticFlatViewMaps,
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewMaps: optimisticFlatViewMaps,
+    },
   }: FlatEntityValidationArgs<
     typeof ALL_METADATA_NAME.view
   >): FailedFlatEntityValidation<FlatView> {
@@ -94,8 +98,8 @@ export class FlatViewValidatorService {
 
   public async validateFlatViewCreation({
     flatEntityToValidate: flatViewToValidate,
-    optimisticFlatEntityMaps: optimisticFlatViewMaps,
-    mutableDependencyOptimisticFlatEntityMaps: {
+    optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+      flatViewMaps: optimisticFlatViewMaps,
       flatFieldMetadataMaps,
       flatObjectMetadataMaps,
     },

packages/twenty-server/src/engine/workspace-manager/workspace-migration-v2/workspace-migration-runner-v2/action-handlers/serverless-function/services/update-serverless-function-action-handler.service.ts

@@ -4,8 +4,8 @@ import { isDefined } from 'twenty-shared/utils';
 
 import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-runner-v2/interfaces/workspace-migration-runner-action-handler-service.interface';
 
-import { type Sources } from 'src/engine/core-modules/file-storage/types/source.type';
 import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { type Sources } from 'src/engine/core-modules/file-storage/types/source.type';
 import { ServerlessService } from 'src/engine/core-modules/serverless/serverless.service';
 import { getServerlessFolder } from 'src/engine/core-modules/serverless/utils/serverless-get-folder.utils';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
@@ -68,7 +68,7 @@ export class UpdateServerlessFunctionActionHandlerService extends WorkspaceMigra
     serverlessFunction: FlatServerlessFunction;
   }) {
     this.serverlessService.delete(
-      serverlessFunction as ServerlessFunctionEntity,
+      serverlessFunction as unknown as ServerlessFunctionEntity,
     );
   }