feat: twenty orm for standard and custom objects (#6178)

### Overview

This PR builds upon #5153, adding the ability to get a repository for
custom objects. The `entitySchema` is now generated for both standard
and custom objects based on metadata stored in the database instead of
the decorated `WorkspaceEntity` in the code. This change ensures that
standard objects with custom fields and relations can also support
custom objects.

### Implementation Details

#### Key Changes:

- **Dynamic Schema Generation:** The `entitySchema` for standard and
custom objects is now dynamically generated from the metadata stored in
the database. This shift allows for greater flexibility and
adaptability, particularly for standard objects with custom fields and
relations.
  
- **Custom Object Repository Retrieval:** A repository for a custom
object can be retrieved using `TwentyORMManager` based on the object's
name. Here's an example of how this can be achieved:

  ```typescript
const repository = await this.twentyORMManager.getRepository('custom');
  /*
* `repository` variable will be typed as follows, ensuring that standard
fields and relations are properly typed:
   * const repository: WorkspaceRepository<CustomWorkspaceEntity & {
   *    [key: string]: any;
   * }>
   */
  const res = await repository.find({});
  ```

Fix #6179

---------

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

packages/twenty-server/src/engine/twenty-orm/datasource/workspace.datasource.ts

@@ -1,24 +1,39 @@
 import {
   DataSource,
-  EntityManager,
+  DataSourceOptions,
   EntityTarget,
   ObjectLiteral,
   QueryRunner,
 } from 'typeorm';
 
+import { WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
+
 import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/entity.manager';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 
 export class WorkspaceDataSource extends DataSource {
+  readonly internalContext: WorkspaceInternalContext;
   readonly manager: WorkspaceEntityManager;
 
+  constructor(
+    internalContext: WorkspaceInternalContext,
+    options: DataSourceOptions,
+  ) {
+    super(options);
+    this.internalContext = internalContext;
+    // Recreate manager after internalContext has been initialized
+    this.manager = this.createEntityManager();
+  }
+
   override getRepository<Entity extends ObjectLiteral>(
     target: EntityTarget<Entity>,
   ): WorkspaceRepository<Entity> {
     return this.manager.getRepository(target);
   }
 
-  override createEntityManager(queryRunner?: QueryRunner): EntityManager {
-    return new WorkspaceEntityManager(this, queryRunner);
+  override createEntityManager(
+    queryRunner?: QueryRunner,
+  ): WorkspaceEntityManager {
+    return new WorkspaceEntityManager(this.internalContext, this, queryRunner);
   }
 }