Optimize metadata queries (#7013)

In this PR:

1. Refactor guards to avoid duplicated queries: WorkspaceAuthGuard and
UserAuthGuard only check for existence of workspace and user in the
request without querying the database

packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.service.ts

@@ -6,6 +6,8 @@ import camelCase from 'lodash.camelcase';
 import { FindOneOptions, In, Repository } from 'typeorm';
 import { v4 as uuidV4 } from 'uuid';
 
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+
 import {
   FieldMetadataEntity,
   FieldMetadataType,
@@ -30,6 +32,7 @@ import {
 } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.entity';
 import { WorkspaceMigrationService } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.service';
 import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
+import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
 import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
 
 import {
@@ -50,6 +53,7 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
     private readonly workspaceMigrationService: WorkspaceMigrationService,
     private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
     private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
+    private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
   ) {
     super(relationMetadataRepository);
   }
@@ -411,43 +415,73 @@ export class RelationMetadataService extends TypeOrmQueryService<RelationMetadat
   }
 
   async findManyRelationMetadataByFieldMetadataIds(
-    fieldMetadataIds: string[],
+    fieldMetadataItems: Array<
+      Pick<FieldMetadataInterface, 'id' | 'type' | 'objectMetadataId'>
+    >,
+    workspaceId: string,
   ): Promise<(RelationMetadataEntity | NotFoundException)[]> {
-    const relationMetadataCollection =
-      await this.relationMetadataRepository.find({
-        where: [
-          {
-            fromFieldMetadataId: In(fieldMetadataIds),
-          },
-          {
-            toFieldMetadataId: In(fieldMetadataIds),
-          },
-        ],
-        relations: [
-          'fromObjectMetadata',
-          'toObjectMetadata',
-          'fromFieldMetadata',
-          'toFieldMetadata',
-        ],
-      });
+    const metadataVersion =
+      await this.workspaceCacheStorageService.getMetadataVersion(workspaceId);
 
-    const mappedResult = fieldMetadataIds.map((fieldMetadataId) => {
-      const foundRelationMetadataItem = relationMetadataCollection.find(
-        (relationMetadataItem) =>
-          relationMetadataItem.fromFieldMetadataId === fieldMetadataId ||
-          relationMetadataItem.toFieldMetadataId === fieldMetadataId,
+    if (!metadataVersion) {
+      throw new NotFoundException(
+        `Metadata version not found for workspace ${workspaceId}`,
+      );
+    }
+
+    const objectMetadataMap =
+      await this.workspaceCacheStorageService.getObjectMetadataMap(
+        workspaceId,
+        metadataVersion,
       );
 
-      return (
-        foundRelationMetadataItem ??
-        // TODO: return a relation metadata not found exception
-        new NotFoundException(
-          `RelationMetadata with fieldMetadataId ${fieldMetadataId} not found`,
-        )
+    if (!objectMetadataMap) {
+      throw new NotFoundException(
+        `Object metadata map not found for workspace ${workspaceId} and metadata version ${metadataVersion}`,
       );
+    }
+
+    const mappedResult = fieldMetadataItems.map((fieldMetadataItem) => {
+      const objectMetadata =
+        objectMetadataMap[fieldMetadataItem.objectMetadataId];
+
+      const fieldMetadata = objectMetadata.fields[fieldMetadataItem.id];
+
+      const relationMetadata =
+        fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
+
+      if (!relationMetadata) {
+        return new NotFoundException(
+          `From object metadata not found for relation ${fieldMetadata?.id}`,
+        );
+      }
+
+      const fromObjectMetadata =
+        objectMetadataMap[relationMetadata.fromObjectMetadataId];
+
+      const toObjectMetadata =
+        objectMetadataMap[relationMetadata.toObjectMetadataId];
+
+      const fromFieldMetadata =
+        objectMetadataMap[fromObjectMetadata.id].fields[
+          relationMetadata.fromFieldMetadataId
+        ];
+
+      const toFieldMetadata =
+        objectMetadataMap[toObjectMetadata.id].fields[
+          relationMetadata.toFieldMetadataId
+        ];
+
+      return {
+        ...relationMetadata,
+        fromObjectMetadata,
+        toObjectMetadata,
+        fromFieldMetadata,
+        toFieldMetadata,
+      };
     });
 
-    return mappedResult;
+    return mappedResult as (RelationMetadataEntity | NotFoundException)[];
   }
 
   private async deleteRelationWorkspaceCustomMigration(