The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Add batch delivery to database-event-triggered logic functions (#25726)
martmullbd46d9de6313
diff --git a/packages/twenty-docs/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/developers/extend/apps/logic/logic-functions.mdxindex a9ecbee548e..05cfa3a9db3 100644--- a/packages/twenty-docs/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/developers/extend/apps/logic/logic-functions.mdx@@ -344,10 +344,11 @@ When the caller must read the response body on the same request (challenge hands#### Database event trigger payload-When a database event trigger invokes your logic function, it receives one `DatabaseEventPayload` per changed record. The payload combines metadata about the source workspace and object with the record-level event.+When a database event trigger invokes your logic function, it receives one `DatabaseEventPayload` per changed record (or a `DatabaseEventBatchPayload` covering several records when `batchMode` is enabled). The payload combines metadata about the source workspace and object with the record-level event.```tsimport type {+ DatabaseEventBatchPayload,DatabaseEventPayload,ObjectRecordCreateEvent,ObjectRecordDestroyEvent,@@ -385,6 +386,14 @@ For permanent deletes, use `.destroyed`.`event.properties.updatedFields` tells you which fields actually changed on the current event.</Note>+`databaseEventTriggerSettings` accepts:++| Property | Description |+|----------|-------------|+| `eventName` | Event to listen on, such as `person.updated`. Supports `*` for the object name, the operation, or both. |+| `updatedFields` | Optional list of field names. On `.updated` events, only changes touching one of them trigger the function. |+| `batchMode` | Optional boolean. When `true`, the handler is called once per batch of records instead of once per record. The server decides how many records a batch holds, up to 200. |+Created event example:```ts@@ -451,6 +460,44 @@ const handler = async (event: PersonDestroyedEvent) => {};```+#### Batching database events++A bulk write emits many events at once: importing a mailbox, for instance, can update thousands of records in a single operation, and one call per record floods the queue. Set `batchMode` to receive them together:++```ts+export default defineLogicFunction({+ ...,+ databaseEventTriggerSettings: {+ eventName: 'person.updated',+ batchMode: true,+ },+});+```++The handler then receives a `DatabaseEventBatchPayload`, which carries the same metadata as `DatabaseEventPayload` but replaces the record-level fields with an `events` array:++```ts+type PeopleUpdatedBatch = DatabaseEventBatchPayload<+ ObjectRecordUpdateEvent<Person>+>;++const handler = async (batch: PeopleUpdatedBatch) => {+ const updatedEmails = batch.events.map(+ (event) => event.properties.after.emails?.primaryEmail,+ );++ return { workspaceId: batch.workspaceId, updatedEmails };+};+```++<Note>+Batch size is not something a handler can rely on. The server decides how many events a call carries, capped at 200, and a batch holds anything from a single event up to that ceiling depending on how many the originating write produced. Write the handler to loop over `events` whatever its length.+</Note>++Events are grouped by the user who caused them before being batched, so every call covers a single actor and `context.workspaceMemberId` stays meaningful. `updatedFields` filtering is applied before batching, so a batch only contains records you asked for.++Without `batchMode`, the handler keeps receiving one `DatabaseEventPayload` per record.+#### Execution contextEvery handler receives a second argument describing the run itself, whatever triggered it. Where the first argument changes shape per trigger, this one does not:diff --git a/packages/twenty-sdk/src/cli/utilities/entity/entity-logic-function-template.ts b/packages/twenty-sdk/src/cli/utilities/entity/entity-logic-function-template.tsindex 51d353259e8..9c7c4863df6 100644--- a/packages/twenty-sdk/src/cli/utilities/entity/entity-logic-function-template.ts+++ b/packages/twenty-sdk/src/cli/utilities/entity/entity-logic-function-template.ts@@ -45,6 +45,9 @@ export default defineLogicFunction({// Database event trigger example:// databaseEventTriggerSettings: {// eventName: 'objectName.created',+ // // Optional: receive one call per batch of events instead of one per event,+ // // the handler payload then becomes { ...eventInfo, events: [...] }+ // batchMode: true,// },});`;diff --git a/packages/twenty-sdk/src/sdk/define/index.ts b/packages/twenty-sdk/src/sdk/define/index.tsindex 3b22e74098e..f74b45eb6c1 100644--- a/packages/twenty-sdk/src/sdk/define/index.ts+++ b/packages/twenty-sdk/src/sdk/define/index.ts@@ -108,6 +108,7 @@ export type {export type { ServerRouteDispatchResult } from 'twenty-shared/application';export type { CronPayload } from '@/sdk/define/logic-functions/triggers/cron-payload-type';export type {+ DatabaseEventBatchPayload,DatabaseEventPayload,ObjectRecordBaseEvent,ObjectRecordCreateEvent,diff --git a/packages/twenty-sdk/src/sdk/define/logic-functions/__tests__/define-logic-function.spec.ts b/packages/twenty-sdk/src/sdk/define/logic-functions/__tests__/define-logic-function.spec.tsindex 7925596b6dd..c816a466787 100644--- a/packages/twenty-sdk/src/sdk/define/logic-functions/__tests__/define-logic-function.spec.ts+++ b/packages/twenty-sdk/src/sdk/define/logic-functions/__tests__/define-logic-function.spec.ts@@ -1,4 +1,5 @@import { defineLogicFunction } from '@/sdk/define';+import { type LogicFunctionConfig } from '@/sdk/define/logic-functions/logic-function-config';const mockHandler = async () => ({ success: true });@@ -52,6 +53,23 @@ describe('defineLogicFunction', () => {expect(result.config.databaseEventTriggerSettings?.eventName).toBeDefined();});+ it('should accept databaseEventTriggerSettings with batchMode enabled', () => {+ const config: LogicFunctionConfig = {+ universalIdentifier: 'e56d363b-0bdc-4d8a-a393-6f0d1c75bdcf',+ name: 'On Contact Created',+ handler: mockHandler,+ databaseEventTriggerSettings: {+ eventName: 'contact.created',+ batchMode: true,+ },+ };++ const result = defineLogicFunction(config);++ expect(result.errors).toEqual([]);+ expect(result.config.databaseEventTriggerSettings?.batchMode).toBe(true);+ });+it('should pass through optional fields', () => {const config = {...validRouteConfig,diff --git a/packages/twenty-sdk/src/sdk/define/logic-functions/triggers/database-event-payload-type.ts b/packages/twenty-sdk/src/sdk/define/logic-functions/triggers/database-event-payload-type.tsindex 34c8ef6c242..1d3e84a53a6 100644--- a/packages/twenty-sdk/src/sdk/define/logic-functions/triggers/database-event-payload-type.ts+++ b/packages/twenty-sdk/src/sdk/define/logic-functions/triggers/database-event-payload-type.ts@@ -1,4 +1,5 @@export type {+ DatabaseEventBatchPayload,DatabaseEventPayload,ObjectRecordCreateEvent,ObjectRecordUpdateEvent,diff --git a/packages/twenty-sdk/src/sdk/logic-function/index.ts b/packages/twenty-sdk/src/sdk/logic-function/index.tsindex fb28415bc55..06f6274e213 100644--- a/packages/twenty-sdk/src/sdk/logic-function/index.ts+++ b/packages/twenty-sdk/src/sdk/logic-function/index.ts@@ -30,6 +30,7 @@ export type {export type { CronPayload } from '@/sdk/define/logic-functions/triggers/cron-payload-type';export type {+ DatabaseEventBatchPayload,DatabaseEventPayload,ObjectRecordBaseEvent,ObjectRecordCreateEvent,diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant.tsnew file mode 100644index 00000000000..2461afd9138--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant.ts@@ -0,0 +1,4 @@+// Hard ceiling on how many database events a single logic function trigger job carries when the+// trigger opts into batchMode. It bounds the Redis job payload, so a handler must never assume a+// batch is full: a batch holds anything from one event up to this many.+export const MAX_EVENTS_PER_TRIGGER_JOB = 200;diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.tsindex cf10b7b2a18..3130cc88264 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts@@ -1,5 +1,6 @@import type { ObjectRecordEvent } from 'twenty-shared/database-events';+import { MAX_EVENTS_PER_TRIGGER_JOB } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant';import { transformEventBatchToEventPayloads } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads';import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';import { type LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';@@ -457,6 +458,337 @@ describe('transformEventBatchToEventPayloads', () => {});});+ describe('batchMode', () => {+ const createEvents = (+ count: number,+ overrides: Partial<ObjectRecordEvent> = {},+ ) =>+ Array.from({ length: count }, (_, index) =>+ createMockEvent({ recordId: `record-${index + 1}`, ...overrides }),+ );++ const getBatchedEvents = (payload: unknown) =>+ (payload as { events: ObjectRecordEvent[] }).events;++ it('should keep one job per event when batchMode is not set', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(3),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [createMockLogicFunction()],+ });++ expect(result).toHaveLength(3);+ expect(result[0]).toEqual({+ logicFunctionId: 'function-1',+ workspaceId: 'workspace-1',+ payload: {+ name: 'company.updated',+ workspaceId: 'workspace-1',+ objectMetadata: workspaceEventBatch.objectMetadata,+ recordId: 'record-1',+ properties: { after: {} },+ },+ });+ result.forEach((jobData) => {+ expect(jobData.payload).not.toHaveProperty('events');+ });+ });++ it('should keep one job per event when batchMode is false', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(3),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: false,+ },+ }),+ ],+ });++ expect(result).toHaveLength(3);+ result.forEach((jobData) => {+ expect(jobData.payload).not.toHaveProperty('events');+ });+ });++ it('should emit a single job when every event fits one chunk', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(6),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(1);+ expect(+ getBatchedEvents(result[0].payload).map((event) => event.recordId),+ ).toEqual([+ 'record-1',+ 'record-2',+ 'record-3',+ 'record-4',+ 'record-5',+ 'record-6',+ ]);+ expect(result[0].payload).toMatchObject({+ name: 'company.updated',+ workspaceId: 'workspace-1',+ });+ });++ it('should split into chunks of at most the ceiling, with a smaller remainder', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(MAX_EVENTS_PER_TRIGGER_JOB * 2 + 1),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(3);+ expect(+ result.map((jobData) => getBatchedEvents(jobData.payload).length),+ ).toEqual([MAX_EVENTS_PER_TRIGGER_JOB, MAX_EVENTS_PER_TRIGGER_JOB, 1]);+ });++ it('should preserve event order across chunks', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(MAX_EVENTS_PER_TRIGGER_JOB + 2),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: true,+ },+ }),+ ],+ });++ expect(+ result.flatMap((jobData) =>+ getBatchedEvents(jobData.payload).map((event) => event.recordId),+ ),+ ).toEqual(+ Array.from(+ { length: MAX_EVENTS_PER_TRIGGER_JOB + 2 },+ (_, index) => `record-${index + 1}`,+ ),+ );+ });++ it('should never mix events triggered by different users in the same job', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: [+ createMockEvent({+ recordId: 'record-1',+ userId: 'user-1',+ userWorkspaceId: 'user-workspace-1',+ }),+ createMockEvent({+ recordId: 'record-2',+ userId: 'user-2',+ userWorkspaceId: 'user-workspace-2',+ }),+ createMockEvent({+ recordId: 'record-3',+ userId: 'user-1',+ userWorkspaceId: 'user-workspace-1',+ }),+ createMockEvent({ recordId: 'record-4' }),+ ],+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(3);+ expect(result[0]).toMatchObject({+ userId: 'user-1',+ userWorkspaceId: 'user-workspace-1',+ });+ expect(+ getBatchedEvents(result[0].payload).map((event) => event.recordId),+ ).toEqual(['record-1', 'record-3']);++ expect(result[1]).toMatchObject({+ userId: 'user-2',+ userWorkspaceId: 'user-workspace-2',+ });+ expect(+ getBatchedEvents(result[1].payload).map((event) => event.recordId),+ ).toEqual(['record-2']);++ expect(result[2]).not.toHaveProperty('userId');+ expect(result[2]).not.toHaveProperty('userWorkspaceId');+ expect(+ getBatchedEvents(result[2].payload).map((event) => event.recordId),+ ).toEqual(['record-4']);+ });++ it('should apply the updatedFields filter before chunking', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: [+ createMockEvent({+ recordId: 'record-1',+ properties: { after: {}, updatedFields: ['name'] },+ }),+ createMockEvent({+ recordId: 'record-2',+ properties: { after: {}, updatedFields: ['address'] },+ }),+ createMockEvent({+ recordId: 'record-3',+ properties: { after: {}, updatedFields: ['name'] },+ }),+ createMockEvent({+ recordId: 'record-4',+ properties: { after: {}, updatedFields: ['address'] },+ }),+ createMockEvent({+ recordId: 'record-5',+ properties: { after: {}, updatedFields: ['name'] },+ }),+ ],+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ updatedFields: ['name'],+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(1);+ expect(+ getBatchedEvents(result[0].payload).map((event) => event.recordId),+ ).toEqual(['record-1', 'record-3', 'record-5']);+ });++ it('should batch operations other than updated', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ name: 'company.created',+ events: createEvents(3),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.created',+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(1);+ expect(getBatchedEvents(result[0].payload)).toHaveLength(3);+ });++ it('should batch per logic function so an unbatched one keeps one job per event', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: createEvents(4),+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({ id: 'function-1' }),+ createMockLogicFunction({+ id: 'function-2',+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ batchMode: true,+ },+ }),+ ],+ });++ expect(+ result.filter((jobData) => jobData.logicFunctionId === 'function-1'),+ ).toHaveLength(4);++ const batchedJobs = result.filter(+ (jobData) => jobData.logicFunctionId === 'function-2',+ );++ expect(batchedJobs).toHaveLength(1);+ expect(getBatchedEvents(batchedJobs[0].payload)).toHaveLength(4);+ });++ it('should emit no job when every event is filtered out', () => {+ const workspaceEventBatch = createMockWorkspaceEventBatch({+ events: [+ createMockEvent({+ recordId: 'record-1',+ properties: { after: {}, updatedFields: ['address'] },+ }),+ ],+ });++ const result = transformEventBatchToEventPayloads({+ workspaceEventBatch,+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: {+ eventName: 'company.updated',+ updatedFields: ['name'],+ batchMode: true,+ },+ }),+ ],+ });++ expect(result).toHaveLength(0);+ });+ });+describe('edge cases', () => {it('should return empty array when no logic functions provided', () => {const workspaceEventBatch = createMockWorkspaceEventBatch();diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.tsindex 3ecb04777f7..f58364d8c8c 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts@@ -1,8 +1,11 @@+import chunk from 'lodash.chunk';+import { isDefined } from 'twenty-shared/utils';import type { ObjectRecordEvent } from 'twenty-shared/database-events';import { type LogicFunctionTriggerJobData } from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';+import { MAX_EVENTS_PER_TRIGGER_JOB } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant';import { type LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';import type { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';@@ -21,33 +24,74 @@ export const transformEventBatchToEventPayloads = ({const [, operation] = workspaceEventBatch.name.split('.');for (const logicFunction of logicFunctions) {- const triggerUpdatedFields =- logicFunction.databaseEventTriggerSettings?.updatedFields;+ const triggerSettings = logicFunction.databaseEventTriggerSettings;const filteredEvents = filterEventsByUpdatedFields({events,operation,- triggerUpdatedFields,+ triggerUpdatedFields: triggerSettings?.updatedFields,});- for (const event of filteredEvents) {- const payload = { ...batchEventInfo, ...event };-- result.push({- logicFunctionId: logicFunction.id,- workspaceId: logicFunction.workspaceId,- payload,- ...(isDefined(event.userId) ? { userId: event.userId } : {}),- ...(isDefined(event.userWorkspaceId)- ? { userWorkspaceId: event.userWorkspaceId }- : {}),- });+ if (triggerSettings?.batchMode !== true) {+ for (const event of filteredEvents) {+ result.push({+ logicFunctionId: logicFunction.id,+ workspaceId: logicFunction.workspaceId,+ payload: { ...batchEventInfo, ...event },+ ...buildAuthContext(event),+ });+ }++ continue;+ }++ // A job carries a single auth context, so events acted by different users can never share one+ for (const eventsSharingAuthContext of groupEventsByAuthContext(+ filteredEvents,+ )) {+ for (const eventsChunk of chunk(+ eventsSharingAuthContext,+ MAX_EVENTS_PER_TRIGGER_JOB,+ )) {+ result.push({+ logicFunctionId: logicFunction.id,+ workspaceId: logicFunction.workspaceId,+ payload: { ...batchEventInfo, events: eventsChunk },+ ...buildAuthContext(eventsChunk[0]),+ });+ }}}return result;};+const buildAuthContext = (event: ObjectRecordEvent) => ({+ ...(isDefined(event.userId) ? { userId: event.userId } : {}),+ ...(isDefined(event.userWorkspaceId)+ ? { userWorkspaceId: event.userWorkspaceId }+ : {}),+});++const groupEventsByAuthContext = (+ events: ObjectRecordEvent[],+): ObjectRecordEvent[][] => {+ const eventsByAuthContext = new Map<string, ObjectRecordEvent[]>();++ for (const event of events) {+ const authContextKey = `${event.userId ?? ''}:${event.userWorkspaceId ?? ''}`;+ const eventsSharingAuthContext = eventsByAuthContext.get(authContextKey);++ if (isDefined(eventsSharingAuthContext)) {+ eventsSharingAuthContext.push(event);+ } else {+ eventsByAuthContext.set(authContextKey, [event]);+ }+ }++ return [...eventsByAuthContext.values()];+};+const filterEventsByUpdatedFields = ({events,operation,diff --git a/packages/twenty-shared/src/application/logicFunctionManifestType.ts b/packages/twenty-shared/src/application/logicFunctionManifestType.tsindex 679c0eb14f1..e6183eb9df5 100644--- a/packages/twenty-shared/src/application/logicFunctionManifestType.ts+++ b/packages/twenty-shared/src/application/logicFunctionManifestType.ts@@ -27,6 +27,7 @@ export type CronTriggerSettings = {export type DatabaseEventTriggerSettings = {eventName: string;updatedFields?: string[];+ batchMode?: boolean;};export type HttpRouteTriggerSettings = {diff --git a/packages/twenty-shared/src/database-events/database-event-payload.type.ts b/packages/twenty-shared/src/database-events/database-event-payload.type.tsindex 6bd80231335..f6c6e3378c0 100644--- a/packages/twenty-shared/src/database-events/database-event-payload.type.ts+++ b/packages/twenty-shared/src/database-events/database-event-payload.type.ts@@ -46,3 +46,8 @@ type DatabaseEventMetadata = {export type DatabaseEventPayload<T = ObjectRecordEvent> =DatabaseEventMetadata & T;++export type DatabaseEventBatchPayload<T = ObjectRecordEvent> =+ DatabaseEventMetadata & {+ events: T[];+ };diff --git a/packages/twenty-shared/src/database-events/index.ts b/packages/twenty-shared/src/database-events/index.tsindex ee8e1601fc2..90ddbb3466d 100644--- a/packages/twenty-shared/src/database-events/index.ts+++ b/packages/twenty-shared/src/database-events/index.ts@@ -7,7 +7,10 @@* |___/*/-export type { DatabaseEventPayload } from './database-event-payload.type';+export type {+ DatabaseEventPayload,+ DatabaseEventBatchPayload,+} from './database-event-payload.type';export { ObjectRecordCreateEvent } from './object-record-create.event';export { ObjectRecordDeleteEvent } from './object-record-delete.event';export { ObjectRecordDestroyEvent } from './object-record-destroy.event';