Prevent relation update from settings (#13099)

## Expected behavior

Described behavior regarding: (update | create) x (custom | standard) x
(icon, label, name, isSynced)

**Custom:**
- Field RELATION create: name, label, isSynced, icon should be editable
- Field RELATION update: name should not, icon label, isSynced should
- For other fields, icon, label, name, isSynced should be editable at
field creation | update

To simplify: Field RELATION name should not be editable at update

**Standards**
- Field: create does not makes sense
- Field: name should not, icon label, isSynced should (this will end up
in overrides)

To simplify, no Field RELATION edge case, name should not be editable at
update

**Note:** the FE logic is quite different as the UI is hiding some
details behind the syncWithLabel. See my comments and TODO there


## What I've tested:
(update | create) x (custom | standard) x (icon, label, name, isSynced,
description)

packages/twenty-server/test/integration/metadata/suites/field-metadata/__snapshots__/failing-field-metadata-relation-update.integration-spec.ts.snap

@@ -0,0 +1,27 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Field metadata relation update should fail relation when name is changed 1`] = `
+[
+  {
+    "extensions": {
+      "code": "BAD_USER_INPUT",
+      "userFriendlyMessage": "An error occurred.",
+    },
+    "message": "Name cannot be changed for relation fields",
+    "name": "UserInputError",
+  },
+]
+`;
+
+exports[`Field metadata relation update should fail relation when name is not in camel case 1`] = `
+[
+  {
+    "extensions": {
+      "code": "BAD_USER_INPUT",
+      "userFriendlyMessage": "An error occurred.",
+    },
+    "message": "New Name should be in camelCase",
+    "name": "UserInputError",
+  },
+]
+`;

packages/twenty-server/test/integration/metadata/suites/field-metadata/failing-field-metadata-relation-update.integration-spec.ts

@@ -0,0 +1,110 @@
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { updateOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { getMockCreateObjectInput } from 'test/integration/metadata/suites/object-metadata/utils/generate-mock-create-object-metadata-input';
+import { EachTestingContext } from 'twenty-shared/testing';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+type UpdateOneFieldMetadataTestingContext = EachTestingContext<{
+  name: string;
+}>;
+
+const globalTestContext = {
+  employeeObjectId: '',
+  enterpriseObjectId: '',
+  employerFieldMetadataId: '',
+};
+
+describe('Field metadata relation update should fail', () => {
+  const failingRelationUpdateTestsUseCase: UpdateOneFieldMetadataTestingContext[] =
+    [
+      {
+        title: 'when name is not in camel case',
+        context: { name: 'New Name' },
+      },
+      {
+        title: 'when name is changed',
+        context: { name: 'newName' },
+      },
+    ];
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: employeeObjectId },
+      },
+    } = await createOneObjectMetadata({
+      input: getMockCreateObjectInput({
+        namePlural: 'employees',
+        nameSingular: 'employee',
+      }),
+    });
+
+    const {
+      data: {
+        createOneObject: { id: enterpriseObjectId },
+      },
+    } = await createOneObjectMetadata({
+      input: getMockCreateObjectInput({
+        namePlural: 'enterprises',
+        nameSingular: 'enterprise',
+      }),
+    });
+
+    const { data } = await createOneFieldMetadata({
+      input: {
+        objectMetadataId: employeeObjectId,
+        name: 'employer',
+        label: 'Employer',
+        isLabelSyncedWithName: false,
+        type: FieldMetadataType.RELATION,
+        relationCreationPayload: {
+          targetFieldLabel: 'employees',
+          type: RelationType.MANY_TO_ONE,
+          targetObjectMetadataId: enterpriseObjectId,
+          targetFieldIcon: 'IconBuildingSkyscraper',
+        },
+      },
+    });
+
+    globalTestContext.employeeObjectId = employeeObjectId;
+    globalTestContext.enterpriseObjectId = enterpriseObjectId;
+    globalTestContext.employerFieldMetadataId = data.createOneField.id;
+
+    expect(data).toBeDefined();
+  });
+
+  afterAll(async () => {
+    for (const objectMetadataId of [
+      globalTestContext.employeeObjectId,
+      globalTestContext.enterpriseObjectId,
+    ]) {
+      await deleteOneObjectMetadata({
+        input: {
+          idToDelete: objectMetadataId,
+        },
+      });
+    }
+  });
+
+  it.each(failingRelationUpdateTestsUseCase)(
+    'relation $title',
+    async ({ context }) => {
+      const { errors } = await updateOneFieldMetadata({
+        expectToFail: true,
+        input: {
+          idToUpdate: globalTestContext.employerFieldMetadataId,
+          updatePayload: {
+            name: context.name,
+          },
+        },
+      });
+
+      expect(errors).toBeDefined();
+      expect(errors).toMatchSnapshot();
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata.integration-spec.ts

@@ -116,78 +116,4 @@ describe('updateOne', () => {
       );
     });
   });
-
-  describe('FieldMetadataService Enum Default Value Validation', () => {
-    let createdObjectMetadataId: string;
-
-    beforeEach(async () => {
-      const { data: listingObjectMetadata } = await createOneObjectMetadata({
-        input: {
-          labelSingular: LISTING_NAME_SINGULAR,
-          labelPlural: LISTING_NAME_PLURAL,
-          nameSingular: LISTING_NAME_SINGULAR,
-          namePlural: LISTING_NAME_PLURAL,
-          icon: 'IconBuildingSkyscraper',
-          isLabelSyncedWithName: true,
-        },
-      });
-
-      createdObjectMetadataId = listingObjectMetadata.createOneObject.id;
-    });
-
-    afterEach(async () => {
-      await deleteOneObjectMetadata({
-        input: { idToDelete: createdObjectMetadataId },
-      });
-    });
-
-    it('should throw an error if the default value is not in the options', async () => {
-      const { data: createdFieldMetadata } = await createOneFieldMetadata({
-        input: {
-          objectMetadataId: createdObjectMetadataId,
-          type: FieldMetadataType.SELECT,
-          name: 'testName',
-          label: 'Test name',
-          isLabelSyncedWithName: true,
-          options: [
-            {
-              label: 'Option 1',
-              value: 'OPTION_1',
-              color: 'green',
-              position: 1,
-            },
-          ],
-        },
-      });
-
-      const { errors } = await updateOneFieldMetadata({
-        input: {
-          idToUpdate: createdFieldMetadata.createOneField.id,
-          updatePayload: {
-            defaultValue: "'OPTION_2'",
-          },
-        },
-        gqlFields: `
-          id
-          name
-          label
-          isLabelSyncedWithName
-        `,
-        expectToFail: true,
-      });
-
-      expect(errors).toMatchInlineSnapshot(`
-[
-  {
-    "extensions": {
-      "code": "BAD_USER_INPUT",
-      "userFriendlyMessage": "Default value "'OPTION_2'" must be one of the option values",
-    },
-    "message": "Default value "'OPTION_2'" must be one of the option values",
-    "name": "UserInputError",
-  },
-]
-`);
-    });
-  });
 });