Add db event emitter in twenty orm (#13167)

## Context
Add an eventEmitter instance to twenty datasources so we can emit DB
events.
Add input and output formatting to twenty orm (formatData, formatResult)
Those 2 elements simplified existing logic when we interact with the
ORM, input will be formatted by the ORM so we can directly use
field-like structure instead of column-like. The output will be
formatted, for builder queries it will be in `result.generatedMaps`
where `result.raw` preserves the previous column-like structure.

Important change: We now have an authContext that we can pass when we
get a repository, this will be used for the different events emitted in
the ORM. We also removed the caching for repositories as it was not
scaling well and not necessary imho

Note: An upcoming PR should handle the onDelete: cascade behavior where
we send DESTROY events in cascade when there is an onDelete: CASCADE on
the FK.

---------

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

packages/twenty-server/src/modules/connected-account/query-hooks/connected-account-delete-one.pre-query.hook.ts

@@ -8,11 +8,11 @@ import { DeleteOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver
 import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
 import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
+import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
 import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
-import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 
 @WorkspaceQueryHook(`connectedAccount.destroyOne`)
 export class ConnectedAccountDeleteOnePreQueryHook
@@ -52,6 +52,7 @@ export class ConnectedAccountDeleteOnePreQueryHook
       },
     });
 
+    // TODO: handle cascade events for delete
     this.workspaceEventEmitter.emitDatabaseBatchEvent({
       objectMetadataNameSingular: 'messageChannel',
       action: DatabaseEventAction.DESTROYED,

packages/twenty-server/src/modules/connected-account/services/imap-smtp-caldav-apis.service.ts

@@ -1,18 +1,14 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { ConnectedAccountProvider } from 'twenty-shared/types';
 import { v4 } from 'uuid';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { EmailAccountConnectionParameters } from 'src/engine/core-modules/imap-smtp-caldav-connection/dtos/imap-smtp-caldav-connection.dto';
 import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   CalendarEventListFetchJob,
   CalendarEventListFetchJobData,
@@ -42,9 +38,6 @@ export class ImapSmtpCalDavAPIService {
     private readonly messageQueueService: MessageQueueService,
     @InjectMessageQueue(MessageQueue.calendarQueue)
     private readonly calendarQueueService: MessageQueueService,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: WorkspaceRepository<ObjectMetadataEntity>,
   ) {}
 
   async setupCompleteAccount(input: {
@@ -97,7 +90,6 @@ export class ImapSmtpCalDavAPIService {
       await this.upsertConnectedAccount(
         input,
         accountId,
-        existingAccount,
         connectedAccountRepository,
       );
 
@@ -116,7 +108,6 @@ export class ImapSmtpCalDavAPIService {
 
     await this.enqueueSyncJobs(
       input,
-      accountId,
       workspaceId,
       createdMessageChannel,
       createdCalendarChannel,
@@ -131,7 +122,6 @@ export class ImapSmtpCalDavAPIService {
       connectionParameters: EmailAccountConnectionParameters;
     },
     accountId: string,
-    existingAccount: ConnectedAccountWorkspaceEntity | null,
     connectedAccountRepository: WorkspaceRepository<ConnectedAccountWorkspaceEntity>,
   ) {
     const accountData = {
@@ -142,48 +132,7 @@ export class ImapSmtpCalDavAPIService {
       accountOwnerId: input.workspaceMemberId,
     };
 
-    const savedAccount = await connectedAccountRepository.save(accountData, {});
-
-    const connectedAccountMetadata =
-      await this.objectMetadataRepository.findOneOrFail({
-        where: {
-          nameSingular: 'connectedAccount',
-          workspaceId: input.workspaceId,
-        },
-      });
-
-    if (existingAccount) {
-      this.workspaceEventEmitter.emitDatabaseBatchEvent({
-        objectMetadataNameSingular: 'connectedAccount',
-        action: DatabaseEventAction.UPDATED,
-        events: [
-          {
-            recordId: savedAccount.id,
-            objectMetadata: connectedAccountMetadata,
-            properties: {
-              before: existingAccount,
-              after: savedAccount,
-            },
-          },
-        ],
-        workspaceId: input.workspaceId,
-      });
-    } else {
-      this.workspaceEventEmitter.emitDatabaseBatchEvent({
-        objectMetadataNameSingular: 'connectedAccount',
-        action: DatabaseEventAction.CREATED,
-        events: [
-          {
-            recordId: savedAccount.id,
-            objectMetadata: connectedAccountMetadata,
-            properties: {
-              after: savedAccount,
-            },
-          },
-        ],
-        workspaceId: input.workspaceId,
-      });
-    }
+    await connectedAccountRepository.save(accountData, {});
   }
 
   private async setupMessageChannels(
@@ -226,29 +175,6 @@ export class ImapSmtpCalDavAPIService {
       {},
     );
 
-    const messageChannelMetadata =
-      await this.objectMetadataRepository.findOneOrFail({
-        where: {
-          nameSingular: 'messageChannel',
-          workspaceId: input.workspaceId,
-        },
-      });
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'messageChannel',
-      action: DatabaseEventAction.CREATED,
-      events: [
-        {
-          recordId: newMessageChannel.id,
-          objectMetadata: messageChannelMetadata,
-          properties: {
-            after: newMessageChannel,
-          },
-        },
-      ],
-      workspaceId: input.workspaceId,
-    });
-
     return shouldEnableSync ? newMessageChannel : null;
   }
 
@@ -289,29 +215,6 @@ export class ImapSmtpCalDavAPIService {
         {},
       );
 
-      const calendarChannelMetadata =
-        await this.objectMetadataRepository.findOneOrFail({
-          where: {
-            nameSingular: 'calendarChannel',
-            workspaceId: input.workspaceId,
-          },
-        });
-
-      this.workspaceEventEmitter.emitDatabaseBatchEvent({
-        objectMetadataNameSingular: 'calendarChannel',
-        action: DatabaseEventAction.CREATED,
-        events: [
-          {
-            recordId: newCalendarChannel.id,
-            objectMetadata: calendarChannelMetadata,
-            properties: {
-              after: newCalendarChannel,
-            },
-          },
-        ],
-        workspaceId: input.workspaceId,
-      });
-
       return newCalendarChannel;
     }
 
@@ -322,7 +225,6 @@ export class ImapSmtpCalDavAPIService {
     input: {
       connectionParameters: EmailAccountConnectionParameters;
     },
-    accountId: string,
     workspaceId: string,
     messageChannel: MessageChannelWorkspaceEntity | null,
     calendarChannel: CalendarChannelWorkspaceEntity | null,

packages/twenty-server/src/modules/contact-creation-manager/services/__tests__/create-company.service.spec.ts

@@ -6,7 +6,6 @@ import { ConnectedAccountProvider } from 'twenty-shared/types';
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import {
   CompanyToCreate,
@@ -103,12 +102,6 @@ describe('CreateCompanyService', () => {
               .mockResolvedValue(mockCompanyRepository),
           },
         },
-        {
-          provide: WorkspaceEventEmitter,
-          useValue: {
-            emitDatabaseBatchEvent: jest.fn(),
-          },
-        },
         {
           provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
           useValue: {

packages/twenty-server/src/modules/contact-creation-manager/services/create-company-and-contact.service.ts

@@ -1,18 +1,13 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isNonEmptyString } from '@sniptt/guards';
 import chunk from 'lodash.chunk';
 import compact from 'lodash.compact';
-import { DeepPartial, Repository } from 'typeorm';
+import { DeepPartial } from 'typeorm';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
-import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { CONTACTS_CREATION_BATCH_SIZE } from 'src/modules/contact-creation-manager/constants/contacts-creation-batch-size.constant';
 import { CreateCompanyService } from 'src/modules/contact-creation-manager/services/create-company.service';
@@ -31,9 +26,6 @@ export class CreateCompanyAndContactService {
   constructor(
     private readonly createContactService: CreateContactService,
     private readonly createCompaniesService: CreateCompanyService,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     private readonly exceptionHandlerService: ExceptionHandlerService,
   ) {}
@@ -85,14 +77,10 @@ export class CreateCompanyAndContactService {
       emails: uniqueHandles,
     });
 
-    const rawAlreadyCreatedContacts = await queryBuilder
+    const alreadyCreatedContacts = await queryBuilder
       .orderBy('person.createdAt', 'ASC')
       .getMany();
 
-    const alreadyCreatedContacts = await personRepository.formatResult(
-      rawAlreadyCreatedContacts,
-    );
-
     const alreadyCreatedContactEmails: string[] =
       alreadyCreatedContacts?.reduce<string[]>((acc, { emails }) => {
         const currentContactEmails: string[] = [];
@@ -190,19 +178,6 @@ export class CreateCompanyAndContactService {
       CONTACTS_CREATION_BATCH_SIZE,
     );
 
-    // TODO: Remove this when events are emitted directly inside TwentyORM
-
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        standardId: STANDARD_OBJECT_IDS.person,
-        workspaceId,
-      },
-    });
-
-    if (!objectMetadata) {
-      throw new Error('Object metadata not found');
-    }
-
     // In some jobs the accountOwner is not populated
     if (!connectedAccount.accountOwner) {
       const workspaceMemberRepository =
@@ -228,26 +203,12 @@ export class CreateCompanyAndContactService {
 
     for (const contactsBatch of contactsBatches) {
       try {
-        const createdPeople = await this.createCompaniesAndPeople(
+        await this.createCompaniesAndPeople(
           connectedAccount,
           contactsBatch,
           workspaceId,
           source,
         );
-
-        this.workspaceEventEmitter.emitDatabaseBatchEvent({
-          objectMetadataNameSingular: 'person',
-          action: DatabaseEventAction.CREATED,
-          events: createdPeople.map((createdPerson) => ({
-            // Fix ' as string': TypeORM typing issue... id is always returned when using save
-            recordId: createdPerson.id as string,
-            objectMetadata,
-            properties: {
-              after: createdPerson,
-            },
-          })),
-          workspaceId,
-        });
       } catch (error) {
         this.exceptionHandlerService.captureExceptions([error], {
           workspace: {

packages/twenty-server/src/modules/contact-creation-manager/services/create-company.service.ts

@@ -1,20 +1,15 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import axios, { AxiosInstance } from 'axios';
 import uniqBy from 'lodash.uniqby';
 import { TWENTY_COMPANIES_BASE_URL } from 'twenty-shared/constants';
 import { ConnectedAccountProvider } from 'twenty-shared/types';
 import { lowercaseUrlOriginAndRemoveTrailingSlash } from 'twenty-shared/utils';
-import { DeepPartial, ILike, Repository } from 'typeorm';
+import { DeepPartial, ILike } from 'typeorm';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
-import { STANDARD_OBJECT_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-object-ids';
 import { CompanyWorkspaceEntity } from 'src/modules/company/standard-objects/company.workspace-entity';
 import { extractDomainFromLink } from 'src/modules/contact-creation-manager/utils/extract-domain-from-link.util';
 import { getCompanyNameFromDomainName } from 'src/modules/contact-creation-manager/utils/get-company-name-from-domain-name.util';
@@ -34,12 +29,7 @@ export type CompanyToCreate = {
 export class CreateCompanyService {
   private readonly httpService: AxiosInstance;
 
-  constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-  ) {
+  constructor(private readonly twentyORMGlobalManager: TwentyORMGlobalManager) {
     this.httpService = axios.create({
       baseURL: TWENTY_COMPANIES_BASE_URL,
     });
@@ -55,17 +45,6 @@ export class CreateCompanyService {
       return {};
     }
 
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        standardId: STANDARD_OBJECT_IDS.company,
-        workspaceId,
-      },
-    });
-
-    if (!objectMetadata) {
-      throw new Error('Object metadata not found');
-    }
-
     const companyRepository =
       await this.twentyORMGlobalManager.getRepositoryForWorkspace(
         workspaceId,
@@ -124,19 +103,6 @@ export class CreateCompanyService {
     // Create new companies
     const createdCompanies = await companyRepository.save(newCompaniesData);
 
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'company',
-      action: DatabaseEventAction.CREATED,
-      events: createdCompanies.map((createdCompany) => ({
-        recordId: createdCompany.id,
-        objectMetadata,
-        properties: {
-          after: createdCompany,
-        },
-      })),
-      workspaceId,
-    });
-
     const createdCompanyIdsMap = this.createCompanyMap(createdCompanies);
 
     return {

packages/twenty-server/src/modules/match-participant/match-participant.service.spec.ts

@@ -20,18 +20,15 @@ describe('MatchParticipantService', () => {
     find: jest.Mock;
     update: jest.Mock;
     createQueryBuilder: jest.Mock;
-    formatResult: jest.Mock;
   };
   let mockCalendarEventParticipantRepository: {
     find: jest.Mock;
     update: jest.Mock;
     createQueryBuilder: jest.Mock;
-    formatResult: jest.Mock;
   };
   let mockPersonRepository: {
     find: jest.Mock;
     createQueryBuilder: jest.Mock;
-    formatResult: jest.Mock;
   };
   let mockWorkspaceMemberRepository: {
     find: jest.Mock;
@@ -53,7 +50,6 @@ describe('MatchParticipantService', () => {
         getMany: jest.fn(),
         withDeleted: jest.fn().mockReturnThis(),
       }),
-      formatResult: jest.fn(),
     };
 
     mockCalendarEventParticipantRepository = {
@@ -68,7 +64,6 @@ describe('MatchParticipantService', () => {
         getMany: jest.fn(),
         withDeleted: jest.fn().mockReturnThis(),
       }),
-      formatResult: jest.fn(),
     };
 
     mockPersonRepository = {
@@ -82,7 +77,6 @@ describe('MatchParticipantService', () => {
         getMany: jest.fn(),
         withDeleted: jest.fn().mockReturnThis(),
       }),
-      formatResult: jest.fn(),
     };
 
     mockWorkspaceMemberRepository = {
@@ -204,7 +198,7 @@ describe('MatchParticipantService', () => {
       };
 
       mockPersonRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
-      mockPersonRepository.formatResult.mockResolvedValue(mockPeople);
+      mockQueryBuilder.getMany.mockResolvedValue(mockPeople);
       mockWorkspaceMemberRepository.find.mockResolvedValue(
         mockWorkspaceMembers,
       );
@@ -316,7 +310,18 @@ describe('MatchParticipantService', () => {
     });
 
     it('should handle participants with no matching people or workspace members', async () => {
-      mockPersonRepository.formatResult.mockResolvedValue([]);
+      const mockQueryBuilder = {
+        select: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        andWhere: jest.fn().mockReturnThis(),
+        orWhere: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis(),
+        getMany: jest.fn().mockResolvedValue([]),
+        withDeleted: jest.fn().mockReturnThis(),
+      };
+
+      mockPersonRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+      mockQueryBuilder.getMany.mockResolvedValue([]);
       mockWorkspaceMemberRepository.find.mockResolvedValue([]);
 
       await service.matchParticipants({
@@ -545,7 +550,18 @@ describe('MatchParticipantService', () => {
         affected: 1,
       });
       mockMessageParticipantRepository.find.mockResolvedValue([]);
-      mockPersonRepository.formatResult.mockResolvedValue([]);
+      const mockQueryBuilder = {
+        select: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        andWhere: jest.fn().mockReturnThis(),
+        orWhere: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis(),
+        getMany: jest.fn().mockResolvedValue([]),
+        withDeleted: jest.fn().mockReturnThis(),
+      };
+
+      mockPersonRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+      mockQueryBuilder.getMany.mockResolvedValue([]);
     });
 
     describe('person unmatching', () => {
@@ -590,9 +606,7 @@ describe('MatchParticipantService', () => {
         mockPersonRepository.createQueryBuilder.mockReturnValue(
           mockQueryBuilder,
         );
-        mockPersonRepository.formatResult.mockResolvedValue(
-          mockAlternativePeople,
-        );
+        mockQueryBuilder.getMany.mockResolvedValue(mockAlternativePeople);
 
         const rematchedParticipants = [
           {
@@ -655,7 +669,7 @@ describe('MatchParticipantService', () => {
         mockPersonRepository.createQueryBuilder.mockReturnValue(
           mockQueryBuilder,
         );
-        mockPersonRepository.formatResult.mockResolvedValue([]);
+        mockQueryBuilder.getMany.mockResolvedValue([]);
 
         await service.unmatchParticipants({
           handle: 'test-1@example.com',

packages/twenty-server/src/modules/match-participant/match-participant.service.ts

@@ -82,12 +82,10 @@ export class MatchParticipantService<
       emails: uniqueParticipantsHandles,
     });
 
-    const rawPeople = await queryBuilder
+    const people = await queryBuilder
       .orderBy('person.createdAt', 'ASC')
       .getMany();
 
-    const people = await personRepository.formatResult(rawPeople);
-
     const workspaceMemberRepository =
       await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
         workspaceId,
@@ -192,12 +190,10 @@ export class MatchParticipantService<
         excludePersonIds: [personId],
       });
 
-      const rawPeople = await queryBuilder
+      const peopleToMatch = await queryBuilder
         .orderBy('person.createdAt', 'ASC')
         .getMany();
 
-      const peopleToMatch = await personRepository.formatResult(rawPeople);
-
       if (peopleToMatch.length > 0) {
         const bestMatch = findPersonByPrimaryOrAdditionalEmail({
           people: peopleToMatch,

packages/twenty-server/src/modules/messaging/message-import-manager/drivers/imap/services/imap-handle-error.service.ts

@@ -1,9 +1,6 @@
 import { Injectable, Logger } from '@nestjs/common';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   MessageChannelSyncStatus,
   MessageChannelWorkspaceEntity,
@@ -18,7 +15,6 @@ export class ImapHandleErrorService {
 
   constructor(
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
   ) {}
 
   async handleError(
@@ -38,42 +34,12 @@ export class ImapHandleErrorService {
           'messageChannel',
         );
 
-      const messageChannel = await messageChannelRepository.findOneOrFail({
-        where: { id: messageChannelId },
-      });
-
       await messageChannelRepository.update(
         { id: messageChannelId },
         {
           syncStatus: MessageChannelSyncStatus.FAILED_UNKNOWN,
         },
       );
-
-      const dataSource =
-        await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-          workspaceId,
-        });
-      const messageChannelMetadata = await dataSource
-        .getRepository(ObjectMetadataEntity)
-        .findOneOrFail({
-          where: { nameSingular: 'messageChannel', workspaceId },
-        });
-
-      this.workspaceEventEmitter.emitDatabaseBatchEvent({
-        objectMetadataNameSingular: 'messageChannel',
-        action: DatabaseEventAction.UPDATED,
-        events: [
-          {
-            recordId: messageChannelId,
-            objectMetadata: messageChannelMetadata,
-            properties: {
-              before: { syncStatus: messageChannel.syncStatus },
-              after: { syncStatus: MessageChannelSyncStatus.FAILED_UNKNOWN },
-            },
-          },
-        ],
-        workspaceId,
-      });
     } catch (handleErrorError) {
       this.logger.error(
         `Error handling IMAP error: ${handleErrorError.message}`,

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service.spec.ts

@@ -7,7 +7,6 @@ import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-q
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { CreateCompanyAndContactJob } from 'src/modules/contact-creation-manager/jobs/create-company-and-contact.job';
 import { MessageDirection } from 'src/modules/messaging/common/enums/message-direction.enum';
@@ -104,12 +103,6 @@ describe('MessagingSaveMessagesAndEnqueueContactCreationService', () => {
             add: jest.fn().mockResolvedValue(undefined),
           },
         },
-        {
-          provide: WorkspaceEventEmitter,
-          useValue: {
-            emitDatabaseBatchEvent: jest.fn().mockResolvedValue(undefined),
-          },
-        },
         {
           provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
           useValue: {

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service.ts

@@ -1,17 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { Repository } from 'typeorm';
-
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import {
   CreateCompanyAndContactJob,
@@ -39,9 +33,6 @@ export class MessagingSaveMessagesAndEnqueueContactCreationService {
     private readonly messageService: MessagingMessageService,
     private readonly messageParticipantService: MessagingMessageParticipantService,
     private readonly twentyORMManager: TwentyORMManager,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
   ) {}
 
   async saveMessagesAndEnqueueContactCreation(
@@ -122,27 +113,7 @@ export class MessagingSaveMessagesAndEnqueueContactCreationService {
         },
       );
 
-    const { participantsWithMessageId, createdMessages } =
-      createdMessagesWithParticipants;
-
-    const messageMetadata = await this.objectMetadataRepository.findOneOrFail({
-      where: { nameSingular: 'message', workspaceId },
-    });
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'message',
-      action: DatabaseEventAction.CREATED,
-      events: createdMessages.map((message) => {
-        return {
-          recordId: message.id ?? '',
-          objectMetadata: messageMetadata,
-          properties: {
-            after: message,
-          },
-        };
-      }),
-      workspaceId,
-    });
+    const { participantsWithMessageId } = createdMessagesWithParticipants;
 
     if (messageChannel.isContactAutoCreationEnabled) {
       const contactsToCreate = participantsWithMessageId.filter(

packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-many.post-query.hook.ts

@@ -1,23 +1,16 @@
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { Repository } from 'typeorm';
-
 import { WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
 import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
 import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
 import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   WorkflowVersionStatus,
   WorkflowVersionWorkspaceEntity,
 } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
 import { WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
-import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 
 @WorkspaceQueryHook({
   key: `workflow.createMany`,
@@ -28,9 +21,6 @@ export class WorkflowCreateManyPostQueryHook
 {
   constructor(
     private readonly twentyORMManager: TwentyORMManager,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     private readonly recordPositionService: RecordPositionService,
   ) {}
 
@@ -71,28 +61,5 @@ export class WorkflowCreateManyPostQueryHook
         return workflowVersionRepository.save(workflowVersion);
       }),
     );
-
-    const objectMetadata = await this.objectMetadataRepository.findOneOrFail({
-      where: {
-        nameSingular: 'workflowVersion',
-        workspaceId: workspace.id,
-      },
-    });
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'workflowVersion',
-      action: DatabaseEventAction.CREATED,
-      events: workflowVersionsToCreate.map((workflowVersionToCreate) => {
-        return {
-          userId: authContext.user?.id,
-          recordId: workflowVersionToCreate.id,
-          objectMetadata,
-          properties: {
-            after: workflowVersionToCreate,
-          },
-        };
-      }),
-      workspaceId: workspace.id,
-    });
   }
 }

packages/twenty-server/src/modules/workflow/common/query-hooks/workflow-create-one.post-query.hook.ts

@@ -1,23 +1,16 @@
-import { InjectRepository } from '@nestjs/typeorm';
-
-import { Repository } from 'typeorm';
-
 import { WorkspacePostQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
 import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type';
 import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
 import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   WorkflowVersionStatus,
   WorkflowVersionWorkspaceEntity,
 } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
 import { WorkflowWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
-import { workspaceValidator } from 'src/engine/core-modules/workspace/workspace.validate';
 
 @WorkspaceQueryHook({
   key: `workflow.createOne`,
@@ -28,9 +21,6 @@ export class WorkflowCreateOnePostQueryHook
 {
   constructor(
     private readonly twentyORMManager: TwentyORMManager,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     private readonly recordPositionService: RecordPositionService,
   ) {}
 
@@ -59,7 +49,7 @@ export class WorkflowCreateOnePostQueryHook
       workspaceId: workspace.id,
     });
 
-    const workflowVersionToCreate = await workflowVersionRepository.create({
+    const workflowVersionToCreate = workflowVersionRepository.create({
       workflowId: workflow.id,
       status: WorkflowVersionStatus.DRAFT,
       name: 'v1',
@@ -67,28 +57,5 @@ export class WorkflowCreateOnePostQueryHook
     });
 
     await workflowVersionRepository.save(workflowVersionToCreate);
-
-    const objectMetadata = await this.objectMetadataRepository.findOneOrFail({
-      where: {
-        nameSingular: 'workflowVersion',
-        workspaceId: workspace.id,
-      },
-    });
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'workflowVersion',
-      action: DatabaseEventAction.CREATED,
-      events: [
-        {
-          userId: authContext.user?.id,
-          recordId: workflowVersionToCreate.id,
-          objectMetadata,
-          properties: {
-            after: workflowVersionToCreate,
-          },
-        },
-      ],
-      workspaceId: workspace.id,
-    });
   }
 }

packages/twenty-server/src/modules/workflow/workflow-builder/workflow-version/workflow-version.workspace-service.ts

@@ -1,14 +1,9 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   WorkflowVersionStepException,
   WorkflowVersionStepExceptionCode,
@@ -28,9 +23,6 @@ export class WorkflowVersionWorkspaceService {
   constructor(
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     private readonly workflowVersionStepWorkspaceService: WorkflowVersionStepWorkspaceService,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
     private readonly recordPositionService: RecordPositionService,
   ) {}
 
@@ -96,11 +88,6 @@ export class WorkflowVersionWorkspaceService {
         status: WorkflowVersionStatus.DRAFT,
         position,
       });
-
-      await this.emitWorkflowVersionCreationEvent({
-        workflowVersion: draftWorkflowVersion,
-        workspaceId,
-      });
     }
 
     assertWorkflowVersionIsDraft(draftWorkflowVersion);
@@ -125,41 +112,4 @@ export class WorkflowVersionWorkspaceService {
 
     return draftWorkflowVersion.id;
   }
-
-  private async emitWorkflowVersionCreationEvent({
-    workflowVersion,
-    workspaceId,
-  }: {
-    workflowVersion: WorkflowVersionWorkspaceEntity;
-    workspaceId: string;
-  }) {
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        nameSingular: 'workflowVersion',
-        workspaceId,
-      },
-    });
-
-    if (!objectMetadata) {
-      throw new WorkflowVersionStepException(
-        'Object metadata not found',
-        WorkflowVersionStepExceptionCode.FAILURE,
-      );
-    }
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'workflowVersion',
-      action: DatabaseEventAction.CREATED,
-      events: [
-        {
-          recordId: workflowVersion.id,
-          objectMetadata,
-          properties: {
-            after: workflowVersion,
-          },
-        },
-      ],
-      workspaceId,
-    });
-  }
 }

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/create-record.workflow-action.ts

@@ -6,14 +6,12 @@ import { Repository } from 'typeorm';
 
 import { WorkflowAction } from 'src/modules/workflow/workflow-executor/interfaces/workflow-action.interface';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
 import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
 import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import {
   WorkflowStepExecutorException,
@@ -35,7 +33,6 @@ export class CreateRecordWorkflowAction implements WorkflowAction {
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     @InjectRepository(ObjectMetadataEntity, 'core')
     private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
     private readonly recordPositionService: RecordPositionService,
     private readonly recordInputTransformerService: RecordInputTransformerService,
@@ -130,21 +127,6 @@ export class CreateRecordWorkflowAction implements WorkflowAction {
       },
     });
 
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: workflowActionInput.objectName,
-      action: DatabaseEventAction.CREATED,
-      events: [
-        {
-          recordId: objectRecord.id,
-          objectMetadata,
-          properties: {
-            after: objectRecord,
-          },
-        },
-      ],
-      workspaceId,
-    });
-
     return {
       result: objectRecord,
     };

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/delete-record.workflow-action.ts

@@ -1,17 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { isDefined } from 'class-validator';
 import { isValidUuid } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
 import { WorkflowAction } from 'src/modules/workflow/workflow-executor/interfaces/workflow-action.interface';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   WorkflowStepExecutorException,
   WorkflowStepExecutorExceptionCode,
@@ -30,9 +25,6 @@ import { WorkflowDeleteRecordActionInput } from 'src/modules/workflow/workflow-e
 export class DeleteRecordWorkflowAction implements WorkflowAction {
   constructor(
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
   ) {}
 
@@ -88,19 +80,6 @@ export class DeleteRecordWorkflowAction implements WorkflowAction {
         { shouldBypassPermissionChecks: true },
       );
 
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        nameSingular: workflowActionInput.objectName,
-      },
-    });
-
-    if (!objectMetadata) {
-      throw new RecordCRUDActionException(
-        'Failed to delete: Object metadata not found',
-        RecordCRUDActionExceptionCode.INVALID_REQUEST,
-      );
-    }
-
     const objectRecord = await repository.findOne({
       where: {
         id: workflowActionInput.objectRecordId,
@@ -116,21 +95,6 @@ export class DeleteRecordWorkflowAction implements WorkflowAction {
 
     await repository.softDelete(workflowActionInput.objectRecordId);
 
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: workflowActionInput.objectName,
-      action: DatabaseEventAction.DELETED,
-      events: [
-        {
-          recordId: objectRecord.id,
-          objectMetadata,
-          properties: {
-            before: objectRecord,
-          },
-        },
-      ],
-      workspaceId,
-    });
-
     return {
       result: objectRecord,
     };

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/find-records.workflow-action.ts

@@ -17,7 +17,6 @@ import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-met
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import {
   WorkflowStepExecutorException,
@@ -147,15 +146,9 @@ export class FindRecordsWorkflowAction implements WorkflowAction {
       false,
     );
 
-    const nonFormattedObjectRecords = await withOrderByQueryBuilder
+    return withOrderByQueryBuilder
       .take(workflowActionInput.limit ?? QUERY_MAX_RECORDS)
       .getMany();
-
-    return formatResult<T[]>(
-      nonFormattedObjectRecords,
-      objectMetadataItemWithFieldsMaps,
-      objectMetadataMaps,
-    );
   }
 
   private async getTotalCount(

packages/twenty-server/src/modules/workflow/workflow-executor/workflow-actions/record-crud/update-record.workflow-action.ts

@@ -1,20 +1,13 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import deepEqual from 'deep-equal';
 import { isDefined, isValidUuid } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
 import { WorkflowAction } from 'src/modules/workflow/workflow-executor/interfaces/workflow-action.interface';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
-import { objectRecordChangedValues } from 'src/engine/core-modules/event-emitter/utils/object-record-changed-values';
 import { RecordInputTransformerService } from 'src/engine/core-modules/record-transformer/services/record-input-transformer.service';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import {
   WorkflowStepExecutorException,
@@ -35,9 +28,6 @@ export class UpdateRecordWorkflowAction implements WorkflowAction {
   constructor(
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
     private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
     private readonly recordInputTransformerService: RecordInputTransformerService,
   ) {}
@@ -95,20 +85,6 @@ export class UpdateRecordWorkflowAction implements WorkflowAction {
         { shouldBypassPermissionChecks: true },
       );
 
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        nameSingular: workflowActionInput.objectName,
-      },
-      relations: ['fields'],
-    });
-
-    if (!objectMetadata) {
-      throw new RecordCRUDActionException(
-        'Failed to update: Object metadata not found',
-        RecordCRUDActionExceptionCode.INVALID_REQUEST,
-      );
-    }
-
     const previousObjectRecord = await repository.findOne({
       where: {
         id: workflowActionInput.objectRecordId,
@@ -153,11 +129,6 @@ export class UpdateRecordWorkflowAction implements WorkflowAction {
         objectMetadataMapItem: objectMetadataItemWithFieldsMaps,
       });
 
-    const objectRecordFormatted = formatData(
-      transformedObjectRecord,
-      objectMetadataItemWithFieldsMaps,
-    );
-
     const updatedObjectRecord = {
       ...previousObjectRecord,
       ...objectRecordWithFilteredFields,
@@ -165,32 +136,7 @@ export class UpdateRecordWorkflowAction implements WorkflowAction {
 
     if (!deepEqual(updatedObjectRecord, previousObjectRecord)) {
       await repository.update(workflowActionInput.objectRecordId, {
-        ...objectRecordFormatted,
-      });
-
-      const diff = objectRecordChangedValues(
-        previousObjectRecord,
-        updatedObjectRecord,
-        workflowActionInput.fieldsToUpdate,
-        objectMetadata,
-      );
-
-      this.workspaceEventEmitter.emitDatabaseBatchEvent({
-        objectMetadataNameSingular: workflowActionInput.objectName,
-        action: DatabaseEventAction.UPDATED,
-        events: [
-          {
-            recordId: previousObjectRecord.id,
-            objectMetadata,
-            properties: {
-              before: previousObjectRecord,
-              after: updatedObjectRecord,
-              updatedFields: workflowActionInput.fieldsToUpdate,
-              diff,
-            },
-          },
-        ],
-        workspaceId,
+        ...transformedObjectRecord,
       });
     }
 

packages/twenty-server/src/modules/workflow/workflow-runner/workflow-run/workflow-run.workspace-service.ts

@@ -1,36 +1,30 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
-import { Repository } from 'typeorm';
-import { v4 } from 'uuid';
 import { isDefined } from 'twenty-shared/utils';
-import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
 import { StepStatus } from 'twenty-shared/workflow';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { v4 } from 'uuid';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
-import { objectRecordChangedValues } from 'src/engine/core-modules/event-emitter/utils/object-record-changed-values';
+import { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';
 import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
 import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
 import { RecordPositionService } from 'src/engine/core-modules/record-position/services/record-position.service';
 import { ActorMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   StepOutput,
   WorkflowRunState,
   WorkflowRunStatus,
   WorkflowRunWorkspaceEntity,
 } from 'src/modules/workflow/common/standard-objects/workflow-run.workspace-entity';
+import { WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
 import { WorkflowCommonWorkspaceService } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';
 import { WorkflowAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
 import {
   WorkflowRunException,
   WorkflowRunExceptionCode,
 } from 'src/modules/workflow/workflow-runner/exceptions/workflow-run.exception';
-import { WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
-import { WithLock } from 'src/engine/core-modules/cache-lock/with-lock.decorator';
 
 @Injectable()
 export class WorkflowRunWorkspaceService {
@@ -38,9 +32,6 @@ export class WorkflowRunWorkspaceService {
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
     private readonly scopedWorkspaceContextFactory: ScopedWorkspaceContextFactory,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
     private readonly recordPositionService: RecordPositionService,
     private readonly metricsService: MetricsService,
   ) {}
@@ -413,76 +404,6 @@ export class WorkflowRunWorkspaceService {
     return workflowRun;
   }
 
-  private async emitWorkflowRunUpdatedEvent({
-    workflowRunBefore,
-    updatedFields,
-  }: {
-    workflowRunBefore: WorkflowRunWorkspaceEntity;
-    updatedFields: string[];
-  }) {
-    const workspaceId = this.scopedWorkspaceContextFactory.create().workspaceId;
-
-    if (!workspaceId) {
-      return;
-    }
-
-    const objectMetadata = await this.objectMetadataRepository.findOne({
-      where: {
-        nameSingular: 'workflowRun',
-        workspaceId,
-      },
-      relations: ['fields'],
-    });
-
-    if (!objectMetadata) {
-      throw new WorkflowRunException(
-        'Object metadata not found',
-        WorkflowRunExceptionCode.FAILURE,
-      );
-    }
-
-    const workflowRunRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
-        workspaceId,
-        'workflowRun',
-        { shouldBypassPermissionChecks: true },
-      );
-
-    const workflowRunAfter = await workflowRunRepository.findOneBy({
-      id: workflowRunBefore.id,
-    });
-
-    if (!workflowRunAfter) {
-      throw new WorkflowRunException(
-        'WorkflowRun not found',
-        WorkflowRunExceptionCode.FAILURE,
-      );
-    }
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'workflowRun',
-      action: DatabaseEventAction.UPDATED,
-      events: [
-        {
-          recordId: workflowRunBefore.id,
-          objectMetadata,
-          properties: {
-            after: workflowRunAfter,
-            before: workflowRunBefore,
-            updatedFields,
-            diff: objectRecordChangedValues(
-              workflowRunBefore,
-              workflowRunAfter,
-              updatedFields,
-              objectMetadata,
-            ),
-          },
-        },
-      ],
-      workspaceId,
-    });
-  }
-
   private getInitState(
     workflowVersion: WorkflowVersionWorkspaceEntity,
   ): WorkflowRunState | undefined {
@@ -538,14 +459,5 @@ export class WorkflowRunWorkspaceService {
     }
 
     await workflowRunRepository.update(workflowRunToUpdate.id, partialUpdate);
-
-    const updatedFields = Object.keys(partialUpdate);
-
-    if (updatedFields.length > 0) {
-      await this.emitWorkflowRunUpdatedEvent({
-        workflowRunBefore: workflowRunToUpdate,
-        updatedFields: updatedFields,
-      });
-    }
   }
 }

packages/twenty-server/src/modules/workflow/workflow-status/jobs/__tests__/workflow-statuses-update.job.spec.ts

@@ -5,7 +5,6 @@ import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadat
 import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import { WorkflowVersionStatus } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
 import { WorkflowStatus } from 'src/modules/workflow/common/standard-objects/workflow.workspace-entity';
 import {
@@ -54,10 +53,6 @@ describe('WorkflowStatusesUpdate', () => {
     findOneOrFail: jest.fn(),
   };
 
-  const mockWorkspaceEventEmitter = {
-    emitDatabaseBatchEvent: jest.fn(),
-  };
-
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
@@ -70,10 +65,6 @@ describe('WorkflowStatusesUpdate', () => {
           provide: ServerlessFunctionService,
           useValue: mockServerlessFunctionService,
         },
-        {
-          provide: WorkspaceEventEmitter,
-          useValue: mockWorkspaceEventEmitter,
-        },
         {
           provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
           useValue: {
@@ -125,9 +116,6 @@ describe('WorkflowStatusesUpdate', () => {
 
         expect(mockWorkflowRepository.findOneOrFail).toHaveBeenCalledTimes(1);
         expect(mockWorkflowRepository.update).toHaveBeenCalledTimes(0);
-        expect(
-          mockWorkspaceEventEmitter.emitDatabaseBatchEvent,
-        ).toHaveBeenCalledTimes(0);
       });
 
       it('when no draft yet, update statuses', async () => {
@@ -155,9 +143,6 @@ describe('WorkflowStatusesUpdate', () => {
           { id: '1' },
           { statuses: [WorkflowStatus.DRAFT, WorkflowStatus.ACTIVE] },
         );
-        expect(
-          mockWorkspaceEventEmitter.emitDatabaseBatchEvent,
-        ).toHaveBeenCalledTimes(1);
       });
     });
 
@@ -202,9 +187,6 @@ describe('WorkflowStatusesUpdate', () => {
           mockWorkflowVersionRepository.findOneOrFail,
         ).toHaveBeenCalledTimes(1);
         expect(mockWorkflowRepository.update).toHaveBeenCalledTimes(0);
-        expect(
-          mockWorkspaceEventEmitter.emitDatabaseBatchEvent,
-        ).toHaveBeenCalledTimes(0);
       });
 
       test('when WorkflowVersionStatus.DRAFT to WorkflowVersionStatus.ACTIVE, should activate and publish serverless functions', async () => {
@@ -286,9 +268,6 @@ describe('WorkflowStatusesUpdate', () => {
           { id: '1' },
           { statuses: [WorkflowStatus.ACTIVE] },
         );
-        expect(
-          mockWorkspaceEventEmitter.emitDatabaseBatchEvent,
-        ).toHaveBeenCalledTimes(1);
       });
     });
 
@@ -338,9 +317,6 @@ describe('WorkflowStatusesUpdate', () => {
           { id: '1' },
           { statuses: [] },
         );
-        expect(
-          mockWorkspaceEventEmitter.emitDatabaseBatchEvent,
-        ).toHaveBeenCalledTimes(1);
       });
     });
   });

packages/twenty-server/src/modules/workflow/workflow-status/jobs/workflow-statuses-update.job.ts

@@ -1,20 +1,15 @@
 import { Logger, Scope } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import isEqual from 'lodash.isequal';
 import { isDefined } from 'twenty-shared/utils';
-import { In, Repository } from 'typeorm';
+import { In } from 'typeorm';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
 import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
-import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
 import {
   WorkflowVersionStatus,
   WorkflowVersionWorkspaceEntity,
@@ -72,22 +67,10 @@ export class WorkflowStatusesUpdateJob {
   constructor(
     private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
     private readonly serverlessFunctionService: ServerlessFunctionService,
-    private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    protected readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
-    @InjectRepository(ServerlessFunctionEntity, 'core')
-    private readonly serverlessFunctionRepository: Repository<ServerlessFunctionEntity>,
   ) {}
 
   @Process(WorkflowStatusesUpdateJob.name)
   async handle(event: WorkflowVersionBatchEvent): Promise<void> {
-    const workflowObjectMetadata =
-      await this.objectMetadataRepository.findOneOrFail({
-        where: {
-          nameSingular: 'workflow',
-        },
-      });
-
     switch (event.type) {
       case WorkflowVersionEventType.CREATE:
       case WorkflowVersionEventType.DELETE:
@@ -95,7 +78,6 @@ export class WorkflowStatusesUpdateJob {
           event.workflowIds.map((workflowId) =>
             this.handleWorkflowVersionCreatedOrDeleted({
               workflowId,
-              workflowObjectMetadata,
               workspaceId: event.workspaceId,
             }),
           ),
@@ -106,7 +88,6 @@ export class WorkflowStatusesUpdateJob {
           event.statusUpdates.map((statusUpdate) =>
             this.handleWorkflowVersionStatusUpdated({
               statusUpdate,
-              workflowObjectMetadata,
               workspaceId: event.workspaceId,
             }),
           ),
@@ -119,11 +100,9 @@ export class WorkflowStatusesUpdateJob {
 
   private async handleWorkflowVersionCreatedOrDeleted({
     workflowId,
-    workflowObjectMetadata,
     workspaceId,
   }: {
     workflowId: string;
-    workflowObjectMetadata: ObjectMetadataEntity;
     workspaceId: string;
   }): Promise<void> {
     const workflowRepository =
@@ -163,13 +142,6 @@ export class WorkflowStatusesUpdateJob {
         statuses: newWorkflowStatuses,
       },
     );
-
-    this.emitWorkflowStatusUpdatedEvent({
-      currentWorkflow: previousWorkflow,
-      workflowObjectMetadata,
-      newWorkflowStatuses,
-      workspaceId,
-    });
   }
 
   private async handlePublishServerlessFunction({
@@ -222,11 +194,9 @@ export class WorkflowStatusesUpdateJob {
 
   private async handleWorkflowVersionStatusUpdated({
     statusUpdate,
-    workflowObjectMetadata,
     workspaceId,
   }: {
     statusUpdate: WorkflowVersionStatusUpdate;
-    workflowObjectMetadata: ObjectMetadataEntity;
     workspaceId: string;
   }): Promise<void> {
     const workflowRepository =
@@ -277,51 +247,6 @@ export class WorkflowStatusesUpdateJob {
         statuses: newWorkflowStatuses,
       },
     );
-
-    this.emitWorkflowStatusUpdatedEvent({
-      currentWorkflow: workflow,
-      workflowObjectMetadata,
-      newWorkflowStatuses,
-      workspaceId,
-    });
-  }
-
-  private emitWorkflowStatusUpdatedEvent({
-    currentWorkflow,
-    workflowObjectMetadata,
-    newWorkflowStatuses,
-    workspaceId,
-  }: {
-    currentWorkflow: WorkflowWorkspaceEntity;
-    workflowObjectMetadata: ObjectMetadataEntity;
-    newWorkflowStatuses: WorkflowStatus[];
-    workspaceId: string;
-  }) {
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: workflowObjectMetadata.nameSingular,
-      action: DatabaseEventAction.UPDATED,
-      events: [
-        {
-          recordId: currentWorkflow.id,
-          objectMetadata: workflowObjectMetadata,
-          properties: {
-            before: currentWorkflow,
-            after: {
-              ...currentWorkflow,
-              statuses: newWorkflowStatuses,
-            },
-            updatedFields: ['statuses'],
-            diff: {
-              statuses: {
-                before: currentWorkflow.statuses,
-                after: newWorkflowStatuses,
-              },
-            },
-          },
-        },
-      ],
-      workspaceId,
-    });
   }
 
   private async getWorkflowStatuses({

packages/twenty-server/src/modules/workflow/workflow-trigger/workspace-services/workflow-trigger.workspace-service.ts

@@ -1,12 +1,8 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
 import { t } from '@lingui/core/macro';
-import { Repository } from 'typeorm';
 
-import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
 import { ActorMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
-import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
 import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
 import { ScopedWorkspaceContextFactory } from 'src/engine/twenty-orm/factories/scoped-workspace-context.factory';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
@@ -43,8 +39,6 @@ export class WorkflowTriggerWorkspaceService {
     private readonly workflowRunnerWorkspaceService: WorkflowRunnerWorkspaceService,
     private readonly automatedTriggerWorkspaceService: AutomatedTriggerWorkspaceService,
     private readonly workspaceEventEmitter: WorkspaceEventEmitter,
-    @InjectRepository(ObjectMetadataEntity, 'core')
-    private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
   ) {}
 
   private getWorkspaceId() {
@@ -412,33 +406,6 @@ export class WorkflowTriggerWorkspaceService {
     newStatus: WorkflowVersionStatus,
     workspaceId: string,
   ) {
-    const objectMetadata = await this.objectMetadataRepository.findOneOrFail({
-      where: {
-        nameSingular: 'workflowVersion',
-        workspaceId,
-      },
-    });
-
-    this.workspaceEventEmitter.emitDatabaseBatchEvent({
-      objectMetadataNameSingular: 'workflowVersion',
-      action: DatabaseEventAction.UPDATED,
-      events: [
-        {
-          recordId: workflowVersion.id,
-          objectMetadata,
-          properties: {
-            before: workflowVersion,
-            after: { ...workflowVersion, status: newStatus },
-            updatedFields: ['status'],
-            diff: {
-              status: { before: workflowVersion.status, after: newStatus },
-            },
-          },
-        },
-      ],
-      workspaceId,
-    });
-
     this.workspaceEventEmitter.emitCustomBatchEvent<WorkflowVersionStatusUpdate>(
       WORKFLOW_VERSION_STATUS_UPDATED,
       [