feat: new relation sync-metadata, twenty-orm, create/update (#10217)

Fix https://github.com/twentyhq/core-team-issues/issues/330#issue-2827026606 and https://github.com/twentyhq/core-team-issues/issues/327#issue-2827001814 What this PR does when `isNewRelationEnabled` is set to `true`: - [x] Drop the creation of the foreign key as a `FieldMetadata` - [x] Stop creating `RelationMetadata` - [x] Properly fill `FieldMetadata` of type `RELATION` during the sync command - [x] Use new relation settings in TwentyORM - [x] Properly create `FieldMetadata` relations when we create a new object - [x] Handle `database:reset` with new relations --------- Co-authored-by: Charles Bochet <charles@twenty.com> Co-authored-by: Charles Bochet <charlesBochet@users.noreply.github.com>
2025-04-22 19:01:39 +02:00
parent de1489aabb
commit cc29c25176
160 changed files with 3247 additions and 711 deletions
--- a/packages/twenty-server/src/engine/twenty-orm/utils/convert-relation-type-to-typeorm-relation-type.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/convert-relation-type-to-typeorm-relation-type.util.ts
@ -0,0 +1,14 @@
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+export const converRelationTypeToTypeORMRelationType = (type: RelationType) => {
+  switch (type) {
+    case RelationType.ONE_TO_MANY:
+      return 'one-to-many';
+    case RelationType.MANY_TO_ONE:
+      return 'many-to-one';
+    case RelationType.ONE_TO_ONE:
+      return 'one-to-one';
+    default:
+      throw new Error(`Invalid relation type: ${type}`);
+  }
+};
--- a/packages/twenty-server/src/engine/twenty-orm/utils/determine-schema-relation-details.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/determine-schema-relation-details.util.ts
@ -0,0 +1,62 @@
+import { FieldMetadataType } from 'twenty-shared/types';
+import { RelationType } from 'typeorm/metadata/types/RelationTypes';
+
+import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
+
+import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
+import { converRelationTypeToTypeORMRelationType } from 'src/engine/twenty-orm/utils/convert-relation-type-to-typeorm-relation-type.util';
+
+interface RelationDetails {
+  relationType: RelationType;
+  target: string;
+  inverseSide: string;
+  joinColumn: { name: string } | undefined;
+}
+
+export async function determineSchemaRelationDetails(
+  fieldMetadata: FieldMetadataInterface<FieldMetadataType.RELATION>,
+  objectMetadataMaps: ObjectMetadataMaps,
+): Promise<RelationDetails> {
+  if (!fieldMetadata.settings) {
+    throw new Error('Field metadata settings are missing');
+  }
+
+  const relationType = converRelationTypeToTypeORMRelationType(
+    fieldMetadata.settings.relationType,
+  );
+
+  if (!fieldMetadata.relationTargetObjectMetadataId) {
+    throw new Error('Relation target object metadata ID is missing');
+  }
+
+  const sourceObjectMetadata =
+    objectMetadataMaps.byId[fieldMetadata.objectMetadataId];
+  const targetObjectMetadata =
+    objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
+
+  if (!sourceObjectMetadata || !targetObjectMetadata) {
+    throw new Error('Object metadata not found');
+  }
+
+  if (!fieldMetadata.relationTargetFieldMetadataId) {
+    throw new Error('Relation target field metadata ID is missing');
+  }
+
+  const targetFieldMetadata =
+    targetObjectMetadata.fieldsById[
+      fieldMetadata.relationTargetFieldMetadataId
+    ];
+
+  if (!targetFieldMetadata) {
+    throw new Error('Target field metadata not found');
+  }
+
+  return {
+    relationType,
+    target: targetObjectMetadata.nameSingular,
+    inverseSide: targetFieldMetadata.name,
+    joinColumn: fieldMetadata.settings.joinColumnName
+      ? { name: fieldMetadata.settings.joinColumnName }
+      : undefined,
+  };
+}
--- a/packages/twenty-server/src/engine/twenty-orm/utils/format-data.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/format-data.util.ts
@ -7,6 +7,7 @@ import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-meta
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
 import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
 import { CompositeFieldMetadataType } from 'src/engine/metadata-modules/workspace-migration/factories/composite-column-action.factory';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';

 export function formatData<T>(
  data: T,
@ -23,9 +24,28 @@ export function formatData<T>(
  }

  const newData: Record<string, any> = {};
+  const fieldMetadataByJoinColumnName =
+    objectMetadataItemWithFieldMaps.fields.reduce((acc, fieldMetadata) => {
+      if (
+        isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      ) {
+        const joinColumnName = fieldMetadata.settings?.joinColumnName;
+
+        if (joinColumnName) {
+          acc.set(joinColumnName, fieldMetadata);
+        }
+      }
+
+      return acc;
+    }, new Map<string, FieldMetadataInterface>());

  for (const [key, value] of Object.entries(data)) {
-    const fieldMetadata = objectMetadataItemWithFieldMaps.fieldsByName[key];
+    const fieldMetadata =
+      objectMetadataItemWithFieldMaps.fieldsByName[key] ||
+      fieldMetadataByJoinColumnName.get(key);

    if (!fieldMetadata) {
      throw new Error(
--- a/packages/twenty-server/src/engine/twenty-orm/utils/format-result.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/format-result.util.ts
@ -13,7 +13,7 @@ import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/typ
 import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
 import { computeRelationType } from 'src/engine/twenty-orm/utils/compute-relation-type.util';
 import { getCompositeFieldMetadataCollection } from 'src/engine/twenty-orm/utils/get-composite-field-metadata-collection';
-import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
+import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
 import { isDate } from 'src/utils/date/isDate';
 import { isValidDate } from 'src/utils/date/isValidDate';

@ -21,6 +21,7 @@ export function formatResult<T>(
  data: any,
  objectMetadataItemWithFieldMaps: ObjectMetadataItemWithFieldMaps,
  objectMetadataMaps: ObjectMetadataMaps,
+  isNewRelationEnabled: boolean,
 ): T {
  if (!data) {
    return data;
@ -28,7 +29,12 @@ export function formatResult<T>(

  if (Array.isArray(data)) {
    return data.map((item) =>
-      formatResult(item, objectMetadataItemWithFieldMaps, objectMetadataMaps),
+      formatResult(
+        item,
+        objectMetadataItemWithFieldMaps,
+        objectMetadataMaps,
+        isNewRelationEnabled,
+      ),
    ) as T;
  }

@ -44,38 +50,57 @@ export function formatResult<T>(
    objectMetadataItemWithFieldMaps,
  );

-  const relationMetadataMap = new Map(
-    Object.values(objectMetadataItemWithFieldMaps.fieldsById)
-      .filter(({ type }) => isRelationFieldMetadataType(type))
-      .map((fieldMetadata) => [
-        fieldMetadata.name,
-        {
-          relationMetadata:
-            fieldMetadata.fromRelationMetadata ??
-            fieldMetadata.toRelationMetadata,
-          relationType: computeRelationType(
-            fieldMetadata,
-            fieldMetadata.fromRelationMetadata ??
-              (fieldMetadata.toRelationMetadata as RelationMetadataEntity),
-          ),
-        },
-      ]),
-  );
+  const relationMetadataMap: Map<
+    string,
+    {
+      relationMetadata: RelationMetadataEntity | undefined;
+      relationType: string;
+    }
+  > = isNewRelationEnabled
+    ? new Map()
+    : new Map(
+        Object.values(objectMetadataItemWithFieldMaps.fieldsById)
+          .filter((fieldMetadata) =>
+            isFieldMetadataInterfaceOfType(
+              fieldMetadata,
+              FieldMetadataType.RELATION,
+            ),
+          )
+          .map((fieldMetadata) => [
+            fieldMetadata.name,
+            {
+              relationMetadata:
+                fieldMetadata.fromRelationMetadata ??
+                fieldMetadata.toRelationMetadata,
+              relationType: computeRelationType(
+                fieldMetadata,
+                fieldMetadata.fromRelationMetadata ??
+                  (fieldMetadata.toRelationMetadata as RelationMetadataEntity),
+              ),
+            },
+          ]),
+      );
  const newData: object = {};
  const objectMetadaItemFieldsByName =
    objectMetadataMaps.byId[objectMetadataItemWithFieldMaps.id]?.fieldsByName;

  for (const [key, value] of Object.entries(data)) {
    const compositePropertyArgs = compositeFieldMetadataMap.get(key);
-    const { relationMetadata, relationType } =
-      relationMetadataMap.get(key) ?? {};
+    const fieldMetadata = objectMetadataItemWithFieldMaps.fieldsById[key];
+    const isRelation = fieldMetadata
+      ? isFieldMetadataInterfaceOfType(
+          fieldMetadata,
+          FieldMetadataType.RELATION,
+        )
+      : false;

-    if (!compositePropertyArgs && !relationMetadata) {
+    if (!compositePropertyArgs && !isRelation) {
      if (isPlainObject(value)) {
        newData[key] = formatResult(
          value,
          objectMetadataItemWithFieldMaps,
          objectMetadataMaps,
+          isNewRelationEnabled,
        );
      } else if (objectMetadaItemFieldsByName[key]) {
        newData[key] = formatFieldMetadataValue(
@ -89,31 +114,63 @@ export function formatResult<T>(
      continue;
    }

-    if (relationMetadata) {
-      const toObjectMetadata =
-        objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
+    if (!isNewRelationEnabled) {
+      const { relationMetadata, relationType } =
+        relationMetadataMap.get(key) ?? {};

-      const fromObjectMetadata =
-        objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId];
+      if (relationMetadata) {
+        const toObjectMetadata =
+          objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];

-      if (!toObjectMetadata) {
-        throw new Error(
-          `Object metadata for object metadataId "${relationMetadata.toObjectMetadataId}" is missing`,
+        const fromObjectMetadata =
+          objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId];
+
+        if (!toObjectMetadata) {
+          throw new Error(
+            `Object metadata for object metadataId "${relationMetadata.toObjectMetadataId}" is missing`,
+          );
+        }
+
+        if (!fromObjectMetadata) {
+          throw new Error(
+            `Object metadata for object metadataId "${relationMetadata.fromObjectMetadataId}" is missing`,
+          );
+        }
+
+        newData[key] = formatResult(
+          value,
+          relationType === 'one-to-many'
+            ? toObjectMetadata
+            : fromObjectMetadata,
+          objectMetadataMaps,
+          isNewRelationEnabled,
+        );
+        continue;
+      }
+    } else {
+      if (isRelation) {
+        if (!fieldMetadata.relationTargetObjectMetadataId) {
+          throw new Error(
+            `Relation target object metadata ID is missing for field "${key}"`,
+          );
+        }
+
+        const targetObjectMetadata =
+          objectMetadataMaps.byId[fieldMetadata.relationTargetObjectMetadataId];
+
+        if (!targetObjectMetadata) {
+          throw new Error(
+            `Object metadata for object metadataId "${fieldMetadata.relationTargetObjectMetadataId}" is missing`,
+          );
+        }
+
+        newData[key] = formatResult(
+          value,
+          targetObjectMetadata,
+          objectMetadataMaps,
+          isNewRelationEnabled,
        );
      }
-
-      if (!fromObjectMetadata) {
-        throw new Error(
-          `Object metadata for object metadataId "${relationMetadata.fromObjectMetadataId}" is missing`,
-        );
-      }
-
-      newData[key] = formatResult(
-        value,
-        relationType === 'one-to-many' ? toObjectMetadata : fromObjectMetadata,
-        objectMetadataMaps,
-      );
-      continue;
    }

    if (!compositePropertyArgs) {
--- a/packages/twenty-server/src/engine/twenty-orm/utils/get-join-column.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/get-join-column.util.ts
@ -1,7 +1,7 @@
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 import { WorkspaceJoinColumnsMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-join-columns-metadata-args.interface';
 import { WorkspaceRelationMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-relation-metadata-args.interface';

-import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
 import { metadataArgsStorage } from 'src/engine/twenty-orm/storage/metadata-args.storage';

 export const getJoinColumn = (
@ -9,10 +9,7 @@ export const getJoinColumn = (
  relationMetadataArgs: WorkspaceRelationMetadataArgs,
  opposite = false,
 ): string | null => {
-  if (
-    relationMetadataArgs.type === RelationMetadataType.ONE_TO_MANY ||
-    relationMetadataArgs.type === RelationMetadataType.MANY_TO_MANY
-  ) {
+  if (relationMetadataArgs.type === RelationType.ONE_TO_MANY) {
    return null;
  }

@ -41,7 +38,7 @@ export const getJoinColumn = (

  // If we're in a ONE_TO_ONE relation and there are no join columns, we need to find the join column on the inverse side
  if (
-    relationMetadataArgs.type === RelationMetadataType.ONE_TO_ONE &&
+    relationMetadataArgs.type === RelationType.ONE_TO_ONE &&
    filteredJoinColumnsMetadataArgsCollection.length === 0 &&
    !opposite
  ) {