Deprecate FieldMetadataInterface (#13264)

# Introduction

From the moment replaced the FieldMetadataInterface definition to:
```ts
import { FieldMetadataType } from 'twenty-shared/types';

import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';

export type FieldMetadataInterface<
  T extends FieldMetadataType = FieldMetadataType,
> = FieldMetadataEntity<T>;
```
After this PR merge will create a new one removing the type and
replacing it to `FieldMetadataEntity`.
Did not renamed it here to avoid conflicts on naming + type issues fixs
within the same PR

## Field metadata entity RELATION or MORPH
Relations fields cannot be null for those field metadata entity instance
anymore, but are never for the others see
`packages/twenty-server/src/engine/metadata-modules/field-metadata/types/field-metadata-entity-test.type.ts`
( introduced TypeScript tests )

## Concerns
- TS_VECTOR is the most at risk with the `generatedType` and
`asExpression` removal from interface

## What's next
- `FielMetadataInterface` removal and rename ( see introduction )
- Depcrecating `ObjectMetadataInterface`
- Refactor `FieldMetadataEntity` optional fiels to be nullable only
- TO DIG `never` occurences on settings, defaultValue etc
- Some interfaces will be replaced by the `FlatFieldMetadata` when
deprecating the current sync and comparators tools

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

@@ -71,7 +71,7 @@ describe.each(fieldMetadataEnumTypes)(
         expect(data.createOneField.type).toEqual(testedFieldMetadataType);
 
         const createdOptions = data.createOneField.options;
-        const optionsToCompare = expectedOptions ?? input.options;
+        const optionsToCompare = expectedOptions ?? input.options ?? [];
 
         expect(errors).toBeUndefined();
         expect(createdOptions?.length).toBe(optionsToCompare.length);

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

@@ -168,12 +168,19 @@ describe.each(fieldMetadataEnumTypes)(
         expect(data.updateOneField).toBeDefined();
         const updatedOptions:
           | FieldMetadataComplexOption[]
-          | FieldMetadataDefaultOption[] = data.updateOneField.options;
+          | FieldMetadataDefaultOption[]
+          | null = data.updateOneField.options;
+
+        expect(updatedOptions).toBeDefined();
+        if (!isDefined(updatedOptions))
+          throw new Error(
+            'Should never occur, type invariant post test assertion',
+          );
 
         expect(errors).toBeUndefined();
         updatedOptions.forEach((option) => expect(option.id).toBeDefined());
 
-        const optionsToCompare = expectedOptions ?? input.options;
+        const optionsToCompare = expectedOptions ?? input.options ?? [];
 
         expect(updatedOptions.length).toBe(optionsToCompare.length);
         expect(updatedOptions).toMatchObject(optionsToCompare);

packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util.ts

@@ -8,14 +8,14 @@ import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perf
 import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
 import { FieldMetadataType } from 'twenty-shared/types';
 
-import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
 
 export const createOneFieldMetadata = async <T extends FieldMetadataType>({
   input,
   gqlFields,
   expectToFail = false,
 }: PerformMetadataQueryParams<CreateOneFieldFactoryInput>): CommonResponseBody<{
-  createOneField: FieldMetadataInterface<T>;
+  createOneField: FieldMetadataDTO<T>;
 }> => {
   const graphqlOperation = createOneFieldMetadataQueryFactory({
     input,

packages/twenty-server/test/integration/metadata/suites/object-metadata/relation/delete-one-object-metadata-with-relation.integration-spec.ts

@@ -1,16 +1,16 @@
-import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util';
 import { findManyFieldsMetadataQueryFactory } from 'test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata-query-factory.util';
-import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
 import { createRelationBetweenObjects } from 'test/integration/metadata/suites/object-metadata/utils/create-relation-between-objects.util';
 import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
 import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
 import { EachTestingContext } from 'twenty-shared/testing';
 import { FieldMetadataType } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import { forceCreateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/force-create-one-object-metadata.util';
 
-import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
+import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+
 type DeleteOneObjectMetadataItemTestingContext = EachTestingContext<
   (args: { objectMetadataIdToDelete: string; relationFieldId: string }) => {
     objectMetadataIdToDelete: string;
@@ -44,11 +44,12 @@ const successfulDeleteTargetUseCase: DeleteOneObjectMetadataItemTestingContext =
 describe('Delete Object metadata with relation should succeed', () => {
   let createdObjectMetadataPersonId = '';
   let createdObjectMetadataOpportunityId = '';
-  let createdRelationField: FieldMetadataInterface<FieldMetadataType.RELATION>;
   let globalTestContext: {
     opportunityMetadataId: string;
     personMetadataId: string;
-    relationField: FieldMetadataInterface<FieldMetadataType.RELATION>;
+    relationField: FieldMetadataDTO & {
+      relation: RelationDTO;
+    };
   };
 
   beforeEach(async () => {
@@ -56,7 +57,7 @@ describe('Delete Object metadata with relation should succeed', () => {
       data: {
         createOneObject: { id: objectMetadataPersonId },
       },
-    } = await createOneObjectMetadata({
+    } = await forceCreateOneObjectMetadata({
       input: {
         nameSingular: 'personForRelation',
         namePlural: 'peopleForRelation',
@@ -72,7 +73,7 @@ describe('Delete Object metadata with relation should succeed', () => {
       data: {
         createOneObject: { id: objectMetadataOpportunityId },
       },
-    } = await createOneObjectMetadata({
+    } = await forceCreateOneObjectMetadata({
       input: {
         nameSingular: 'opportunityForRelation',
         namePlural: 'opportunitiesForRelation',
@@ -84,24 +85,20 @@ describe('Delete Object metadata with relation should succeed', () => {
 
     createdObjectMetadataOpportunityId = objectMetadataOpportunityId;
 
-    createdRelationField =
-      await createRelationBetweenObjects<FieldMetadataType.RELATION>({
-        objectMetadataId: createdObjectMetadataOpportunityId,
-        targetObjectMetadataId: createdObjectMetadataPersonId,
-        type: FieldMetadataType.RELATION,
-        relationType: RelationType.MANY_TO_ONE,
-      });
-
     globalTestContext = {
       opportunityMetadataId: createdObjectMetadataOpportunityId,
       personMetadataId: createdObjectMetadataPersonId,
-      relationField: createdRelationField,
+      relationField:
+        await createRelationBetweenObjects<FieldMetadataType.RELATION>({
+          objectMetadataId: createdObjectMetadataOpportunityId,
+          targetObjectMetadataId: createdObjectMetadataPersonId,
+          type: FieldMetadataType.RELATION,
+          relationType: RelationType.MANY_TO_ONE,
+        }),
     };
   });
+
   afterEach(async () => {
-    await deleteOneFieldMetadata({
-      input: { idToDelete: createdRelationField.id },
-    });
     await deleteOneObjectMetadata({
       input: { idToDelete: createdObjectMetadataPersonId },
     });
@@ -128,14 +125,9 @@ describe('Delete Object metadata with relation should succeed', () => {
   });
 
   it.each(successfulDeleteTargetUseCase)('$title', async ({ context }) => {
-    if (!isDefined(globalTestContext.relationField.relation)) {
-      throw new Error('Relation field relation is undefined');
-    }
-
     const computedContext = context({
       objectMetadataIdToDelete: globalTestContext.opportunityMetadataId,
-      relationFieldId:
-        globalTestContext.relationField.relation.targetFieldMetadata.id,
+      relationFieldId: globalTestContext.relationField.id,
     });
 
     await deleteOneObjectMetadata({

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/create-relation-between-objects.util.ts

@@ -4,6 +4,9 @@ import { FieldMetadataType } from 'twenty-shared/types';
 
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
+import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+
 export const createRelationBetweenObjects = async <
   T extends FieldMetadataType.RELATION | FieldMetadataType.MORPH_RELATION,
 >({
@@ -41,22 +44,35 @@ export const createRelationBetweenObjects = async <
     },
   };
 
-  const {
-    data: { createOneField: createdFieldPerson },
-  } = await createOneFieldMetadata<typeof type>({
+  const { data } = await createOneFieldMetadata<typeof type>({
     input: createFieldInput,
     gqlFields: `
             id
             name
             label
             isLabelSyncedWithName
+            settings
             relation {
               type
+              sourceObjectMetadata {
+                id
+                nameSingular
+                namePlural
+              }
+              targetObjectMetadata {
+                id
+                nameSingular
+                namePlural
+              }
+              sourceFieldMetadata {
+                id
+                name
+              }
               targetFieldMetadata {
                 id
+                name
               }
             }
-            settings
             object {
               id
               nameSingular
@@ -65,5 +81,7 @@ export const createRelationBetweenObjects = async <
     expectToFail: false,
   });
 
-  return createdFieldPerson;
+  return data.createOneField as unknown as FieldMetadataDTO<T> & {
+    relation: RelationDTO;
+  };
 };