@cap-js-community/event-queue 1.4.5 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "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",
@@ -44,16 +44,16 @@
   },
   "dependencies": {
     "@sap/xssec": "^3.6.1",
-    "redis": "^4.6.13",
+    "redis": "^4.6.14",
     "verror": "^1.10.1",
-    "yaml": "^2.4.1"
+    "yaml": "^2.4.2"
   },
   "devDependencies": {
-    "@cap-js/hana": "^0.1.0",
-    "@cap-js/sqlite": "^1.5.0",
-    "@sap/cds": "^7.8.0",
+    "@cap-js/hana": "^0.4.0",
+    "@cap-js/sqlite": "^1.7.1",
+    "@sap/cds": "^7.9.2",
     "@sap/cds-dk": "^7.8.0",
-    "eslint": "^8.56.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^27.9.0",
     "eslint-plugin-node": "^11.1.0",

package/src/config.js

@@ -10,7 +10,8 @@ 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_CONFIG_BLOCKLIST_CHANNEL = "REDIS_CONFIG_BLOCKLIST_CHANNEL";
+const REDIS_OFFBOARD_TENANT_CHANNEL = "REDIS_OFFBOARD_TENANT_CHANNEL";
+const REDIS_CONFIG_BLOCKLIST_CHANNEL = "EVENT_QUEUE_REDIS_CONFIG_BLOCKLIST_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/config";
 const MIN_INTERVAL_SEC = 10;
 const DEFAULT_LOAD = 1;
@@ -19,8 +20,8 @@ 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;
 
 const BASE_PERIODIC_EVENTS = [
   {
@@ -67,6 +68,8 @@ class Config {
   #cleanupLocksAndEventsForDev;
   #redisOptions;
   #insertEventsBeforeCommit;
+  #unsubscribeHandlers = [];
+  #unsubscribedTenants = {};
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -126,6 +129,51 @@ class Config {
     });
   }
 
+  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);
+    for (const unsubscribeHandler of this.#unsubscribeHandlers) {
+      try {
+        unsubscribeHandler(tenantId);
+      } catch (err) {
+        this.#logger.error("could executing unsubscribe handler", err, {
+          tenantId,
+        });
+      }
+    }
+  }
+
+  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 });
@@ -320,6 +368,10 @@ class Config {
     delete this.#eventMap[this.generateKey(type, subType)];
   }
 
+  isTenantUnsubscribed(tenantId) {
+    return this.#unsubscribedTenants[tenantId];
+  }
+
   get fileContent() {
     return this.#config;
   }

package/src/dbHandler.js

@@ -2,7 +2,7 @@
 
 const cds = require("@sap/cds");
 
-const { broadcastEvent } = require("./redis/redisPub");
+const redisPub = require("./redis/redisPub");
 const config = require("./config");
 
 const COMPONENT_NAME = "/eventQueue/dbHandler";
@@ -25,7 +25,7 @@ const registerEventQueueDbHandler = (dbService) => {
     req.tx._ = req.tx._ ?? {};
     req.tx._.eventQueuePublishEvents = req.tx._.eventQueuePublishEvents ?? {};
     const eventQueuePublishEvents = req.tx._.eventQueuePublishEvents;
-    const data = Array.isArray(req.data) ? req.data : [req.data];
+    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("##");
@@ -45,7 +45,7 @@ const registerEventQueueDbHandler = (dbService) => {
           return { type, subType };
         });
 
-        broadcastEvent(req.tenant, events).catch((err) => {
+        redisPub.broadcastEvent(req.tenant, events).catch((err) => {
           cds.log(COMPONENT_NAME).error("db handler failure during broadcasting event", err, {
             tenant: req.tenant,
             events,

package/src/index.d.ts

@@ -136,3 +136,75 @@ export function processEventQueue(
   eventSubType: string,
   startTime: Date
 ): Promise<any>;
+
+declare class Config {
+  constructor();
+
+  getEventConfig(type: string, subType: string): any;
+  isCapOutboxEvent(type: string): boolean;
+  hasEventAfterCommitFlag(type: string, subType: string): boolean;
+  _checkRedisIsBound(): boolean;
+  checkRedisEnabled(): boolean;
+  attachConfigChangeHandler(): void;
+  attachRedisUnsubscribeHandler(): void;
+  executeUnsubscribeHandlers(tenantId: string): void;
+  handleUnsubscribe(tenantId: string): void;
+  attachUnsubscribeHandler(cb: Function): void;
+  publishConfigChange(key: string, value: any): void;
+  blockEvent(type: string, subType: string, isPeriodic: boolean, tenant?: string): void;
+  clearPeriodicEventBlockList(): void;
+  unblockEvent(type: string, subType: string, isPeriodic: boolean, tenant?: string): void;
+  addCAPOutboxEvent(serviceName: string, config: any): void;
+  isEventBlocked(type: string, subType: string, isPeriodicEvent: boolean, tenant: string): boolean;
+  get isEventQueueActive(): boolean;
+  set isEventQueueActive(value: boolean);
+  set fileContent(config: any);
+  get fileContent(): any;
+  get events(): any[];
+  get periodicEvents(): any[];
+  isPeriodicEvent(type: string, subType: string): boolean;
+  get allEvents(): any[];
+  get forUpdateTimeout(): number;
+  get globalTxTimeout(): number;
+  set forUpdateTimeout(value: number);
+  set globalTxTimeout(value: number);
+  get runInterval(): number | null;
+  set runInterval(value: number);
+  get redisEnabled(): boolean | null;
+  set redisEnabled(value: boolean | null);
+  get initialized(): boolean;
+  set initialized(value: boolean);
+  get instanceLoadLimit(): number;
+  set instanceLoadLimit(value: number);
+  get isEventBlockedCb(): any;
+  set isEventBlockedCb(value: any);
+  get tableNameEventQueue(): string;
+  get tableNameEventLock(): string;
+  set configFilePath(value: string | null);
+  get configFilePath(): string | null;
+  set processEventsAfterPublish(value: any);
+  get processEventsAfterPublish(): any;
+  set skipCsnCheck(value: any);
+  get skipCsnCheck(): any;
+  set disableRedis(value: any);
+  get disableRedis(): any;
+  set updatePeriodicEvents(value: any);
+  get updatePeriodicEvents(): any;
+  set registerAsEventProcessor(value: any);
+  get registerAsEventProcessor(): any;
+  set thresholdLoggingEventProcessing(value: any);
+  get thresholdLoggingEventProcessing(): any;
+  set useAsCAPOutbox(value: any);
+  get useAsCAPOutbox(): any;
+  set userId(value: any);
+  get userId(): any;
+  set cleanupLocksAndEventsForDev(value: any);
+  get cleanupLocksAndEventsForDev(): any;
+  set redisOptions(value: any);
+  get redisOptions(): any;
+  set insertEventsBeforeCommit(value: any);
+  get insertEventsBeforeCommit(): any;
+  get isMultiTenancy(): boolean;
+}
+
+export const config: Config;

package/src/initialize.js

@@ -128,6 +128,24 @@ const readConfigFromFile = async (configFilepath) => {
 };
 
 const registerEventProcessors = () => {
+  cds.on("listening", () => {
+    cds.connect
+      .to("cds.xt.DeploymentService")
+      .then((ds) => {
+        cds.log(COMPONENT).info("event-queue unsubscribe handler registered", {
+          redisEnabled: config.redisEnabled,
+        });
+        ds.after("unsubscribe", async (_, req) => {
+          const { tenant } = req.data;
+          config.handleUnsubscribe(tenant);
+        });
+      })
+      .catch(
+        () => {} // ignore errors as the DeploymentService is most of the time only available in the mtx sidecar
+      );
+  });
+  config.redisEnabled && config.attachRedisUnsubscribeHandler();
+
   if (!config.registerAsEventProcessor) {
     return;
   }

package/src/processEventQueue.js

@@ -268,10 +268,15 @@ const _checkEventIsBlocked = async (baseInstance) => {
     );
   }
 
+  if (!eventBlocked) {
+    eventBlocked = config.isTenantUnsubscribed(baseInstance.context.tenant);
+  }
+
   if (eventBlocked) {
     baseInstance.logger.info("skipping run because event is blocked by configuration", {
       type: baseInstance.eventType,
       subType: baseInstance.eventSubType,
+      tenantUnsubscribed: config.isTenantUnsubscribed(baseInstance.context.tenant),
     });
   }
   return eventBlocked;

package/src/shared/eventScheduler.js

@@ -10,7 +10,10 @@ const COMPONENT_NAME = "/eventQueue/shared/eventScheduler";
 let instance;
 class EventScheduler {
   #scheduledEvents = {};
-  constructor() {}
+  #eventsByTenants = {};
+  constructor() {
+    config.attachUnsubscribeHandler(this.clearForTenant.bind(this));
+  }
 
   scheduleEvent(tenantId, type, subType, startAfter) {
     const { date, relative } = this.calculateOffset(type, subType, startAfter);
@@ -37,6 +40,8 @@ class EventScheduler {
     }, relative).unref();
   }
 
+  clearForTenant() {}
+
   calculateOffset(type, subType, startAfter) {
     const eventConfig = config.getEventConfig(type, subType);
     const scheduleWithoutDelay = config.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;