Add missing FK on view tables (#14084)

## Context
View tables were missing some FK, we are also introducing delete cascade
on those tables when needed to leverage pg cascade deletion instead of
having to implement it.
Also renaming those classes with Entity suffix to follow repo
guidelines.

packages/twenty-server/src/engine/core-modules/view/controllers/view-field.controller.ts

@@ -15,7 +15,7 @@ import { isDefined } from 'twenty-shared/utils';
 
 import { CreateViewFieldInput } from 'src/engine/core-modules/view/dtos/inputs/create-view-field.input';
 import { UpdateViewFieldInput } from 'src/engine/core-modules/view/dtos/inputs/update-view-field.input';
-import { type ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { type ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
 import { ViewFieldRestApiExceptionFilter } from 'src/engine/core-modules/view/filters/view-field-rest-api-exception.filter';
 import { ViewFieldService } from 'src/engine/core-modules/view/services/view-field.service';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
@@ -32,7 +32,7 @@ export class ViewFieldController {
   async findMany(
     @AuthWorkspace() workspace: Workspace,
     @Query('viewId') viewId?: string,
-  ): Promise<ViewField[]> {
+  ): Promise<ViewFieldEntity[]> {
     if (viewId) {
       return this.viewFieldService.findByViewId(workspace.id, viewId);
     }
@@ -44,7 +44,7 @@ export class ViewFieldController {
   async findOne(
     @Param('id') id: string,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField | null> {
+  ): Promise<ViewFieldEntity | null> {
     return this.viewFieldService.findById(id, workspace.id);
   }
 
@@ -53,7 +53,7 @@ export class ViewFieldController {
     @Param('id') id: string,
     @Body() input: UpdateViewFieldInput,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField> {
+  ): Promise<ViewFieldEntity> {
     const updatedViewField = await this.viewFieldService.update(
       id,
       workspace.id,
@@ -67,7 +67,7 @@ export class ViewFieldController {
   async create(
     @Body() input: CreateViewFieldInput,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField> {
+  ): Promise<ViewFieldEntity> {
     return this.viewFieldService.create({
       ...input,
       workspaceId: workspace.id,

packages/twenty-server/src/engine/core-modules/view/entities/view-field.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -13,9 +12,9 @@ import {
 } from 'typeorm';
 
 import { AggregateOperations } from 'src/engine/api/graphql/graphql-query-runner/constants/aggregate-operations.constant';
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
 @Entity({ name: 'viewField', schema: 'core' })
 @Index('IDX_VIEW_FIELD_WORKSPACE_ID_VIEW_ID', ['workspaceId', 'viewId'])
@@ -27,14 +26,19 @@ import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
     where: '"deletedAt" IS NULL',
   },
 )
-export class ViewField {
-  @IDField(() => UUIDScalarType)
+export class ViewFieldEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
   @Column({ nullable: false, type: 'uuid' })
   fieldMetadataId: string;
 
+  @ManyToOne(() => FieldMetadataEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'fieldMetadataId' })
+  fieldMetadata: Relation<FieldMetadataEntity>;
+
   @Column({ nullable: false, default: true })
   isVisible: boolean;
 
@@ -73,9 +77,9 @@ export class ViewField {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @ManyToOne(() => View, (view) => view.viewFields, {
+  @ManyToOne(() => ViewEntity, (view) => view.viewFields, {
     onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'viewId' })
-  view: Relation<View>;
+  view: Relation<ViewEntity>;
 }

packages/twenty-server/src/engine/core-modules/view/entities/view-filter-group.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -13,16 +12,14 @@ import {
   UpdateDateColumn,
 } from 'typeorm';
 
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { ViewFilter } from 'src/engine/core-modules/view/entities/view-filter.entity';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewFilterEntity } from 'src/engine/core-modules/view/entities/view-filter.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { ViewFilterGroupLogicalOperator } from 'src/engine/core-modules/view/enums/view-filter-group-logical-operator';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 
 @Entity({ name: 'viewFilterGroup', schema: 'core' })
 @Index('IDX_VIEW_FILTER_GROUP_WORKSPACE_ID_VIEW_ID', ['workspaceId', 'viewId'])
-export class ViewFilterGroup {
-  @IDField(() => UUIDScalarType)
+export class ViewFilterGroupEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
@@ -61,28 +58,28 @@ export class ViewFilterGroup {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @ManyToOne(() => View, (view) => view.viewFilterGroups, {
+  @ManyToOne(() => ViewEntity, (view) => view.viewFilterGroups, {
     onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'viewId' })
-  view: Relation<View>;
+  view: Relation<ViewEntity>;
 
-  @OneToMany(() => ViewFilter, (viewFilter) => viewFilter.viewFilterGroup)
-  viewFilters: Relation<ViewFilter>[];
+  @OneToMany(() => ViewFilterEntity, (viewFilter) => viewFilter.viewFilterGroup)
+  viewFilters: Relation<ViewFilterEntity>[];
 
   @ManyToOne(
-    () => ViewFilterGroup,
+    () => ViewFilterGroupEntity,
     (viewFilterGroup) => viewFilterGroup.childViewFilterGroups,
     {
       onDelete: 'CASCADE',
     },
   )
   @JoinColumn({ name: 'parentViewFilterGroupId' })
-  parentViewFilterGroup: Relation<ViewFilterGroup>;
+  parentViewFilterGroup: Relation<ViewFilterGroupEntity>;
 
   @OneToMany(
-    () => ViewFilterGroup,
+    () => ViewFilterGroupEntity,
     (viewFilterGroup) => viewFilterGroup.parentViewFilterGroup,
   )
-  childViewFilterGroups: Relation<ViewFilterGroup>[];
+  childViewFilterGroups: Relation<ViewFilterGroupEntity>[];
 }

packages/twenty-server/src/engine/core-modules/view/entities/view-filter.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -12,24 +11,29 @@ import {
   UpdateDateColumn,
 } from 'typeorm';
 
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { ViewFilterGroup } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewFilterGroupEntity } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { ViewFilterOperand } from 'src/engine/core-modules/view/enums/view-filter-operand';
 import { ViewFilterValue } from 'src/engine/core-modules/view/types/view-filter-value.type';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
 @Entity({ name: 'viewFilter', schema: 'core' })
 @Index('IDX_VIEW_FILTER_WORKSPACE_ID_VIEW_ID', ['workspaceId', 'viewId'])
 @Index('IDX_VIEW_FILTER_FIELD_METADATA_ID', ['fieldMetadataId'])
-export class ViewFilter {
-  @IDField(() => UUIDScalarType)
+export class ViewFilterEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
   @Column({ nullable: false, type: 'uuid' })
   fieldMetadataId: string;
 
+  @ManyToOne(() => FieldMetadataEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'fieldMetadataId' })
+  fieldMetadata: Relation<FieldMetadataEntity>;
+
   @Column({
     nullable: false,
     type: 'enum',
@@ -71,19 +75,19 @@ export class ViewFilter {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @ManyToOne(() => View, (view) => view.viewFilters, {
+  @ManyToOne(() => ViewEntity, (view) => view.viewFilters, {
     onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'viewId' })
-  view: Relation<View>;
+  view: Relation<ViewEntity>;
 
   @ManyToOne(
-    () => ViewFilterGroup,
+    () => ViewFilterGroupEntity,
     (viewFilterGroup) => viewFilterGroup.viewFilters,
     {
       onDelete: 'CASCADE',
     },
   )
   @JoinColumn({ name: 'viewFilterGroupId' })
-  viewFilterGroup: Relation<ViewFilterGroup>;
+  viewFilterGroup: Relation<ViewFilterGroupEntity>;
 }

packages/twenty-server/src/engine/core-modules/view/entities/view-group.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -12,20 +11,25 @@ import {
   UpdateDateColumn,
 } from 'typeorm';
 
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
 @Entity({ name: 'viewGroup', schema: 'core' })
 @Index('IDX_VIEW_GROUP_WORKSPACE_ID_VIEW_ID', ['workspaceId', 'viewId'])
-export class ViewGroup {
-  @IDField(() => UUIDScalarType)
+export class ViewGroupEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
   @Column({ nullable: false, type: 'uuid' })
   fieldMetadataId: string;
 
+  @ManyToOne(() => FieldMetadataEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'fieldMetadataId' })
+  fieldMetadata: Relation<FieldMetadataEntity>;
+
   @Column({ nullable: false, default: true })
   isVisible: boolean;
 
@@ -56,9 +60,9 @@ export class ViewGroup {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @ManyToOne(() => View, (view) => view.viewGroups, {
+  @ManyToOne(() => ViewEntity, (view) => view.viewGroups, {
     onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'viewId' })
-  view: Relation<View>;
+  view: Relation<ViewEntity>;
 }

packages/twenty-server/src/engine/core-modules/view/entities/view-sort.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -12,10 +11,10 @@ import {
   UpdateDateColumn,
 } from 'typeorm';
 
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { ViewSortDirection } from 'src/engine/core-modules/view/enums/view-sort-direction';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
 @Entity({ name: 'viewSort', schema: 'core' })
 @Index('IDX_VIEW_SORT_WORKSPACE_ID_VIEW_ID', ['workspaceId', 'viewId'])
@@ -27,14 +26,19 @@ import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
     where: '"deletedAt" IS NULL',
   },
 )
-export class ViewSort {
-  @IDField(() => UUIDScalarType)
+export class ViewSortEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
   @Column({ nullable: false, type: 'uuid' })
   fieldMetadataId: string;
 
+  @ManyToOne(() => FieldMetadataEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'fieldMetadataId' })
+  fieldMetadata: Relation<FieldMetadataEntity>;
+
   @Column({
     nullable: false,
     type: 'enum',
@@ -64,9 +68,9 @@ export class ViewSort {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @ManyToOne(() => View, (view) => view.viewSorts, {
+  @ManyToOne(() => ViewEntity, (view) => view.viewSorts, {
     onDelete: 'CASCADE',
   })
   @JoinColumn({ name: 'viewId' })
-  view: Relation<View>;
+  view: Relation<ViewEntity>;
 }

packages/twenty-server/src/engine/core-modules/view/entities/view.entity.ts

@@ -1,4 +1,3 @@
-import { IDField } from '@ptc-org/nestjs-query-graphql';
 import {
   Column,
   CreateDateColumn,
@@ -14,24 +13,23 @@ import {
 } from 'typeorm';
 
 import { AggregateOperations } from 'src/engine/api/graphql/graphql-query-runner/constants/aggregate-operations.constant';
-import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
-import { ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
-import { ViewFilterGroup } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
-import { ViewFilter } from 'src/engine/core-modules/view/entities/view-filter.entity';
-import { ViewGroup } from 'src/engine/core-modules/view/entities/view-group.entity';
-import { ViewSort } from 'src/engine/core-modules/view/entities/view-sort.entity';
+import { ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { ViewFilterGroupEntity } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
+import { ViewFilterEntity } from 'src/engine/core-modules/view/entities/view-filter.entity';
+import { ViewGroupEntity } from 'src/engine/core-modules/view/entities/view-group.entity';
+import { ViewSortEntity } from 'src/engine/core-modules/view/entities/view-sort.entity';
 import { ViewKey } from 'src/engine/core-modules/view/enums/view-key.enum';
 import { ViewOpenRecordIn } from 'src/engine/core-modules/view/enums/view-open-record-in';
 import { ViewType } from 'src/engine/core-modules/view/enums/view-type.enum';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 
 @Entity({ name: 'view', schema: 'core' })
 @Index('IDX_VIEW_WORKSPACE_ID_OBJECT_METADATA_ID', [
   'workspaceId',
   'objectMetadataId',
 ])
-export class View {
-  @IDField(() => UUIDScalarType)
+export class ViewEntity {
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
@@ -41,6 +39,12 @@ export class View {
   @Column({ nullable: false, type: 'uuid' })
   objectMetadataId: string;
 
+  @ManyToOne(() => ObjectMetadataEntity, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'objectMetadataId' })
+  objectMetadata: Relation<ObjectMetadataEntity>;
+
   @Column({
     type: 'enum',
     enum: Object.values(ViewType),
@@ -109,18 +113,21 @@ export class View {
   @JoinColumn({ name: 'workspaceId' })
   workspace: Relation<Workspace>;
 
-  @OneToMany(() => ViewField, (viewField) => viewField.view)
-  viewFields: Relation<ViewField[]>;
+  @OneToMany(() => ViewFieldEntity, (viewField) => viewField.view)
+  viewFields: Relation<ViewFieldEntity[]>;
 
-  @OneToMany(() => ViewFilter, (viewFilter) => viewFilter.view)
-  viewFilters: Relation<ViewFilter[]>;
+  @OneToMany(() => ViewFilterEntity, (viewFilter) => viewFilter.view)
+  viewFilters: Relation<ViewFilterEntity[]>;
 
-  @OneToMany(() => ViewSort, (viewSort) => viewSort.view)
-  viewSorts: Relation<ViewSort[]>;
+  @OneToMany(() => ViewSortEntity, (viewSort) => viewSort.view)
+  viewSorts: Relation<ViewSortEntity[]>;
 
-  @OneToMany(() => ViewGroup, (viewGroup) => viewGroup.view)
-  viewGroups: Relation<ViewGroup[]>;
+  @OneToMany(() => ViewGroupEntity, (viewGroup) => viewGroup.view)
+  viewGroups: Relation<ViewGroupEntity[]>;
 
-  @OneToMany(() => ViewFilterGroup, (viewFilterGroup) => viewFilterGroup.view)
-  viewFilterGroups: Relation<ViewFilterGroup[]>;
+  @OneToMany(
+    () => ViewFilterGroupEntity,
+    (viewFilterGroup) => viewFilterGroup.view,
+  )
+  viewFilterGroups: Relation<ViewFilterGroupEntity[]>;
 }

packages/twenty-server/src/engine/core-modules/view/resolvers/view-field.resolver.ts

@@ -6,7 +6,7 @@ import { isDefined } from 'twenty-shared/utils';
 import { CreateViewFieldInput } from 'src/engine/core-modules/view/dtos/inputs/create-view-field.input';
 import { UpdateViewFieldInput } from 'src/engine/core-modules/view/dtos/inputs/update-view-field.input';
 import { ViewFieldDTO } from 'src/engine/core-modules/view/dtos/view-field.dto';
-import { type ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { type ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
 import { ViewFieldService } from 'src/engine/core-modules/view/services/view-field.service';
 import { ViewGraphqlApiExceptionFilter } from 'src/engine/core-modules/view/utils/view-graphql-api-exception.filter';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
@@ -23,7 +23,7 @@ export class ViewFieldResolver {
   async getCoreViewFields(
     @Args('viewId', { type: () => String }) viewId: string,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField[]> {
+  ): Promise<ViewFieldEntity[]> {
     return this.viewFieldService.findByViewId(workspace.id, viewId);
   }
 
@@ -31,7 +31,7 @@ export class ViewFieldResolver {
   async getCoreViewField(
     @Args('id', { type: () => String }) id: string,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField | null> {
+  ): Promise<ViewFieldEntity | null> {
     return this.viewFieldService.findById(id, workspace.id);
   }
 
@@ -40,7 +40,7 @@ export class ViewFieldResolver {
     @Args('id', { type: () => String }) id: string,
     @Args('input') input: UpdateViewFieldInput,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField> {
+  ): Promise<ViewFieldEntity> {
     return this.viewFieldService.update(id, workspace.id, input);
   }
 
@@ -48,7 +48,7 @@ export class ViewFieldResolver {
   async createCoreViewField(
     @Args('input') input: CreateViewFieldInput,
     @AuthWorkspace() workspace: Workspace,
-  ): Promise<ViewField> {
+  ): Promise<ViewFieldEntity> {
     return this.viewFieldService.create({
       ...input,
       workspaceId: workspace.id,

packages/twenty-server/src/engine/core-modules/view/services/tests/view-field.service.spec.ts

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
 import {
   ViewFieldException,
   ViewFieldExceptionCode,
@@ -15,7 +15,7 @@ import { ViewFieldService } from 'src/engine/core-modules/view/services/view-fie
 
 describe('ViewFieldService', () => {
   let viewFieldService: ViewFieldService;
-  let viewFieldRepository: Repository<ViewField>;
+  let viewFieldRepository: Repository<ViewFieldEntity>;
 
   const mockViewField = {
     id: 'view-field-id',
@@ -28,14 +28,14 @@ describe('ViewFieldService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as ViewField;
+  } as ViewFieldEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewFieldService,
         {
-          provide: getRepositoryToken(ViewField, 'core'),
+          provide: getRepositoryToken(ViewFieldEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -49,8 +49,8 @@ describe('ViewFieldService', () => {
     }).compile();
 
     viewFieldService = module.get<ViewFieldService>(ViewFieldService);
-    viewFieldRepository = module.get<Repository<ViewField>>(
-      getRepositoryToken(ViewField, 'core'),
+    viewFieldRepository = module.get<Repository<ViewFieldEntity>>(
+      getRepositoryToken(ViewFieldEntity, 'core'),
     );
   });
 

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

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { ViewFilterGroup } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
+import { ViewFilterGroupEntity } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
 import { ViewFilterGroupLogicalOperator } from 'src/engine/core-modules/view/enums/view-filter-group-logical-operator';
 import {
   ViewFilterGroupException,
@@ -16,7 +16,7 @@ import { ViewFilterGroupService } from 'src/engine/core-modules/view/services/vi
 
 describe('ViewFilterGroupService', () => {
   let viewFilterGroupService: ViewFilterGroupService;
-  let viewFilterGroupRepository: Repository<ViewFilterGroup>;
+  let viewFilterGroupRepository: Repository<ViewFilterGroupEntity>;
 
   const mockViewFilterGroup = {
     id: 'view-filter-group-id',
@@ -27,14 +27,14 @@ describe('ViewFilterGroupService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as ViewFilterGroup;
+  } as ViewFilterGroupEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewFilterGroupService,
         {
-          provide: getRepositoryToken(ViewFilterGroup, 'core'),
+          provide: getRepositoryToken(ViewFilterGroupEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -50,8 +50,8 @@ describe('ViewFilterGroupService', () => {
     viewFilterGroupService = module.get<ViewFilterGroupService>(
       ViewFilterGroupService,
     );
-    viewFilterGroupRepository = module.get<Repository<ViewFilterGroup>>(
-      getRepositoryToken(ViewFilterGroup, 'core'),
+    viewFilterGroupRepository = module.get<Repository<ViewFilterGroupEntity>>(
+      getRepositoryToken(ViewFilterGroupEntity, 'core'),
     );
   });
 

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

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { ViewFilter } from 'src/engine/core-modules/view/entities/view-filter.entity';
+import { ViewFilterEntity } from 'src/engine/core-modules/view/entities/view-filter.entity';
 import { ViewFilterOperand } from 'src/engine/core-modules/view/enums/view-filter-operand';
 import {
   ViewFilterException,
@@ -16,7 +16,7 @@ import { ViewFilterService } from 'src/engine/core-modules/view/services/view-fi
 
 describe('ViewFilterService', () => {
   let viewFilterService: ViewFilterService;
-  let viewFilterRepository: Repository<ViewFilter>;
+  let viewFilterRepository: Repository<ViewFilterEntity>;
 
   const mockViewFilter = {
     id: 'view-filter-id',
@@ -29,14 +29,14 @@ describe('ViewFilterService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as ViewFilter;
+  } as ViewFilterEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewFilterService,
         {
-          provide: getRepositoryToken(ViewFilter, 'core'),
+          provide: getRepositoryToken(ViewFilterEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -50,8 +50,8 @@ describe('ViewFilterService', () => {
     }).compile();
 
     viewFilterService = module.get<ViewFilterService>(ViewFilterService);
-    viewFilterRepository = module.get<Repository<ViewFilter>>(
-      getRepositoryToken(ViewFilter, 'core'),
+    viewFilterRepository = module.get<Repository<ViewFilterEntity>>(
+      getRepositoryToken(ViewFilterEntity, 'core'),
     );
   });
 

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

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { ViewGroup } from 'src/engine/core-modules/view/entities/view-group.entity';
+import { ViewGroupEntity } from 'src/engine/core-modules/view/entities/view-group.entity';
 import {
   ViewGroupException,
   ViewGroupExceptionCode,
@@ -15,7 +15,7 @@ import { ViewGroupService } from 'src/engine/core-modules/view/services/view-gro
 
 describe('ViewGroupService', () => {
   let viewGroupService: ViewGroupService;
-  let viewGroupRepository: Repository<ViewGroup>;
+  let viewGroupRepository: Repository<ViewGroupEntity>;
 
   const mockViewGroup = {
     id: 'view-group-id',
@@ -28,14 +28,14 @@ describe('ViewGroupService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as ViewGroup;
+  } as ViewGroupEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewGroupService,
         {
-          provide: getRepositoryToken(ViewGroup, 'core'),
+          provide: getRepositoryToken(ViewGroupEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -49,8 +49,8 @@ describe('ViewGroupService', () => {
     }).compile();
 
     viewGroupService = module.get<ViewGroupService>(ViewGroupService);
-    viewGroupRepository = module.get<Repository<ViewGroup>>(
-      getRepositoryToken(ViewGroup, 'core'),
+    viewGroupRepository = module.get<Repository<ViewGroupEntity>>(
+      getRepositoryToken(ViewGroupEntity, 'core'),
     );
   });
 

packages/twenty-server/src/engine/core-modules/view/services/tests/view-sort.service.spec.ts

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { ViewSort } from 'src/engine/core-modules/view/entities/view-sort.entity';
+import { ViewSortEntity } from 'src/engine/core-modules/view/entities/view-sort.entity';
 import { ViewSortDirection } from 'src/engine/core-modules/view/enums/view-sort-direction';
 import {
   ViewSortException,
@@ -16,7 +16,7 @@ import { ViewSortService } from 'src/engine/core-modules/view/services/view-sort
 
 describe('ViewSortService', () => {
   let viewSortService: ViewSortService;
-  let viewSortRepository: Repository<ViewSort>;
+  let viewSortRepository: Repository<ViewSortEntity>;
 
   const mockViewSort = {
     id: 'view-sort-id',
@@ -27,14 +27,14 @@ describe('ViewSortService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as ViewSort;
+  } as ViewSortEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewSortService,
         {
-          provide: getRepositoryToken(ViewSort, 'core'),
+          provide: getRepositoryToken(ViewSortEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -48,8 +48,8 @@ describe('ViewSortService', () => {
     }).compile();
 
     viewSortService = module.get<ViewSortService>(ViewSortService);
-    viewSortRepository = module.get<Repository<ViewSort>>(
-      getRepositoryToken(ViewSort, 'core'),
+    viewSortRepository = module.get<Repository<ViewSortEntity>>(
+      getRepositoryToken(ViewSortEntity, 'core'),
     );
   });
 

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

@@ -3,7 +3,7 @@ import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { type Repository } from 'typeorm';
 
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { ViewOpenRecordIn } from 'src/engine/core-modules/view/enums/view-open-record-in';
 import { ViewType } from 'src/engine/core-modules/view/enums/view-type.enum';
 import {
@@ -17,7 +17,7 @@ import { ViewService } from 'src/engine/core-modules/view/services/view.service'
 
 describe('ViewService', () => {
   let viewService: ViewService;
-  let viewRepository: Repository<View>;
+  let viewRepository: Repository<ViewEntity>;
 
   const mockView = {
     id: 'view-id',
@@ -37,14 +37,14 @@ describe('ViewService', () => {
     createdAt: new Date(),
     updatedAt: new Date(),
     deletedAt: null,
-  } as View;
+  } as ViewEntity;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ViewService,
         {
-          provide: getRepositoryToken(View, 'core'),
+          provide: getRepositoryToken(ViewEntity, 'core'),
           useValue: {
             find: jest.fn(),
             findOne: jest.fn(),
@@ -58,8 +58,8 @@ describe('ViewService', () => {
     }).compile();
 
     viewService = module.get<ViewService>(ViewService);
-    viewRepository = module.get<Repository<View>>(
-      getRepositoryToken(View, 'core'),
+    viewRepository = module.get<Repository<ViewEntity>>(
+      getRepositoryToken(ViewEntity, 'core'),
     );
   });
 

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
 import {
   ViewFieldException,
   ViewFieldExceptionCode,
@@ -16,11 +16,11 @@ import {
 @Injectable()
 export class ViewFieldService {
   constructor(
-    @InjectRepository(ViewField, 'core')
-    private readonly viewFieldRepository: Repository<ViewField>,
+    @InjectRepository(ViewFieldEntity, 'core')
+    private readonly viewFieldRepository: Repository<ViewFieldEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<ViewField[]> {
+  async findByWorkspaceId(workspaceId: string): Promise<ViewFieldEntity[]> {
     return this.viewFieldRepository.find({
       where: {
         workspaceId,
@@ -34,7 +34,7 @@ export class ViewFieldService {
   async findByViewId(
     workspaceId: string,
     viewId: string,
-  ): Promise<ViewField[]> {
+  ): Promise<ViewFieldEntity[]> {
     return this.viewFieldRepository.find({
       where: {
         workspaceId,
@@ -46,7 +46,10 @@ export class ViewFieldService {
     });
   }
 
-  async findById(id: string, workspaceId: string): Promise<ViewField | null> {
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<ViewFieldEntity | null> {
     const viewField = await this.viewFieldRepository.findOne({
       where: {
         id,
@@ -59,7 +62,9 @@ export class ViewFieldService {
     return viewField || null;
   }
 
-  async create(viewFieldData: Partial<ViewField>): Promise<ViewField> {
+  async create(
+    viewFieldData: Partial<ViewFieldEntity>,
+  ): Promise<ViewFieldEntity> {
     if (!isDefined(viewFieldData.workspaceId)) {
       throw new ViewFieldException(
         generateViewFieldExceptionMessage(
@@ -110,8 +115,8 @@ export class ViewFieldService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<ViewField>,
-  ): Promise<ViewField> {
+    updateData: Partial<ViewFieldEntity>,
+  ): Promise<ViewFieldEntity> {
     const existingViewField = await this.findById(id, workspaceId);
 
     if (!isDefined(existingViewField)) {
@@ -132,7 +137,7 @@ export class ViewFieldService {
     return { ...existingViewField, ...updatedViewField };
   }
 
-  async delete(id: string, workspaceId: string): Promise<ViewField> {
+  async delete(id: string, workspaceId: string): Promise<ViewFieldEntity> {
     const viewField = await this.findById(id, workspaceId);
 
     if (!isDefined(viewField)) {

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ViewFilterGroup } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
+import { ViewFilterGroupEntity } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
 import {
   ViewFilterGroupException,
   ViewFilterGroupExceptionCode,
@@ -16,11 +16,13 @@ import {
 @Injectable()
 export class ViewFilterGroupService {
   constructor(
-    @InjectRepository(ViewFilterGroup, 'core')
-    private readonly viewFilterGroupRepository: Repository<ViewFilterGroup>,
+    @InjectRepository(ViewFilterGroupEntity, 'core')
+    private readonly viewFilterGroupRepository: Repository<ViewFilterGroupEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<ViewFilterGroup[]> {
+  async findByWorkspaceId(
+    workspaceId: string,
+  ): Promise<ViewFilterGroupEntity[]> {
     return this.viewFilterGroupRepository.find({
       where: {
         workspaceId,
@@ -40,7 +42,7 @@ export class ViewFilterGroupService {
   async findByViewId(
     workspaceId: string,
     viewId: string,
-  ): Promise<ViewFilterGroup[]> {
+  ): Promise<ViewFilterGroupEntity[]> {
     return this.viewFilterGroupRepository.find({
       where: {
         workspaceId,
@@ -61,7 +63,7 @@ export class ViewFilterGroupService {
   async findById(
     id: string,
     workspaceId: string,
-  ): Promise<ViewFilterGroup | null> {
+  ): Promise<ViewFilterGroupEntity | null> {
     const viewFilterGroup = await this.viewFilterGroupRepository.findOne({
       where: {
         id,
@@ -81,8 +83,8 @@ export class ViewFilterGroupService {
   }
 
   async create(
-    viewFilterGroupData: Partial<ViewFilterGroup>,
-  ): Promise<ViewFilterGroup> {
+    viewFilterGroupData: Partial<ViewFilterGroupEntity>,
+  ): Promise<ViewFilterGroupEntity> {
     if (!isDefined(viewFilterGroupData.workspaceId)) {
       throw new ViewFilterGroupException(
         generateViewFilterGroupExceptionMessage(
@@ -122,8 +124,8 @@ export class ViewFilterGroupService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<ViewFilterGroup>,
-  ): Promise<ViewFilterGroup> {
+    updateData: Partial<ViewFilterGroupEntity>,
+  ): Promise<ViewFilterGroupEntity> {
     const existingViewFilterGroup = await this.findById(id, workspaceId);
 
     if (!isDefined(existingViewFilterGroup)) {
@@ -144,7 +146,10 @@ export class ViewFilterGroupService {
     return { ...existingViewFilterGroup, ...updatedViewFilterGroup };
   }
 
-  async delete(id: string, workspaceId: string): Promise<ViewFilterGroup> {
+  async delete(
+    id: string,
+    workspaceId: string,
+  ): Promise<ViewFilterGroupEntity> {
     const viewFilterGroup = await this.findById(id, workspaceId);
 
     if (!isDefined(viewFilterGroup)) {

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ViewFilter } from 'src/engine/core-modules/view/entities/view-filter.entity';
+import { ViewFilterEntity } from 'src/engine/core-modules/view/entities/view-filter.entity';
 import {
   ViewFilterException,
   ViewFilterExceptionCode,
@@ -16,11 +16,11 @@ import {
 @Injectable()
 export class ViewFilterService {
   constructor(
-    @InjectRepository(ViewFilter, 'core')
-    private readonly viewFilterRepository: Repository<ViewFilter>,
+    @InjectRepository(ViewFilterEntity, 'core')
+    private readonly viewFilterRepository: Repository<ViewFilterEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<ViewFilter[]> {
+  async findByWorkspaceId(workspaceId: string): Promise<ViewFilterEntity[]> {
     return this.viewFilterRepository.find({
       where: {
         workspaceId,
@@ -34,7 +34,7 @@ export class ViewFilterService {
   async findByViewId(
     workspaceId: string,
     viewId: string,
-  ): Promise<ViewFilter[]> {
+  ): Promise<ViewFilterEntity[]> {
     return this.viewFilterRepository.find({
       where: {
         workspaceId,
@@ -46,7 +46,10 @@ export class ViewFilterService {
     });
   }
 
-  async findById(id: string, workspaceId: string): Promise<ViewFilter | null> {
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<ViewFilterEntity | null> {
     const viewFilter = await this.viewFilterRepository.findOne({
       where: {
         id,
@@ -59,7 +62,9 @@ export class ViewFilterService {
     return viewFilter || null;
   }
 
-  async create(viewFilterData: Partial<ViewFilter>): Promise<ViewFilter> {
+  async create(
+    viewFilterData: Partial<ViewFilterEntity>,
+  ): Promise<ViewFilterEntity> {
     if (!isDefined(viewFilterData.workspaceId)) {
       throw new ViewFilterException(
         generateViewFilterExceptionMessage(
@@ -110,8 +115,8 @@ export class ViewFilterService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<ViewFilter>,
-  ): Promise<ViewFilter> {
+    updateData: Partial<ViewFilterEntity>,
+  ): Promise<ViewFilterEntity> {
     const existingViewFilter = await this.findById(id, workspaceId);
 
     if (!isDefined(existingViewFilter)) {
@@ -132,7 +137,7 @@ export class ViewFilterService {
     return { ...existingViewFilter, ...updatedViewFilter };
   }
 
-  async delete(id: string, workspaceId: string): Promise<ViewFilter> {
+  async delete(id: string, workspaceId: string): Promise<ViewFilterEntity> {
     const viewFilter = await this.findById(id, workspaceId);
 
     if (!isDefined(viewFilter)) {

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ViewGroup } from 'src/engine/core-modules/view/entities/view-group.entity';
+import { ViewGroupEntity } from 'src/engine/core-modules/view/entities/view-group.entity';
 import {
   ViewGroupException,
   ViewGroupExceptionCode,
@@ -16,11 +16,11 @@ import {
 @Injectable()
 export class ViewGroupService {
   constructor(
-    @InjectRepository(ViewGroup, 'core')
-    private readonly viewGroupRepository: Repository<ViewGroup>,
+    @InjectRepository(ViewGroupEntity, 'core')
+    private readonly viewGroupRepository: Repository<ViewGroupEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<ViewGroup[]> {
+  async findByWorkspaceId(workspaceId: string): Promise<ViewGroupEntity[]> {
     return this.viewGroupRepository.find({
       where: {
         workspaceId,
@@ -34,7 +34,7 @@ export class ViewGroupService {
   async findByViewId(
     workspaceId: string,
     viewId: string,
-  ): Promise<ViewGroup[]> {
+  ): Promise<ViewGroupEntity[]> {
     return this.viewGroupRepository.find({
       where: {
         workspaceId,
@@ -46,7 +46,10 @@ export class ViewGroupService {
     });
   }
 
-  async findById(id: string, workspaceId: string): Promise<ViewGroup | null> {
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<ViewGroupEntity | null> {
     const viewGroup = await this.viewGroupRepository.findOne({
       where: {
         id,
@@ -59,7 +62,9 @@ export class ViewGroupService {
     return viewGroup || null;
   }
 
-  async create(viewGroupData: Partial<ViewGroup>): Promise<ViewGroup> {
+  async create(
+    viewGroupData: Partial<ViewGroupEntity>,
+  ): Promise<ViewGroupEntity> {
     if (!isDefined(viewGroupData.workspaceId)) {
       throw new ViewGroupException(
         generateViewGroupExceptionMessage(
@@ -110,8 +115,8 @@ export class ViewGroupService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<ViewGroup>,
-  ): Promise<ViewGroup> {
+    updateData: Partial<ViewGroupEntity>,
+  ): Promise<ViewGroupEntity> {
     const existingViewGroup = await this.findById(id, workspaceId);
 
     if (!isDefined(existingViewGroup)) {
@@ -132,7 +137,7 @@ export class ViewGroupService {
     return { ...existingViewGroup, ...updatedViewGroup };
   }
 
-  async delete(id: string, workspaceId: string): Promise<ViewGroup> {
+  async delete(id: string, workspaceId: string): Promise<ViewGroupEntity> {
     const viewGroup = await this.findById(id, workspaceId);
 
     if (!isDefined(viewGroup)) {

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ViewSort } from 'src/engine/core-modules/view/entities/view-sort.entity';
+import { ViewSortEntity } from 'src/engine/core-modules/view/entities/view-sort.entity';
 import {
   ViewSortException,
   ViewSortExceptionCode,
@@ -16,11 +16,11 @@ import {
 @Injectable()
 export class ViewSortService {
   constructor(
-    @InjectRepository(ViewSort, 'core')
-    private readonly viewSortRepository: Repository<ViewSort>,
+    @InjectRepository(ViewSortEntity, 'core')
+    private readonly viewSortRepository: Repository<ViewSortEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<ViewSort[]> {
+  async findByWorkspaceId(workspaceId: string): Promise<ViewSortEntity[]> {
     return this.viewSortRepository.find({
       where: {
         workspaceId,
@@ -30,7 +30,10 @@ export class ViewSortService {
     });
   }
 
-  async findByViewId(workspaceId: string, viewId: string): Promise<ViewSort[]> {
+  async findByViewId(
+    workspaceId: string,
+    viewId: string,
+  ): Promise<ViewSortEntity[]> {
     return this.viewSortRepository.find({
       where: {
         workspaceId,
@@ -41,7 +44,10 @@ export class ViewSortService {
     });
   }
 
-  async findById(id: string, workspaceId: string): Promise<ViewSort | null> {
+  async findById(
+    id: string,
+    workspaceId: string,
+  ): Promise<ViewSortEntity | null> {
     const viewSort = await this.viewSortRepository.findOne({
       where: {
         id,
@@ -54,7 +60,7 @@ export class ViewSortService {
     return viewSort || null;
   }
 
-  async create(viewSortData: Partial<ViewSort>): Promise<ViewSort> {
+  async create(viewSortData: Partial<ViewSortEntity>): Promise<ViewSortEntity> {
     if (!isDefined(viewSortData.workspaceId)) {
       throw new ViewSortException(
         generateViewSortExceptionMessage(
@@ -105,8 +111,8 @@ export class ViewSortService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<ViewSort>,
-  ): Promise<ViewSort> {
+    updateData: Partial<ViewSortEntity>,
+  ): Promise<ViewSortEntity> {
     const existingViewSort = await this.findById(id, workspaceId);
 
     if (!isDefined(existingViewSort)) {
@@ -127,7 +133,7 @@ export class ViewSortService {
     return { ...existingViewSort, ...updatedViewSort };
   }
 
-  async delete(id: string, workspaceId: string): Promise<ViewSort> {
+  async delete(id: string, workspaceId: string): Promise<ViewSortEntity> {
     const viewSort = await this.findById(id, workspaceId);
 
     if (!isDefined(viewSort)) {

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

@@ -4,7 +4,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import {
   ViewException,
   ViewExceptionCode,
@@ -16,11 +16,11 @@ import {
 @Injectable()
 export class ViewService {
   constructor(
-    @InjectRepository(View, 'core')
-    private readonly viewRepository: Repository<View>,
+    @InjectRepository(ViewEntity, 'core')
+    private readonly viewRepository: Repository<ViewEntity>,
   ) {}
 
-  async findByWorkspaceId(workspaceId: string): Promise<View[]> {
+  async findByWorkspaceId(workspaceId: string): Promise<ViewEntity[]> {
     return this.viewRepository.find({
       where: {
         workspaceId,
@@ -41,7 +41,7 @@ export class ViewService {
   async findByObjectMetadataId(
     workspaceId: string,
     objectMetadataId: string,
-  ): Promise<View[]> {
+  ): Promise<ViewEntity[]> {
     return this.viewRepository.find({
       where: {
         workspaceId,
@@ -60,7 +60,7 @@ export class ViewService {
     });
   }
 
-  async findById(id: string, workspaceId: string): Promise<View | null> {
+  async findById(id: string, workspaceId: string): Promise<ViewEntity | null> {
     const view = await this.viewRepository.findOne({
       where: {
         id,
@@ -80,7 +80,7 @@ export class ViewService {
     return view || null;
   }
 
-  async create(viewData: Partial<View>): Promise<View> {
+  async create(viewData: Partial<ViewEntity>): Promise<ViewEntity> {
     if (!isDefined(viewData.workspaceId)) {
       throw new ViewException(
         generateViewExceptionMessage(
@@ -120,8 +120,8 @@ export class ViewService {
   async update(
     id: string,
     workspaceId: string,
-    updateData: Partial<View>,
-  ): Promise<View> {
+    updateData: Partial<ViewEntity>,
+  ): Promise<ViewEntity> {
     const existingView = await this.findById(id, workspaceId);
 
     if (!isDefined(existingView)) {
@@ -142,7 +142,7 @@ export class ViewService {
     return { ...existingView, ...updatedView };
   }
 
-  async delete(id: string, workspaceId: string): Promise<View> {
+  async delete(id: string, workspaceId: string): Promise<ViewEntity> {
     const view = await this.findById(id, workspaceId);
 
     if (!isDefined(view)) {

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

@@ -8,12 +8,12 @@ import { ViewFilterController } from 'src/engine/core-modules/view/controllers/v
 import { ViewGroupController } from 'src/engine/core-modules/view/controllers/view-group.controller';
 import { ViewSortController } from 'src/engine/core-modules/view/controllers/view-sort.controller';
 import { ViewController } from 'src/engine/core-modules/view/controllers/view.controller';
-import { ViewField } from 'src/engine/core-modules/view/entities/view-field.entity';
-import { ViewFilterGroup } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
-import { ViewFilter } from 'src/engine/core-modules/view/entities/view-filter.entity';
-import { ViewGroup } from 'src/engine/core-modules/view/entities/view-group.entity';
-import { ViewSort } from 'src/engine/core-modules/view/entities/view-sort.entity';
-import { View } from 'src/engine/core-modules/view/entities/view.entity';
+import { ViewFieldEntity } from 'src/engine/core-modules/view/entities/view-field.entity';
+import { ViewFilterGroupEntity } from 'src/engine/core-modules/view/entities/view-filter-group.entity';
+import { ViewFilterEntity } from 'src/engine/core-modules/view/entities/view-filter.entity';
+import { ViewGroupEntity } from 'src/engine/core-modules/view/entities/view-group.entity';
+import { ViewSortEntity } from 'src/engine/core-modules/view/entities/view-sort.entity';
+import { ViewEntity } from 'src/engine/core-modules/view/entities/view.entity';
 import { ViewFieldResolver } from 'src/engine/core-modules/view/resolvers/view-field.resolver';
 import { ViewFilterGroupResolver } from 'src/engine/core-modules/view/resolvers/view-filter-group.resolver';
 import { ViewFilterResolver } from 'src/engine/core-modules/view/resolvers/view-filter.resolver';
@@ -32,7 +32,14 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
 @Module({
   imports: [
     TypeOrmModule.forFeature(
-      [View, ViewField, ViewFilter, ViewFilterGroup, ViewGroup, ViewSort],
+      [
+        ViewEntity,
+        ViewFieldEntity,
+        ViewFilterEntity,
+        ViewFilterGroupEntity,
+        ViewGroupEntity,
+        ViewSortEntity,
+      ],
       'core',
     ),
     I18nModule,