[permissions] Improve performances using a cache for userWorkspaces roles (#11587)

In this PR we are 

- introducing a cached map `{ userworkspaceId: roleId } `to reduce calls
to get a userWorkspace's role (we were having N+1 around that with
combinedFindMany queries and generally having a lot of avoidable
queries)
- using the roles permissions cache (`{ roleId: { objectNameSingular:
{ canRead: bool, canUpdate: bool, ...} } `) in Permissions V1's
userHasObjectPermission, in order to 1) improve performances to avoid
calls to get roles 2) start using our permissions cache

packages/twenty-server/src/engine/twenty-orm/factories/workspace-datasource.factory.ts

@@ -7,12 +7,12 @@ import { EntitySchema } from 'typeorm';
 import { FeatureFlagMap } from 'src/engine/core-modules/feature-flag/interfaces/feature-flag-map.interface';
 import { NodeEnvironment } from 'src/engine/core-modules/twenty-config/interfaces/node-environment.interface';
 
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { WorkspaceFeatureFlagsMapCacheService } from 'src/engine/metadata-modules/workspace-feature-flags-map-cache/workspace-feature-flags-map-cache.service';
 import { WorkspaceMetadataCacheService } from 'src/engine/metadata-modules/workspace-metadata-cache/services/workspace-metadata-cache.service';
-import { WorkspaceRolesPermissionsCacheService } from 'src/engine/metadata-modules/workspace-roles-permissions-cache/workspace-roles-permissions-cache.service';
+import { WorkspacePermissionsCacheStorageService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache-storage.service';
+import { WorkspacePermissionsCacheService } from 'src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service';
 import { WorkspaceDataSource } from 'src/engine/twenty-orm/datasource/workspace.datasource';
 import {
   TwentyORMException,
@@ -40,7 +40,8 @@ export class WorkspaceDatasourceFactory {
     private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
     private readonly workspaceMetadataCacheService: WorkspaceMetadataCacheService,
     private readonly entitySchemaFactory: EntitySchemaFactory,
-    private readonly workspaceRolesPermissionsCacheService: WorkspaceRolesPermissionsCacheService,
+    private readonly workspacePermissionsCacheService: WorkspacePermissionsCacheService,
+    private readonly workspacePermissionsCacheStorageService: WorkspacePermissionsCacheStorageService,
     private readonly workspaceFeatureFlagsMapCacheService: WorkspaceFeatureFlagsMapCacheService,
   ) {}
 
@@ -60,15 +61,11 @@ export class WorkspaceDatasourceFactory {
         { workspaceId },
       );
 
-    const isPermissionsV2Enabled =
-      cachedFeatureFlagMap[FeatureFlagKey.IsPermissionsV2Enabled];
-
     const {
       data: cachedRolesPermissions,
       version: cachedRolesPermissionsVersion,
     } = await this.getRolesPermissionsFromCache({
       workspaceId,
-      isPermissionsV2Enabled,
     });
 
     if (
@@ -196,13 +193,11 @@ export class WorkspaceDatasourceFactory {
       throw new Error(`Failed to create WorkspaceDataSource for ${cacheKey}`);
     }
 
-    if (isPermissionsV2Enabled) {
-      await this.updateWorkspaceDataSourceRolesPermissionsIfNeeded({
-        workspaceDataSource,
-        cachedRolesPermissionsVersion,
-        cachedRolesPermissions,
-      });
-    }
+    await this.updateWorkspaceDataSourceRolesPermissionsIfNeeded({
+      workspaceDataSource,
+      cachedRolesPermissionsVersion,
+      cachedRolesPermissions,
+    });
 
     await this.updateWorkspaceDataSourceFeatureFlagsMapIfNeeded({
       workspaceDataSource,
@@ -215,33 +210,21 @@ export class WorkspaceDatasourceFactory {
 
   private async getRolesPermissionsFromCache({
     workspaceId,
-    isPermissionsV2Enabled,
   }: {
     workspaceId: string;
-    isPermissionsV2Enabled?: boolean;
-  }): Promise<
-    CacheResult<
-      string | undefined,
-      ObjectRecordsPermissionsByRoleId | undefined
-    >
-  > {
-    if (!isPermissionsV2Enabled) {
-      return { version: undefined, data: undefined };
-    }
-
-    return getFromCacheWithRecompute<
-      string | undefined,
-      ObjectRecordsPermissionsByRoleId | undefined
-    >({
+  }): Promise<CacheResult<string, ObjectRecordsPermissionsByRoleId>> {
+    return getFromCacheWithRecompute<string, ObjectRecordsPermissionsByRoleId>({
       workspaceId,
       getCacheData: () =>
-        this.workspaceCacheStorageService.getRolesPermissions(workspaceId),
+        this.workspacePermissionsCacheStorageService.getRolesPermissions(
+          workspaceId,
+        ),
       getCacheVersion: () =>
-        this.workspaceCacheStorageService.getRolesPermissionsVersionFromCache(
+        this.workspacePermissionsCacheStorageService.getRolesPermissionsVersion(
           workspaceId,
         ),
       recomputeCache: (params) =>
-        this.workspaceRolesPermissionsCacheService.recomputeRolesPermissionsCache(
+        this.workspacePermissionsCacheService.recomputeRolesPermissionsCache(
           params,
         ),
       cachedEntityName: 'Roles permissions',
@@ -281,8 +264,8 @@ export class WorkspaceDatasourceFactory {
     cachedRolesPermissions,
   }: {
     workspaceDataSource: WorkspaceDataSource;
-    cachedRolesPermissionsVersion: string | undefined;
-    cachedRolesPermissions: ObjectRecordsPermissionsByRoleId | undefined;
+    cachedRolesPermissionsVersion: string;
+    cachedRolesPermissions: ObjectRecordsPermissionsByRoleId;
   }): Promise<void> {
     this.updateWorkspaceDataSourceIfNeeded({
       workspaceDataSource,