feat: drop target column map (#4670)

This PR is dropping the column `targetColumnMap` of fieldMetadata
entities.
The goal of this column was to properly map field to their respecting
column in the table.
We decide to drop it and instead compute the column name on the fly when
we need it, as it's more easier to support.
Some parts of the code has been refactored to try making implementation
of composite type more easier to understand and maintain.

Fix #3760

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-server/src/engine/api/rest/api-rest-query-builder/utils/fields.utils.ts

@@ -1,36 +1,55 @@
 import { BadRequestException } from '@nestjs/common';
 
+import { compositeTypeDefintions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
 
 export const getFieldType = (
-  objectMetadataItem,
-  fieldName,
+  objectMetadata: ObjectMetadataEntity,
+  fieldName: string,
 ): FieldMetadataType | undefined => {
-  for (const itemField of objectMetadataItem.fields) {
-    if (fieldName === itemField.name) {
-      return itemField.type;
+  for (const fieldMetdata of objectMetadata.fields) {
+    if (fieldName === fieldMetdata.name) {
+      return fieldMetdata.type;
     }
   }
 };
 
-export const checkFields = (objectMetadataItem, fieldNames): void => {
+export const checkFields = (
+  objectMetadata: ObjectMetadataEntity,
+  fieldNames: string[],
+): void => {
+  const fieldMetadataNames = objectMetadata.fields
+    .map((field) => {
+      if (isCompositeFieldMetadataType(field.type)) {
+        const compositeType = compositeTypeDefintions.get(field.type);
+
+        if (!compositeType) {
+          throw new BadRequestException(
+            `Composite type '${field.type}' not found`,
+          );
+        }
+
+        // TODO: Don't really know why we need to put fieldName and compositeType name here
+        return [
+          field.name,
+          compositeType.properties.map(
+            (compositeProperty) => compositeProperty.name,
+          ),
+        ].flat();
+      }
+
+      return field.name;
+    })
+    .flat();
+
   for (const fieldName of fieldNames) {
-    if (
-      !objectMetadataItem.fields
-        .reduce(
-          (acc, itemField) => [
-            ...acc,
-            itemField.name,
-            ...Object.keys(itemField.targetColumnMap),
-          ],
-          [],
-        )
-        .includes(fieldName)
-    ) {
+    if (!fieldMetadataNames.includes(fieldName)) {
       throw new BadRequestException(
         `field '${fieldName}' does not exist in '${computeObjectTargetTable(
-          objectMetadataItem,
+          objectMetadata,
         )}' object`,
       );
     }

packages/twenty-server/src/engine/api/rest/api-rest-query-builder/utils/map-field-metadata-to-graphql-query.utils.ts

@@ -3,6 +3,7 @@ import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metad
 
 const DEFAULT_DEPTH_VALUE = 2;
 
+// TODO: Should be properly type and based on composite type definitions
 export const mapFieldMetadataToGraphqlQuery = (
   objectMetadataItems,
   field,