feat: emit metadata events for schema changes with actor context for webhooks (#17622)

## Summary

This PR adds **metadata eventing**: when schema metadata
(objectMetadata, fieldMetadata, view, viewField, etc.) is created,
updated, or deleted, we now emit events that can trigger webhooks and
future audit logs. It also adds **actor context** (`userId`,
`workspaceMemberId`) to those events so subscribers can attribute
changes to a user or API key.

## What changed

### 1. Metadata eventing (first commit)

- **MetadataEventEmitter**  
New service that emits batch events after successful workspace
migrations. Event names follow `metadata.{entity}.{action}` (e.g.
`metadata.objectMetadata.created`, `metadata.fieldMetadata.updated`).
- **MetadataEventsToDbListener**  
Listens for metadata events and enqueues webhook delivery via
`CallWebhookJobsForMetadataJob`.
- **Event types** (twenty-shared)  
`MetadataEventAction`, `MetadataEventBatch`, and record event types for
create/update/delete.
- **WorkspaceMigrationValidateBuildAndRunService**  
Calls the metadata event emitter after running migrations so all
metadata changes (from any module) emit events from a single place.
- **Create events**  
Sourced from the create action payload (`flatEntity` /
`flatFieldMetadatas`) because `fromToAllFlatEntityMaps` does not provide
a before/after diff for creates. Update/delete events still use the
fromToAllFlatEntityMaps comparison.

### 2. Actor context (second commit)

- **MetadataEventEmitter**  
Accepts optional `actorContext` (`userId`, `workspaceMemberId`) and
includes it on emitted batch events.
- **WorkspaceMigrationValidateBuildAndRunService**  
Passes `actorContext` from the request into the metadata event emitter.
- **Metadata resolvers & services**  
All metadata modules resolve `@AuthUser({ allowUndefined: true })` and
`@AuthUserWorkspaceId()` and pass `userId` and `workspaceMemberId`
through to the migration/event pipeline. Both are optional so
API-key–authenticated requests (no user) still emit events without a
user identity.
  
Shared some questions on Discord about the PR.

---------

Co-authored-by: Félix Malfait <felix.malfait@gmail.com>
Co-authored-by: prastoin <paul@twenty.com>

packages/twenty-server/src/engine/core-modules/core-engine.module.ts

@@ -63,6 +63,7 @@ import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
 import { RowLevelPermissionModule } from 'src/engine/metadata-modules/row-level-permission-predicate/row-level-permission.module';
 import { SubscriptionsModule } from 'src/engine/subscriptions/subscriptions.module';
 import { TrashCleanupModule } from 'src/engine/trash-cleanup/trash-cleanup.module';
+import { MetadataEventEmitterModule } from 'src/engine/metadata-event-emitter/metadata-event-emitter.module';
 import { WorkspaceEventEmitterModule } from 'src/engine/workspace-event-emitter/workspace-event-emitter.module';
 import { ChannelSyncModule } from 'src/modules/connected-account/channel-sync/channel-sync.module';
 import { DashboardModule } from 'src/modules/dashboard/dashboard.module';
@@ -104,6 +105,7 @@ import { FileModule } from './file/file.module';
     PostgresCredentialsModule,
     WorkflowApiModule,
     WorkspaceEventEmitterModule,
+    MetadataEventEmitterModule,
     ActorModule,
     TelemetryModule,
     AdminPanelModule,

packages/twenty-server/src/engine/metadata-event-emitter/listeners/metadata-events-to-db.listener.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+
+import { AllMetadataName } from 'twenty-shared/metadata';
+
+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 { type MetadataEventBatch } from 'src/engine/metadata-event-emitter/types/metadata-event-batch.type';
+import { CallWebhookJobsForMetadataJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs-for-metadata.job';
+import { AllMetadataEventType } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
+
+@Injectable()
+export class MetadataEventsToDbListener {
+  constructor(
+    @InjectMessageQueue(MessageQueue.webhookQueue)
+    private readonly webhookQueueService: MessageQueueService,
+  ) {}
+
+  @OnEvent('metadata.*.created')
+  async handleCreate(
+    metadataEventBatch: MetadataEventBatch<AllMetadataName, 'created'>,
+  ): Promise<void> {
+    return this.handleEvent(metadataEventBatch);
+  }
+
+  @OnEvent('metadata.*.updated')
+  async handleUpdate(
+    metadataEventBatch: MetadataEventBatch<AllMetadataName, 'updated'>,
+  ): Promise<void> {
+    return this.handleEvent(metadataEventBatch);
+  }
+
+  @OnEvent('metadata.*.deleted')
+  async handleDelete(
+    metadataEventBatch: MetadataEventBatch<AllMetadataName, 'deleted'>,
+  ): Promise<void> {
+    return this.handleEvent(metadataEventBatch);
+  }
+
+  private async handleEvent(
+    metadataEventBatch: MetadataEventBatch<
+      AllMetadataName,
+      AllMetadataEventType
+    >,
+  ): Promise<void> {
+    await this.webhookQueueService.add<
+      MetadataEventBatch<AllMetadataName, AllMetadataEventType>
+    >(CallWebhookJobsForMetadataJob.name, metadataEventBatch, {
+      retryLimit: 3,
+    });
+  }
+}

packages/twenty-server/src/engine/metadata-event-emitter/metadata-event-emitter.module.ts

@@ -0,0 +1,11 @@
+import { Global, Module } from '@nestjs/common';
+
+import { MetadataEventEmitter } from 'src/engine/metadata-event-emitter/metadata-event-emitter';
+import { MetadataEventsToDbListener } from 'src/engine/metadata-event-emitter/listeners/metadata-events-to-db.listener';
+
+@Global()
+@Module({
+  providers: [MetadataEventEmitter, MetadataEventsToDbListener],
+  exports: [MetadataEventEmitter],
+})
+export class MetadataEventEmitterModule {}

packages/twenty-server/src/engine/metadata-event-emitter/metadata-event-emitter.ts

@@ -0,0 +1,121 @@
+import { Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+import { AllMetadataName } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+
+import { getWorkspaceAuthContext } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { MetadataEventBatch } from 'src/engine/metadata-event-emitter/types/metadata-event-batch.type';
+import { computeMetadataEventName } from 'src/engine/metadata-event-emitter/utils/compute-metadata-event-name.util';
+import {
+  AllMetadataEventName,
+  AllMetadataEventType,
+  MetadataEvent,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
+
+type EmitMetadataEventsArgs = {
+  metadataEvents: MetadataEvent[];
+  workspaceId: string;
+  initiatorContext?: WorkspaceAuthContext;
+};
+
+@Injectable()
+export class MetadataEventEmitter {
+  constructor(private readonly eventEmitter: EventEmitter2) {}
+
+  public emitMetadataEvents({
+    metadataEvents,
+    workspaceId,
+    initiatorContext,
+  }: EmitMetadataEventsArgs): void {
+    if (metadataEvents.length === 0) {
+      return;
+    }
+
+    const resolvedInitiatorContext =
+      this.resolveInitiatorContext(initiatorContext);
+
+    const userId =
+      resolvedInitiatorContext?.type === 'user' ||
+      resolvedInitiatorContext?.type === 'pendingActivationUser'
+        ? resolvedInitiatorContext.user.id
+        : undefined;
+    const apiKeyId =
+      resolvedInitiatorContext?.type === 'apiKey'
+        ? resolvedInitiatorContext.apiKey.id
+        : undefined;
+
+    const grouped = this.groupByMetadataNameAndAction(metadataEvents);
+
+    for (const { eventName, events, metadataName, type } of grouped.values()) {
+      if (metadataEvents.length === 0) {
+        continue;
+      }
+
+      const metadataEventBatch: MetadataEventBatch = {
+        name: eventName,
+        workspaceId,
+        metadataName,
+        type,
+        events,
+        userId,
+        apiKeyId,
+      };
+
+      this.eventEmitter.emit(eventName, metadataEventBatch);
+    }
+  }
+
+  private resolveInitiatorContext(
+    initiatorContext?: WorkspaceAuthContext,
+  ): WorkspaceAuthContext | undefined {
+    if (isDefined(initiatorContext)) {
+      return initiatorContext;
+    }
+
+    try {
+      return getWorkspaceAuthContext();
+    } catch {
+      return undefined;
+    }
+  }
+
+  private groupByMetadataNameAndAction(metadataEvents: MetadataEvent[]) {
+    const grouped = new Map<
+      AllMetadataEventName,
+      {
+        metadataName: AllMetadataName;
+        type: AllMetadataEventType;
+        eventName: AllMetadataEventName;
+        events: MetadataEvent[];
+      }
+    >();
+
+    for (const metadataEvent of metadataEvents) {
+      const { metadataName, type } = metadataEvent;
+      const eventName = computeMetadataEventName({
+        metadataName,
+        type,
+      });
+      const occurence = grouped.get(eventName);
+
+      if (!isDefined(occurence)) {
+        grouped.set(eventName, {
+          eventName,
+          metadataName,
+          type,
+          events: [metadataEvent],
+        });
+        continue;
+      }
+
+      grouped.set(eventName, {
+        ...occurence,
+        events: [...occurence.events, metadataEvent],
+      });
+    }
+
+    return grouped;
+  }
+}

packages/twenty-server/src/engine/metadata-event-emitter/types/metadata-event-batch.type.ts

@@ -0,0 +1,19 @@
+import type { AllMetadataName } from 'twenty-shared/metadata';
+
+import {
+  type AllMetadataEventType,
+  type MetadataEvent,
+} from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
+
+export type MetadataEventBatch<
+  TMetadataName extends AllMetadataName = AllMetadataName,
+  TType extends AllMetadataEventType = AllMetadataEventType,
+> = {
+  name: `metadata.${TMetadataName}.${TType}`;
+  workspaceId: string;
+  metadataName: TMetadataName;
+  type: TType;
+  events: MetadataEvent[];
+  userId?: string;
+  apiKeyId?: string;
+};

packages/twenty-server/src/engine/metadata-event-emitter/utils/compute-metadata-event-name.util.ts

@@ -0,0 +1,7 @@
+import { type MetadataEvent } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
+
+export const computeMetadataEventName = ({
+  metadataName,
+  type,
+}: Pick<MetadataEvent, 'metadataName' | 'type'>) =>
+  `metadata.${metadataName}.${type}` as const;

packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.resolver.ts

@@ -1,8 +1,8 @@
 import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
 import { Args, Context, Mutation, Parent, ResolveField } from '@nestjs/graphql';
 
-import { isDefined } from 'twenty-shared/utils';
 import { PermissionFlagType } from 'twenty-shared/constants';
+import { isDefined } from 'twenty-shared/utils';
 
 import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
 import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';

packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs-for-metadata.job.ts

@@ -0,0 +1,99 @@
+import chunk from 'lodash.chunk';
+import { isDefined } from 'twenty-shared/utils';
+
+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
+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 { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+import { type MetadataEventBatch } from 'src/engine/metadata-event-emitter/types/metadata-event-batch.type';
+import { type FlatWebhook } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook.type';
+import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';
+import { type CallMetadataWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const WEBHOOK_JOBS_CHUNK_SIZE = 20;
+
+@Processor(MessageQueue.webhookQueue)
+export class CallWebhookJobsForMetadataJob {
+  constructor(
+    @InjectMessageQueue(MessageQueue.webhookQueue)
+    private readonly messageQueueService: MessageQueueService,
+    private readonly workspaceCacheService: WorkspaceCacheService,
+  ) {}
+
+  @Process(CallWebhookJobsForMetadataJob.name)
+  async handle(metadataEventBatch: MetadataEventBatch): Promise<void> {
+    const eventName = metadataEventBatch.name;
+    const metadataName = metadataEventBatch.metadataName;
+    const operation = metadataEventBatch.type;
+
+    const operationsToMatch = [
+      eventName,
+      `metadata.${metadataName}.*`,
+      `metadata.*.${operation}`,
+      `metadata.*.*`,
+      '*.*',
+    ];
+
+    const { flatWebhookMaps } = await this.workspaceCacheService.getOrRecompute(
+      metadataEventBatch.workspaceId,
+      ['flatWebhookMaps'],
+    );
+
+    const webhooks = Object.values(flatWebhookMaps.byUniversalIdentifier)
+      .filter(isDefined)
+      .filter((webhook) =>
+        operationsToMatch.some((operationToMatch) =>
+          webhook.operations.includes(operationToMatch),
+        ),
+      );
+
+    if (webhooks.length === 0) {
+      return;
+    }
+
+    const webhookEvents = this.transformMetadataEventBatchToWebhookEvents({
+      metadataEventBatch,
+      webhooks,
+    });
+
+    const webhookEventsChunks = chunk(webhookEvents, WEBHOOK_JOBS_CHUNK_SIZE);
+
+    for (const webhookEventsChunk of webhookEventsChunks) {
+      await this.messageQueueService.add<CallMetadataWebhookJobData[]>(
+        CallWebhookJob.name,
+        webhookEventsChunk,
+        { retryLimit: 3 },
+      );
+    }
+  }
+
+  private transformMetadataEventBatchToWebhookEvents({
+    metadataEventBatch,
+    webhooks,
+  }: {
+    metadataEventBatch: MetadataEventBatch;
+    webhooks: FlatWebhook[];
+  }): CallMetadataWebhookJobData[] {
+    const result: CallMetadataWebhookJobData[] = [];
+
+    for (const webhook of webhooks) {
+      for (const event of metadataEventBatch.events) {
+        result.push({
+          targetUrl: webhook.targetUrl,
+          eventName: metadataEventBatch.name,
+          workspaceId: metadataEventBatch.workspaceId,
+          webhookId: webhook.id,
+          eventDate: new Date(),
+          userId: metadataEventBatch.userId,
+          apiKeyId: metadataEventBatch.apiKeyId,
+          secret: webhook.secret,
+          event,
+        });
+      }
+    }
+
+    return result;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts

@@ -10,10 +10,8 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/proces
 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 { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
-import {
-  CallWebhookJob,
-  type CallWebhookJobData,
-} from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';
+import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';
+import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';
 import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';
 import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';

packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook.job.ts

@@ -10,21 +10,7 @@ import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queu
 import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
 import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
 import { SecureHttpClientService } from 'src/engine/core-modules/secure-http-client/secure-http-client.service';
-
-export type CallWebhookJobData = {
-  targetUrl: string;
-  eventName: string;
-  objectMetadata: { id: string; nameSingular: string };
-  workspaceId: string;
-  webhookId: string;
-  eventDate: Date;
-  userId?: string;
-  workspaceMemberId?: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  record: any;
-  updatedFields?: string[];
-  secret?: string;
-};
+import { type WebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';
 
 @Processor(MessageQueue.webhookQueue)
 export class CallWebhookJob {
@@ -35,7 +21,7 @@ export class CallWebhookJob {
   ) {}
 
   private generateSignature(
-    payload: CallWebhookJobData,
+    payload: Record<string, unknown>,
     secret: string,
     timestamp: string,
   ): string {
@@ -46,7 +32,7 @@ export class CallWebhookJob {
   }
 
   @Process(CallWebhookJob.name)
-  async handle(webhookJobEvents: CallWebhookJobData[]): Promise<void> {
+  async handle(webhookJobEvents: WebhookJobData[]): Promise<void> {
     await Promise.all(
       webhookJobEvents.map(
         async (webhookJobEvent) => await this.callWebhook(webhookJobEvent),
@@ -54,7 +40,7 @@ export class CallWebhookJob {
     );
   }
 
-  private async callWebhook(data: CallWebhookJobData): Promise<void> {
+  private async callWebhook(data: WebhookJobData): Promise<void> {
     const commonPayload = {
       url: data.targetUrl,
       webhookId: data.webhookId,

packages/twenty-server/src/engine/metadata-modules/webhook/jobs/webhook-job.module.ts

@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
 import { AuditModule } from 'src/engine/core-modules/audit/audit.module';
 import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';
 import { SecureHttpClientModule } from 'src/engine/core-modules/secure-http-client/secure-http-client.module';
+import { CallWebhookJobsForMetadataJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs-for-metadata.job';
 import { CallWebhookJobsJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job';
 import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';
 import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@@ -14,6 +15,10 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     SecureHttpClientModule,
     WorkspaceCacheModule,
   ],
-  providers: [CallWebhookJobsJob, CallWebhookJob],
+  providers: [
+    CallWebhookJobsJob,
+    CallWebhookJobsForMetadataJob,
+    CallWebhookJob,
+  ],
 })
 export class WebhookJobModule {}

packages/twenty-server/src/engine/metadata-modules/webhook/types/webhook-job-data.type.ts

@@ -0,0 +1,27 @@
+import { type MetadataEvent } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
+
+type WebhookJobBase = {
+  targetUrl: string;
+  eventName: string;
+  workspaceId: string;
+  webhookId: string;
+  eventDate: Date;
+  userId?: string;
+  apiKeyId?: string;
+  secret?: string;
+};
+
+export type CallWebhookJobData = WebhookJobBase & {
+  objectMetadata: { id: string; nameSingular: string };
+  workspaceMemberId?: string;
+  applicationId?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  record: any;
+  updatedFields?: string[];
+};
+
+export type CallMetadataWebhookJobData = WebhookJobBase & {
+  event: MetadataEvent;
+};
+
+export type WebhookJobData = CallWebhookJobData | CallMetadataWebhookJobData;

packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts

@@ -1,7 +1,7 @@
 import type { ObjectRecordEvent } from 'twenty-shared/database-events';
 
 import { type WebhookEntity } from 'src/engine/metadata-modules/webhook/entities/webhook.entity';
-import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';
+import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';
 import { transformEventToWebhookEvent } from 'src/engine/metadata-modules/webhook/utils/transform-event-to-webhook-event';
 import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
 

packages/twenty-server/src/engine/metadata-modules/webhook/webhook.service.ts

@@ -4,8 +4,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { isDefined } from 'twenty-shared/utils';
 import { IsNull, Repository } from 'typeorm';
 
-import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
 import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
 import { fromCreateWebhookInputToFlatWebhookToCreate } from 'src/engine/metadata-modules/flat-webhook/utils/from-create-webhook-input-to-flat-webhook-to-create.util';

packages/twenty-server/src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service.ts

@@ -7,6 +7,7 @@ import {
 import { isDefined } from 'twenty-shared/utils';
 
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
+import { MetadataEventEmitter } from 'src/engine/metadata-event-emitter/metadata-event-emitter';
 import { ALL_METADATA_REQUIRED_METADATA_FOR_VALIDATION } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-required-metadata-for-validation.constant';
 import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
 import { AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
@@ -53,6 +54,7 @@ export class WorkspaceMigrationValidateBuildAndRunService {
     private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
     private readonly workspaceMigrationBuildOrchestratorService: WorkspaceMigrationBuildOrchestratorService,
     private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly metadataEventEmitter: MetadataEventEmitter,
     twentyConfigService: TwentyConfigService,
   ) {
     const logLevels = twentyConfigService.get('LOG_LEVELS');
@@ -248,7 +250,13 @@ export class WorkspaceMigrationValidateBuildAndRunService {
         })
       : validateAndBuildResult.workspaceMigration;
 
-    await this.workspaceMigrationRunnerService.run(workspaceMigration);
+    const { metadataEvents } =
+      await this.workspaceMigrationRunnerService.run(workspaceMigration);
+
+    this.metadataEventEmitter.emitMetadataEvents({
+      metadataEvents,
+      workspaceId: args.workspaceId,
+    });
   }
 
   public async validateBuildAndRunWorkspaceMigration({

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/workspace-migration-action-common.ts

@@ -9,12 +9,14 @@ import {
 export type AllUniversalWorkspaceMigrationAction<
   TActionType extends
     WorkspaceMigrationActionType = WorkspaceMigrationActionType,
-> = MetadataUniversalWorkspaceMigrationAction<AllMetadataName, TActionType>;
+  TMetadataName extends AllMetadataName = AllMetadataName,
+> = MetadataUniversalWorkspaceMigrationAction<TMetadataName, TActionType>;
 
 export type AllFlatWorkspaceMigrationAction<
   TActionType extends
     WorkspaceMigrationActionType = WorkspaceMigrationActionType,
-> = MetadataFlatWorkspaceMigrationAction<AllMetadataName, TActionType>;
+  TMetadataName extends AllMetadataName = AllMetadataName,
+> = MetadataFlatWorkspaceMigrationAction<TMetadataName, TActionType>;
 
 export { WorkspaceMigrationActionType };
 

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface.ts

@@ -6,7 +6,6 @@ import { QueryRunner } from 'typeorm';
 import { LoggerService } from 'src/engine/core-modules/logger/logger.service';
 import { ALL_METADATA_ENTITY_BY_METADATA_NAME } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant';
 import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
-import { AllFlatEntityTypesByMetadataName } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-types-by-metadata-name';
 import { FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
 import { MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
 import { MetadataRelatedFlatEntityMapsKeys } from 'src/engine/metadata-modules/flat-entity/types/metadata-related-flat-entity-maps-keys.type';
@@ -61,9 +60,15 @@ export abstract class BaseWorkspaceMigrationRunnerActionHandlerService<
   TActionType extends WorkspaceMigrationActionType,
   TMetadataName extends AllMetadataName,
   TUniversalAction extends // TODO create abstracted type utils
-    AllUniversalWorkspaceMigrationAction = AllFlatEntityTypesByMetadataName[TMetadataName]['universalActions'][TActionType],
+    AllUniversalWorkspaceMigrationAction = AllUniversalWorkspaceMigrationAction<
+    TActionType,
+    TMetadataName
+  >,
   TFlatAction extends
-    AllFlatWorkspaceMigrationAction = AllFlatEntityTypesByMetadataName[TMetadataName]['flatActions'][TActionType],
+    AllFlatWorkspaceMigrationAction = AllFlatWorkspaceMigrationAction<
+    TActionType,
+    TMetadataName
+  >,
 > {
   public actionType: TActionType;
   public metadataName: TMetadataName;

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/services/workspace-migration-runner.service.ts

@@ -8,7 +8,6 @@ import { DataSource } from 'typeorm';
 import { LoggerService } from 'src/engine/core-modules/logger/logger.service';
 import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
 import { AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
-import { type MetadataEvent } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
 import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
 import { getMetadataRelatedMetadataNames } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-related-metadata-names.util';
 import { getMetadataSerializedRelationNames } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-serialized-relation-names.util';
@@ -22,6 +21,7 @@ import {
   WorkspaceMigrationRunnerExceptionCode,
 } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/exceptions/workspace-migration-runner.exception';
 import { WorkspaceMigrationRunnerActionHandlerRegistryService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/registry/workspace-migration-runner-action-handler-registry.service';
+import { type MetadataEvent } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
 
 @Injectable()
 export class WorkspaceMigrationRunnerService {

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event.ts

@@ -5,6 +5,7 @@ import { type MetadataUniversalFlatEntityPropertiesToCompare } from 'src/engine/
 
 type BaseMetadataEvent<T extends AllMetadataName, TPayload extends object> = {
   metadataName: T;
+  recordId: string;
   properties: TPayload;
 };
 
@@ -12,7 +13,7 @@ export type DeleteMetadataEvent<T extends AllMetadataName> = BaseMetadataEvent<
   T,
   { before: MetadataFlatEntity<T> }
 > & {
-  type: 'delete';
+  type: 'deleted';
 };
 
 export type UpdateMetadataEventDiff<
@@ -37,16 +38,21 @@ export type UpdateMetadataEvent<
     before: MetadataFlatEntity<T>;
     after: MetadataFlatEntity<T>;
   }
-> & { type: 'update' };
+> & { type: 'updated' };
 
 export type CreateMetadataEvent<T extends AllMetadataName> = BaseMetadataEvent<
   T,
   {
     after: MetadataFlatEntity<T>;
   }
-> & { type: 'create' };
+> & { type: 'created' };
 
 export type MetadataEvent<T extends AllMetadataName = AllMetadataName> =
   | DeleteMetadataEvent<T>
   | UpdateMetadataEvent<T>
   | CreateMetadataEvent<T>;
+
+export type AllMetadataEventType = MetadataEvent['type'];
+
+export type AllMetadataEventName =
+  `metadata.${AllMetadataName}.${MetadataEvent['type']}`;

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-create-action.util.ts

@@ -13,7 +13,8 @@ export const deriveMetadataEventsFromCreateAction = (
     case 'fieldMetadata': {
       return flatAction.flatFieldMetadatas.map(
         (flatFieldMetadata): CreateMetadataEvent<'fieldMetadata'> => ({
-          type: 'create',
+          type: 'created',
+          recordId: flatFieldMetadata.id,
           metadataName: 'fieldMetadata',
           properties: {
             after: flatFieldMetadata,
@@ -23,8 +24,9 @@ export const deriveMetadataEventsFromCreateAction = (
     }
     case 'objectMetadata': {
       const objectEvent: CreateMetadataEvent<'objectMetadata'> = {
-        type: 'create',
+        type: 'created',
         metadataName: 'objectMetadata',
+        recordId: flatAction.flatEntity.id,
         properties: {
           after: flatAction.flatEntity,
         },
@@ -32,7 +34,8 @@ export const deriveMetadataEventsFromCreateAction = (
 
       const fieldEvents: MetadataEvent[] = flatAction.flatFieldMetadatas.map(
         (flatFieldMetadata): CreateMetadataEvent<'fieldMetadata'> => ({
-          type: 'create',
+          type: 'created',
+          recordId: flatFieldMetadata.id,
           metadataName: 'fieldMetadata',
           properties: {
             after: flatFieldMetadata,
@@ -65,7 +68,8 @@ export const deriveMetadataEventsFromCreateAction = (
     case 'webhook': {
       return [
         {
-          type: 'create',
+          type: 'created',
+          recordId: flatAction.flatEntity.id,
           metadataName: flatAction.metadataName,
           properties: {
             after: flatAction.flatEntity,

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-delete-action.util.ts

@@ -52,8 +52,9 @@ export const deriveMetadataEventsFromDeleteAction = ({
 
       return [
         {
-          type: 'delete',
+          type: 'deleted',
           metadataName: flatAction.metadataName,
+          recordId: flatAction.entityId,
           properties: {
             before: flatEntityToDelete,
           },

packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/derive-metadata-events-from-update-action.util.ts

@@ -8,11 +8,11 @@ import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-e
 import { type MetadataUniversalFlatEntityPropertiesToCompare } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/metadata-universal-flat-entity-properties-to-compare.type';
 import { type AllFlatWorkspaceMigrationAction } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/types/workspace-migration-action-common';
 import {
-  type UpdateMetadataEventDiff,
   type CreateMetadataEvent,
   type DeleteMetadataEvent,
   type MetadataEvent,
   type UpdateMetadataEvent,
+  type UpdateMetadataEventDiff,
 } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/types/metadata-event';
 
 export type DeriveMetadataEventsFromUpdateActionArgs = {
@@ -42,8 +42,9 @@ const buildUpdateMetadataEvent = <TMetadataName extends AllMetadataName>({
   ) as UpdateMetadataEventDiff<TMetadataName, (typeof updatedFields)[number]>;
 
   return {
-    type: 'update',
+    type: 'updated',
     metadataName,
+    recordId: before.id,
     properties: {
       updatedFields,
       diff,
@@ -68,18 +69,20 @@ export const deriveMetadataEventsFromUpdateAction = ({
 
       const deleteIndexMetadataEvent: DeleteMetadataEvent<'index'> = {
         metadataName: 'index',
+        recordId: fromFlatEntity.id,
         properties: {
           before: fromFlatEntity,
         },
-        type: 'delete',
+        type: 'deleted',
       };
 
       const createIndexMetadataEvent: CreateMetadataEvent<'index'> = {
         metadataName: 'index',
+        recordId: toFlatEntity.id,
         properties: {
           after: toFlatEntity,
         },
-        type: 'create',
+        type: 'created',
       };
 
       return [deleteIndexMetadataEvent, createIndexMetadataEvent];