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

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]) {