Remove view filter v1 implem (#16154)

# Introduction
Removing view filter v1 implem 

Related https://github.com/twentyhq/core-team-issues/issues/1911

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

@@ -13,8 +13,6 @@ import {
 
 import { isDefined } from 'twenty-shared/utils';
 
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
 import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
@@ -30,7 +28,6 @@ import {
   ViewFilterExceptionMessageKey,
 } from 'src/engine/metadata-modules/view-filter/exceptions/view-filter.exception';
 import { ViewFilterRestApiExceptionFilter } from 'src/engine/metadata-modules/view-filter/filters/view-filter-rest-api-exception.filter';
-import { ViewFilterV2Service } from 'src/engine/metadata-modules/view-filter/services/view-filter-v2.service';
 import { ViewFilterService } from 'src/engine/metadata-modules/view-filter/services/view-filter.service';
 import { CreateViewFilterPermissionGuard } from 'src/engine/metadata-modules/view-permissions/guards/create-view-filter-permission.guard';
 import { DeleteViewFilterPermissionGuard } from 'src/engine/metadata-modules/view-permissions/guards/delete-view-filter-permission.guard';
@@ -40,11 +37,7 @@ import { UpdateViewFilterPermissionGuard } from 'src/engine/metadata-modules/vie
 @UseGuards(WorkspaceAuthGuard)
 @UseFilters(ViewFilterRestApiExceptionFilter)
 export class ViewFilterController {
-  constructor(
-    private readonly viewFilterService: ViewFilterService,
-    private readonly viewFilterV2Service: ViewFilterV2Service,
-    private readonly featureFlagService: FeatureFlagService,
-  ) {}
+  constructor(private readonly viewFilterService: ViewFilterService) {}
 
   @Get()
   @UseGuards(NoPermissionGuard)
@@ -91,21 +84,8 @@ export class ViewFilterController {
     @Body() input: CreateViewFilterInput,
     @AuthWorkspace() workspace: WorkspaceEntity,
   ): Promise<ViewFilterDTO> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspace.id,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.createOne({
-        createViewFilterInput: input,
-        workspaceId: workspace.id,
-      });
-    }
-
-    return this.viewFilterService.create({
-      ...input,
+    return await this.viewFilterService.createOne({
+      createViewFilterInput: input,
       workspaceId: workspace.id,
     });
   }
@@ -122,26 +102,10 @@ export class ViewFilterController {
       update: input.update ?? input,
     };
 
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspace.id,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.updateOne({
-        updateViewFilterInput: updateInput,
-        workspaceId: workspace.id,
-      });
-    }
-
-    const updatedViewFilter = await this.viewFilterService.update(
-      updateInput.id,
-      workspace.id,
-      updateInput.update,
-    );
-
-    return updatedViewFilter;
+    return await this.viewFilterService.updateOne({
+      updateViewFilterInput: updateInput,
+      workspaceId: workspace.id,
+    });
   }
 
   @Delete(':id')
@@ -150,25 +114,10 @@ export class ViewFilterController {
     @Param('id') id: string,
     @AuthWorkspace() workspace: WorkspaceEntity,
   ): Promise<{ success: boolean }> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspace.id,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      const deletedViewFilter = await this.viewFilterV2Service.deleteOne({
-        deleteViewFilterInput: { id },
-        workspaceId: workspace.id,
-      });
-
-      return { success: isDefined(deletedViewFilter) };
-    }
-
-    const deletedViewFilter = await this.viewFilterService.delete(
-      id,
-      workspace.id,
-    );
+    const deletedViewFilter = await this.viewFilterService.deleteOne({
+      deleteViewFilterInput: { id },
+      workspaceId: workspace.id,
+    });
 
     return { success: isDefined(deletedViewFilter) };
   }

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

@@ -1,8 +1,6 @@
 import { UseFilters, UseGuards } from '@nestjs/common';
 import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
 import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
@@ -12,7 +10,6 @@ import { DeleteViewFilterInput } from 'src/engine/metadata-modules/view-filter/d
 import { DestroyViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/destroy-view-filter.input';
 import { UpdateViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/update-view-filter.input';
 import { ViewFilterDTO } from 'src/engine/metadata-modules/view-filter/dtos/view-filter.dto';
-import { ViewFilterV2Service } from 'src/engine/metadata-modules/view-filter/services/view-filter-v2.service';
 import { ViewFilterService } from 'src/engine/metadata-modules/view-filter/services/view-filter.service';
 import { CreateViewFilterPermissionGuard } from 'src/engine/metadata-modules/view-permissions/guards/create-view-filter-permission.guard';
 import { DeleteViewFilterPermissionGuard } from 'src/engine/metadata-modules/view-permissions/guards/delete-view-filter-permission.guard';
@@ -24,11 +21,7 @@ import { ViewGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/view/
 @UseFilters(ViewGraphqlApiExceptionFilter)
 @UseGuards(WorkspaceAuthGuard)
 export class ViewFilterResolver {
-  constructor(
-    private readonly viewFilterService: ViewFilterService,
-    private readonly featureFlagService: FeatureFlagService,
-    private readonly viewFilterV2Service: ViewFilterV2Service,
-  ) {}
+  constructor(private readonly viewFilterService: ViewFilterService) {}
 
   @Query(() => [ViewFilterDTO])
   @UseGuards(NoPermissionGuard)
@@ -59,21 +52,8 @@ export class ViewFilterResolver {
     @Args('input') createViewFilterInput: CreateViewFilterInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<ViewFilterDTO> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspaceId,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.createOne({
-        createViewFilterInput,
-        workspaceId,
-      });
-    }
-
-    return this.viewFilterService.create({
-      ...createViewFilterInput,
+    return await this.viewFilterService.createOne({
+      createViewFilterInput,
       workspaceId,
     });
   }
@@ -84,24 +64,10 @@ export class ViewFilterResolver {
     @Args('input') updateViewFilterInput: UpdateViewFilterInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<ViewFilterDTO> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspaceId,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.updateOne({
-        updateViewFilterInput,
-        workspaceId,
-      });
-    }
-
-    return this.viewFilterService.update(
-      updateViewFilterInput.id,
+    return this.viewFilterService.updateOne({
+      updateViewFilterInput,
       workspaceId,
-      updateViewFilterInput.update,
-    );
+    });
   }
 
   @Mutation(() => ViewFilterDTO)
@@ -110,20 +76,10 @@ export class ViewFilterResolver {
     @Args('input') deleteViewFilterInput: DeleteViewFilterInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<ViewFilterDTO> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspaceId,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.deleteOne({
-        deleteViewFilterInput,
-        workspaceId,
-      });
-    }
-
-    return this.viewFilterService.delete(deleteViewFilterInput.id, workspaceId);
+    return this.viewFilterService.deleteOne({
+      deleteViewFilterInput,
+      workspaceId,
+    });
   }
 
   @Mutation(() => ViewFilterDTO)
@@ -132,22 +88,9 @@ export class ViewFilterResolver {
     @Args('input') destroyViewFilterInput: DestroyViewFilterInput,
     @AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
   ): Promise<ViewFilterDTO> {
-    const isWorkspaceMigrationV2Enabled =
-      await this.featureFlagService.isFeatureEnabled(
-        FeatureFlagKey.IS_WORKSPACE_MIGRATION_V2_ENABLED,
-        workspaceId,
-      );
-
-    if (isWorkspaceMigrationV2Enabled) {
-      return await this.viewFilterV2Service.destroyOne({
-        destroyViewFilterInput,
-        workspaceId,
-      });
-    }
-
-    return this.viewFilterService.destroy(
-      destroyViewFilterInput.id,
+    return this.viewFilterService.destroyOne({
+      destroyViewFilterInput,
       workspaceId,
-    );
+    });
   }
 }

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

@@ -1,343 +0,0 @@
-import { Test, type TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-
-import { ViewFilterOperand } from 'twenty-shared/types';
-import { type Repository } from 'typeorm';
-
-import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
-import {
-  ViewFilterException,
-  ViewFilterExceptionCode,
-  ViewFilterExceptionMessageKey,
-  generateViewFilterExceptionMessage,
-  generateViewFilterUserFriendlyExceptionMessage,
-} from 'src/engine/metadata-modules/view-filter/exceptions/view-filter.exception';
-import { ViewFilterService } from 'src/engine/metadata-modules/view-filter/services/view-filter.service';
-import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
-
-describe('ViewFilterService', () => {
-  let viewFilterService: ViewFilterService;
-  let viewFilterRepository: Repository<ViewFilterEntity>;
-
-  const mockViewFilter = {
-    id: 'view-filter-id',
-    fieldMetadataId: 'field-id',
-    viewId: 'view-id',
-    workspaceId: 'workspace-id',
-    operand: ViewFilterOperand.CONTAINS,
-    value: 'test',
-    positionInViewFilterGroup: 0,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    deletedAt: null,
-  } as ViewFilterEntity;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        ViewFilterService,
-        {
-          provide: WorkspaceCacheStorageService,
-          useValue: {
-            flushGraphQLOperation: jest.fn(),
-          },
-        },
-        {
-          provide: getRepositoryToken(ViewFilterEntity),
-          useValue: {
-            find: jest.fn(),
-            findOne: jest.fn(),
-            create: jest.fn(),
-            save: jest.fn(),
-            softDelete: jest.fn(),
-            delete: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    viewFilterService = module.get<ViewFilterService>(ViewFilterService);
-    viewFilterRepository = module.get<Repository<ViewFilterEntity>>(
-      getRepositoryToken(ViewFilterEntity),
-    );
-  });
-
-  it('should be defined', () => {
-    expect(viewFilterService).toBeDefined();
-  });
-
-  describe('findByWorkspaceId', () => {
-    it('should return view filters for a workspace', async () => {
-      const workspaceId = 'workspace-id';
-      const expectedViewFilters = [mockViewFilter];
-
-      jest
-        .spyOn(viewFilterRepository, 'find')
-        .mockResolvedValue(expectedViewFilters);
-
-      const result = await viewFilterService.findByWorkspaceId(workspaceId);
-
-      expect(viewFilterRepository.find).toHaveBeenCalledWith({
-        where: {
-          workspaceId,
-          deletedAt: expect.anything(),
-        },
-        order: { positionInViewFilterGroup: 'ASC' },
-        relations: ['workspace', 'view', 'viewFilterGroup'],
-      });
-      expect(result).toEqual(expectedViewFilters);
-    });
-  });
-
-  describe('findByViewId', () => {
-    it('should return view filters for a view', async () => {
-      const workspaceId = 'workspace-id';
-      const viewId = 'view-id';
-      const expectedViewFilters = [mockViewFilter];
-
-      jest
-        .spyOn(viewFilterRepository, 'find')
-        .mockResolvedValue(expectedViewFilters);
-
-      const result = await viewFilterService.findByViewId(workspaceId, viewId);
-
-      expect(viewFilterRepository.find).toHaveBeenCalledWith({
-        where: {
-          workspaceId,
-          viewId,
-          deletedAt: expect.anything(),
-        },
-        order: { positionInViewFilterGroup: 'ASC' },
-        relations: ['workspace', 'view', 'viewFilterGroup'],
-      });
-      expect(result).toEqual(expectedViewFilters);
-    });
-  });
-
-  describe('findById', () => {
-    it('should return a view filter by id', async () => {
-      const id = 'view-filter-id';
-      const workspaceId = 'workspace-id';
-
-      jest
-        .spyOn(viewFilterRepository, 'findOne')
-        .mockResolvedValue(mockViewFilter);
-
-      const result = await viewFilterService.findById(id, workspaceId);
-
-      expect(viewFilterRepository.findOne).toHaveBeenCalledWith({
-        where: {
-          id,
-          workspaceId,
-          deletedAt: expect.anything(),
-        },
-        relations: ['workspace', 'view', 'viewFilterGroup'],
-      });
-      expect(result).toEqual(mockViewFilter);
-    });
-
-    it('should return null when view filter is not found', async () => {
-      const id = 'non-existent-id';
-      const workspaceId = 'workspace-id';
-
-      jest.spyOn(viewFilterRepository, 'findOne').mockResolvedValue(null);
-
-      const result = await viewFilterService.findById(id, workspaceId);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('create', () => {
-    const validViewFilterData = {
-      fieldMetadataId: 'field-id',
-      viewId: 'view-id',
-      workspaceId: 'workspace-id',
-      operand: ViewFilterOperand.CONTAINS,
-      value: 'test',
-      positionInViewFilterGroup: 0,
-    };
-
-    it('should create a view filter successfully', async () => {
-      jest
-        .spyOn(viewFilterRepository, 'create')
-        .mockReturnValue(mockViewFilter);
-      jest
-        .spyOn(viewFilterRepository, 'save')
-        .mockResolvedValue(mockViewFilter);
-
-      const result = await viewFilterService.create(validViewFilterData);
-
-      expect(viewFilterRepository.create).toHaveBeenCalledWith(
-        validViewFilterData,
-      );
-      expect(viewFilterRepository.save).toHaveBeenCalledWith(mockViewFilter);
-      expect(result).toEqual(mockViewFilter);
-    });
-
-    it('should throw exception when workspaceId is missing', async () => {
-      const invalidData = { ...validViewFilterData, workspaceId: undefined };
-
-      await expect(viewFilterService.create(invalidData)).rejects.toThrow(
-        new ViewFilterException(
-          generateViewFilterExceptionMessage(
-            ViewFilterExceptionMessageKey.WORKSPACE_ID_REQUIRED,
-          ),
-          ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-          {
-            userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-              ViewFilterExceptionMessageKey.WORKSPACE_ID_REQUIRED,
-            ),
-          },
-        ),
-      );
-    });
-
-    it('should throw exception when viewId is missing', async () => {
-      const invalidData = { ...validViewFilterData, viewId: undefined };
-
-      await expect(viewFilterService.create(invalidData)).rejects.toThrow(
-        new ViewFilterException(
-          generateViewFilterExceptionMessage(
-            ViewFilterExceptionMessageKey.VIEW_ID_REQUIRED,
-          ),
-          ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-          {
-            userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-              ViewFilterExceptionMessageKey.VIEW_ID_REQUIRED,
-            ),
-          },
-        ),
-      );
-    });
-
-    it('should throw exception when fieldMetadataId is missing', async () => {
-      const invalidData = {
-        ...validViewFilterData,
-        fieldMetadataId: undefined,
-      };
-
-      await expect(viewFilterService.create(invalidData)).rejects.toThrow(
-        new ViewFilterException(
-          generateViewFilterExceptionMessage(
-            ViewFilterExceptionMessageKey.FIELD_METADATA_ID_REQUIRED,
-          ),
-          ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-          {
-            userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-              ViewFilterExceptionMessageKey.FIELD_METADATA_ID_REQUIRED,
-            ),
-          },
-        ),
-      );
-    });
-  });
-
-  describe('update', () => {
-    it('should update a view filter successfully', async () => {
-      const id = 'view-filter-id';
-      const workspaceId = 'workspace-id';
-      const updateData = { value: 'updated test' };
-      const updatedViewFilter = { ...mockViewFilter, ...updateData };
-
-      jest
-        .spyOn(viewFilterService, 'findById')
-        .mockResolvedValue(mockViewFilter);
-      jest
-        .spyOn(viewFilterRepository, 'save')
-        .mockResolvedValue(updatedViewFilter);
-
-      const result = await viewFilterService.update(
-        id,
-        workspaceId,
-        updateData,
-      );
-
-      expect(viewFilterService.findById).toHaveBeenCalledWith(id, workspaceId);
-      expect(viewFilterRepository.save).toHaveBeenCalledWith({
-        id,
-        ...updateData,
-      });
-      expect(result).toEqual({ ...mockViewFilter, ...updatedViewFilter });
-    });
-
-    it('should throw exception when view filter is not found', async () => {
-      const id = 'non-existent-id';
-      const workspaceId = 'workspace-id';
-      const updateData = { value: 'updated test' };
-
-      jest.spyOn(viewFilterService, 'findById').mockResolvedValue(null);
-
-      await expect(
-        viewFilterService.update(id, workspaceId, updateData),
-      ).rejects.toThrow(
-        new ViewFilterException(
-          generateViewFilterExceptionMessage(
-            ViewFilterExceptionMessageKey.VIEW_FILTER_NOT_FOUND,
-            id,
-          ),
-          ViewFilterExceptionCode.VIEW_FILTER_NOT_FOUND,
-        ),
-      );
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete a view filter successfully', async () => {
-      const id = 'view-filter-id';
-      const workspaceId = 'workspace-id';
-
-      jest
-        .spyOn(viewFilterService, 'findById')
-        .mockResolvedValue(mockViewFilter);
-      jest
-        .spyOn(viewFilterRepository, 'softDelete')
-        .mockResolvedValue({} as any);
-
-      const result = await viewFilterService.delete(id, workspaceId);
-
-      expect(viewFilterService.findById).toHaveBeenCalledWith(id, workspaceId);
-      expect(viewFilterRepository.softDelete).toHaveBeenCalledWith(id);
-      expect(result).toEqual(mockViewFilter);
-    });
-
-    it('should throw exception when view filter is not found', async () => {
-      const id = 'non-existent-id';
-      const workspaceId = 'workspace-id';
-
-      jest.spyOn(viewFilterService, 'findById').mockResolvedValue(null);
-
-      await expect(viewFilterService.delete(id, workspaceId)).rejects.toThrow(
-        new ViewFilterException(
-          generateViewFilterExceptionMessage(
-            ViewFilterExceptionMessageKey.VIEW_FILTER_NOT_FOUND,
-            id,
-          ),
-          ViewFilterExceptionCode.VIEW_FILTER_NOT_FOUND,
-        ),
-      );
-    });
-  });
-
-  describe('destroy', () => {
-    it('should destroy a view filter successfully', async () => {
-      const id = 'view-filter-id';
-      const workspaceId = 'workspace-id';
-
-      jest
-        .spyOn(viewFilterRepository, 'findOne')
-        .mockResolvedValue(mockViewFilter);
-      jest.spyOn(viewFilterRepository, 'delete').mockResolvedValue({} as any);
-
-      const result = await viewFilterService.destroy(id, workspaceId);
-
-      expect(viewFilterRepository.findOne).toHaveBeenCalledWith({
-        where: { id, workspaceId },
-        relations: ['workspace', 'view', 'viewFilterGroup'],
-        withDeleted: true,
-      });
-      expect(viewFilterRepository.delete).toHaveBeenCalledWith(id);
-      expect(result).toEqual(mockViewFilter);
-    });
-  });
-});

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

@@ -1,317 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-import { isDefined } from 'twenty-shared/utils';
-
-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 { computeFlatEntityMapsFromTo } from 'src/engine/metadata-modules/flat-entity/utils/compute-flat-entity-maps-from-to.util';
-import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
-import { fromCreateViewFilterInputToFlatViewFilterToCreate } from 'src/engine/metadata-modules/flat-view-filter/utils/from-create-view-filter-input-to-flat-view-filter-to-create.util';
-import { fromDeleteViewFilterInputToFlatViewFilterOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-delete-view-filter-input-to-flat-view-filter-or-throw.util';
-import { fromDestroyViewFilterInputToFlatViewFilterOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-destroy-view-filter-input-to-flat-view-filter-or-throw.util';
-import { fromUpdateViewFilterInputToFlatViewFilterToUpdateOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-update-view-filter-input-to-flat-view-filter-to-update-or-throw.util';
-import { CreateViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/create-view-filter.input';
-import { DeleteViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/delete-view-filter.input';
-import { DestroyViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/destroy-view-filter.input';
-import { UpdateViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/update-view-filter.input';
-import { ViewFilterDTO } from 'src/engine/metadata-modules/view-filter/dtos/view-filter.dto';
-import { WorkspaceMigrationBuilderExceptionV2 } from 'src/engine/workspace-manager/workspace-migration-v2/exceptions/workspace-migration-builder-exception-v2';
-import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration-v2/services/workspace-migration-validate-build-and-run-service';
-
-@Injectable()
-export class ViewFilterV2Service {
-  constructor(
-    private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
-    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
-    private readonly applicationService: ApplicationService,
-  ) {}
-
-  async createOne({
-    createViewFilterInput,
-    workspaceId,
-  }: {
-    createViewFilterInput: CreateViewFilterInput;
-    workspaceId: string;
-  }): Promise<ViewFilterDTO> {
-    const { workspaceCustomFlatApplication } =
-      await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
-        {
-          workspaceId,
-        },
-      );
-
-    const {
-      flatViewFilterMaps: existingFlatViewFilterMaps,
-      flatViewMaps,
-      flatFieldMetadataMaps,
-      flatObjectMetadataMaps,
-    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-      {
-        workspaceId,
-        flatMapsKeys: [
-          'flatViewFilterMaps',
-          'flatViewMaps',
-          'flatFieldMetadataMaps',
-          'flatObjectMetadataMaps',
-        ],
-      },
-    );
-
-    const flatViewFilterToCreate =
-      fromCreateViewFilterInputToFlatViewFilterToCreate({
-        createViewFilterInput,
-        workspaceId,
-        workspaceCustomApplicationId: workspaceCustomFlatApplication.id,
-      });
-
-    const validateAndBuildResult =
-      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
-        {
-          fromToAllFlatEntityMaps: {
-            flatViewFilterMaps: computeFlatEntityMapsFromTo({
-              flatEntityMaps: existingFlatViewFilterMaps,
-              flatEntityToCreate: [flatViewFilterToCreate],
-              flatEntityToDelete: [],
-              flatEntityToUpdate: [],
-            }),
-          },
-          dependencyAllFlatEntityMaps: {
-            flatFieldMetadataMaps,
-            flatViewMaps,
-            flatObjectMetadataMaps,
-          },
-          buildOptions: {
-            isSystemBuild: false,
-          },
-          workspaceId,
-        },
-      );
-
-    if (isDefined(validateAndBuildResult)) {
-      throw new WorkspaceMigrationBuilderExceptionV2(
-        validateAndBuildResult,
-        'Multiple validation errors occurred while creating view filter',
-      );
-    }
-
-    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatViewFilterMaps'],
-        },
-      );
-
-    return findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: flatViewFilterToCreate.id,
-      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
-    });
-  }
-
-  async updateOne({
-    updateViewFilterInput,
-    workspaceId,
-  }: {
-    workspaceId: string;
-    updateViewFilterInput: UpdateViewFilterInput;
-  }): Promise<ViewFilterDTO> {
-    const {
-      flatViewFilterMaps: existingFlatViewFilterMaps,
-      flatViewMaps,
-      flatFieldMetadataMaps,
-    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-      {
-        workspaceId,
-        flatMapsKeys: [
-          'flatViewFilterMaps',
-          'flatViewMaps',
-          'flatFieldMetadataMaps',
-        ],
-      },
-    );
-
-    const optimisticallyUpdatedFlatViewFilter =
-      fromUpdateViewFilterInputToFlatViewFilterToUpdateOrThrow({
-        flatViewFilterMaps: existingFlatViewFilterMaps,
-        updateViewFilterInput,
-      });
-
-    const validateAndBuildResult =
-      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
-        {
-          fromToAllFlatEntityMaps: {
-            flatViewFilterMaps: computeFlatEntityMapsFromTo({
-              flatEntityMaps: existingFlatViewFilterMaps,
-              flatEntityToCreate: [],
-              flatEntityToDelete: [],
-              flatEntityToUpdate: [optimisticallyUpdatedFlatViewFilter],
-            }),
-          },
-          dependencyAllFlatEntityMaps: {
-            flatViewMaps,
-            flatFieldMetadataMaps,
-          },
-          buildOptions: {
-            isSystemBuild: false,
-          },
-          workspaceId,
-        },
-      );
-
-    if (isDefined(validateAndBuildResult)) {
-      throw new WorkspaceMigrationBuilderExceptionV2(
-        validateAndBuildResult,
-        'Multiple validation errors occurred while updating view filter',
-      );
-    }
-
-    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatViewFilterMaps'],
-        },
-      );
-
-    return findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: optimisticallyUpdatedFlatViewFilter.id,
-      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
-    });
-  }
-
-  async deleteOne({
-    deleteViewFilterInput,
-    workspaceId,
-  }: {
-    deleteViewFilterInput: DeleteViewFilterInput;
-    workspaceId: string;
-  }): Promise<ViewFilterDTO> {
-    const {
-      flatViewFilterMaps: existingFlatViewFilterMaps,
-      flatViewMaps,
-      flatFieldMetadataMaps,
-    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-      {
-        workspaceId,
-        flatMapsKeys: [
-          'flatViewFilterMaps',
-          'flatViewMaps',
-          'flatFieldMetadataMaps',
-        ],
-      },
-    );
-
-    const optimisticallyUpdatedFlatViewFilterWithDeletedAt =
-      fromDeleteViewFilterInputToFlatViewFilterOrThrow({
-        flatViewFilterMaps: existingFlatViewFilterMaps,
-        deleteViewFilterInput,
-      });
-
-    const validateAndBuildResult =
-      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
-        {
-          fromToAllFlatEntityMaps: {
-            flatViewFilterMaps: computeFlatEntityMapsFromTo({
-              flatEntityMaps: existingFlatViewFilterMaps,
-              flatEntityToCreate: [],
-              flatEntityToDelete: [],
-              flatEntityToUpdate: [
-                optimisticallyUpdatedFlatViewFilterWithDeletedAt,
-              ],
-            }),
-          },
-          dependencyAllFlatEntityMaps: {
-            flatFieldMetadataMaps,
-            flatViewMaps,
-          },
-          buildOptions: {
-            isSystemBuild: false,
-          },
-          workspaceId,
-        },
-      );
-
-    if (isDefined(validateAndBuildResult)) {
-      throw new WorkspaceMigrationBuilderExceptionV2(
-        validateAndBuildResult,
-        'Multiple validation errors occurred while deleting view filter',
-      );
-    }
-
-    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
-      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-        {
-          workspaceId,
-          flatMapsKeys: ['flatViewFilterMaps'],
-        },
-      );
-
-    return findFlatEntityByIdInFlatEntityMapsOrThrow({
-      flatEntityId: optimisticallyUpdatedFlatViewFilterWithDeletedAt.id,
-      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
-    });
-  }
-
-  async destroyOne({
-    destroyViewFilterInput,
-    workspaceId,
-  }: {
-    destroyViewFilterInput: DestroyViewFilterInput;
-    workspaceId: string;
-  }): Promise<ViewFilterDTO> {
-    const {
-      flatViewFilterMaps: existingFlatViewFilterMaps,
-      flatViewMaps: existingFlatViewMaps,
-      flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
-    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
-      {
-        workspaceId,
-        flatMapsKeys: [
-          'flatViewFilterMaps',
-          'flatViewMaps',
-          'flatFieldMetadataMaps',
-        ],
-      },
-    );
-
-    const existingViewFilterToDelete =
-      fromDestroyViewFilterInputToFlatViewFilterOrThrow({
-        destroyViewFilterInput,
-        flatViewFilterMaps: existingFlatViewFilterMaps,
-      });
-
-    const validateAndBuildResult =
-      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
-        {
-          fromToAllFlatEntityMaps: {
-            flatViewFilterMaps: computeFlatEntityMapsFromTo({
-              flatEntityMaps: existingFlatViewFilterMaps,
-              flatEntityToCreate: [],
-              flatEntityToDelete: [existingViewFilterToDelete],
-              flatEntityToUpdate: [],
-            }),
-          },
-          dependencyAllFlatEntityMaps: {
-            flatViewMaps: existingFlatViewMaps,
-            flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
-          },
-          buildOptions: {
-            isSystemBuild: false,
-            inferDeletionFromMissingEntities: {
-              viewFilter: true,
-            },
-          },
-          workspaceId,
-        },
-      );
-
-    if (isDefined(validateAndBuildResult)) {
-      throw new WorkspaceMigrationBuilderExceptionV2(
-        validateAndBuildResult,
-        'Multiple validation errors occurred while destroying view filter',
-      );
-    }
-
-    return existingViewFilterToDelete;
-  }
-}

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

@@ -4,25 +4,322 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } 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';
+import { computeFlatEntityMapsFromTo } from 'src/engine/metadata-modules/flat-entity/utils/compute-flat-entity-maps-from-to.util';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { fromCreateViewFilterInputToFlatViewFilterToCreate } from 'src/engine/metadata-modules/flat-view-filter/utils/from-create-view-filter-input-to-flat-view-filter-to-create.util';
+import { fromDeleteViewFilterInputToFlatViewFilterOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-delete-view-filter-input-to-flat-view-filter-or-throw.util';
+import { fromDestroyViewFilterInputToFlatViewFilterOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-destroy-view-filter-input-to-flat-view-filter-or-throw.util';
+import { fromUpdateViewFilterInputToFlatViewFilterToUpdateOrThrow } from 'src/engine/metadata-modules/flat-view-filter/utils/from-update-view-filter-input-to-flat-view-filter-to-update-or-throw.util';
+import { CreateViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/create-view-filter.input';
+import { DeleteViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/delete-view-filter.input';
+import { DestroyViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/destroy-view-filter.input';
+import { UpdateViewFilterInput } from 'src/engine/metadata-modules/view-filter/dtos/inputs/update-view-filter.input';
+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 {
-  ViewFilterException,
-  ViewFilterExceptionCode,
-  ViewFilterExceptionMessageKey,
-  generateViewFilterExceptionMessage,
-  generateViewFilterUserFriendlyExceptionMessage,
-} from 'src/engine/metadata-modules/view-filter/exceptions/view-filter.exception';
-import { FIND_ALL_CORE_VIEWS_GRAPHQL_OPERATION } from 'src/engine/metadata-modules/view/constants/find-all-core-views-graphql-operation.constant';
-import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
+import { WorkspaceMigrationBuilderExceptionV2 } from 'src/engine/workspace-manager/workspace-migration-v2/exceptions/workspace-migration-builder-exception-v2';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration-v2/services/workspace-migration-validate-build-and-run-service';
 
 @Injectable()
 export class ViewFilterService {
   constructor(
     @InjectRepository(ViewFilterEntity)
     private readonly viewFilterRepository: Repository<ViewFilterEntity>,
-    private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
+    private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+    private readonly applicationService: ApplicationService,
   ) {}
 
+  async createOne({
+    createViewFilterInput,
+    workspaceId,
+  }: {
+    createViewFilterInput: CreateViewFilterInput;
+    workspaceId: string;
+  }): Promise<ViewFilterDTO> {
+    const { workspaceCustomFlatApplication } =
+      await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+        {
+          workspaceId,
+        },
+      );
+
+    const {
+      flatViewFilterMaps: existingFlatViewFilterMaps,
+      flatViewMaps,
+      flatFieldMetadataMaps,
+      flatObjectMetadataMaps,
+    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+      {
+        workspaceId,
+        flatMapsKeys: [
+          'flatViewFilterMaps',
+          'flatViewMaps',
+          'flatFieldMetadataMaps',
+          'flatObjectMetadataMaps',
+        ],
+      },
+    );
+
+    const flatViewFilterToCreate =
+      fromCreateViewFilterInputToFlatViewFilterToCreate({
+        createViewFilterInput,
+        workspaceId,
+        workspaceCustomApplicationId: workspaceCustomFlatApplication.id,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatViewFilterMaps: computeFlatEntityMapsFromTo({
+              flatEntityMaps: existingFlatViewFilterMaps,
+              flatEntityToCreate: [flatViewFilterToCreate],
+              flatEntityToDelete: [],
+              flatEntityToUpdate: [],
+            }),
+          },
+          dependencyAllFlatEntityMaps: {
+            flatFieldMetadataMaps,
+            flatViewMaps,
+            flatObjectMetadataMaps,
+          },
+          buildOptions: {
+            isSystemBuild: false,
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while creating view filter',
+      );
+    }
+
+    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatViewFilterMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: flatViewFilterToCreate.id,
+      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
+    });
+  }
+
+  async updateOne({
+    updateViewFilterInput,
+    workspaceId,
+  }: {
+    workspaceId: string;
+    updateViewFilterInput: UpdateViewFilterInput;
+  }): Promise<ViewFilterDTO> {
+    const {
+      flatViewFilterMaps: existingFlatViewFilterMaps,
+      flatViewMaps,
+      flatFieldMetadataMaps,
+    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+      {
+        workspaceId,
+        flatMapsKeys: [
+          'flatViewFilterMaps',
+          'flatViewMaps',
+          'flatFieldMetadataMaps',
+        ],
+      },
+    );
+
+    const optimisticallyUpdatedFlatViewFilter =
+      fromUpdateViewFilterInputToFlatViewFilterToUpdateOrThrow({
+        flatViewFilterMaps: existingFlatViewFilterMaps,
+        updateViewFilterInput,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatViewFilterMaps: computeFlatEntityMapsFromTo({
+              flatEntityMaps: existingFlatViewFilterMaps,
+              flatEntityToCreate: [],
+              flatEntityToDelete: [],
+              flatEntityToUpdate: [optimisticallyUpdatedFlatViewFilter],
+            }),
+          },
+          dependencyAllFlatEntityMaps: {
+            flatViewMaps,
+            flatFieldMetadataMaps,
+          },
+          buildOptions: {
+            isSystemBuild: false,
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while updating view filter',
+      );
+    }
+
+    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatViewFilterMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: optimisticallyUpdatedFlatViewFilter.id,
+      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
+    });
+  }
+
+  async deleteOne({
+    deleteViewFilterInput,
+    workspaceId,
+  }: {
+    deleteViewFilterInput: DeleteViewFilterInput;
+    workspaceId: string;
+  }): Promise<ViewFilterDTO> {
+    const {
+      flatViewFilterMaps: existingFlatViewFilterMaps,
+      flatViewMaps,
+      flatFieldMetadataMaps,
+    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+      {
+        workspaceId,
+        flatMapsKeys: [
+          'flatViewFilterMaps',
+          'flatViewMaps',
+          'flatFieldMetadataMaps',
+        ],
+      },
+    );
+
+    const optimisticallyUpdatedFlatViewFilterWithDeletedAt =
+      fromDeleteViewFilterInputToFlatViewFilterOrThrow({
+        flatViewFilterMaps: existingFlatViewFilterMaps,
+        deleteViewFilterInput,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatViewFilterMaps: computeFlatEntityMapsFromTo({
+              flatEntityMaps: existingFlatViewFilterMaps,
+              flatEntityToCreate: [],
+              flatEntityToDelete: [],
+              flatEntityToUpdate: [
+                optimisticallyUpdatedFlatViewFilterWithDeletedAt,
+              ],
+            }),
+          },
+          dependencyAllFlatEntityMaps: {
+            flatFieldMetadataMaps,
+            flatViewMaps,
+          },
+          buildOptions: {
+            isSystemBuild: false,
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while deleting view filter',
+      );
+    }
+
+    const { flatViewFilterMaps: recomputedExistingFlatViewFilterMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatMapsKeys: ['flatViewFilterMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: optimisticallyUpdatedFlatViewFilterWithDeletedAt.id,
+      flatEntityMaps: recomputedExistingFlatViewFilterMaps,
+    });
+  }
+
+  async destroyOne({
+    destroyViewFilterInput,
+    workspaceId,
+  }: {
+    destroyViewFilterInput: DestroyViewFilterInput;
+    workspaceId: string;
+  }): Promise<ViewFilterDTO> {
+    const {
+      flatViewFilterMaps: existingFlatViewFilterMaps,
+      flatViewMaps: existingFlatViewMaps,
+      flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
+    } = await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+      {
+        workspaceId,
+        flatMapsKeys: [
+          'flatViewFilterMaps',
+          'flatViewMaps',
+          'flatFieldMetadataMaps',
+        ],
+      },
+    );
+
+    const existingViewFilterToDelete =
+      fromDestroyViewFilterInputToFlatViewFilterOrThrow({
+        destroyViewFilterInput,
+        flatViewFilterMaps: existingFlatViewFilterMaps,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatViewFilterMaps: computeFlatEntityMapsFromTo({
+              flatEntityMaps: existingFlatViewFilterMaps,
+              flatEntityToCreate: [],
+              flatEntityToDelete: [existingViewFilterToDelete],
+              flatEntityToUpdate: [],
+            }),
+          },
+          dependencyAllFlatEntityMaps: {
+            flatViewMaps: existingFlatViewMaps,
+            flatFieldMetadataMaps: existingFlatFieldMetadataMaps,
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: {
+              viewFilter: true,
+            },
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while destroying view filter',
+      );
+    }
+
+    return existingViewFilterToDelete;
+  }
+
   async findByWorkspaceId(workspaceId: string): Promise<ViewFilterEntity[]> {
     return this.viewFilterRepository.find({
       where: {
@@ -64,141 +361,4 @@ export class ViewFilterService {
 
     return viewFilter || null;
   }
-
-  async create(
-    viewFilterData: Partial<ViewFilterEntity>,
-  ): Promise<ViewFilterEntity> {
-    if (!isDefined(viewFilterData.workspaceId)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.WORKSPACE_ID_REQUIRED,
-        ),
-        ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-        {
-          userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-            ViewFilterExceptionMessageKey.WORKSPACE_ID_REQUIRED,
-          ),
-        },
-      );
-    }
-
-    if (!isDefined(viewFilterData.viewId)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.VIEW_ID_REQUIRED,
-        ),
-        ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-        {
-          userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-            ViewFilterExceptionMessageKey.VIEW_ID_REQUIRED,
-          ),
-        },
-      );
-    }
-
-    if (!isDefined(viewFilterData.fieldMetadataId)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.FIELD_METADATA_ID_REQUIRED,
-        ),
-        ViewFilterExceptionCode.INVALID_VIEW_FILTER_DATA,
-        {
-          userFriendlyMessage: generateViewFilterUserFriendlyExceptionMessage(
-            ViewFilterExceptionMessageKey.FIELD_METADATA_ID_REQUIRED,
-          ),
-        },
-      );
-    }
-
-    const viewFilter = this.viewFilterRepository.create(viewFilterData);
-
-    await this.flushGraphQLCache(viewFilterData.workspaceId);
-
-    const savedViewFilter = await this.viewFilterRepository.save(viewFilter);
-
-    await this.flushGraphQLCache(viewFilterData.workspaceId);
-
-    return savedViewFilter;
-  }
-
-  async update(
-    id: string,
-    workspaceId: string,
-    updateData: Partial<ViewFilterEntity>,
-  ): Promise<ViewFilterEntity> {
-    const existingViewFilter = await this.findById(id, workspaceId);
-
-    if (!isDefined(existingViewFilter)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.VIEW_FILTER_NOT_FOUND,
-          id,
-        ),
-        ViewFilterExceptionCode.VIEW_FILTER_NOT_FOUND,
-      );
-    }
-
-    const updatedViewFilter = await this.viewFilterRepository.save({
-      id,
-      ...updateData,
-    });
-
-    await this.flushGraphQLCache(workspaceId);
-
-    return { ...existingViewFilter, ...updatedViewFilter };
-  }
-
-  async delete(id: string, workspaceId: string): Promise<ViewFilterEntity> {
-    const viewFilter = await this.findById(id, workspaceId);
-
-    if (!isDefined(viewFilter)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.VIEW_FILTER_NOT_FOUND,
-          id,
-        ),
-        ViewFilterExceptionCode.VIEW_FILTER_NOT_FOUND,
-      );
-    }
-
-    await this.viewFilterRepository.softDelete(id);
-
-    await this.flushGraphQLCache(workspaceId);
-
-    return viewFilter;
-  }
-
-  async destroy(id: string, workspaceId: string): Promise<ViewFilterEntity> {
-    const viewFilter = await this.viewFilterRepository.findOne({
-      where: {
-        id,
-        workspaceId,
-      },
-      relations: ['workspace', 'view', 'viewFilterGroup'],
-      withDeleted: true,
-    });
-
-    if (!isDefined(viewFilter)) {
-      throw new ViewFilterException(
-        generateViewFilterExceptionMessage(
-          ViewFilterExceptionMessageKey.VIEW_FILTER_NOT_FOUND,
-          id,
-        ),
-        ViewFilterExceptionCode.VIEW_FILTER_NOT_FOUND,
-      );
-    }
-
-    await this.viewFilterRepository.delete(id);
-
-    await this.flushGraphQLCache(workspaceId);
-
-    return viewFilter;
-  }
-
-  private async flushGraphQLCache(workspaceId: string): Promise<void> {
-    await this.workspaceCacheStorageService.flushGraphQLOperation({
-      operationName: FIND_ALL_CORE_VIEWS_GRAPHQL_OPERATION,
-      workspaceId,
-    });
-  }
 }

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

@@ -2,13 +2,11 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
-import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
 import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
 import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
 import { ViewFilterController } from 'src/engine/metadata-modules/view-filter/controllers/view-filter.controller';
 import { ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
 import { ViewFilterResolver } from 'src/engine/metadata-modules/view-filter/resolvers/view-filter.resolver';
-import { ViewFilterV2Service } from 'src/engine/metadata-modules/view-filter/services/view-filter-v2.service';
 import { ViewFilterService } from 'src/engine/metadata-modules/view-filter/services/view-filter.service';
 import { ViewPermissionsModule } from 'src/engine/metadata-modules/view-permissions/view-permissions.module';
 import { ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
@@ -20,14 +18,13 @@ import { WorkspaceMigrationV2Module } from 'src/engine/workspace-manager/workspa
     TypeOrmModule.forFeature([ViewFilterEntity, ViewEntity]),
     WorkspaceCacheStorageModule,
     ApplicationModule,
-    FeatureFlagModule,
     PermissionsModule,
     WorkspaceMigrationV2Module,
     WorkspaceManyOrAllFlatEntityMapsCacheModule,
     ViewPermissionsModule,
   ],
   controllers: [ViewFilterController],
-  providers: [ViewFilterService, ViewFilterResolver, ViewFilterV2Service],
-  exports: [ViewFilterService, ViewFilterV2Service],
+  providers: [ViewFilterService, ViewFilterResolver],
+  exports: [ViewFilterService],
 })
 export class ViewFilterModule {}