@cap-js-community/event-queue 1.10.0-beta.0 → 1.10.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.10.0-beta.0",
+  "version": "1.10.0-beta.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",

package/src/EventQueueProcessorBase.js

@@ -243,7 +243,7 @@ class EventQueueProcessorBase {
    * This can be useful for e.g. multiple tasks have been scheduled and always the same user should be informed.
    * In this case the events should be clustered together and only one mail should be sent.
    */
-  clusterQueueEntries(queueEntriesWithPayloadMap) {
+  async clusterQueueEntries(queueEntriesWithPayloadMap) {
     Object.entries(queueEntriesWithPayloadMap).forEach(([key, { queueEntry, payload }]) => {
       this.addEntryToProcessingMap(key, queueEntry, payload);
     });

package/src/config.js

@@ -10,9 +10,12 @@ const { Priorities } = require("./constants");
 
 const FOR_UPDATE_TIMEOUT = 10;
 const GLOBAL_TX_TIMEOUT = 30 * 60 * 1000;
-const REDIS_CONFIG_CHANNEL = "EVENT_QUEUE_CONFIG_CHANNEL";
+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 = "EVENT_QUEUE_REDIS_CONFIG_BLOCKLIST_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;
@@ -22,8 +25,6 @@ const DEFAULT_KEEP_ALIVE_INTERVAL = 60;
 const DEFAULT_MAX_FACTOR_STUCK_2_KEEP_ALIVE_INTERVAL = 3.5;
 const DEFAULT_INHERIT_TRACE_CONTEXT = true;
 const SUFFIX_PERIODIC = "_PERIODIC";
-const COMMAND_BLOCK = "EVENT_QUEUE_EVENT_BLOCK";
-const COMMAND_UNBLOCK = "EVENT_QUEUE_EVENT_UNBLOCK";
 const CAP_EVENT_TYPE = "CAP_OUTBOX";
 const CAP_PARALLEL_DEFAULT = 5;
 const DELETE_TENANT_BLOCK_AFTER_MS = 5 * 60 * 1000;
@@ -64,6 +65,7 @@ const ALLOWED_EVENT_OPTIONS_AD_HOC = [
   "retryFailedAfter",
   "multiInstanceProcessing",
   "kind",
+  "timeBucket",
 ];
 
 const ALLOWED_EVENT_OPTIONS_PERIODIC_EVENT = [
@@ -105,6 +107,7 @@ class Config {
   #unsubscribeHandlers = [];
   #unsubscribedTenants = {};
   #cronTimezone;
+  #redisNamespace;
   #publishEventBlockList;
   #crashOnRedisUnavailable;
   #tenantIdFilterTokenInfoCb;
@@ -181,7 +184,7 @@ class Config {
 
   attachConfigChangeHandler() {
     this.#attachBlockListChangeHandler();
-    redis.subscribeRedisChannel(this.#redisOptions, REDIS_CONFIG_CHANNEL, (messageData) => {
+    redis.subscribeRedisChannel(this.redisOptions, REDIS_CONFIG_CHANNEL, (messageData) => {
       try {
         const { key, value } = JSON.parse(messageData);
         if (this[key] !== value) {
@@ -198,7 +201,7 @@ class Config {
 
   attachRedisUnsubscribeHandler() {
     this.#logger.info("attached redis handle for unsubscribe events");
-    redis.subscribeRedisChannel(this.#redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, (messageData) => {
+    redis.subscribeRedisChannel(this.redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, (messageData) => {
       try {
         const { tenantId } = JSON.parse(messageData);
         this.#logger.info("received unsubscribe broadcast event", { tenantId });
@@ -228,7 +231,7 @@ class Config {
   handleUnsubscribe(tenantId) {
     if (this.redisEnabled) {
       redis
-        .publishMessage(this.#redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, JSON.stringify({ tenantId }))
+        .publishMessage(this.redisOptions, REDIS_OFFBOARD_TENANT_CHANNEL, JSON.stringify({ tenantId }))
         .catch((error) => {
           this.#logger.error(`publishing tenant unsubscribe failed. tenantId: ${tenantId}`, error);
         });
@@ -246,13 +249,13 @@ class Config {
       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) => {
+    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) => {
+    redis.subscribeRedisChannel(this.redisOptions, REDIS_CONFIG_BLOCKLIST_CHANNEL, (messageData) => {
       try {
         const { command, key, tenant } = JSON.parse(messageData);
         if (command === COMMAND_BLOCK) {
@@ -282,7 +285,7 @@ class Config {
 
     redis
       .publishMessage(
-        this.#redisOptions,
+        this.redisOptions,
         REDIS_CONFIG_BLOCKLIST_CHANNEL,
         JSON.stringify({ command: COMMAND_BLOCK, key, tenant })
       )
@@ -315,7 +318,7 @@ class Config {
 
     redis
       .publishMessage(
-        this.#redisOptions,
+        this.redisOptions,
         REDIS_CONFIG_BLOCKLIST_CHANNEL,
         JSON.stringify({ command: COMMAND_UNBLOCK, key, tenant })
       )
@@ -630,6 +633,14 @@ class Config {
     }
     event.inheritTraceContext = event.inheritTraceContext ?? DEFAULT_INHERIT_TRACE_CONTEXT;
 
+    if (event.timeBucket) {
+      try {
+        CronExpressionParser.parse(event.timeBucket);
+      } catch {
+        throw EventQueueError.cantParseCronExpression(event.type, event.subType, event.timeBucket);
+      }
+    }
+
     this.#basicEventValidation(event);
   }
 
@@ -865,7 +876,18 @@ class Config {
   }
 
   get redisOptions() {
-    return this.#redisOptions;
+    return {
+      ...this.#redisOptions,
+      redisNamespace: `${[REDIS_PREFIX, this.redisNamespace].filter((a) => a).join("_")}`,
+    };
+  }
+
+  set redisNamespace(value) {
+    this.#redisNamespace = value;
+  }
+
+  get redisNamespace() {
+    return this.#redisNamespace;
   }
 
   set insertEventsBeforeCommit(value) {

package/src/initialize.js

@@ -42,6 +42,7 @@ const CONFIG_VARS = [
   ["insertEventsBeforeCommit", true],
   ["enableTelemetry", true],
   ["cronTimezone", null],
+  ["redisNamespace", null],
   ["publishEventBlockList", true],
   ["crashOnRedisUnavailable", false],
 ];

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -15,34 +15,251 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     this.logger = cds.log(`${COMPONENT_NAME}/${eventSubType}`);
   }
 
+  async getQueueEntriesAndSetToInProgress() {
+    const [serviceName] = this.eventSubType.split(".");
+    this.__srv = await cds.connect.to(serviceName);
+    this.__srvUnboxed = cds.unboxed(this.__srv);
+    const { handlers, clusterRelevant, specificClusterRelevant } = this.__srvUnboxed.handlers.on.reduce(
+      (result, handler) => {
+        if (handler.on.startsWith("clusterQueueEntries")) {
+          if (handler.on.split(".").length === 2) {
+            result.specificClusterRelevant = true;
+          } else {
+            result.clusterRelevant = true;
+          }
+        }
+
+        result.handlers[handler.on] = handler.on;
+        return result;
+      },
+      { handlers: {}, clusterRelevant: false, specificClusterRelevant: false }
+    );
+    this.__onHandlers = handlers;
+    this.__genericClusterHandler = clusterRelevant;
+    this.__specificClusterHandler = specificClusterRelevant;
+    await this.#setContextUser(this.context, config.userId);
+    return super.getQueueEntriesAndSetToInProgress();
+  }
+
+  // NOTE: issue here: if events are not sorted before it might not be unique here:
+  //       - we have service events
+  //       - we have action specific events
+  // 1. I need to collect all action names
+  // 2. I need to check for which actions a handler exits
+  // 3. For actions with specific existing handler --> call specific action
+  // 4. For all others call generic handler
+  // NOTE: OVERALL idea is that the handler returns the cluster map and MUST not call any baseImpl functions!
+  //      --> structure is a map of { key: { queueEntries: [], payload: {} }
+  // TODO: document that clusterQueueEntries is now async!!!
+  // TODO: validate that return structure is as expected
+  async clusterQueueEntries(queueEntriesWithPayloadMap) {
+    if (!this.__genericClusterRelevantAndAvailable && !this.__specificClusterRelevantAndAvailable) {
+      return super.clusterQueueEntries(queueEntriesWithPayloadMap);
+    }
+    const { genericClusterEvents, specificClusterEvents } = this.#clusterByAction(queueEntriesWithPayloadMap);
+    if (Object.keys(genericClusterEvents).length) {
+      if (!this.__genericClusterRelevantAndAvailable) {
+        await super.clusterQueueEntries(genericClusterEvents);
+      } else {
+        const msg = new cds.Request({
+          event: "clusterQueueEntries",
+          eventQueue: {
+            processor: this,
+            clusterByPayloadProperty: (propertyName, cb) =>
+              this.clusterByPayloadProperty(genericClusterEvents, propertyName, cb),
+            clusterByEventProperty: (propertyName) => this.clusterByEventProperty(genericClusterEvents, propertyName),
+          },
+        });
+        const handlerCluster = await this.__srvUnboxed.tx(this.context).send(msg);
+        this.#addToProcessingMap(handlerCluster);
+      }
+    }
+
+    for (const actionName in specificClusterEvents) {
+      const msg = new cds.Request({
+        event: `clusterQueueEntries.${actionName}`,
+        eventQueue: {
+          processor: this,
+          clusterByPayloadProperty: (propertyName, cb) =>
+            this.clusterByPayloadProperty(specificClusterEvents[actionName], propertyName, cb),
+          clusterByEventProperty: (propertyName, cb) =>
+            this.clusterByEventProperty(specificClusterEvents[actionName], propertyName, cb),
+        },
+      });
+      const handlerCluster = await this.__srvUnboxed.tx(this.context).send(msg);
+      this.#addToProcessingMap(handlerCluster);
+    }
+  }
+
+  clusterBase(queueEntriesWithPayloadMap, propertyName, refCb, cb) {
+    return Object.entries(queueEntriesWithPayloadMap).reduce((result, [, { queueEntry, payload }], index) => {
+      const ref = refCb(result, payload, queueEntry);
+      ref.queueEntries.push(queueEntry);
+      if (cb) {
+        const clusterResult = cb(ref.payload.data, queueEntry.payload.data, index);
+        ref.payload.data ??= clusterResult;
+      }
+      return result;
+    }, {});
+  }
+
+  clusterByPayloadProperty(queueEntriesWithPayloadMap, propertyName, cb) {
+    return this.clusterBase(
+      queueEntriesWithPayloadMap,
+      propertyName,
+      (result, payload) => {
+        const parts = propertyName.split(".");
+        const data = JSON.parse(JSON.stringify(payload.data));
+        let ref = payload;
+        for (const part of parts) {
+          ref = ref[part];
+        }
+        result[ref[propertyName]] ??= {
+          queueEntries: [],
+          payload: { ...payload, data },
+        };
+        return result[ref[propertyName]];
+      },
+      cb
+    );
+  }
+
+  clusterByEventProperty(queueEntriesWithPayloadMap, propertyName, cb) {
+    return this.clusterBase(
+      queueEntriesWithPayloadMap,
+      propertyName,
+      (result, payload, queueEntry) => {
+        const parts = propertyName.split(".");
+        const payloadCopy = JSON.parse(JSON.stringify(payload));
+        let ref = queueEntry;
+        for (const part of parts) {
+          ref = ref[part];
+        }
+        result[queueEntry[propertyName]] ??= {
+          queueEntries: [],
+          payload: payloadCopy,
+        };
+        return result[queueEntry[propertyName]];
+      },
+      cb
+    );
+  }
+
+  #clusterByAction(queueEntriesWithPayloadMap) {
+    return Object.entries(queueEntriesWithPayloadMap).reduce(
+      (result, [eventId, clusterData]) => {
+        const hasSpecificClusterHandler = this.#hasEventSpecificClusterHandler(clusterData.queueEntry);
+        if (hasSpecificClusterHandler && this.__specificClusterRelevantAndAvailable) {
+          result.specificClusterEvents[clusterData.payload.event] ??= {};
+          result.specificClusterEvents[clusterData.payload.event][eventId] = clusterData;
+        } else {
+          result.genericClusterEvents[eventId] = clusterData;
+        }
+        return result;
+      },
+      { genericClusterEvents: {}, specificClusterEvents: {} }
+    );
+  }
+
+  #addToProcessingMap(handlerCluster) {
+    for (const clusterKey in handlerCluster) {
+      const { payload, queueEntries } = handlerCluster[clusterKey];
+      for (const queueEntry of queueEntries) {
+        this.addEntryToProcessingMap(clusterKey, queueEntry, payload);
+      }
+    }
+  }
+
+  // NOTE: Currently not exposed to CAP service; I don't see any valid use case at this time
+  modifyQueueEntry(queueEntry) {
+    super.modifyQueueEntry(queueEntry);
+    const hasSpecificClusterHandler = this.#hasEventSpecificClusterHandler(queueEntry);
+    if (this.__specificClusterHandler && hasSpecificClusterHandler) {
+      this.__specificClusterRelevantAndAvailable = true;
+    }
+    if (this.__genericClusterHandler && !hasSpecificClusterHandler) {
+      this.__genericClusterRelevantAndAvailable = true;
+    }
+  }
+
+  #hasEventSpecificClusterHandler(queueEntry) {
+    return !!this.__onHandlers[["clusterQueueEntries", queueEntry.payload.event].join(".")];
+  }
+
+  async checkEventAndGeneratePayload(queueEntry) {
+    const payload = await super.checkEventAndGeneratePayload(queueEntry);
+    const { event } = payload;
+    const handlerName = this.#checkHandlerExists("checkEventAndGeneratePayload", event);
+    if (!handlerName) {
+      return payload;
+    }
+
+    const { msg, userId } = this.#buildDispatchData(this.context, payload, {
+      queueEntries: [queueEntry],
+    });
+    msg.event = handlerName;
+    await this.#setContextUser(this.context, userId);
+    const data = await this.__srvUnboxed.tx(this.context).send(msg);
+    if (data) {
+      payload.data = data;
+      return payload;
+    } else {
+      return null;
+    }
+  }
+
+  // simple here as per entry
+  async hookForExceededEvents(exceededEvent) {
+    return await super.hookForExceededEvents(exceededEvent);
+  }
+
+  async beforeProcessingEvents() {
+    return await super.beforeProcessingEvents();
+  }
+
+  // maybe async getter on req.data // only for periodic events
+  // getLastSuccessfulRunTimestamp
+
+  #checkHandlerExists(eventQueueFn, event) {
+    const specificHandler = this.__onHandlers[[eventQueueFn, event].join(".")];
+    if (specificHandler) {
+      return specificHandler;
+    }
+
+    const genericHandler = this.__onHandlers[eventQueueFn];
+    return genericHandler ?? null;
+  }
+
   async processPeriodicEvent(processContext, key, queueEntry) {
-    const [serviceName, action] = this.eventSubType.split(".");
-    const service = await cds.connect.to(serviceName);
-    const msg = new cds.Event({ event: action });
-    processContext.user = new cds.User.Privileged({
-      id: config.userId,
-      authInfo: await common.getTokenInfo(processContext.tenant),
+    const [, action] = this.eventSubType.split(".");
+    const msg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    await this.#setContextUser(processContext, config.userId);
+    await this.__srvUnboxed.tx(processContext).emit(msg);
+  }
+
+  #buildDispatchData(context, payload, { key, queueEntries } = {}) {
+    const { useEventQueueUser } = this.eventConfig;
+    const userId = useEventQueueUser ? config.userId : payload.contextUser;
+    const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
+    const invocationFn = payload._fromSend ? "send" : "emit";
+    delete msg._fromSend; // TODO: this changes the source object --> check after multiple invocations
+    delete msg.contextUser;
+    msg.eventQueue = { processor: this, key, queueEntries, payload };
+    return { msg, userId, invocationFn };
+  }
+
+  async #setContextUser(context, userId) {
+    context.user = new cds.User.Privileged({
+      id: userId,
+      authInfo: await common.getTokenInfo(this.baseContext.tenant),
     });
-    processContext._eventQueue = { processor: this, key, queueEntries: [queueEntry] };
-    await cds.unboxed(service).tx(processContext)["emit"](msg);
   }
 
   async processEvent(processContext, key, queueEntries, payload) {
     try {
-      const [srvName] = this.eventSubType.split(".");
-      const service = await cds.connect.to(srvName);
-      const { useEventQueueUser } = this.eventConfig;
-      const userId = useEventQueueUser ? config.userId : payload.contextUser;
-      const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
-      const invocationFn = payload._fromSend ? "send" : "emit";
-      delete msg._fromSend;
-      delete msg.contextUser;
-      processContext.user = new cds.User.Privileged({
-        id: userId,
-        authInfo: await common.getTokenInfo(processContext.tenant),
-      });
-      processContext._eventQueue = { processor: this, key, queueEntries, payload };
-      const result = await cds.unboxed(service).tx(processContext)[invocationFn](msg);
+      const { userId, invocationFn, msg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
+      await this.#setContextUser(processContext, userId);
+      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](msg);
       return this.#determineResultStatus(result, queueEntries);
     } catch (err) {
       this.logger.error("error processing outboxed service call", err, {

package/src/outbox/eventQueueAsOutbox.js

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

package/src/processEventQueue.js

@@ -79,7 +79,7 @@ const processEventQueue = async (context, eventType, eventSubType) => {
         await executeInNewTransaction(context, `eventQueue-processing-${eventType}##${eventSubType}`, async (tx) => {
           eventTypeInstance.processEventContext = tx.context;
           try {
-            eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
+            await eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
             await processEventMap(eventTypeInstance);
           } catch (err) {
             eventTypeInstance.handleErrorDuringClustering(err);

package/src/publishEvent.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { CronExpressionParser } = require("cron-parser");
+
 const config = require("./config");
 const common = require("./shared/common");
 const EventQueueError = require("./EventQueueError");
@@ -60,6 +62,10 @@ const publishEvent = async (
     if (addTraceContext) {
       event.context = JSON.stringify({ traceContext: openTelemetry.getCurrentTraceContext() });
     }
+
+    if (eventConfig.timeBucket) {
+      event.startAfter ??= CronExpressionParser.parse(eventConfig.timeBucket).next().toISOString();
+    }
   }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);

package/src/runner/runner.js

@@ -18,10 +18,10 @@ const { runEventCombinationForTenant } = require("./runnerHelper");
 const { trace } = require("../shared/openTelemetry");
 
 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_REDIS_CHECK = "EVENT_QUEUE_RUN_REDIS_CHECK";
-const EVENT_QUEUE_UPDATE_PERIODIC_EVENTS = "EVENT_QUEUE_UPDATE_PERIODIC_EVENTS";
+const EVENT_QUEUE_RUN_ID = "RUN_ID";
+const EVENT_QUEUE_RUN_TS = "RUN_TS";
+const EVENT_QUEUE_RUN_REDIS_CHECK = "RUN_REDIS_CHECK";
+const EVENT_QUEUE_UPDATE_PERIODIC_EVENTS = "UPDATE_PERIODIC_EVENTS";
 let OFFSET_FIRST_RUN = 10 * 1000;
 
 let tenantIdHash;

package/src/shared/distributedLock.js

@@ -4,7 +4,6 @@ const redis = require("./redis");
 const config = require("../config");
 const cdsHelper = require("./cdsHelper");
 
-const KEY_PREFIX = "EVENT_QUEUE";
 const existingLocks = {};
 const REDIS_COMMAND_OK = "OK";
 const COMPONENT_NAME = "/eventQueue/distributedLock";
@@ -176,10 +175,10 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
 };
 
 const _generateKey = (context, tenantScoped, key) => {
-  const keyParts = [];
+  const keyParts = [config.redisOptions.redisNamespace];
   tenantScoped && keyParts.push(context.tenant);
   keyParts.push(key);
-  return `${KEY_PREFIX}_${keyParts.join("##")}`;
+  return `${keyParts.join("##")}`;
 };
 
 const shutdownHandler = async () => {

package/src/shared/redis.js

@@ -46,6 +46,7 @@ const _createClientBase = (redisOptions = {}) => {
       password: redisOptions.password ?? options.password ?? credentials.password,
       socket,
     });
+    delete socketOptions.redisNamespace;
     if (credentials.cluster_mode) {
       return redis.createCluster({
         rootNodes: [socketOptions],
@@ -106,9 +107,10 @@ const _subscribeChannels = (options, subscribedChannels, errorHandlerCreateClien
         if (client._subscribedChannels[channel]) {
           continue;
         }
-        cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });
+        const prefixedChannelName = [options.redisNamespace, channel].join("_");
+        cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel: prefixedChannelName });
         client
-          .subscribe(channel, fn)
+          .subscribe(prefixedChannelName, fn)
           .then(() => {
             client._subscribedChannels ??= {};
             client._subscribedChannels[channel] = 1;
@@ -133,7 +135,7 @@ const _subscribeChannels = (options, subscribedChannels, errorHandlerCreateClien
 
 const publishMessage = async (options, channel, message) => {
   const client = await createMainClientAndConnect(options);
-  return await client.publish(channel, message);
+  return await client.publish([options.redisNamespace, channel].join("_"), message);
 };
 
 const closeMainClient = async () => {