Skip to content

The open alternative to Salesforce, designed for AI.

Skip webhook and trigger fan-out jobs when nothing listens to the event (#26184)

neo773d9b67fcc214e
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
index 86876782e47..952ee102fcc 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/listeners/entity-events-to-db.listener.ts
@@ -19,7 +19,10 @@ import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queu
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { CallWebhookJobsJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job';
import { WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';
+import { findWebhooksMatchingEventName } from 'src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util';
import { CallDatabaseEventTriggerJobsJob } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job';
+import { findLogicFunctionsTriggeredByEventName } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { ObjectRecordEventPublisher } from 'src/engine/subscriptions/object-record-event/object-record-event-publisher';
import { UpsertTimelineActivityFromInternalEvent } from 'src/modules/timeline/jobs/upsert-timeline-activity-from-internal-event.job';
@@ -36,6 +39,7 @@ export class EntityEventsToDbListener {
private readonly triggerQueueService: MessageQueueService,
private readonly objectRecordEventPublisher: ObjectRecordEventPublisher,
private readonly timelineActivityRoutingPlanService: TimelineActivityRoutingPlanService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
) {}
@OnDatabaseBatchEvent('*', DatabaseEventAction.CREATED)
@@ -96,25 +100,12 @@ export class EntityEventsToDbListener {
},
};
- const promises = [
+ const promises: Promise<unknown>[] = [
this.objectRecordEventPublisher.publish(batchEvent),
- this.webhookQueueService.add<WorkspaceEventBatchForWebhook<T>>(
- CallWebhookJobsJob.name,
- batchEventForWebhook,
- {
- retryLimit: 3,
- },
- ),
+ this.enqueueWebhookJobsIfAnyWebhookMatches(batchEventForWebhook),
+ this.enqueueDatabaseEventTriggerJobsIfAnyLogicFunctionMatches(batchEvent),
];
- promises.push(
- this.triggerQueueService.add<WorkspaceEventBatch<T>>(
- CallDatabaseEventTriggerJobsJob.name,
- batchEvent,
- { retryLimit: 3 },
- ),
- );
-
if (shouldCreateTimelineActivity) {
promises.push(
this.entityEventsToDbQueueService.add<
@@ -139,4 +130,54 @@ export class EntityEventsToDbListener {
await Promise.all(promises);
}
+
+ private async enqueueWebhookJobsIfAnyWebhookMatches<
+ T extends ObjectRecordEvent,
+ >(batchEventForWebhook: WorkspaceEventBatchForWebhook<T>) {
+ const hasMatchingWebhook = await this.workspaceCacheService
+ .getOrRecompute(batchEventForWebhook.workspaceId, ['flatWebhookMaps'])
+ .then(
+ ({ flatWebhookMaps }) =>
+ findWebhooksMatchingEventName({
+ flatWebhookMaps,
+ eventName: batchEventForWebhook.name,
+ }).length > 0,
+ )
+ .catch(() => true);
+
+ if (!hasMatchingWebhook) {
+ return;
+ }
+
+ await this.webhookQueueService.add<WorkspaceEventBatchForWebhook<T>>(
+ CallWebhookJobsJob.name,
+ batchEventForWebhook,
+ { retryLimit: 3 },
+ );
+ }
+
+ private async enqueueDatabaseEventTriggerJobsIfAnyLogicFunctionMatches<
+ T extends ObjectRecordEvent,
+ >(batchEvent: WorkspaceEventBatch<T>) {
+ const hasMatchingLogicFunction = await this.workspaceCacheService
+ .getOrRecompute(batchEvent.workspaceId, ['flatLogicFunctionMaps'])
+ .then(
+ ({ flatLogicFunctionMaps }) =>
+ findLogicFunctionsTriggeredByEventName({
+ flatLogicFunctionMaps,
+ eventName: batchEvent.name,
+ }).length > 0,
+ )
+ .catch(() => true);
+
+ if (!hasMatchingLogicFunction) {
+ return;
+ }
+
+ await this.triggerQueueService.add<WorkspaceEventBatch<T>>(
+ CallDatabaseEventTriggerJobsJob.name,
+ batchEvent,
+ { retryLimit: 3 },
+ );
+ }
}
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
index aca96187c56..9565810ef6b 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-runner.module.ts
@@ -9,6 +9,7 @@ import { RecordPositionModule } from 'src/engine/core-modules/record-position/re
import { RecordTransformerModule } from 'src/engine/core-modules/record-transformer/record-transformer.module';
import { TelemetryModule } from 'src/engine/core-modules/telemetry/telemetry.module';
import { SubscriptionsModule } from 'src/engine/subscriptions/subscriptions.module';
+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
import { TimelineActivityModule } from 'src/modules/timeline/timeline-activity.module';
@@ -25,6 +26,7 @@ import { EntityEventsToDbListener } from './listeners/entity-events-to-db.listen
RecordPositionModule,
SubscriptionsModule,
TimelineActivityModule,
+ WorkspaceCacheModule,
],
providers: [EntityEventsToDbListener, TelemetryListener],
})
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts
index 4953fe08537..97ba3558b7d 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts
@@ -13,6 +13,7 @@ import { ApplicationJobEnqueueThrottlerService } from 'src/engine/core-modules/m
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { ThrottlerException } from 'src/engine/core-modules/throttler/throttler.exception';
import { LOGIC_FUNCTION_QUEUE_RETRY_BACKOFF } from 'src/engine/core-modules/logic-function/logic-function-trigger/constants/logic-function-queue-retry-backoff.constant';
+import { findLogicFunctionsTriggeredByEventName } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name';
import { transformEventBatchToEventPayloads } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads';
import {
LogicFunctionTriggerJob,
@@ -64,25 +65,10 @@ export class CallDatabaseEventTriggerJobsJob {
],
);
- const logicFunctionsWithDatabaseEventTrigger = Object.values(
- flatLogicFunctionMaps.byUniversalIdentifier,
- )
- .filter(isDefined)
- .filter(
- (logicFunction) =>
- !isDefined(logicFunction.deletedAt) &&
- isDefined(logicFunction.databaseEventTriggerSettings),
- );
-
- const logicFunctionsToTrigger =
- logicFunctionsWithDatabaseEventTrigger.filter((logicFunction) =>
- this.shouldTriggerJob({
- workspaceEventBatch,
- eventName: isDefined(logicFunction.databaseEventTriggerSettings)
- ? logicFunction.databaseEventTriggerSettings.eventName
- : '',
- }),
- );
+ const logicFunctionsToTrigger = findLogicFunctionsTriggeredByEventName({
+ flatLogicFunctionMaps,
+ eventName: workspaceEventBatch.name,
+ });
const logicFunctionsByApplicationId = new Map<
string,
@@ -203,23 +189,4 @@ export class CallDatabaseEventTriggerJobsJob {
);
}
}
-
- private shouldTriggerJob({
- workspaceEventBatch,
- eventName,
- }: {
- workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;
- eventName: string;
- }) {
- const [nameSingular, operation] = workspaceEventBatch.name.split('.');
-
- const validEventNames = [
- `${nameSingular}.${operation}`,
- `*.${operation}`,
- `${nameSingular}.*`,
- '*.*',
- ];
-
- return validEventNames.includes(eventName);
- }
}
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/find-logic-functions-triggered-by-event-name.spec.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/find-logic-functions-triggered-by-event-name.spec.ts
new file mode 100644
index 00000000000..9c3ec068288
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/find-logic-functions-triggered-by-event-name.spec.ts
@@ -0,0 +1,83 @@
+import { findLogicFunctionsTriggeredByEventName } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { type FlatLogicFunctionMaps } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function-maps.type';
+
+const buildLogicFunction = ({
+ id,
+ triggerEventName,
+ deletedAt = null,
+}: {
+ id: string;
+ triggerEventName?: string;
+ deletedAt?: string | null;
+}) =>
+ ({
+ id,
+ deletedAt,
+ databaseEventTriggerSettings: triggerEventName
+ ? { eventName: triggerEventName }
+ : null,
+ }) as unknown as FlatLogicFunction;
+
+const findTriggeredLogicFunctionIds = (
+ logicFunctions: FlatLogicFunction[],
+ eventName: string,
+) => {
+ const flatLogicFunctionMaps: FlatLogicFunctionMaps = {
+ universalIdentifierById: {},
+ universalIdentifiersByApplicationId: {},
+ byUniversalIdentifier: Object.fromEntries(
+ logicFunctions.map((logicFunction) => [logicFunction.id, logicFunction]),
+ ),
+ };
+
+ return findLogicFunctionsTriggeredByEventName({
+ flatLogicFunctionMaps,
+ eventName,
+ }).map((logicFunction) => logicFunction.id);
+};
+
+describe('findLogicFunctionsTriggeredByEventName', () => {
+ it('matches exact and wildcard trigger event names', () => {
+ expect(
+ findTriggeredLogicFunctionIds(
+ [
+ buildLogicFunction({
+ id: 'exact',
+ triggerEventName: 'person.created',
+ }),
+ buildLogicFunction({
+ id: 'anyObject',
+ triggerEventName: '*.created',
+ }),
+ buildLogicFunction({
+ id: 'anyOperation',
+ triggerEventName: 'person.*',
+ }),
+ buildLogicFunction({ id: 'everything', triggerEventName: '*.*' }),
+ buildLogicFunction({
+ id: 'otherObject',
+ triggerEventName: 'company.created',
+ }),
+ ],
+ 'person.created',
+ ),
+ ).toEqual(['exact', 'anyObject', 'anyOperation', 'everything']);
+ });
+
+ it('ignores deleted logic functions and those without a database event trigger', () => {
+ expect(
+ findTriggeredLogicFunctionIds(
+ [
+ buildLogicFunction({
+ id: 'deleted',
+ triggerEventName: 'person.created',
+ deletedAt: '2026-09-01T00:00:00.000Z',
+ }),
+ buildLogicFunction({ id: 'httpRoute' }),
+ ],
+ 'person.created',
+ ),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name.ts
new file mode 100644
index 00000000000..00ea3daee0e
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/find-logic-functions-triggered-by-event-name.ts
@@ -0,0 +1,32 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { type FlatLogicFunctionMaps } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function-maps.type';
+
+export const findLogicFunctionsTriggeredByEventName = ({
+ flatLogicFunctionMaps,
+ eventName,
+}: {
+ flatLogicFunctionMaps: FlatLogicFunctionMaps;
+ eventName: string;
+}): FlatLogicFunction[] => {
+ const [nameSingular, operation] = eventName.split('.');
+
+ const matchingTriggerEventNames = [
+ `${nameSingular}.${operation}`,
+ `*.${operation}`,
+ `${nameSingular}.*`,
+ '*.*',
+ ];
+
+ return Object.values(flatLogicFunctionMaps.byUniversalIdentifier)
+ .filter(isDefined)
+ .filter(
+ (logicFunction) =>
+ !isDefined(logicFunction.deletedAt) &&
+ isDefined(logicFunction.databaseEventTriggerSettings) &&
+ matchingTriggerEventNames.includes(
+ logicFunction.databaseEventTriggerSettings.eventName,
+ ),
+ );
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts
index 126deb13b55..274a62e6792 100644
--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts
@@ -15,7 +15,7 @@ import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-we
import { WebhookRateLimitService } from 'src/engine/metadata-modules/webhook/jobs/webhook-rate-limit.service';
import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';
import { type WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';
-import { computeWebhookOperationsToMatch } from 'src/engine/metadata-modules/webhook/utils/compute-webhook-operations-to-match.util';
+import { findWebhooksMatchingEventName } from 'src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util';
import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';
import { EVERYONE_ROW_ACCESS_POLICY_SUBJECT } from 'src/engine/core-modules/record-share/constants/everyone-row-access-policy-subject.constant';
import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
@@ -45,26 +45,16 @@ export class CallWebhookJobsJob {
// Also change the openApi schema for webhooks
// packages/twenty-server/src/engine/core-modules/open-api/utils/computeWebhooks.utils.ts
- const [nameSingular, operation] = workspaceEventBatch.name.split('.');
-
- const operationsToMatch = computeWebhookOperationsToMatch({
- nameSingular,
- operation,
- });
-
const { flatWebhookMaps, flatObjectMetadataMaps } =
await this.workspaceCacheService.getOrRecompute(
workspaceEventBatch.workspaceId,
['flatWebhookMaps', 'flatObjectMetadataMaps'],
);
- const webhooks = Object.values(flatWebhookMaps.byUniversalIdentifier)
- .filter(isDefined)
- .filter((webhook) =>
- operationsToMatch.some((operationToMatch) =>
- webhook.operations.includes(operationToMatch),
- ),
- );
+ const webhooks = findWebhooksMatchingEventName({
+ flatWebhookMaps,
+ eventName: workspaceEventBatch.name,
+ });
if (webhooks.length === 0) {
return;
diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/find-webhooks-matching-event-name.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/find-webhooks-matching-event-name.util.spec.ts
new file mode 100644
index 00000000000..dbdc61ac028
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/find-webhooks-matching-event-name.util.spec.ts
@@ -0,0 +1,60 @@
+import { type FlatWebhook } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook.type';
+import { type FlatWebhookMaps } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook-maps.type';
+import { findWebhooksMatchingEventName } from 'src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util';
+
+const buildFlatWebhookMaps = (
+ operationsByWebhookId: Record<string, string[]>,
+): FlatWebhookMaps => ({
+ universalIdentifierById: {},
+ universalIdentifiersByApplicationId: {},
+ byUniversalIdentifier: Object.fromEntries(
+ Object.entries(operationsByWebhookId).map(([webhookId, operations]) => [
+ webhookId,
+ { id: webhookId, operations } as unknown as FlatWebhook,
+ ]),
+ ),
+});
+
+const findMatchingWebhookIds = (
+ operationsByWebhookId: Record<string, string[]>,
+ eventName: string,
+) =>
+ findWebhooksMatchingEventName({
+ flatWebhookMaps: buildFlatWebhookMaps(operationsByWebhookId),
+ eventName,
+ }).map((webhook) => webhook.id);
+
+describe('findWebhooksMatchingEventName', () => {
+ it('matches exact and wildcard operations but not other objects or operations', () => {
+ expect(
+ findMatchingWebhookIds(
+ {
+ exact: ['person.created'],
+ anyObject: ['*.created'],
+ anyOperation: ['person.*'],
+ everything: ['*.*'],
+ otherObject: ['company.created'],
+ otherOperation: ['person.updated'],
+ },
+ 'person.created',
+ ),
+ ).toEqual(['exact', 'anyObject', 'anyOperation', 'everything']);
+ });
+
+ it('only matches workflowRun.updated webhooks subscribed to it explicitly', () => {
+ expect(
+ findMatchingWebhookIds(
+ {
+ exact: ['workflowRun.updated'],
+ everything: ['*.*'],
+ anyObject: ['*.updated'],
+ },
+ 'workflowRun.updated',
+ ),
+ ).toEqual(['exact']);
+ });
+
+ it('returns nothing when the workspace has no webhooks', () => {
+ expect(findMatchingWebhookIds({}, 'person.created')).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util.ts
new file mode 100644
index 00000000000..c81f6efaf17
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/find-webhooks-matching-event-name.util.ts
@@ -0,0 +1,28 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatWebhook } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook.type';
+import { type FlatWebhookMaps } from 'src/engine/metadata-modules/flat-webhook/types/flat-webhook-maps.type';
+import { computeWebhookOperationsToMatch } from 'src/engine/metadata-modules/webhook/utils/compute-webhook-operations-to-match.util';
+
+export const findWebhooksMatchingEventName = ({
+ flatWebhookMaps,
+ eventName,
+}: {
+ flatWebhookMaps: FlatWebhookMaps;
+ eventName: string;
+}): FlatWebhook[] => {
+ const [nameSingular, operation] = eventName.split('.');
+
+ const operationsToMatch = computeWebhookOperationsToMatch({
+ nameSingular,
+ operation,
+ });
+
+ return Object.values(flatWebhookMaps.byUniversalIdentifier)
+ .filter(isDefined)
+ .filter((webhook) =>
+ operationsToMatch.some((operationToMatch) =>
+ webhook.operations.includes(operationToMatch),
+ ),
+ );
+};