6071 return only updated fields of records in zapier update trigger (#8193)

- move webhook triggers into `entity-events-to-db.listener.ts` - refactor event management - add a `@OnDatabaseEvent` decorator to manage database events - add updatedFields in updated events - update openApi webhooks docs - update zapier integration
2024-11-04 17:44:36 +01:00
parent 741020fbb0
commit 695991881f
62 changed files with 547 additions and 578 deletions
--- a/packages/twenty-server/src/modules/timeline/jobs/create-audit-log-from-internal-event.ts
+++ b/packages/twenty-server/src/modules/timeline/jobs/create-audit-log-from-internal-event.ts
@ -20,15 +20,15 @@ export class CreateAuditLogFromInternalEvent {

  @Process(CreateAuditLogFromInternalEvent.name)
  async handle(
-    data: WorkspaceEventBatch<ObjectRecordBaseEvent>,
+    workspaceEventBatch: WorkspaceEventBatch<ObjectRecordBaseEvent>,
  ): Promise<void> {
-    for (const eventData of data.events) {
+    for (const eventData of workspaceEventBatch.events) {
      let workspaceMemberId: string | null = null;

      if (eventData.userId) {
        const workspaceMember = await this.workspaceMemberService.getByIdOrFail(
          eventData.userId,
-          data.workspaceId,
+          workspaceEventBatch.workspaceId,
        );

        workspaceMemberId = workspaceMember.id;
@ -42,13 +42,13 @@ export class CreateAuditLogFromInternalEvent {
      }

      await this.auditLogRepository.insert(
-        data.name,
+        workspaceEventBatch.name,
        eventData.properties,
        workspaceMemberId,
-        data.name.split('.')[0],
+        workspaceEventBatch.name.split('.')[0],
        eventData.objectMetadata.id,
        eventData.recordId,
-        data.workspaceId,
+        workspaceEventBatch.workspaceId,
      );
    }
  }
--- a/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
+++ b/packages/twenty-server/src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job.ts
@ -18,13 +18,13 @@ export class UpsertTimelineActivityFromInternalEvent {

  @Process(UpsertTimelineActivityFromInternalEvent.name)
  async handle(
-    data: WorkspaceEventBatch<ObjectRecordBaseEvent>,
+    workspaceEventBatch: WorkspaceEventBatch<ObjectRecordBaseEvent>,
  ): Promise<void> {
-    for (const eventData of data.events) {
+    for (const eventData of workspaceEventBatch.events) {
      if (eventData.userId) {
        const workspaceMember = await this.workspaceMemberService.getByIdOrFail(
          eventData.userId,
-          data.workspaceId,
+          workspaceEventBatch.workspaceId,
        );

        eventData.workspaceMemberId = workspaceMember.id;
@ -48,9 +48,9 @@ export class UpsertTimelineActivityFromInternalEvent {
      }

      await this.timelineActivityService.upsertEvent({
-        ...eventData,
-        workspaceId: data.workspaceId,
-        name: data.name,
+        event: eventData,
+        eventName: workspaceEventBatch.name,
+        workspaceId: workspaceEventBatch.workspaceId,
      });
    }
  }
--- a/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
+++ b/packages/twenty-server/src/modules/timeline/services/timeline-activity.service.ts
@ -1,12 +1,12 @@
 import { Injectable } from '@nestjs/common';

-import { ObjectRecordBaseEventWithNameAndWorkspaceId } from 'src/engine/core-modules/event-emitter/types/object-record.base.event';
+import { ObjectRecordBaseEvent } from 'src/engine/core-modules/event-emitter/types/object-record.base.event';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
 import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/workspace-datasource.service';
 import { TimelineActivityRepository } from 'src/modules/timeline/repositiories/timeline-activity.repository';
 import { TimelineActivityWorkspaceEntity } from 'src/modules/timeline/standard-objects/timeline-activity.workspace-entity';

-type TransformedEvent = ObjectRecordBaseEventWithNameAndWorkspaceId & {
+type TransformedEvent = ObjectRecordBaseEvent & {
  objectName?: string;
  linkedRecordCachedName?: string;
  linkedRecordId?: string;
@ -26,18 +26,26 @@ export class TimelineActivityService {
    task: 'taskTarget',
  };

-  async upsertEvent(event: ObjectRecordBaseEventWithNameAndWorkspaceId) {
-    const events = await this.transformEvent(event);
+  async upsertEvent({
+    event,
+    eventName,
+    workspaceId,
+  }: {
+    event: ObjectRecordBaseEvent;
+    eventName: string;
+    workspaceId: string;
+  }) {
+    const events = await this.transformEvent({ event, workspaceId, eventName });

    if (!events || events.length === 0) return;

    for (const event of events) {
      await this.timelineActivityRepository.upsertOne(
-        event.name,
+        eventName,
        event.properties,
        event.objectName ?? event.objectMetadata.nameSingular,
        event.recordId,
-        event.workspaceId,
+        workspaceId,
        event.workspaceMemberId,
        event.linkedRecordCachedName,
        event.linkedRecordId,
@ -46,11 +54,21 @@ export class TimelineActivityService {
    }
  }

-  private async transformEvent(
-    event: ObjectRecordBaseEventWithNameAndWorkspaceId,
-  ): Promise<TransformedEvent[]> {
+  private async transformEvent({
+    event,
+    workspaceId,
+    eventName,
+  }: {
+    event: ObjectRecordBaseEvent;
+    workspaceId: string;
+    eventName: string;
+  }): Promise<TransformedEvent[]> {
    if (['note', 'task'].includes(event.objectMetadata.nameSingular)) {
-      const linkedObjects = await this.handleLinkedObjects(event);
+      const linkedObjects = await this.handleLinkedObjects({
+        event,
+        workspaceId,
+        eventName,
+      });

      // 2 timelines, one for the linked object and one for the task/note
      if (linkedObjects?.length > 0) return [...linkedObjects, event];
@ -61,56 +79,81 @@ export class TimelineActivityService {
        event.objectMetadata.nameSingular,
      )
    ) {
-      const linkedObjects = await this.handleLinkedObjects(event);
-
-      return linkedObjects;
+      return await this.handleLinkedObjects({ event, workspaceId, eventName });
    }

    return [event];
  }

-  private async handleLinkedObjects(
-    event: ObjectRecordBaseEventWithNameAndWorkspaceId,
-  ) {
-    const dataSourceSchema = this.workspaceDataSourceService.getSchemaName(
-      event.workspaceId,
-    );
+  private async handleLinkedObjects({
+    event,
+    workspaceId,
+    eventName,
+  }: {
+    event: ObjectRecordBaseEvent;
+    workspaceId: string;
+    eventName: string;
+  }) {
+    const dataSourceSchema =
+      this.workspaceDataSourceService.getSchemaName(workspaceId);

    switch (event.objectMetadata.nameSingular) {
      case 'noteTarget':
-        return this.processActivityTarget(event, dataSourceSchema, 'note');
-      case 'taskTarget':
-        return this.processActivityTarget(event, dataSourceSchema, 'task');
-      case 'note':
-      case 'task':
-        return this.processActivity(
+        return this.processActivityTarget({
          event,
          dataSourceSchema,
-          event.objectMetadata.nameSingular,
-        );
+          activityType: 'note',
+          eventName,
+          workspaceId,
+        });
+      case 'taskTarget':
+        return this.processActivityTarget({
+          event,
+          dataSourceSchema,
+          activityType: 'task',
+          eventName,
+          workspaceId,
+        });
+      case 'note':
+      case 'task':
+        return this.processActivity({
+          event,
+          dataSourceSchema,
+          activityType: event.objectMetadata.nameSingular,
+          eventName,
+          workspaceId,
+        });
      default:
        return [];
    }
  }

-  private async processActivity(
-    event: ObjectRecordBaseEventWithNameAndWorkspaceId,
-    dataSourceSchema: string,
-    activityType: string,
-  ) {
+  private async processActivity({
+    event,
+    dataSourceSchema,
+    activityType,
+    eventName,
+    workspaceId,
+  }: {
+    event: ObjectRecordBaseEvent;
+    dataSourceSchema: string;
+    activityType: string;
+    eventName: string;
+    workspaceId: string;
+  }) {
    const activityTargets =
      await this.workspaceDataSourceService.executeRawQuery(
        `SELECT * FROM ${dataSourceSchema}."${this.targetObjects[activityType]}"
          WHERE "${activityType}Id" = $1`,
        [event.recordId],
-        event.workspaceId,
+        workspaceId,
      );

    const activity = await this.workspaceDataSourceService.executeRawQuery(
      `SELECT * FROM ${dataSourceSchema}."${activityType}"
          WHERE "id" = $1`,
      [event.recordId],
-      event.workspaceId,
+      workspaceId,
    );

    if (activityTargets.length === 0) return;
@ -135,7 +178,7 @@ export class TimelineActivityService {

        return {
          ...event,
-          name: 'linked-' + event.name,
+          name: 'linked-' + eventName,
          objectName: targetColumn[0].replace(/Id$/, ''),
          recordId: activityTarget[targetColumn[0]],
          linkedRecordCachedName: activity[0].title,
@ -146,17 +189,25 @@ export class TimelineActivityService {
      .filter((event): event is TransformedEvent => event !== undefined);
  }

-  private async processActivityTarget(
-    event: ObjectRecordBaseEventWithNameAndWorkspaceId,
-    dataSourceSchema: string,
-    activityType: string,
-  ) {
+  private async processActivityTarget({
+    event,
+    dataSourceSchema,
+    activityType,
+    eventName,
+    workspaceId,
+  }: {
+    event: ObjectRecordBaseEvent;
+    dataSourceSchema: string;
+    activityType: string;
+    eventName: string;
+    workspaceId: string;
+  }) {
    const activityTarget =
      await this.workspaceDataSourceService.executeRawQuery(
        `SELECT * FROM ${dataSourceSchema}."${this.targetObjects[activityType]}"
            WHERE "id" = $1`,
        [event.recordId],
-        event.workspaceId,
+        workspaceId,
      );

    if (activityTarget.length === 0) return;
@ -165,7 +216,7 @@ export class TimelineActivityService {
      `SELECT * FROM ${dataSourceSchema}."${activityType}"
          WHERE "id" = $1`,
      [activityTarget[0].activityId],
-      event.workspaceId,
+      workspaceId,
    );

    if (activity.length === 0) return;
@ -189,14 +240,14 @@ export class TimelineActivityService {
    return [
      {
        ...event,
-        name: 'linked-' + event.name,
+        name: 'linked-' + eventName,
        properties: {},
        objectName: targetColumn[0].replace(/Id$/, ''),
        recordId: activityTarget[0][targetColumn[0]],
        linkedRecordCachedName: activity[0].title,
        linkedRecordId: activity[0].id,
        linkedObjectMetadataId: activityObjectMetadataId,
-      },
-    ] as TransformedEvent[];
+      } as TransformedEvent,
+    ];
  }
 }