@cap-js-community/event-queue 1.6.6 → 1.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.6.6",
+  "version": "1.6.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",
@@ -43,22 +43,22 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@sap/xssec": "^4.2.1",
+    "@sap/xssec": "^4.2.4",
     "redis": "^4.7.0",
     "verror": "^1.10.1",
-    "yaml": "^2.5.0"
+    "yaml": "^2.5.1"
   },
   "devDependencies": {
-    "@cap-js/hana": "^1.1.1",
+    "@sap/cds": "^8.3.0",
+    "@sap/cds-dk": "^8.3.0",
+    "@cap-js/hana": "^1.3.0",
     "@cap-js/sqlite": "^1.7.3",
-    "@sap/cds": "^8.1.0",
-    "@sap/cds-dk": "^8.1.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^28.6.0",
     "eslint-plugin-node": "^11.1.0",
-    "express": "^4.18.2",
-    "hdb": "^0.19.7",
+    "express": "^4.21.0",
+    "hdb": "^0.19.10",
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
     "sqlite3": "^5.1.7"

package/src/EventQueueError.js

@@ -19,6 +19,7 @@ const ERROR_CODES = {
   LOAD_HIGHER_THAN_LIMIT: "LOAD_HIGHER_THAN_LIMIT",
   NOT_ALLOWED_PRIORITY: "NOT_ALLOWED_PRIORITY",
   APP_NAMES_FORMAT: "APP_NAMES_FORMAT",
+  APP_INSTANCES_FORMAT: "APP_INSTANCES_FORMAT",
 };
 
 const ERROR_CODES_META = {
@@ -71,6 +72,9 @@ const ERROR_CODES_META = {
   [ERROR_CODES.APP_NAMES_FORMAT]: {
     message: "The app names property must be an array and only contain strings.",
   },
+  [ERROR_CODES.APP_INSTANCES_FORMAT]: {
+    message: "The app instances property must be an array and only contain numbers.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -250,6 +254,17 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static appInstancesFormat(type, subType, appInstances) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.APP_INSTANCES_FORMAT];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.APP_INSTANCES_FORMAT,
+        info: { type, subType, appInstances },
+      },
+      message
+    );
+  }
 }
 
 module.exports = EventQueueError;

package/src/config.js

@@ -22,6 +22,7 @@ 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 PRIORITIES = Object.values(Priorities);
 
 const BASE_PERIODIC_EVENTS = [
   {
@@ -110,7 +111,27 @@ class Config {
 
   shouldBeProcessedInThisApplication(type, subType) {
     const config = this.#eventMap[this.generateKey(type, subType)];
-    return !config._appNameMap || config._appNameMap[this.#env.applicationName];
+    const appNameConfig = config._appNameMap;
+    const appInstanceConfig = config._appInstancesMap;
+    if (!appNameConfig && !appInstanceConfig) {
+      return true;
+    }
+
+    if (appNameConfig) {
+      const shouldBeProcessedBasedOnAppName = appNameConfig[this.#env.applicationName];
+      if (!shouldBeProcessedBasedOnAppName) {
+        return false;
+      }
+    }
+
+    if (appInstanceConfig) {
+      const shouldBeProcessedBasedOnAppInstance = appInstanceConfig[this.#env.applicationInstance];
+      if (!shouldBeProcessedBasedOnAppInstance) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
   checkRedisEnabled() {
@@ -282,12 +303,11 @@ class Config {
       checkForNextChunk: config.checkForNextChunk,
       deleteFinishedEventsAfterDays: config.deleteFinishedEventsAfterDays,
       appNames: config.appNames,
+      appInstances: config.appInstances,
       useEventQueueUser: config.useEventQueueUser,
       internalEvent: true,
     };
-    eventConfig._appNameMap = eventConfig.appNames
-      ? Object.fromEntries(new Map(eventConfig.appNames.map((a) => [a, true])))
-      : null;
+    this.#basicEventTransformationAfterValidate(eventConfig);
     this.#config.events.push(eventConfig);
     this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)] = eventConfig;
   }
@@ -324,55 +344,83 @@ class Config {
     config.events = config.events ?? [];
     config.periodicEvents = (config.periodicEvents ?? []).concat(BASE_PERIODIC_EVENTS.map((event) => ({ ...event })));
     this.#eventMap = config.events.reduce((result, event) => {
-      event.load = event.load ?? DEFAULT_LOAD;
-      event.priority = event.priority ?? DEFAULT_PRIORITY;
-      this.validateAdHocEvents(result, event);
-      event._appNameMap = event.appNames ? Object.fromEntries(new Map(event.appNames.map((a) => [a, true]))) : null;
+      this.#basicEventTransformation(event);
+      this.#validateAdHocEvents(result, event);
+      this.#basicEventTransformationAfterValidate(event);
       result[this.generateKey(event.type, event.subType)] = event;
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
-      event.load = event.load ?? DEFAULT_LOAD;
       event.priority = event.priority ?? DEFAULT_PRIORITY;
       event.type = `${event.type}${SUFFIX_PERIODIC}`;
       event.isPeriodic = true;
-      this.validatePeriodicConfig(result, event);
-      event._appNameMap = event.appNames ? Object.fromEntries(new Map(event.appNames.map((a) => [a, true]))) : null;
+      this.#basicEventTransformation(event);
+      this.#validatePeriodicConfig(result, event);
+      this.#basicEventTransformationAfterValidate(event);
       result[this.generateKey(event.type, event.subType)] = event;
       return result;
     }, this.#eventMap);
   }
 
-  validatePeriodicConfig(eventMap, config) {
-    const key = this.generateKey(config.type, config.subType);
-    if (eventMap[key] && eventMap[key].isPeriodic) {
-      throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
+  #basicEventTransformation(event) {
+    event.load = event.load ?? DEFAULT_LOAD;
+    event.priority = event.priority ?? DEFAULT_PRIORITY;
+  }
+
+  #basicEventTransformationAfterValidate(event) {
+    event._appNameMap = event.appNames ? Object.fromEntries(new Map(event.appNames.map((a) => [a, true]))) : null;
+    event._appInstancesMap = event.appInstances
+      ? Object.fromEntries(new Map(event.appInstances.map((a) => [a, true])))
+      : null;
+  }
+
+  #basicEventValidation(event) {
+    if (!event.impl) {
+      throw EventQueueError.missingImpl(event.type, event.subType);
     }
 
-    if (!config.interval || config.interval <= MIN_INTERVAL_SEC) {
-      throw EventQueueError.invalidInterval(config.type, config.subType, config.interval);
+    if (event.appNames) {
+      if (!Array.isArray(event.appNames) || event.appNames.some((appName) => typeof appName !== "string")) {
+        throw EventQueueError.appNamesFormat(event.type, event.subType, event.appNames);
+      }
     }
 
-    if (!config.impl) {
-      throw EventQueueError.missingImpl(config.type, config.subType);
+    if (event.appInstances) {
+      if (
+        !Array.isArray(event.appInstances) ||
+        event.appInstances.some((appInstance) => typeof appInstance !== "number")
+      ) {
+        throw EventQueueError.appInstancesFormat(event.type, event.subType, event.appInstances);
+      }
+    }
+
+    if (!PRIORITIES.includes(event.priority)) {
+      throw EventQueueError.priorityNotAllowed(event.priority, "initEvent");
+    }
+
+    if (event.load > this.#instanceLoadLimit) {
+      throw EventQueueError.loadHigherThanLimit(event.load, "initEvent");
     }
   }
 
-  validateAdHocEvents(eventMap, config) {
-    const key = this.generateKey(config.type, config.subType);
-    if (eventMap[key] && !eventMap[key].isPeriodic) {
-      throw EventQueueError.duplicateEventRegistration(config.type, config.subType);
+  #validatePeriodicConfig(eventMap, event) {
+    const key = this.generateKey(event.type, event.subType);
+    if (eventMap[key] && eventMap[key].isPeriodic) {
+      throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
 
-    if (!config.impl) {
-      throw EventQueueError.missingImpl(config.type, config.subType);
+    if (!event.interval || event.interval <= MIN_INTERVAL_SEC) {
+      throw EventQueueError.invalidInterval(event.type, event.subType, event.interval);
     }
+    this.#basicEventValidation(event);
+  }
 
-    if (config.appNames) {
-      if (!Array.isArray(config.appNames) || config.appNames.some((appName) => typeof appName !== "string")) {
-        throw EventQueueError.appNamesFormat(config.type, config.subType, config.appNames);
-      }
+  #validateAdHocEvents(eventMap, event) {
+    const key = this.generateKey(event.type, event.subType);
+    if (eventMap[key] && !eventMap[key].isPeriodic) {
+      throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
+    this.#basicEventValidation(event);
   }
 
   generateKey(type, subType) {

package/src/outbox/eventQueueAsOutbox.js

@@ -7,10 +7,9 @@ const config = require("../config");
 
 const OUTBOXED = Symbol("outboxed");
 const UNBOXED = Symbol("unboxed");
-
 const CDS_EVENT_TYPE = "CAP_OUTBOX";
-
 const COMPONENT_NAME = "/eventQueue/eventQueueAsOutbox";
+const EVENT_QUEUE_SPECIFIC_FIELDS = ["startAfter", "referenceEntity", "referenceEntityKey"];
 
 function outboxed(srv, customOpts) {
   // outbox max. once
@@ -74,12 +73,14 @@ function unboxed(srv) {
 }
 
 const _mapToEventAndPublish = async (context, name, req) => {
-  let startAfter;
+  const eventQueueSpecificValues = {};
   for (const header in req.headers ?? {}) {
-    if (header.toLocaleLowerCase() === "x-eventqueue-startafter") {
-      startAfter = req.headers[header];
-      delete req.headers[header];
-      break;
+    for (const field of EVENT_QUEUE_SPECIFIC_FIELDS) {
+      if (header.toLocaleLowerCase() === `x-eventqueue-${field.toLocaleLowerCase()}`) {
+        eventQueueSpecificValues[field] = req.headers[header];
+        delete req.headers[header];
+        break;
+      }
     }
   }
   const event = {
@@ -96,7 +97,7 @@ const _mapToEventAndPublish = async (context, name, req) => {
     type: CDS_EVENT_TYPE,
     subType: name,
     payload: JSON.stringify(event),
-    ...(startAfter && { startAfter }),
+    ...eventQueueSpecificValues,
   });
 };
 

package/src/runner/openEvents.js

@@ -5,7 +5,7 @@ const cds = require("@sap/cds");
 const eventConfig = require("../config");
 const { EventProcessingStatus } = require("../constants");
 
-const getOpenQueueEntries = async (tx) => {
+const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const startTime = new Date();
   const refDateStartAfter = new Date(startTime.getTime() + eventConfig.runInterval * 1.2);
   const entries = await tx.run(
@@ -37,14 +37,25 @@ const getOpenQueueEntries = async (tx) => {
             return;
           }
           cds.outboxed(service);
-          if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
+          if (filterAppSpecificEvents) {
+            if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
+              result.push({ type, subType });
+            }
+          } else {
             result.push({ type, subType });
           }
         })
         .catch(() => {});
     } else {
-      if (eventConfig.getEventConfig(type, subType) && eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
-        result.push({ type, subType });
+      if (filterAppSpecificEvents) {
+        if (
+          eventConfig.getEventConfig(type, subType) &&
+          eventConfig.shouldBeProcessedInThisApplication(type, subType)
+        ) {
+          result.push({ type, subType });
+        }
+      } else {
+        eventConfig.getEventConfig(type, subType) && result.push({ type, subType });
       }
     }
   }

package/src/runner/runner.js

@@ -134,7 +134,7 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
               id: config.userId,
               authInfo: await common.getAuthInfo(tenantId),
             });
-            const entries = await openEvents.getOpenQueueEntries(tx);
+            const entries = await openEvents.getOpenQueueEntries(tx, false);
             logger.info("broadcasting events for run", {
               tenantId,
               entries: entries.length,

package/src/shared/env.js

@@ -5,6 +5,7 @@ let instance;
 class Env {
   #vcapServices;
   #vcapApplication;
+  #vcapApplicationInstance;
 
   constructor() {
     try {
@@ -14,6 +15,7 @@ class Env {
       this.#vcapServices = {};
       this.#vcapApplication = {};
     }
+    this.#vcapApplicationInstance = Number(process.env.CF_INSTANCE_INDEX);
   }
 
   get redisCredentialsFromEnv() {
@@ -24,6 +26,10 @@ class Env {
     return this.#vcapApplication.application_name;
   }
 
+  get applicationInstance() {
+    return this.#vcapApplicationInstance;
+  }
+
   set vcapServices(value) {
     this.#vcapServices = value;
   }
@@ -32,6 +38,10 @@ class Env {
     return this.#vcapServices;
   }
 
+  set applicationInstance(value) {
+    this.#vcapApplicationInstance = value;
+  }
+
   set vcapApplication(value) {
     this.#vcapApplication = value;
   }