[Fix] Prevent fields name conflicts with composite subfields names

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

@@ -40,6 +40,10 @@ import {
   NameTooLongException,
   validateMetadataNameOrThrow,
 } from 'src/engine/metadata-modules/utils/validate-metadata-name.utils';
+import {
+  NameNotAvailableException,
+  validateNameAvailabilityOrThrow,
+} from 'src/engine/metadata-modules/utils/validate-name-availability.utils';
 import { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.service';
 import { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
 import {
@@ -140,7 +144,10 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
         );
       }
 
-      this.validateFieldMetadataInput<CreateFieldInput>(fieldMetadataInput);
+      this.validateFieldMetadataInput<CreateFieldInput>(
+        fieldMetadataInput,
+        objectMetadata.standardId,
+      );
 
       const fieldAlreadyExists = await fieldMetadataRepository.findOne({
         where: {
@@ -355,7 +362,10 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
         }
       }
 
-      this.validateFieldMetadataInput<UpdateFieldInput>(fieldMetadataInput);
+      this.validateFieldMetadataInput<UpdateFieldInput>(
+        fieldMetadataInput,
+        objectMetadata.standardId,
+      );
 
       const updatableFieldInput =
         existingFieldMetadata.isCustom === false
@@ -673,10 +683,14 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
 
   private validateFieldMetadataInput<
     T extends UpdateFieldInput | CreateFieldInput,
-  >(fieldMetadataInput: T): T {
+  >(fieldMetadataInput: T, objectMetadataStandardId: string | null): T {
     if (fieldMetadataInput.name) {
       try {
         validateMetadataNameOrThrow(fieldMetadataInput.name);
+        validateNameAvailabilityOrThrow(
+          fieldMetadataInput.name,
+          objectMetadataStandardId,
+        );
       } catch (error) {
         if (error instanceof InvalidStringException) {
           throw new FieldMetadataException(
@@ -688,6 +702,11 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
             `Name "${fieldMetadataInput.name}" exceeds 63 characters`,
             FieldMetadataExceptionCode.INVALID_FIELD_INPUT,
           );
+        } else if (error instanceof NameNotAvailableException) {
+          throw new FieldMetadataException(
+            `Name "${fieldMetadataInput.name}" is not available`,
+            FieldMetadataExceptionCode.INVALID_FIELD_INPUT,
+          );
         } else {
           throw error;
         }

packages/twenty-server/src/engine/metadata-modules/utils/__tests__/validate-name-availability.spec.ts

@@ -0,0 +1,80 @@
+import {
+  NameNotAvailableException,
+  validateNameAvailabilityOrThrow,
+} from 'src/engine/metadata-modules/utils/validate-name-availability.utils';
+import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
+
+describe('validateNameAvailabilityOrThrow', () => {
+  describe('on person', () => {
+    const objectMetadataStandardId = STANDARD_OBJECT_IDS.person;
+
+    it('does not throw if name is not reserved', () => {
+      const name = 'testName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).not.toThrow();
+    });
+    it('throws error if name is reserved', () => {
+      const name = 'nameFirstName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).toThrow(NameNotAvailableException);
+    });
+  });
+  describe('on company', () => {
+    const objectMetadataStandardId = STANDARD_OBJECT_IDS.company;
+
+    it('does not throw if name is not reserved', () => {
+      const name = 'nameFirstName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).not.toThrow();
+    });
+    it('throws error if name is reserved', () => {
+      const name = 'domainNamePrimaryLinkUrl';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).toThrow(NameNotAvailableException);
+    });
+  });
+  describe('on opportunity', () => {
+    const objectMetadataStandardId = STANDARD_OBJECT_IDS.opportunity;
+
+    it('does not throw if name is not reserved', () => {
+      const name = 'nameFirstName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).not.toThrow();
+    });
+    it('throws error if name is reserved', () => {
+      const name = 'annualRecurringRevenueAmountMicros';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).toThrow(NameNotAvailableException);
+    });
+  });
+  describe('on custom object', () => {
+    const objectMetadataStandardId = null;
+
+    it('does not throw if name is not reserved', () => {
+      const name = 'nameFirstName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).not.toThrow();
+    });
+    it('throws error if name is reserved', () => {
+      const name = 'createdByName';
+
+      expect(() =>
+        validateNameAvailabilityOrThrow(name, objectMetadataStandardId),
+      ).toThrow(NameNotAvailableException);
+    });
+  });
+});

packages/twenty-server/src/engine/metadata-modules/utils/validate-name-availability.utils.ts

@@ -0,0 +1,92 @@
+import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
+
+const createdByFieldsNames = [
+  'createdByName',
+  'createdByWorkspaceMemberId',
+  'createdBySource',
+];
+
+const linkedinLinkFieldsNames = [
+  'linkedinLinkPrimaryLinkLabel',
+  'linkedinLinkPrimaryLinkUrl',
+  'linkedinLinkPrimaryLinkLabel',
+];
+
+const xLinkFieldsNames = [
+  'xLinkPrimaryLinkLabel',
+  'xLinkPrimaryLinkUrl',
+  'xLinkSecondaryLinks',
+];
+
+const amountFieldsNames = [
+  'annualRecurringRevenueAmountMicros',
+  'annualRecurringRevenueCurrencyCode',
+];
+
+const reservedCompositeFieldsNamesForPerson = [
+  ...createdByFieldsNames,
+  ...linkedinLinkFieldsNames,
+  ...xLinkFieldsNames,
+  'nameFirstName',
+  'nameLastName',
+];
+const reservedCompositeFieldsNamesForCompany = [
+  ...createdByFieldsNames,
+  ...linkedinLinkFieldsNames,
+  ...xLinkFieldsNames,
+  ...amountFieldsNames,
+  'domainNamePrimaryLinkLabel',
+  'domainNamePrimaryLinkUrl',
+  'domainNameSecondaryLinks',
+  'addressAddressStreet1',
+  'addressAddressStreet2',
+  'addressAddressCity',
+  'addressAddressState',
+  'addressAddressPostcode',
+  'addressAddressCountry',
+  'addressAddressLat',
+  'addressAddressLng',
+  'introVideoPrimaryLinkLabel',
+  'introVideoPrimaryLinkUrl',
+  'introVideoSecondaryLinks',
+];
+const reservedCompositeFieldsNamesForOpportunity = [
+  ...createdByFieldsNames,
+  ...amountFieldsNames,
+];
+
+const getReservedCompositeFieldsNames = (
+  objectMetadataStandardId: string | null,
+) => {
+  switch (objectMetadataStandardId) {
+    case STANDARD_OBJECT_IDS.person:
+      return reservedCompositeFieldsNamesForPerson;
+    case STANDARD_OBJECT_IDS.company:
+      return reservedCompositeFieldsNamesForCompany;
+    case STANDARD_OBJECT_IDS.opportunity:
+      return reservedCompositeFieldsNamesForOpportunity;
+    default:
+      return createdByFieldsNames;
+  }
+};
+
+export const validateNameAvailabilityOrThrow = (
+  name: string,
+  objectMetadataStandardId: string | null,
+) => {
+  const reservedCompositeFieldsNames = getReservedCompositeFieldsNames(
+    objectMetadataStandardId,
+  );
+
+  if (reservedCompositeFieldsNames.includes(name)) {
+    throw new NameNotAvailableException(name);
+  }
+};
+
+export class NameNotAvailableException extends Error {
+  constructor(name: string) {
+    const message = `Name "${name}" is not available`;
+
+    super(message);
+  }
+}