@cap-js-community/event-queue 1.11.0-beta.5 → 2.0.0-beta.0

package/db/Event.cds

@@ -25,4 +25,5 @@ entity Event: cuid {
     startAfter: Timestamp;
     context: LargeString;
     error: String;
+    namespace: String default 'default';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.11.0-beta.5",
+  "version": "2.0.0-beta.0",
   "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",
@@ -47,29 +47,29 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@sap/xssec": "^4.6.0",
-    "cron-parser": "^5.3.1",
-    "redis": "^4.7.0",
+    "@cap-js-community/common": "0.3.2",
+    "@sap/xssec": "^4.11.0",
+    "cron-parser": "^5.4.0",
     "verror": "^1.10.1",
     "yaml": "^2.7.1"
   },
   "devDependencies": {
+    "@actions/core": "^1.11.1",
     "@cap-js/cds-test": "^0.4.0",
-    "@cap-js/hana": "^2.2.0",
-    "@cap-js/sqlite": "^2.0.1",
-    "@sap/cds": "^9.3.1",
-    "@sap/cds-dk": "^9.3.1",
+    "@cap-js/hana": "^2.3.4",
+    "@cap-js/sqlite": "^2.0.4",
+    "@opentelemetry/api": "^1.9.0",
+    "@sap/cds": "^9.4.4",
+    "@sap/cds-dk": "^9.4.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",
     "eslint-plugin-node": "^11.1.0",
     "express": "^4.21.2",
-    "hdb": "^2.25.1",
+    "hdb": "^2.26.1",
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
-    "sqlite3": "^5.1.7",
-    "@opentelemetry/api": "^1.9.0",
-    "@actions/core": "^1.11.1"
+    "sqlite3": "^5.1.7"
   },
   "homepage": "https://cap-js-community.github.io/event-queue/",
   "repository": {
@@ -100,6 +100,12 @@
       }
     },
     "requires": {
+      "xsuaa-eventQueue": {
+        "vcap": {
+          "label": "xsuaa",
+          "plan": "application"
+        }
+      },
       "redis-eventQueue": {
         "options": {},
         "vcap": {

package/src/EventQueueProcessorBase.js

@@ -42,15 +42,17 @@ class EventQueueProcessorBase {
   #keepAliveRunner;
   #currentKeepAlivePromise = Promise.resolve();
   #etagMap;
+  #namespace;
 
   constructor(context, eventType, eventSubType, config) {
     this.__context = context;
     this.__baseContext = context;
     this.__tx = cds.tx(context);
     this.__baseLogger = cds.log(COMPONENT_NAME);
+    this.#namespace = config.namespace;
     this.#eventSchedulerInstance = eventScheduler.getInstance();
     this.#config = eventConfig;
-    this.#isPeriodic = this.#config.isPeriodicEvent(eventType, eventSubType);
+    this.#isPeriodic = this.#config.isPeriodicEvent(eventType, eventSubType, this.#namespace);
     this.__logger = null;
     this.__eventProcessingMap = {};
     this.__statusMap = {};
@@ -178,6 +180,7 @@ class EventQueueProcessorBase {
       this.__context.tenant,
       this.#eventType,
       this.#eventSubType,
+      this.#namespace,
       new Date(Date.now() + 5 * 1000) // add some offset to make sure all locks are released
     );
   }
@@ -477,6 +480,7 @@ class EventQueueProcessorBase {
             this.__context.tenant,
             this.#eventType,
             this.#eventSubType,
+            this.#namespace,
             startAfter
           );
         }
@@ -606,6 +610,8 @@ class EventQueueProcessorBase {
             this.#eventType,
             "AND subType=",
             this.#eventSubType,
+            "AND namespace =",
+            this.#namespace,
             "AND ( startAfter IS NULL OR startAfter <=",
             refDateStartAfter.toISOString(),
             " ) AND ( status =",
@@ -743,6 +749,7 @@ class EventQueueProcessorBase {
         this.__context.tenant,
         this.#eventType,
         this.#eventSubType,
+        delayedEvent.namespace,
         delayedEvent.startAfter
       );
     }
@@ -960,7 +967,7 @@ class EventQueueProcessorBase {
     return await trace(this.baseContext, "acquire-lock", async () => {
       const lockAcquired = await distributedLock.acquireLock(
         this.__context,
-        [this.#eventType, this.#eventSubType].join("##"),
+        [this.#namespace, this.#eventType, this.#eventSubType].join("##"),
         { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000 }
       );
       if (!lockAcquired) {
@@ -1002,7 +1009,10 @@ class EventQueueProcessorBase {
     }
     try {
       await trace(this.baseContext, "release-lock", async () => {
-        await distributedLock.releaseLock(this.context, [this.#eventType, this.#eventSubType].join("##"));
+        await distributedLock.releaseLock(
+          this.context,
+          [this.#namespace, this.#eventType, this.#eventSubType].join("##")
+        );
       });
     } catch (err) {
       this.logger.error("Releasing distributed lock failed.", err);
@@ -1035,6 +1045,7 @@ class EventQueueProcessorBase {
     const newEvent = {
       type: this.#eventType,
       subType: this.#eventSubType,
+      namespace: this.#eventConfig.namespace,
       startAfter: new Date(newStartAfter),
     };
     const { relative } = this.#eventSchedulerInstance.calculateOffset(
@@ -1293,6 +1304,10 @@ class EventQueueProcessorBase {
   get inheritTraceContext() {
     return this.#eventConfig.inheritTraceContext;
   }
+
+  get namespace() {
+    return this.#namespace;
+  }
 }
 
 module.exports = EventQueueProcessorBase;

package/src/config.js

@@ -4,18 +4,12 @@ const cds = require("@sap/cds");
 const { CronExpressionParser } = require("cron-parser");
 
 const { getEnvInstance } = require("./shared/env");
-const redis = require("./shared/redis");
 const EventQueueError = require("./EventQueueError");
 const { Priorities } = require("./constants");
 
 const FOR_UPDATE_TIMEOUT = 10;
 const GLOBAL_TX_TIMEOUT = 30 * 60 * 1000;
 const REDIS_PREFIX = "EVENT_QUEUE";
-const REDIS_CONFIG_CHANNEL = "CONFIG_CHANNEL";
-const REDIS_OFFBOARD_TENANT_CHANNEL = "REDIS_OFFBOARD_TENANT_CHANNEL";
-const REDIS_CONFIG_BLOCKLIST_CHANNEL = "REDIS_CONFIG_BLOCKLIST_CHANNEL";
-const COMMAND_BLOCK = "EVENT_BLOCK";
-const COMMAND_UNBLOCK = "EVENT_UNBLOCK";
 const COMPONENT_NAME = "/eventQueue/config";
 const MIN_INTERVAL_SEC = 10;
 const DEFAULT_LOAD = 1;
@@ -53,6 +47,7 @@ const ALLOWED_EVENT_OPTIONS_BASE = [
   "keepAliveMaxInProgressTime",
   "appNames",
   "appInstances",
+  "namespace",
   "internalEvent",
 ];
 
@@ -98,7 +93,6 @@ class Config {
   #env;
   #eventMap;
   #updatePeriodicEvents;
-  #blockedEvents;
   #isEventBlockedCb;
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
@@ -112,7 +106,6 @@ class Config {
   #cronTimezone;
   #randomOffsetPeriodicEvents;
   #redisNamespace;
-  #publishEventBlockList;
   #crashOnRedisUnavailable;
   #tenantIdFilterAuthContextCb;
   #tenantIdFilterEventProcessingCb;
@@ -120,6 +113,8 @@ class Config {
   #configPeriodicEvents;
   #enableAdminService;
   #disableProcessingOfSuspendedTenants;
+  #namespace;
+  #processingNamespaces;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -137,12 +132,11 @@ class Config {
     this.#processEventsAfterPublish = null;
     this.#disableRedis = null;
     this.#env = getEnvInstance();
-    this.#blockedEvents = {};
   }
 
-  getEventConfig(type, subType) {
-    return this.#eventMap[this.generateKey(type, subType)]
-      ? { ...this.#eventMap[this.generateKey(type, subType)] }
+  getEventConfig(type, subType, namespace = this.namespace) {
+    return this.#eventMap[this.generateKey(namespace, type, subType)]
+      ? { ...this.#eventMap[this.generateKey(namespace, type, subType)] }
       : undefined;
   }
 
@@ -150,8 +144,8 @@ class Config {
     return type === CAP_EVENT_TYPE;
   }
 
-  hasEventAfterCommitFlag(type, subType) {
-    return this.#eventMap[this.generateKey(type, subType)]?.processAfterCommit ?? true;
+  hasEventAfterCommitFlag(type, subType, namespace = this.namespace) {
+    return this.#eventMap[this.generateKey(namespace, type, subType)]?.processAfterCommit ?? true;
   }
 
   _checkRedisIsBound() {
@@ -178,10 +172,10 @@ class Config {
     return actionSpecificCall ? rawSubType : serviceName;
   }
 
-  shouldBeProcessedInThisApplication(type, rawSubType) {
+  shouldBeProcessedInThisApplication(type, rawSubType, namespace = this.namespace) {
     const subType = this.#normalizeSubType(rawSubType);
 
-    const config = this.#eventMap[this.generateKey(type, subType)];
+    const config = this.#eventMap[this.generateKey(namespace, type, subType)];
     const appNameConfig = config._appNameMap;
     const appInstanceConfig = config._appInstancesMap;
     let result = true;
@@ -226,38 +220,6 @@ class Config {
     return this.#redisEnabled;
   }
 
-  attachConfigChangeHandler() {
-    this.#attachBlockListChangeHandler();
-    redis.subscribeRedisChannel(this.redisOptions, REDIS_CONFIG_CHANNEL, (messageData) => {
-      try {
-        const { key, value } = JSON.parse(messageData);
-        if (this[key] !== value) {
-          this.#logger.info("received config change", { key, value });
-          this[key] = value;
-        }
-      } catch (err) {
-        this.#logger.error("could not parse event config change", err, {
-          messageData,
-        });
-      }
-    });
-  }
-
-  attachRedisUnsubscribeHandler() {
-    this.#logger.info("attached redis handle for unsubscribe events");
-    redis.subscribeRedisChannel(this.redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, (messageData) => {
-      try {
-        const { tenantId } = JSON.parse(messageData);
-        this.#logger.info("received unsubscribe broadcast event", { tenantId });
-        this.executeUnsubscribeHandlers(tenantId);
-      } catch (err) {
-        this.#logger.error("could not parse unsubscribe broadcast event", err, {
-          messageData,
-        });
-      }
-    });
-  }
-
   executeUnsubscribeHandlers(tenantId) {
     this.#unsubscribedTenants[tenantId] = true;
     setTimeout(() => delete this.#unsubscribedTenants[tenantId], DELETE_TENANT_BLOCK_AFTER_MS);
@@ -272,122 +234,24 @@ class Config {
     }
   }
 
-  handleUnsubscribe(tenantId) {
-    if (this.redisEnabled) {
-      redis
-        .publishMessage(this.redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, JSON.stringify({ tenantId }))
-        .catch((error) => {
-          this.#logger.error(`publishing tenant unsubscribe failed. tenantId: ${tenantId}`, error);
-        });
-    } else {
-      this.executeUnsubscribeHandlers(tenantId);
-    }
-  }
-
   attachUnsubscribeHandler(cb) {
     this.#unsubscribeHandlers.push(cb);
   }
 
-  publishConfigChange(key, value) {
-    if (!this.redisEnabled) {
-      this.#logger.info("redis not connected, config change won't be published", { key, value });
-      return;
-    }
-    redis.publishMessage(this.redisOptions, REDIS_CONFIG_CHANNEL, JSON.stringify({ key, value })).catch((error) => {
-      this.#logger.error(`publishing config change failed key: ${key}, value: ${value}`, error);
-    });
-  }
-
-  #attachBlockListChangeHandler() {
-    redis.subscribeRedisChannel(this.redisOptions, REDIS_CONFIG_BLOCKLIST_CHANNEL, (messageData) => {
-      try {
-        const { command, key, tenant } = JSON.parse(messageData);
-        if (command === COMMAND_BLOCK) {
-          this.#blockEventLocalState(key, tenant);
-        } else {
-          this.#unblockEventLocalState(key, tenant);
-        }
-      } catch (err) {
-        this.#logger.error("could not parse event blocklist change", err, {
-          messageData,
-        });
-      }
-    });
-  }
-
-  blockEvent(type, subType, isPeriodic, tenant = "*") {
-    const typeWithSuffix = `${type}${isPeriodic ? SUFFIX_PERIODIC : ""}`;
-    const config = this.getEventConfig(typeWithSuffix, subType);
-    if (!config) {
-      return;
-    }
-    const key = this.generateKey(typeWithSuffix, subType);
-    this.#blockEventLocalState(key, tenant);
-    if (!this.redisEnabled || !this.publishEventBlockList) {
-      return;
-    }
-
-    redis
-      .publishMessage(
-        this.redisOptions,
-        REDIS_CONFIG_BLOCKLIST_CHANNEL,
-        JSON.stringify({ command: COMMAND_BLOCK, key, tenant })
-      )
-      .catch((error) => {
-        this.#logger.error(`publishing config block failed key: ${key}`, error);
-      });
-  }
-
-  #blockEventLocalState(key, tenant) {
-    this.#blockedEvents[key] ??= {};
-    this.#blockedEvents[key][tenant] = true;
-    return key;
-  }
-
-  clearPeriodicEventBlockList() {
-    this.#blockedEvents = {};
-  }
-
-  unblockEvent(type, subType, isPeriodic, tenant = "*") {
-    const typeWithSuffix = `${type}${isPeriodic ? SUFFIX_PERIODIC : ""}`;
-    const key = this.generateKey(typeWithSuffix, subType);
-    const config = this.getEventConfig(typeWithSuffix, subType);
-    if (!config) {
-      return;
-    }
-    this.#unblockEventLocalState(key, tenant);
-    if (!this.redisEnabled) {
-      return;
-    }
-
-    redis
-      .publishMessage(
-        this.redisOptions,
-        REDIS_CONFIG_BLOCKLIST_CHANNEL,
-        JSON.stringify({ command: COMMAND_UNBLOCK, key, tenant })
-      )
-      .catch((error) => {
-        this.#logger.error(`publishing config block failed key: ${key}`, error);
-      });
-  }
-
   addCAPOutboxEventBase(serviceName, config) {
-    if (this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)]) {
-      const index = this.#config.events.findIndex(
-        (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
-      );
-      this.#config.events.splice(index, 1);
-    }
+    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
+    // NOTE: CAP outbox defaults are injected by cds.requires.outbox // cds.requires.queue
     const eventConfig = this.#sanitizeParamsAdHocEvent({
       type: CAP_EVENT_TYPE,
       subType: serviceName,
       impl: "./outbox/EventQueueGenericOutboxHandler",
-      kind: config.kind ?? "persistent-outbox",
+      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,
+      namespace,
       ...config,
     });
     eventConfig.internalEvent = true;
@@ -395,21 +259,20 @@ class Config {
     this.#basicEventTransformation(eventConfig);
     this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
     this.#basicEventTransformationAfterValidate(eventConfig);
-    this.#config.events.push(eventConfig);
-    this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)] = eventConfig;
+    this.#eventMap[this.generateKey(namespace, CAP_EVENT_TYPE, serviceName)] = eventConfig;
   }
 
   addCAPOutboxEventSpecificAction(serviceName, actionName) {
     const subType = [serviceName, actionName].join(".");
-    if (this.#eventMap[this.generateKey(CAP_EVENT_TYPE, subType)]) {
-      const index = this.#config.events.findIndex(
-        (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
-      );
-      this.#config.events.splice(index, 1);
+
+    const specific = this.#findBaseCAPServiceWithoutNamespace(subType);
+    if (specific) {
+      delete this.#eventMap[this.generateKey(specific.namespace, CAP_EVENT_TYPE, subType)];
     }
 
+    const base = this.#findBaseCAPServiceWithoutNamespace(serviceName);
     const eventConfig = this.#sanitizeParamsAdHocEvent({
-      ...this.getEventConfig(CAP_EVENT_TYPE, serviceName),
+      ...this.getEventConfig(CAP_EVENT_TYPE, serviceName, base.namespace),
       ...this.getCdsOutboxEventSpecificConfig(serviceName, actionName),
       subType,
     });
@@ -418,28 +281,14 @@ class Config {
     this.#basicEventTransformation(eventConfig);
     this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
     this.#basicEventTransformationAfterValidate(eventConfig);
-    this.#config.events.push(eventConfig);
-    this.#eventMap[this.generateKey(CAP_EVENT_TYPE, subType)] = eventConfig;
+    this.#eventMap[this.generateKey(eventConfig.namespace, CAP_EVENT_TYPE, subType)] = eventConfig;
     return eventConfig;
   }
 
-  #unblockEventLocalState(key, tenant) {
-    const map = this.#blockedEvents[key];
-    if (!map) {
-      return;
-    }
-    this.#blockedEvents[key][tenant] = false;
-    return key;
-  }
-
-  isEventBlocked(type, subType, isPeriodicEvent, tenant) {
-    const map = this.#blockedEvents[this.generateKey(`${type}${isPeriodicEvent ? SUFFIX_PERIODIC : ""}`, subType)];
-    if (!map) {
-      return false;
-    }
-    const tenantSpecific = map[tenant];
-    const allTenants = map["*"];
-    return tenantSpecific ?? allTenants;
+  #findBaseCAPServiceWithoutNamespace(serviceName) {
+    return Object.values(this.#eventMap).find(
+      (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
+    );
   }
 
   get isEventQueueActive() {
@@ -469,10 +318,11 @@ class Config {
 
   #cdsPeriodicOutboxServicesFromEnv() {
     return Object.entries(cds.env.requires).reduce((result, [name, value]) => {
-      if (value.outbox?.events) {
-        for (const fnName in value.outbox.events) {
-          const base = { ...value.outbox };
-          const fnConfig = value.outbox.events[fnName];
+      const config = value.outbox ?? value.queued;
+      if (config?.events) {
+        for (const fnName in config.events) {
+          const base = { ...config };
+          const fnConfig = config.events[fnName];
           if (fnConfig.interval || fnConfig.cron) {
             if ("interval" in base || "cron" in base) {
               this.#logger.error(
@@ -502,8 +352,10 @@ class Config {
   }
 
   getCdsOutboxEventSpecificConfig(serviceName, action) {
-    if (cds.env.requires[serviceName]?.outbox?.events?.[action]) {
-      return cds.env.requires[serviceName].outbox.events[action];
+    const srv = cds.env.requires[serviceName];
+    const config = srv?.outbox ?? srv?.queued;
+    if (config?.events?.[action]) {
+      return config.events[action];
     } else {
       return null;
     }
@@ -531,7 +383,7 @@ class Config {
       this.#basicEventTransformation(eventSanitized);
       this.#validateAdHocEvents(result, eventSanitized);
       this.#basicEventTransformationAfterValidate(eventSanitized);
-      result[this.generateKey(eventSanitized.type, eventSanitized.subType)] = eventSanitized;
+      result[this.generateKey(eventSanitized.namespace, eventSanitized.type, eventSanitized.subType)] = eventSanitized;
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
@@ -541,7 +393,7 @@ class Config {
       this.#basicEventTransformation(eventSanitized);
       this.#validatePeriodicConfig(result, eventSanitized);
       this.#basicEventTransformationAfterValidate(eventSanitized);
-      result[this.generateKey(eventSanitized.type, eventSanitized.subType)] = eventSanitized;
+      result[this.generateKey(eventSanitized.namespace, eventSanitized.type, eventSanitized.subType)] = eventSanitized;
       return result;
     }, this.#eventMap);
     this.#config = config;
@@ -554,6 +406,7 @@ class Config {
     event.keepAliveInterval = event.keepAliveInterval ?? DEFAULT_KEEP_ALIVE_INTERVAL;
     event.keepAliveMaxInProgressTime = event.keepAliveInterval * DEFAULT_MAX_FACTOR_STUCK_2_KEEP_ALIVE_INTERVAL;
     event.checkForNextChunk = event.checkForNextChunk ?? DEFAULT_CHECK_FOR_NEXT_CHUNK;
+    event.namespace = event.namespace === undefined ? this.#namespace : event.namespace;
   }
 
   #sanitizeParamsBase(config, allowList) {
@@ -623,7 +476,7 @@ class Config {
   }
 
   #validatePeriodicConfig(eventMap, event) {
-    const key = this.generateKey(event.type, event.subType);
+    const key = this.generateKey(event.namespace, event.type, event.subType);
     if (eventMap[key] && eventMap[key].isPeriodic) {
       throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
@@ -674,7 +527,7 @@ class Config {
   }
 
   #validateAdHocEvents(eventMap, event, checkForDuplication = true) {
-    const key = this.generateKey(event.type, event.subType);
+    const key = this.generateKey(event.namespace, event.type, event.subType);
     if (eventMap[key] && !eventMap[key].isPeriodic && checkForDuplication) {
       throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
@@ -695,22 +548,22 @@ class Config {
     this.#basicEventValidation(event);
   }
 
-  generateKey(type, subType) {
-    return [type, subType].join("##");
+  generateKey(namespace, type, subType) {
+    return [namespace, type, subType].join("##");
   }
 
-  removeEvent(type, subType) {
-    const index = this.#config.events.findIndex((event) => event.type === "CAP_OUTBOX");
-    if (index >= 0) {
-      this.#config.events.splice(index, 1);
-    }
-    delete this.#eventMap[this.generateKey(type, subType)];
+  removeEvent(type, subType, namespace = this.namespace) {
+    delete this.#eventMap[this.generateKey(namespace, type, subType)];
   }
 
   isTenantUnsubscribed(tenantId) {
     return this.#unsubscribedTenants[tenantId];
   }
 
+  shouldProcessNamespace(namespace) {
+    return this.#processingNamespaces.includes(namespace);
+  }
+
   get fileContent() {
     return this.#config;
   }
@@ -735,8 +588,8 @@ class Config {
     return Object.values(this.#eventMap).filter((e) => e.isPeriodic);
   }
 
-  isPeriodicEvent(type, subType) {
-    return this.#eventMap[this.generateKey(type, subType)]?.isPeriodic;
+  isPeriodicEvent(type, subType, namespace = this.namespace) {
+    return this.#eventMap[this.generateKey(namespace, type, subType)]?.isPeriodic;
   }
 
   get allEvents() {
@@ -755,14 +608,6 @@ class Config {
     this.#forUpdateTimeout = value;
   }
 
-  get publishEventBlockList() {
-    return this.#publishEventBlockList;
-  }
-
-  set publishEventBlockList(value) {
-    this.#publishEventBlockList = value;
-  }
-
   get crashOnRedisUnavailable() {
     return this.#crashOnRedisUnavailable;
   }
@@ -937,7 +782,6 @@ class Config {
   get redisOptions() {
     return {
       ...this.#redisOptions,
-      redisNamespace: `${[REDIS_PREFIX, this.redisNamespace].filter((a) => a).join("_")}`,
     };
   }
 
@@ -946,7 +790,7 @@ class Config {
   }
 
   get redisNamespace() {
-    return this.#redisNamespace;
+    return `${[REDIS_PREFIX, this.#redisNamespace].filter((a) => a).join("##")}`;
   }
 
   set insertEventsBeforeCommit(value) {
@@ -993,6 +837,22 @@ class Config {
     this.#disableProcessingOfSuspendedTenants = value;
   }
 
+  get namespace() {
+    return this.#namespace;
+  }
+
+  set namespace(value) {
+    this.#namespace = value;
+  }
+
+  get processingNamespaces() {
+    return this.#processingNamespaces;
+  }
+
+  set processingNamespaces(value) {
+    this.#processingNamespaces = value;
+  }
+
   /**
     @return { Config }
   **/

package/src/dbHandler.js

@@ -28,8 +28,11 @@ const registerEventQueueDbHandler = (dbService) => {
     const data = Array.isArray(req.query.INSERT.entries) ? req.query.INSERT.entries : [req.query.INSERT.entries];
     const eventCombinations = Object.keys(
       data.reduce((result, event) => {
-        const key = [event.type, event.subType].join("##");
-        if (!config.hasEventAfterCommitFlag(event.type, event.subType) || eventQueuePublishEvents[key]) {
+        const key = [event.type, event.subType, event.namespace].join("##");
+        if (
+          !config.hasEventAfterCommitFlag(event.type, event.subType, event.namespace) ||
+          eventQueuePublishEvents[key]
+        ) {
           return result;
         }
         eventQueuePublishEvents[key] = true;
@@ -41,8 +44,8 @@ const registerEventQueueDbHandler = (dbService) => {
     eventCombinations.length &&
       req.on("succeeded", () => {
         const events = eventCombinations.map((eventCombination) => {
-          const [type, subType] = eventCombination.split("##");
-          return { type, subType };
+          const [type, subType, namespace] = eventCombination.split("##");
+          return { type, subType, namespace };
         });
 
         redisPub.broadcastEvent(req.tenant, events).catch((err) => {