refactor(twenty-orm): migrate PageLayout entities to WorkspaceScopedRepository

Migrates PageLayoutEntity, PageLayoutTabEntity and PageLayoutWidgetEntity in
their flat cache services.

packages/twenty-server/src/database/commands/upgrade-version-command/1-21/1-21-upgrade-version-command.module.ts

@@ -26,6 +26,7 @@ import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-s
 import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
 import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
 import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -64,6 +65,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     MigrateMessagingInfrastructureToMetadataCommand,
     FixMessageThreadViewAndLabelIdentifierCommand,
     UpdateSearchCommandMenuItemLabelsCommand,
+    provideWorkspaceScopedRepository(DataSourceEntity),
   ],
 })
 export class V1_21_UpgradeVersionCommandModule {}

packages/twenty-server/src/database/commands/upgrade-version-command/1-21/1-21-workspace-command-1775500003000-backfill-datasource-to-workspace.command.ts

@@ -11,6 +11,8 @@ import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/w
 import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 
 @RegisteredWorkspaceCommand('1.21.0', 1775500003000)
 @Command({
@@ -22,8 +24,8 @@ export class BackfillDatasourceToWorkspaceCommand extends ActiveOrSuspendedWorks
   constructor(
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
-    @InjectRepository(DataSourceEntity)
-    private readonly dataSourceRepository: Repository<DataSourceEntity>,
+    @InjectWorkspaceScopedRepository(DataSourceEntity)
+    private readonly dataSourceRepository: WorkspaceScopedRepository<DataSourceEntity>,
     protected readonly workspaceIteratorService: WorkspaceIteratorService,
   ) {
     super(workspaceIteratorService);
@@ -54,8 +56,7 @@ export class BackfillDatasourceToWorkspaceCommand extends ActiveOrSuspendedWorks
       return;
     }
 
-    const dataSource = await this.dataSourceRepository.findOne({
-      where: { workspaceId },
+    const dataSource = await this.dataSourceRepository.findOne(workspaceId, {
       order: { createdAt: 'DESC' },
     });
 

packages/twenty-server/src/engine/core-modules/api-key/api-key.module.ts

@@ -44,6 +44,8 @@ import { ApiKeyController } from './controllers/api-key.controller';
     WorkspaceApiKeyMapCacheService,
     GenerateApiKeyCommand,
     provideWorkspaceScopedRepository(ApiKeyEntity),
+    provideWorkspaceScopedRepository(RoleEntity),
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   controllers: [ApiKeyController],
   exports: [

packages/twenty-server/src/engine/core-modules/api-key/commands/generate-api-key.command.ts

@@ -13,6 +13,8 @@ import { ApiKeyService } from 'src/engine/core-modules/api-key/services/api-key.
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
 
 type GenerateApiKeyCommandOptions = {
@@ -33,8 +35,8 @@ export class GenerateApiKeyCommand extends CommandRunner {
   constructor(
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     private readonly apiKeyService: ApiKeyService,
     private readonly twentyConfigService: TwentyConfigService,
   ) {
@@ -104,9 +106,8 @@ export class GenerateApiKeyCommand extends CommandRunner {
       return;
     }
 
-    const adminRole = await this.roleRepository.findOne({
+    const adminRole = await this.roleRepository.findOne(workspace.id, {
       where: {
-        workspaceId: workspace.id,
         universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
       },
     });

packages/twenty-server/src/engine/core-modules/api-key/services/__tests__/api-key.service.spec.ts

@@ -1,5 +1,5 @@
 import { Test, type TestingModule } from '@nestjs/testing';
-import { getDataSourceToken, getRepositoryToken } from '@nestjs/typeorm';
+import { getDataSourceToken } from '@nestjs/typeorm';
 
 import { IsNull } from 'typeorm';
 
@@ -101,7 +101,7 @@ describe('ApiKeyService', () => {
           useValue: mockRoleTargetService,
         },
         {
-          provide: getRepositoryToken(RoleTargetEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleTargetEntity),
           useValue: mockroleTargetRepository,
         },
         {

packages/twenty-server/src/engine/core-modules/api-key/services/api-key-role.service.ts

@@ -1,8 +1,7 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { In, IsNull, Not, Repository } from 'typeorm';
+import { In, IsNull, Not } from 'typeorm';
 
 import { ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
 import {
@@ -23,10 +22,10 @@ import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/works
 @Injectable()
 export class ApiKeyRoleService {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
 
     @InjectWorkspaceScopedRepository(ApiKeyEntity)
     private readonly apiKeyRepository: WorkspaceScopedRepository<ApiKeyEntity>,
@@ -141,8 +140,8 @@ export class ApiKeyRoleService {
       );
     }
 
-    const role = await this.roleRepository.findOne({
-      where: { id: roleId, workspaceId },
+    const role = await this.roleRepository.findOne(workspaceId, {
+      where: { id: roleId },
     });
 
     if (!role) {
@@ -159,13 +158,15 @@ export class ApiKeyRoleService {
       );
     }
 
-    const existingRoleTarget = await this.roleTargetRepository.findOne({
-      where: {
-        apiKeyId,
-        roleId,
-        workspaceId,
+    const existingRoleTarget = await this.roleTargetRepository.findOne(
+      workspaceId,
+      {
+        where: {
+          apiKeyId,
+          roleId,
+        },
       },
-    });
+    );
 
     return {
       roleToAssignIsSameAsCurrentRole: Boolean(existingRoleTarget),
@@ -183,10 +184,9 @@ export class ApiKeyRoleService {
       return new Map();
     }
 
-    const roleTargets = await this.roleTargetRepository.find({
+    const roleTargets = await this.roleTargetRepository.find(workspaceId, {
       where: {
         apiKeyId: In(apiKeyIds),
-        workspaceId,
       },
       relations: ['role'],
     });
@@ -209,10 +209,9 @@ export class ApiKeyRoleService {
     roleId: string,
     workspaceId: string,
   ): Promise<ApiKeyEntity[]> {
-    const roleTargets = await this.roleTargetRepository.find({
+    const roleTargets = await this.roleTargetRepository.find(workspaceId, {
       where: {
         roleId,
-        workspaceId,
         apiKeyId: Not(IsNull()),
       },
     });

packages/twenty-server/src/engine/core-modules/application/application.module.ts

@@ -39,6 +39,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     ApplicationService,
     WorkspaceFlatApplicationMapCacheService,
     provideWorkspaceScopedRepository(AgentEntity),
+    provideWorkspaceScopedRepository(CommandMenuItemEntity),
   ],
 })
 export class ApplicationModule {}

packages/twenty-server/src/engine/core-modules/application/application.service.ts

@@ -43,8 +43,8 @@ export class ApplicationService {
     private readonly agentRepository: WorkspaceScopedRepository<AgentEntity>,
     @InjectRepository(FrontComponentEntity)
     private readonly frontComponentRepository: Repository<FrontComponentEntity>,
-    @InjectRepository(CommandMenuItemEntity)
-    private readonly commandMenuItemRepository: Repository<CommandMenuItemEntity>,
+    @InjectWorkspaceScopedRepository(CommandMenuItemEntity)
+    private readonly commandMenuItemRepository: WorkspaceScopedRepository<CommandMenuItemEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(ApplicationVariableEntity)
@@ -206,8 +206,8 @@ export class ApplicationService {
       this.frontComponentRepository.find({
         where: { applicationId: application.id, workspaceId },
       }),
-      this.commandMenuItemRepository.find({
-        where: { applicationId: application.id, workspaceId },
+      this.commandMenuItemRepository.find(workspaceId, {
+        where: { applicationId: application.id },
       }),
       this.objectMetadataRepository.find({
         where: { applicationId: application.id, workspaceId },

packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.service.ts

@@ -51,6 +51,8 @@ export class UserWorkspaceService extends TypeOrmQueryService<UserWorkspaceEntit
     private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
     @InjectRepository(UserEntity)
     private readonly userRepository: Repository<UserEntity>,
+    // softRemove is not supported by WorkspaceScopedRepository.
+    // eslint-disable-next-line twenty/prefer-workspace-scoped-repository
     @InjectRepository(RoleTargetEntity)
     private readonly roleTargetRepository: Repository<RoleTargetEntity>,
     private readonly roleValidationService: RoleValidationService,

packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/ai-agent-execution.module.ts

@@ -14,6 +14,7 @@ import { AiModelsModule } from 'src/engine/metadata-modules/ai/ai-models/ai-mode
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 
 import { AgentMessagePartEntity } from './entities/agent-message-part.entity';
@@ -49,6 +50,7 @@ import { AgentAsyncExecutorService } from './services/agent-async-executor.servi
     AgentAsyncExecutorService,
     AgentActorContextService,
     AgentMessagePartResolver,
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   exports: [
     AgentAsyncExecutorService,

packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-execution/services/agent-async-executor.service.ts

@@ -45,6 +45,8 @@ import {
 } from 'src/engine/metadata-modules/ai/ai.exception';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 
 const EMPTY_USAGE: LanguageModelUsage = {
   inputTokens: 0,
@@ -75,8 +77,8 @@ export class AgentAsyncExecutorService {
     private readonly nativeToolBinder: NativeToolBinderService,
     private readonly aiBillingService: AiBillingService,
     private readonly billingUsageService: BillingUsageService,
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
   ) {}
@@ -104,10 +106,9 @@ export class AgentAsyncExecutorService {
     workspaceId: string,
     rolePermissionConfig?: RolePermissionConfig,
   ): Promise<RolePermissionConfig | undefined> {
-    const roleTarget = await this.roleTargetRepository.findOne({
+    const roleTarget = await this.roleTargetRepository.findOne(workspaceId, {
       where: {
         agentId,
-        workspaceId,
       },
       select: ['roleId'],
     });

packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-role/agent-role.service.spec.ts

@@ -1,7 +1,4 @@
 import { Test, type TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-
-import { type Repository } from 'typeorm';
 
 import {
   AiException,
@@ -20,8 +17,8 @@ import { AiAgentRoleService } from './ai-agent-role.service';
 describe('AiAgentRoleService', () => {
   let service: AiAgentRoleService;
   let agentRepository: WorkspaceScopedRepository<AgentEntity>;
-  let roleRepository: Repository<RoleEntity>;
-  let roleTargetRepository: Repository<RoleTargetEntity>;
+  let roleRepository: WorkspaceScopedRepository<RoleEntity>;
+  let roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>;
   let roleTargetService: RoleTargetService;
 
   const testWorkspaceId = 'test-workspace-id';
@@ -42,19 +39,20 @@ describe('AiAgentRoleService', () => {
           },
         },
         {
-          provide: getRepositoryToken(RoleEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleEntity),
           useValue: {
             findOne: jest.fn(),
             save: jest.fn(),
           },
         },
         {
-          provide: getRepositoryToken(RoleTargetEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleTargetEntity),
           useValue: {
             findOne: jest.fn(),
             save: jest.fn(),
             delete: jest.fn(),
             find: jest.fn(),
+            count: jest.fn(),
           },
         },
         {
@@ -71,12 +69,12 @@ describe('AiAgentRoleService', () => {
     agentRepository = module.get<WorkspaceScopedRepository<AgentEntity>>(
       getWorkspaceScopedRepositoryToken(AgentEntity),
     );
-    roleRepository = module.get<Repository<RoleEntity>>(
-      getRepositoryToken(RoleEntity),
-    );
-    roleTargetRepository = module.get<Repository<RoleTargetEntity>>(
-      getRepositoryToken(RoleTargetEntity),
+    roleRepository = module.get<WorkspaceScopedRepository<RoleEntity>>(
+      getWorkspaceScopedRepositoryToken(RoleEntity),
     );
+    roleTargetRepository = module.get<
+      WorkspaceScopedRepository<RoleTargetEntity>
+    >(getWorkspaceScopedRepositoryToken(RoleTargetEntity));
     roleTargetService = module.get<RoleTargetService>(RoleTargetService);
 
     // Setup test data
@@ -153,16 +151,18 @@ describe('AiAgentRoleService', () => {
       expect(agentRepository.findOne).toHaveBeenCalledWith(testWorkspaceId, {
         where: { id: testAgent.id },
       });
-      expect(roleRepository.findOne).toHaveBeenCalledWith({
-        where: { id: testRole.id, workspaceId: testWorkspaceId },
+      expect(roleRepository.findOne).toHaveBeenCalledWith(testWorkspaceId, {
+        where: { id: testRole.id },
       });
-      expect(roleTargetRepository.findOne).toHaveBeenCalledWith({
-        where: {
-          agentId: testAgent.id,
-          roleId: testRole.id,
-          workspaceId: testWorkspaceId,
+      expect(roleTargetRepository.findOne).toHaveBeenCalledWith(
+        testWorkspaceId,
+        {
+          where: {
+            agentId: testAgent.id,
+            roleId: testRole.id,
+          },
         },
-      });
+      );
       expect(roleTargetService.create).toHaveBeenCalledWith({
         createRoleTargetInput: {
           roleId: testRole.id,
@@ -335,12 +335,14 @@ describe('AiAgentRoleService', () => {
       });
 
       // Assert
-      expect(roleTargetRepository.findOne).toHaveBeenCalledWith({
-        where: {
-          agentId: testAgent.id,
-          workspaceId: testWorkspaceId,
+      expect(roleTargetRepository.findOne).toHaveBeenCalledWith(
+        testWorkspaceId,
+        {
+          where: {
+            agentId: testAgent.id,
+          },
         },
-      });
+      );
       expect(roleTargetService.delete).toHaveBeenCalledWith({
         id: existingRoleTarget.id,
         workspaceId: testWorkspaceId,

packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-role/ai-agent-role.module.ts

@@ -16,6 +16,8 @@ import { AiAgentRoleService } from './ai-agent-role.service';
   providers: [
     AiAgentRoleService,
     provideWorkspaceScopedRepository(AgentEntity),
+    provideWorkspaceScopedRepository(RoleEntity),
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   exports: [AiAgentRoleService],
 })

packages/twenty-server/src/engine/metadata-modules/ai/ai-agent-role/ai-agent-role.service.ts

@@ -1,8 +1,7 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { In, IsNull, Not, Repository } from 'typeorm';
+import { In, IsNull, Not } from 'typeorm';
 
 import {
   AiException,
@@ -19,10 +18,10 @@ export class AiAgentRoleService {
   constructor(
     @InjectWorkspaceScopedRepository(AgentEntity)
     private readonly agentRepository: WorkspaceScopedRepository<AgentEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     private readonly roleTargetService: RoleTargetService,
   ) {}
 
@@ -62,12 +61,14 @@ export class AiAgentRoleService {
     workspaceId: string;
     agentId: string;
   }): Promise<void> {
-    const existingRoleTarget = await this.roleTargetRepository.findOne({
-      where: {
-        agentId,
-        workspaceId,
+    const existingRoleTarget = await this.roleTargetRepository.findOne(
+      workspaceId,
+      {
+        where: {
+          agentId,
+        },
       },
-    });
+    );
 
     if (!isDefined(existingRoleTarget)) {
       throw new AiException(
@@ -86,10 +87,9 @@ export class AiAgentRoleService {
     roleId: string,
     workspaceId: string,
   ): Promise<AgentEntity[]> {
-    const roleTargets = await this.roleTargetRepository.find({
+    const roleTargets = await this.roleTargetRepository.find(workspaceId, {
       where: {
         roleId,
-        workspaceId,
         agentId: Not(IsNull()),
       },
     });
@@ -129,8 +129,8 @@ export class AiAgentRoleService {
       );
     }
 
-    const role = await this.roleRepository.findOne({
-      where: { id: roleId, workspaceId },
+    const role = await this.roleRepository.findOne(workspaceId, {
+      where: { id: roleId },
     });
 
     if (!role) {
@@ -147,13 +147,15 @@ export class AiAgentRoleService {
       );
     }
 
-    const existingRoleTarget = await this.roleTargetRepository.findOne({
-      where: {
-        agentId,
-        roleId,
-        workspaceId,
+    const existingRoleTarget = await this.roleTargetRepository.findOne(
+      workspaceId,
+      {
+        where: {
+          agentId,
+          roleId,
+        },
       },
-    });
+    );
 
     return {
       roleToAssignIsSameAsCurrentRole: Boolean(existingRoleTarget),
@@ -169,8 +171,8 @@ export class AiAgentRoleService {
     roleTargetId: string;
     workspaceId: string;
   }): Promise<void> {
-    const role = await this.roleRepository.findOne({
-      where: { id: roleId, workspaceId },
+    const role = await this.roleRepository.findOne(workspaceId, {
+      where: { id: roleId },
     });
 
     if (
@@ -182,16 +184,18 @@ export class AiAgentRoleService {
       return;
     }
 
-    const remainingAssignments = await this.roleTargetRepository.count({
-      where: {
-        roleId,
-        workspaceId,
-        id: Not(roleTargetId),
+    const remainingAssignments = await this.roleTargetRepository.count(
+      workspaceId,
+      {
+        where: {
+          roleId,
+          id: Not(roleTargetId),
+        },
       },
-    });
+    );
 
     if (remainingAssignments === 0) {
-      await this.roleRepository.delete({ id: roleId, workspaceId });
+      await this.roleRepository.delete(workspaceId, { id: roleId });
     }
   }
 }

packages/twenty-server/src/engine/metadata-modules/flat-agent/services/workspace-flat-role-target-by-agent-id.service.ts

@@ -11,6 +11,8 @@ import { FlatRoleTargetByAgentIdMaps } from 'src/engine/metadata-modules/flat-ag
 import { fromRoleTargetEntityToFlatRoleTarget } from 'src/engine/metadata-modules/flat-role-target/utils/from-role-target-entity-to-flat-role-target.util';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 
@@ -18,12 +20,12 @@ import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/uti
 @WorkspaceCache('flatRoleTargetByAgentIdMaps')
 export class WorkspaceFlatRoleTargetByAgentIdService extends WorkspaceCacheProvider<FlatRoleTargetByAgentIdMaps> {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
   ) {
     super();
   }
@@ -32,9 +34,8 @@ export class WorkspaceFlatRoleTargetByAgentIdService extends WorkspaceCacheProvi
     workspaceId: string,
   ): Promise<FlatRoleTargetByAgentIdMaps> {
     const [roleTargetEntities, applications, roles] = await Promise.all([
-      this.roleTargetRepository.find({
+      this.roleTargetRepository.find(workspaceId, {
         where: {
-          workspaceId,
           agentId: Not(IsNull()),
         },
         withDeleted: true,
@@ -44,8 +45,7 @@ export class WorkspaceFlatRoleTargetByAgentIdService extends WorkspaceCacheProvi
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

packages/twenty-server/src/engine/metadata-modules/flat-command-menu-item/flat-command-menu-item.module.ts

@@ -8,6 +8,7 @@ import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata
 import { FrontComponentEntity } from 'src/engine/metadata-modules/front-component/entities/front-component.entity';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [
@@ -20,7 +21,11 @@ import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entiti
     ]),
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
   ],
-  providers: [WorkspaceFlatCommandMenuItemMapCacheService],
+  providers: [
+    WorkspaceFlatCommandMenuItemMapCacheService,
+    provideWorkspaceScopedRepository(CommandMenuItemEntity),
+    provideWorkspaceScopedRepository(PageLayoutEntity),
+  ],
   exports: [WorkspaceFlatCommandMenuItemMapCacheService],
 })
 export class FlatCommandMenuItemModule {}

packages/twenty-server/src/engine/metadata-modules/flat-command-menu-item/services/workspace-flat-command-menu-item-map-cache.service.ts

@@ -13,6 +13,8 @@ import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-enti
 import { FrontComponentEntity } from 'src/engine/metadata-modules/front-component/entities/front-component.entity';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -21,16 +23,16 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatCommandMenuItemMaps')
 export class WorkspaceFlatCommandMenuItemMapCacheService extends WorkspaceCacheProvider<FlatCommandMenuItemMaps> {
   constructor(
-    @InjectRepository(CommandMenuItemEntity)
-    private readonly commandMenuItemRepository: Repository<CommandMenuItemEntity>,
+    @InjectWorkspaceScopedRepository(CommandMenuItemEntity)
+    private readonly commandMenuItemRepository: WorkspaceScopedRepository<CommandMenuItemEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(FrontComponentEntity)
     private readonly frontComponentRepository: Repository<FrontComponentEntity>,
-    @InjectRepository(PageLayoutEntity)
-    private readonly pageLayoutRepository: Repository<PageLayoutEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutEntity)
+    private readonly pageLayoutRepository: WorkspaceScopedRepository<PageLayoutEntity>,
   ) {
     super();
   }
@@ -43,8 +45,7 @@ export class WorkspaceFlatCommandMenuItemMapCacheService extends WorkspaceCacheP
       frontComponents,
       pageLayouts,
     ] = await Promise.all([
-      this.commandMenuItemRepository.find({
-        where: { workspaceId },
+      this.commandMenuItemRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -62,8 +63,7 @@ export class WorkspaceFlatCommandMenuItemMapCacheService extends WorkspaceCacheP
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.pageLayoutRepository.find({
-        where: { workspaceId },
+      this.pageLayoutRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

packages/twenty-server/src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module.ts

@@ -44,6 +44,7 @@ import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entiti
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 
 @Module({
@@ -96,6 +97,23 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     WorkspaceFlatPageLayoutWidgetMapCacheService,
     WorkspaceFlatRowLevelPermissionPredicateMapCacheService,
     WorkspaceFlatRowLevelPermissionPredicateGroupMapCacheService,
+    provideWorkspaceScopedRepository(PermissionFlagEntity),
+    provideWorkspaceScopedRepository(IndexMetadataEntity),
+    provideWorkspaceScopedRepository(ViewEntity),
+    provideWorkspaceScopedRepository(ViewFieldEntity),
+    provideWorkspaceScopedRepository(ViewFieldGroupEntity),
+    provideWorkspaceScopedRepository(ViewFilterEntity),
+    provideWorkspaceScopedRepository(ViewFilterGroupEntity),
+    provideWorkspaceScopedRepository(ViewGroupEntity),
+    provideWorkspaceScopedRepository(ViewSortEntity),
+    provideWorkspaceScopedRepository(PageLayoutEntity),
+    provideWorkspaceScopedRepository(PageLayoutTabEntity),
+    provideWorkspaceScopedRepository(PageLayoutWidgetEntity),
+    provideWorkspaceScopedRepository(ObjectPermissionEntity),
+    provideWorkspaceScopedRepository(FieldPermissionEntity),
+    provideWorkspaceScopedRepository(RoleEntity),
+    provideWorkspaceScopedRepository(RowLevelPermissionPredicateEntity),
+    provideWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity),
   ],
   exports: [
     WorkspaceManyOrAllFlatEntityMapsCacheService,

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

@@ -18,6 +18,8 @@ import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -32,22 +34,22 @@ export class WorkspaceFlatFieldMetadataMapCacheService extends WorkspaceCachePro
   constructor(
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(IndexMetadataEntity)
-    private readonly indexMetadataRepository: Repository<IndexMetadataEntity>,
+    @InjectWorkspaceScopedRepository(IndexMetadataEntity)
+    private readonly indexMetadataRepository: WorkspaceScopedRepository<IndexMetadataEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(ViewFieldEntity)
-    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
-    @InjectRepository(ViewGroupEntity)
-    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
-    @InjectRepository(ViewSortEntity)
-    private readonly viewSortRepository: Repository<ViewSortEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldEntity)
+    private readonly viewFieldRepository: WorkspaceScopedRepository<ViewFieldEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewGroupEntity)
+    private readonly viewGroupRepository: WorkspaceScopedRepository<ViewGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewSortEntity)
+    private readonly viewSortRepository: WorkspaceScopedRepository<ViewSortEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {
     super();
   }
@@ -69,8 +71,8 @@ export class WorkspaceFlatFieldMetadataMapCacheService extends WorkspaceCachePro
         where: { workspaceId },
         withDeleted: true,
       }),
-      this.indexMetadataRepository.find({
-        where: { workspaceId, isUnique: true },
+      this.indexMetadataRepository.find(workspaceId, {
+        where: { isUnique: true },
         relations: ['indexFieldMetadatas'],
         withDeleted: true,
       }),
@@ -84,23 +86,19 @@ export class WorkspaceFlatFieldMetadataMapCacheService extends WorkspaceCachePro
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.viewFieldRepository.find({
-        where: { workspaceId },
+      this.viewFieldRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'fieldMetadataId'],
         withDeleted: true,
       }),
-      this.viewFilterRepository.find({
-        where: { workspaceId },
+      this.viewFilterRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'fieldMetadataId'],
         withDeleted: true,
       }),
-      this.viewSortRepository.find({
-        where: { workspaceId },
+      this.viewSortRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'fieldMetadataId'],
         withDeleted: true,
       }),
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         select: [
           'id',
           'universalIdentifier',

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

@@ -11,6 +11,8 @@ import { fromFieldPermissionEntityToFlatFieldPermission } from 'src/engine/metad
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { FieldPermissionEntity } from 'src/engine/metadata-modules/object-permission/field-permission/field-permission.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
@@ -20,12 +22,12 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatFieldPermissionMaps')
 export class WorkspaceFlatFieldPermissionMapCacheService extends WorkspaceCacheProvider<FlatFieldPermissionMaps> {
   constructor(
-    @InjectRepository(FieldPermissionEntity)
-    private readonly fieldPermissionRepository: Repository<FieldPermissionEntity>,
+    @InjectWorkspaceScopedRepository(FieldPermissionEntity)
+    private readonly fieldPermissionRepository: WorkspaceScopedRepository<FieldPermissionEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(FieldMetadataEntity)
@@ -42,8 +44,7 @@ export class WorkspaceFlatFieldPermissionMapCacheService extends WorkspaceCacheP
       objectMetadatas,
       fieldMetadatas,
     ] = await Promise.all([
-      this.fieldPermissionRepository.find({
-        where: { workspaceId },
+      this.fieldPermissionRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -51,8 +52,7 @@ export class WorkspaceFlatFieldPermissionMapCacheService extends WorkspaceCacheP
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

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

@@ -13,6 +13,8 @@ import { FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metada
 import { fromIndexMetadataEntityToFlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/utils/from-index-metadata-entity-to-flat-index-metadata.util';
 import { IndexMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-metadata.entity';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -23,8 +25,8 @@ export class WorkspaceFlatIndexMapCacheService extends WorkspaceCacheProvider<
   FlatEntityMaps<FlatIndexMetadata>
 > {
   constructor(
-    @InjectRepository(IndexMetadataEntity)
-    private readonly indexMetadataRepository: Repository<IndexMetadataEntity>,
+    @InjectWorkspaceScopedRepository(IndexMetadataEntity)
+    private readonly indexMetadataRepository: WorkspaceScopedRepository<IndexMetadataEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
@@ -40,10 +42,7 @@ export class WorkspaceFlatIndexMapCacheService extends WorkspaceCacheProvider<
   ): Promise<FlatEntityMaps<FlatIndexMetadata>> {
     const [indexes, applications, objectMetadatas, fieldMetadatas] =
       await Promise.all([
-        this.indexMetadataRepository.find({
-          where: {
-            workspaceId,
-          },
+        this.indexMetadataRepository.find(workspaceId, {
           withDeleted: true,
           relationLoadStrategy: 'join',
           relations: ['indexFieldMetadatas'],

packages/twenty-server/src/engine/metadata-modules/flat-navigation-menu-item/flat-navigation-menu-item.module.ts

@@ -8,6 +8,7 @@ import { NavigationMenuItemEntity } from 'src/engine/metadata-modules/navigation
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [
@@ -20,7 +21,12 @@ import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entit
     ]),
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
   ],
-  providers: [WorkspaceFlatNavigationMenuItemMapCacheService],
+  providers: [
+    WorkspaceFlatNavigationMenuItemMapCacheService,
+    provideWorkspaceScopedRepository(NavigationMenuItemEntity),
+    provideWorkspaceScopedRepository(ViewEntity),
+    provideWorkspaceScopedRepository(PageLayoutEntity),
+  ],
   exports: [WorkspaceFlatNavigationMenuItemMapCacheService],
 })
 export class FlatNavigationMenuItemModule {}

packages/twenty-server/src/engine/metadata-modules/flat-navigation-menu-item/services/workspace-flat-navigation-menu-item-map-cache.service.ts

@@ -14,6 +14,8 @@ import { NavigationMenuItemEntity } from 'src/engine/metadata-modules/navigation
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 
@@ -21,16 +23,16 @@ import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/uti
 @WorkspaceCache('flatNavigationMenuItemMaps')
 export class WorkspaceFlatNavigationMenuItemMapCacheService extends WorkspaceCacheProvider<FlatNavigationMenuItemMaps> {
   constructor(
-    @InjectRepository(NavigationMenuItemEntity)
-    private readonly navigationMenuItemRepository: Repository<NavigationMenuItemEntity>,
+    @InjectWorkspaceScopedRepository(NavigationMenuItemEntity)
+    private readonly navigationMenuItemRepository: WorkspaceScopedRepository<NavigationMenuItemEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
-    @InjectRepository(PageLayoutEntity)
-    private readonly pageLayoutRepository: Repository<PageLayoutEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutEntity)
+    private readonly pageLayoutRepository: WorkspaceScopedRepository<PageLayoutEntity>,
   ) {
     super();
   }
@@ -45,8 +47,7 @@ export class WorkspaceFlatNavigationMenuItemMapCacheService extends WorkspaceCac
       views,
       pageLayouts,
     ] = await Promise.all([
-      this.navigationMenuItemRepository.find({
-        where: { workspaceId },
+      this.navigationMenuItemRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -59,13 +60,11 @@ export class WorkspaceFlatNavigationMenuItemMapCacheService extends WorkspaceCac
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.pageLayoutRepository.find({
-        where: { workspaceId },
+      this.pageLayoutRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

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

@@ -15,6 +15,8 @@ import { IndexMetadataEntity } from 'src/engine/metadata-modules/index-metadata/
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ObjectPermissionEntity } from 'src/engine/metadata-modules/object-permission/object-permission.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -32,12 +34,12 @@ export class WorkspaceFlatObjectMetadataMapCacheService extends WorkspaceCachePr
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(IndexMetadataEntity)
-    private readonly indexMetadataRepository: Repository<IndexMetadataEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
-    @InjectRepository(ObjectPermissionEntity)
-    private readonly objectPermissionRepository: Repository<ObjectPermissionEntity>,
+    @InjectWorkspaceScopedRepository(IndexMetadataEntity)
+    private readonly indexMetadataRepository: WorkspaceScopedRepository<IndexMetadataEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ObjectPermissionEntity)
+    private readonly objectPermissionRepository: WorkspaceScopedRepository<ObjectPermissionEntity>,
   ) {
     super();
   }
@@ -67,18 +69,15 @@ export class WorkspaceFlatObjectMetadataMapCacheService extends WorkspaceCachePr
         select: ['id', 'universalIdentifier', 'objectMetadataId'],
         withDeleted: true,
       }),
-      this.indexMetadataRepository.find({
-        where: { workspaceId },
+      this.indexMetadataRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'objectMetadataId'],
         withDeleted: true,
       }),
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'objectMetadataId'],
         withDeleted: true,
       }),
-      this.objectPermissionRepository.find({
-        where: { workspaceId },
+      this.objectPermissionRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'objectMetadataId'],
         withDeleted: true,
       }),

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

@@ -10,6 +10,8 @@ import { fromObjectPermissionEntityToFlatObjectPermission } from 'src/engine/met
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ObjectPermissionEntity } from 'src/engine/metadata-modules/object-permission/object-permission.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
@@ -19,12 +21,12 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatObjectPermissionMaps')
 export class WorkspaceFlatObjectPermissionMapCacheService extends WorkspaceCacheProvider<FlatObjectPermissionMaps> {
   constructor(
-    @InjectRepository(ObjectPermissionEntity)
-    private readonly objectPermissionRepository: Repository<ObjectPermissionEntity>,
+    @InjectWorkspaceScopedRepository(ObjectPermissionEntity)
+    private readonly objectPermissionRepository: WorkspaceScopedRepository<ObjectPermissionEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
   ) {
@@ -36,8 +38,7 @@ export class WorkspaceFlatObjectPermissionMapCacheService extends WorkspaceCache
   ): Promise<FlatObjectPermissionMaps> {
     const [objectPermissions, applications, roles, objectMetadatas] =
       await Promise.all([
-        this.objectPermissionRepository.find({
-          where: { workspaceId },
+        this.objectPermissionRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -45,8 +46,7 @@ export class WorkspaceFlatObjectPermissionMapCacheService extends WorkspaceCache
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.roleRepository.find({
-          where: { workspaceId },
+        this.roleRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

packages/twenty-server/src/engine/metadata-modules/flat-page-layout-tab/services/workspace-flat-page-layout-tab-map-cache.service.ts

@@ -12,6 +12,8 @@ import { transformPageLayoutTabEntityToFlatPageLayoutTab } from 'src/engine/meta
 import { PageLayoutTabEntity } from 'src/engine/metadata-modules/page-layout-tab/entities/page-layout-tab.entity';
 import { PageLayoutWidgetEntity } from 'src/engine/metadata-modules/page-layout-widget/entities/page-layout-widget.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -21,14 +23,14 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatPageLayoutTabMaps')
 export class WorkspaceFlatPageLayoutTabMapCacheService extends WorkspaceCacheProvider<FlatPageLayoutTabMaps> {
   constructor(
-    @InjectRepository(PageLayoutTabEntity)
-    private readonly pageLayoutTabRepository: Repository<PageLayoutTabEntity>,
-    @InjectRepository(PageLayoutWidgetEntity)
-    private readonly pageLayoutWidgetRepository: Repository<PageLayoutWidgetEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutTabEntity)
+    private readonly pageLayoutTabRepository: WorkspaceScopedRepository<PageLayoutTabEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutWidgetEntity)
+    private readonly pageLayoutWidgetRepository: WorkspaceScopedRepository<PageLayoutWidgetEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(PageLayoutEntity)
-    private readonly pageLayoutRepository: Repository<PageLayoutEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutEntity)
+    private readonly pageLayoutRepository: WorkspaceScopedRepository<PageLayoutEntity>,
   ) {
     super();
   }
@@ -36,12 +38,10 @@ export class WorkspaceFlatPageLayoutTabMapCacheService extends WorkspaceCachePro
   async computeForCache(workspaceId: string): Promise<FlatPageLayoutTabMaps> {
     const [pageLayoutTabs, pageLayoutWidgets, applications, pageLayouts] =
       await Promise.all([
-        this.pageLayoutTabRepository.find({
-          where: { workspaceId },
+        this.pageLayoutTabRepository.find(workspaceId, {
           withDeleted: true,
         }),
-        this.pageLayoutWidgetRepository.find({
-          where: { workspaceId },
+        this.pageLayoutWidgetRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier', 'pageLayoutTabId'],
           withDeleted: true,
         }),
@@ -50,8 +50,7 @@ export class WorkspaceFlatPageLayoutTabMapCacheService extends WorkspaceCachePro
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.pageLayoutRepository.find({
-          where: { workspaceId },
+        this.pageLayoutRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

packages/twenty-server/src/engine/metadata-modules/flat-page-layout-widget/services/workspace-flat-page-layout-widget-map-cache.service.ts

@@ -15,6 +15,8 @@ import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadat
 import { PageLayoutTabEntity } from 'src/engine/metadata-modules/page-layout-tab/entities/page-layout-tab.entity';
 import { PageLayoutWidgetEntity } from 'src/engine/metadata-modules/page-layout-widget/entities/page-layout-widget.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -23,20 +25,20 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatPageLayoutWidgetMaps')
 export class WorkspaceFlatPageLayoutWidgetMapCacheService extends WorkspaceCacheProvider<FlatPageLayoutWidgetMaps> {
   constructor(
-    @InjectRepository(PageLayoutWidgetEntity)
-    private readonly pageLayoutWidgetRepository: Repository<PageLayoutWidgetEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutWidgetEntity)
+    private readonly pageLayoutWidgetRepository: WorkspaceScopedRepository<PageLayoutWidgetEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(PageLayoutTabEntity)
-    private readonly pageLayoutTabRepository: Repository<PageLayoutTabEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutTabEntity)
+    private readonly pageLayoutTabRepository: WorkspaceScopedRepository<PageLayoutTabEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
     @InjectRepository(FrontComponentEntity)
     private readonly frontComponentRepository: Repository<FrontComponentEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {
     super();
   }
@@ -53,8 +55,7 @@ export class WorkspaceFlatPageLayoutWidgetMapCacheService extends WorkspaceCache
       frontComponents,
       views,
     ] = await Promise.all([
-      this.pageLayoutWidgetRepository.find({
-        where: { workspaceId },
+      this.pageLayoutWidgetRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -62,8 +63,7 @@ export class WorkspaceFlatPageLayoutWidgetMapCacheService extends WorkspaceCache
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.pageLayoutTabRepository.find({
-        where: { workspaceId },
+      this.pageLayoutTabRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
@@ -82,8 +82,7 @@ export class WorkspaceFlatPageLayoutWidgetMapCacheService extends WorkspaceCache
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

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

@@ -12,6 +12,8 @@ import { transformPageLayoutEntityToFlatPageLayout } from 'src/engine/metadata-m
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { PageLayoutTabEntity } from 'src/engine/metadata-modules/page-layout-tab/entities/page-layout-tab.entity';
 import { PageLayoutEntity } from 'src/engine/metadata-modules/page-layout/entities/page-layout.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -21,10 +23,10 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatPageLayoutMaps')
 export class WorkspaceFlatPageLayoutMapCacheService extends WorkspaceCacheProvider<FlatPageLayoutMaps> {
   constructor(
-    @InjectRepository(PageLayoutEntity)
-    private readonly pageLayoutRepository: Repository<PageLayoutEntity>,
-    @InjectRepository(PageLayoutTabEntity)
-    private readonly pageLayoutTabRepository: Repository<PageLayoutTabEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutEntity)
+    private readonly pageLayoutRepository: WorkspaceScopedRepository<PageLayoutEntity>,
+    @InjectWorkspaceScopedRepository(PageLayoutTabEntity)
+    private readonly pageLayoutTabRepository: WorkspaceScopedRepository<PageLayoutTabEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
@@ -36,12 +38,10 @@ export class WorkspaceFlatPageLayoutMapCacheService extends WorkspaceCacheProvid
   async computeForCache(workspaceId: string): Promise<FlatPageLayoutMaps> {
     const [pageLayouts, pageLayoutTabs, applications, objectMetadatas] =
       await Promise.all([
-        this.pageLayoutRepository.find({
-          where: { workspaceId },
+        this.pageLayoutRepository.find(workspaceId, {
           withDeleted: true,
         }),
-        this.pageLayoutTabRepository.find({
-          where: { workspaceId },
+        this.pageLayoutTabRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier', 'pageLayoutId'],
           withDeleted: true,
         }),

packages/twenty-server/src/engine/metadata-modules/flat-permission-flag/flat-permission-flag.module.ts

@@ -6,6 +6,7 @@ import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata
 import { WorkspaceFlatPermissionFlagMapCacheService } from 'src/engine/metadata-modules/flat-permission-flag/services/workspace-flat-permission-flag-map-cache.service';
 import { PermissionFlagEntity } from 'src/engine/metadata-modules/permission-flag/permission-flag.entity';
 import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [
@@ -16,7 +17,10 @@ import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permi
     ]),
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
   ],
-  providers: [WorkspaceFlatPermissionFlagMapCacheService],
+  providers: [
+    WorkspaceFlatPermissionFlagMapCacheService,
+    provideWorkspaceScopedRepository(PermissionFlagEntity),
+  ],
   exports: [WorkspaceFlatPermissionFlagMapCacheService],
 })
 export class FlatPermissionFlagModule {}

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

@@ -9,6 +9,8 @@ import { type FlatPermissionFlagMaps } from 'src/engine/metadata-modules/flat-pe
 import { fromPermissionFlagEntityToFlatPermissionFlag } from 'src/engine/metadata-modules/flat-permission-flag/utils/from-permission-flag-entity-to-flat-permission-flag.util';
 import { PermissionFlagEntity } from 'src/engine/metadata-modules/permission-flag/permission-flag.entity';
 import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
@@ -19,8 +21,8 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatPermissionFlagMaps')
 export class WorkspaceFlatPermissionFlagMapCacheService extends WorkspaceCacheProvider<FlatPermissionFlagMaps> {
   constructor(
-    @InjectRepository(PermissionFlagEntity)
-    private readonly permissionFlagRepository: Repository<PermissionFlagEntity>,
+    @InjectWorkspaceScopedRepository(PermissionFlagEntity)
+    private readonly permissionFlagRepository: WorkspaceScopedRepository<PermissionFlagEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(RolePermissionFlagEntity)
@@ -32,8 +34,7 @@ export class WorkspaceFlatPermissionFlagMapCacheService extends WorkspaceCachePr
   async computeForCache(workspaceId: string): Promise<FlatPermissionFlagMaps> {
     const [permissionFlags, applications, rolePermissionFlags] =
       await Promise.all([
-        this.permissionFlagRepository.find({
-          where: { workspaceId },
+        this.permissionFlagRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({

packages/twenty-server/src/engine/metadata-modules/flat-role-permission-flag/services/workspace-flat-role-permission-flag-map-cache.service.ts

@@ -10,6 +10,8 @@ import { fromRolePermissionFlagEntityToFlatRolePermissionFlag } from 'src/engine
 import { PermissionFlagEntity } from 'src/engine/metadata-modules/permission-flag/permission-flag.entity';
 import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permission-flag/role-permission-flag.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
@@ -23,10 +25,10 @@ export class WorkspaceFlatRolePermissionFlagMapCacheService extends WorkspaceCac
     private readonly rolePermissionFlagRepository: Repository<RolePermissionFlagEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
-    @InjectRepository(PermissionFlagEntity)
-    private readonly permissionFlagRepository: Repository<PermissionFlagEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(PermissionFlagEntity)
+    private readonly permissionFlagRepository: WorkspaceScopedRepository<PermissionFlagEntity>,
   ) {
     super();
   }
@@ -45,13 +47,11 @@ export class WorkspaceFlatRolePermissionFlagMapCacheService extends WorkspaceCac
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.roleRepository.find({
-          where: { workspaceId },
+        this.roleRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.permissionFlagRepository.find({
-          where: { workspaceId },
+        this.permissionFlagRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

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

@@ -11,6 +11,8 @@ import { type FlatRoleTargetMaps } from 'src/engine/metadata-modules/flat-role-t
 import { fromRoleTargetEntityToFlatRoleTarget } from 'src/engine/metadata-modules/flat-role-target/utils/from-role-target-entity-to-flat-role-target.util';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -19,20 +21,19 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatRoleTargetMaps')
 export class WorkspaceFlatRoleTargetMapCacheService extends WorkspaceCacheProvider<FlatRoleTargetMaps> {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
   ) {
     super();
   }
 
   async computeForCache(workspaceId: string): Promise<FlatRoleTargetMaps> {
     const [roleTargets, applications, roles] = await Promise.all([
-      this.roleTargetRepository.find({
-        where: { workspaceId },
+      this.roleTargetRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -40,8 +41,7 @@ export class WorkspaceFlatRoleTargetMapCacheService extends WorkspaceCacheProvid
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

packages/twenty-server/src/engine/metadata-modules/flat-row-level-permission-predicate/services/workspace-flat-row-level-permission-predicate-group-map-cache.service.ts

@@ -15,6 +15,8 @@ import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
 import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -24,16 +26,16 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatRowLevelPermissionPredicateGroupMaps')
 export class WorkspaceFlatRowLevelPermissionPredicateGroupMapCacheService extends WorkspaceCacheProvider<FlatRowLevelPermissionPredicateGroupMaps> {
   constructor(
-    @InjectRepository(RowLevelPermissionPredicateGroupEntity)
-    private readonly rowLevelPermissionPredicateGroupRepository: Repository<RowLevelPermissionPredicateGroupEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity)
+    private readonly rowLevelPermissionPredicateGroupRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateGroupEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
-    @InjectRepository(RowLevelPermissionPredicateEntity)
-    private readonly rowLevelPermissionPredicateRepository: Repository<RowLevelPermissionPredicateEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateEntity)
+    private readonly rowLevelPermissionPredicateRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateEntity>,
   ) {
     super();
   }
@@ -48,8 +50,7 @@ export class WorkspaceFlatRowLevelPermissionPredicateGroupMapCacheService extend
       roles,
       rowLevelPermissionPredicates,
     ] = await Promise.all([
-      this.rowLevelPermissionPredicateGroupRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateGroupRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -62,13 +63,11 @@ export class WorkspaceFlatRowLevelPermissionPredicateGroupMapCacheService extend
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.rowLevelPermissionPredicateRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateRepository.find(workspaceId, {
         select: [
           'id',
           'universalIdentifier',

packages/twenty-server/src/engine/metadata-modules/flat-row-level-permission-predicate/services/workspace-flat-row-level-permission-predicate-map-cache.service.ts

@@ -16,6 +16,8 @@ import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
 import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -24,18 +26,18 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatRowLevelPermissionPredicateMaps')
 export class WorkspaceFlatRowLevelPermissionPredicateMapCacheService extends WorkspaceCacheProvider<FlatRowLevelPermissionPredicateMaps> {
   constructor(
-    @InjectRepository(RowLevelPermissionPredicateEntity)
-    private readonly rowLevelPermissionPredicateRepository: Repository<RowLevelPermissionPredicateEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateEntity)
+    private readonly rowLevelPermissionPredicateRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
-    @InjectRepository(RowLevelPermissionPredicateGroupEntity)
-    private readonly rowLevelPermissionPredicateGroupRepository: Repository<RowLevelPermissionPredicateGroupEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity)
+    private readonly rowLevelPermissionPredicateGroupRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateGroupEntity>,
   ) {
     super();
   }
@@ -51,8 +53,7 @@ export class WorkspaceFlatRowLevelPermissionPredicateMapCacheService extends Wor
       roles,
       rowLevelPermissionPredicateGroups,
     ] = await Promise.all([
-      this.rowLevelPermissionPredicateRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -70,13 +71,11 @@ export class WorkspaceFlatRowLevelPermissionPredicateMapCacheService extends Wor
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.rowLevelPermissionPredicateGroupRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateGroupRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

packages/twenty-server/src/engine/metadata-modules/flat-skill/flat-skill.module.ts

@@ -5,13 +5,17 @@ import { ApplicationEntity } from 'src/engine/core-modules/application/applicati
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
 import { WorkspaceFlatSkillMapCacheService } from 'src/engine/metadata-modules/flat-skill/services/workspace-flat-skill-map-cache.service';
 import { SkillEntity } from 'src/engine/metadata-modules/skill/entities/skill.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([ApplicationEntity, SkillEntity]),
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
   ],
-  providers: [WorkspaceFlatSkillMapCacheService],
+  providers: [
+    WorkspaceFlatSkillMapCacheService,
+    provideWorkspaceScopedRepository(SkillEntity),
+  ],
   exports: [WorkspaceFlatSkillMapCacheService],
 })
 export class FlatSkillModule {}

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

@@ -10,6 +10,8 @@ import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-enti
 import { type FlatSkillMaps } from 'src/engine/metadata-modules/flat-skill/types/flat-skill-maps.type';
 import { fromSkillEntityToFlatSkill } from 'src/engine/metadata-modules/flat-skill/utils/from-skill-entity-to-flat-skill.util';
 import { SkillEntity } from 'src/engine/metadata-modules/skill/entities/skill.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -18,8 +20,8 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatSkillMaps')
 export class WorkspaceFlatSkillMapCacheService extends WorkspaceCacheProvider<FlatSkillMaps> {
   constructor(
-    @InjectRepository(SkillEntity)
-    private readonly skillRepository: Repository<SkillEntity>,
+    @InjectWorkspaceScopedRepository(SkillEntity)
+    private readonly skillRepository: WorkspaceScopedRepository<SkillEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
   ) {
@@ -28,8 +30,7 @@ export class WorkspaceFlatSkillMapCacheService extends WorkspaceCacheProvider<Fl
 
   async computeForCache(workspaceId: string): Promise<FlatSkillMaps> {
     const [skills, applications] = await Promise.all([
-      this.skillRepository.find({
-        where: { workspaceId },
+      this.skillRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({

packages/twenty-server/src/engine/metadata-modules/flat-view-field-group/services/workspace-flat-view-field-group-map-cache.service.ts

@@ -12,6 +12,8 @@ import { fromViewFieldGroupEntityToFlatViewFieldGroup } from 'src/engine/metadat
 import { ViewFieldGroupEntity } from 'src/engine/metadata-modules/view-field-group/entities/view-field-group.entity';
 import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -21,14 +23,14 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewFieldGroupMaps')
 export class WorkspaceFlatViewFieldGroupMapCacheService extends WorkspaceCacheProvider<FlatViewFieldGroupMaps> {
   constructor(
-    @InjectRepository(ViewFieldGroupEntity)
-    private readonly viewFieldGroupRepository: Repository<ViewFieldGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldGroupEntity)
+    private readonly viewFieldGroupRepository: WorkspaceScopedRepository<ViewFieldGroupEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
-    @InjectRepository(ViewFieldEntity)
-    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldEntity)
+    private readonly viewFieldRepository: WorkspaceScopedRepository<ViewFieldEntity>,
   ) {
     super();
   }
@@ -36,8 +38,7 @@ export class WorkspaceFlatViewFieldGroupMapCacheService extends WorkspaceCachePr
   async computeForCache(workspaceId: string): Promise<FlatViewFieldGroupMaps> {
     const [viewFieldGroups, applications, views, viewFields] =
       await Promise.all([
-        this.viewFieldGroupRepository.find({
-          where: { workspaceId },
+        this.viewFieldGroupRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -45,13 +46,11 @@ export class WorkspaceFlatViewFieldGroupMapCacheService extends WorkspaceCachePr
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewRepository.find({
-          where: { workspaceId },
+        this.viewRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewFieldRepository.find({
-          where: { workspaceId },
+        this.viewFieldRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier', 'viewFieldGroupId'],
           withDeleted: true,
         }),

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

@@ -13,6 +13,8 @@ import { fromViewFieldEntityToFlatViewField } from 'src/engine/metadata-modules/
 import { ViewFieldGroupEntity } from 'src/engine/metadata-modules/view-field-group/entities/view-field-group.entity';
 import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -21,16 +23,16 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewFieldMaps')
 export class WorkspaceFlatViewFieldMapCacheService extends WorkspaceCacheProvider<FlatViewFieldMaps> {
   constructor(
-    @InjectRepository(ViewFieldEntity)
-    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldEntity)
+    private readonly viewFieldRepository: WorkspaceScopedRepository<ViewFieldEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
-    @InjectRepository(ViewFieldGroupEntity)
-    private readonly viewFieldGroupRepository: Repository<ViewFieldGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldGroupEntity)
+    private readonly viewFieldGroupRepository: WorkspaceScopedRepository<ViewFieldGroupEntity>,
   ) {
     super();
   }
@@ -38,8 +40,7 @@ export class WorkspaceFlatViewFieldMapCacheService extends WorkspaceCacheProvide
   async computeForCache(workspaceId: string): Promise<FlatViewFieldMaps> {
     const [viewFields, applications, fieldMetadatas, views, viewFieldGroups] =
       await Promise.all([
-        this.viewFieldRepository.find({
-          where: { workspaceId },
+        this.viewFieldRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -52,13 +53,11 @@ export class WorkspaceFlatViewFieldMapCacheService extends WorkspaceCacheProvide
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewRepository.find({
-          where: { workspaceId },
+        this.viewRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewFieldGroupRepository.find({
-          where: { workspaceId },
+        this.viewFieldGroupRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

packages/twenty-server/src/engine/metadata-modules/flat-view-filter-group/services/workspace-flat-view-filter-group-map-cache.service.ts

@@ -12,6 +12,8 @@ import { fromViewFilterGroupEntityToFlatViewFilterGroup } from 'src/engine/metad
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -21,14 +23,14 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewFilterGroupMaps')
 export class WorkspaceFlatViewFilterGroupMapCacheService extends WorkspaceCacheProvider<FlatViewFilterGroupMaps> {
   constructor(
-    @InjectRepository(ViewFilterGroupEntity)
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterGroupEntity)
+    private readonly viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {
     super();
   }
@@ -36,8 +38,7 @@ export class WorkspaceFlatViewFilterGroupMapCacheService extends WorkspaceCacheP
   async computeForCache(workspaceId: string): Promise<FlatViewFilterGroupMaps> {
     const [viewFilterGroups, applications, viewFilters, views] =
       await Promise.all([
-        this.viewFilterGroupRepository.find({
-          where: { workspaceId },
+        this.viewFilterGroupRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -45,13 +46,11 @@ export class WorkspaceFlatViewFilterGroupMapCacheService extends WorkspaceCacheP
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewFilterRepository.find({
-          where: { workspaceId },
+        this.viewFilterRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier', 'viewFilterGroupId'],
           withDeleted: true,
         }),
-        this.viewRepository.find({
-          where: { workspaceId },
+        this.viewRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

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

@@ -13,6 +13,8 @@ import { fromViewFilterEntityToFlatViewFilter } from 'src/engine/metadata-module
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -21,16 +23,16 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewFilterMaps')
 export class WorkspaceFlatViewFilterMapCacheService extends WorkspaceCacheProvider<FlatViewFilterMaps> {
   constructor(
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(ViewFilterGroupEntity)
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterGroupEntity)
+    private readonly viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {
     super();
   }
@@ -38,8 +40,7 @@ export class WorkspaceFlatViewFilterMapCacheService extends WorkspaceCacheProvid
   async computeForCache(workspaceId: string): Promise<FlatViewFilterMaps> {
     const [viewFilters, applications, fieldMetadatas, viewFilterGroups, views] =
       await Promise.all([
-        this.viewFilterRepository.find({
-          where: { workspaceId },
+        this.viewFilterRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -52,13 +53,11 @@ export class WorkspaceFlatViewFilterMapCacheService extends WorkspaceCacheProvid
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewFilterGroupRepository.find({
-          where: { workspaceId },
+        this.viewFilterGroupRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewRepository.find({
-          where: { workspaceId },
+        this.viewRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

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

@@ -11,6 +11,8 @@ import { FlatViewGroupMaps } from 'src/engine/metadata-modules/flat-view-group/t
 import { fromViewGroupEntityToFlatViewGroup } from 'src/engine/metadata-modules/flat-view-group/utils/from-view-group-entity-to-flat-view-group.util';
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -19,20 +21,19 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewGroupMaps')
 export class WorkspaceFlatViewGroupMapCacheService extends WorkspaceCacheProvider<FlatViewGroupMaps> {
   constructor(
-    @InjectRepository(ViewGroupEntity)
-    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewGroupEntity)
+    private readonly viewGroupRepository: WorkspaceScopedRepository<ViewGroupEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {
     super();
   }
 
   async computeForCache(workspaceId: string): Promise<FlatViewGroupMaps> {
     const [viewGroups, applications, views] = await Promise.all([
-      this.viewGroupRepository.find({
-        where: { workspaceId },
+      this.viewGroupRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -40,8 +41,7 @@ export class WorkspaceFlatViewGroupMapCacheService extends WorkspaceCacheProvide
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),

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

@@ -5,6 +5,8 @@ import { Repository } from 'typeorm';
 
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { FlatViewSortMaps } from 'src/engine/metadata-modules/flat-view-sort/types/flat-view-sort-maps.type';
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
@@ -20,10 +22,10 @@ import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/uti
 @WorkspaceCache('flatViewSortMaps')
 export class WorkspaceFlatViewSortMapCacheService extends WorkspaceCacheProvider<FlatViewSortMaps> {
   constructor(
-    @InjectRepository(ViewSortEntity)
-    private readonly viewSortRepository: Repository<ViewSortEntity>,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewSortEntity)
+    private readonly viewSortRepository: WorkspaceScopedRepository<ViewSortEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(FieldMetadataEntity)
@@ -35,8 +37,7 @@ export class WorkspaceFlatViewSortMapCacheService extends WorkspaceCacheProvider
   async computeForCache(workspaceId: string): Promise<FlatViewSortMaps> {
     const [existingViewSorts, applications, views, fieldMetadatas] =
       await Promise.all([
-        this.viewSortRepository.find({
-          where: { workspaceId },
+        this.viewSortRepository.find(workspaceId, {
           withDeleted: true,
         }),
         this.applicationRepository.find({
@@ -44,8 +45,7 @@ export class WorkspaceFlatViewSortMapCacheService extends WorkspaceCacheProvider
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),
-        this.viewRepository.find({
-          where: { workspaceId },
+        this.viewRepository.find(workspaceId, {
           select: ['id', 'universalIdentifier'],
           withDeleted: true,
         }),

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

@@ -18,6 +18,8 @@ import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entiti
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -27,26 +29,26 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatViewMaps')
 export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<FlatViewMaps> {
   constructor(
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     @InjectRepository(FieldMetadataEntity)
     private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
-    @InjectRepository(ViewFieldEntity)
-    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
-    @InjectRepository(ViewGroupEntity)
-    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
-    @InjectRepository(ViewFilterGroupEntity)
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
-    @InjectRepository(ViewSortEntity)
-    private readonly viewSortRepository: Repository<ViewSortEntity>,
-    @InjectRepository(ViewFieldGroupEntity)
-    private readonly viewFieldGroupRepository: Repository<ViewFieldGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldEntity)
+    private readonly viewFieldRepository: WorkspaceScopedRepository<ViewFieldEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewGroupEntity)
+    private readonly viewGroupRepository: WorkspaceScopedRepository<ViewGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterGroupEntity)
+    private readonly viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewSortEntity)
+    private readonly viewSortRepository: WorkspaceScopedRepository<ViewSortEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldGroupEntity)
+    private readonly viewFieldGroupRepository: WorkspaceScopedRepository<ViewFieldGroupEntity>,
   ) {
     super();
   }
@@ -64,8 +66,7 @@ export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<Fla
       viewSorts,
       viewFieldGroups,
     ] = await Promise.all([
-      this.viewRepository.find({
-        where: { workspaceId },
+      this.viewRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -83,33 +84,27 @@ export class WorkspaceFlatViewMapCacheService extends WorkspaceCacheProvider<Fla
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.viewFieldRepository.find({
-        where: { workspaceId },
+      this.viewFieldRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),
-      this.viewFilterRepository.find({
-        where: { workspaceId },
+      this.viewFilterRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),
-      this.viewGroupRepository.find({
-        where: { workspaceId },
+      this.viewGroupRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),
-      this.viewFilterGroupRepository.find({
-        where: { workspaceId },
+      this.viewFilterGroupRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),
-      this.viewSortRepository.find({
-        where: { workspaceId },
+      this.viewSortRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),
-      this.viewFieldGroupRepository.find({
-        where: { workspaceId },
+      this.viewFieldGroupRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'viewId'],
         withDeleted: true,
       }),

packages/twenty-server/src/engine/metadata-modules/flat-webhook/flat-webhook.module.ts

@@ -5,13 +5,17 @@ import { ApplicationEntity } from 'src/engine/core-modules/application/applicati
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
 import { WorkspaceFlatWebhookMapCacheService } from 'src/engine/metadata-modules/flat-webhook/services/workspace-flat-webhook-map-cache.service';
 import { WebhookEntity } from 'src/engine/metadata-modules/webhook/entities/webhook.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([ApplicationEntity, WebhookEntity]),
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
   ],
-  providers: [WorkspaceFlatWebhookMapCacheService],
+  providers: [
+    WorkspaceFlatWebhookMapCacheService,
+    provideWorkspaceScopedRepository(WebhookEntity),
+  ],
   exports: [WorkspaceFlatWebhookMapCacheService],
 })
 export class FlatWebhookModule {}

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

@@ -10,6 +10,8 @@ import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-enti
 import { type FlatWebhookMaps } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook-maps.type';
 import { fromWebhookEntityToFlatWebhook } from 'src/engine/metadata-modules/flat-webhook/utils/from-webhook-entity-to-flat-webhook.util';
 import { WebhookEntity } from 'src/engine/metadata-modules/webhook/entities/webhook.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/workspace-manager/workspace-migration/utils/add-flat-entity-to-flat-entity-maps-through-mutation-or-throw.util';
@@ -18,8 +20,8 @@ import { addFlatEntityToFlatEntityMapsThroughMutationOrThrow } from 'src/engine/
 @WorkspaceCache('flatWebhookMaps')
 export class WorkspaceFlatWebhookMapCacheService extends WorkspaceCacheProvider<FlatWebhookMaps> {
   constructor(
-    @InjectRepository(WebhookEntity)
-    private readonly webhookRepository: Repository<WebhookEntity>,
+    @InjectWorkspaceScopedRepository(WebhookEntity)
+    private readonly webhookRepository: WorkspaceScopedRepository<WebhookEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
   ) {
@@ -28,8 +30,8 @@ export class WorkspaceFlatWebhookMapCacheService extends WorkspaceCacheProvider<
 
   async computeForCache(workspaceId: string): Promise<FlatWebhookMaps> {
     const [webhooks, applications] = await Promise.all([
-      this.webhookRepository.find({
-        where: { workspaceId, deletedAt: IsNull() },
+      this.webhookRepository.find(workspaceId, {
+        where: { deletedAt: IsNull() },
       }),
       this.applicationRepository.find({
         where: { workspaceId },

packages/twenty-server/src/engine/metadata-modules/permissions/__tests__/permissions.service.spec.ts

@@ -11,6 +11,7 @@ import { ApplicationEntity } from 'src/engine/core-modules/application/applicati
 import { PermissionsService } from 'src/engine/metadata-modules/permissions/permissions.service';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { getWorkspaceScopedRepositoryToken } from 'src/engine/twenty-orm/workspace-scoped-repository/get-workspace-scoped-repository-token.util';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 
 describe('PermissionsService', () => {
@@ -21,7 +22,7 @@ describe('PermissionsService', () => {
       providers: [
         PermissionsService,
         {
-          provide: getRepositoryToken(RoleEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleEntity),
           useValue: {},
         },
         {

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

@@ -32,6 +32,8 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     ApiKeyRoleService,
     PermissionsService,
     provideWorkspaceScopedRepository(ApiKeyEntity),
+    provideWorkspaceScopedRepository(RoleEntity),
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   exports: [PermissionsService, ApiKeyRoleService],
 })

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

@@ -25,6 +25,8 @@ import { type UserWorkspacePermissions } from 'src/engine/metadata-modules/permi
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
 import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 
 @Injectable()
@@ -33,8 +35,8 @@ export class PermissionsService {
     private readonly userRoleService: UserRoleService,
     private readonly workspaceCacheService: WorkspaceCacheService,
     private readonly apiKeyRoleService: ApiKeyRoleService,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
   ) {}
@@ -149,8 +151,8 @@ export class PermissionsService {
         workspaceId,
       );
 
-      const role = await this.roleRepository.findOne({
-        where: { id: roleId, workspaceId },
+      const role = await this.roleRepository.findOne(workspaceId, {
+        where: { id: roleId },
         relations: [
           'rolePermissionFlags',
           'rolePermissionFlags.permissionFlag',
@@ -205,8 +207,8 @@ export class PermissionsService {
 
       const applicationRoleId = application.defaultRoleId;
 
-      const role = await this.roleRepository.findOne({
-        where: { id: applicationRoleId, workspaceId },
+      const role = await this.roleRepository.findOne(workspaceId, {
+        where: { id: applicationRoleId },
         relations: [
           'rolePermissionFlags',
           'rolePermissionFlags.permissionFlag',
@@ -289,8 +291,8 @@ export class PermissionsService {
       throw new Error('No role IDs provided');
     }
 
-    const roles = await this.roleRepository.find({
-      where: { id: In(roleIds), workspaceId },
+    const roles = await this.roleRepository.find(workspaceId, {
+      where: { id: In(roleIds) },
       relations,
     });
 

packages/twenty-server/src/engine/metadata-modules/role-target/role-target.module.ts

@@ -6,6 +6,7 @@ import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { WorkspaceApiKeyRoleMapCacheService } from 'src/engine/metadata-modules/role-target/services/workspace-api-key-role-map-cache.service';
 import { WorkspaceUserWorkspaceRoleMapCacheService } from 'src/engine/metadata-modules/role-target/services/workspace-user-workspace-role-map-cache.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
 import { RoleTargetService } from './services/role-target.service';
@@ -21,6 +22,7 @@ import { RoleTargetService } from './services/role-target.service';
     RoleTargetService,
     WorkspaceUserWorkspaceRoleMapCacheService,
     WorkspaceApiKeyRoleMapCacheService,
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   exports: [RoleTargetService],
 })

packages/twenty-server/src/engine/metadata-modules/role-target/services/workspace-api-key-role-map-cache.service.ts

@@ -1,11 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { IsNull, Not, Repository } from 'typeorm';
+import { IsNull, Not } from 'typeorm';
 
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 
 @Injectable()
@@ -14,16 +15,15 @@ export class WorkspaceApiKeyRoleMapCacheService extends WorkspaceCacheProvider<
   Record<string, string>
 > {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
   ) {
     super();
   }
 
   async computeForCache(workspaceId: string): Promise<Record<string, string>> {
-    const roleTargetsMap = await this.roleTargetRepository.find({
+    const roleTargetsMap = await this.roleTargetRepository.find(workspaceId, {
       where: {
-        workspaceId,
         apiKeyId: Not(IsNull()),
       },
     });

packages/twenty-server/src/engine/metadata-modules/role-target/services/workspace-user-workspace-role-map-cache.service.ts

@@ -1,29 +1,29 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { IsNull, Not, Repository } from 'typeorm';
+import { IsNull, Not } from 'typeorm';
 
 import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
 
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 
 @Injectable()
 @WorkspaceCache('userWorkspaceRoleMap')
 export class WorkspaceUserWorkspaceRoleMapCacheService extends WorkspaceCacheProvider<UserWorkspaceRoleMap> {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
   ) {
     super();
   }
 
   async computeForCache(workspaceId: string): Promise<UserWorkspaceRoleMap> {
-    const roleTargetsMap = await this.roleTargetRepository.find({
+    const roleTargetsMap = await this.roleTargetRepository.find(workspaceId, {
       where: {
-        workspaceId,
         userWorkspaceId: Not(IsNull()),
       },
     });

packages/twenty-server/src/engine/metadata-modules/role-validation/role-validation.module.ts

@@ -3,10 +3,14 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleValidationService } from 'src/engine/metadata-modules/role-validation/services/role-validation.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 
 @Module({
   imports: [TypeOrmModule.forFeature([RoleEntity])],
-  providers: [RoleValidationService],
+  providers: [
+    RoleValidationService,
+    provideWorkspaceScopedRepository(RoleEntity),
+  ],
   exports: [RoleValidationService],
 })
 export class RoleValidationModule {}

packages/twenty-server/src/engine/metadata-modules/role-validation/services/role-validation.service.ts

@@ -1,7 +1,4 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { Repository } from 'typeorm';
 
 import {
   PermissionsException,
@@ -9,22 +6,23 @@ import {
   PermissionsExceptionMessage,
 } from 'src/engine/metadata-modules/permissions/permissions.exception';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 
 @Injectable()
 export class RoleValidationService {
   constructor(
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
   ) {}
 
   async validateRoleAssignableToUsersOrThrow(
     roleId: string,
     workspaceId: string,
   ): Promise<void> {
-    const role = await this.roleRepository.findOne({
+    const role = await this.roleRepository.findOne(workspaceId, {
       where: {
         id: roleId,
-        workspaceId,
       },
     });
 

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

@@ -28,6 +28,7 @@ import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modu
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
 import { RowLevelPermissionModule } from 'src/engine/metadata-modules/row-level-permission-predicate/row-level-permission.module';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 import { WorkspaceMigrationGraphqlApiExceptionInterceptor } from 'src/engine/workspace-manager/workspace-migration/interceptors/workspace-migration-graphql-api-exception.interceptor';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -69,6 +70,12 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     WorkspaceFlatRoleTargetMapCacheService,
     WorkspaceMigrationGraphqlApiExceptionInterceptor,
     WorkspaceRolesPermissionsCacheService,
+    provideWorkspaceScopedRepository(RoleEntity),
+    provideWorkspaceScopedRepository(RoleTargetEntity),
+    provideWorkspaceScopedRepository(ObjectPermissionEntity),
+    provideWorkspaceScopedRepository(FieldPermissionEntity),
+    provideWorkspaceScopedRepository(RowLevelPermissionPredicateEntity),
+    provideWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity),
   ],
   exports: [
     RoleService,

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

@@ -36,6 +36,8 @@ import { type UpdateRoleInput } from 'src/engine/metadata-modules/role/dtos/upda
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { fromFlatRoleToRoleDto } from 'src/engine/metadata-modules/role/utils/fromFlatRoleToRoleDto.util';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
@@ -46,8 +48,8 @@ export class RoleService {
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     private readonly userRoleService: UserRoleService,
     private readonly applicationService: ApplicationService,
     private readonly apiKeyRoleService: ApiKeyRoleService,
@@ -55,10 +57,7 @@ export class RoleService {
   ) {}
 
   public async getWorkspaceRoles(workspaceId: string): Promise<RoleEntity[]> {
-    return this.roleRepository.find({
-      where: {
-        workspaceId,
-      },
+    return this.roleRepository.find(workspaceId, {
       relations: {
         roleTargets: true,
         rolePermissionFlags: {
@@ -74,10 +73,9 @@ export class RoleService {
     id: string,
     workspaceId: string,
   ): Promise<RoleEntity | null> {
-    return this.roleRepository.findOne({
+    return this.roleRepository.findOne(workspaceId, {
       where: {
         id,
-        workspaceId,
       },
       relations: {
         roleTargets: true,

packages/twenty-server/src/engine/metadata-modules/role/services/__tests__/workspace-roles-permissions-cache.service.spec.ts

@@ -16,6 +16,8 @@ import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { WorkspaceRolesPermissionsCacheService } from 'src/engine/metadata-modules/role/services/workspace-roles-permissions-cache.service';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
+import { getWorkspaceScopedRepositoryToken } from 'src/engine/twenty-orm/workspace-scoped-repository/get-workspace-scoped-repository-token.util';
+import { type WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 
 const WORKSPACE_ID = '20202020-0000-4000-8000-000000000000';
 const ROLE_ID = '11111111-1111-4111-8111-111111111111';
@@ -52,12 +54,14 @@ const createBaseRole = (
 
 describe('WorkspaceRolesPermissionsCacheService', () => {
   let service: WorkspaceRolesPermissionsCacheService;
-  let roleRepository: jest.Mocked<Pick<Repository<RoleEntity>, 'find'>>;
+  let roleRepository: jest.Mocked<
+    Pick<WorkspaceScopedRepository<RoleEntity>, 'find'>
+  >;
   let objectMetadataRepository: jest.Mocked<
     Pick<Repository<ObjectMetadataEntity>, 'find'>
   >;
   let objectPermissionRepository: jest.Mocked<
-    Pick<Repository<ObjectPermissionEntity>, 'find'>
+    Pick<WorkspaceScopedRepository<ObjectPermissionEntity>, 'find'>
   >;
   let rolePermissionFlagRepository: jest.Mocked<
     Pick<Repository<RolePermissionFlagEntity>, 'find'>
@@ -118,11 +122,11 @@ describe('WorkspaceRolesPermissionsCacheService', () => {
           useValue: objectMetadataRepository,
         },
         {
-          provide: getRepositoryToken(RoleEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleEntity),
           useValue: roleRepository,
         },
         {
-          provide: getRepositoryToken(ObjectPermissionEntity),
+          provide: getWorkspaceScopedRepositoryToken(ObjectPermissionEntity),
           useValue: objectPermissionRepository,
         },
         {
@@ -130,15 +134,19 @@ describe('WorkspaceRolesPermissionsCacheService', () => {
           useValue: rolePermissionFlagRepository,
         },
         {
-          provide: getRepositoryToken(FieldPermissionEntity),
+          provide: getWorkspaceScopedRepositoryToken(FieldPermissionEntity),
           useValue: fieldPermissionRepository,
         },
         {
-          provide: getRepositoryToken(RowLevelPermissionPredicateEntity),
+          provide: getWorkspaceScopedRepositoryToken(
+            RowLevelPermissionPredicateEntity,
+          ),
           useValue: rowLevelPermissionPredicateRepository,
         },
         {
-          provide: getRepositoryToken(RowLevelPermissionPredicateGroupEntity),
+          provide: getWorkspaceScopedRepositoryToken(
+            RowLevelPermissionPredicateGroupEntity,
+          ),
           useValue: rowLevelPermissionPredicateGroupRepository,
         },
       ],

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

@@ -17,6 +17,8 @@ import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-t
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { createIdToUniversalIdentifierMap } from 'src/engine/workspace-cache/utils/create-id-to-universal-identifier-map.util';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
@@ -28,22 +30,22 @@ export class WorkspaceFlatRoleMapCacheService extends WorkspaceCacheProvider<
   FlatEntityMaps<FlatRole>
 > {
   constructor(
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
-    @InjectRepository(ObjectPermissionEntity)
-    private readonly objectPermissionRepository: Repository<ObjectPermissionEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(ObjectPermissionEntity)
+    private readonly objectPermissionRepository: WorkspaceScopedRepository<ObjectPermissionEntity>,
     @InjectRepository(RolePermissionFlagEntity)
     private readonly rolePermissionFlagRepository: Repository<RolePermissionFlagEntity>,
-    @InjectRepository(FieldPermissionEntity)
-    private readonly fieldPermissionRepository: Repository<FieldPermissionEntity>,
-    @InjectRepository(RowLevelPermissionPredicateEntity)
-    private readonly rowLevelPermissionPredicateRepository: Repository<RowLevelPermissionPredicateEntity>,
-    @InjectRepository(RowLevelPermissionPredicateGroupEntity)
-    private readonly rowLevelPermissionPredicateGroupRepository: Repository<RowLevelPermissionPredicateGroupEntity>,
+    @InjectWorkspaceScopedRepository(FieldPermissionEntity)
+    private readonly fieldPermissionRepository: WorkspaceScopedRepository<FieldPermissionEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateEntity)
+    private readonly rowLevelPermissionPredicateRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity)
+    private readonly rowLevelPermissionPredicateGroupRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateGroupEntity>,
   ) {
     super();
   }
@@ -61,8 +63,7 @@ export class WorkspaceFlatRoleMapCacheService extends WorkspaceCacheProvider<
       rowLevelPermissionPredicates,
       rowLevelPermissionPredicateGroups,
     ] = await Promise.all([
-      this.roleRepository.find({
-        where: { workspaceId },
+      this.roleRepository.find(workspaceId, {
         withDeleted: true,
       }),
       this.applicationRepository.find({
@@ -70,13 +71,11 @@ export class WorkspaceFlatRoleMapCacheService extends WorkspaceCacheProvider<
         select: ['id', 'universalIdentifier'],
         withDeleted: true,
       }),
-      this.roleTargetRepository.find({
-        where: { workspaceId },
+      this.roleTargetRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),
-      this.objectPermissionRepository.find({
-        where: { workspaceId },
+      this.objectPermissionRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),
@@ -85,18 +84,15 @@ export class WorkspaceFlatRoleMapCacheService extends WorkspaceCacheProvider<
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),
-      this.fieldPermissionRepository.find({
-        where: { workspaceId },
+      this.fieldPermissionRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),
-      this.rowLevelPermissionPredicateRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),
-      this.rowLevelPermissionPredicateGroupRepository.find({
-        where: { workspaceId },
+      this.rowLevelPermissionPredicateGroupRepository.find(workspaceId, {
         select: ['id', 'universalIdentifier', 'roleId'],
         withDeleted: true,
       }),

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

@@ -23,6 +23,8 @@ import { RolePermissionFlagEntity } from 'src/engine/metadata-modules/role-permi
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
 import { regroupEntitiesByRelatedEntityId } from 'src/engine/workspace-cache/utils/regroup-entities-by-related-entity-id';
 
@@ -40,18 +42,18 @@ export class WorkspaceRolesPermissionsCacheService extends WorkspaceCacheProvide
   constructor(
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
-    @InjectRepository(ObjectPermissionEntity)
-    private readonly objectPermissionRepository: Repository<ObjectPermissionEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(ObjectPermissionEntity)
+    private readonly objectPermissionRepository: WorkspaceScopedRepository<ObjectPermissionEntity>,
     @InjectRepository(RolePermissionFlagEntity)
     private readonly rolePermissionFlagRepository: Repository<RolePermissionFlagEntity>,
-    @InjectRepository(FieldPermissionEntity)
-    private readonly fieldPermissionRepository: Repository<FieldPermissionEntity>,
-    @InjectRepository(RowLevelPermissionPredicateEntity)
-    private readonly rowLevelPermissionPredicateRepository: Repository<RowLevelPermissionPredicateEntity>,
-    @InjectRepository(RowLevelPermissionPredicateGroupEntity)
-    private readonly rowLevelPermissionPredicateGroupRepository: Repository<RowLevelPermissionPredicateGroupEntity>,
+    @InjectWorkspaceScopedRepository(FieldPermissionEntity)
+    private readonly fieldPermissionRepository: WorkspaceScopedRepository<FieldPermissionEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateEntity)
+    private readonly rowLevelPermissionPredicateRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity)
+    private readonly rowLevelPermissionPredicateGroupRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateGroupEntity>,
   ) {
     super();
   }
@@ -68,24 +70,18 @@ export class WorkspaceRolesPermissionsCacheService extends WorkspaceCacheProvide
       rowLevelPermissionPredicateGroups,
       workspaceObjectMetadataCollection,
     ] = await Promise.all([
-      this.roleRepository.find({
-        where: { workspaceId },
-      }),
-      this.objectPermissionRepository.find({
-        where: { workspaceId },
-      }),
+      this.roleRepository.find(workspaceId),
+      this.objectPermissionRepository.find(workspaceId),
       this.rolePermissionFlagRepository.find({
         where: { workspaceId },
         relations: ['permissionFlag'],
       }),
-      this.fieldPermissionRepository.find({
-        where: { workspaceId },
+      this.fieldPermissionRepository.find(workspaceId),
+      this.rowLevelPermissionPredicateRepository.find(workspaceId, {
+        where: { deletedAt: IsNull() },
       }),
-      this.rowLevelPermissionPredicateRepository.find({
-        where: { workspaceId, deletedAt: IsNull() },
-      }),
-      this.rowLevelPermissionPredicateGroupRepository.find({
-        where: { workspaceId, deletedAt: IsNull() },
+      this.rowLevelPermissionPredicateGroupRepository.find(workspaceId, {
+        where: { deletedAt: IsNull() },
       }),
       this.getWorkspaceObjectMetadataCollection(workspaceId),
     ]);

packages/twenty-server/src/engine/metadata-modules/row-level-permission-predicate/row-level-permission.module.ts

@@ -11,6 +11,7 @@ import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modu
 import { RowLevelPermissionPredicateEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate.entity';
 import { RowLevelPermissionPredicateGroupService } from 'src/engine/metadata-modules/row-level-permission-predicate/services/row-level-permission-predicate-group.service';
 import { RowLevelPermissionPredicateService } from 'src/engine/metadata-modules/row-level-permission-predicate/services/row-level-permission-predicate.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -30,6 +31,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
   providers: [
     RowLevelPermissionPredicateService,
     RowLevelPermissionPredicateGroupService,
+    provideWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity),
   ],
   exports: [
     RowLevelPermissionPredicateService,

packages/twenty-server/src/engine/metadata-modules/row-level-permission-predicate/services/row-level-permission-predicate-group.service.ts

@@ -1,10 +1,8 @@
 /* @license Enterprise */
 
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
 import { BillingEntitlementKey } from 'src/engine/core-modules/billing/enums/billing-entitlement-key.enum';
 import { BillingService } from 'src/engine/core-modules/billing/services/billing.service';
@@ -14,6 +12,8 @@ import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/
 import { fromFlatRowLevelPermissionPredicateGroupToDto } from 'src/engine/metadata-modules/flat-row-level-permission-predicate/utils/from-flat-row-level-permission-predicate-group-to-dto.util';
 import { RowLevelPermissionPredicateGroupDTO } from 'src/engine/metadata-modules/row-level-permission-predicate/dtos/row-level-permission-predicate-group.dto';
 import { RowLevelPermissionPredicateGroupEntity } from 'src/engine/metadata-modules/row-level-permission-predicate/entities/row-level-permission-predicate-group.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 
 @Injectable()
@@ -22,8 +22,8 @@ export class RowLevelPermissionPredicateGroupService {
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly workspaceCacheService: WorkspaceCacheService,
     private readonly billingService: BillingService,
-    @InjectRepository(RowLevelPermissionPredicateGroupEntity)
-    private readonly rowLevelPermissionPredicateGroupRepository: Repository<RowLevelPermissionPredicateGroupEntity>,
+    @InjectWorkspaceScopedRepository(RowLevelPermissionPredicateGroupEntity)
+    private readonly rowLevelPermissionPredicateGroupRepository: WorkspaceScopedRepository<RowLevelPermissionPredicateGroupEntity>,
     private readonly enterprisePlanService: EnterprisePlanService,
   ) {}
 
@@ -122,9 +122,10 @@ export class RowLevelPermissionPredicateGroupService {
   }
 
   public async deleteAllRowLevelPermissionPredicateGroups(workspaceId: string) {
-    await this.rowLevelPermissionPredicateGroupRepository.delete({
+    await this.rowLevelPermissionPredicateGroupRepository.delete(
       workspaceId,
-    });
+      {},
+    );
 
     await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [
       'rolesPermissions',

packages/twenty-server/src/engine/metadata-modules/user-role/user-role.module.ts

@@ -6,6 +6,7 @@ import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-t
 import { RoleTargetModule } from 'src/engine/metadata-modules/role-target/role-target.module';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 
 @Module({
@@ -15,7 +16,10 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     WorkspaceCacheModule,
     RoleTargetModule,
   ],
-  providers: [UserRoleService],
+  providers: [
+    UserRoleService,
+    provideWorkspaceScopedRepository(RoleTargetEntity),
+  ],
   exports: [UserRoleService],
 })
 export class UserRoleModule {}

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

@@ -15,14 +15,16 @@ import { RoleTargetService } from 'src/engine/metadata-modules/role-target/servi
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
 import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
 
 export class UserRoleService {
   constructor(
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     @InjectRepository(UserWorkspaceEntity)
     private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
     private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
@@ -101,10 +103,9 @@ export class UserRoleService {
       return new Map();
     }
 
-    const allRoleTargets = await this.roleTargetRepository.find({
+    const allRoleTargets = await this.roleTargetRepository.find(workspaceId, {
       where: {
         userWorkspaceId: In(userWorkspaceIds),
-        workspaceId,
       },
       relations: {
         role: {

packages/twenty-server/src/engine/metadata-modules/view-field-group/services/fields-widget-upsert.service.ts

@@ -1,12 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { t } from '@lingui/core/macro';
 import {
   isDefined,
   isFieldMetadataEligibleForFieldsWidget,
 } from 'twenty-shared/utils';
-import { IsNull, Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 import { v4 } from 'uuid';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
@@ -36,6 +35,8 @@ import {
   ViewFieldGroupExceptionCode,
 } from 'src/engine/metadata-modules/view-field-group/exceptions/view-field-group.exception';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
@@ -45,8 +46,8 @@ export class FieldsWidgetUpsertService {
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {}
 
   async upsertFieldsWidget({
@@ -181,8 +182,8 @@ export class FieldsWidgetUpsertService {
       });
     }
 
-    const view = await this.viewRepository.findOne({
-      where: { id: viewId, workspaceId, deletedAt: IsNull() },
+    const view = await this.viewRepository.findOne(workspaceId, {
+      where: { id: viewId, deletedAt: IsNull() },
     });
 
     if (!isDefined(view)) {

packages/twenty-server/src/engine/metadata-modules/view-field-group/view-field-group.module.ts

@@ -9,6 +9,7 @@ import { ViewFieldGroupResolver } from 'src/engine/metadata-modules/view-field-g
 import { FieldsWidgetUpsertService } from 'src/engine/metadata-modules/view-field-group/services/fields-widget-upsert.service';
 import { ViewFieldGroupService } from 'src/engine/metadata-modules/view-field-group/services/view-field-group.service';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -25,6 +26,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     ViewFieldGroupResolver,
     ViewFieldGroupService,
     FieldsWidgetUpsertService,
+    provideWorkspaceScopedRepository(ViewEntity),
   ],
   exports: [ViewFieldGroupService],
 })

packages/twenty-server/src/engine/metadata-modules/view-filter-group/services/tests/view-filter-group.service.spec.ts

@@ -1,18 +1,18 @@
 import { Test, type TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
 
-import { type Repository } from 'typeorm';
 import { ViewFilterGroupLogicalOperator } from 'twenty-shared/types';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { ViewFilterGroupService } from 'src/engine/metadata-modules/view-filter-group/services/view-filter-group.service';
+import { getWorkspaceScopedRepositoryToken } from 'src/engine/twenty-orm/workspace-scoped-repository/get-workspace-scoped-repository-token.util';
+import { type WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 describe('ViewFilterGroupService', () => {
   let viewFilterGroupService: ViewFilterGroupService;
-  let viewFilterGroupRepository: Repository<ViewFilterGroupEntity>;
+  let viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>;
 
   const mockViewFilterGroup = {
     id: 'view-filter-group-id',
@@ -30,13 +30,11 @@ describe('ViewFilterGroupService', () => {
       providers: [
         ViewFilterGroupService,
         {
-          provide: getRepositoryToken(ViewFilterGroupEntity),
+          provide: getWorkspaceScopedRepositoryToken(ViewFilterGroupEntity),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
-            create: jest.fn(),
             save: jest.fn(),
-            softDelete: jest.fn(),
             delete: jest.fn(),
           },
         },
@@ -65,9 +63,9 @@ describe('ViewFilterGroupService', () => {
     viewFilterGroupService = module.get<ViewFilterGroupService>(
       ViewFilterGroupService,
     );
-    viewFilterGroupRepository = module.get<Repository<ViewFilterGroupEntity>>(
-      getRepositoryToken(ViewFilterGroupEntity),
-    );
+    viewFilterGroupRepository = module.get<
+      WorkspaceScopedRepository<ViewFilterGroupEntity>
+    >(getWorkspaceScopedRepositoryToken(ViewFilterGroupEntity));
   });
 
   it('should be defined', () => {
@@ -86,9 +84,8 @@ describe('ViewFilterGroupService', () => {
       const result =
         await viewFilterGroupService.findByWorkspaceId(workspaceId);
 
-      expect(viewFilterGroupRepository.find).toHaveBeenCalledWith({
+      expect(viewFilterGroupRepository.find).toHaveBeenCalledWith(workspaceId, {
         where: {
-          workspaceId,
           deletedAt: expect.anything(),
         },
         order: { positionInViewFilterGroup: 'ASC' },
@@ -119,9 +116,8 @@ describe('ViewFilterGroupService', () => {
         viewId,
       );
 
-      expect(viewFilterGroupRepository.find).toHaveBeenCalledWith({
+      expect(viewFilterGroupRepository.find).toHaveBeenCalledWith(workspaceId, {
         where: {
-          workspaceId,
           viewId,
           deletedAt: expect.anything(),
         },
@@ -149,20 +145,22 @@ describe('ViewFilterGroupService', () => {
 
       const result = await viewFilterGroupService.findById(id, workspaceId);
 
-      expect(viewFilterGroupRepository.findOne).toHaveBeenCalledWith({
-        where: {
-          id,
-          workspaceId,
-          deletedAt: expect.anything(),
+      expect(viewFilterGroupRepository.findOne).toHaveBeenCalledWith(
+        workspaceId,
+        {
+          where: {
+            id,
+            deletedAt: expect.anything(),
+          },
+          relations: [
+            'workspace',
+            'view',
+            'viewFilters',
+            'parentViewFilterGroup',
+            'childViewFilterGroups',
+          ],
         },
-        relations: [
-          'workspace',
-          'view',
-          'viewFilters',
-          'parentViewFilterGroup',
-          'childViewFilterGroups',
-        ],
-      });
+      );
       expect(result).toEqual(mockViewFilterGroup);
     });
 

packages/twenty-server/src/engine/metadata-modules/view-filter-group/services/view-filter-group.service.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { IsNull, type Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
@@ -18,14 +17,16 @@ import { type UpdateViewFilterGroupInput } from 'src/engine/metadata-modules/vie
 import { type ViewFilterGroupDTO } from 'src/engine/metadata-modules/view-filter-group/dtos/view-filter-group.dto';
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
 import { fromFlatViewFilterGroupToViewFilterGroupDto } from 'src/engine/metadata-modules/view-filter-group/utils/from-flat-view-filter-group-to-view-filter-group-dto.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewFilterGroupService {
   constructor(
-    @InjectRepository(ViewFilterGroupEntity)
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterGroupEntity)
+    private readonly viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
@@ -320,9 +321,8 @@ export class ViewFilterGroupService {
   async findByWorkspaceId(
     workspaceId: string,
   ): Promise<ViewFilterGroupEntity[]> {
-    return this.viewFilterGroupRepository.find({
+    return this.viewFilterGroupRepository.find(workspaceId, {
       where: {
-        workspaceId,
         deletedAt: IsNull(),
       },
       order: { positionInViewFilterGroup: 'ASC' },
@@ -340,9 +340,8 @@ export class ViewFilterGroupService {
     workspaceId: string,
     viewId: string,
   ): Promise<ViewFilterGroupEntity[]> {
-    return this.viewFilterGroupRepository.find({
+    return this.viewFilterGroupRepository.find(workspaceId, {
       where: {
-        workspaceId,
         viewId,
         deletedAt: IsNull(),
       },
@@ -361,20 +360,22 @@ export class ViewFilterGroupService {
     id: string,
     workspaceId: string,
   ): Promise<ViewFilterGroupEntity | null> {
-    const viewFilterGroup = await this.viewFilterGroupRepository.findOne({
-      where: {
-        id,
-        workspaceId,
-        deletedAt: IsNull(),
+    const viewFilterGroup = await this.viewFilterGroupRepository.findOne(
+      workspaceId,
+      {
+        where: {
+          id,
+          deletedAt: IsNull(),
+        },
+        relations: [
+          'workspace',
+          'view',
+          'viewFilters',
+          'parentViewFilterGroup',
+          'childViewFilterGroups',
+        ],
       },
-      relations: [
-        'workspace',
-        'view',
-        'viewFilters',
-        'parentViewFilterGroup',
-        'childViewFilterGroups',
-      ],
-    });
+    );
 
     return viewFilterGroup || null;
   }

packages/twenty-server/src/engine/metadata-modules/view-filter-group/view-filter-group.module.ts

@@ -10,6 +10,7 @@ import { ViewFilterGroupResolver } from 'src/engine/metadata-modules/view-filter
 import { ViewFilterGroupService } from 'src/engine/metadata-modules/view-filter-group/services/view-filter-group.service';
 import { ViewPermissionsModule } from 'src/engine/metadata-modules/view-permissions/view-permissions.module';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -24,7 +25,11 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     ViewPermissionsModule,
   ],
   controllers: [ViewFilterGroupController],
-  providers: [ViewFilterGroupService, ViewFilterGroupResolver],
+  providers: [
+    ViewFilterGroupService,
+    ViewFilterGroupResolver,
+    provideWorkspaceScopedRepository(ViewFilterGroupEntity),
+  ],
   exports: [ViewFilterGroupService],
 })
 export class ViewFilterGroupModule {}

packages/twenty-server/src/engine/metadata-modules/view-filter/services/view-filter.service.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { IsNull, Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
@@ -18,14 +17,16 @@ import { UpdateViewFilterInput } from 'src/engine/metadata-modules/view-filter/d
 import { ViewFilterDTO } from 'src/engine/metadata-modules/view-filter/dtos/view-filter.dto';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { fromFlatViewFilterToViewFilterDto } from 'src/engine/metadata-modules/view-filter/utils/from-flat-view-filter-to-view-filter-dto.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewFilterService {
   constructor(
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
@@ -319,9 +320,8 @@ export class ViewFilterService {
   }
 
   async findByWorkspaceId(workspaceId: string): Promise<ViewFilterEntity[]> {
-    return this.viewFilterRepository.find({
+    return this.viewFilterRepository.find(workspaceId, {
       where: {
-        workspaceId,
         deletedAt: IsNull(),
       },
       order: { positionInViewFilterGroup: 'ASC' },
@@ -333,9 +333,8 @@ export class ViewFilterService {
     workspaceId: string,
     viewId: string,
   ): Promise<ViewFilterEntity[]> {
-    return this.viewFilterRepository.find({
+    return this.viewFilterRepository.find(workspaceId, {
       where: {
-        workspaceId,
         viewId,
         deletedAt: IsNull(),
       },
@@ -348,10 +347,9 @@ export class ViewFilterService {
     id: string,
     workspaceId: string,
   ): Promise<ViewFilterEntity | null> {
-    const viewFilter = await this.viewFilterRepository.findOne({
+    const viewFilter = await this.viewFilterRepository.findOne(workspaceId, {
       where: {
         id,
-        workspaceId,
         deletedAt: IsNull(),
       },
       relations: ['workspace', 'view', 'viewFilterGroup'],

packages/twenty-server/src/engine/metadata-modules/view-filter/view-filter.module.ts

@@ -11,6 +11,7 @@ import { ViewFilterService } from 'src/engine/metadata-modules/view-filter/servi
 import { ViewFilterToolsFactory } from 'src/engine/metadata-modules/view-filter/tools/view-filter-tools.factory';
 import { ViewPermissionsModule } from 'src/engine/metadata-modules/view-permissions/view-permissions.module';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -25,7 +26,12 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     ViewPermissionsModule,
   ],
   controllers: [ViewFilterController],
-  providers: [ViewFilterService, ViewFilterResolver, ViewFilterToolsFactory],
+  providers: [
+    ViewFilterService,
+    ViewFilterResolver,
+    ViewFilterToolsFactory,
+    provideWorkspaceScopedRepository(ViewFilterEntity),
+  ],
   exports: [ViewFilterService, ViewFilterToolsFactory],
 })
 export class ViewFilterModule {}

packages/twenty-server/src/engine/metadata-modules/view-group/services/view-group.service.ts

@@ -1,8 +1,7 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { IsNull, Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
@@ -25,14 +24,16 @@ import {
   ViewGroupExceptionCode,
 } from 'src/engine/metadata-modules/view-group/exceptions/view-group.exception';
 import { fromFlatViewGroupToViewGroupDto } from 'src/engine/metadata-modules/view-group/utils/from-flat-view-group-to-view-group-dto.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewGroupService {
   constructor(
-    @InjectRepository(ViewGroupEntity)
-    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewGroupEntity)
+    private readonly viewGroupRepository: WorkspaceScopedRepository<ViewGroupEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
@@ -379,9 +380,8 @@ export class ViewGroupService {
   }
 
   async findByWorkspaceId(workspaceId: string): Promise<ViewGroupEntity[]> {
-    return this.viewGroupRepository.find({
+    return this.viewGroupRepository.find(workspaceId, {
       where: {
-        workspaceId,
         deletedAt: IsNull(),
       },
       order: { position: 'ASC' },
@@ -393,9 +393,8 @@ export class ViewGroupService {
     workspaceId: string,
     viewId: string,
   ): Promise<ViewGroupEntity[]> {
-    return this.viewGroupRepository.find({
+    return this.viewGroupRepository.find(workspaceId, {
       where: {
-        workspaceId,
         viewId,
         deletedAt: IsNull(),
       },
@@ -408,10 +407,9 @@ export class ViewGroupService {
     id: string,
     workspaceId: string,
   ): Promise<ViewGroupEntity | null> {
-    const viewGroup = await this.viewGroupRepository.findOne({
+    const viewGroup = await this.viewGroupRepository.findOne(workspaceId, {
       where: {
         id,
-        workspaceId,
         deletedAt: IsNull(),
       },
       relations: ['workspace', 'view'],

packages/twenty-server/src/engine/metadata-modules/view-group/view-group.module.ts

@@ -12,6 +12,7 @@ import { ViewGroupResolver } from 'src/engine/metadata-modules/view-group/resolv
 import { ViewGroupService } from 'src/engine/metadata-modules/view-group/services/view-group.service';
 import { ViewPermissionsModule } from 'src/engine/metadata-modules/view-permissions/view-permissions.module';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -28,7 +29,11 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     ViewPermissionsModule,
   ],
   controllers: [ViewGroupController],
-  providers: [ViewGroupService, ViewGroupResolver],
+  providers: [
+    ViewGroupService,
+    ViewGroupResolver,
+    provideWorkspaceScopedRepository(ViewGroupEntity),
+  ],
   exports: [ViewGroupService],
 })
 export class ViewGroupModule {}

packages/twenty-server/src/engine/metadata-modules/view-permissions/services/view-entity-lookup.service.ts

@@ -1,7 +1,4 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { Repository } from 'typeorm';
 
 import { ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
 import { ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
@@ -9,20 +6,22 @@ import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entiti
 import { ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
 import { type ViewChildEntityKind } from 'src/engine/metadata-modules/view-permissions/types/view-permissions.types';
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 
 @Injectable()
 export class ViewEntityLookupService {
   constructor(
-    @InjectRepository(ViewFieldEntity)
-    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
-    @InjectRepository(ViewFilterEntity)
-    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
-    @InjectRepository(ViewFilterGroupEntity)
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
-    @InjectRepository(ViewGroupEntity)
-    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
-    @InjectRepository(ViewSortEntity)
-    private readonly viewSortRepository: Repository<ViewSortEntity>,
+    @InjectWorkspaceScopedRepository(ViewFieldEntity)
+    private readonly viewFieldRepository: WorkspaceScopedRepository<ViewFieldEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterEntity)
+    private readonly viewFilterRepository: WorkspaceScopedRepository<ViewFilterEntity>,
+    @InjectWorkspaceScopedRepository(ViewFilterGroupEntity)
+    private readonly viewFilterGroupRepository: WorkspaceScopedRepository<ViewFilterGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewGroupEntity)
+    private readonly viewGroupRepository: WorkspaceScopedRepository<ViewGroupEntity>,
+    @InjectWorkspaceScopedRepository(ViewSortEntity)
+    private readonly viewSortRepository: WorkspaceScopedRepository<ViewSortEntity>,
   ) {}
 
   async findViewIdByEntityIdAndKind(
@@ -32,8 +31,8 @@ export class ViewEntityLookupService {
   ): Promise<string | null> {
     switch (kind) {
       case 'viewField': {
-        const row = await this.viewFieldRepository.findOne({
-          where: { id: entityId, workspaceId },
+        const row = await this.viewFieldRepository.findOne(workspaceId, {
+          where: { id: entityId },
           select: ['viewId'],
         });
 
@@ -42,8 +41,8 @@ export class ViewEntityLookupService {
       }
 
       case 'viewFilter': {
-        const row = await this.viewFilterRepository.findOne({
-          where: { id: entityId, workspaceId },
+        const row = await this.viewFilterRepository.findOne(workspaceId, {
+          where: { id: entityId },
           select: ['viewId'],
         });
 
@@ -52,8 +51,8 @@ export class ViewEntityLookupService {
       }
 
       case 'viewFilterGroup': {
-        const row = await this.viewFilterGroupRepository.findOne({
-          where: { id: entityId, workspaceId },
+        const row = await this.viewFilterGroupRepository.findOne(workspaceId, {
+          where: { id: entityId },
           select: ['viewId'],
         });
 
@@ -62,8 +61,8 @@ export class ViewEntityLookupService {
       }
 
       case 'viewGroup': {
-        const row = await this.viewGroupRepository.findOne({
-          where: { id: entityId, workspaceId },
+        const row = await this.viewGroupRepository.findOne(workspaceId, {
+          where: { id: entityId },
           select: ['viewId'],
         });
 
@@ -72,8 +71,8 @@ export class ViewEntityLookupService {
       }
 
       case 'viewSort': {
-        const row = await this.viewSortRepository.findOne({
-          where: { id: entityId, workspaceId },
+        const row = await this.viewSortRepository.findOne(workspaceId, {
+          where: { id: entityId },
           select: ['viewId'],
         });
 

packages/twenty-server/src/engine/metadata-modules/view-permissions/view-permissions.module.ts

@@ -38,6 +38,7 @@ import { ViewEntityLookupService } from 'src/engine/metadata-modules/view-permis
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
 import { ViewService } from 'src/engine/metadata-modules/view/services/view.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -86,6 +87,12 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     UpdateViewSortPermissionGuard,
     DeleteViewSortPermissionGuard,
     DestroyViewSortPermissionGuard,
+    provideWorkspaceScopedRepository(ViewEntity),
+    provideWorkspaceScopedRepository(ViewFieldEntity),
+    provideWorkspaceScopedRepository(ViewFilterEntity),
+    provideWorkspaceScopedRepository(ViewFilterGroupEntity),
+    provideWorkspaceScopedRepository(ViewGroupEntity),
+    provideWorkspaceScopedRepository(ViewSortEntity),
   ],
   exports: [
     ViewService,

packages/twenty-server/src/engine/metadata-modules/view-sort/services/view-sort.service.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { IsNull, Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
@@ -18,14 +17,16 @@ import { UpdateViewSortInput } from 'src/engine/metadata-modules/view-sort/dtos/
 import { ViewSortDTO } from 'src/engine/metadata-modules/view-sort/dtos/view-sort.dto';
 import { ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
 import { fromFlatViewSortToViewSortDto } from 'src/engine/metadata-modules/view-sort/utils/from-flat-view-sort-to-view-sort-dto.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewSortService {
   constructor(
-    @InjectRepository(ViewSortEntity)
-    private readonly viewSortRepository: Repository<ViewSortEntity>,
+    @InjectWorkspaceScopedRepository(ViewSortEntity)
+    private readonly viewSortRepository: WorkspaceScopedRepository<ViewSortEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
@@ -301,9 +302,8 @@ export class ViewSortService {
   }
 
   async findByWorkspaceId(workspaceId: string): Promise<ViewSortEntity[]> {
-    return this.viewSortRepository.find({
+    return this.viewSortRepository.find(workspaceId, {
       where: {
-        workspaceId,
         deletedAt: IsNull(),
       },
       relations: ['workspace', 'view'],
@@ -314,9 +314,8 @@ export class ViewSortService {
     workspaceId: string,
     viewId: string,
   ): Promise<ViewSortEntity[]> {
-    return this.viewSortRepository.find({
+    return this.viewSortRepository.find(workspaceId, {
       where: {
-        workspaceId,
         viewId,
         deletedAt: IsNull(),
       },
@@ -328,10 +327,9 @@ export class ViewSortService {
     id: string,
     workspaceId: string,
   ): Promise<ViewSortEntity | null> {
-    const viewSort = await this.viewSortRepository.findOne({
+    const viewSort = await this.viewSortRepository.findOne(workspaceId, {
       where: {
         id,
-        workspaceId,
         deletedAt: IsNull(),
       },
       relations: ['workspace', 'view'],

packages/twenty-server/src/engine/metadata-modules/view-sort/view-sort.module.ts

@@ -10,6 +10,7 @@ import { ViewSortResolver } from 'src/engine/metadata-modules/view-sort/resolver
 import { ViewSortService } from 'src/engine/metadata-modules/view-sort/services/view-sort.service';
 import { ViewSortToolsFactory } from 'src/engine/metadata-modules/view-sort/tools/view-sort-tools.factory';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
@@ -25,7 +26,12 @@ import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata
     ViewPermissionsModule,
   ],
   controllers: [ViewSortController],
-  providers: [ViewSortService, ViewSortResolver, ViewSortToolsFactory],
+  providers: [
+    ViewSortService,
+    ViewSortResolver,
+    ViewSortToolsFactory,
+    provideWorkspaceScopedRepository(ViewSortEntity),
+  ],
   exports: [ViewSortService, ViewSortToolsFactory],
 })
 export class ViewSortModule {}

packages/twenty-server/src/engine/metadata-modules/view/services/view-widget-upsert.service.ts

@@ -1,5 +1,4 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { t } from '@lingui/core/macro';
 import {
@@ -8,7 +7,7 @@ import {
   ViewSortDirection,
 } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
-import { IsNull, Repository } from 'typeorm';
+import { IsNull } from 'typeorm';
 import { v4 } from 'uuid';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
@@ -43,6 +42,8 @@ import {
   ViewException,
   ViewExceptionCode,
 } from 'src/engine/metadata-modules/view/exceptions/view.exception';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
@@ -75,8 +76,8 @@ export class ViewWidgetUpsertService {
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
   ) {}
 
   async upsertViewWidget({
@@ -186,13 +187,15 @@ export class ViewWidgetUpsertService {
       !isDefined(input.viewFilters) &&
       !isDefined(input.viewSorts)
     ) {
-      const view = await this.viewRepository.findOne({
-        where: {
-          id: upsertContext.viewId,
-          workspaceId: upsertContext.workspaceId,
-          deletedAt: IsNull(),
+      const view = await this.viewRepository.findOne(
+        upsertContext.workspaceId,
+        {
+          where: {
+            id: upsertContext.viewId,
+            deletedAt: IsNull(),
+          },
         },
-      });
+      );
 
       if (!isDefined(view)) {
         throw new ViewException(
@@ -354,10 +357,9 @@ export class ViewWidgetUpsertService {
       );
     }
 
-    const view = await this.viewRepository.findOne({
+    const view = await this.viewRepository.findOne(upsertContext.workspaceId, {
       where: {
         id: upsertContext.viewId,
-        workspaceId: upsertContext.workspaceId,
         deletedAt: IsNull(),
       },
     });

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

@@ -1,10 +1,8 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { APP_LOCALES, SOURCE_LOCALE } from 'twenty-shared/translations';
 import { ViewType, ViewVisibility } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
 import { ApplicationService } from 'src/engine/core-modules/application/application.service';
 import { I18nService } from 'src/engine/core-modules/i18n/i18n.service';
@@ -32,14 +30,16 @@ import { UpdateViewInput } from 'src/engine/metadata-modules/view/dtos/inputs/up
 import { ViewDTO } from 'src/engine/metadata-modules/view/dtos/view.dto';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
 import { fromFlatViewToViewDto } from 'src/engine/metadata-modules/view/utils/from-flat-view-to-view-dto.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
 import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewService {
   constructor(
-    @InjectRepository(ViewEntity)
-    private readonly viewRepository: Repository<ViewEntity>,
+    @InjectWorkspaceScopedRepository(ViewEntity)
+    private readonly viewRepository: WorkspaceScopedRepository<ViewEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
     private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
     private readonly applicationService: ApplicationService,
@@ -625,10 +625,9 @@ export class ViewService {
     id: string,
     workspaceId: string,
   ): Promise<ViewEntity | null> {
-    const view = await this.viewRepository.findOne({
+    const view = await this.viewRepository.findOne(workspaceId, {
       where: {
         id,
-        workspaceId,
       },
       relations: [
         'workspace',

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

@@ -19,6 +19,7 @@ import { ViewResolver } from 'src/engine/metadata-modules/view/resolvers/view.re
 import { ViewQueryParamsService } from 'src/engine/metadata-modules/view/services/view-query-params.service';
 import { ViewService } from 'src/engine/metadata-modules/view/services/view.service';
 import { ViewToolsFactory } from 'src/engine/metadata-modules/view/tools/view-tools.factory';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
 
@@ -46,6 +47,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     ViewQueryParamsService,
     ViewToolsFactory,
     ViewWidgetUpsertService,
+    provideWorkspaceScopedRepository(ViewEntity),
   ],
   exports: [
     ViewService,

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

@@ -13,6 +13,7 @@ import { WebhookGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modul
 import { WebhookToolWorkspaceService } from 'src/engine/metadata-modules/webhook/tools/services/webhook-tool.workspace-service';
 import { WebhookResolver } from 'src/engine/metadata-modules/webhook/webhook.resolver';
 import { WebhookService } from 'src/engine/metadata-modules/webhook/webhook.service';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceMigrationGraphqlApiExceptionInterceptor } from 'src/engine/workspace-manager/workspace-migration/interceptors/workspace-migration-graphql-api-exception.interceptor';
 import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration.module';
@@ -35,6 +36,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     WebhookGraphqlApiExceptionInterceptor,
     WorkspaceMigrationGraphqlApiExceptionInterceptor,
     WebhookToolWorkspaceService,
+    provideWorkspaceScopedRepository(WebhookEntity),
   ],
   exports: [WebhookService, WebhookToolWorkspaceService],
 })

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

@@ -13,6 +13,8 @@ import { fromDeleteWebhookInputToFlatWebhookOrThrow } from 'src/engine/metadata-
 import { fromFlatWebhookToWebhookDto } from 'src/engine/metadata-modules/flat-webhook/utils/from-flat-webhook-to-webhook-dto.util';
 import { fromUpdateWebhookInputToFlatWebhookToUpdateOrThrow } from 'src/engine/metadata-modules/flat-webhook/utils/from-update-webhook-input-to-flat-webhook-to-update-or-throw.util';
 import { fromWebhookEntityToFlatWebhook } from 'src/engine/metadata-modules/flat-webhook/utils/from-webhook-entity-to-flat-webhook.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { type CreateWebhookInput } from 'src/engine/metadata-modules/webhook/dtos/create-webhook.input';
 import { type UpdateWebhookInput } from 'src/engine/metadata-modules/webhook/dtos/update-webhook.input';
 import { type WebhookDTO } from 'src/engine/metadata-modules/webhook/dtos/webhook.dto';
@@ -24,8 +26,8 @@ import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspa
 @Injectable()
 export class WebhookService {
   constructor(
-    @InjectRepository(WebhookEntity)
-    private readonly webhookRepository: Repository<WebhookEntity>,
+    @InjectWorkspaceScopedRepository(WebhookEntity)
+    private readonly webhookRepository: WorkspaceScopedRepository<WebhookEntity>,
     @InjectRepository(ApplicationEntity)
     private readonly applicationRepository: Repository<ApplicationEntity>,
     private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
@@ -45,8 +47,8 @@ export class WebhookService {
 
   async findAll(workspaceId: string): Promise<WebhookDTO[]> {
     const [webhooks, applications] = await Promise.all([
-      this.webhookRepository.find({
-        where: { workspaceId, deletedAt: IsNull() },
+      this.webhookRepository.find(workspaceId, {
+        where: { deletedAt: IsNull() },
         order: { createdAt: 'ASC' },
       }),
       this.applicationRepository.find({
@@ -70,8 +72,8 @@ export class WebhookService {
 
   async findById(id: string, workspaceId: string): Promise<WebhookDTO | null> {
     const [webhook, applications] = await Promise.all([
-      this.webhookRepository.findOne({
-        where: { id, workspaceId, deletedAt: IsNull() },
+      this.webhookRepository.findOne(workspaceId, {
+        where: { id, deletedAt: IsNull() },
       }),
       this.applicationRepository.find({
         where: { workspaceId },

packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/services/dev-seeder-permissions.service.ts

@@ -14,6 +14,8 @@ import { RoleDTO } from 'src/engine/metadata-modules/role/dtos/role.dto';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleService } from 'src/engine/metadata-modules/role/role.service';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import {
   SEED_APPLE_WORKSPACE_ID,
   SEED_YCOMBINATOR_WORKSPACE_ID,
@@ -35,8 +37,8 @@ export class DevSeederPermissionsService {
     private readonly objectPermissionService: ObjectPermissionService,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     private readonly fieldPermissionService: FieldPermissionService,
     private readonly roleTargetService: RoleTargetService,
     @InjectDataSource()
@@ -54,10 +56,9 @@ export class DevSeederPermissionsService {
     workspaceCustomFlatApplication: FlatApplication;
     light?: boolean;
   }) {
-    const adminRole = await this.roleRepository.findOne({
+    const adminRole = await this.roleRepository.findOne(workspaceId, {
       where: {
         universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
-        workspaceId,
       },
     });
 

packages/twenty-server/src/engine/workspace-manager/dev-seeder/dev-seeder.module.ts

@@ -15,9 +15,11 @@ import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadat
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
 import { ObjectPermissionModule } from 'src/engine/metadata-modules/object-permission/object-permission.module';
 import { RoleTargetModule } from 'src/engine/metadata-modules/role-target/role-target.module';
+import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
 import { UpgradeModule } from 'src/engine/core-modules/upgrade/upgrade.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
@@ -62,6 +64,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
     DevSeederPermissionsService,
     DevSeederDataService,
     TimelineActivitySeederService,
+    provideWorkspaceScopedRepository(RoleEntity),
   ],
 })
 export class DevSeederModule {}

packages/twenty-server/src/engine/workspace-manager/workspace-manager.module.ts

@@ -15,6 +15,7 @@ import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-t
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { DevSeederModule } from 'src/engine/workspace-manager/dev-seeder/dev-seeder.module';
 import { TwentyStandardApplicationModule } from 'src/engine/workspace-manager/twenty-standard-application/twenty-standard-application.module';
@@ -45,6 +46,9 @@ import { WorkspaceManagerService } from './workspace-manager.service';
     ]),
   ],
   exports: [WorkspaceManagerService],
-  providers: [WorkspaceManagerService],
+  providers: [
+    WorkspaceManagerService,
+    provideWorkspaceScopedRepository(RoleEntity),
+  ],
 })
 export class WorkspaceManagerModule {}

packages/twenty-server/src/engine/workspace-manager/workspace-manager.service.ts

@@ -10,6 +10,8 @@ import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.ent
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
 import { RoleService } from 'src/engine/metadata-modules/role/role.service';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
 import { TwentyStandardApplicationService } from 'src/engine/workspace-manager/twenty-standard-application/services/twenty-standard-application.service';
@@ -27,8 +29,8 @@ export class WorkspaceManagerService {
     private readonly twentyStandardApplicationService: TwentyStandardApplicationService,
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
-    @InjectRepository(RoleEntity)
-    private readonly roleRepository: Repository<RoleEntity>,
+    @InjectWorkspaceScopedRepository(RoleEntity)
+    private readonly roleRepository: WorkspaceScopedRepository<RoleEntity>,
     private readonly applicationService: ApplicationService,
   ) {}
 
@@ -97,10 +99,9 @@ export class WorkspaceManagerService {
     userId: string;
     workspaceCustomFlatApplication: FlatApplication;
   }): Promise<void> {
-    const adminRole = await this.roleRepository.findOne({
+    const adminRole = await this.roleRepository.findOne(workspaceId, {
       where: {
         universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
-        workspaceId,
       },
     });
 

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/__tests__/workflow-version-step-operations.workspace-service.spec.ts

@@ -12,6 +12,7 @@ import { LogicFunctionFromSourceService } from 'src/engine/metadata-modules/logi
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { getWorkspaceScopedRepositoryToken } from 'src/engine/twenty-orm/workspace-scoped-repository/get-workspace-scoped-repository-token.util';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import { CodeStepBuildService } from 'src/modules/workflow/workflow-builder/workflow-version-step/code-step/services/code-step-build.service';
@@ -143,7 +144,7 @@ describe('WorkflowVersionStepOperationsWorkspaceService', () => {
           useValue: agentService,
         },
         {
-          provide: getRepositoryToken(RoleTargetEntity),
+          provide: getWorkspaceScopedRepositoryToken(RoleTargetEntity),
           useValue: roleTargetRepository,
         },
         {

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step-operations.workspace-service.ts

@@ -27,6 +27,8 @@ import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadat
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
+import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 import {
   WorkflowVersionStepException,
@@ -70,8 +72,8 @@ export class WorkflowVersionStepOperationsWorkspaceService {
     private readonly logicFunctionFromSourceService: LogicFunctionFromSourceService,
     private readonly codeStepBuildService: CodeStepBuildService,
     private readonly agentService: AgentService,
-    @InjectRepository(RoleTargetEntity)
-    private readonly roleTargetRepository: Repository<RoleTargetEntity>,
+    @InjectWorkspaceScopedRepository(RoleTargetEntity)
+    private readonly roleTargetRepository: WorkspaceScopedRepository<RoleTargetEntity>,
     @InjectRepository(ObjectMetadataEntity)
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
@@ -100,12 +102,14 @@ export class WorkflowVersionStepOperationsWorkspaceService {
           break;
         }
 
-        const roleTarget = await this.roleTargetRepository.findOne({
-          where: {
-            agentId: step.settings.input.agentId,
-            workspaceId,
+        const roleTarget = await this.roleTargetRepository.findOne(
+          workspaceId,
+          {
+            where: {
+              agentId: step.settings.input.agentId,
+            },
           },
-        });
+        );
 
         await this.agentService.deleteManyAgents({
           ids: [step.settings.input.agentId],

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version-step/workflow-version-step.module.ts

@@ -9,6 +9,7 @@ import { LogicFunctionModule } from 'src/engine/metadata-modules/logic-function/
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { RoleTargetEntity } from 'src/engine/metadata-modules/role-target/role-target.entity';
 import { RoleEntity } from 'src/engine/metadata-modules/role/role.entity';
+import { provideWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/provide-workspace-scoped-repository';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';
 import { WorkflowSchemaModule } from 'src/modules/workflow/workflow-builder/workflow-schema/workflow-schema.module';
@@ -43,6 +44,7 @@ import { WorkflowVersionStepWorkspaceService } from 'src/modules/workflow/workfl
     WorkflowVersionStepCreationWorkspaceService,
     WorkflowVersionStepUpdateWorkspaceService,
     WorkflowVersionStepDeletionWorkspaceService,
+    provideWorkspaceScopedRepository(RoleTargetEntity),
   ],
   exports: [
     WorkflowVersionStepWorkspaceService,