@cap-js-community/event-queue 0.1.58 → 0.2.0

package/db/Event.cds

@@ -21,4 +21,5 @@ entity Event: cuid {
     attempts: Integer default 0 not null;
     lastAttemptTimestamp: Timestamp;
     createdAt: Timestamp @cds.on.insert : $now;
+    startAfter: Timestamp;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "0.1.58",
+  "version": "0.2.0",
   "description": "An event queue that enables secure transactional processing of asynchronous events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "files": [
@@ -23,9 +23,10 @@
     "test:unit": "jest --testPathIgnorePatterns=\"/test-integration/\"",
     "test:integration": "jest --testPathIgnorePatterns=\"/test/\" --runInBand --forceExit",
     "test:all": "npm run test:unit && npm run test:integration",
-    "test:ci": "npm run test:prepare && npm run test:all",
     "test:all:coverage": "jest --runInBand --forceExit --collect-coverage",
     "test:prepare": "npm run build:ci --prefix=./test-integration/_env",
+    "test:deploySchema": "node test-integration/_env/srv/hana/deploy.js",
+    "test:cleanSchemas": "node test-integration/_env/srv/hana/cleanObsoletSchemas.js",
     "lint": "npm run eslint && npm run prettier",
     "lint:ci": "npm run eslint:ci && npm run prettier:ci",
     "eslint": "eslint --fix .",
@@ -43,7 +44,7 @@
   "dependencies": {
     "redis": "4.6.10",
     "verror": "1.10.1",
-    "yaml": "2.3.3"
+    "yaml": "2.3.4"
   },
   "devDependencies": {
     "@sap/cds": "7.3.1",
@@ -55,7 +56,7 @@
     "express": "4.18.2",
     "hdb": "0.19.6",
     "jest": "29.7.0",
-    "prettier": "3.0.3",
+    "prettier": "2.8.8",
     "sqlite3": "5.1.6"
   },
   "homepage": "https://cap-js-community.github.io/event-queue/",

package/src/EventQueueError.js

@@ -11,6 +11,7 @@ const ERROR_CODES = {
   MISSING_TABLE_DEFINITION: "MISSING_TABLE_DEFINITION",
   MISSING_ELEMENT_IN_TABLE: "MISSING_ELEMENT_IN_TABLE",
   TYPE_MISMATCH_TABLE: "TYPE_MISMATCH_TABLE",
+  NO_VALID_DATE: "NO_VALID_DATE",
 };
 
 const ERROR_CODES_META = {
@@ -39,6 +40,9 @@ const ERROR_CODES_META = {
   [ERROR_CODES.TYPE_MISMATCH_TABLE]: {
     message: "At least one field in the provided table doesn't have the expected data type.",
   },
+  [ERROR_CODES.NO_VALID_DATE]: {
+    message: "One or more events contain a date in a malformed format.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -131,6 +135,17 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static malformedDate(date) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.NO_VALID_DATE];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.NO_VALID_DATE,
+        info: { date },
+      },
+      message
+    );
+  }
 }
 
 module.exports = EventQueueError;

package/src/EventQueueProcessorBase.js

@@ -7,6 +7,7 @@ const { EventProcessingStatus, TransactionMode } = require("./constants");
 const distributedLock = require("./shared/distributedLock");
 const EventQueueError = require("./EventQueueError");
 const { arrayToFlatMap } = require("./shared/common");
+const eventScheduler = require("./shared/EventScheduler");
 const eventQueueConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
 
@@ -20,12 +21,16 @@ const SELECT_LIMIT_EVENTS_PER_TICK = 100;
 const DEFAULT_DELETE_FINISHED_EVENTS_AFTER = 0;
 const DAYS_TO_MS = 24 * 60 * 60 * 1000;
 const TRIES_FOR_EXCEEDED_EVENTS = 3;
+const EVENT_START_AFTER_HEADROOM = 3 * 1000;
 
 class EventQueueProcessorBase {
   #eventsWithExceededTries = [];
   #exceededTriesExceeded = [];
   #selectedEventMap = {};
   #queueEntriesWithPayloadMap = {};
+  #eventType = null;
+  #eventSubType = null;
+  #config = null;
 
   constructor(context, eventType, eventSubType, config) {
     this.__context = context;
@@ -36,26 +41,27 @@ class EventQueueProcessorBase {
     this.__eventProcessingMap = {};
     this.__statusMap = {};
     this.__commitedStatusMap = {};
-    this.__eventType = eventType;
-    this.__eventSubType = eventSubType;
-    this.__config = config ?? {};
-    this.__parallelEventProcessing = this.__config.parallelEventProcessing ?? DEFAULT_PARALLEL_EVENT_PROCESSING;
+    this.#eventType = eventType;
+    this.#eventSubType = eventSubType;
+    this.__eventConfig = config ?? {};
+    this.__parallelEventProcessing = this.__eventConfig.parallelEventProcessing ?? DEFAULT_PARALLEL_EVENT_PROCESSING;
     if (this.__parallelEventProcessing > LIMIT_PARALLEL_EVENT_PROCESSING) {
       this.__parallelEventProcessing = LIMIT_PARALLEL_EVENT_PROCESSING;
     }
     // NOTE: keep the feature, this might be needed again
     this.__concurrentEventProcessing = false;
-    this.__startTime = this.__config.startTime ?? new Date();
-    this.__retryAttempts = this.__config.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS;
-    this.__selectMaxChunkSize = this.__config.selectMaxChunkSize ?? SELECT_LIMIT_EVENTS_PER_TICK;
-    this.__selectNextChunk = !!this.__config.checkForNextChunk;
+    this.__startTime = this.__eventConfig.startTime ?? new Date();
+    this.__retryAttempts = this.__eventConfig.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS;
+    this.__selectMaxChunkSize = this.__eventConfig.selectMaxChunkSize ?? SELECT_LIMIT_EVENTS_PER_TICK;
+    this.__selectNextChunk = !!this.__eventConfig.checkForNextChunk;
     this.__keepalivePromises = {};
-    this.__outdatedCheckEnabled = this.__config.eventOutdatedCheck ?? true;
-    this.__transactionMode = this.__config.transactionMode ?? TransactionMode.isolated;
-    if (this.__config.deleteFinishedEventsAfterDays) {
+    this.__outdatedCheckEnabled = this.__eventConfig.eventOutdatedCheck ?? true;
+    this.__transactionMode = this.__eventConfig.transactionMode ?? TransactionMode.isolated;
+    if (this.__eventConfig.deleteFinishedEventsAfterDays) {
       this.__deleteFinishedEventsAfter =
-        Number.isInteger(this.__config.deleteFinishedEventsAfterDays) && this.__config.deleteFinishedEventsAfterDays > 0
-          ? this.__config.deleteFinishedEventsAfterDays
+        Number.isInteger(this.__eventConfig.deleteFinishedEventsAfterDays) &&
+        this.__eventConfig.deleteFinishedEventsAfterDays > 0
+          ? this.__eventConfig.deleteFinishedEventsAfterDays
           : DEFAULT_DELETE_FINISHED_EVENTS_AFTER;
     } else {
       this.__deleteFinishedEventsAfter = DEFAULT_DELETE_FINISHED_EVENTS_AFTER;
@@ -65,7 +71,7 @@ class EventQueueProcessorBase {
     this.__txUsageAllowed = true;
     this.__txMap = {};
     this.__txRollback = {};
-    this.__eventQueueConfig = eventQueueConfig.getConfigInstance();
+    this.#config = eventQueueConfig.getConfigInstance();
     this.__queueEntries = [];
   }
 
@@ -99,8 +105,8 @@ class EventQueueProcessorBase {
     this.__performanceLoggerEvents?.endPerformanceTrace(
       { threshold: 50 },
       {
-        eventType: this.eventType,
-        eventSubType: this.eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
       }
     );
   }
@@ -109,16 +115,16 @@ class EventQueueProcessorBase {
     this.__performanceLoggerPreprocessing?.endPerformanceTrace(
       { threshold: 50 },
       {
-        eventType: this.eventType,
-        eventSubType: this.eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
       }
     );
   }
 
   logTimeExceeded(iterationCounter) {
     this.logger.info("Exiting event queue processing as max time exceeded", {
-      eventType: this.eventType,
-      eventSubType: this.eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
       iterationCounter,
     });
   }
@@ -127,8 +133,8 @@ class EventQueueProcessorBase {
     // TODO: how to handle custom fields
     this.logger.info("Processing queue event", {
       numberQueueEntries: queueEntries.length,
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
   }
 
@@ -157,8 +163,8 @@ class EventQueueProcessorBase {
       this.logger.error(
         "The supplied queueEntry has not been selected before and should not be processed. Entry will not be processed.",
         {
-          eventType: this.__eventType,
-          eventSubType: this.__eventSubType,
+          eventType: this.#eventType,
+          eventSubType: this.#eventSubType,
           queueEntryId: queueEntry.ID,
         }
       );
@@ -177,8 +183,8 @@ class EventQueueProcessorBase {
   setStatusToDone(queueEntry) {
     this.logger.debug("setting status for queueEntry to done", {
       id: queueEntry.ID,
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
     this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Done);
   }
@@ -207,8 +213,8 @@ class EventQueueProcessorBase {
     this.logger.debug("add entry to processing map", {
       key,
       queueEntry,
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
     this.__eventProcessingMap[key] = this.__eventProcessingMap[key] ?? {
       queueEntries: [],
@@ -230,8 +236,8 @@ class EventQueueProcessorBase {
   setEventStatus(queueEntries, queueEntryProcessingStatusTuple, returnMap = false) {
     this.logger.debug("setting event status for entries", {
       queueEntryProcessingStatusTuple: JSON.stringify(queueEntryProcessingStatusTuple),
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
     const statusMap = this.commitOnEventLevel || returnMap ? {} : this.__statusMap;
     try {
@@ -245,8 +251,8 @@ class EventQueueProcessorBase {
       this.logger.error(
         `The supplied status tuple doesn't have the required structure. Setting all entries to error. Error: ${error.toString()}`,
         {
-          eventType: this.__eventType,
-          eventSubType: this.__eventSubType,
+          eventType: this.#eventType,
+          eventSubType: this.#eventSubType,
         }
       );
     }
@@ -286,8 +292,8 @@ class EventQueueProcessorBase {
     this.logger.error(
       `Caught error during event processing - setting queue entry to error. Please catch your promises/exceptions. Error: ${error}`,
       {
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
         queueEntriesIds: queueEntries.map(({ ID }) => ID),
       }
     );
@@ -304,8 +310,8 @@ class EventQueueProcessorBase {
    */
   async persistEventStatus(tx, { skipChecks, statusMap = this.__statusMap } = {}) {
     this.logger.debug("entering persistEventStatus", {
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
     this.#ensureOnlySelectedQueueEntries(statusMap);
     if (!skipChecks) {
@@ -335,8 +341,8 @@ class EventQueueProcessorBase {
       }
     );
     this.logger.debug("persistEventStatus for entries", {
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
       invalidAttempts,
       failed,
       exceeded,
@@ -344,7 +350,7 @@ class EventQueueProcessorBase {
     });
     if (invalidAttempts.length) {
       await tx.run(
-        UPDATE.entity(this.__eventQueueConfig.tableNameEventQueue)
+        UPDATE.entity(this.#config.tableNameEventQueue)
           .set({
             status: EventProcessingStatus.Open,
             lastAttemptTimestamp: new Date().toISOString(),
@@ -365,7 +371,7 @@ class EventQueueProcessorBase {
         continue;
       }
       await tx.run(
-        UPDATE.entity(this.__eventQueueConfig.tableNameEventQueue)
+        UPDATE.entity(this.#config.tableNameEventQueue)
           .set({
             status: status,
             lastAttemptTimestamp: ts,
@@ -374,8 +380,8 @@ class EventQueueProcessorBase {
       );
     }
     this.logger.debug("exiting persistEventStatus", {
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
   }
 
@@ -384,18 +390,18 @@ class EventQueueProcessorBase {
       return;
     }
     const deleteCount = await tx.run(
-      DELETE.from(this.__eventQueueConfig.tableNameEventQueue).where(
+      DELETE.from(this.#config.tableNameEventQueue).where(
         "type =",
-        this.eventType,
+        this.#eventType,
         "AND subType=",
-        this.eventSubType,
+        this.#eventSubType,
         "AND lastAttemptTimestamp <=",
         new Date(Date.now() - this.__deleteFinishedEventsAfter * DAYS_TO_MS).toISOString()
       )
     );
     this.logger.debug("Deleted finished events", {
-      eventType: this.eventType,
-      eventSubType: this.eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
       deleteFinishedEventsAfter: this.__deleteFinishedEventsAfter,
       deleteCount,
     });
@@ -407,8 +413,8 @@ class EventQueueProcessorBase {
         return;
       }
       this.logger.error("Missing status for selected event entry. Setting status to error", {
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
         queueEntry,
       });
       this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error);
@@ -429,8 +435,8 @@ class EventQueueProcessorBase {
       }
 
       this.logger.error("Not allowed event status returned. Only Open, Done, Error is allowed!", {
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
         queueEntryId,
         status: statusMap[queueEntryId],
       });
@@ -447,8 +453,8 @@ class EventQueueProcessorBase {
       this.logger.error(
         "Status reported for event queue entry which haven't be selected before. Removing the status.",
         {
-          eventType: this.__eventType,
-          eventSubType: this.__eventSubType,
+          eventType: this.#eventType,
+          eventSubType: this.#eventSubType,
           queueEntryId,
         }
       );
@@ -458,8 +464,8 @@ class EventQueueProcessorBase {
 
   handleErrorDuringClustering(error) {
     this.logger.error(`Error during clustering of events - setting all queue entries to error. Error: ${error}`, {
-      eventType: this.__eventType,
-      eventSubType: this.__eventSubType,
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
     });
     this.__queueEntries.forEach((queueEntry) => {
       this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error);
@@ -471,21 +477,13 @@ class EventQueueProcessorBase {
       "Undefined payload is not allowed. If status should be done, nulls needs to be returned" +
         " - setting queue entry to error",
       {
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
       }
     );
     this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error);
   }
 
-  static async handleMissingTypeImplementation(context, eventType, eventSubType) {
-    const baseInstance = new EventQueueProcessorBase(context, eventType, eventSubType);
-    baseInstance.logger.error("No Implementation found in the provided configuration file.", {
-      eventType,
-      eventSubType,
-    });
-  }
-
   /**
    * This function selects all relevant events based on the eventType and eventSubType supplied through the constructor
    * during initialization of the class.
@@ -495,17 +493,20 @@ class EventQueueProcessorBase {
    */
   async getQueueEntriesAndSetToInProgress() {
     let result = [];
+    const refDateStartAfter = new Date(Date.now() + this.#config.runInterval);
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
       const entries = await tx.run(
-        SELECT.from(this.__eventQueueConfig.tableNameEventQueue)
-          .forUpdate({ wait: this.__eventQueueConfig.forUpdateTimeout })
+        SELECT.from(this.#config.tableNameEventQueue)
+          .forUpdate({ wait: this.#config.forUpdateTimeout })
           .limit(this.selectMaxChunkSize)
           .where(
             "type =",
-            this.__eventType,
+            this.#eventType,
             "AND subType=",
-            this.__eventSubType,
-            "AND ( status =",
+            this.#eventSubType,
+            "AND ( startAfter IS NULL OR startAfter <=",
+            refDateStartAfter.toISOString(),
+            " ) AND ( status =",
             EventProcessingStatus.Open,
             "OR ( status =",
             EventProcessingStatus.Error,
@@ -514,7 +515,7 @@ class EventQueueProcessorBase {
             ") OR ( status =",
             EventProcessingStatus.InProgress,
             "AND lastAttemptTimestamp <=",
-            new Date(new Date().getTime() - this.__eventQueueConfig.globalTxTimeout).toISOString(),
+            new Date(new Date().getTime() - this.#config.globalTxTimeout).toISOString(),
             ") )"
           )
           .orderBy("createdAt", "ID")
@@ -522,37 +523,44 @@ class EventQueueProcessorBase {
 
       if (!entries.length) {
         this.logger.debug("no entries available for processing", {
-          eventType: this.__eventType,
-          eventSubType: this.__eventSubType,
+          eventType: this.#eventType,
+          eventSubType: this.#eventSubType,
         });
         this.__emptyChunkSelected = true;
         return;
       }
 
-      this.#selectedEventMap = arrayToFlatMap(entries);
-      const { exceededTries, openEvents, exceededTriesExceeded } = this.#filterExceededEvents(entries);
+      const { exceededTries, openEvents, exceededTriesExceeded, delayedEvents } = this.#clusterEvents(
+        entries,
+        refDateStartAfter
+      );
+      const eventsForProcessing = exceededTries.concat(openEvents).concat(exceededTriesExceeded);
+      this.#selectedEventMap = arrayToFlatMap(eventsForProcessing);
       if (exceededTries.length) {
         this.#eventsWithExceededTries = exceededTries;
       }
       if (exceededTriesExceeded.length) {
         this.#exceededTriesExceeded = exceededTriesExceeded;
       }
+      this.#handleDelayedEvents(delayedEvents);
 
       result = openEvents;
+      this.logger.info("Selected event queue entries for processing", {
+        openEvents: openEvents.length,
+        ...(delayedEvents.length && { delayedEvents: delayedEvents.length }),
+        ...(exceededTries.length && { exceededTries: exceededTries.length }),
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+      });
 
-      if (!result.length) {
+      if (!eventsForProcessing.length) {
         this.__emptyChunkSelected = true;
+        return;
       }
 
-      this.logger.info("Selected event queue entries for processing", {
-        queueEntriesCount: result.length,
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
-      });
-
       const isoTimestamp = new Date().toISOString();
       await tx.run(
-        UPDATE.entity(this.__eventQueueConfig.tableNameEventQueue)
+        UPDATE.entity(this.#config.tableNameEventQueue)
           .with({
             status: EventProcessingStatus.InProgress,
             lastAttemptTimestamp: isoTimestamp,
@@ -560,10 +568,10 @@ class EventQueueProcessorBase {
           })
           .where(
             "ID IN",
-            entries.map(({ ID }) => ID)
+            eventsForProcessing.map(({ ID }) => ID)
           )
       );
-      entries.forEach((entry) => {
+      eventsForProcessing.forEach((entry) => {
         entry.lastAttemptTimestamp = isoTimestamp;
         // NOTE: empty payloads are supported on DB-Level.
         // Behaviour of event queue is: null as payload is treated as obsolete/done
@@ -578,22 +586,45 @@ class EventQueueProcessorBase {
     return result;
   }
 
-  #filterExceededEvents(events) {
+  #handleDelayedEvents(delayedEvents) {
+    const eventSchedulerInstance = eventScheduler.getInstance();
+    for (const delayedEvent of delayedEvents) {
+      eventSchedulerInstance.scheduleEvent(
+        this.__context.tenant,
+        this.#eventType,
+        this.#eventSubType,
+        delayedEvent.startAfter
+      );
+    }
+  }
+
+  #clusterEvents(events, refDateStartAfter) {
+    const refDate = new Date(refDateStartAfter.getTime() - this.#config.runInterval + EVENT_START_AFTER_HEADROOM);
     return events.reduce(
       (result, event) => {
         if (event.attempts === this.__retryAttempts + TRIES_FOR_EXCEEDED_EVENTS) {
           result.exceededTriesExceeded.push(event);
         } else if (event.attempts >= this.__retryAttempts) {
           result.exceededTries.push(event);
+        } else if (this.#isDelayedEvent(event, refDate)) {
+          result.delayedEvents.push(event);
         } else {
           result.openEvents.push(event);
         }
         return result;
       },
-      { exceededTries: [], openEvents: [], exceededTriesExceeded: [] }
+      { exceededTries: [], openEvents: [], exceededTriesExceeded: [], delayedEvents: [] }
     );
   }
 
+  #isDelayedEvent(event, refDate) {
+    if (!event.startAfter) {
+      return false;
+    }
+    event.startAfter = new Date(event.startAfter);
+    return !(refDate >= event.startAfter);
+  }
+
   async handleExceededEvents() {
     await this.#handleExceededTriesExceeded();
     if (!this.#eventsWithExceededTries.length) {
@@ -603,15 +634,15 @@ class EventQueueProcessorBase {
     for (const exceededEvent of this.#eventsWithExceededTries) {
       await executeInNewTransaction(
         this.context,
-        `eventQueue-handleExceededEvents-${this.eventType}##${this.eventSubType}`,
+        `eventQueue-handleExceededEvents-${this.#eventType}##${this.#eventSubType}`,
         async (tx) => {
           try {
             this.processEventContext = tx.context;
             this.modifyQueueEntry(exceededEvent);
             await this.hookForExceededEvents({ ...exceededEvent });
             this.logger.warn("The retry attempts for the following events are exceeded", {
-              eventType: this.__eventType,
-              eventSubType: this.__eventSubType,
+              eventType: this.#eventType,
+              eventSubType: this.#eventSubType,
               retryAttempts: this.__retryAttempts,
               queueEntriesId: exceededEvent.ID,
               currentAttempt: exceededEvent.attempts,
@@ -621,8 +652,8 @@ class EventQueueProcessorBase {
             this.logger.error(
               `Caught error during hook for exceeded events - setting queue entry to error. Please catch your promises/exceptions. Error: ${err}`,
               {
-                eventType: this.__eventType,
-                eventSubType: this.__eventSubType,
+                eventType: this.#eventType,
+                eventSubType: this.#eventSubType,
                 retryAttempts: this.__retryAttempts,
                 queueEntriesId: exceededEvent.ID,
                 currentAttempt: exceededEvent.attempts,
@@ -641,8 +672,8 @@ class EventQueueProcessorBase {
   async #handleExceededTriesExceeded() {
     if (this.#exceededTriesExceeded.length) {
       this.logger.error("Event hook failure exceeded, status set to 'exceeded' without invoking hook again!", {
-        eventType: this.__eventType,
-        eventSubType: this.__eventSubType,
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
         queueEntriesIds: this.#eventsWithExceededTries.map(({ ID }) => ID),
       });
       await executeInNewTransaction(this.context, "exceededTriesExceeded", async (tx) => {
@@ -705,8 +736,8 @@ class EventQueueProcessorBase {
     const checkAndUpdatePromise = new Promise((resolve, reject) => {
       executeInNewTransaction(this.__baseContext, "eventProcessing-isOutdatedAndKeepalive", async (tx) => {
         const queueEntriesFresh = await tx.run(
-          SELECT.from(this.__eventQueueConfig.tableNameEventQueue)
-            .forUpdate({ wait: this.__eventQueueConfig.forUpdateTimeout })
+          SELECT.from(this.#config.tableNameEventQueue)
+            .forUpdate({ wait: this.#config.forUpdateTimeout })
             .where(
               "ID IN",
               queueEntries.map(({ ID }) => ID)
@@ -720,7 +751,7 @@ class EventQueueProcessorBase {
         let newTs = new Date().toISOString();
         if (!eventOutdated) {
           await tx.run(
-            UPDATE.entity(this.__eventQueueConfig.tableNameEventQueue)
+            UPDATE.entity(this.#config.tableNameEventQueue)
               .set("lastAttemptTimestamp =", newTs)
               .where(
                 "ID IN",
@@ -730,8 +761,8 @@ class EventQueueProcessorBase {
         } else {
           newTs = null;
           this.logger.warn("event data has been modified. Processing skipped.", {
-            eventType: this.__eventType,
-            eventSubType: this.__eventSubType,
+            eventType: this.#eventType,
+            eventSubType: this.#eventSubType,
             queueEntriesIds: queueEntries.map(({ ID }) => ID),
           });
           queueEntries.forEach(({ ID: queueEntryId }) => delete this.__queueEntriesMap[queueEntryId]);
@@ -761,7 +792,7 @@ class EventQueueProcessorBase {
 
     const lockAcquired = await distributedLock.acquireLock(
       this.context,
-      [this.eventType, this.eventSubType].join("##")
+      [this.#eventType, this.#eventSubType].join("##")
     );
     if (!lockAcquired) {
       return false;
@@ -775,7 +806,7 @@ class EventQueueProcessorBase {
       return;
     }
     try {
-      await distributedLock.releaseLock(this.context, [this.eventType, this.eventSubType].join("##"));
+      await distributedLock.releaseLock(this.context, [this.#eventType, this.#eventSubType].join("##"));
     } catch (err) {
       this.logger.error("Releasing distributed lock failed. Error:", err.toString());
     }
@@ -822,14 +853,14 @@ class EventQueueProcessorBase {
 
   get tx() {
     if (!this.__txUsageAllowed && this.__parallelEventProcessing > 1) {
-      throw EventQueueError.wrongTxUsage(this.eventType, this.eventSubType);
+      throw EventQueueError.wrongTxUsage(this.#eventType, this.#eventSubType);
     }
     return this.__processTx ?? this.__tx;
   }
 
   get context() {
     if (!this.__txUsageAllowed && this.__parallelEventProcessing > 1) {
-      throw EventQueueError.wrongTxUsage(this.eventType, this.eventSubType);
+      throw EventQueueError.wrongTxUsage(this.#eventType, this.#eventSubType);
     }
     return this.__processContext ?? this.__context;
   }
@@ -847,11 +878,11 @@ class EventQueueProcessorBase {
   }
 
   get eventType() {
-    return this.__eventType;
+    return this.#eventType;
   }
 
   get eventSubType() {
-    return this.__eventSubType;
+    return this.#eventSubType;
   }
 
   get emptyChunkSelected() {

package/src/config.js

@@ -13,38 +13,56 @@ const REDIS_CONFIG_CHANNEL = "EVENT_QUEUE_CONFIG_CHANNEL";
 const COMPONENT_NAME = "eventQueue/config";
 
 class Config {
+  #logger;
+  #config;
+  #forUpdateTimeout;
+  #globalTxTimeout;
+  #runInterval;
+  #redisEnabled;
+  #initialized;
+  #parallelTenantProcessing;
+  #tableNameEventQueue;
+  #tableNameEventLock;
+  #isRunnerDeactivated;
+  #configFilePath;
+  #processEventsAfterPublish;
+  #skipCsnCheck;
+  #disableRedis;
+  #env;
+  #eventMap;
   constructor() {
-    this.__logger = cds.log(COMPONENT_NAME);
-    this.__config = null;
-    this.__forUpdateTimeout = FOR_UPDATE_TIMEOUT;
-    this.__globalTxTimeout = GLOBAL_TX_TIMEOUT;
-    this.__runInterval = null;
-    this.__redisEnabled = null;
-    this.__initialized = false;
-    this.__parallelTenantProcessing = null;
-    this.__tableNameEventQueue = null;
-    this.__tableNameEventLock = null;
-    this.__isRunnerDeactivated = false;
-    this.__configFilePath = null;
-    this.__processEventsAfterPublish = null;
-    this.__skipCsnCheck = null;
-    this.__env = getEnvInstance();
+    this.#logger = cds.log(COMPONENT_NAME);
+    this.#config = null;
+    this.#forUpdateTimeout = FOR_UPDATE_TIMEOUT;
+    this.#globalTxTimeout = GLOBAL_TX_TIMEOUT;
+    this.#runInterval = null;
+    this.#redisEnabled = null;
+    this.#initialized = false;
+    this.#parallelTenantProcessing = null;
+    this.#tableNameEventQueue = null;
+    this.#tableNameEventLock = null;
+    this.#isRunnerDeactivated = false;
+    this.#configFilePath = null;
+    this.#processEventsAfterPublish = null;
+    this.#skipCsnCheck = null;
+    this.#disableRedis = null;
+    this.#env = getEnvInstance();
   }
 
   getEventConfig(type, subType) {
-    return this.__eventMap[[type, subType].join("##")];
+    return this.#eventMap[[type, subType].join("##")];
   }
 
   hasEventAfterCommitFlag(type, subType) {
-    return this.__eventMap[[type, subType].join("##")]?.processAfterCommit ?? true;
+    return this.#eventMap[[type, subType].join("##")]?.processAfterCommit ?? true;
   }
 
   _checkRedisIsBound() {
-    return !!this.__env.getRedisCredentialsFromEnv();
+    return !!this.#env.getRedisCredentialsFromEnv();
   }
 
   checkRedisEnabled() {
-    this.__redisEnabled = this._checkRedisIsBound() && this.__env.isOnCF;
+    this.#redisEnabled = !this.#disableRedis && this._checkRedisIsBound() && this.#env.isOnCF;
   }
 
   attachConfigChangeHandler() {
@@ -52,11 +70,11 @@ class Config {
       try {
         const { key, value } = JSON.parse(messageData);
         if (this[key] !== value) {
-          this.__logger.info("received config change", { key, value });
+          this.#logger.info("received config change", { key, value });
           this[key] = value;
         }
       } catch (err) {
-        this.__logger.error("could not parse event config change", {
+        this.#logger.error("could not parse event config change", {
           messageData,
         });
       }
@@ -65,124 +83,132 @@ class Config {
 
   publishConfigChange(key, value) {
     if (!this.redisEnabled) {
-      this.__logger.info("redis not connected, config change won't be published", { key, value });
+      this.#logger.info("redis not connected, config change won't be published", { key, value });
       return;
     }
     redis.publishMessage(REDIS_CONFIG_CHANNEL, JSON.stringify({ key, value })).catch((error) => {
-      this.__logger.error(`publishing config change failed key: ${key}, value: ${value}`, error);
+      this.#logger.error(`publishing config change failed key: ${key}, value: ${value}`, error);
     });
   }
 
   get isRunnerDeactivated() {
-    return this.__isRunnerDeactivated;
+    return this.#isRunnerDeactivated;
   }
 
   set isRunnerDeactivated(value) {
-    this.__isRunnerDeactivated = value;
+    this.#isRunnerDeactivated = value;
   }
 
   set fileContent(config) {
-    this.__config = config;
-    this.__eventMap = config.events.reduce((result, event) => {
+    this.#config = config;
+    this.#eventMap = config.events.reduce((result, event) => {
       result[[event.type, event.subType].join("##")] = event;
       return result;
     }, {});
   }
 
   get fileContent() {
-    return this.__config;
+    return this.#config;
   }
 
   get events() {
-    return this.__config.events;
+    return this.#config.events;
   }
 
   get forUpdateTimeout() {
-    return this.__forUpdateTimeout;
+    return this.#forUpdateTimeout;
   }
 
   get globalTxTimeout() {
-    return this.__globalTxTimeout;
+    return this.#globalTxTimeout;
   }
 
   set forUpdateTimeout(value) {
-    this.__forUpdateTimeout = value;
+    this.#forUpdateTimeout = value;
   }
 
   set globalTxTimeout(value) {
-    this.__globalTxTimeout = value;
+    this.#globalTxTimeout = value;
   }
 
   get runInterval() {
-    return this.__runInterval;
+    return this.#runInterval;
   }
 
   set runInterval(value) {
-    this.__runInterval = value;
+    this.#runInterval = value;
   }
 
   get redisEnabled() {
-    return this.__redisEnabled;
+    return this.#redisEnabled;
   }
 
   set redisEnabled(value) {
-    this.__redisEnabled = value;
+    this.#redisEnabled = value;
   }
 
   get initialized() {
-    return this.__initialized;
+    return this.#initialized;
   }
 
   set initialized(value) {
-    this.__initialized = value;
+    this.#initialized = value;
   }
 
   get parallelTenantProcessing() {
-    return this.__parallelTenantProcessing;
+    return this.#parallelTenantProcessing;
   }
 
   set parallelTenantProcessing(value) {
-    this.__parallelTenantProcessing = value;
+    this.#parallelTenantProcessing = value;
   }
 
   get tableNameEventQueue() {
-    return this.__tableNameEventQueue;
+    return this.#tableNameEventQueue;
   }
 
   set tableNameEventQueue(value) {
-    this.__tableNameEventQueue = value;
+    this.#tableNameEventQueue = value;
   }
 
   get tableNameEventLock() {
-    return this.__tableNameEventLock;
+    return this.#tableNameEventLock;
   }
 
   set tableNameEventLock(value) {
-    this.__tableNameEventLock = value;
+    this.#tableNameEventLock = value;
   }
 
   set configFilePath(value) {
-    this.__configFilePath = value;
+    this.#configFilePath = value;
   }
 
   get configFilePath() {
-    return this.__configFilePath;
+    return this.#configFilePath;
   }
 
   set processEventsAfterPublish(value) {
-    this.__processEventsAfterPublish = value;
+    this.#processEventsAfterPublish = value;
   }
 
   get processEventsAfterPublish() {
-    return this.__processEventsAfterPublish;
+    return this.#processEventsAfterPublish;
   }
 
   set skipCsnCheck(value) {
-    this.__skipCsnCheck = value;
+    this.#skipCsnCheck = value;
   }
 
   get skipCsnCheck() {
-    return this.__skipCsnCheck;
+    return this.#skipCsnCheck;
+  }
+
+  set disableRedis(value) {
+    this.#disableRedis = value;
+  }
+
+  get disableRedis() {
+    return this.#disableRedis;
   }
 
   get isMultiTenancy() {

package/src/dbHandler.js

@@ -1,8 +1,12 @@
 "use strict";
 
-const { publishEvent } = require("./redisPubSub");
+const cds = require("@sap/cds");
+
+const { broadcastEvent } = require("./redisPubSub");
 const config = require("./config");
 
+const COMPONENT_NAME = "eventQueue/dbHandler";
+
 const registerEventQueueDbHandler = (dbService) => {
   const configInstance = config.getConfigInstance();
   const def = dbService.model.definitions[configInstance.tableNameEventQueue];
@@ -26,7 +30,12 @@ const registerEventQueueDbHandler = (dbService) => {
     eventCombinations.length &&
       req.on("succeeded", () => {
         for (const eventCombination of eventCombinations) {
-          publishEvent(req.tenant, ...eventCombination.split("##"));
+          broadcastEvent(req.tenant, ...eventCombination.split("##")).catch((err) => {
+            cds.log(COMPONENT_NAME).error("db handler failure during broadcasting event", err, {
+              tenant: req.tenant,
+              eventCombination,
+            });
+          });
         }
       });
   });

package/src/initialize.js

@@ -5,7 +5,6 @@ const fs = require("fs");
 const path = require("path");
 
 const cds = require("@sap/cds");
-
 const yaml = require("yaml");
 const VError = require("verror");
 
@@ -23,6 +22,18 @@ const BASE_TABLES = {
   EVENT: "sap.eventqueue.Event",
   LOCK: "sap.eventqueue.Lock",
 };
+const CONFIG_VARS = [
+  ["configFilePath", null],
+  ["registerAsEventProcessor", true],
+  ["processEventsAfterPublish", true],
+  ["isRunnerDeactivated", false],
+  ["runInterval", 5 * 60 * 1000],
+  ["parallelTenantProcessing", 5],
+  ["tableNameEventQueue", BASE_TABLES.EVENT],
+  ["tableNameEventLock", BASE_TABLES.LOCK],
+  ["disableRedis", false],
+  ["skipCsnCheck", false],
+];
 
 const initialize = async ({
   configFilePath,
@@ -33,6 +44,7 @@ const initialize = async ({
   parallelTenantProcessing,
   tableNameEventQueue,
   tableNameEventLock,
+  disableRedis,
   skipCsnCheck,
 } = {}) => {
   // TODO: initialize check:
@@ -54,6 +66,7 @@ const initialize = async ({
     parallelTenantProcessing,
     tableNameEventQueue,
     tableNameEventLock,
+    disableRedis,
     skipCsnCheck
   );
 
@@ -160,32 +173,12 @@ const checkCustomTable = (baseCsn, customCsn) => {
   }
 };
 
-const mixConfigVarsWithEnv = (
-  configFilePath,
-  registerAsEventProcessor,
-  processEventsAfterPublish,
-  isRunnerDeactivated,
-  runInterval,
-  parallelTenantProcessing,
-  tableNameEventQueue,
-  tableNameEventLock,
-  skipCsnCheck
-) => {
+const mixConfigVarsWithEnv = (...args) => {
   const configInstance = getConfigInstance();
-
-  configInstance.configFilePath = configFilePath ?? cds.env.eventQueue?.configFilePath;
-  configInstance.registerAsEventProcessor =
-    registerAsEventProcessor ?? cds.env.eventQueue?.registerAsEventProcessor ?? true;
-  configInstance.isRunnerDeactivated = isRunnerDeactivated ?? cds.env.eventQueue?.isRunnerDeactivated ?? false;
-  configInstance.processEventsAfterPublish =
-    processEventsAfterPublish ?? cds.env.eventQueue?.processEventsAfterPublish ?? true;
-  configInstance.runInterval = runInterval ?? cds.env.eventQueue?.runInterval ?? 5 * 60 * 1000;
-  configInstance.parallelTenantProcessing =
-    parallelTenantProcessing ?? cds.env.eventQueue?.parallelTenantProcessing ?? 5;
-  configInstance.tableNameEventQueue =
-    tableNameEventQueue ?? cds.env.eventQueue?.tableNameEventQueue ?? BASE_TABLES.EVENT;
-  configInstance.tableNameEventLock = tableNameEventLock ?? cds.env.eventQueue?.tableNameEventLock ?? BASE_TABLES.LOCK;
-  configInstance.skipCsnCheck = skipCsnCheck ?? cds.env.eventQueue?.skipCsnCheck ?? false;
+  CONFIG_VARS.forEach(([configName, defaultValue], index) => {
+    const configValue = args[index];
+    configInstance[configName] = configValue ?? cds.env.eventQueue?.[configName] ?? defaultValue;
+  });
 };
 
 module.exports = {

package/src/processEventQueue.js

@@ -8,7 +8,6 @@ const { getConfigInstance } = require("./config");
 const { TransactionMode } = require("./constants");
 const { limiter, Funnel } = require("./shared/common");
 
-const EventQueueBase = require("./EventQueueProcessorBase");
 const { executeInNewTransaction, TriggerRollback } = require("./shared/cdsHelper");
 
 const COMPONENT_NAME = "eventQueue/processEventQueue";
@@ -33,7 +32,10 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
     const eventConfig = getConfigInstance().getEventConfig(eventType, eventSubType);
     const [err, EventTypeClass] = resilientRequire(eventConfig?.impl);
     if (!eventConfig || err || !(typeof EventTypeClass.constructor === "function")) {
-      await EventQueueBase.handleMissingTypeImplementation(context, eventType, eventSubType);
+      cds.log(COMPONENT_NAME).error("No Implementation found in the provided configuration file.", {
+        eventType,
+        eventSubType,
+      });
       return;
     }
     baseInstance = new EventTypeClass(context, eventType, eventSubType, eventConfig);

package/src/publishEvent.js

@@ -1,19 +1,45 @@
 "use strict";
 
 const config = require("./config");
+const common = require("./shared/common");
 const EventQueueError = require("./EventQueueError");
 
+/**
+ * Asynchronously publishes a series of events to the event queue.
+ *
+ * @param {Transaction} tx - The transaction object to be used for database operations.
+ * @param {Array|Object} events - An array of event objects or a single event object. Each event object should match the Event table structure:
+ *   {
+ *     type: String, // Event type. This is a required field.
+ *     subType: String, // Event subtype. This is a required field.
+ *     referenceEntity: String, // Reference entity associated with the event.
+ *     referenceEntityKey: UUID, // UUID key of the reference entity.
+ *     status: Status, // Status of the event, defaults to 0.
+ *     payload: LargeString, // Payload of the event.
+ *     attempts: Integer, // The number of attempts made, defaults to 0.
+ *     lastAttemptTimestamp: Timestamp, // Timestamp of the last attempt.
+ *     createdAt: Timestamp, // Timestamp of event creation. This field is automatically set on insert.
+ *     startAfter: Timestamp, // Timestamp indicating when the event should start after.
+ *   }
+ * @throws {EventQueueError} Throws an error if the configuration is not initialized.
+ * @throws {EventQueueError} Throws an error if the event type is unknown.
+ * @throws {EventQueueError} Throws an error if the startAfter field is not a valid date.
+ * @returns {Promise} Returns a promise which resolves to the result of the database insert operation.
+ */
 const publishEvent = async (tx, events) => {
   const configInstance = config.getConfigInstance();
   if (!configInstance.initialized) {
     throw EventQueueError.notInitialized();
   }
   const eventsForProcessing = Array.isArray(events) ? events : [events];
-  for (const { type, subType } of eventsForProcessing) {
+  for (const { type, subType, startAfter } of eventsForProcessing) {
     const eventConfig = configInstance.getEventConfig(type, subType);
     if (!eventConfig) {
       throw EventQueueError.unknownEventType(type, subType);
     }
+    if (startAfter && !common.isValidDate(startAfter)) {
+      throw EventQueueError.malformedDate(startAfter);
+    }
   }
   return await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(eventsForProcessing));
 };

package/src/redisPubSub.js

@@ -1,11 +1,9 @@
 "use strict";
 
 const redis = require("./shared/redis");
-const { processEventQueue } = require("./processEventQueue");
-const { getSubdomainForTenantId } = require("./shared/cdsHelper");
 const { checkLockExistsAndReturnValue } = require("./shared/distributedLock");
 const config = require("./config");
-const { getWorkerPoolInstance } = require("./shared/WorkerQueue");
+const { runEventCombinationForTenant } = require("./runner");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "eventQueue/redisPubSub";
@@ -23,19 +21,12 @@ const messageHandlerProcessEvents = async (messageData) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
     const { tenantId, type, subType } = JSON.parse(messageData);
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const context = new cds.EventContext({
-      tenant: tenantId,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-    });
-    cds.context = context;
     logger.debug("received redis event", {
       tenantId,
       type,
       subType,
     });
-    getWorkerPoolInstance().addToQueue(async () => processEventQueue(context, type, subType));
+    await runEventCombinationForTenant(tenantId, type, subType);
   } catch (err) {
     logger.error("could not parse event information", {
       messageData,
@@ -43,12 +34,12 @@ const messageHandlerProcessEvents = async (messageData) => {
   }
 };
 
-const publishEvent = async (tenantId, type, subType) => {
+const broadcastEvent = async (tenantId, type, subType) => {
   const logger = cds.log(COMPONENT_NAME);
   const configInstance = config.getConfigInstance();
   if (!configInstance.redisEnabled) {
     if (configInstance.registerAsEventProcessor) {
-      await _handleEventInternally(tenantId, type, subType);
+      await runEventCombinationForTenant(tenantId, type, subType);
     }
     return;
   }
@@ -76,22 +67,7 @@ const publishEvent = async (tenantId, type, subType) => {
   }
 };
 
-const _handleEventInternally = async (tenantId, type, subType) => {
-  cds.log(COMPONENT_NAME).info("processEventQueue internally", {
-    tenantId,
-    type,
-    subType,
-  });
-  const subdomain = await getSubdomainForTenantId(tenantId);
-  const context = new cds.EventContext({
-    tenant: tenantId,
-    // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-    http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-  });
-  getWorkerPoolInstance().addToQueue(async () => processEventQueue(context, type, subType));
-};
-
 module.exports = {
   initEventQueueRedisSubscribe,
-  publishEvent,
+  broadcastEvent,
 };

package/src/runner.js

@@ -3,11 +3,12 @@
 const { randomUUID } = require("crypto");
 
 const eventQueueConfig = require("./config");
-const { eventQueueRunner } = require("./processEventQueue");
+const { eventQueueRunner, processEventQueue } = require("./processEventQueue");
 const { getWorkerPoolInstance } = require("./shared/WorkerQueue");
 const cdsHelper = require("./shared/cdsHelper");
 const distributedLock = require("./shared/distributedLock");
 const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
+const { getSubdomainForTenantId } = require("./shared/cdsHelper");
 
 const COMPONENT_NAME = "eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
@@ -190,10 +191,31 @@ const _calculateOffsetForFirstRun = async () => {
   return offsetDependingOnLastRun;
 };
 
+const runEventCombinationForTenant = async (tenantId, type, subType) => {
+  try {
+    const subdomain = await getSubdomainForTenantId(tenantId);
+    const context = new cds.EventContext({
+      tenant: tenantId,
+      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
+      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
+    });
+    cds.context = context;
+    getWorkerPoolInstance().addToQueue(async () => await processEventQueue(context, type, subType));
+  } catch (err) {
+    const logger = cds.log(COMPONENT_NAME);
+    logger.error("error executing event combination for tenant", err, {
+      tenantId,
+      type,
+      subType,
+    });
+  }
+};
+
 module.exports = {
   singleTenant,
   multiTenancyDb,
   multiTenancyRedis,
+  runEventCombinationForTenant,
   _: {
     _multiTenancyRedis,
     _multiTenancyDb,

package/src/shared/EventScheduler.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const { broadcastEvent } = require("../redisPubSub");
+
+const COMPONENT_NAME = "eventQueue/shared/EventScheduler";
+
+let instance;
+class EventScheduler {
+  #scheduledEvents = {};
+  constructor() {}
+
+  scheduleEvent(tenantId, type, subType, startAfter) {
+    const startAfterSeconds = startAfter.getSeconds();
+    const secondsUntilNextTen = 10 - (startAfterSeconds % 10);
+    const roundUpDate = new Date(startAfter.getTime() + secondsUntilNextTen * 1000);
+    const key = [tenantId, type, subType, roundUpDate.toISOString()].join("##");
+    if (this.#scheduledEvents[key]) {
+      return; // event combination already scheduled
+    }
+    this.#scheduledEvents[key] = true;
+    cds.log(COMPONENT_NAME).info("scheduling event queue run for delayed event", {
+      type,
+      subType,
+      delaySeconds: (roundUpDate.getTime() - Date.now()) / 1000,
+    });
+    setTimeout(() => {
+      delete this.#scheduledEvents[key];
+      broadcastEvent(tenantId, type, subType).catch((err) => {
+        cds.log(COMPONENT_NAME).error("could not execute scheduled event", err, {
+          tenantId,
+          type,
+          subType,
+          scheduledFor: roundUpDate.toISOString(),
+        });
+      });
+    }, roundUpDate.getTime() - Date.now()).unref();
+  }
+
+  clearScheduledEvents() {
+    this.#scheduledEvents = {};
+  }
+}
+
+module.exports = {
+  getInstance: () => {
+    if (!instance) {
+      instance = new EventScheduler();
+    }
+    return instance;
+  },
+};

package/src/shared/common.js

@@ -107,4 +107,15 @@ const limiter = async (limit, payloads, iterator) => {
   return Promise.allSettled(returnPromises);
 };
 
-module.exports = { arrayToFlatMap, Funnel, limiter };
+const isValidDate = (value) => {
+  if (typeof value === "string") {
+    const date = Date.parse(value);
+    return !isNaN(date);
+  } else if (value instanceof Date) {
+    return !isNaN(value.getTime());
+  } else {
+    return false;
+  }
+};
+
+module.exports = { arrayToFlatMap, Funnel, limiter, isValidDate };