Allow to edit labels of standard objects (#10922)

Fixes #10793

This PR is a work in progress.

**Still left to fix:**

- [x] When disabling synchronization of labels / api names, the edited
labels should be set to the English version. Currently the client just
send the localized versions together with the `isLabelSyncedWithName`
change. Could be an easy fix.
- [ ] Sometimes flipping the switch don't trigger the update function,
may be a regression as it seems to affect the custom objects too.
- [ ] There is a frontend problem where the labels inputs don't reflect
the changes made. When enabling back synchronisation after editing
labels, they are correctly back to their base values (backend,
navigation breadcrumb, etc) but the label inputs still have the old
values (switching pages will put them back to normal). I suspect this
could be linked to the above problem.
- [ ] API names are still displayed for standard objects per (kept them
for debugging, trivial fix)
- [ ] `SettingsDataModelObjectAboutForm` have a `disableEdition`
parameter which is now used only for a few fields, not sure if it's
worth keeping because it's a bit misleading since it doesn't "disable"
much?
- [ ] I don't know what these do, but I have seen "Remote" object types.
Not sure if they work with my patch or not (I don't know how to test
them)
- [ ] Make it work with metadata synchronisation


**What should work:**

- Disabling synchronization of standard objects should work, label
inputs should no longer be disabled
- Modifying labels should work
- Enabling back synchronization should reset back the labels to the base
value and disable the label inputs again (minus the mentioned display
bug)
- The synchronisation switch should still work as expected for custom
objects
- Creating custom objects should still work (it uses the same form)

---------

Signed-off-by: AFCMS <afcm.contact@gmail.com>
Co-authored-by: Félix Malfait <felix@twenty.com>
Co-authored-by: Félix Malfait <felix.malfait@gmail.com>

packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/create-field.input.ts

@@ -1,14 +1,14 @@
 import { Field, InputType, OmitType } from '@nestjs/graphql';
 
-import { IsOptional, IsUUID, ValidateNested } from 'class-validator';
 import { Type } from 'class-transformer';
+import { IsOptional, IsUUID, ValidateNested } from 'class-validator';
 
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
 
 @InputType()
 export class CreateFieldInput extends OmitType(
   FieldMetadataDTO,
-  ['id', 'createdAt', 'updatedAt'] as const,
+  ['id', 'createdAt', 'updatedAt', 'standardOverrides'] as const,
   InputType,
 ) {
   @IsUUID()

packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto.ts

@@ -32,6 +32,7 @@ import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadat
 
 import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
 import { IsValidMetadataName } from 'src/engine/decorators/metadata/is-valid-metadata-name.decorator';
+import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
 import { FieldMetadataDefaultOption } from 'src/engine/metadata-modules/field-metadata/dtos/options.input';
 import { IsFieldMetadataDefaultValue } from 'src/engine/metadata-modules/field-metadata/validators/is-field-metadata-default-value.validator';
 import { IsFieldMetadataOptions } from 'src/engine/metadata-modules/field-metadata/validators/is-field-metadata-options.validator';
@@ -96,6 +97,10 @@ export class FieldMetadataDTO<T extends FieldMetadataType = FieldMetadataType> {
   @Field({ nullable: true })
   icon?: string;
 
+  @IsOptional()
+  @Field(() => FieldStandardOverridesDTO, { nullable: true })
+  standardOverrides?: FieldStandardOverridesDTO;
+
   @IsBoolean()
   @IsOptional()
   @FilterableField({ nullable: true })

packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto.ts

@@ -0,0 +1,21 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+import { IsOptional, IsString } from 'class-validator';
+
+@ObjectType('StandardOverrides')
+export class FieldStandardOverridesDTO {
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  label?: string | null;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  description?: string | null;
+
+  @IsString()
+  @IsOptional()
+  @Field(() => String, { nullable: true })
+  icon?: string | null;
+}

packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/update-field.input.ts

@@ -15,7 +15,14 @@ import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dto
 @InputType()
 export class UpdateFieldInput extends OmitType(
   PartialType(FieldMetadataDTO, InputType),
-  ['id', 'type', 'createdAt', 'updatedAt', 'isCustom'] as const,
+  [
+    'id',
+    'type',
+    'createdAt',
+    'updatedAt',
+    'isCustom',
+    'standardOverrides',
+  ] as const,
 ) {
   @HideField()
   id: string;

packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.entity.ts

@@ -1,3 +1,4 @@
+import { FieldMetadataType } from 'twenty-shared/types';
 import {
   Column,
   CreateDateColumn,
@@ -12,13 +13,13 @@ import {
   Unique,
   UpdateDateColumn,
 } from 'typeorm';
-import { FieldMetadataType } from 'twenty-shared/types';
 
 import { FieldMetadataDefaultValue } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-default-value.interface';
 import { FieldMetadataOptions } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-options.interface';
 import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
 import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 
+import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
 import { IndexFieldMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-field-metadata.entity';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@@ -76,6 +77,9 @@ export class FieldMetadataEntity<
   @Column({ nullable: true })
   icon: string;
 
+  @Column({ type: 'jsonb', nullable: true })
+  standardOverrides?: FieldStandardOverridesDTO;
+
   @Column('jsonb', { nullable: true })
   options: FieldMetadataOptions<T>;
 

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

@@ -15,6 +15,7 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
 import { FieldMetadataValidationService } from 'src/engine/metadata-modules/field-metadata/field-metadata-validation.service';
 import { FieldMetadataResolver } from 'src/engine/metadata-modules/field-metadata/field-metadata.resolver';
+import { BeforeUpdateOneField } from 'src/engine/metadata-modules/field-metadata/hooks/before-update-one-field.hook';
 import { FieldMetadataGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/field-metadata/interceptors/field-metadata-graphql-api-exception.interceptor';
 import { FieldMetadataRelationService } from 'src/engine/metadata-modules/field-metadata/relation/field-metadata-relation.service';
 import { FieldMetadataRelatedRecordsService } from 'src/engine/metadata-modules/field-metadata/services/field-metadata-related-records.service';
@@ -96,6 +97,7 @@ import { UpdateFieldInput } from './dtos/update-field.input';
     FieldMetadataRelationService,
     FieldMetadataRelatedRecordsService,
     FieldMetadataResolver,
+    BeforeUpdateOneField,
   ],
   exports: [
     FieldMetadataService,

packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.resolver.ts

@@ -24,13 +24,17 @@ import { DeleteOneFieldInput } from 'src/engine/metadata-modules/field-metadata/
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
 import { RelationDefinitionDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto';
 import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
-import { UpdateOneFieldMetadataInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
+import {
+  UpdateFieldInput,
+  UpdateOneFieldMetadataInput,
+} from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import {
   FieldMetadataException,
   FieldMetadataExceptionCode,
 } from 'src/engine/metadata-modules/field-metadata/field-metadata.exception';
 import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
+import { BeforeUpdateOneField } from 'src/engine/metadata-modules/field-metadata/hooks/before-update-one-field.hook';
 import { fieldMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/field-metadata/utils/field-metadata-graphql-api-exception-handler.util';
 import { SettingsPermissions } from 'src/engine/metadata-modules/permissions/constants/settings-permissions.constants';
 import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
@@ -43,6 +47,7 @@ export class FieldMetadataResolver {
   constructor(
     private readonly fieldMetadataService: FieldMetadataService,
     private readonly featureFlagService: FeatureFlagService,
+    private readonly beforeUpdateOneField: BeforeUpdateOneField<UpdateFieldInput>,
   ) {}
 
   @ResolveField(() => String, { nullable: true })
@@ -50,7 +55,7 @@ export class FieldMetadataResolver {
     @Parent() fieldMetadata: FieldMetadataDTO,
     @Context() context: I18nContext,
   ): Promise<string> {
-    return this.fieldMetadataService.resolveTranslatableString(
+    return this.fieldMetadataService.resolveOverridableString(
       fieldMetadata,
       'label',
       context.req.headers['x-locale'],
@@ -62,13 +67,25 @@ export class FieldMetadataResolver {
     @Parent() fieldMetadata: FieldMetadataDTO,
     @Context() context: I18nContext,
   ): Promise<string> {
-    return this.fieldMetadataService.resolveTranslatableString(
+    return this.fieldMetadataService.resolveOverridableString(
       fieldMetadata,
       'description',
       context.req.headers['x-locale'],
     );
   }
 
+  @ResolveField(() => String, { nullable: true })
+  async icon(
+    @Parent() fieldMetadata: FieldMetadataDTO,
+    @Context() context: I18nContext,
+  ): Promise<string> {
+    return this.fieldMetadataService.resolveOverridableString(
+      fieldMetadata,
+      'icon',
+      context.req.headers['x-locale'],
+    );
+  }
+
   @UseGuards(SettingsPermissionsGuard(SettingsPermissions.DATA_MODEL))
   @Mutation(() => FieldMetadataDTO)
   async createOneField(
@@ -92,8 +109,13 @@ export class FieldMetadataResolver {
     @AuthWorkspace() { id: workspaceId }: Workspace,
   ) {
     try {
-      return await this.fieldMetadataService.updateOne(input.id, {
-        ...input.update,
+      const updatedInput = (await this.beforeUpdateOneField.run(
+        input,
+        workspaceId,
+      )) as UpdateOneFieldMetadataInput;
+
+      return await this.fieldMetadataService.updateOne(updatedInput.id, {
+        ...updatedInput.update,
         workspaceId,
       });
     } catch (error) {

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

@@ -4,11 +4,11 @@ import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { i18n } from '@lingui/core';
 import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
 import isEmpty from 'lodash.isempty';
-import { DataSource, FindOneOptions, In, Repository } from 'typeorm';
-import { v4 as uuidV4, v4 } from 'uuid';
 import { APP_LOCALES } from 'twenty-shared/translations';
 import { FieldMetadataType } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
+import { DataSource, FindOneOptions, In, Repository } from 'typeorm';
+import { v4 as uuidV4, v4 } from 'uuid';
 
 import { TypeORMService } from 'src/database/typeorm/typeorm.service';
 import { settings } from 'src/engine/constants/settings';
@@ -18,6 +18,7 @@ import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-meta
 import { CreateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
 import { DeleteOneFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/delete-field.input';
 import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
 import {
   RelationDefinitionDTO,
   RelationDefinitionType,
@@ -457,14 +458,23 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
     fieldMetadataInput: UpdateFieldInput,
     existingFieldMetadata: FieldMetadataEntity,
   ) {
-    const updatableStandardFieldInput: UpdateFieldInput = {
+    const updatableStandardFieldInput: UpdateFieldInput & {
+      standardOverrides?: FieldStandardOverridesDTO;
+    } = {
       id: fieldMetadataInput.id,
       isActive: fieldMetadataInput.isActive,
       workspaceId: fieldMetadataInput.workspaceId,
       defaultValue: fieldMetadataInput.defaultValue,
       settings: fieldMetadataInput.settings,
+      isLabelSyncedWithName: fieldMetadataInput.isLabelSyncedWithName,
     };
 
+    if ('standardOverrides' in fieldMetadataInput) {
+      updatableStandardFieldInput.standardOverrides = (
+        fieldMetadataInput as any
+      ).standardOverrides;
+    }
+
     if (
       existingFieldMetadata.type === FieldMetadataType.SELECT ||
       existingFieldMetadata.type === FieldMetadataType.MULTI_SELECT
@@ -599,9 +609,9 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
     return fieldMetadataInput;
   }
 
-  async resolveTranslatableString(
+  async resolveOverridableString(
     fieldMetadata: FieldMetadataDTO,
-    labelKey: 'label' | 'description',
+    labelKey: 'label' | 'description' | 'icon',
     locale: keyof typeof APP_LOCALES | undefined,
   ): Promise<string> {
     if (fieldMetadata.isCustom) {
@@ -612,6 +622,13 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
       return fieldMetadata[labelKey] ?? '';
     }
 
+    if (
+      fieldMetadata.standardOverrides &&
+      isDefined(fieldMetadata.standardOverrides[labelKey])
+    ) {
+      return fieldMetadata.standardOverrides[labelKey] as string;
+    }
+
     const messageId = generateMessageId(fieldMetadata[labelKey] ?? '');
     const translatedMessage = i18n._(messageId);
 

packages/twenty-server/src/engine/metadata-modules/field-metadata/hooks/before-update-one-field.hook.ts

@@ -0,0 +1,225 @@
+import {
+  BadRequestException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+import {
+  BeforeUpdateOneHook,
+  UpdateOneInputType,
+} from '@ptc-org/nestjs-query-graphql';
+import { isDefined } from 'twenty-shared/utils';
+
+import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
+import { UpdateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
+
+interface StandardFieldUpdate extends Partial<UpdateFieldInput> {
+  standardOverrides?: FieldStandardOverridesDTO;
+}
+
+@Injectable()
+export class BeforeUpdateOneField<T extends UpdateFieldInput>
+  implements BeforeUpdateOneHook<T>
+{
+  constructor(readonly fieldMetadataService: FieldMetadataService) {}
+
+  async run(
+    instance: UpdateOneInputType<T>,
+    workspaceId: string,
+  ): Promise<UpdateOneInputType<T>> {
+    if (!workspaceId) {
+      throw new UnauthorizedException();
+    }
+
+    const fieldMetadata = await this.getFieldMetadata(instance, workspaceId);
+
+    if (!fieldMetadata.isCustom) {
+      return this.handleStandardFieldUpdate(instance, fieldMetadata);
+    }
+
+    return instance;
+  }
+
+  private async getFieldMetadata(
+    instance: UpdateOneInputType<T>,
+    workspaceId: string,
+  ) {
+    const fieldMetadata =
+      await this.fieldMetadataService.findOneWithinWorkspace(workspaceId, {
+        where: {
+          id: instance.id.toString(),
+        },
+      });
+
+    if (!fieldMetadata) {
+      throw new BadRequestException('Field does not exist');
+    }
+
+    return fieldMetadata;
+  }
+
+  private handleStandardFieldUpdate(
+    instance: UpdateOneInputType<T>,
+    fieldMetadata: FieldMetadataEntity,
+  ): UpdateOneInputType<T> {
+    const update: StandardFieldUpdate = {};
+    const updatableFields = ['isActive', 'isLabelSyncedWithName'];
+    const overridableFields = ['label', 'icon', 'description'];
+
+    const hasNonUpdatableFields = Object.keys(instance.update).some(
+      (key) =>
+        !updatableFields.includes(key) && !overridableFields.includes(key),
+    );
+
+    const isUpdatingLabelWhenSynced =
+      instance.update.label &&
+      fieldMetadata.isLabelSyncedWithName &&
+      instance.update.isLabelSyncedWithName !== false &&
+      instance.update.label !== fieldMetadata.label;
+
+    if (isUpdatingLabelWhenSynced) {
+      throw new BadRequestException(
+        'Cannot update label when it is synced with name',
+      );
+    }
+
+    if (hasNonUpdatableFields) {
+      throw new BadRequestException(
+        'Only isActive, isLabelSyncedWithName, label, icon and description fields can be updated for standard fields',
+      );
+    }
+
+    // Preserve existing overrides
+    update.standardOverrides = fieldMetadata.standardOverrides
+      ? { ...fieldMetadata.standardOverrides }
+      : {};
+
+    this.handleActiveField(instance, update);
+    this.handleLabelSyncedWithNameField(instance, update);
+    this.handleStandardOverrides(instance, fieldMetadata, update);
+
+    return {
+      id: instance.id,
+      update: update as T,
+    };
+  }
+
+  private handleActiveField(
+    instance: UpdateOneInputType<T>,
+    update: StandardFieldUpdate,
+  ): void {
+    if (!isDefined(instance.update.isActive)) {
+      return;
+    }
+
+    update.isActive = instance.update.isActive;
+  }
+
+  private handleLabelSyncedWithNameField(
+    instance: UpdateOneInputType<T>,
+    update: StandardFieldUpdate,
+  ): void {
+    if (!isDefined(instance.update.isLabelSyncedWithName)) {
+      return;
+    }
+
+    update.isLabelSyncedWithName = instance.update.isLabelSyncedWithName;
+
+    if (instance.update.isLabelSyncedWithName === false) {
+      return;
+    }
+
+    update.standardOverrides = update.standardOverrides || {};
+    update.standardOverrides.label = null;
+  }
+
+  private handleStandardOverrides(
+    instance: UpdateOneInputType<T>,
+    fieldMetadata: FieldMetadataEntity,
+    update: StandardFieldUpdate,
+  ): void {
+    const hasStandardOverrides =
+      isDefined(instance.update.description) ||
+      isDefined(instance.update.icon) ||
+      isDefined(instance.update.label);
+
+    if (!hasStandardOverrides) {
+      return;
+    }
+
+    update.standardOverrides = update.standardOverrides || {};
+
+    this.handleDescriptionOverride(instance, fieldMetadata, update);
+    this.handleIconOverride(instance, fieldMetadata, update);
+    this.handleLabelOverride(instance, fieldMetadata, update);
+  }
+
+  private handleDescriptionOverride(
+    instance: UpdateOneInputType<T>,
+    fieldMetadata: FieldMetadataEntity,
+    update: StandardFieldUpdate,
+  ): void {
+    if (!isDefined(instance.update.description)) {
+      return;
+    }
+
+    update.standardOverrides = update.standardOverrides || {};
+
+    if (instance.update.description === fieldMetadata.description) {
+      update.standardOverrides.description = null;
+
+      return;
+    }
+
+    update.standardOverrides.description = instance.update.description;
+  }
+
+  private handleIconOverride(
+    instance: UpdateOneInputType<T>,
+    fieldMetadata: FieldMetadataEntity,
+    update: StandardFieldUpdate,
+  ): void {
+    if (!isDefined(instance.update.icon)) {
+      return;
+    }
+
+    update.standardOverrides = update.standardOverrides || {};
+
+    if (instance.update.icon === fieldMetadata.icon) {
+      update.standardOverrides.icon = null;
+
+      return;
+    }
+
+    update.standardOverrides.icon = instance.update.icon;
+  }
+
+  private handleLabelOverride(
+    instance: UpdateOneInputType<T>,
+    fieldMetadata: FieldMetadataEntity,
+    update: StandardFieldUpdate,
+  ): void {
+    if (
+      fieldMetadata.isLabelSyncedWithName ||
+      update.isLabelSyncedWithName === true
+    ) {
+      return;
+    }
+
+    if (!isDefined(instance.update.label)) {
+      return;
+    }
+
+    update.standardOverrides = update.standardOverrides || {};
+
+    if (instance.update.label === fieldMetadata.label) {
+      update.standardOverrides.label = null;
+
+      return;
+    }
+
+    update.standardOverrides.label = instance.update.label;
+  }
+}