@cap-js-community/event-queue 1.10.1 → 1.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "An event queue that enables secure transactional processing of asynchronous and periodic events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/EventQueueProcessorBase.js

@@ -1019,11 +1019,18 @@ class EventQueueProcessorBase {
   async scheduleNextPeriodEvent(queueEntry) {
     const intervalInMs = this.#eventConfig.cron ? null : this.#eventConfig.interval * 1000;
     const next = this.#calculateCronDates();
+    let newStartAfter;
+
+    if (this.#eventConfig.cron) {
+      newStartAfter = next.getTime() + this.#calculateRandomOffset();
+    } else {
+      newStartAfter = new Date(queueEntry.startAfter).getTime() + intervalInMs + this.#calculateRandomOffset();
+    }
 
     const newEvent = {
       type: this.#eventType,
       subType: this.#eventSubType,
-      startAfter: next ?? new Date(new Date(queueEntry.startAfter).getTime() + intervalInMs),
+      startAfter: new Date(newStartAfter),
     };
     const { relative } = this.#eventSchedulerInstance.calculateOffset(
       this.#eventType,
@@ -1071,6 +1078,15 @@ class EventQueueProcessorBase {
     }
   }
 
+  #calculateRandomOffset() {
+    const offset = this.#eventConfig.randomOffset ?? this.#config.randomOffsetPeriodicEvents;
+    if (!offset) {
+      return 0;
+    }
+
+    return Math.floor(Math.random() * offset) * 1000;
+  }
+
   async handleDuplicatedPeriodicEventEntry(queueEntries) {
     this.logger.error("More than one open events for the same configuration which is not allowed!", {
       eventType: this.#eventType,

package/src/config.js

@@ -75,6 +75,7 @@ const ALLOWED_EVENT_OPTIONS_PERIODIC_EVENT = [
   "cron",
   "utc",
   "useCronTimezone",
+  "randomOffset",
 ];
 
 class Config {
@@ -108,6 +109,7 @@ class Config {
   #unsubscribeHandlers = [];
   #unsubscribedTenants = {};
   #cronTimezone;
+  #randomOffsetPeriodicEvents;
   #redisNamespace;
   #publishEventBlockList;
   #crashOnRedisUnavailable;
@@ -167,7 +169,15 @@ class Config {
     return { type: "string", value: str };
   }
 
-  shouldBeProcessedInThisApplication(type, subType) {
+  #normalizeSubType(rawSubType) {
+    const [serviceName, actionName] = rawSubType.split(".");
+    const actionSpecificCall = this.getCdsOutboxEventSpecificConfig(serviceName, actionName);
+    return actionSpecificCall ? rawSubType : serviceName;
+  }
+
+  shouldBeProcessedInThisApplication(type, rawSubType) {
+    const subType = this.#normalizeSubType(rawSubType);
+
     const config = this.#eventMap[this.generateKey(type, subType)];
     const appNameConfig = config._appNameMap;
     const appInstanceConfig = config._appInstancesMap;
@@ -815,6 +825,14 @@ class Config {
     this.#cronTimezone = value;
   }
 
+  get randomOffsetPeriodicEvents() {
+    return this.#randomOffsetPeriodicEvents;
+  }
+
+  set randomOffsetPeriodicEvents(value) {
+    this.#randomOffsetPeriodicEvents = value;
+  }
+
   get instanceLoadLimit() {
     return this.#instanceLoadLimit;
   }

package/src/initialize.js

@@ -42,6 +42,7 @@ const CONFIG_VARS = [
   ["insertEventsBeforeCommit", true],
   ["enableTelemetry", true],
   ["cronTimezone", null],
+  ["randomOffsetPeriodicEvents", null],
   ["redisNamespace", null],
   ["publishEventBlockList", true],
   ["crashOnRedisUnavailable", false],
@@ -68,6 +69,7 @@ const CONFIG_VARS = [
  * @param {boolean} [options.insertEventsBeforeCommit=true] - Insert events into the queue before committing the transaction.
  * @param {boolean} [options.enableTelemetry=false] - Enable telemetry for CAP.
  * @param {string} [options.cronTimezone=null] - Default timezone for cron jobs.
+ * @param {string} [options.randomOffsetPeriodicEvents=null] - Default random offset for periodic events.
  * @param {string} [options.publishEventBlockList=true] - If redis is available event blocklist is distributed to all application instances
  * @param {string} [options.crashOnRedisUnavailable=true] - If enabled an error is thrown if the redis connection check is not successful
  */

package/src/outbox/eventQueueAsOutbox.js

@@ -47,7 +47,6 @@ function outboxed(srv, customOpts) {
       customOpts || {}
     );
     config.addCAPOutboxEventBase(srv.name, outboxOpts);
-    // TODO: check req.event ?? req.method
     const specificSettings = config.getCdsOutboxEventSpecificConfig(srv.name, req.event);
     if (specificSettings) {
       outboxOpts = config.addCAPOutboxEventSpecificAction(srv.name, req.event);

package/src/redis/redisSub.js

@@ -40,11 +40,18 @@ const _messageHandlerProcessEvents = async (messageData) => {
       return;
     }
 
+    const [serviceNameOrSubType, actionName] = subType.split(".");
     if (!config.getEventConfig(type, subType)) {
       if (config.isCapOutboxEvent(type)) {
         try {
-          const service = await cds.connect.to(subType);
+          const service = await cds.connect.to(serviceNameOrSubType);
           cds.outboxed(service);
+          if (actionName) {
+            const specificSettings = config.getCdsOutboxEventSpecificConfig(serviceNameOrSubType, actionName);
+            if (specificSettings) {
+              config.addCAPOutboxEventSpecificAction(serviceNameOrSubType, actionName);
+            }
+          }
         } catch (err) {
           logger.warn("could not connect to outboxed service", err, {
             type,