Remove usages of connectToDataSource and use workspaceDataSource (#11873)

In this PR we are

1. cleaning typeORM service by removing connectToDataSource method
2. using workspaceDataSource instead of mainDataSource when possible,
and replacing raw SQL with workspaceRepository methods to use

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

@@ -47,15 +47,15 @@ export class WorkspaceDataSource extends DataSource {
     roleId?: string,
   ): WorkspaceRepository<Entity> {
     if (shouldBypassPermissionChecks === true) {
-      return this.manager.getRepository(target, shouldBypassPermissionChecks);
+      return this.manager.getRepository(target, {
+        shouldBypassPermissionChecks: true,
+      });
     }
 
     if (roleId) {
-      return this.manager.getRepository(
-        target,
-        shouldBypassPermissionChecks,
+      return this.manager.getRepository(target, {
         roleId,
-      );
+      });
     }
 
     return this.manager.getRepository(target);

packages/twenty-server/src/engine/twenty-orm/entity-manager/workspace-entity-manager.ts

@@ -2,6 +2,7 @@ import { ObjectRecordsPermissions } from 'twenty-shared/types';
 import {
   EntityManager,
   EntityTarget,
+  FindManyOptions,
   InsertResult,
   ObjectLiteral,
   QueryRunner,
@@ -44,16 +45,19 @@ export class WorkspaceEntityManager extends EntityManager {
 
   override getRepository<Entity extends ObjectLiteral>(
     target: EntityTarget<Entity>,
-    shouldBypassPermissionChecks = false,
-    roleId?: string,
+    permissionOptions?: {
+      shouldBypassPermissionChecks?: boolean;
+      roleId?: string;
+    },
   ): WorkspaceRepository<Entity> {
     const dataSource = this.connection;
 
     const repositoryKey = this.getRepositoryKey({
       target,
       dataSource,
-      roleId,
-      shouldBypassPermissionChecks,
+      roleId: permissionOptions?.roleId,
+      shouldBypassPermissionChecks:
+        permissionOptions?.shouldBypassPermissionChecks ?? false,
     });
     const repoFromMap = this.repositories.get(repositoryKey);
 
@@ -63,10 +67,11 @@ export class WorkspaceEntityManager extends EntityManager {
 
     let objectPermissions = {};
 
-    if (roleId) {
+    if (permissionOptions?.roleId) {
       const objectPermissionsByRoleId = dataSource.permissionsPerRoleId;
 
-      objectPermissions = objectPermissionsByRoleId?.[roleId] ?? {};
+      objectPermissions =
+        objectPermissionsByRoleId?.[permissionOptions?.roleId] ?? {};
     }
 
     const newRepository = new WorkspaceRepository<Entity>(
@@ -76,7 +81,7 @@ export class WorkspaceEntityManager extends EntityManager {
       dataSource.featureFlagMap,
       this.queryRunner,
       objectPermissions,
-      shouldBypassPermissionChecks,
+      permissionOptions?.shouldBypassPermissionChecks,
     );
 
     this.repositories.set(repositoryKey, newRepository);
@@ -135,17 +140,30 @@ export class WorkspaceEntityManager extends EntityManager {
     }
   }
 
+  override find<Entity extends ObjectLiteral>(
+    target: EntityTarget<Entity>,
+    options?: FindManyOptions<Entity>,
+    permissionOptions?: {
+      shouldBypassPermissionChecks?: boolean;
+      objectRecordsPermissions?: ObjectRecordsPermissions;
+    },
+  ): Promise<Entity[]> {
+    this.validatePermissions(target, 'select', permissionOptions);
+
+    return super.find(target, options);
+  }
+
   override insert<Entity extends ObjectLiteral>(
     target: EntityTarget<Entity>,
     entityOrEntities:
       | QueryDeepPartialEntity<Entity>
       | QueryDeepPartialEntity<Entity>[],
-    options?: {
+    permissionOptions?: {
       shouldBypassPermissionChecks?: boolean;
       objectRecordsPermissions?: ObjectRecordsPermissions;
     },
   ): Promise<InsertResult> {
-    this.validatePermissions(target, 'insert', options);
+    this.validatePermissions(target, 'insert', permissionOptions);
 
     return super.insert(target, entityOrEntities);
   }
@@ -156,12 +174,12 @@ export class WorkspaceEntityManager extends EntityManager {
       | QueryDeepPartialEntity<Entity>
       | QueryDeepPartialEntity<Entity>[],
     conflictPathsOrOptions: string[] | UpsertOptions<Entity>,
-    options?: {
+    permissionOptions?: {
       shouldBypassPermissionChecks?: boolean;
       objectRecordsPermissions?: ObjectRecordsPermissions;
     },
   ): Promise<InsertResult> {
-    this.validatePermissions(target, 'update', options);
+    this.validatePermissions(target, 'update', permissionOptions);
 
     return super.upsert(target, entityOrEntities, conflictPathsOrOptions);
   }
@@ -194,7 +212,7 @@ export class WorkspaceEntityManager extends EntityManager {
   private validatePermissions<Entity extends ObjectLiteral>(
     target: EntityTarget<Entity>,
     operationType: OperationType,
-    options?: {
+    permissionOptions?: {
       shouldBypassPermissionChecks?: boolean;
       objectRecordsPermissions?: ObjectRecordsPermissions;
     },
@@ -208,14 +226,15 @@ export class WorkspaceEntityManager extends EntityManager {
       return;
     }
 
-    if (options?.shouldBypassPermissionChecks === true) {
+    if (permissionOptions?.shouldBypassPermissionChecks === true) {
       return;
     }
 
     validateOperationIsPermittedOrThrow({
       entityName: this.extractTargetNameSingularFromEntityTarget(target),
       operationType,
-      objectRecordsPermissions: options?.objectRecordsPermissions ?? {},
+      objectRecordsPermissions:
+        permissionOptions?.objectRecordsPermissions ?? {},
       objectMetadataMaps: this.internalContext.objectMetadataMaps,
     });
   }

packages/twenty-server/src/engine/twenty-orm/twenty-orm-global.manager.ts

@@ -65,10 +65,13 @@ export class TwentyORMGlobalManager {
     return repository;
   }
 
-  async getDataSourceForWorkspace(
-    workspaceId: string,
+  async getDataSourceForWorkspace({
+    workspaceId,
     shouldFailIfMetadataNotFound = true,
-  ) {
+  }: {
+    workspaceId: string;
+    shouldFailIfMetadataNotFound?: boolean;
+  }) {
     return await this.workspaceDataSourceFactory.create(
       workspaceId,
       null,