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>
2024-04-08 16:00:28 +02:00
parent 84f8c14e52
commit 5019b5febc
72 changed files with 1432 additions and 1853 deletions
@@ -0,0 +1,53 @@
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+import { CompositeProperty } from 'src/engine/metadata-modules/field-metadata/interfaces/composite-type.interface';
+
+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 { pascalCase } from 'src/utils/pascal-case';
+
+type ComputeColumnNameOptions = { isForeignKey?: boolean };
+
+export function computeColumnName(
+  fieldName: string,
+  options?: ComputeColumnNameOptions,
+): string;
+export function computeColumnName<T extends FieldMetadataType | 'default'>(
+  fieldMetadata: FieldMetadataInterface<T>,
+  ioptions?: ComputeColumnNameOptions,
+): string;
+// TODO: If we need to implement custom name logic for columns, we can do it here
+export function computeColumnName<T extends FieldMetadataType | 'default'>(
+  fieldMetadataOrFieldName: FieldMetadataInterface<T> | string,
+  options?: ComputeColumnNameOptions,
+): string {
+  const generateName = (name: string) => {
+    return options?.isForeignKey ? `${name}Id` : name;
+  };
+
+  if (typeof fieldMetadataOrFieldName === 'string') {
+    return generateName(fieldMetadataOrFieldName);
+  }
+
+  if (isCompositeFieldMetadataType(fieldMetadataOrFieldName.type)) {
+    throw new Error(
+      `Cannot compute column name for composite field metadata type: ${fieldMetadataOrFieldName.type}`,
+    );
+  }
+
+  return generateName(fieldMetadataOrFieldName.name);
+}
+
+export const computeCompositeColumnName = <
+  T extends FieldMetadataType | 'default',
+>(
+  fieldMetadata: FieldMetadataInterface<T>,
+  compositeProperty: CompositeProperty,
+): string => {
+  if (!isCompositeFieldMetadataType(fieldMetadata.type)) {
+    throw new Error(
+      `Cannot compute composite column name for non-composite field metadata type: ${fieldMetadata.type}`,
+    );
+  }
+
+  return `${fieldMetadata.name}${pascalCase(compositeProperty.name)}`;
+};