@cap-js-community/event-queue 2.0.0-beta.6 → 2.0.0-beta.8

package/package.json

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

@@ -353,12 +353,14 @@ class EventQueueProcessorBase {
       statusMap[id] = statusOrUpdateData;
       return;
     }
+
     if ([EventProcessingStatus.Error, EventProcessingStatus.Exceeded].includes(statusMap[id].status)) {
       // NOTE: worst aggregation --> if already error|exceeded keep this state
       return;
     }
-    if (statusMap[id].status >= 0) {
-      statusMap[id] = { status: statusOrUpdateData };
+
+    if (statusMap[id].status >= statusOrUpdateData.status) {
+      statusMap[id] = statusOrUpdateData;
     }
   }
 
@@ -407,7 +409,7 @@ class EventQueueProcessorBase {
       if (typeof entry === "number") {
         result.status = entry;
       } else if (typeof entry === "object") {
-        for (const fieldName of ALLOWED_FIELDS_FOR_UPDATE) {
+        for (const fieldName of this.allowedFieldsEventHandler) {
           if (fieldName in entry) {
             result[fieldName] = entry[fieldName];
           }
@@ -442,7 +444,8 @@ class EventQueueProcessorBase {
       });
       const ts = new Date().toISOString();
       const updateData = Object.entries(statusMap).reduce((result, [id, data]) => {
-        const key = ALLOWED_FIELDS_FOR_UPDATE.map((name) => [name, data[name]])
+        const key = this.allowedFieldsEventHandler
+          .map((name) => [name, data[name]])
           .flat()
           .join("##");
 
@@ -1358,6 +1361,10 @@ class EventQueueProcessorBase {
   get namespace() {
     return this.#namespace;
   }
+
+  get allowedFieldsEventHandler() {
+    return ALLOWED_FIELDS_FOR_UPDATE;
+  }
 }
 
 module.exports = EventQueueProcessorBase;

package/src/config.js

@@ -143,7 +143,7 @@ class Config {
   }
 
   isCapOutboxEvent(type) {
-    return type === CAP_EVENT_TYPE;
+    return [CAP_EVENT_TYPE, [CAP_EVENT_TYPE, SUFFIX_PERIODIC].join("")].includes(type);
   }
 
   hasEventAfterCommitFlag(type, subType, namespace = this.namespace) {
@@ -168,15 +168,27 @@ class Config {
     return { type: "string", value: str };
   }
 
-  #normalizeSubType(rawSubType) {
-    const [serviceName, actionName] = rawSubType.split(".");
-    const actionSpecificCall = this.getCdsOutboxEventSpecificConfig(serviceName, actionName);
-    return actionSpecificCall ? rawSubType : serviceName;
+  normalizeSubType(type, rawSubType) {
+    if (![CAP_EVENT_TYPE, [CAP_EVENT_TYPE, SUFFIX_PERIODIC].join("")].includes(type)) {
+      return { subType: rawSubType };
+    }
+
+    const serviceParts = rawSubType.split(".");
+    let srvName = serviceParts.shift();
+    while (!cds.env.requires[srvName] && serviceParts.length) {
+      srvName = [srvName, serviceParts.shift()].join(".");
+    }
+    const actionName = serviceParts.shift();
+    const actionSpecificCall = this.getCdsOutboxEventSpecificConfig(srvName, actionName);
+    return {
+      subType: actionSpecificCall ? rawSubType : srvName,
+      actionName,
+      srvName,
+    };
   }
 
   shouldBeProcessedInThisApplication(type, rawSubType, namespace = this.namespace) {
-    const subType = this.#normalizeSubType(rawSubType);
-
+    const { subType } = this.normalizeSubType(type, rawSubType);
     const config = this.#eventMap[this.generateKey(namespace, type, subType)];
     const appNameConfig = config._appNameMap;
     const appInstanceConfig = config._appInstancesMap;

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -22,8 +22,8 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
   }
 
   async getQueueEntriesAndSetToInProgress() {
-    const [serviceName] = this.eventSubType.split(".");
-    this.__srv = await cds.connect.to(serviceName);
+    const { srvName } = config.normalizeSubType(this.eventType, this.eventSubType);
+    this.__srv = await cds.connect.to(srvName);
     this.__srvUnboxed = cds.unboxed(this.__srv);
     const { handlers, clusterRelevant, specificClusterRelevant } = this.__srvUnboxed.handlers.on.reduce(
       (result, handler) => {
@@ -309,8 +309,8 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
   }
 
   async processPeriodicEvent(processContext, key, queueEntry) {
-    const [, action] = this.eventSubType.split(".");
-    const reg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    const { actionName } = config.normalizeSubType(this.eventType, this.eventSubType);
+    const reg = new cds.Event({ event: actionName, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
     await this.#setContextUser(processContext, config.userId, reg);
     await this.__srvUnboxed.tx(processContext).emit(reg);
   }
@@ -366,7 +366,11 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     }
 
     if (result instanceof Object && !Array.isArray(result)) {
-      return queueEntries.map((queueEntry) => [queueEntry.ID, result]);
+      const allAllowed = !Object.keys(result).some((name) => !this.allowedFieldsEventHandler.includes(name));
+      return queueEntries.map((queueEntry) => [
+        queueEntry.ID,
+        allAllowed ? result : { status: EventProcessingStatus.Done },
+      ]);
     }
 
     if (!Array.isArray(result)) {
@@ -377,7 +381,11 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     if (Array.isArray(firstEntry)) {
       const [, innerResult] = firstEntry;
       if (innerResult instanceof Object) {
-        return result;
+        const allAllowed = !Object.keys(innerResult).some((name) => !this.allowedFieldsEventHandler.includes(name));
+        if (allAllowed) {
+          return result;
+        }
+        return queueEntries.map((queueEntry) => [queueEntry.ID, { status: EventProcessingStatus.Done }]);
       } else {
         return result.map(([id, status]) => {
           return [id, { status }];
@@ -398,6 +406,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
         }
 
         delete entry.ID;
+        const allAllowed = !Object.keys(entry).some((name) => !this.allowedFieldsEventHandler.includes(name));
+
+        if (!allAllowed) {
+          result.push([ID, { status: EventProcessingStatus.Done }]);
+        }
+
         if (!("status" in entry)) {
           entry.status = EventProcessingStatus.Done;
         }

package/src/redis/redisSub.js

@@ -43,16 +43,16 @@ const _messageHandlerProcessEvents = async (messageData) => {
       return;
     }
 
-    const [serviceNameOrSubType, actionName] = subType.split(".");
+    const { srvName, actionName } = config.normalizeSubType(type, subType);
     if (!config.getEventConfig(type, subType, namespace)) {
       if (config.isCapOutboxEvent(type)) {
         try {
-          const service = await cds.connect.to(serviceNameOrSubType);
+          const service = await cds.connect.to(srvName);
           cds.outboxed(service);
           if (actionName) {
-            const specificSettings = config.getCdsOutboxEventSpecificConfig(serviceNameOrSubType, actionName);
+            const specificSettings = config.getCdsOutboxEventSpecificConfig(srvName, actionName);
             if (specificSettings) {
-              config.addCAPOutboxEventSpecificAction(serviceNameOrSubType, actionName);
+              config.addCAPOutboxEventSpecificAction(srvName, actionName);
             }
           }
         } catch (err) {

package/src/runner/openEvents.js

@@ -39,7 +39,7 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const result = [];
   for (const { type, subType, namespace } of entries) {
     if (eventConfig.isCapOutboxEvent(type)) {
-      const [srvName, actionName] = subType.split(".");
+      const { srvName, actionName } = config.normalizeSubType(type, subType);
       try {
         const service = await cds.connect.to(srvName);
         if (filterAppSpecificEvents) {