feat: Add seed people and companies data for demo environment (#2207) (#2307)

* feat: seed companies and people data

* init DataSeedDemoWorkspaceCommand to handle:
- seedCoreSchema()
- seedMetadataSchema()

* feature: Seed workspace with demo data

- delete workspace
- initDemo() with prefillWorkspaceWithDemoObjects()

* added companies-demo.ts with data
* added people-demo.ts with data

* added workspaceId to seedFeatureFlags()

* delete previous CoreSchema before seedCoreSchema

* added workspaceMemberPrefillData

* getDemoWorkspaces() to get DEMO_WORKSPACES from config

* defined DemoSeedUserIds

- created core/demo/ to keep modified seedCoreSchema() there
- DemoSeedUserIds with new set of users and Ids

* generateOpportunities() to seed demo opportunities (limit = 50)

* Code review and fixes

* Fix

---------

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

server/src/workspace/workspace-manager/demo-objects-prefill-data/company.ts

@@ -0,0 +1,23 @@
+import { EntityManager } from 'typeorm';
+
+import { companiesDemo } from './companies-demo';
+
+export const companyPrefillData = async (
+  entityManager: EntityManager,
+  schemaName: string,
+) => {
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.company`, [
+      'name',
+      'domainName',
+      'address',
+      'employees',
+      'linkedinLinkUrl',
+    ])
+    .orIgnore()
+    .values(companiesDemo)
+    .returning('*')
+    .execute();
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/demo-objects-prefill-data.ts

@@ -0,0 +1,40 @@
+import { DataSource, EntityManager } from 'typeorm';
+
+import { ObjectMetadataEntity } from 'src/metadata/object-metadata/object-metadata.entity';
+import { viewPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/view';
+import { companyPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/company';
+import { personPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/person';
+import { pipelineStepPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/pipeline-step';
+import { workspaceMemberPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/workspace-member';
+import { seedDemoOpportunity } from 'src/workspace/workspace-manager/demo-objects-prefill-data/opportunity';
+
+export const demoObjectsPrefillData = async (
+  workspaceDataSource: DataSource,
+  schemaName: string,
+  objectMetadata: ObjectMetadataEntity[],
+) => {
+  const objectMetadataMap = objectMetadata.reduce((acc, object) => {
+    acc[object.nameSingular] = {
+      id: object.id,
+      fields: object.fields.reduce((acc, field) => {
+        acc[field.name] = field.id;
+        return acc;
+      }, {}),
+    };
+    return acc;
+  }, {});
+
+  // TODO: udnerstand why only with this createQueryRunner transaction below works
+  const queryRunner = workspaceDataSource.createQueryRunner();
+  await queryRunner.connect();
+
+  workspaceDataSource.transaction(async (entityManager: EntityManager) => {
+    await companyPrefillData(entityManager, schemaName);
+    await personPrefillData(entityManager, schemaName);
+    await viewPrefillData(entityManager, schemaName, objectMetadataMap);
+    await pipelineStepPrefillData(entityManager, schemaName);
+    await seedDemoOpportunity(entityManager, schemaName);
+
+    await workspaceMemberPrefillData(entityManager, schemaName);
+  });
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/opportunity.ts

@@ -0,0 +1,76 @@
+import { EntityManager } from 'typeorm';
+import { v4 } from 'uuid';
+
+const tableName = 'opportunity';
+
+const getRandomProbability = () => {
+  const firstDigit = Math.floor(Math.random() * 9) + 1;
+  return firstDigit / 10;
+};
+
+const getRandomPipelineStepId = (pipelineStepIds: { id: string }[]) =>
+  pipelineStepIds[Math.floor(Math.random() * pipelineStepIds.length)].id;
+
+const generateRandomAmountMicros = () => {
+  const firstDigit = Math.floor(Math.random() * 9) + 1;
+  return firstDigit * 10000000000;
+};
+
+// Function to generate the array of opportunities
+// companiesWithPeople - selecting from the db companies and 1 person related to the company.id to use companyId, pointOfContactId and personId
+// pipelineStepIds - selecting from the db pipeline, getting random id from selected to use as pipelineStepId
+
+const generateOpportunities = (
+  companies,
+  pipelineStepIds: { id: string }[],
+) => {
+  return companies.map((company) => ({
+    id: v4(),
+    amountAmountMicros: generateRandomAmountMicros(),
+    amountCurrencyCode: 'USD',
+    closeDate: new Date(),
+    probability: getRandomProbability(),
+    pipelineStepId: getRandomPipelineStepId(pipelineStepIds),
+    pointOfContactId: company.personId,
+    personId: company.personId,
+    companyId: company.id,
+  }));
+};
+
+export const seedDemoOpportunity = async (
+  entityManager: EntityManager,
+  schemaName: string,
+) => {
+  const companiesWithPeople = await entityManager?.query(
+    `SELECT company.*, person.id AS "personId"
+     FROM ${schemaName}.company
+     LEFT JOIN ${schemaName}.person ON company.id = "person"."companyId"
+     LIMIT 50`,
+  );
+  const pipelineStepIds = await entityManager?.query(
+    `SELECT id FROM ${schemaName}."pipelineStep"`,
+  );
+
+  const opportunities = generateOpportunities(
+    companiesWithPeople,
+    pipelineStepIds,
+  );
+
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.${tableName}`, [
+      'id',
+      'amountAmountMicros',
+      'amountCurrencyCode',
+      'closeDate',
+      'probability',
+      'pipelineStepId',
+      'pointOfContactId',
+      'personId',
+      'companyId',
+    ])
+    .orIgnore()
+    .values(opportunities)
+    .execute();
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/person.ts

@@ -0,0 +1,42 @@
+import { EntityManager } from 'typeorm';
+
+import { peopleDemo } from './people-demo';
+
+export const personPrefillData = async (
+  entityManager: EntityManager,
+  schemaName: string,
+) => {
+  const companies = await entityManager?.query(
+    `SELECT * FROM ${schemaName}.company`,
+  );
+
+  // Iterate through the array and add a UUID for each person
+  const people = peopleDemo.map((person, index) => ({
+    nameFirstName: person.firstName,
+    nameLastName: person.lastName,
+    email: person.email,
+    linkedinLinkUrl: person.linkedinUrl,
+    jobTitle: person.jobTitle,
+    city: person.city,
+    avatarUrl: person.avatarUrl,
+    companyId: companies[Math.floor(index / 2)].id,
+  }));
+
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.person`, [
+      'nameFirstName',
+      'nameLastName',
+      'city',
+      'email',
+      'avatarUrl',
+      'linkedinLinkUrl',
+      'jobTitle',
+      'companyId',
+    ])
+    .orIgnore()
+    .values(people)
+    .returning('*')
+    .execute();
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/pipeline-step.ts

@@ -0,0 +1,41 @@
+import { EntityManager } from 'typeorm';
+
+export const pipelineStepPrefillData = async (
+  entityManager: EntityManager,
+  schemaName: string,
+) => {
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.pipelineStep`, ['name', 'color', 'position'])
+    .orIgnore()
+    .values([
+      {
+        name: 'New',
+        color: 'red',
+        position: 0,
+      },
+      {
+        name: 'Screening',
+        color: 'purple',
+        position: 1,
+      },
+      {
+        name: 'Meeting',
+        color: 'sky',
+        position: 2,
+      },
+      {
+        name: 'Proposal',
+        color: 'turquoise',
+        position: 3,
+      },
+      {
+        name: 'Customer',
+        color: 'yellow',
+        position: 4,
+      },
+    ])
+    .returning('*')
+    .execute();
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/view.ts

@@ -0,0 +1,200 @@
+import { EntityManager } from 'typeorm';
+
+import { ObjectMetadataEntity } from 'src/metadata/object-metadata/object-metadata.entity';
+
+export const viewPrefillData = async (
+  entityManager: EntityManager,
+  schemaName: string,
+  objectMetadataMap: Record<string, ObjectMetadataEntity>,
+) => {
+  // Creating views
+  const createdViews = await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.view`, ['name', 'objectMetadataId', 'type'])
+    .orIgnore()
+    .values([
+      {
+        name: 'All Companies',
+        objectMetadataId: objectMetadataMap['company'].id,
+        type: 'table',
+      },
+      {
+        name: 'All People',
+        objectMetadataId: objectMetadataMap['person'].id,
+        type: 'table',
+      },
+      {
+        name: 'All Opportunities',
+        objectMetadataId: objectMetadataMap['opportunity'].id,
+        type: 'kanban',
+      },
+    ])
+    .returning('*')
+    .execute();
+
+  const viewIdMap = createdViews.raw.reduce((acc, view) => {
+    acc[view.name] = view.id;
+    return acc;
+  }, {});
+
+  // Creating viewFields
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.viewField`, [
+      'fieldMetadataId',
+      'viewId',
+      'position',
+      'isVisible',
+      'size',
+    ])
+    .orIgnore()
+    .values([
+      // Company
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['name'],
+        viewId: viewIdMap['All Companies'],
+        position: 0,
+        isVisible: true,
+        size: 180,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['domainName'],
+        viewId: viewIdMap['All Companies'],
+        position: 1,
+        isVisible: true,
+        size: 100,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['accountOwner'],
+        viewId: viewIdMap['All Companies'],
+        position: 2,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['createdAt'],
+        viewId: viewIdMap['All Companies'],
+        position: 3,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['employees'],
+        viewId: viewIdMap['All Companies'],
+        position: 4,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['linkedinLink'],
+        viewId: viewIdMap['All Companies'],
+        position: 5,
+        isVisible: true,
+        size: 170,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['company'].fields['address'],
+        viewId: viewIdMap['All Companies'],
+        position: 6,
+        isVisible: true,
+        size: 170,
+      },
+      // Person
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['name'],
+        viewId: viewIdMap['All People'],
+        position: 0,
+        isVisible: true,
+        size: 210,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['email'],
+        viewId: viewIdMap['All People'],
+        position: 1,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['company'],
+        viewId: viewIdMap['All People'],
+        position: 2,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['phone'],
+        viewId: viewIdMap['All People'],
+        position: 3,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['createdAt'],
+        viewId: viewIdMap['All People'],
+        position: 4,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['city'],
+        viewId: viewIdMap['All People'],
+        position: 5,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['jobTitle'],
+        viewId: viewIdMap['All People'],
+        position: 6,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['linkedinLink'],
+        viewId: viewIdMap['All People'],
+        position: 7,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['person'].fields['xLink'],
+        viewId: viewIdMap['All People'],
+        position: 8,
+        isVisible: true,
+        size: 150,
+      },
+      // Opportunity
+      {
+        fieldMetadataId: objectMetadataMap['opportunity'].fields['amount'],
+        viewId: viewIdMap['All Opportunities'],
+        position: 0,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['opportunity'].fields['closeDate'],
+        viewId: viewIdMap['All Opportunities'],
+        position: 1,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId: objectMetadataMap['opportunity'].fields['probability'],
+        viewId: viewIdMap['All Opportunities'],
+        position: 2,
+        isVisible: true,
+        size: 150,
+      },
+      {
+        fieldMetadataId:
+          objectMetadataMap['opportunity'].fields['pointOfContact'],
+        viewId: viewIdMap['All Opportunities'],
+        position: 3,
+        isVisible: true,
+        size: 150,
+      },
+    ])
+    .execute();
+};

server/src/workspace/workspace-manager/demo-objects-prefill-data/workspace-member.ts

@@ -0,0 +1,54 @@
+import { EntityManager } from 'typeorm';
+
+import { DemoSeedUserIds } from 'src/database/typeorm-seeds/core/demo/users';
+
+const WorkspaceMemberIds = {
+  Noah: '20202020-0687-4c41-b707-ed1bfca972a7',
+  Hugo: '20202020-77d5-4cb6-b60a-f4a835a85d61',
+  Julia: '20202020-1553-45c6-a028-5a9064cce07f',
+};
+
+export const workspaceMemberPrefillData = async (
+  entityManager: EntityManager,
+  schemaName: string,
+) => {
+  await entityManager
+    .createQueryBuilder()
+    .insert()
+    .into(`${schemaName}.workspaceMember`, [
+      'id',
+      'nameFirstName',
+      'nameLastName',
+      'locale',
+      'colorScheme',
+      'userId',
+    ])
+    .orIgnore()
+    .values([
+      {
+        id: WorkspaceMemberIds.Noah,
+        nameFirstName: 'Noah',
+        nameLastName: 'A',
+        locale: 'en',
+        colorScheme: 'Light',
+        userId: DemoSeedUserIds.Noah,
+      },
+      {
+        id: WorkspaceMemberIds.Hugo,
+        nameFirstName: 'Hugo',
+        nameLastName: 'I',
+        locale: 'en',
+        colorScheme: 'Light',
+        userId: DemoSeedUserIds.Hugo,
+      },
+      {
+        id: WorkspaceMemberIds.Julia,
+        nameFirstName: 'Julia',
+        nameLastName: 'S',
+        locale: 'en',
+        colorScheme: 'Light',
+        userId: DemoSeedUserIds.Julia,
+      },
+    ])
+    .execute();
+};

server/src/workspace/workspace-manager/workspace-manager.service.ts

@@ -6,6 +6,7 @@ import { ObjectMetadataService } from 'src/metadata/object-metadata/object-metad
 import { WorkspaceMigrationRunnerService } from 'src/workspace/workspace-migration-runner/workspace-migration-runner.service';
 import { WorkspaceMigrationService } from 'src/metadata/workspace-migration/workspace-migration.service';
 import { standardObjectsPrefillData } from 'src/workspace/workspace-manager/standard-objects-prefill-data/standard-objects-prefill-data';
+import { demoObjectsPrefillData } from 'src/workspace/workspace-manager/demo-objects-prefill-data/demo-objects-prefill-data';
 import { WorkspaceDataSourceService } from 'src/workspace/workspace-datasource/workspace-datasource.service';
 import { DataSourceEntity } from 'src/metadata/data-source/data-source.entity';
 import { RelationMetadataService } from 'src/metadata/relation-metadata/relation-metadata.service';
@@ -71,6 +72,44 @@ export class WorkspaceManagerService {
     );
   }
 
+  /**
+   * InitDemo a workspace by creating a new data source and running all migrations
+   * @param workspaceId
+   * @returns Promise<void>
+   */
+  public async initDemo(workspaceId: string): Promise<void> {
+    const schemaName =
+      await this.workspaceDataSourceService.createWorkspaceDBSchema(
+        workspaceId,
+      );
+
+    const dataSourceMetadata =
+      await this.dataSourceService.createDataSourceMetadata(
+        workspaceId,
+        schemaName,
+      );
+
+    await this.setWorkspaceMaxRow(workspaceId, schemaName);
+
+    await this.workspaceMigrationService.insertStandardMigrations(workspaceId);
+
+    await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
+      workspaceId,
+    );
+
+    const createdObjectMetadata =
+      await this.createStandardObjectsAndFieldsMetadata(
+        dataSourceMetadata.id,
+        workspaceId,
+      );
+
+    await this.prefillWorkspaceWithDemoObjects(
+      dataSourceMetadata,
+      workspaceId,
+      createdObjectMetadata,
+    );
+  }
+
   /**
    *
    * Create all standard objects and fields metadata for a given workspace
@@ -256,8 +295,34 @@ export class WorkspaceManagerService {
     if (!workspaceDataSource) {
       throw new Error('Could not connect to workspace data source');
     }
+    await standardObjectsPrefillData(
+      workspaceDataSource,
+      dataSourceMetadata.schema,
+      createdObjectMetadata,
+    );
+  }
+  /**
+   *
+   * We are prefilling a few demo objects with data to make it easier for the user to get started.
+   *
+   * @param dataSourceMetadata
+   * @param workspaceId
+   */
+  private async prefillWorkspaceWithDemoObjects(
+    dataSourceMetadata: DataSourceEntity,
+    workspaceId: string,
+    createdObjectMetadata: ObjectMetadataEntity[],
+  ) {
+    const workspaceDataSource =
+      await this.workspaceDataSourceService.connectToWorkspaceDataSource(
+        workspaceId,
+      );
 
-    standardObjectsPrefillData(
+    if (!workspaceDataSource) {
+      throw new Error('Could not connect to workspace data source');
+    }
+
+    await demoObjectsPrefillData(
       workspaceDataSource,
       dataSourceMetadata.schema,
       createdObjectMetadata,