@cap-js-community/event-queue 1.10.8 → 1.10.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.10.8",
+  "version": "1.10.10",
   "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",
@@ -54,17 +54,17 @@
     "yaml": "^2.7.1"
   },
   "devDependencies": {
-    "@cap-js/cds-test": "^0.3.0",
+    "@cap-js/cds-test": "^0.4.0",
     "@cap-js/hana": "^2.1.0",
     "@cap-js/sqlite": "^2.0.1",
-    "@sap/cds": "^9.0.3",
-    "@sap/cds-dk": "^9.0.4",
+    "@sap/cds": "^9.1.0",
+    "@sap/cds-dk": "^9.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.21.2",
-    "hdb": "^0.19.10",
+    "hdb": "^2.25.1",
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
     "sqlite3": "^5.1.7",

package/src/config.js

@@ -484,10 +484,11 @@ class Config {
               delete base.interval;
             }
 
-            result[fnName] = Object.assign(
+            const subType = `${name}.${fnName}`;
+            result[subType] = Object.assign(
               {
                 type: CAP_EVENT_TYPE,
-                subType: `${name}.${fnName}`,
+                subType,
                 impl: "./outbox/EventQueueGenericOutboxHandler",
                 internalEvent: true,
               },

package/src/periodicEvents.js

@@ -15,6 +15,9 @@ const COMPONENT_NAME = "/eventQueue/periodicEvents";
 
 const checkAndInsertPeriodicEvents = async (context) => {
   const now = new Date();
+  cds.log(COMPONENT_NAME).info("updating periodic events", {
+    tenant: context.tenant,
+  });
   const tx = cds.tx(context);
   const baseCqn = SELECT.from(eventConfig.tableNameEventQueue)
     .where([

package/src/runner/openEvents.js

@@ -40,23 +40,17 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
       const [srvName, actionName] = subType.split(".");
       try {
         const service = await cds.connect.to(srvName);
-        if (!filterAppSpecificEvents) {
-          return; // will be done in finally
-        }
-
-        if (!service) {
-          return;
-        }
-        cds.outboxed(service);
-        if (actionName) {
-          config.addCAPOutboxEventSpecificAction(srvName, actionName);
-        }
         if (filterAppSpecificEvents) {
+          if (!service) {
+            continue;
+          }
+          cds.outboxed(service);
+          if (actionName) {
+            config.addCAPOutboxEventSpecificAction(srvName, actionName);
+          }
           if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
             result.push({ type, subType });
           }
-        } else {
-          result.push({ type, subType });
         }
       } catch {
         /* ignore catch */

package/src/runner/runner.js

@@ -509,6 +509,7 @@ const _checkPeriodicEventsSingleTenantOneTime = async () => {
         tenantScoped: false,
       });
       if (!couldAcquireLock) {
+        logger.info("skipping updating periodic events - lock not acquired");
         return;
       }
       return await cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));

package/src/shared/cdsHelper.js

@@ -150,7 +150,9 @@ const getAllTenantIds = async () => {
     }, []);
 };
 
-const getAllTenantWithSubdomain = async () => {
+const TENANT_COLUMNS = ["subscribedSubdomain", "createdAt", "modifiedAt"];
+
+const getAllTenantWithMetadata = async () => {
   const response = await _getAllTenantBase();
   if (!response) {
     return null;
@@ -160,10 +162,19 @@ const getAllTenantWithSubdomain = async () => {
     const tenantId = row.subscribedTenantId ?? row.tenant;
     result = await result;
     if (await common.isTenantIdValidCb(TenantIdCheckTypes.eventProcessing, tenantId)) {
-      result.push({
-        ID: tenantId,
-        subdomain: row.subscribedSubdomain,
-      });
+      const data = Object.entries(row).reduce(
+        (result, [key, value]) => {
+          if (TENANT_COLUMNS.includes(key)) {
+            result[key] = value;
+          } else {
+            result.metadata[key] = value;
+          }
+          return result;
+        },
+        { metadata: {} }
+      );
+      data.metadata = JSON.stringify(data.metadata);
+      result.push(data);
     }
     return result;
   }, []);
@@ -172,5 +183,5 @@ const getAllTenantWithSubdomain = async () => {
 module.exports = {
   executeInNewTransaction,
   getAllTenantIds,
-  getAllTenantWithSubdomain,
+  getAllTenantWithMetadata,
 };

package/src/shared/distributedLock.js

@@ -121,8 +121,9 @@ const _checkLockExistsDb = async (context, fullKey) => {
 
 const _releaseLockRedis = async (context, fullKey) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
-  await client.del(fullKey);
+  const result = await client.del(fullKey);
   delete existingLocks[fullKey];
+  return result === 1;
 };
 
 const _releaseLockDb = async (context, fullKey) => {
@@ -130,6 +131,7 @@ const _releaseLockDb = async (context, fullKey) => {
     await tx.run(DELETE.from(config.tableNameEventLock).where("code =", fullKey));
   });
   delete existingLocks[fullKey];
+  return true;
 };
 
 const _acquireLockDB = async (

package/srv/service/admin-service.cds

@@ -13,14 +13,14 @@ service EventQueueAdminService {
         null as space: String,
         *
   } actions {
-    action setStatusAndAttempts(
-      // TODO: remove tenant as soon as CAP issue is fixed https://github.tools.sap/cap/issues/issues/18445
-      @mandatory
-      tenant: String,
-      status: db.Status,
-      @assert.range: [0,100]
-      attempts: Integer) returns Event;
-  }
+      action setStatusAndAttempts(
+        // TODO: remove tenant as soon as CAP issue is fixed https://github.tools.sap/cap/issues/issues/18445
+        @mandatory
+        tenant: String,
+        status: db.Status,
+        @assert.range: [0,100]
+        attempts: Integer) returns Event;
+    }
 
   @cds.persistence.skip
   @readonly
@@ -32,12 +32,22 @@ service EventQueueAdminService {
     space: String;
     ttl: Integer;
     createdAt: Integer;
-  }
+  } actions {
+      action releaseLock(
+        // TODO: remove tenant as soon as CAP issue is fixed https://github.tools.sap/cap/issues/issues/18445
+        @mandatory
+        tenant: String,
+        @mandatory
+        type: String,
+        @mandatory
+        subType: String) returns Boolean;
+    }
 
    @readonly
    @cds.persistence.skip
    entity Tenant {
       Key ID: String;
       subdomain: String;
+      metadata: String;
    }
 }

package/srv/service/admin-service.js

@@ -5,6 +5,7 @@ const cdsHelper = require("../../src/shared/cdsHelper");
 const { EventProcessingStatus } = require("../../src");
 const config = require("../../src/config");
 const distributedLock = require("../../src/shared/distributedLock");
+const redisPub = require("../../src/redis/redisPub");
 
 module.exports = class AdminService extends cds.ApplicationService {
   async init() {
@@ -61,7 +62,7 @@ module.exports = class AdminService extends cds.ApplicationService {
     });
 
     this.on("READ", Tenant, async () => {
-      const tenants = await cdsHelper.getAllTenantWithSubdomain();
+      const tenants = await cdsHelper.getAllTenantWithMetadata();
       return tenants ?? [];
     });
 
@@ -82,14 +83,27 @@ module.exports = class AdminService extends cds.ApplicationService {
         return req.reject(400, "No status or attempts provided");
       }
 
-      await cds.tx({ tenant, headers: { "z-id": tenant } }, async () => {
+      const event = await cds.tx({ tenant, headers: { "z-id": tenant } }, async () => {
+        const event = await SELECT.one.from(EventDb).where({ ID: req.params[0].ID ?? req.params[0] });
         await UPDATE.entity(EventDb)
           .set(updateData)
           .where({ ID: req.params[0].ID ?? req.params[0] });
+        return event;
+      });
+      redisPub.broadcastEvent(tenant, event).catch(() => {
+        /* ignore errors */
       });
       return await this.send(new cds.Request({ query: req.query, headers: req.headers }));
     });
 
+    this.on("releaseLock", async (req) => {
+      cds.log("eventQueue").info("Releasing event-queue lock", req.data);
+      const { tenant, type, subType } = req.data;
+      return await cds.tx({ tenant }, async (tx) => {
+        return await distributedLock.releaseLock(tx.context, [type, subType].join("##"));
+      });
+    });
+
     await super.init();
   }