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

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@cap-js-community/event-queue)](https://www.npmjs.com/package/@cap-js-community/event-queue)
 [![monthly downloads](https://img.shields.io/npm/dm/@cap-js-community/event-queue)](https://www.npmjs.com/package/@cap-js-community/event-queue)
 [![REUSE status](https://api.reuse.software/badge/github.com/cap-js-community/event-queue)](https://api.reuse.software/info/github.com/cap-js-community/event-queue)
-[![CI Main](https://github.com/cap-js-community/event-queue/actions/workflows/ci-main.yml/badge.svg)](https://github.com/cap-js-community/event-queue/commits/main)
+[![CI Main](https://github.com/cap-js-community/event-queue/actions/workflows/main-ci.yml/badge.svg)](https://github.com/cap-js-community/event-queue/commits/main)
 
 The Event-Queue is a framework built on top of CAP Node.js, specifically designed to enable efficient and streamlined
 asynchronous event processing in a multi-tenancy environment. With a strong emphasis on load balancing, this package

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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": [

package/src/EventQueueError.js

@@ -12,6 +12,10 @@ const ERROR_CODES = {
   MISSING_ELEMENT_IN_TABLE: "MISSING_ELEMENT_IN_TABLE",
   TYPE_MISMATCH_TABLE: "TYPE_MISMATCH_TABLE",
   NO_VALID_DATE: "NO_VALID_DATE",
+  INVALID_INTERVAL: "INVALID_INTERVAL",
+  MISSING_IMPL: "MISSING_IMPL",
+  DUPLICATE_EVENT_REGISTRATION: "DUPLICATE_EVENT_REGISTRATION",
+  NO_MANUEL_INSERT_OF_PERIODIC: "NO_MANUEL_INSERT_OF_PERIODIC",
 };
 
 const ERROR_CODES_META = {
@@ -43,6 +47,18 @@ const ERROR_CODES_META = {
   [ERROR_CODES.NO_VALID_DATE]: {
     message: "One or more events contain a date in a malformed format.",
   },
+  [ERROR_CODES.INVALID_INTERVAL]: {
+    message: "Invalid interval, the value needs to greater than 10 seconds.",
+  },
+  [ERROR_CODES.MISSING_IMPL]: {
+    message: "Missing path to event class implementation.",
+  },
+  [ERROR_CODES.DUPLICATE_EVENT_REGISTRATION]: {
+    message: "Duplicate event registration, check the uniqueness of type and subType.",
+  },
+  [ERROR_CODES.NO_MANUEL_INSERT_OF_PERIODIC]: {
+    message: "Periodic events are managed by the framework and are not allowed to insert manually.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -146,6 +162,50 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static invalidInterval(type, subType, interval) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.INVALID_INTERVAL];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.INVALID_INTERVAL,
+        info: { type, subType, interval },
+      },
+      message
+    );
+  }
+
+  static missingImpl(type, subType) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.MISSING_IMPL];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.MISSING_IMPL,
+        info: { type, subType },
+      },
+      message
+    );
+  }
+
+  static duplicateEventRegistration(type, subType) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.DUPLICATE_EVENT_REGISTRATION];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.DUPLICATE_EVENT_REGISTRATION,
+        info: { type, subType },
+      },
+      message
+    );
+  }
+
+  static manuelPeriodicEventInsert(type, subType) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.NO_MANUEL_INSERT_OF_PERIODIC];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.NO_MANUEL_INSERT_OF_PERIODIC,
+        info: { type, subType },
+      },
+      message
+    );
+  }
 }
 
 module.exports = EventQueueError;

package/src/EventQueueProcessorBase.js

@@ -7,7 +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 eventScheduler = require("./shared/eventScheduler");
 const eventQueueConfig = require("./config");
 const PerformanceTracer = require("./shared/PerformanceTracer");
 
@@ -303,6 +303,29 @@ class EventQueueProcessorBase {
     return Object.fromEntries(queueEntries.map((queueEntry) => [queueEntry.ID, EventProcessingStatus.Error]));
   }
 
+  handleErrorDuringPeriodicEventProcessing(error, queueEntry) {
+    this.logger.error(
+      `Caught error during event periodic processing. Please catch your promises/exceptions. Error: ${error}`,
+      {
+        eventType: this.#eventType,
+        eventSubType: this.#eventSubType,
+        queueEntryId: queueEntry.ID,
+      }
+    );
+  }
+
+  async setPeriodicEventStatus(queueEntryIds) {
+    await this.tx.run(
+      UPDATE.entity(this.#config.tableNameEventQueue)
+        .set({
+          status: EventProcessingStatus.Done,
+        })
+        .where({
+          ID: queueEntryIds,
+        })
+    );
+  }
+
   /**
    * This function validates for all selected events one status has been submitted. It's also validated that only for
    * selected events a status has been submitted. Persisting the status of events is done in a dedicated database tx.
@@ -812,6 +835,47 @@ class EventQueueProcessorBase {
     }
   }
 
+  async scheduleNextPeriodEvent(queueEntry) {
+    const interval = this.__eventConfig.interval;
+    const newEvent = {
+      type: this.#eventType,
+      subType: this.#eventSubType,
+      startAfter: new Date(new Date(queueEntry.startAfter).getTime() + interval * 1000),
+    };
+    this.tx._skipEventQueueBroadcase = true;
+    await this.tx.run(INSERT.into(this.#config.tableNameEventQueue).entries({ ...newEvent }));
+    this.tx._skipEventQueueBroadcase = false;
+    if (interval < this.#config.runInterval) {
+      this.#handleDelayedEvents([newEvent]);
+    }
+  }
+
+  async handleDuplicatedPeriodicEventEntry(queueEntries) {
+    this.logger.error("More than one open events for the same configuration which is not allowed!", {
+      eventType: this.#eventType,
+      eventSubType: this.#eventSubType,
+      queueEntriesIds: queueEntries.map(({ ID }) => ID),
+    });
+
+    let queueEntryToUse;
+    const obsoleteEntries = [];
+    for (const queueEntry of queueEntries) {
+      if (!queueEntryToUse) {
+        queueEntryToUse = queueEntry;
+        continue;
+      }
+
+      if (queueEntryToUse.startAfter <= queueEntry.queueEntry) {
+        obsoleteEntries.push(queueEntryToUse);
+        queueEntryToUse = queueEntry;
+      } else {
+        obsoleteEntries.push(queueEntry);
+      }
+    }
+    await this.setPeriodicEventStatus(obsoleteEntries.map(({ ID }) => ID));
+    return queueEntryToUse;
+  }
+
   statusMapContainsError(statusMap) {
     return Object.values(statusMap).includes(EventProcessingStatus.Error);
   }
@@ -920,6 +984,10 @@ class EventQueueProcessorBase {
   setTxForEventProcessing(key, tx) {
     this.__txMap[key] = tx;
   }
+
+  get isPeriodicEvent() {
+    return this.__eventConfig.isPeriodic;
+  }
 }
 
 module.exports = EventQueueProcessorBase;

package/src/config.js

@@ -4,6 +4,7 @@ const cds = require("@sap/cds");
 
 const { getEnvInstance } = require("./shared/env");
 const redis = require("./shared/redis");
+const EventQueueError = require("./EventQueueError");
 
 let instance;
 
@@ -11,6 +12,7 @@ const FOR_UPDATE_TIMEOUT = 10;
 const GLOBAL_TX_TIMEOUT = 30 * 60 * 1000;
 const REDIS_CONFIG_CHANNEL = "EVENT_QUEUE_CONFIG_CHANNEL";
 const COMPONENT_NAME = "eventQueue/config";
+const MIN_INTERVAL_SEC = 10;
 
 class Config {
   #logger;
@@ -30,6 +32,7 @@ class Config {
   #disableRedis;
   #env;
   #eventMap;
+  #updatePeriodicEvents;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
     this.#config = null;
@@ -50,11 +53,11 @@ class Config {
   }
 
   getEventConfig(type, subType) {
-    return this.#eventMap[[type, subType].join("##")];
+    return this.#eventMap[this.generateKey(type, subType)];
   }
 
   hasEventAfterCommitFlag(type, subType) {
-    return this.#eventMap[[type, subType].join("##")]?.processAfterCommit ?? true;
+    return this.#eventMap[this.generateKey(type, subType)]?.processAfterCommit ?? true;
   }
 
   _checkRedisIsBound() {
@@ -101,10 +104,47 @@ class Config {
 
   set fileContent(config) {
     this.#config = config;
+    config.events = config.events ?? [];
+    config.periodicEvents = config.periodicEvents ?? [];
     this.#eventMap = config.events.reduce((result, event) => {
+      this.validateAdHocEvents(result, event);
       result[[event.type, event.subType].join("##")] = event;
       return result;
     }, {});
+    this.#eventMap = config.periodicEvents.reduce((result, event) => {
+      this.validatePeriodicConfig(result, event);
+      event.isPeriodic = true;
+      result[[event.type, event.subType].join("##")] = event;
+      return result;
+    }, this.#eventMap);
+  }
+
+  validatePeriodicConfig(eventMap, config) {
+    if (eventMap[this.generateKey(config.type, config.subType)]) {
+      throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
+    }
+
+    if (!config.interval || config.interval <= MIN_INTERVAL_SEC) {
+      throw EventQueueError.invalidInterval(config.type, config.subType, config.interval);
+    }
+
+    if (!config.impl) {
+      throw EventQueueError.missingImpl(config.type, config.subType);
+    }
+  }
+
+  validateAdHocEvents(eventMap, config) {
+    if (eventMap[this.generateKey(config.type, config.subType)]) {
+      throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
+    }
+
+    if (!config.impl) {
+      throw EventQueueError.missingImpl(config.type, config.subType);
+    }
+  }
+
+  generateKey(type, subType) {
+    return [type, subType].join("##");
   }
 
   get fileContent() {
@@ -115,6 +155,18 @@ class Config {
     return this.#config.events;
   }
 
+  get periodicEvents() {
+    return this.#config.periodicEvents;
+  }
+
+  isPeriodicEvent(type, subType) {
+    return this.#eventMap[this.generateKey(type, subType)]?.isPeriodic;
+  }
+
+  get allEvents() {
+    return this.#config.events.concat(this.#config.periodicEvents);
+  }
+
   get forUpdateTimeout() {
     return this.#forUpdateTimeout;
   }
@@ -211,6 +263,14 @@ class Config {
     return this.#disableRedis;
   }
 
+  set updatePeriodicEvents(value) {
+    this.#updatePeriodicEvents = value;
+  }
+
+  get updatePeriodicEvents() {
+    return this.#updatePeriodicEvents;
+  }
+
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }

package/src/dbHandler.js

@@ -11,6 +11,9 @@ const registerEventQueueDbHandler = (dbService) => {
   const configInstance = config.getConfigInstance();
   const def = dbService.model.definitions[configInstance.tableNameEventQueue];
   dbService.after("CREATE", def, (_, req) => {
+    if (req.tx._skipEventQueueBroadcase) {
+      return;
+    }
     req.tx._ = req.tx._ ?? {};
     req.tx._.eventQueuePublishEvents = req.tx._.eventQueuePublishEvents ?? {};
     const eventQueuePublishEvents = req.tx._.eventQueuePublishEvents;

package/src/initialize.js

@@ -12,7 +12,8 @@ const EventQueueError = require("./EventQueueError");
 const runner = require("./runner");
 const dbHandler = require("./dbHandler");
 const { getConfigInstance } = require("./config");
-const { initEventQueueRedisSubscribe } = require("./redisPubSub");
+const { initEventQueueRedisSubscribe, closeSubscribeClient } = require("./redisPubSub");
+const { closeMainClient } = require("./shared/redis");
 
 const readFileAsync = promisify(fs.readFile);
 
@@ -33,6 +34,7 @@ const CONFIG_VARS = [
   ["tableNameEventLock", BASE_TABLES.LOCK],
   ["disableRedis", false],
   ["skipCsnCheck", false],
+  ["updatePeriodicEvents", true],
 ];
 
 const initialize = async ({
@@ -46,6 +48,7 @@ const initialize = async ({
   tableNameEventLock,
   disableRedis,
   skipCsnCheck,
+  updatePeriodicEvents,
 } = {}) => {
   // TODO: initialize check:
   // - content of yaml check
@@ -67,7 +70,8 @@ const initialize = async ({
     tableNameEventQueue,
     tableNameEventLock,
     disableRedis,
-    skipCsnCheck
+    skipCsnCheck,
+    updatePeriodicEvents
   );
 
   const logger = cds.log(COMPONENT);
@@ -82,6 +86,7 @@ const initialize = async ({
   }
 
   registerEventProcessors();
+  registerCdsShutdown();
   logger.info("event queue initialized", {
     registerAsEventProcessor: configInstance.registerAsEventProcessor,
     multiTenancyEnabled: configInstance.isMultiTenancy,
@@ -115,17 +120,19 @@ const registerEventProcessors = () => {
     return;
   }
 
+  const errorHandler = (err) => cds.log(COMPONENT).error("error during init runner", err);
+
   if (!configInstance.isMultiTenancy) {
-    runner.singleTenant();
+    runner.singleTenant().catch(errorHandler);
     return;
   }
 
   if (configInstance.redisEnabled) {
     initEventQueueRedisSubscribe();
     configInstance.attachConfigChangeHandler();
-    runner.multiTenancyRedis();
+    runner.multiTenancyRedis().catch(errorHandler);
   } else {
-    runner.multiTenancyDb();
+    runner.multiTenancyDb().catch(errorHandler);
   }
 };
 
@@ -181,6 +188,12 @@ const mixConfigVarsWithEnv = (...args) => {
   });
 };
 
+const registerCdsShutdown = () => {
+  cds.on("shutdown", async () => {
+    await Promise.allSettled([closeMainClient(), closeSubscribeClient()]);
+  });
+};
+
 module.exports = {
   initialize,
 };

package/src/periodicEvents.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const { EventProcessingStatus } = require("./constants");
+const { processChunkedSync } = require("./shared/common");
+const { getConfigInstance } = require("./config");
+
+const COMPONENT_NAME = "eventQueue/periodicEvents";
+
+const checkAndInsertPeriodicEvents = async (context) => {
+  const tx = cds.tx(context);
+  const configInstance = getConfigInstance();
+  const baseCqn = SELECT.from(configInstance.tableNameEventQueue)
+    .where([
+      { list: [{ ref: ["type"] }, { ref: ["subType"] }] },
+      "IN",
+      {
+        list: configInstance.periodicEvents.map((periodicEvent) => ({
+          list: [{ val: periodicEvent.type }, { val: periodicEvent.subType }],
+        })),
+      },
+      "AND",
+      { ref: ["status"] },
+      "=",
+      { val: EventProcessingStatus.Open },
+    ])
+    .columns(["ID", "type", "subType", "startAfter"]);
+  const currentPeriodEvents = await tx.run(baseCqn);
+
+  if (!currentPeriodEvents.length) {
+    // fresh insert all
+    return await insertPeriodEvents(tx, configInstance.periodicEvents);
+  }
+
+  const exitingEventMap = currentPeriodEvents.reduce((result, current) => {
+    const key = _generateKey(current);
+    result[key] = current;
+    return result;
+  }, {});
+
+  const { newEvents, existingEvents } = configInstance.periodicEvents.reduce(
+    (result, event) => {
+      if (exitingEventMap[_generateKey(event)]) {
+        result.existingEvents.push(exitingEventMap[_generateKey(event)]);
+      } else {
+        result.newEvents.push(event);
+      }
+      return result;
+    },
+    { newEvents: [], existingEvents: [] }
+  );
+
+  const currentDate = new Date();
+  const exitingWithNotMatchingInterval = existingEvents.filter((existingEvent) => {
+    const config = configInstance.getEventConfig(existingEvent.type, existingEvent.subType);
+    const eventStartAfter = new Date(existingEvent.startAfter);
+    // check if to far in future
+    const dueInWithNewInterval = new Date(currentDate.getTime() + config.interval * 1000);
+    return eventStartAfter >= dueInWithNewInterval;
+  });
+
+  exitingWithNotMatchingInterval.length &&
+    cds.log(COMPONENT_NAME).info("deleting periodic events because they have changed", {
+      changedEvents: exitingWithNotMatchingInterval.map(({ type, subType }) => ({ type, subType })),
+    });
+  await tx.run(
+    DELETE.from(configInstance.tableNameEventQueue).where(
+      "ID IN",
+      exitingWithNotMatchingInterval.map(({ ID }) => ID)
+    )
+  );
+
+  const newOrChangedEvents = newEvents.concat(exitingWithNotMatchingInterval);
+
+  if (!newOrChangedEvents.length) {
+    return;
+  }
+
+  return await insertPeriodEvents(tx, newOrChangedEvents);
+};
+
+const insertPeriodEvents = async (tx, events) => {
+  const startAfter = new Date();
+  const configInstance = getConfigInstance();
+  processChunkedSync(events, 4, (chunk) => {
+    cds.log(COMPONENT_NAME).info("inserting changed or new periodic events", {
+      events: chunk.map(({ type, subType }) => {
+        const { interval } = configInstance.getEventConfig(type, subType);
+        return { type, subType, interval };
+      }),
+    });
+  });
+  const periodEventsInsert = events.map((periodicEvent) => ({
+    type: periodicEvent.type,
+    subType: periodicEvent.subType,
+    startAfter: startAfter,
+  }));
+
+  tx._skipEventQueueBroadcase = true;
+  await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(periodEventsInsert));
+  tx._skipEventQueueBroadcase = false;
+};
+
+const _generateKey = ({ type, subType }) => [type, subType].join("##");
+
+module.exports = {
+  checkAndInsertPeriodicEvents,
+};

package/src/processEventQueue.js

@@ -43,6 +43,9 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
     if (!continueProcessing) {
       return;
     }
+    if (baseInstance.isPeriodicEvent) {
+      return await processPeriodicEvent(baseInstance);
+    }
     eventConfig.startTime = startTime;
     while (shouldContinue) {
       iterationCounter++;
@@ -131,6 +134,66 @@ const reevaluateShouldContinue = (eventTypeInstance, iterationCounter, startTime
   return false;
 };
 
+// TODO: don't forget to release lock
+const processPeriodicEvent = async (eventTypeInstance) => {
+  let queueEntry;
+  try {
+    await executeInNewTransaction(
+      eventTypeInstance.context,
+      `eventQueue-periodic-scheduleNext-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+      async (tx) => {
+        eventTypeInstance.processEventContext = tx.context;
+        const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
+        if (!queueEntries.length) {
+          return;
+        }
+        if (queueEntries.length > 1) {
+          queueEntry = await eventTypeInstance.handleDuplicatedPeriodicEventEntry(queueEntries);
+        } else {
+          queueEntry = queueEntries[0];
+        }
+        await eventTypeInstance.scheduleNextPeriodEvent(queueEntry);
+      }
+    );
+
+    if (!queueEntry) {
+      return;
+    }
+
+    await executeInNewTransaction(
+      eventTypeInstance.context,
+      `eventQueue-periodic-process-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+      async (tx) => {
+        eventTypeInstance.processEventContext = tx.context;
+        eventTypeInstance.setTxForEventProcessing(queueEntry.ID, cds.tx(tx.context));
+        try {
+          await eventTypeInstance.processEvent(tx.context, queueEntry.ID, [queueEntry]);
+        } catch (err) {
+          eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
+          throw new TriggerRollback();
+        }
+        if (
+          eventTypeInstance.transactionMode !== TransactionMode.alwaysCommit ||
+          eventTypeInstance.shouldRollbackTransaction(queueEntry.ID)
+        ) {
+          throw new TriggerRollback();
+        }
+      }
+    );
+
+    await executeInNewTransaction(
+      eventTypeInstance.context,
+      `eventQueue-periodic-setStatus-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
+      async (tx) => {
+        eventTypeInstance.processEventContext = tx.context;
+        await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID);
+      }
+    );
+  } finally {
+    await eventTypeInstance?.handleReleaseLock();
+  }
+};
+
 const processEventMap = async (eventTypeInstance) => {
   eventTypeInstance.startPerformanceTracerEvents();
   await eventTypeInstance.beforeProcessingEvents();

package/src/publishEvent.js

@@ -21,12 +21,13 @@ const EventQueueError = require("./EventQueueError");
  *     createdAt: Timestamp, // Timestamp of event creation. This field is automatically set on insert.
  *     startAfter: Timestamp, // Timestamp indicating when the event should start after.
  *   }
+ * @param {Boolean} skipBroadcast - (Optional) If set to true, event broadcasting will be skipped. Defaults to false.
  * @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 publishEvent = async (tx, events, skipBroadcast = false) => {
   const configInstance = config.getConfigInstance();
   if (!configInstance.initialized) {
     throw EventQueueError.notInitialized();
@@ -40,8 +41,15 @@ const publishEvent = async (tx, events) => {
     if (startAfter && !common.isValidDate(startAfter)) {
       throw EventQueueError.malformedDate(startAfter);
     }
+
+    if (eventConfig.isPeriodic) {
+      throw EventQueueError.manuelPeriodicEventInsert(type, subType);
+    }
   }
-  return await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(eventsForProcessing));
+  tx._skipEventQueueBroadcase = skipBroadcast;
+  const result = await tx.run(INSERT.into(configInstance.tableNameEventQueue).entries(eventsForProcessing));
+  tx._skipEventQueueBroadcase = false;
+  return result;
 };
 
 module.exports = {

package/src/redisPubSub.js

@@ -67,7 +67,19 @@ const broadcastEvent = async (tenantId, type, subType) => {
   }
 };
 
+const closeSubscribeClient = async () => {
+  try {
+    const client = await subscriberClientPromise;
+    if (client?.quit) {
+      await client.quit();
+    }
+  } catch (err) {
+    // ignore errors during shutdown
+  }
+};
+
 module.exports = {
   initEventQueueRedisSubscribe,
   broadcastEvent,
+  closeSubscribeClient,
 };

package/src/runner.js

@@ -9,22 +9,27 @@ const cdsHelper = require("./shared/cdsHelper");
 const distributedLock = require("./shared/distributedLock");
 const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
 const { getSubdomainForTenantId } = require("./shared/cdsHelper");
+const periodicEvents = require("./periodicEvents");
+const { hashStringTo32Bit } = require("./shared/common");
 
 const COMPONENT_NAME = "eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
 const EVENT_QUEUE_RUN_TS = "EVENT_QUEUE_RUN_TS";
+const EVENT_QUEUE_RUN_PERIODIC_EVENT = "EVENT_QUEUE_RUN_PERIODIC_EVENT";
 const OFFSET_FIRST_RUN = 10 * 1000;
 
-const singleTenant = () => _scheduleFunction(_executeRunForTenant);
+let tenantIdHash;
 
-const multiTenancyDb = () => _scheduleFunction(_multiTenancyDb);
+const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenant, _executeRunForTenant);
 
-const multiTenancyRedis = () => _scheduleFunction(_multiTenancyRedis);
+const multiTenancyDb = () => _scheduleFunction(_multiTenancyPeriodicEvents, _multiTenancyDb);
 
-const _scheduleFunction = async (fn) => {
+const multiTenancyRedis = () => _scheduleFunction(_multiTenancyPeriodicEvents, _multiTenancyRedis);
+
+const _scheduleFunction = async (singleRunFn, periodicFn) => {
   const logger = cds.log(COMPONENT_NAME);
   const configInstance = eventQueueConfig.getConfigInstance();
-  const eventsForAutomaticRun = configInstance.events;
+  const eventsForAutomaticRun = configInstance.allEvents;
   if (!eventsForAutomaticRun.length) {
     logger.warn("no events for automatic run are configured - skipping runner registration");
     return;
@@ -36,7 +41,7 @@ const _scheduleFunction = async (fn) => {
       logger.info("runner is deactivated via config variable. Skipping this run.");
       return;
     }
-    return fn();
+    return periodicFn();
   };
 
   const offsetDependingOnLastRun = await _calculateOffsetForFirstRun();
@@ -46,6 +51,7 @@ const _scheduleFunction = async (fn) => {
   });
 
   setTimeout(() => {
+    singleRunFn();
     fnWithRunningCheck();
     const intervalRunner = new SetIntervalDriftSafe(configInstance.runInterval);
     intervalRunner.run(fnWithRunningCheck);
@@ -57,6 +63,8 @@ const _multiTenancyRedis = async () => {
   const emptyContext = new cds.EventContext({});
   logger.info("executing event queue run for multi instance and tenant");
   const tenantIds = await cdsHelper.getAllTenantIds();
+  _checkAndTriggerPriodicEventUpdate(tenantIds);
+
   const runId = await _acquireRunId(emptyContext);
 
   if (!runId) {
@@ -67,20 +75,21 @@ const _multiTenancyRedis = async () => {
   _executeAllTenants(tenantIds, runId);
 };
 
-const _multiTenancyDb = async () => {
-  const logger = cds.log(COMPONENT_NAME);
-  try {
-    logger.info("executing event queue run for single instance and multi tenant");
-    const tenantIds = await cdsHelper.getAllTenantIds();
-    _executeAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
-  } catch (err) {
-    logger.error(
-      `Couldn't fetch tenant ids for event queue processing! Next try after defined interval. Error: ${err}`
-    );
+const _checkAndTriggerPriodicEventUpdate = (tenantIds) => {
+  const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
+  if (!tenantIdHash) {
+    tenantIdHash = hash;
+    return;
+  }
+  if (tenantIdHash && tenantIdHash !== hash) {
+    cds.log(COMPONENT_NAME).info("tenant id hash changed, triggering updating periodic events!");
+    _multiTenancyPeriodicEvents().catch((err) => {
+      cds.log(COMPONENT_NAME).error("Error during triggering updating periodic events! Error:", err);
+    });
   }
 };
 
-const _executeAllTenants = (tenantIds, runId) => {
+const _executeAllTenantsGeneric = (tenantIds, runId, fn) => {
   const configInstance = eventQueueConfig.getConfigInstance();
   const workerQueueInstance = getWorkerPoolInstance();
   tenantIds.forEach((tenantId) => {
@@ -93,7 +102,7 @@ const _executeAllTenants = (tenantIds, runId) => {
         if (!couldAcquireLock) {
           return;
         }
-        await _executeRunForTenant(tenantId, runId);
+        await fn(tenantId, runId);
       } catch (err) {
         cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
           tenantId,
@@ -103,11 +112,16 @@ const _executeAllTenants = (tenantIds, runId) => {
   });
 };
 
+const _executeAllTenants = (tenantIds, runId) => _executeAllTenantsGeneric(tenantIds, runId, _executeRunForTenant);
+
+const _executePeriodicEventsAllTenants = (tenantIds, runId) =>
+  _executeAllTenantsGeneric(tenantIds, runId, _checkPeriodicEventsSingleTenant);
+
 const _executeRunForTenant = async (tenantId, runId) => {
   const logger = cds.log(COMPONENT_NAME);
   const configInstance = eventQueueConfig.getConfigInstance();
   try {
-    const eventsForAutomaticRun = configInstance.events;
+    const eventsForAutomaticRun = configInstance.allEvents;
     const subdomain = await cdsHelper.getSubdomainForTenantId(tenantId);
     const context = new cds.EventContext({
       tenant: tenantId,
@@ -211,6 +225,60 @@ const runEventCombinationForTenant = async (tenantId, type, subType) => {
   }
 };
 
+const _multiTenancyDb = async () => {
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    logger.info("executing event queue run for single instance and multi tenant");
+    const tenantIds = await cdsHelper.getAllTenantIds();
+    _checkAndTriggerPriodicEventUpdate(tenantIds);
+    _executeAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
+  } catch (err) {
+    logger.error(
+      `Couldn't fetch tenant ids for event queue processing! Next try after defined interval. Error: ${err}`
+    );
+  }
+};
+
+const _multiTenancyPeriodicEvents = async () => {
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    logger.info("executing event queue update periodic events");
+    const tenantIds = await cdsHelper.getAllTenantIds();
+    _executePeriodicEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_PERIODIC_EVENT);
+  } catch (err) {
+    logger.error(`Couldn't fetch tenant ids for updating periodic event processing! Error: ${err}`);
+  }
+};
+
+const _checkPeriodicEventsSingleTenant = async (tenantId) => {
+  const logger = cds.log(COMPONENT_NAME);
+  const configInstance = eventQueueConfig.getConfigInstance();
+  if (!configInstance.updatePeriodicEvents) {
+    logger.info("updating of periodic events is disabled");
+  }
+  try {
+    const subdomain = await cdsHelper.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.info("executing updating periotic events", {
+      tenantId,
+      subdomain,
+    });
+    await cdsHelper.executeInNewTransaction(context, "update-periodic-events", async (tx) => {
+      await periodicEvents.checkAndInsertPeriodicEvents(tx.context);
+    });
+  } catch (err) {
+    logger.error(`Couldn't process eventQueue for tenant! Next try after defined interval. Error: ${err}`, {
+      tenantId,
+      redisEnabled: configInstance.redisEnabled,
+    });
+  }
+};
+
 module.exports = {
   singleTenant,
   multiTenancyDb,

package/src/shared/common.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const crypto = require("crypto");
+
 const { floor, abs, min } = Math;
 
 const arrayToFlatMap = (array, key = "ID") => {
@@ -118,4 +120,16 @@ const isValidDate = (value) => {
   }
 };
 
-module.exports = { arrayToFlatMap, Funnel, limiter, isValidDate };
+const processChunkedSync = (inputs, chunkSize, chunkHandler) => {
+  let start = 0;
+  while (start < inputs.length) {
+    let end = start + chunkSize > inputs.length ? inputs.length : start + chunkSize;
+    const chunk = inputs.slice(start, end);
+    chunkHandler(chunk);
+    start = end;
+  }
+};
+
+const hashStringTo32Bit = (value) => crypto.createHash("sha256").update(String(value)).digest("base64").slice(0, 32);
+
+module.exports = { arrayToFlatMap, Funnel, limiter, isValidDate, processChunkedSync, hashStringTo32Bit };

package/src/shared/{EventScheduler.js → eventScheduler.js}

@@ -3,8 +3,9 @@
 const cds = require("@sap/cds");
 
 const { broadcastEvent } = require("../redisPubSub");
+const config = require("./../config");
 
-const COMPONENT_NAME = "eventQueue/shared/EventScheduler";
+const COMPONENT_NAME = "eventQueue/shared/eventScheduler";
 
 let instance;
 class EventScheduler {
@@ -12,9 +13,10 @@ class EventScheduler {
   constructor() {}
 
   scheduleEvent(tenantId, type, subType, startAfter) {
-    const startAfterSeconds = startAfter.getSeconds();
-    const secondsUntilNextTen = 10 - (startAfterSeconds % 10);
-    const roundUpDate = new Date(startAfter.getTime() + secondsUntilNextTen * 1000);
+    const configInstance = config.getConfigInstance();
+    const eventConfig = configInstance.getEventConfig(type, subType);
+    const scheduleWithoutDelay = configInstance.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
+    const roundUpDate = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
     const key = [tenantId, type, subType, roundUpDate.toISOString()].join("##");
     if (this.#scheduledEvents[key]) {
       return; // event combination already scheduled
@@ -38,6 +40,12 @@ class EventScheduler {
     }, roundUpDate.getTime() - Date.now()).unref();
   }
 
+  calculateFutureTime(date, seoncds) {
+    const startAfterSeconds = date.getSeconds();
+    const secondsUntil = seoncds - (startAfterSeconds % seoncds);
+    return new Date(date.getTime() + secondsUntil * 1000);
+  }
+
   clearScheduledEvents() {
     this.#scheduledEvents = {};
   }

package/src/shared/redis.js

@@ -29,9 +29,18 @@ const _createClientBase = () => {
   if (env.isOnCF) {
     try {
       const credentials = env.getRedisCredentialsFromEnv();
-      // NOTE: settings the user explicitly to empty resolves auth problems, see
-      // https://github.com/go-redis/redis/issues/1343
+      const redisIsCluster = credentials.cluster_mode;
       const url = credentials.uri.replace(/(?<=rediss:\/\/)[\w-]+?(?=:)/, "");
+      if (redisIsCluster) {
+        return redis.createCluster({
+          rootNodes: [{ url }],
+          // https://github.com/redis/node-redis/issues/1782
+          defaults: {
+            password: credentials.password,
+            socket: { tls: credentials.tls },
+          },
+        });
+      }
       return redis.createClient({ url });
     } catch (err) {
       throw EventQueueError.redisConnectionFailure(err);
@@ -87,9 +96,21 @@ const publishMessage = async (channel, message) => {
 
 const _localReconnectStrategy = () => EventQueueError.redisNoReconnect();
 
+const closeMainClient = async () => {
+  try {
+    const client = await mainClientPromise;
+    if (client?.quit) {
+      await client.quit();
+    }
+  } catch (err) {
+    // ignore errors during shutdown
+  }
+};
+
 module.exports = {
   createClientAndConnect,
   createMainClientAndConnect,
   subscribeRedisChannel,
   publishMessage,
+  closeMainClient,
 };