fix: multiple twenty orm issues & show an example of use (#5439)

This PR is fixing some issues and adding enhancement in TwentyORM: - [x] Composite fields in nested relations are not formatted properly - [x] Passing operators like `Any` in `where` condition is breaking the query - [x] Ability to auto load workspace-entities based on a regex path I've also introduced an example of use for `CalendarEventService`: https://github.com/twentyhq/twenty/pull/5439/files#diff-3a7dffc0dea57345d10e70c648e911f98fe237248bcea124dafa9c8deb1db748R15
2024-05-20 11:01:47 +02:00
parent 81e8f49033
commit 8b5f79ddbf
147 changed files with 1108 additions and 1101 deletions
--- a/packages/twenty-server/src/engine/twenty-orm/custom.workspace-entity.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/custom.workspace-entity.ts
@ -3,11 +3,11 @@ import {
  RelationMetadataType,
  RelationOnDeleteAction,
 } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
-import { ActivityTargetObjectMetadata } from 'src/modules/activity/standard-objects/activity-target.object-metadata';
-import { FavoriteObjectMetadata } from 'src/modules/favorite/standard-objects/favorite.object-metadata';
-import { AttachmentObjectMetadata } from 'src/modules/attachment/standard-objects/attachment.object-metadata';
+import { ActivityTargetWorkspaceEntity } from 'src/modules/activity/standard-objects/activity-target.workspace-entity';
+import { FavoriteWorkspaceEntity } from 'src/modules/favorite/standard-objects/favorite.workspace-entity';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
 import { CUSTOM_OBJECT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
-import { TimelineActivityObjectMetadata } from 'src/modules/timeline/standard-objects/timeline-activity.object-metadata';
+import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';
 import { WorkspaceField } from 'src/engine/twenty-orm/decorators/workspace-field.decorator';
 import { WorkspaceIsNullable } from 'src/engine/twenty-orm/decorators/workspace-is-nullable.decorator';
 import { WorkspaceIsSystem } from 'src/engine/twenty-orm/decorators/workspace-is-system.decorator';
@ -45,11 +45,11 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Activities tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconCheckbox',
-    inverseSideTarget: () => ActivityTargetObjectMetadata,
+    inverseSideTarget: () => ActivityTargetWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
-  activityTargets: ActivityTargetObjectMetadata[];
+  activityTargets: ActivityTargetWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.favorites,
@ -58,12 +58,12 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Favorites tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconHeart',
-    inverseSideTarget: () => FavoriteObjectMetadata,
+    inverseSideTarget: () => FavoriteWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
  @WorkspaceIsSystem()
-  favorites: FavoriteObjectMetadata[];
+  favorites: FavoriteWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.attachments,
@ -72,11 +72,11 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Attachments tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconFileImport',
-    inverseSideTarget: () => AttachmentObjectMetadata,
+    inverseSideTarget: () => AttachmentWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
-  attachments: AttachmentObjectMetadata[];
+  attachments: AttachmentWorkspaceEntity[];

  @WorkspaceRelation({
    standardId: CUSTOM_OBJECT_STANDARD_FIELD_IDS.timelineActivities,
@ -85,10 +85,10 @@ export class CustomWorkspaceEntity extends BaseWorkspaceEntity {
    description: (objectMetadata) =>
      `Timeline Activities tied to the ${objectMetadata.labelSingular}`,
    icon: 'IconIconTimelineEvent',
-    inverseSideTarget: () => TimelineActivityObjectMetadata,
+    inverseSideTarget: () => TimelineActivityWorkspaceEntity,
    onDelete: RelationOnDeleteAction.CASCADE,
  })
  @WorkspaceIsNullable()
  @WorkspaceIsSystem()
-  timelineActivities: TimelineActivityObjectMetadata[];
+  timelineActivities: TimelineActivityWorkspaceEntity[];
 }
--- a/packages/twenty-server/src/engine/twenty-orm/decorators/workspace-entity.decorator.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/decorators/workspace-entity.decorator.ts
--- a/packages/twenty-server/src/engine/twenty-orm/entity-manager/entity.manager.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/entity-manager/entity.manager.ts
@ -9,7 +9,9 @@ export class WorkspaceEntityManager extends EntityManager {
    // find already created repository instance and return it if found
    const repoFromMap = this.repositories.get(target);

-    if (repoFromMap) return repoFromMap as WorkspaceRepository<Entity>;
+    if (repoFromMap) {
+      return repoFromMap as WorkspaceRepository<Entity>;
+    }

    const newRepository = new WorkspaceRepository<Entity>(
      target,
--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-column.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-column.factory.ts
@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { ColumnType, EntitySchemaColumnOptions } from 'typeorm';

 import { WorkspaceFieldMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-field-metadata-args.interface';
+import { WorkspaceRelationMetadataArgs } from 'src/engine/twenty-orm/interfaces/workspace-relation-metadata-args.interface';

 import { fieldMetadataTypeToColumnType } from 'src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util';
 import { isEnumFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-enum-field-metadata-type.util';
@ -20,6 +21,7 @@ type EntitySchemaColumnMap = {
 export class EntitySchemaColumnFactory {
  create(
    fieldMetadataArgsCollection: WorkspaceFieldMetadataArgs[],
+    relationMetadataArgsCollection: WorkspaceRelationMetadataArgs[],
  ): EntitySchemaColumnMap {
    let entitySchemaColumnMap: EntitySchemaColumnMap = {};

@ -53,6 +55,16 @@ export class EntitySchemaColumnFactory {
        default: defaultValue,
      };

+      for (const relationMetadataArgs of relationMetadataArgsCollection) {
+        if (relationMetadataArgs.joinColumn) {
+          entitySchemaColumnMap[relationMetadataArgs.joinColumn] = {
+            name: relationMetadataArgs.joinColumn,
+            type: 'uuid',
+            nullable: relationMetadataArgs.isNullable,
+          };
+        }
+      }
+
      if (isEnumFieldMetadataType(fieldMetadataArgs.type)) {
        const values = fieldMetadataArgs.options?.map((option) => option.value);

--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-relation.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema-relation.factory.ts
@ -15,11 +15,14 @@ type EntitySchemaRelationMap = {
@Injectable()
 export class EntitySchemaRelationFactory {
  create(
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    target: Function,
    relationMetadataArgsCollection: WorkspaceRelationMetadataArgs[],
  ): EntitySchemaRelationMap {
    const entitySchemaRelationMap: EntitySchemaRelationMap = {};

    for (const relationMetadataArgs of relationMetadataArgsCollection) {
+      const objectName = convertClassNameToObjectMetadataName(target.name);
      const oppositeTarget = relationMetadataArgs.inverseSideTarget();
      const oppositeObjectName = convertClassNameToObjectMetadataName(
        oppositeTarget.name,
@ -30,7 +33,7 @@ export class EntitySchemaRelationFactory {
      entitySchemaRelationMap[relationMetadataArgs.name] = {
        type: relationType,
        target: oppositeObjectName,
-        inverseSide: relationMetadataArgs.inverseSideFieldKey,
+        inverseSide: relationMetadataArgs.inverseSideFieldKey ?? objectName,
        joinColumn: relationMetadataArgs.joinColumn
          ? {
              name: relationMetadataArgs.joinColumn,
--- a/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema.factory.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/factories/entity-schema.factory.ts
@ -28,9 +28,11 @@ export class EntitySchemaFactory {

    const columns = this.entitySchemaColumnFactory.create(
      fieldMetadataArgsCollection,
+      relationMetadataArgsCollection,
    );

    const relations = this.entitySchemaRelationFactory.create(
+      target,
      relationMetadataArgsCollection,
    );

--- a/packages/twenty-server/src/engine/twenty-orm/interfaces/twenty-orm-options.interface.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/interfaces/twenty-orm-options.interface.ts
@ -3,7 +3,7 @@ import { FactoryProvider, ModuleMetadata, Type } from '@nestjs/common';
 import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';

 export interface TwentyORMOptions {
-  workspaceEntities: Type<BaseWorkspaceEntity>[];
+  workspaceEntities: (Type<BaseWorkspaceEntity> | string)[];
 }

 export type TwentyORMModuleAsyncOptions = {
--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace.repository.ts
@ -21,6 +21,7 @@ import { ObjectLiteralStorage } from 'src/engine/twenty-orm/storage/object-liter
 import { compositeTypeDefintions } from 'src/engine/metadata-modules/field-metadata/composite-types';
 import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
+import { isPlainObject } from 'src/utils/is-plain-object';

 export class WorkspaceRepository<
  Entity extends ObjectLiteral,
@ -492,7 +493,7 @@ export class WorkspaceRepository<
      const fieldMetadataArgs = compositeFieldMetadataArgsMap.get(key);

      if (!fieldMetadataArgs) {
-        if (typeof value === 'object') {
+        if (isPlainObject(value)) {
          newData[key] = this.formatData(value);
        } else {
          newData[key] = value;
@ -524,25 +525,30 @@ export class WorkspaceRepository<
    return newData as T;
  }

-  private formatResult<T>(data: T): T {
+  private formatResult<T>(
+    data: T,
+    target = ObjectLiteralStorage.getObjectLiteral(this.target as any),
+  ): T {
    if (!data) {
      return data;
    }

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

-    const objectLiteral = ObjectLiteralStorage.getObjectLiteral(
-      this.target as any,
-    );
+    if (!isPlainObject(data)) {
+      return data;
+    }

-    if (!objectLiteral) {
+    if (!target) {
      throw new Error('Object literal is missing');
    }

    const fieldMetadataArgsCollection =
-      metadataArgsStorage.filterFields(objectLiteral);
+      metadataArgsStorage.filterFields(target);
+    const relationMetadataArgsCollection =
+      metadataArgsStorage.filterRelations(target);
    const compositeFieldMetadataArgsCollection =
      fieldMetadataArgsCollection.filter((fieldMetadataArg) =>
        isCompositeFieldMetadataType(fieldMetadataArg.type),
@ -565,13 +571,20 @@ export class WorkspaceRepository<
        ]);
      }),
    );
+    const relationMetadataArgsMap = new Map(
+      relationMetadataArgsCollection.map((relationMetadataArgs) => [
+        relationMetadataArgs.name,
+        relationMetadataArgs,
+      ]),
+    );
    const newData: object = {};

    for (const [key, value] of Object.entries(data)) {
      const compositePropertyArgs = compositeFieldMetadataArgsMap.get(key);
+      const relationMetadataArgs = relationMetadataArgsMap.get(key);

-      if (!compositePropertyArgs) {
-        if (typeof value === 'object') {
+      if (!compositePropertyArgs && !relationMetadataArgs) {
+        if (isPlainObject(value)) {
          newData[key] = this.formatResult(value);
        } else {
          newData[key] = value;
@ -579,6 +592,18 @@ export class WorkspaceRepository<
        continue;
      }

+      if (relationMetadataArgs) {
+        newData[key] = this.formatResult(
+          value,
+          relationMetadataArgs.inverseSideTarget() as any,
+        );
+        continue;
+      }
+
+      if (!compositePropertyArgs) {
+        continue;
+      }
+
      const { parentField, ...compositeProperty } = compositePropertyArgs;

      if (!newData[parentField]) {
--- a/packages/twenty-server/src/engine/twenty-orm/twenty-orm-core.module.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/twenty-orm-core.module.ts
@ -5,12 +5,16 @@ import {
  Module,
  OnApplicationShutdown,
  Provider,
+  Type,
 } from '@nestjs/common';
 import {
  ConfigurableModuleClass,
  MODULE_OPTIONS_TOKEN,
 } from '@nestjs/common/cache/cache.module-definition';

+import { importClassesFromDirectories } from 'typeorm/util/DirectoryExportedClassesLoader';
+import { Logger as TypeORMLogger } from 'typeorm/logger/Logger';
+
 import {
  TwentyORMModuleAsyncOptions,
  TwentyORMOptions,
@ -23,6 +27,9 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
 import { EntitySchemaFactory } from 'src/engine/twenty-orm/factories/entity-schema.factory';
 import { DataSourceStorage } from 'src/engine/twenty-orm/storage/data-source.storage';
 import { ScopedWorkspaceDatasourceFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-datasource.factory';
+import { BaseWorkspaceEntity } from 'src/engine/twenty-orm/base.workspace-entity';
+import { splitClassesAndStrings } from 'src/engine/twenty-orm/utils/split-classes-and-strings.util';
+import { CustomWorkspaceEntity } from 'src/engine/twenty-orm/custom.workspace-entity';

@Global()
@Module({
@ -34,10 +41,12 @@ export class TwentyORMCoreModule
  extends ConfigurableModuleClass
  implements OnApplicationShutdown
 {
-  private readonly logger = new Logger(TwentyORMCoreModule.name);
+  private static readonly logger = new Logger(TwentyORMCoreModule.name);

  static register(options: TwentyORMOptions): DynamicModule {
    const dynamicModule = super.register(options);
+
+    console.log('register', options);
    const providers: Provider[] = [
      {
        provide: TWENTY_ORM_WORKSPACE_DATASOURCE,
@ -45,7 +54,11 @@ export class TwentyORMCoreModule
          entitySchemaFactory: EntitySchemaFactory,
          scopedWorkspaceDatasourceFactory: ScopedWorkspaceDatasourceFactory,
        ) => {
-          const entities = options.workspaceEntities.map((entityClass) =>
+          const workspaceEntities = await this.loadEntities(
+            options.workspaceEntities,
+          );
+
+          const entities = workspaceEntities.map((entityClass) =>
            entitySchemaFactory.create(entityClass),
          );

@ -80,7 +93,11 @@ export class TwentyORMCoreModule
          scopedWorkspaceDatasourceFactory: ScopedWorkspaceDatasourceFactory,
          options: TwentyORMOptions,
        ) => {
-          const entities = options.workspaceEntities.map((entityClass) =>
+          const workspaceEntities = await this.loadEntities(
+            options.workspaceEntities,
+          );
+
+          const entities = workspaceEntities.map((entityClass) =>
            entitySchemaFactory.create(entityClass),
          );

@ -123,4 +140,29 @@ export class TwentyORMCoreModule
      }
    }
  }
+
+  private static async loadEntities(
+    workspaceEntities: (Type<BaseWorkspaceEntity> | string)[],
+  ): Promise<Type<BaseWorkspaceEntity>[]> {
+    const [entityClassesOrSchemas, entityDirectories] = splitClassesAndStrings(
+      workspaceEntities || [],
+    );
+    const importedEntities = await importClassesFromDirectories(
+      // Only `log` function is used under importClassesFromDirectories function
+      this.logger as unknown as TypeORMLogger,
+      entityDirectories,
+    );
+    const entities = [
+      ...entityClassesOrSchemas,
+      ...(importedEntities as Type<BaseWorkspaceEntity>[]),
+    ];
+
+    return entities.filter(
+      (entity) =>
+        // Filter out CustomWorkspaceEntity as it's a partial entity handled separately
+        entity.name !== CustomWorkspaceEntity.name &&
+        // Filter out BaseWorkspaceEntity as it's a base entity and should not be included in the workspace entities
+        entity.name !== BaseWorkspaceEntity.name,
+    );
+  }
 }
--- a/packages/twenty-server/src/engine/twenty-orm/utils/split-classes-and-strings.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/split-classes-and-strings.util.ts
@ -0,0 +1,8 @@
+export const splitClassesAndStrings = <T>(
+  classesAndStrings: (string | T)[],
+): [T[], string[]] => {
+  return [
+    classesAndStrings.filter((cls): cls is T => typeof cls !== 'string'),
+    classesAndStrings.filter((str): str is string => typeof str === 'string'),
+  ];
+};