Improve performance on metadata computation (#12785)

In this PR:

## Improve recompute metadata cache performance. We are aiming for
~100ms

Deleting relationMetadata table and FKs pointing on it
Fetching indexMetadata and indexFieldMetadata in a separate query as
typeorm is suboptimizing

## Remove caching lock

As recomputing the metadata cache is lighter, we try to stop preventing
multiple concurrent computations. This also simplifies interfaces

## Introduce self recovery mecanisms to recompute cache automatically if
corrupted

Aka getFreshObjectMetadataMaps

## custom object resolver performance improvement:  1sec to 200ms

Double check queries and indexes used while creating a custom object
Remove the queries to db to use the cached objectMetadataMap

## reduce objectMetadataMaps to 500kb
<img width="222" alt="image"
src="https://github.com/user-attachments/assets/2370dc80-49b6-4b63-8d5e-30c5ebdaa062"
/>

We used to stored 3 fieldMetadataMaps (byId, byName, byJoinColumnName).
While this is great for devXP, this is not great for performances.
Using the same mecanisme as for objectMetadataMap: we only keep byIdMap
and introduce two otherMaps to idByName, idByJoinColumnName to make the
bridge

## Add dataloader on IndexMetadata (aka indexMetadataList in the API)

## Improve field resolver performances too

## Deprecate ClientConfig

packages/twenty-server/src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache-storage.service.ts

@@ -64,28 +64,6 @@ export class WorkspacePermissionsCacheStorageService {
     );
   }
 
-  addRolesPermissionsOngoingCachingLock(workspaceId: string) {
-    return this.cacheStorageService.set<boolean>(
-      `${WorkspaceCacheKeys.MetadataPermissionsRolesPermissionsOngoingCachingLock}:${workspaceId}`,
-      true,
-      1_000 * 60, // 1 minute
-    );
-  }
-
-  removeRolesPermissionsOngoingCachingLock(workspaceId: string) {
-    return this.cacheStorageService.del(
-      `${WorkspaceCacheKeys.MetadataPermissionsRolesPermissionsOngoingCachingLock}:${workspaceId}`,
-    );
-  }
-
-  getRolesPermissionsOngoingCachingLock(
-    workspaceId: string,
-  ): Promise<boolean | undefined> {
-    return this.cacheStorageService.get<boolean>(
-      `${WorkspaceCacheKeys.MetadataPermissionsRolesPermissionsOngoingCachingLock}:${workspaceId}`,
-    );
-  }
-
   async setUserWorkspaceRoleMap(
     workspaceId: string,
     userWorkspaceRoleMap: UserWorkspaceRoleMap,
@@ -128,31 +106,9 @@ export class WorkspacePermissionsCacheStorageService {
     );
   }
 
-  addUserWorkspaceRoleMapOngoingCachingLock(workspaceId: string) {
-    return this.cacheStorageService.set<boolean>(
-      `${WorkspaceCacheKeys.MetadataPermissionsUserWorkspaceRoleMapOngoingCachingLock}:${workspaceId}`,
-      true,
-      1_000 * 60, // 1 minute
-    );
-  }
-
-  removeUserWorkspaceRoleMapOngoingCachingLock(workspaceId: string) {
-    return this.cacheStorageService.del(
-      `${WorkspaceCacheKeys.MetadataPermissionsUserWorkspaceRoleMapOngoingCachingLock}:${workspaceId}`,
-    );
-  }
-
   removeUserWorkspaceRoleMap(workspaceId: string) {
     return this.cacheStorageService.del(
       `${WorkspaceCacheKeys.MetadataPermissionsUserWorkspaceRoleMap}:${workspaceId}`,
     );
   }
-
-  getUserWorkspaceRoleMapOngoingCachingLock(
-    workspaceId: string,
-  ): Promise<boolean | undefined> {
-    return this.cacheStorageService.get<boolean>(
-      `${WorkspaceCacheKeys.MetadataPermissionsUserWorkspaceRoleMapOngoingCachingLock}:${workspaceId}`,
-    );
-  }
 }

packages/twenty-server/src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service.ts

@@ -12,7 +12,6 @@ import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadat
 import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { UserWorkspaceRoleEntity } from 'src/engine/metadata-modules/role/user-workspace-role.entity';
-import { WorkspaceFeatureFlagsMapCacheService } from 'src/engine/metadata-modules/workspace-feature-flags-map-cache/workspace-feature-flags-map-cache.service';
 import { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/workspace-permissions-cache/types/user-workspace-role-map.type';
 import { WorkspacePermissionsCacheStorageService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache-storage.service';
 import { TwentyORMExceptionCode } from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';
@@ -39,118 +38,55 @@ export class WorkspacePermissionsCacheService {
     @InjectRepository(UserWorkspaceRoleEntity, 'core')
     private readonly userWorkspaceRoleRepository: Repository<UserWorkspaceRoleEntity>,
     private readonly workspacePermissionsCacheStorageService: WorkspacePermissionsCacheStorageService,
-    private readonly workspaceFeatureFlagsMapCacheService: WorkspaceFeatureFlagsMapCacheService,
   ) {}
 
   async recomputeRolesPermissionsCache({
     workspaceId,
-    ignoreLock = false,
     roleIds,
   }: {
     workspaceId: string;
-    ignoreLock?: boolean;
     roleIds?: string[];
   }): Promise<void> {
-    const isAlreadyCaching =
-      await this.workspacePermissionsCacheStorageService.getRolesPermissionsOngoingCachingLock(
-        workspaceId,
-      );
+    let currentRolesPermissions: ObjectRecordsPermissionsByRoleId | undefined;
 
-    if (isAlreadyCaching) {
-      if (ignoreLock) {
-        this.logger.warn(
-          `RolesPermissions data is already being cached (workspace ${workspaceId}), ignoring lock`,
-        );
-      } else {
-        this.logger.warn(
-          `RolesPermissions data is already being cached (workspace ${workspaceId}), respecting lock and returning no data`,
-        );
-
-        return;
-      }
-    }
-
-    await this.workspacePermissionsCacheStorageService.addRolesPermissionsOngoingCachingLock(
-      workspaceId,
-    );
-
-    try {
-      let currentRolesPermissions: ObjectRecordsPermissionsByRoleId | undefined;
-
-      if (roleIds) {
-        currentRolesPermissions =
-          await this.workspacePermissionsCacheStorageService.getRolesPermissions(
-            workspaceId,
-          );
-      }
-
-      const recomputedRolesPermissions =
-        await this.getObjectRecordPermissionsForRoles({
+    if (roleIds) {
+      currentRolesPermissions =
+        await this.workspacePermissionsCacheStorageService.getRolesPermissions(
           workspaceId,
-          roleIds,
-        });
-
-      const freshObjectRecordsPermissionsByRoleId = roleIds
-        ? { ...currentRolesPermissions, ...recomputedRolesPermissions }
-        : recomputedRolesPermissions;
-
-      await this.workspacePermissionsCacheStorageService.setRolesPermissions(
-        workspaceId,
-        freshObjectRecordsPermissionsByRoleId,
-      );
-    } finally {
-      await this.workspacePermissionsCacheStorageService.removeRolesPermissionsOngoingCachingLock(
-        workspaceId,
-      );
+        );
     }
+
+    const recomputedRolesPermissions =
+      await this.getObjectRecordPermissionsForRoles({
+        workspaceId,
+        roleIds,
+      });
+
+    const freshObjectRecordsPermissionsByRoleId = roleIds
+      ? { ...currentRolesPermissions, ...recomputedRolesPermissions }
+      : recomputedRolesPermissions;
+
+    await this.workspacePermissionsCacheStorageService.setRolesPermissions(
+      workspaceId,
+      freshObjectRecordsPermissionsByRoleId,
+    );
   }
 
   async recomputeUserWorkspaceRoleMapCache({
     workspaceId,
-    ignoreLock = false,
   }: {
     workspaceId: string;
-    ignoreLock?: boolean;
   }): Promise<void> {
     try {
-      const isAlreadyCaching =
-        await this.workspacePermissionsCacheStorageService.getUserWorkspaceRoleMapOngoingCachingLock(
+      const freshUserWorkspaceRoleMap =
+        await this.getUserWorkspaceRoleMapFromDatabase({
           workspaceId,
-        );
+        });
 
-      if (isAlreadyCaching) {
-        if (ignoreLock) {
-          this.logger.warn(
-            `UserWorkspaceRoleMap data is already being cached (workspace ${workspaceId}), ignoring lock`,
-          );
-        } else {
-          this.logger.warn(
-            `UserWorkspaceRoleMap data is already being cached (workspace ${workspaceId}), respecting lock and returning no data`,
-          );
-
-          return;
-        }
-      }
-
-      await this.workspacePermissionsCacheStorageService.addUserWorkspaceRoleMapOngoingCachingLock(
+      await this.workspacePermissionsCacheStorageService.setUserWorkspaceRoleMap(
         workspaceId,
+        freshUserWorkspaceRoleMap,
       );
-
-      try {
-        const freshUserWorkspaceRoleMap =
-          await this.getUserWorkspaceRoleMapFromDatabase({
-            workspaceId,
-          });
-
-        await this.workspacePermissionsCacheStorageService.setUserWorkspaceRoleMap(
-          workspaceId,
-          freshUserWorkspaceRoleMap,
-        );
-      } finally {
-        await this.workspacePermissionsCacheStorageService.removeUserWorkspaceRoleMapOngoingCachingLock(
-          workspaceId,
-        );
-      }
     } catch (error) {
       // Flush stale userWorkspaceRoleMap
       await this.workspacePermissionsCacheStorageService.removeUserWorkspaceRoleMap(