Skip to content

The open alternative to Salesforce, designed for AI.

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.mdx
index 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.
```ts
import 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 context
Every 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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';