@cap-js-community/event-queue 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "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",
@@ -56,10 +56,11 @@
   "devDependencies": {
     "@actions/core": "^1.11.1",
     "@cap-js/cds-test": "^0.4.0",
+    "@cap-js/db-service": "^2.6.0",
     "@cap-js/hana": "^2.3.4",
-    "@cap-js/sqlite": "^2.0.4",
+    "@cap-js/sqlite": "^2.1.0",
     "@opentelemetry/api": "^1.9.0",
-    "@sap/cds": "^9.4.4",
+    "@sap/cds": "^9.4.5",
     "@sap/cds-dk": "^9.4.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",

package/src/EventQueueError.js

@@ -27,12 +27,16 @@ const ERROR_CODES = {
   APP_NAMES_FORMAT: "APP_NAMES_FORMAT",
   APP_INSTANCES_FORMAT: "APP_INSTANCES_FORMAT",
   MULTI_INSTANCE_PROCESSING_NOT_ALLOWED: "MULTI_INSTANCE_PROCESSING_NOT_ALLOWED",
+  INVALID_CLUSTER_HANDLER_RESULT: "INVALID_CLUSTER_HANDLER_RESULT",
 };
 
 const ERROR_CODES_META = {
   [ERROR_CODES.WRONG_TX_USAGE]: {
     message: "Usage of this.tx|this.context is not allowed if parallel event processing is enabled",
   },
+  [ERROR_CODES.INVALID_CLUSTER_HANDLER_RESULT]: {
+    message: "A cluster handler returned an invalid result. Cluster handlers must return the clustered payload data.",
+  },
   [ERROR_CODES.UNKNOWN_EVENT_TYPE]: {
     message: "The event type and subType configuration is not configured! Maintain the combination in the config file.",
   },
@@ -371,6 +375,17 @@ class EventQueueError extends VError {
     );
   }
 
+  static invalidClusterHandlerResult(clusterKey, propertyName) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.INVALID_CLUSTER_HANDLER_RESULT];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.INVALID_CLUSTER_HANDLER_RESULT,
+        info: { clusterKey, propertyName },
+      },
+      message
+    );
+  }
+
   static isRedisConnectionFailure(err) {
     return err instanceof VError && err.name === ERROR_CODES.REDIS_CREATE_CLIENT;
   }

package/src/EventQueueProcessorBase.js

@@ -62,6 +62,7 @@ class EventQueueProcessorBase {
     this.#eventType = eventType;
     this.#eventSubType = eventSubType;
     this.#eventConfig = config ?? {};
+    this.#eventConfig.selectedDelayedEventIds ??= [];
     this.__parallelEventProcessing = this.#eventConfig.parallelEventProcessing ?? DEFAULT_PARALLEL_EVENT_PROCESSING;
     if (this.__parallelEventProcessing > LIMIT_PARALLEL_EVENT_PROCESSING) {
       this.__parallelEventProcessing = LIMIT_PARALLEL_EVENT_PROCESSING;
@@ -664,45 +665,49 @@ class EventQueueProcessorBase {
     const baseDate = Date.now();
     const refDateStartAfter = new Date(baseDate + this.#config.runInterval * 1.2);
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
-      const entries = await tx.run(
-        SELECT.from(this.#config.tableNameEventQueue)
-          .forUpdate({ wait: this.#config.forUpdateTimeout })
-          .limit(this.selectMaxChunkSize)
-          .where(
-            "type =",
-            this.#eventType,
-            "AND subType=",
-            this.#eventSubType,
-            "AND namespace =",
-            this.#namespace,
-            "AND ( startAfter IS NULL OR startAfter <=",
-            refDateStartAfter.toISOString(),
-            " ) AND ( status =",
-            EventProcessingStatus.Open,
-            "AND ( lastAttemptTimestamp <=",
-            this.startTime.toISOString(),
-            ...(this.isPeriodicEvent
-              ? [
-                  "OR lastAttemptTimestamp IS NULL ) OR ( status =",
-                  EventProcessingStatus.InProgress,
-                  "AND lastAttemptTimestamp <=",
-                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
-                  ") )",
-                ]
-              : [
-                  "OR lastAttemptTimestamp IS NULL ) OR ( status =",
-                  EventProcessingStatus.Error,
-                  "AND lastAttemptTimestamp <=",
-                  this.startTime.toISOString(),
-                  ") OR ( status =",
-                  EventProcessingStatus.InProgress,
-                  "AND lastAttemptTimestamp <=",
-                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
-                  ") )",
-                ])
-          )
-          .orderBy("createdAt", "ID")
-      );
+      const cqn = SELECT.from(this.#config.tableNameEventQueue)
+        .forUpdate({ wait: this.#config.forUpdateTimeout })
+        .limit(this.selectMaxChunkSize)
+        .where(
+          "type =",
+          this.#eventType,
+          "AND subType=",
+          this.#eventSubType,
+          "AND namespace =",
+          this.#namespace,
+          "AND ( startAfter IS NULL OR startAfter <=",
+          refDateStartAfter.toISOString(),
+          " ) AND ( status =",
+          EventProcessingStatus.Open,
+          "AND ( lastAttemptTimestamp <=",
+          this.startTime.toISOString(),
+          ...(this.isPeriodicEvent
+            ? [
+                "OR lastAttemptTimestamp IS NULL ) OR ( status =",
+                EventProcessingStatus.InProgress,
+                "AND lastAttemptTimestamp <=",
+                new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
+                ") ) ",
+              ]
+            : [
+                "OR lastAttemptTimestamp IS NULL ) OR ( status =",
+                EventProcessingStatus.Error,
+                "AND lastAttemptTimestamp <=",
+                this.startTime.toISOString(),
+                ") OR ( status =",
+                EventProcessingStatus.InProgress,
+                "AND lastAttemptTimestamp <=",
+                new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
+                ") )",
+              ])
+        )
+        .orderBy("createdAt", "ID");
+
+      if (this.#eventConfig.selectedDelayedEventIds) {
+        cqn.where("ID NOT IN", this.#eventConfig.selectedDelayedEventIds);
+      }
+
+      const entries = await tx.run(cqn);
 
       if (!entries.length) {
         this.logger.debug("no entries available for processing", {
@@ -756,7 +761,9 @@ class EventQueueProcessorBase {
       }
 
       if (!eventsForProcessing.length) {
-        this.__emptyChunkSelected = true;
+        if (!entries.length) {
+          this.__emptyChunkSelected = true;
+        }
         return;
       }
 
@@ -806,8 +813,11 @@ class EventQueueProcessorBase {
     return entry.lastAttemptsTs;
   }
 
-  #handleDelayedEvents(delayedEvents) {
+  #handleDelayedEvents(delayedEvents, { skipExcludeDelayedEventIds = false } = {}) {
     for (const delayedEvent of delayedEvents) {
+      if (!skipExcludeDelayedEventIds) {
+        this.#eventConfig.selectedDelayedEventIds.push(delayedEvent.ID);
+      }
       this.#eventSchedulerInstance.scheduleEvent(
         this.__context.tenant,
         this.#eventType,
@@ -1031,7 +1041,7 @@ class EventQueueProcessorBase {
       const lockAcquired = await distributedLock.acquireLock(
         this.__context,
         [this.#namespace, this.#eventType, this.#eventSubType].join("##"),
-        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000 }
+        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000, skipNamespace: true }
       );
       if (!lockAcquired) {
         this.logger.debug("no lock available, exit processing", {
@@ -1074,7 +1084,8 @@ class EventQueueProcessorBase {
       await trace(this.baseContext, "release-lock", async () => {
         await distributedLock.releaseLock(
           this.context,
-          [this.#namespace, this.#eventType, this.#eventSubType].join("##")
+          [this.#namespace, this.#eventType, this.#eventSubType].join("##"),
+          { skipNamespace: true }
         );
       });
     } catch (err) {
@@ -1106,6 +1117,7 @@ class EventQueueProcessorBase {
     }
 
     const newEvent = {
+      ID: cds.utils.uuid(),
       type: this.#eventType,
       subType: this.#eventSubType,
       namespace: this.#eventConfig.namespace,
@@ -1130,16 +1142,16 @@ class EventQueueProcessorBase {
       });
     }
 
-    this.tx._skipEventQueueBroadcase = true;
+    this.tx._skipEventQueueBroadcast = true;
     await this.tx.run(
       INSERT.into(this.#config.tableNameEventQueue).entries({
         ...newEvent,
         startAfter: newEvent.startAfter.toISOString(),
       })
     );
-    this.tx._skipEventQueueBroadcase = false;
+    this.tx._skipEventQueueBroadcast = false;
     if (intervalInMs < this.#config.runInterval * 1.5) {
-      this.#handleDelayedEvents([newEvent]);
+      this.#handleDelayedEvents([newEvent], { skipExcludeDelayedEventIds: true });
       const { relative: relativeAfterSchedule } = this.#eventSchedulerInstance.calculateOffset(
         this.#eventType,
         this.#eventSubType,

package/src/config.js

@@ -252,9 +252,8 @@ class Config {
     this.#unsubscribeHandlers.push(cb);
   }
 
-  addCAPOutboxEventBase(serviceName, config) {
+  addCAPOutboxEventBase(serviceName, config, currentEvents) {
     const namespace = config.namespace ?? this.#namespace;
-    delete this.#eventMap[this.generateKey(namespace, CAP_EVENT_TYPE, serviceName)];
 
     // NOTE: CAP outbox defaults are injected by cds.requires.outbox // cds.requires.queue
     const eventConfig = this.#sanitizeParamsAdHocEvent({
@@ -262,44 +261,45 @@ class Config {
       subType: serviceName,
       impl: "./outbox/EventQueueGenericOutboxHandler",
       kind: config.kind ?? "persistent-queue",
-      selectMaxChunkSize: config.selectMaxChunkSize ?? config.chunkSize,
-      parallelEventProcessing: config.parallelEventProcessing ?? (config.parallel && CAP_PARALLEL_DEFAULT),
-      retryAttempts: config.retryAttempts ?? config.maxAttempts ?? CAP_MAX_ATTEMPTS_DEFAULT,
+      ...this.#mixCAPPropertyNamesWithEventQueueNames(config),
       namespace,
       ...config,
     });
+    eventConfig.retryAttempts ??= CAP_MAX_ATTEMPTS_DEFAULT;
     eventConfig.internalEvent = true;
 
     this.#basicEventTransformation(eventConfig);
-    this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
+    this.#validateAdHocEvents(currentEvents, eventConfig, false);
     this.#basicEventTransformationAfterValidate(eventConfig);
-    this.#eventMap[this.generateKey(namespace, CAP_EVENT_TYPE, serviceName)] = eventConfig;
+    return [this.generateKey(namespace, CAP_EVENT_TYPE, serviceName), eventConfig];
   }
 
-  addCAPOutboxEventSpecificAction(serviceName, actionName) {
-    const subType = [serviceName, actionName].join(".");
+  #mixCAPPropertyNamesWithEventQueueNames(config) {
+    return this.#cleanUndefined({
+      selectMaxChunkSize: config.selectMaxChunkSize ?? config.chunkSize,
+      parallelEventProcessing: config.parallelEventProcessing ?? (config.parallel && CAP_PARALLEL_DEFAULT),
+      retryAttempts: config.retryAttempts ?? config.maxAttempts,
+      ...config,
+    });
+  }
 
-    const specific = this.#findBaseCAPServiceWithoutNamespace(subType);
-    if (specific) {
-      delete this.#eventMap[this.generateKey(specific.namespace, CAP_EVENT_TYPE, subType)];
-    }
+  addCAPOutboxEventSpecificAction(baseServiceConfig, serviceName, actionName, currentEvents) {
+    const subType = [serviceName, actionName].join(".");
 
-    const base = this.#findBaseCAPServiceWithoutNamespace(serviceName);
     const eventConfig = this.#sanitizeParamsAdHocEvent({
-      ...this.getEventConfig(CAP_EVENT_TYPE, serviceName, base.namespace),
+      ...baseServiceConfig,
       ...this.getCdsOutboxEventSpecificConfig(serviceName, actionName),
       subType,
     });
     eventConfig.internalEvent = true;
 
     this.#basicEventTransformation(eventConfig);
-    this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
+    this.#validateAdHocEvents(currentEvents, eventConfig, false);
     this.#basicEventTransformationAfterValidate(eventConfig);
-    this.#eventMap[this.generateKey(eventConfig.namespace, CAP_EVENT_TYPE, subType)] = eventConfig;
-    return eventConfig;
+    return [this.generateKey(eventConfig.namespace, CAP_EVENT_TYPE, subType), eventConfig];
   }
 
-  #findBaseCAPServiceWithoutNamespace(serviceName) {
+  findBaseCAPServiceWithoutNamespace(serviceName) {
     return Object.values(this.#eventMap).find(
       (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
     );
@@ -318,22 +318,39 @@ class Config {
     fileContent.periodicEvents ??= [];
     const events = this.#configEvents ?? {};
     const periodicEvents = this.#configPeriodicEvents ?? {};
-    const periodicCapServiceEvents = this.#cdsPeriodicOutboxServicesFromEnv();
-    fileContent.events = fileContent.events.concat(this.#mapEnvEvents(events));
+    const { adHoc: adHocCAP, periodicEvents: periodicEventsCAP } = this.#cdsQueueEventsFromEnv();
+    fileContent.events = fileContent.events.concat(this.#mapEnvEvents(events)).concat(Object.values(adHocCAP));
     fileContent.periodicEvents = fileContent.periodicEvents
       .concat(this.#mapEnvEvents(periodicEvents))
-      .concat(this.#mapCapOutboxPeriodicEvent(periodicCapServiceEvents));
+      .concat(Object.values(periodicEventsCAP));
     this.fileContent = fileContent;
   }
 
-  #mapCapOutboxPeriodicEvent(periodicEventMap) {
-    return Object.values(periodicEventMap);
+  #getBasicCapOutboxEventConfig(serviceName) {
+    return Object.assign(
+      {},
+      (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
+      (typeof cds.requires.queue === "object" && cds.requires.queue) || {},
+      (typeof cds.env.requires[serviceName]?.outbox === "object" && cds.env.requires[serviceName].outbox) || {},
+      (typeof cds.env.requires[serviceName]?.queued === "object" && cds.env.requires[serviceName].queued) || {}
+    );
   }
 
-  #cdsPeriodicOutboxServicesFromEnv() {
-    return Object.entries(cds.env.requires).reduce((result, [name, value]) => {
-      const config = value.outbox ?? value.queued;
-      if (config?.events) {
+  #cdsQueueEventsFromEnv() {
+    return Object.entries(cds.env.requires).reduce(
+      (result, [name, value]) => {
+        const config = value.outbox ?? value.queued;
+
+        if (!config) {
+          return result;
+        }
+
+        // make sure service is known in general
+        // only if not known
+        const basicServiceConfig = this.#getBasicCapOutboxEventConfig(name);
+        const [key, srvConfig] = this.addCAPOutboxEventBase(name, basicServiceConfig, result.adHoc);
+        result.adHoc[key] = srvConfig;
+
         for (const fnName in config.events) {
           const base = { ...config };
           const fnConfig = config.events[fnName];
@@ -348,7 +365,7 @@ class Config {
             }
 
             const subType = `${name}.${fnName}`;
-            result[subType] = Object.assign(
+            result.periodicEvents[subType] = Object.assign(
               {
                 type: CAP_EVENT_TYPE,
                 subType,
@@ -358,18 +375,38 @@ class Config {
               base,
               fnConfig
             );
+          } else {
+            const [key, specificEventConfig] = this.addCAPOutboxEventSpecificAction(
+              srvConfig,
+              name,
+              fnName,
+              result.adHoc
+            );
+            result.adHoc[key] = specificEventConfig;
           }
         }
-      }
-      return result;
-    }, {});
+        return result;
+      },
+      { adHoc: {}, periodicEvents: {} }
+    );
+  }
+
+  addCAPServiceWithoutEnvConfig(serviceName, srv, customOpts = {}) {
+    const queueOptions = srv.options.queued ?? srv.options.outbox ?? {};
+    const basicServiceConfig = this.#getBasicCapOutboxEventConfig(serviceName);
+    const [key, srvConfig] = this.addCAPOutboxEventBase(
+      serviceName,
+      { ...basicServiceConfig, ...queueOptions, ...customOpts },
+      this.#eventMap
+    );
+    this.#eventMap[key] = srvConfig;
   }
 
   getCdsOutboxEventSpecificConfig(serviceName, action) {
     const srv = cds.env.requires[serviceName];
     const config = srv?.outbox ?? srv?.queued;
     if (config?.events?.[action]) {
-      return config.events[action];
+      return this.#mixCAPPropertyNamesWithEventQueueNames(config.events[action]);
     } else {
       return null;
     }
@@ -877,6 +914,15 @@ class Config {
     this.#processingNamespaces = value;
   }
 
+  #cleanUndefined(input) {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  }
+
   /**
     @return { Config }
   **/

package/src/dbHandler.js

@@ -19,7 +19,7 @@ const registerEventQueueDbHandler = (dbService) => {
   registeredHandlers.eventQueueDbHandler = true;
   const def = dbService.model.definitions[config.tableNameEventQueue];
   dbService.after("CREATE", def, (_, req) => {
-    if (req.tx._skipEventQueueBroadcase) {
+    if (req.tx._skipEventQueueBroadcast) {
       return;
     }
     req.tx._ = req.tx._ ?? {};

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -6,6 +6,7 @@ const EventQueueBaseClass = require("../EventQueueProcessorBase");
 const { EventProcessingStatus } = require("../constants");
 const common = require("../shared/common");
 const config = require("../config");
+const EventQueueError = require("../EventQueueError");
 
 const COMPONENT_NAME = "/eventQueue/outbox/generic";
 
@@ -164,7 +165,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
           clusterData.queueEntries.map((entry) => entry.payload.data)
         );
         if (!clusterResult) {
-          throw new Error("hmm??");
+          throw EventQueueError.invalidClusterHandlerResult(clustersKey, propertyName);
         }
         clusterData.payload.data = clusterResult;
       }

package/src/outbox/eventQueueAsOutbox.js

@@ -20,16 +20,6 @@ function outboxed(srv, customOpts) {
   }
 
   const logger = cds.log(COMPONENT_NAME);
-  let outboxOpts = Object.assign(
-    {},
-    (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
-    (typeof cds.requires.queue === "object" && cds.requires.queue) || {},
-    (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
-    (typeof srv.options?.queued === "object" && srv.options.queued) || {},
-    customOpts || {}
-  );
-
-  config.addCAPOutboxEventBase(srv.name, outboxOpts);
 
   const originalSrv = srv[UNBOXED] || srv;
   const outboxedSrv = Object.create(originalSrv);
@@ -42,25 +32,19 @@ function outboxed(srv, customOpts) {
   }
   outboxedSrv.handle = async function (req) {
     const context = req.context || cds.context;
-    outboxOpts = Object.assign(
-      {},
-      (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
-      (typeof cds.requires.queue === "object" && cds.requires.queue) || {},
-      (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
-      (typeof srv.options?.queued === "object" && srv.options.queued) || {},
-      customOpts || {}
-    );
-    config.addCAPOutboxEventBase(srv.name, outboxOpts);
     const hasSpecificSettings = !!config.getCdsOutboxEventSpecificConfig(srv.name, req.event);
-    if (hasSpecificSettings) {
-      outboxOpts = config.addCAPOutboxEventSpecificAction(srv.name, req.event);
-    }
     const subType = hasSpecificSettings ? [srv.name, req.event].join(".") : srv.name;
-    const namespace = outboxOpts.namespace ?? config.namespace;
-    outboxOpts = config.getEventConfig(CDS_EVENT_TYPE, subType, namespace);
+    let srvConfig = config.findBaseCAPServiceWithoutNamespace(subType);
+    // NOTE: service is outboxed without config in cds.env.requires[srv]
+    if (!srvConfig) {
+      config.addCAPServiceWithoutEnvConfig(subType, srv, customOpts);
+      srvConfig = config.findBaseCAPServiceWithoutNamespace(subType);
+    }
+
+    const outboxOpts = config.getEventConfig(CDS_EVENT_TYPE, subType, srvConfig.namespace);
     const eventHeaders = getPropagatedHeaders(outboxOpts, req);
     if (["persistent-outbox", "persistent-queue"].includes(outboxOpts.kind)) {
-      await _mapToEventAndPublish(context, subType, req, eventHeaders, namespace);
+      await _mapToEventAndPublish(context, subType, req, eventHeaders, srvConfig.namespace);
       return;
     }
     context.on("succeeded", async () => {

package/src/periodicEvents.js

@@ -171,9 +171,9 @@ const _insertPeriodEvents = async (tx, events, now) => {
     counter++;
   });
 
-  tx._skipEventQueueBroadcase = true;
+  tx._skipEventQueueBroadcast = true;
   await tx.run(INSERT.into(eventConfig.tableNameEventQueue).entries(eventsToBeInserted));
-  tx._skipEventQueueBroadcase = false;
+  tx._skipEventQueueBroadcast = false;
 };
 
 const _generateKey = ({ type, subType, namespace }) => [namespace, type, subType].join("##");

package/src/processEventQueue.js

@@ -137,6 +137,7 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
             eventTypeInstance.processEventContext = tx.context;
             const queueEntries = await eventTypeInstance.getQueueEntriesAndSetToInProgress();
             if (!queueEntries.length) {
+              processNext = false;
               return;
             }
             if (queueEntries.length > 1) {

package/src/publishEvent.js

@@ -77,17 +77,17 @@ const publishEvent = async (
     }
   }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
-    _registerHandlerAndAddEvents(tx, events);
+    _registerHandlerAndAddEvents(tx, events, skipBroadcast);
   } else {
     let result;
-    tx._skipEventQueueBroadcase = skipBroadcast;
+    tx._skipEventQueueBroadcast = skipBroadcast;
     result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(events));
-    tx._skipEventQueueBroadcase = false;
+    tx._skipEventQueueBroadcast = false;
     return result;
   }
 };
 
-const _registerHandlerAndAddEvents = (tx, events) => {
+const _registerHandlerAndAddEvents = (tx, events, skipBroadcast) => {
   tx._eventQueue ??= { events: [], handlerRegistered: false };
   tx._eventQueue.events = tx._eventQueue.events.concat(events);
 
@@ -99,7 +99,9 @@ const _registerHandlerAndAddEvents = (tx, events) => {
     if (!tx._eventQueue.events?.length) {
       return;
     }
+    tx._skipEventQueueBroadcast = skipBroadcast;
     await tx.run(INSERT.into(config.tableNameEventQueue).entries(tx._eventQueue.events));
+    tx._skipEventQueueBroadcast = false;
     tx._eventQueue = null;
   });
 };

package/src/redis/redisSub.js

@@ -48,17 +48,20 @@ const _messageHandlerProcessEvents = async (messageData) => {
       if (config.isCapOutboxEvent(type)) {
         try {
           const service = await cds.connect.to(srvName);
-          cds.outboxed(service);
-          if (actionName) {
-            const specificSettings = config.getCdsOutboxEventSpecificConfig(srvName, actionName);
-            if (specificSettings) {
-              config.addCAPOutboxEventSpecificAction(srvName, actionName);
-            }
+          if (!service || actionName) {
+            logger.warn("could not find CAP Service configuration to process event!", {
+              type,
+              subType,
+              namespace,
+            });
+            return;
           }
+          config.addCAPServiceWithoutEnvConfig(subType, service);
         } catch (err) {
           logger.warn("could not connect to outboxed service", err, {
             type,
             subType,
+            namespace,
           });
           return;
         }

package/src/runner/openEvents.js

@@ -1,8 +1,5 @@
 "use strict";
 
-const cds = require("@sap/cds");
-
-const eventConfig = require("../config");
 const { EventProcessingStatus } = require("../constants");
 const config = require("../config");
 
@@ -10,9 +7,9 @@ const MS_IN_DAYS = 24 * 60 * 60 * 1000;
 
 const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const startTime = new Date();
-  const refDateStartAfter = new Date(startTime.getTime() + eventConfig.runInterval * 1.2);
+  const refDateStartAfter = new Date(startTime.getTime() + config.runInterval * 1.2);
   const entries = await tx.run(
-    SELECT.from(eventConfig.tableNameEventQueue)
+    SELECT.from(config.tableNameEventQueue)
       .where(
         "namespace IN",
         config.processingNamespaces,
@@ -25,7 +22,7 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
         ") OR ( status =",
         EventProcessingStatus.InProgress,
         "AND lastAttemptTimestamp <=",
-        new Date(startTime.getTime() - eventConfig.globalTxTimeout).toISOString(),
+        new Date(startTime.getTime() - config.globalTxTimeout).toISOString(),
         ") ) AND (createdAt >=",
         new Date(startTime.getTime() - 30 * MS_IN_DAYS).toISOString(),
         " OR startAfter >=",
@@ -38,19 +35,19 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
 
   const result = [];
   for (const { type, subType, namespace } of entries) {
-    if (eventConfig.isCapOutboxEvent(type)) {
+    if (config.isCapOutboxEvent(type)) {
       const { srvName, actionName } = config.normalizeSubType(type, subType);
       try {
-        const service = await cds.connect.to(srvName);
         if (filterAppSpecificEvents) {
-          if (!service) {
-            continue;
-          }
-          cds.outboxed(service);
-          if (actionName) {
-            config.addCAPOutboxEventSpecificAction(srvName, actionName);
+          const eventConfig = config.getEventConfig(type, subType, namespace);
+          if (!eventConfig) {
+            const service = await cds.connect.to(srvName);
+            if (!service || actionName) {
+              continue;
+            }
+            config.addCAPServiceWithoutEnvConfig(subType, service);
           }
-          if (eventConfig.shouldBeProcessedInThisApplication(type, subType, namespace)) {
+          if (config.shouldBeProcessedInThisApplication(type, subType, namespace)) {
             result.push({ namespace, type, subType });
           }
         }
@@ -64,8 +61,8 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
     } else {
       if (filterAppSpecificEvents) {
         if (
-          eventConfig.getEventConfig(type, subType, namespace) &&
-          eventConfig.shouldBeProcessedInThisApplication(type, subType, namespace)
+          config.getEventConfig(type, subType, namespace) &&
+          config.shouldBeProcessedInThisApplication(type, subType, namespace)
         ) {
           result.push({ namespace, type, subType });
         }

package/src/runner/runner.js

@@ -180,7 +180,7 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
   }
 };
 
-const _executeEventsAllTenants = async (tenantIds, runId) => {
+const _executeEventsAllTenants = async (tenantIds) => {
   const promises = [];
   for (const tenantId of tenantIds) {
     const id = cds.utils.uuid();
@@ -230,13 +230,6 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
                 label,
                 async () => {
                   try {
-                    const lockId = `${runId}_${label}`;
-                    const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-                      expiryTime: eventQueueConfig.runInterval * 0.95,
-                    });
-                    if (!couldAcquireLock) {
-                      return;
-                    }
                     await runEventCombinationForTenant(
                       context,
                       eventConfig.type,
@@ -308,50 +301,40 @@ const _singleTenantDb = async () => {
     { newRootSpan: true }
   );
 
-  return await Promise.allSettled(
-    events.map(async (openEvent) => {
-      const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
-      const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
-      return await WorkerQueue.instance.addToQueue(
-        eventConfig.load,
-        label,
-        eventConfig.priority,
-        eventConfig.increasePriorityOverTime,
-        async () => {
-          return await cds.tx({}, async ({ context }) => {
-            await trace(
-              context,
-              label,
-              async () => {
-                try {
-                  const couldAcquireLock = eventConfig.multiInstanceProcessing
-                    ? true
-                    : await distributedLock.acquireLock(context, label, {
-                        expiryTime: eventQueueConfig.runInterval * 0.95,
-                      });
-                  if (!couldAcquireLock) {
-                    return;
+  for (const openEvent of events) {
+    const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType, openEvent.namespace);
+    const label = [openEvent.namespace, eventConfig.type, eventConfig.subType].join("##");
+    await WorkerQueue.instance.addToQueue(
+      eventConfig.load,
+      label,
+      eventConfig.priority,
+      eventConfig.increasePriorityOverTime,
+      async () => {
+        return await cds.tx({}, async ({ context }) => {
+          await trace(
+            context,
+            label,
+            async () => {
+              try {
+                await runEventCombinationForTenant(
+                  context,
+                  eventConfig.type,
+                  eventConfig.subType,
+                  openEvent.namespace,
+                  {
+                    skipWorkerPool: true,
                   }
-                  await runEventCombinationForTenant(
-                    context,
-                    eventConfig.type,
-                    eventConfig.subType,
-                    openEvent.namespace,
-                    {
-                      skipWorkerPool: true,
-                    }
-                  );
-                } catch (err) {
-                  cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
-                }
-              },
-              { newRootSpan: true }
-            );
-          });
-        }
-      );
-    })
-  );
+                );
+              } catch (err) {
+                cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed");
+              }
+            },
+            { newRootSpan: true }
+          );
+        });
+      }
+    );
+  }
 };
 
 const _singleTenantRedis = async () => {
@@ -467,7 +450,7 @@ const _multiTenancyDb = async () => {
     logger.info("executing event queue run for single instance and multi tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
     await _checkPeriodicEventUpdate(tenantIds);
-    return await _executeEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_ID);
+    return await _executeEventsAllTenants(tenantIds);
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for event queue processing! Next try after defined interval.", err);
   }

package/src/runner/runnerHelper.js

@@ -4,7 +4,7 @@ const { AsyncResource } = require("async_hooks");
 
 const cds = require("@sap/cds");
 
-const { processEventQueue } = require("../processEventQueue");
+const processor = require("../processEventQueue");
 const eventQueueConfig = require("../config");
 const WorkerQueue = require("../shared/WorkerQueue");
 const distributedLock = require("../shared/distributedLock");
@@ -21,7 +21,7 @@ const runEventCombinationForTenant = async (
 ) => {
   try {
     if (skipWorkerPool) {
-      return await processEventQueue(context, type, subType, namespace);
+      return await processor.processEventQueue(context, type, subType, namespace);
     } else {
       const eventConfig = eventQueueConfig.getEventConfig(type, subType, namespace);
       const label = `${type}_${subType}`;
@@ -39,7 +39,7 @@ const runEventCombinationForTenant = async (
               }
             }
 
-            await processEventQueue(context, type, subType, namespace);
+            await processor.processEventQueue(context, type, subType, namespace);
           };
           if (shouldTrace) {
             return await trace(context, label, _exec, { newRootSpan: true });

package/src/shared/cdsHelper.js

@@ -26,7 +26,7 @@ const CONCURRENCY_AUTH_INFO = 3;
 async function executeInNewTransaction(context = {}, transactionTag, fn, args, { info = {} } = {}) {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
-  let transactionRollbackPromise = Promise.resolve(false);
+  let transactionRollbackPromise = Promise.resolve(true);
   try {
     const authInfo = await common.getAuthContext(context.tenant);
     const user = new cds.User.Privileged({ id: config.userId, authInfo, tokenInfo: authInfo?.token });

package/src/shared/distributedLock.js

@@ -11,9 +11,9 @@ const COMPONENT_NAME = "/eventQueue/distributedLock";
 const acquireLock = async (
   context,
   key,
-  { tenantScoped = true, expiryTime = config.globalTxTimeout, keepTrackOfLock = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, keepTrackOfLock = false, skipNamespace = false } = {}
 ) => {
-  const fullKey = _generateKey(context, tenantScoped, key);
+  const fullKey = _generateKey(context, tenantScoped, key, skipNamespace);
   if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, { keepTrackOfLock });
   } else {
@@ -51,8 +51,8 @@ const setValueWithExpire = async (
   }
 };
 
-const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
-  const fullKey = _generateKey(context, tenantScoped, key);
+const releaseLock = async (context, key, { tenantScoped = true, skipNamespace = false } = {}) => {
+  const fullKey = _generateKey(context, tenantScoped, key, skipNamespace);
   if (config.redisEnabled) {
     return await _releaseLockRedis(context, fullKey);
   } else {
@@ -194,8 +194,8 @@ const _acquireLockDB = async (
   return result;
 };
 
-const _generateKey = (context, tenantScoped, key) => {
-  const keyParts = [config.redisNamespace()];
+const _generateKey = (context, tenantScoped, key, skipNamespace) => {
+  const keyParts = [config.redisNamespace(!skipNamespace)];
   tenantScoped && keyParts.push(context.tenant);
   keyParts.push(key);
   return `${keyParts.join("##")}`;
@@ -216,14 +216,15 @@ const getAllLocksRedis = async () => {
   // NOTE: use SCAN because KEYS is not supported for cluster clients
   for (const client of clients) {
     for await (const key of client.scanIterator({ MATCH: "EVENT*", COUNT: 1000 })) {
-      const [, tenant, guidOrType, subType] = key.split("##");
+      const [, namespace, tenant, guidOrType, subType] = key.split("##");
       if (!subType) {
         continue;
       }
 
       const pipeline = client.multi();
       output.push({
-        tenant: tenant,
+        namespace,
+        tenant,
         type: guidOrType,
         subType: subType,
       });

package/srv/service/admin-service.cds

@@ -9,14 +9,9 @@ service EventQueueAdminService {
   @cds.persistence.skip
   entity Event as projection on db.Event {
         null as tenant: String,
-        null as landscape: String,
-        null as space: String,
         *
   } actions {
       action setStatusAndAttempts(
-        // TODO: remove tenant as soon as CAP issue is fixed https://github.tools.sap/cap/issues/issues/18445
-        @mandatory
-        tenant: String,
         status: db.Status,
         @assert.range: [0,100]
         attempts: Integer) returns Event;
@@ -25,18 +20,14 @@ service EventQueueAdminService {
   @cds.persistence.skip
   @readonly
   entity Lock {
+    key namespace: String;
     key tenant: String;
     key type: String;
     key subType: String;
-    landscape: String;
-    space: String;
     ttl: Integer;
     createdAt: Integer;
   } actions {
       action releaseLock(
-        // TODO: remove tenant as soon as CAP issue is fixed https://github.tools.sap/cap/issues/issues/18445
-        @mandatory
-        tenant: String,
         @mandatory
         type: String,
         @mandatory
@@ -44,6 +35,8 @@ service EventQueueAdminService {
     }
 
       action publishEvent(
+          @mandatory
+          namespace: String,
           @mandatory
           tenants: array of String,
           @mandatory
@@ -52,7 +45,7 @@ service EventQueueAdminService {
           subType: String,
           referenceEntity: String,
           referenceEntityKey: String,
-          @open
-          payload: {},
-          startAfter: String);
+          payload: String,
+          startAfter: String,
+             );
 }

package/srv/service/admin-service.js

@@ -15,7 +15,6 @@ module.exports = class AdminService extends cds.ApplicationService {
     const { Event: EventService, Lock: LockService } = this.entities;
     const { Event: EventDb } = cds.db.entities("sap.eventqueue");
     const { publishEvent } = this.actions;
-    const { landscape, space } = this.getLandscapeAndSpace();
 
     this.before("*", (req) => {
       if (!eventQueue.config.enableAdminService) {
@@ -26,6 +25,10 @@ module.exports = class AdminService extends cds.ApplicationService {
         return;
       }
 
+      if (req.target === LockService) {
+        return;
+      }
+
       const headers = Object.assign({}, req.headers, req.req?.headers);
       const tenant = headers["z-id"] ?? req.data.tenant;
 
@@ -46,8 +49,6 @@ module.exports = class AdminService extends cds.ApplicationService {
         }
         const events = await tx.run(req.query);
         return events?.map((event) => {
-          event.landscape = landscape;
-          event.space = space;
           event.tenant = tenant;
           return event;
         });
@@ -58,12 +59,7 @@ module.exports = class AdminService extends cds.ApplicationService {
       if (!eventQueue.config.redisEnabled) {
         return [];
       }
-      const locks = await distributedLock.getAllLocksRedis();
-      return locks.map((lock) => ({
-        ...lock,
-        landscape: landscape,
-        space: space,
-      }));
+      return await distributedLock.getAllLocksRedis();
     });
 
     this.on("setStatusAndAttempts", async (req) => {
@@ -97,17 +93,20 @@ module.exports = class AdminService extends cds.ApplicationService {
     });
 
     this.on("releaseLock", async (req) => {
+      const tenant = req.headers["z-id"];
       cds.log("eventQueue").info("Releasing event-queue lock", req.data);
-      const { tenant, type, subType } = req.data;
+      const { type, subType, namespace } = req.data;
       return await cds.tx({ tenant }, async (tx) => {
-        return await distributedLock.releaseLock(tx.context, [type, subType].join("##"));
+        return await distributedLock.releaseLock(tx.context, [namespace, type, subType].join("##"), {
+          skipNamespace: true,
+        });
       });
     });
 
     this.on(publishEvent, async (req) => {
       const logger = cds.log(COMPONENT_NAME);
       try {
-        const { type, subType, referenceEntity, referenceEntityKey, payload, startAfter } = req.data;
+        const { type, subType, referenceEntity, referenceEntityKey, payload, startAfter, namespace } = req.data;
         const tenants = await publishEventHelper.resolveTenantInfos(req);
         const eventOptions = commonHelper.cleanUndefined({
           type,
@@ -116,8 +115,9 @@ module.exports = class AdminService extends cds.ApplicationService {
           referenceEntityKey,
           payload,
           startAfter,
+          namespace,
         });
-        const publishInfo = { count: tenants.length, type, subType, tenants: req.data.tenants };
+        const publishInfo = { count: tenants.length, type, subType, namespace, tenants: req.data.tenants };
         logger.info("publishing event for tenant(s)", publishInfo);
         for (const tenant of tenants) {
           await cds.tx({ tenant }, async (tx) => {
@@ -127,25 +127,10 @@ module.exports = class AdminService extends cds.ApplicationService {
         logger.info("finished publishing event for tenant(s)", publishInfo);
       } catch (err) {
         logger.error("error publishing event", err);
+        req.reject(400, "Error publishing event: " + err.toString());
       }
     });
 
     await super.init();
   }
-
-  getLandscapeAndSpace() {
-    const url = cds.requires.db.credentials.url;
-    if (!url) {
-      return { landscape: "eu10-canary", space: "local-dev" };
-    }
-    const match = url.match(/https?:\/\/[^.]+\.authentication\.([^.]+)\.hana\.ondemand\.com/);
-    const landscape = (match?.[1] ?? "sap") === "sap" ? "eu10-canary" : match?.[1];
-    let space = "local-dev";
-    try {
-      space = JSON.parse(process.env.VCAP_APPLICATION)?.space_name;
-    } catch {
-      /* empty */
-    }
-    return { landscape, space };
-  }
 };