Added all field types on pet custom object (#9248)

- Added all usable composite field types on pet custom object - Fixed missing createdBy on people and company seeds - DEFAULT_SUBDOMAIN is now used for login (could be improved for multi workspace) - Refactored ObjectMetadataStandardIdToIdMap to disambiguate from ObjectMetadataMap - Refactored seedCustomObjects
2024-12-27 15:01:09 +01:00
parent 58c92e036b
commit a8bb3e6bdf
27 changed files with 742 additions and 5428 deletions
--- a/packages/twenty-front/src/modules/settings/data-model/constants/SettingsCompositeFieldTypeConfigs.ts
+++ b/packages/twenty-front/src/modules/settings/data-model/constants/SettingsCompositeFieldTypeConfigs.ts
@ -89,10 +89,11 @@ export const SETTINGS_COMPOSITE_FIELD_TYPE_CONFIGS = {
    label: 'Phones',
    Icon: IllustrationIconPhone,
    exampleValue: {
-      primaryPhoneNumber: '234-567-890',
-      primaryPhoneCountryCode: '+1',
+      primaryPhoneCallingCode: '+33',
+      primaryPhoneCountryCode: 'FR',
+      primaryPhoneNumber: '789012345',
      additionalPhones: [
-        { number: '234-567-890', callingCode: '+1', countryCode: 'US' },
+        { number: '617272323', callingCode: '+33', countryCode: 'FR' },
      ],
    },
    subFields: [
--- a/packages/twenty-server/src/database/commands/data-seed-dev-workspace.command.ts
+++ b/packages/twenty-server/src/database/commands/data-seed-dev-workspace.command.ts
@ -1,18 +1,17 @@
 import { Logger } from '@nestjs/common';

 import { Command, CommandRunner } from 'nest-commander';
-import { EntityManager } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';

 import { seedCoreSchema } from 'src/database/typeorm-seeds/core';
 import {
-  SEED_APPLE_WORKSPACE_ID,
  SEED_ACME_WORKSPACE_ID,
+  SEED_APPLE_WORKSPACE_ID,
 } from 'src/database/typeorm-seeds/core/workspaces';
 import {
  getDevSeedCompanyCustomFields,
  getDevSeedPeopleCustomFields,
 } from 'src/database/typeorm-seeds/metadata/fieldsMetadata';
-import { getDevSeedCustomObjects } from 'src/database/typeorm-seeds/metadata/objectsMetadata';
 import { seedCalendarChannels } from 'src/database/typeorm-seeds/workspace/calendar-channel';
 import { seedCalendarChannelEventAssociations } from 'src/database/typeorm-seeds/workspace/calendar-channel-event-association';
 import { seedCalendarEventParticipants } from 'src/database/typeorm-seeds/workspace/calendar-event-participants';
@ -27,7 +26,7 @@ import { seedMessageThreadSubscribers } from 'src/database/typeorm-seeds/workspa
 import { seedMessageThread } from 'src/database/typeorm-seeds/workspace/message-threads';
 import { seedMessage } from 'src/database/typeorm-seeds/workspace/messages';
 import { seedOpportunity } from 'src/database/typeorm-seeds/workspace/opportunities';
-import { seedPeople } from 'src/database/typeorm-seeds/workspace/people';
+import { seedPeople } from 'src/database/typeorm-seeds/workspace/seedPeople';
 import { seedWorkspaceMember } from 'src/database/typeorm-seeds/workspace/workspace-members';
 import { rawDataSource } from 'src/database/typeorm/raw/raw.datasource';
 import { TypeORMService } from 'src/database/typeorm/typeorm.service';
@ -36,10 +35,15 @@ import { CacheStorageService } from 'src/engine/core-modules/cache-storage/servi
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
 import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ObjectMetadataService } from 'src/engine/metadata-modules/object-metadata/object-metadata.service';
+import { PETS_DATA_SEEDS } from 'src/engine/seeder/data-seeds/pets-data-seeds';
+import { SURVEY_RESULTS_DATA_SEEDS } from 'src/engine/seeder/data-seeds/survey-results-data-seeds';
+import { PETS_METADATA_SEEDS } from 'src/engine/seeder/metadata-seeds/pets-metadata-seeds';
+import { SURVEY_RESULTS_METADATA_SEEDS } from 'src/engine/seeder/metadata-seeds/survey-results-metadata-seeds';
+import { SeederService } from 'src/engine/seeder/seeder.service';
 import { shouldSeedWorkspaceFavorite } from 'src/engine/utils/should-seed-workspace-favorite';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { seedViewWithDemoData } from 'src/engine/workspace-manager/standard-objects-prefill-data/seed-view-with-demo-data';
@ -66,6 +70,7 @@ export class DataSeedWorkspaceCommand extends CommandRunner {
    @InjectCacheStorage(CacheStorageNamespace.EngineWorkspace)
    private readonly workspaceSchemaCache: CacheStorageService,
    private readonly featureFlagService: FeatureFlagService,
+    private readonly seederService: SeederService,
  ) {
    super();
  }
@ -73,29 +78,7 @@ export class DataSeedWorkspaceCommand extends CommandRunner {
  async run(): Promise<void> {
    try {
      for (const workspaceId of this.workspaceIds) {
-        await this.workspaceSchemaCache.flush();
-
-        await rawDataSource.initialize();
-
-        await seedCoreSchema(rawDataSource, workspaceId);
-
-        await rawDataSource.destroy();
-
-        const schemaName =
-          await this.workspaceDataSourceService.createWorkspaceDBSchema(
-            workspaceId,
-          );
-
-        const dataSourceMetadata =
-          await this.dataSourceService.createDataSourceMetadata(
-            workspaceId,
-            schemaName,
-          );
-
-        await this.workspaceSyncMetadataService.synchronize({
-          workspaceId: workspaceId,
-          dataSourceId: dataSourceMetadata.id,
-        });
+        await this.createWorkspaceSchema(workspaceId);
      }
    } catch (error) {
      this.logger.error(error);
@ -104,150 +87,185 @@ export class DataSeedWorkspaceCommand extends CommandRunner {
    }

    for (const workspaceId of this.workspaceIds) {
-      const dataSourceMetadata =
-        await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+      await this.seedWorkspace(workspaceId);
+    }
+  }
+
+  async createWorkspaceSchema(workspaceId: string) {
+    await this.workspaceSchemaCache.flush();
+
+    await rawDataSource.initialize();
+
+    await seedCoreSchema(rawDataSource, workspaceId);
+
+    await rawDataSource.destroy();
+
+    const schemaName =
+      await this.workspaceDataSourceService.createWorkspaceDBSchema(
+        workspaceId,
+      );
+
+    const dataSourceMetadata =
+      await this.dataSourceService.createDataSourceMetadata(
+        workspaceId,
+        schemaName,
+      );
+
+    await this.workspaceSyncMetadataService.synchronize({
+      workspaceId: workspaceId,
+      dataSourceId: dataSourceMetadata.id,
+    });
+  }
+
+  async seedWorkspace(workspaceId: string) {
+    const dataSourceMetadata =
+      await this.dataSourceService.getLastDataSourceMetadataFromWorkspaceIdOrFail(
+        workspaceId,
+      );
+
+    const workspaceDataSource =
+      await this.typeORMService.connectToDataSource(dataSourceMetadata);
+
+    if (!workspaceDataSource) {
+      throw new Error('Could not connect to workspace data source');
+    }
+
+    try {
+      const { objectMetadataStandardIdToIdMap } =
+        await this.objectMetadataService.getObjectMetadataStandardIdToIdMap(
          workspaceId,
        );

-      const workspaceDataSource =
-        await this.typeORMService.connectToDataSource(dataSourceMetadata);
+      await this.seedCompanyCustomFields(
+        objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].id,
+        workspaceId,
+      );

-      if (!workspaceDataSource) {
-        throw new Error('Could not connect to workspace data source');
-      }
+      await this.seedPeopleCustomFields(
+        objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].id,
+        workspaceId,
+      );

-      try {
-        const objectMetadata =
-          await this.objectMetadataService.findManyWithinWorkspace(workspaceId);
-        const objectMetadataMap = objectMetadata.reduce((acc, object) => {
-          acc[object.standardId ?? ''] = {
-            id: object.id,
-            fields: object.fields.reduce((acc, field) => {
-              acc[field.standardId ?? ''] = field.id;
+      await this.seedStandardObjectRecords(
+        workspaceDataSource,
+        dataSourceMetadata,
+      );

-              return acc;
-            }, {}),
-          };
+      await this.seederService.seedCustomObjects(
+        dataSourceMetadata.id,
+        workspaceId,
+        PETS_METADATA_SEEDS,
+        PETS_DATA_SEEDS,
+      );

-          return acc;
-        }, {});
+      await this.seederService.seedCustomObjects(
+        dataSourceMetadata.id,
+        workspaceId,
+        SURVEY_RESULTS_METADATA_SEEDS,
+        SURVEY_RESULTS_DATA_SEEDS,
+      );
+    } catch (error) {
+      this.logger.error(error);
+    }
+
+    await this.typeORMService.disconnectFromDataSource(dataSourceMetadata.id);
+  }
+
+  async seedStandardObjectRecords(
+    workspaceDataSource: DataSource,
+    dataSourceMetadata: DataSourceEntity,
+  ) {
+    await workspaceDataSource.transaction(
+      async (entityManager: EntityManager) => {
+        const { objectMetadataStandardIdToIdMap } =
+          await this.objectMetadataService.getObjectMetadataStandardIdToIdMap(
+            dataSourceMetadata.workspaceId,
+          );

        const isMessageThreadSubscriberEnabled =
          await this.featureFlagService.isFeatureEnabled(
            FeatureFlagKey.IsMessageThreadSubscriberEnabled,
-            workspaceId,
+            dataSourceMetadata.workspaceId,
          );

        const isWorkflowEnabled =
          await this.featureFlagService.isFeatureEnabled(
            FeatureFlagKey.IsWorkflowEnabled,
-            workspaceId,
+            dataSourceMetadata.workspaceId,
          );

-        await this.seedCompanyCustomFields(
-          objectMetadataMap[STANDARD_OBJECT_IDS.company],
-          workspaceId,
+        await seedCompanies(entityManager, dataSourceMetadata.schema);
+        await seedPeople(entityManager, dataSourceMetadata.schema);
+        await seedOpportunity(entityManager, dataSourceMetadata.schema);
+        await seedWorkspaceMember(
+          entityManager,
+          dataSourceMetadata.schema,
+          dataSourceMetadata.workspaceId,
        );
-        await this.seedPeopleCustomFields(
-          objectMetadataMap[STANDARD_OBJECT_IDS.person],
-          workspaceId,
-        );
-        await this.seedCustomObjects(workspaceId, dataSourceMetadata.id);

-        await workspaceDataSource.transaction(
-          async (entityManager: EntityManager) => {
-            await seedCompanies(entityManager, dataSourceMetadata.schema);
-            await seedPeople(entityManager, dataSourceMetadata.schema);
-            await seedOpportunity(entityManager, dataSourceMetadata.schema);
-            await seedWorkspaceMember(
-              entityManager,
-              dataSourceMetadata.schema,
-              workspaceId,
-            );
+        if (dataSourceMetadata.workspaceId === SEED_APPLE_WORKSPACE_ID) {
+          await seedMessageThread(entityManager, dataSourceMetadata.schema);
+          await seedConnectedAccount(entityManager, dataSourceMetadata.schema);

-            if (workspaceId === SEED_APPLE_WORKSPACE_ID) {
-              await seedMessageThread(entityManager, dataSourceMetadata.schema);
-              await seedConnectedAccount(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-
-              if (isMessageThreadSubscriberEnabled) {
-                await seedMessageThreadSubscribers(
-                  entityManager,
-                  dataSourceMetadata.schema,
-                );
-              }
-
-              await seedMessage(entityManager, dataSourceMetadata.schema);
-              await seedMessageChannel(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-              await seedMessageChannelMessageAssociation(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-              await seedMessageParticipant(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-
-              await seedCalendarEvents(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-              await seedCalendarChannels(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-              await seedCalendarChannelEventAssociations(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-              await seedCalendarEventParticipants(
-                entityManager,
-                dataSourceMetadata.schema,
-              );
-            }
-
-            const viewDefinitionsWithId = await seedViewWithDemoData(
-              entityManager,
-              dataSourceMetadata.schema,
-              objectMetadataMap,
-              isWorkflowEnabled,
-            );
-
-            await seedWorkspaceFavorites(
-              viewDefinitionsWithId
-                .filter(
-                  (view) =>
-                    view.key === 'INDEX' &&
-                    shouldSeedWorkspaceFavorite(
-                      view.objectMetadataId,
-                      objectMetadataMap,
-                    ),
-                )
-                .map((view) => view.id),
+          if (isMessageThreadSubscriberEnabled) {
+            await seedMessageThreadSubscribers(
              entityManager,
              dataSourceMetadata.schema,
            );
-          },
-        );
-      } catch (error) {
-        this.logger.error(error);
-      }
+          }

-      await this.typeORMService.disconnectFromDataSource(dataSourceMetadata.id);
-    }
+          await seedMessage(entityManager, dataSourceMetadata.schema);
+          await seedMessageChannel(entityManager, dataSourceMetadata.schema);
+          await seedMessageChannelMessageAssociation(
+            entityManager,
+            dataSourceMetadata.schema,
+          );
+          await seedMessageParticipant(
+            entityManager,
+            dataSourceMetadata.schema,
+          );
+
+          await seedCalendarEvents(entityManager, dataSourceMetadata.schema);
+          await seedCalendarChannels(entityManager, dataSourceMetadata.schema);
+          await seedCalendarChannelEventAssociations(
+            entityManager,
+            dataSourceMetadata.schema,
+          );
+          await seedCalendarEventParticipants(
+            entityManager,
+            dataSourceMetadata.schema,
+          );
+        }
+
+        const viewDefinitionsWithId = await seedViewWithDemoData(
+          entityManager,
+          dataSourceMetadata.schema,
+          objectMetadataStandardIdToIdMap,
+          isWorkflowEnabled,
+        );
+
+        await seedWorkspaceFavorites(
+          viewDefinitionsWithId
+            .filter(
+              (view) =>
+                view.key === 'INDEX' &&
+                shouldSeedWorkspaceFavorite(
+                  view.objectMetadataId,
+                  objectMetadataStandardIdToIdMap,
+                ),
+            )
+            .map((view) => view.id),
+          entityManager,
+          dataSourceMetadata.schema,
+        );
+      },
+    );
  }

  async seedCompanyCustomFields(
-    companyObjectMetadata: ObjectMetadataEntity,
+    companyObjectMetadataId: string,
    workspaceId: string,
  ) {
-    const companyObjectMetadataId = companyObjectMetadata?.id;
-
    if (!companyObjectMetadataId) {
      throw new Error(
        `Company object metadata not found for workspace ${workspaceId}, can't seed custom fields`,
@ -269,11 +287,9 @@ export class DataSeedWorkspaceCommand extends CommandRunner {
  }

  async seedPeopleCustomFields(
-    personObjectMetadata: ObjectMetadataEntity,
+    personObjectMetadataId: string,
    workspaceId: string,
  ) {
-    const personObjectMetadataId = personObjectMetadata?.id;
-
    if (!personObjectMetadataId) {
      throw new Error(
        `Person object metadata not found for workspace ${workspaceId}, can't seed custom fields`,
@ -292,15 +308,4 @@ export class DataSeedWorkspaceCommand extends CommandRunner {
      });
    }
  }
-
-  async seedCustomObjects(workspaceId: string, dataSourceId: string) {
-    const devSeedCustomObjects = getDevSeedCustomObjects(
-      workspaceId,
-      dataSourceId,
-    );
-
-    for (const customObject of devSeedCustomObjects) {
-      await this.objectMetadataService.createOne(customObject);
-    }
-  }
 }
--- a/packages/twenty-server/src/database/commands/database-command.module.ts
+++ b/packages/twenty-server/src/database/commands/database-command.module.ts
@ -23,6 +23,7 @@ import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
 import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
+import { SeederModule } from 'src/engine/seeder/seeder.module';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
 import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { WorkspaceManagerModule } from 'src/engine/workspace-manager/workspace-manager.module';
@ -30,6 +31,7 @@ import { WorkspaceSyncMetadataModule } from 'src/engine/workspace-manager/worksp

@Module({
  imports: [
+    SeederModule,
    WorkspaceManagerModule,
    DataSourceModule,
    TypeORMModule,
--- a/packages/twenty-server/src/database/typeorm-seeds/workspace/calendar-event-participants.ts
+++ b/packages/twenty-server/src/database/typeorm-seeds/workspace/calendar-event-participants.ts
@ -1,6 +1,6 @@
 import { EntityManager } from 'typeorm';

-import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/people';
+import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/seedPeople';
 import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';
 import { CalendarEventParticipantResponseStatus } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';

--- a/packages/twenty-server/src/database/typeorm-seeds/workspace/companies.ts
+++ b/packages/twenty-server/src/database/typeorm-seeds/workspace/companies.ts
@ -264,8 +264,8 @@ export const seedCompanies = async (
        tagline: "Algolia's tagline",
        workPolicy: ['ON_SITE'],
        createdBySource: 'MANUAL',
-        createdByWorkspaceMemberId: null,
-        createdByName: '',
+        createdByWorkspaceMemberId: DEV_SEED_WORKSPACE_MEMBER_IDS.TIM,
+        createdByName: 'Tim Apple',
      },
    ])
    .execute();
--- a/packages/twenty-server/src/database/typeorm-seeds/workspace/message-participants.ts
+++ b/packages/twenty-server/src/database/typeorm-seeds/workspace/message-participants.ts
@ -1,8 +1,8 @@
 import { EntityManager } from 'typeorm';

-import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';
-import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/people';
 import { DEV_SEED_MESSAGE_IDS } from 'src/database/typeorm-seeds/workspace/messages';
+import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/seedPeople';
+import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';

 const tableName = 'messageParticipant';

--- a/packages/twenty-server/src/database/typeorm-seeds/workspace/opportunities.ts
+++ b/packages/twenty-server/src/database/typeorm-seeds/workspace/opportunities.ts
@ -1,7 +1,7 @@
 import { EntityManager } from 'typeorm';

 import { DEV_SEED_COMPANY_IDS } from 'src/database/typeorm-seeds/workspace/companies';
-import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/people';
+import { DEV_SEED_PERSON_IDS } from 'src/database/typeorm-seeds/workspace/seedPeople';
 import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';

 const tableName = 'opportunity';
--- a/packages/twenty-server/src/database/typeorm-seeds/workspace/seedPeople.ts
+++ b/packages/twenty-server/src/database/typeorm-seeds/workspace/seedPeople.ts
@ -317,8 +317,8 @@ export const seedPeople = async (
        whatsappPrimaryPhoneCallingCode: '+33',
        whatsappPrimaryPhoneNumber: '788901235',
        createdBySource: 'MANUAL',
-        createdByWorkspaceMemberId: null,
-        createdByName: '',
+        createdByWorkspaceMemberId: DEV_SEED_WORKSPACE_MEMBER_IDS.TIM,
+        createdByName: 'Tim Apple',
      },
    ])
    .execute();
--- a/packages/twenty-server/src/engine/core-modules/domain-manager/service/domain-manager.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/domain-manager/service/domain-manager.service.ts
@ -147,6 +147,21 @@ export class DomainManagerService {

  private async getDefaultWorkspace() {
    if (!this.environmentService.get('IS_MULTIWORKSPACE_ENABLED')) {
+      const defaultWorkspaceSubDomain =
+        this.environmentService.get('DEFAULT_SUBDOMAIN');
+
+      if (isDefined(defaultWorkspaceSubDomain)) {
+        const foundWorkspaceForDefaultSubDomain =
+          await this.workspaceRepository.findOne({
+            where: { subdomain: defaultWorkspaceSubDomain },
+            relations: ['workspaceSSOIdentityProviders'],
+          });
+
+        if (isDefined(foundWorkspaceForDefaultSubDomain)) {
+          return foundWorkspaceForDefaultSubDomain;
+        }
+      }
+
      const workspaces = await this.workspaceRepository.find({
        order: {
          createdAt: 'DESC',
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map.ts
@ -0,0 +1,8 @@
+export type ObjectMetadataStandardIdToIdMap = {
+  [objectMetadataStandardId: string]: {
+    id: string;
+    fields: {
+      [fieldMetadataStandardId: string]: string;
+    };
+  };
+};
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
@ -8,6 +8,8 @@ import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
 import { isDefined } from 'class-validator';
 import { FindManyOptions, FindOneOptions, In, Not, Repository } from 'typeorm';

+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { IndexMetadataService } from 'src/engine/metadata-modules/index-metadata/index-metadata.service';
@ -411,6 +413,26 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
    );
  }

+  public async getObjectMetadataStandardIdToIdMap(workspaceId: string) {
+    const objectMetadata = await this.findManyWithinWorkspace(workspaceId);
+
+    const objectMetadataStandardIdToIdMap =
+      objectMetadata.reduce<ObjectMetadataStandardIdToIdMap>((acc, object) => {
+        acc[object.standardId ?? ''] = {
+          id: object.id,
+          fields: object.fields.reduce((acc, field) => {
+            acc[field.standardId ?? ''] = field.id;
+
+            return acc;
+          }, {}),
+        };
+
+        return acc;
+      }, {});
+
+    return { objectMetadataStandardIdToIdMap };
+  }
+
  private async handleObjectNameAndLabelUpdates(
    existingObjectMetadata: ObjectMetadataEntity,
    objectMetadataForUpdate: ObjectMetadataEntity,
--- a/packages/twenty-server/src/engine/seeder/data-seeds/pets-data-seeds.ts
+++ b/packages/twenty-server/src/engine/seeder/data-seeds/pets-data-seeds.ts
--- a/packages/twenty-server/src/engine/seeder/data-seeds/survey-results-data-seeds.ts
+++ b/packages/twenty-server/src/engine/seeder/data-seeds/survey-results-data-seeds.ts
--- a/packages/twenty-server/src/engine/seeder/metadata-seeds/pets-metadata-seeds.ts
+++ b/packages/twenty-server/src/engine/seeder/metadata-seeds/pets-metadata-seeds.ts
@ -22,6 +22,24 @@ export const PETS_METADATA_SEEDS: ObjectMetadataSeed = {
        { label: 'Hamster', value: 'hamster', position: 5, color: 'orange' },
      ],
    },
+    {
+      type: FieldMetadataType.MULTI_SELECT,
+      label: 'Traits',
+      name: 'traits',
+      options: [
+        { label: 'Playful', value: 'playful', position: 0, color: 'blue' },
+        { label: 'Friendly', value: 'friendly', position: 1, color: 'red' },
+        {
+          label: 'Protective',
+          value: 'protective',
+          position: 2,
+          color: 'green',
+        },
+        { label: 'Shy', value: 'shy', position: 3, color: 'yellow' },
+        { label: 'Brave', value: 'brave', position: 4, color: 'purple' },
+        { label: 'Curious', value: 'curious', position: 5, color: 'orange' },
+      ],
+    },
    {
      type: FieldMetadataType.TEXT,
      label: 'Comments',
@ -37,5 +55,60 @@ export const PETS_METADATA_SEEDS: ObjectMetadataSeed = {
      label: 'Location',
      name: 'location',
    },
+    {
+      type: FieldMetadataType.PHONES,
+      label: 'Vet phone',
+      name: 'vetPhone',
+    },
+    {
+      type: FieldMetadataType.EMAILS,
+      label: 'Vet email',
+      name: 'vetEmail',
+    },
+    {
+      type: FieldMetadataType.DATE,
+      label: 'Birthday',
+      name: 'birthday',
+    },
+    {
+      type: FieldMetadataType.BOOLEAN,
+      label: 'Is good with kids',
+      name: 'isGoodWithKids',
+    },
+    {
+      type: FieldMetadataType.LINKS,
+      label: 'Pictures',
+      name: 'pictures',
+    },
+    {
+      type: FieldMetadataType.CURRENCY,
+      label: 'Average cost of kibble per month',
+      name: 'averageCostOfKibblePerMonth',
+    },
+    {
+      type: FieldMetadataType.FULL_NAME,
+      label: 'Makes its owner think of',
+      name: 'makesOwnerThinkOf',
+    },
+    {
+      type: FieldMetadataType.RATING,
+      label: 'Sound swag (bark style, meow style, etc.)',
+      name: 'soundSwag',
+    },
+    {
+      type: FieldMetadataType.RICH_TEXT,
+      label: 'Bio',
+      name: 'bio',
+    },
+    {
+      type: FieldMetadataType.ARRAY,
+      label: 'Interesting facts',
+      name: 'interestingFacts',
+    },
+    {
+      type: FieldMetadataType.RAW_JSON,
+      label: 'Extra data',
+      name: 'extraData',
+    },
  ],
 };
--- a/packages/twenty-server/src/engine/seeder/seeder.service.ts
+++ b/packages/twenty-server/src/engine/seeder/seeder.service.ts
@ -2,11 +2,14 @@ import { Injectable } from '@nestjs/common';

 import { ObjectMetadataSeed } from 'src/engine/seeder/interfaces/object-metadata-seed';

+import { DEV_SEED_WORKSPACE_MEMBER_IDS } from 'src/database/typeorm-seeds/workspace/workspace-members';
 import { compositeTypeDefinitions } from 'src/engine/metadata-modules/field-metadata/composite-types';
+import { CreateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
 import { FieldMetadataType } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
 import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
 import { ObjectMetadataService } from 'src/engine/metadata-modules/object-metadata/object-metadata.service';
+import { computeTableName } from 'src/engine/utils/compute-table-name.util';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { capitalize } from 'src/utils/capitalize';
 import { isDefined } from 'src/utils/is-defined';
@ -22,11 +25,11 @@ export class SeederService {
  public async seedCustomObjects(
    dataSourceId: string,
    workspaceId: string,
-    metadataSeeds: ObjectMetadataSeed,
-    dataSeeds: Record<string, any>[],
+    objectMetadataSeed: ObjectMetadataSeed,
+    objectRecordSeeds: Record<string, any>[],
  ): Promise<void> {
    const createdObjectMetadata = await this.objectMetadataService.createOne({
-      ...metadataSeeds,
+      ...objectMetadataSeed,
      dataSourceId,
      workspaceId,
    });
@ -35,9 +38,9 @@ export class SeederService {
      throw new Error("Object metadata couldn't be created");
    }

-    for (const customField of metadataSeeds.fields) {
+    for (const fieldMetadataSeed of objectMetadataSeed.fields) {
      await this.fieldMetadataService.createOne({
-        ...customField,
+        ...fieldMetadataSeed,
        objectMetadataId: createdObjectMetadata.id,
        workspaceId,
      });
@ -45,7 +48,7 @@ export class SeederService {

    const objectMetadataAfterFieldCreation =
      await this.objectMetadataService.findOneWithinWorkspace(workspaceId, {
-        where: { nameSingular: metadataSeeds.nameSingular },
+        where: { nameSingular: objectMetadataSeed.nameSingular },
      });

    if (!objectMetadataAfterFieldCreation) {
@ -64,98 +67,163 @@ export class SeederService {

    const entityManager = workspaceDataSource.createEntityManager();

-    const filteredFields = metadataSeeds.fields.filter((field) =>
-      objectMetadataAfterFieldCreation.fields.some(
-        (f) => f.name === field.name || f.name === `name`,
-      ),
+    const filteredFieldMetadataSeeds = objectMetadataSeed.fields.filter(
+      (field) =>
+        objectMetadataAfterFieldCreation.fields.some(
+          (f) => f.name === field.name || f.name === `name`,
+        ),
    );

-    if (filteredFields.length === 0) {
-      throw new Error('No fields found for seeding, check metadata');
+    if (filteredFieldMetadataSeeds.length === 0) {
+      throw new Error('No fields found for seeding, check metadata file');
    }

-    filteredFields.unshift({
-      name: 'name',
-      type: FieldMetadataType.TEXT,
-      label: 'Name',
-    });
+    this.addNameFieldToFieldMetadataSeeds(filteredFieldMetadataSeeds);

-    const fieldMetadataMap = filteredFields
-      .map((field) => {
-        if (isCompositeFieldMetadataType(field.type)) {
-          const compositeFieldTypeDefinition = compositeTypeDefinitions.get(
-            field.type,
-          );
+    const objectRecordSeedsAsSQLFlattenedSeeds = objectRecordSeeds.map(
+      (recordSeed) => {
+        const objectRecordSeedsAsSQLFlattenedSeeds = {};

-          if (!isDefined(compositeFieldTypeDefinition)) {
-            throw new Error(
-              `Composite field type definition not found for ${field.type}`,
+        for (const field of filteredFieldMetadataSeeds) {
+          if (isCompositeFieldMetadataType(field.type)) {
+            const compositeFieldTypeDefinition = compositeTypeDefinitions.get(
+              field.type,
            );
-          }

-          const fieldNames = compositeFieldTypeDefinition.properties?.map(
-            (property) => property.name,
-          );
+            if (!isDefined(compositeFieldTypeDefinition)) {
+              throw new Error(
+                `Composite field type definition not found for ${field.type}`,
+              );
+            }

-          return (
-            fieldNames?.map(
-              (subFieldName: string) =>
-                `${field.name}${capitalize(subFieldName)}`,
-            ) ?? []
-          );
-        } else {
-          return field.name;
-        }
-      })
-      .flat()
-      .filter(isDefined);
+            const fieldNames = compositeFieldTypeDefinition.properties
+              ?.map((property) => property.name)
+              .filter(isDefined);

-    const flattenedSeeds = dataSeeds.map((seed) => {
-      const flattenedSeed = {};
+            for (const subFieldName of fieldNames) {
+              const subFieldValue = recordSeed?.[field.name]?.[subFieldName];

-      for (const field of filteredFields) {
-        if (isCompositeFieldMetadataType(field.type)) {
-          const compositeFieldTypeDefinition = compositeTypeDefinitions.get(
-            field.type,
-          );
+              const subFieldValueAsSQLValue =
+                this.turnCompositeSubFieldValueAsSQLValue(
+                  field.type,
+                  subFieldName,
+                  subFieldValue,
+                );

-          if (!isDefined(compositeFieldTypeDefinition)) {
-            throw new Error(
-              `Composite field type definition not found for ${field.type}`,
+              const subFieldNameAsSQLColumnName = `${field.name}${capitalize(subFieldName)}`;
+
+              objectRecordSeedsAsSQLFlattenedSeeds[
+                subFieldNameAsSQLColumnName
+              ] = subFieldValueAsSQLValue;
+            }
+          } else {
+            const fieldValue = recordSeed[field.name];
+
+            const fieldValueAsSQLValue = this.turnFieldValueAsSQLValue(
+              field.type,
+              fieldValue,
            );
-          }

-          const fieldNames = compositeFieldTypeDefinition.properties
-            ?.map((property) => property.name)
-            .filter(isDefined);
-
-          for (const subFieldName of fieldNames) {
-            flattenedSeed[`${field.name}${capitalize(subFieldName)}`] =
-              seed?.[field.name]?.[subFieldName];
+            objectRecordSeedsAsSQLFlattenedSeeds[field.name] =
+              fieldValueAsSQLValue;
          }
-        } else {
-          flattenedSeed[field.name] = seed[field.name];
        }
-      }

-      return flattenedSeed;
-    });
+        return objectRecordSeedsAsSQLFlattenedSeeds;
+      },
+    );
+
+    if (!(objectRecordSeedsAsSQLFlattenedSeeds.length > 0)) {
+      return;
+    }
+
+    const fieldMetadataNamesAsFlattenedSQLColumnNames = Object.keys(
+      objectRecordSeedsAsSQLFlattenedSeeds[0],
+    );
+
+    const sqlColumnNames = [
+      ...fieldMetadataNamesAsFlattenedSQLColumnNames,
+      'position',
+      'createdBySource',
+      'createdByWorkspaceMemberId',
+      'createdByName',
+    ];
+
+    const sqlValues = objectRecordSeedsAsSQLFlattenedSeeds.map(
+      (flattenedSeed, index) => ({
+        ...flattenedSeed,
+        position: index,
+        createdBySource: 'MANUAL',
+        createdByWorkspaceMemberId: DEV_SEED_WORKSPACE_MEMBER_IDS.TIM,
+        createdByName: 'Tim Apple',
+      }),
+    );

    await entityManager
      .createQueryBuilder()
      .insert()
-      .into(`${schemaName}._${objectMetadataAfterFieldCreation.nameSingular}`, [
-        ...fieldMetadataMap,
-        'position',
-      ])
-      .orIgnore()
-      .values(
-        flattenedSeeds.map((flattenedSeed, index) => ({
-          ...flattenedSeed,
-          position: index,
-        })),
+      .into(
+        `${schemaName}.${computeTableName(objectMetadataAfterFieldCreation.nameSingular, true)}`,
+        sqlColumnNames,
      )
+      .orIgnore()
+      .values(sqlValues)
      .returning('*')
      .execute();
  }
+
+  private addNameFieldToFieldMetadataSeeds(
+    arrayOfMetadataFields: Pick<CreateFieldInput, 'name' | 'type' | 'label'>[],
+  ) {
+    arrayOfMetadataFields.unshift({
+      name: 'name',
+      type: FieldMetadataType.TEXT,
+      label: 'Name',
+    });
+  }
+
+  private turnCompositeSubFieldValueAsSQLValue(
+    fieldType: FieldMetadataType,
+    subFieldName: string,
+    subFieldValue: any,
+  ) {
+    if (!isCompositeFieldMetadataType(fieldType)) {
+      throw new Error(
+        `${subFieldName} is not a sub field of a composite field type.`,
+      );
+    }
+
+    const compositeFieldTypeDefinition =
+      compositeTypeDefinitions.get(fieldType);
+
+    const compositeSubFieldType =
+      compositeFieldTypeDefinition?.properties.find(
+        (property) => property.name === subFieldName,
+      )?.type ?? null;
+
+    if (!isDefined(compositeSubFieldType)) {
+      throw new Error(
+        `Cannot find ${subFieldName} in properties of composite type ${fieldType}.`,
+      );
+    }
+
+    return this.turnFieldValueAsSQLValue(compositeSubFieldType, subFieldValue);
+  }
+
+  private turnFieldValueAsSQLValue(
+    fieldType: FieldMetadataType,
+    fieldValue: any,
+  ) {
+    if (fieldType === FieldMetadataType.RAW_JSON) {
+      try {
+        return JSON.stringify(fieldValue);
+      } catch (error) {
+        throw new Error(
+          `Error while trying to turn field value as stringified JSON : ${error.message}`,
+        );
+      }
+    }
+
+    return fieldValue;
+  }
 }
--- a/packages/twenty-server/src/engine/utils/compute-table-name.util.ts
+++ b/packages/twenty-server/src/engine/utils/compute-table-name.util.ts
@ -1,5 +1,5 @@
 export const customNamePrefix = '_';

-export const computeTableName = (name: string, isCustom: boolean) => {
-  return isCustom ? `${customNamePrefix}${name}` : name;
+export const computeTableName = (nameSingular: string, isCustom: boolean) => {
+  return isCustom ? `${customNamePrefix}${nameSingular}` : nameSingular;
 };
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/seed-view-with-demo-data.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/seed-view-with-demo-data.ts
@ -1,8 +1,9 @@
 import { EntityManager } from 'typeorm';
 import { v4 } from 'uuid';

-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { companiesAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/companies-all.view';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
+import { seedCompaniesAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/companies-all.view';
 import { notesAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/notes-all.view';
 import { opportunitiesAllView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/opportunities-all.view';
 import { opportunitiesByStageView } from 'src/engine/workspace-manager/standard-objects-prefill-data/views/opportunity-by-stage.view';
@ -16,22 +17,22 @@ import { workflowsAllView } from 'src/engine/workspace-manager/standard-objects-
 export const seedViewWithDemoData = async (
  entityManager: EntityManager,
  schemaName: string,
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
  isWorkflowEnabled: boolean,
 ) => {
  const viewDefinitions = [
-    companiesAllView(objectMetadataMap),
-    peopleAllView(objectMetadataMap),
-    opportunitiesAllView(objectMetadataMap),
-    opportunitiesByStageView(objectMetadataMap),
-    notesAllView(objectMetadataMap),
-    tasksAllView(objectMetadataMap),
-    tasksByStatusView(objectMetadataMap),
+    seedCompaniesAllView(objectMetadataStandardIdToIdMap),
+    peopleAllView(objectMetadataStandardIdToIdMap),
+    opportunitiesAllView(objectMetadataStandardIdToIdMap),
+    opportunitiesByStageView(objectMetadataStandardIdToIdMap),
+    notesAllView(objectMetadataStandardIdToIdMap),
+    tasksAllView(objectMetadataStandardIdToIdMap),
+    tasksByStatusView(objectMetadataStandardIdToIdMap),
    ...(isWorkflowEnabled
      ? [
-          workflowsAllView(objectMetadataMap),
-          workflowVersionsAllView(objectMetadataMap),
-          workflowRunsAllView(objectMetadataMap),
+          workflowsAllView(objectMetadataStandardIdToIdMap),
+          workflowVersionsAllView(objectMetadataStandardIdToIdMap),
+          workflowRunsAllView(objectMetadataStandardIdToIdMap),
        ]
      : []),
  ];
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/companies-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/companies-all.view.ts
@ -1,16 +1,18 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  COMPANY_STANDARD_FIELD_IDS,
 } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

-export const companiesAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+export const seedCompaniesAllView = (
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.company].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -20,7 +22,7 @@ export const companiesAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.name
          ],
        position: 0,
@ -29,7 +31,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.domainName
          ],
        position: 1,
@ -38,7 +40,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.createdBy
          ],
        position: 2,
@ -47,7 +49,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.accountOwner
          ],
        position: 3,
@ -56,7 +58,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.createdAt
          ],
        position: 4,
@ -65,7 +67,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.employees
          ],
        position: 5,
@ -74,7 +76,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.linkedinLink
          ],
        position: 6,
@ -83,7 +85,7 @@ export const companiesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.company].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.company].fields[
            COMPANY_STANDARD_FIELD_IDS.address
          ],
        position: 7,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/notes-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/notes-all.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  NOTE_STANDARD_FIELD_IDS,
@ -6,11 +7,12 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const notesAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All Notes',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.note].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -20,7 +22,7 @@ export const notesAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.note].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].fields[
            NOTE_STANDARD_FIELD_IDS.title
          ],
        position: 0,
@ -29,7 +31,7 @@ export const notesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.note].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].fields[
            NOTE_STANDARD_FIELD_IDS.noteTargets
          ],
        position: 1,
@ -38,7 +40,7 @@ export const notesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.note].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].fields[
            NOTE_STANDARD_FIELD_IDS.body
          ],
        position: 2,
@ -47,7 +49,7 @@ export const notesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.note].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].fields[
            NOTE_STANDARD_FIELD_IDS.createdBy
          ],
        position: 3,
@ -56,7 +58,7 @@ export const notesAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.note].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.note].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.createdAt
          ],
        position: 4,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/opportunities-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/opportunities-all.view.ts
@ -1,13 +1,15 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import { OPPORTUNITY_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const opportunitiesAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -17,54 +19,48 @@ export const opportunitiesAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.name
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.name],
        position: 0,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.amount
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.amount],
        position: 1,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.createdBy
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.createdBy],
        position: 2,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.closeDate
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.closeDate],
        position: 3,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.company
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.company],
        position: 4,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.pointOfContact
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.pointOfContact],
        position: 5,
        isVisible: true,
        size: 150,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/opportunity-by-stage.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/opportunity-by-stage.view.ts
@ -1,73 +1,69 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import { OPPORTUNITY_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const opportunitiesByStageView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'By Stage',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity].id,
    type: 'kanban',
    key: null,
    position: 1,
    icon: 'IconLayoutKanban',
    kanbanFieldMetadataId:
-      objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity].fields[
        OPPORTUNITY_STANDARD_FIELD_IDS.stage
      ],
    filters: [],
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.name
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.name],
        position: 0,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.amount
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.amount],
        position: 1,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.createdBy
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.createdBy],
        position: 2,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.closeDate
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.closeDate],
        position: 3,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.company
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.company],
        position: 4,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.pointOfContact
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.pointOfContact],
        position: 5,
        isVisible: true,
        size: 150,
@ -76,45 +72,40 @@ export const opportunitiesByStageView = (
    groups: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.stage
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.stage],
        isVisible: true,
        fieldValue: 'NEW',
        position: 0,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.stage
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.stage],
        isVisible: true,
        fieldValue: 'SCREENING',
        position: 1,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.stage
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.stage],
        isVisible: true,
        fieldValue: 'MEETING',
        position: 2,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.stage
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.stage],
        isVisible: true,
        fieldValue: 'PROPOSAL',
        position: 3,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.opportunity].fields[
-            OPPORTUNITY_STANDARD_FIELD_IDS.stage
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.opportunity]
+            .fields[OPPORTUNITY_STANDARD_FIELD_IDS.stage],
        isVisible: true,
        fieldValue: 'CUSTOMER',
        position: 4,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/people-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/people-all.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  PERSON_STANDARD_FIELD_IDS,
@ -6,11 +7,12 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const peopleAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.person].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -20,7 +22,7 @@ export const peopleAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.name
          ],
        position: 0,
@ -29,7 +31,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.emails
          ],
        position: 1,
@ -38,7 +40,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.createdBy
          ],
        position: 2,
@ -47,7 +49,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.company
          ],
        position: 3,
@ -56,7 +58,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.phones
          ],
        position: 4,
@ -65,7 +67,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.createdAt
          ],
        position: 5,
@ -74,7 +76,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.city
          ],
        position: 6,
@ -83,7 +85,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.jobTitle
          ],
        position: 7,
@ -92,7 +94,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.linkedinLink
          ],
        position: 8,
@ -101,7 +103,7 @@ export const peopleAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.person].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.person].fields[
            PERSON_STANDARD_FIELD_IDS.xLink
          ],
        position: 9,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/tasks-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/tasks-all.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  TASK_STANDARD_FIELD_IDS,
@ -6,11 +7,12 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const tasksAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All Tasks',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.task].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -30,7 +32,7 @@ export const tasksAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.title
          ],
        position: 0,
@ -39,7 +41,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.status
          ],
        position: 2,
@ -48,7 +50,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.taskTargets
          ],
        position: 3,
@ -57,7 +59,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.createdBy
          ],
        position: 4,
@ -66,7 +68,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.dueAt
          ],
        position: 5,
@ -75,7 +77,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.assignee
          ],
        position: 6,
@ -84,7 +86,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.body
          ],
        position: 7,
@ -93,7 +95,7 @@ export const tasksAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.createdAt
          ],
        position: 8,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/tasks-by-status.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/tasks-by-status.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  TASK_STANDARD_FIELD_IDS,
@ -6,17 +7,18 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const tasksByStatusView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'By status',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.task].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].id,
    type: 'kanban',
    key: null,
    position: 0,
    icon: 'IconLayoutKanban',
    kanbanFieldMetadataId:
-      objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
        TASK_STANDARD_FIELD_IDS.status
      ],
    filters: [] /* [
@ -33,7 +35,7 @@ export const tasksByStatusView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.title
          ],
        position: 0,
@ -42,7 +44,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.status
          ],
        position: 2,
@ -51,7 +53,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.dueAt
          ],
        position: 3,
@ -60,7 +62,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.assignee
          ],
        position: 4,
@ -69,7 +71,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.createdAt
          ],
        position: 6,
@ -92,7 +94,7 @@ export const tasksByStatusView = (
    groups: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.status
          ],
        isVisible: true,
@ -101,7 +103,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.status
          ],
        isVisible: true,
@ -110,7 +112,7 @@ export const tasksByStatusView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.task].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.task].fields[
            TASK_STANDARD_FIELD_IDS.status
          ],
        isVisible: true,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-runs-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-runs-all.view.ts
@ -1,13 +1,15 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import { WORKFLOW_RUN_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const workflowRunsAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All Workflow Runs',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -17,54 +19,48 @@ export const workflowRunsAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.name
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.name],
        position: 0,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.workflow
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.workflow],
        position: 1,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.status
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.status],
        position: 2,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.startedAt
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.startedAt],
        position: 3,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.createdBy
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.createdBy],
        position: 4,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowRun].fields[
-            WORKFLOW_RUN_STANDARD_FIELD_IDS.workflowVersion
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowRun]
+            .fields[WORKFLOW_RUN_STANDARD_FIELD_IDS.workflowVersion],
        position: 5,
        isVisible: true,
        size: 150,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-versions-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflow-versions-all.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  WORKFLOW_VERSION_STANDARD_FIELD_IDS,
@ -6,11 +7,12 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const workflowVersionsAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All Workflow Versions',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -20,45 +22,40 @@ export const workflowVersionsAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].fields[
-            WORKFLOW_VERSION_STANDARD_FIELD_IDS.name
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion]
+            .fields[WORKFLOW_VERSION_STANDARD_FIELD_IDS.name],
        position: 0,
        isVisible: true,
        size: 210,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].fields[
-            WORKFLOW_VERSION_STANDARD_FIELD_IDS.workflow
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion]
+            .fields[WORKFLOW_VERSION_STANDARD_FIELD_IDS.workflow],
        position: 1,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].fields[
-            WORKFLOW_VERSION_STANDARD_FIELD_IDS.status
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion]
+            .fields[WORKFLOW_VERSION_STANDARD_FIELD_IDS.status],
        position: 2,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].fields[
-            BASE_OBJECT_STANDARD_FIELD_IDS.updatedAt
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion]
+            .fields[BASE_OBJECT_STANDARD_FIELD_IDS.updatedAt],
        position: 3,
        isVisible: true,
        size: 150,
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflowVersion].fields[
-            WORKFLOW_VERSION_STANDARD_FIELD_IDS.runs
-          ],
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflowVersion]
+            .fields[WORKFLOW_VERSION_STANDARD_FIELD_IDS.runs],
        position: 4,
        isVisible: true,
        size: 150,
--- a/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflows-all.view.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/standard-objects-prefill-data/views/workflows-all.view.ts
@ -1,4 +1,5 @@
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { ObjectMetadataStandardIdToIdMap } from 'src/engine/metadata-modules/object-metadata/interfaces/object-metadata-standard-id-to-id-map';
+
 import {
  BASE_OBJECT_STANDARD_FIELD_IDS,
  WORKFLOW_STANDARD_FIELD_IDS,
@ -6,11 +7,12 @@ import {
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';

 export const workflowsAllView = (
-  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+  objectMetadataStandardIdToIdMap: ObjectMetadataStandardIdToIdMap,
 ) => {
  return {
    name: 'All Workflows',
-    objectMetadataId: objectMetadataMap[STANDARD_OBJECT_IDS.workflow].id,
+    objectMetadataId:
+      objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].id,
    type: 'table',
    key: 'INDEX',
    position: 0,
@ -20,7 +22,7 @@ export const workflowsAllView = (
    fields: [
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            WORKFLOW_STANDARD_FIELD_IDS.name
          ],
        position: 0,
@ -29,7 +31,7 @@ export const workflowsAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            WORKFLOW_STANDARD_FIELD_IDS.statuses
          ],
        position: 1,
@ -38,7 +40,7 @@ export const workflowsAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            BASE_OBJECT_STANDARD_FIELD_IDS.updatedAt
          ],
        position: 2,
@ -47,7 +49,7 @@ export const workflowsAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            WORKFLOW_STANDARD_FIELD_IDS.createdBy
          ],
        position: 3,
@ -56,7 +58,7 @@ export const workflowsAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            WORKFLOW_STANDARD_FIELD_IDS.versions
          ],
        position: 4,
@ -65,7 +67,7 @@ export const workflowsAllView = (
      },
      {
        fieldMetadataId:
-          objectMetadataMap[STANDARD_OBJECT_IDS.workflow].fields[
+          objectMetadataStandardIdToIdMap[STANDARD_OBJECT_IDS.workflow].fields[
            WORKFLOW_STANDARD_FIELD_IDS.runs
          ],
        position: 5,