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

package/package.json

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

@@ -296,7 +296,7 @@ class EventQueueProcessorBase {
     const statusMap = this.commitOnEventLevel || returnMap ? {} : this.__statusMap;
     const errorHandler = (error) => {
       queueEntries.forEach((queueEntry) =>
-        this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error, statusMap)
+        this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error, { statusMap })
       );
       this.logger.error(
         "The supplied status tuple doesn't have the required structure. Setting all entries to error.",
@@ -317,7 +317,7 @@ class EventQueueProcessorBase {
 
     try {
       queueEntryProcessingStatusTuple.forEach(([id, processingStatus]) =>
-        this.#determineAndAddEventStatusToMap(id, processingStatus, statusMap)
+        this.#determineAndAddEventStatusToMap(id, processingStatus, { statusMap })
       );
     } catch (error) {
       errorHandler(error);
@@ -344,11 +344,15 @@ class EventQueueProcessorBase {
     }
   }
 
-  #determineAndAddEventStatusToMap(id, statusOrUpdateData, statusMap = this.__statusMap) {
+  #determineAndAddEventStatusToMap(id, statusOrUpdateData, { statusMap = this.__statusMap, error } = {}) {
     if (typeof statusOrUpdateData === "number") {
       statusOrUpdateData = { status: statusOrUpdateData };
     }
 
+    if (error) {
+      statusOrUpdateData.error = error;
+    }
+
     if (!statusMap[id]) {
       statusMap[id] = statusOrUpdateData;
       return;
@@ -376,9 +380,17 @@ class EventQueueProcessorBase {
       }
     );
     queueEntries.forEach((queueEntry) =>
-      this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error)
+      this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error, { error })
+    );
+    return Object.fromEntries(
+      queueEntries.map((queueEntry) => [
+        queueEntry.ID,
+        {
+          status: EventProcessingStatus.Error,
+          error,
+        },
+      ])
     );
-    return Object.fromEntries(queueEntries.map((queueEntry) => [queueEntry.ID, EventProcessingStatus.Error]));
   }
 
   handleErrorDuringPeriodicEventProcessing(error, queueEntry) {
@@ -389,11 +401,12 @@ class EventQueueProcessorBase {
     });
   }
 
-  async setPeriodicEventStatus(queueEntryIds, status) {
+  async setPeriodicEventStatus(queueEntryIds, status, error) {
     await this.tx.run(
       UPDATE.entity(this.#config.tableNameEventQueue)
         .set({
           status: status,
+          ...(error && { error: this.#error2String(error) }),
         })
         .where({
           ID: queueEntryIds,
@@ -409,7 +422,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];
           }
@@ -444,7 +457,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("##");
 
@@ -1360,6 +1374,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/processEventQueue.js

@@ -154,6 +154,7 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
       }
 
       let status = EventProcessingStatus.Done;
+      let error;
       await executeInNewTransaction(
         eventTypeInstance.context,
         `eventQueue-periodic-process-${eventTypeInstance.eventType}##${eventTypeInstance.eventSubType}`,
@@ -166,6 +167,7 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
               eventTypeInstance.startPerformanceTracerPeriodicEvents();
               await eventTypeInstance.processPeriodicEvent(tx.context, queueEntry.ID, queueEntry);
             } catch (err) {
+              error = err;
               status = EventProcessingStatus.Error;
               eventTypeInstance.handleErrorDuringPeriodicEventProcessing(err, queueEntry);
               await tx.rollback();
@@ -190,7 +192,7 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
         async (tx) => {
           await trace(eventTypeInstance.context, "periodic-event-set-status", async () => {
             eventTypeInstance.processEventContext = tx.context;
-            await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID, status);
+            await eventTypeInstance.setPeriodicEventStatus(queueEntry.ID, status, error);
           });
         }
       );

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) {

package/src/shared/common.js

@@ -165,6 +165,14 @@ const isTenantIdValidCb = async (checkType, tenantId) => {
   }
 };
 
+const cleanUndefined = (input) =>
+  Object.entries(input).reduce((acc, [key, value]) => {
+    if (value !== undefined) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+
 module.exports = {
   arrayToFlatMap,
   limiter,
@@ -174,6 +182,7 @@ module.exports = {
   getAuthContext,
   isTenantIdValidCb,
   promiseAllDone,
+  cleanUndefined,
   __: {
     clearAuthContextCache: () => getAuthContext._cache?.clear(),
   },

package/srv/service/admin-service.cds

@@ -42,4 +42,17 @@ service EventQueueAdminService {
         @mandatory
         subType: String) returns Boolean;
     }
+
+      action publishEvent(
+          @mandatory
+          tenants: array of String,
+          @mandatory
+          type: String,
+          @mandatory
+          subType: String,
+          referenceEntity: String,
+          referenceEntityKey: String,
+          @open
+          payload: {},
+          startAfter: String);
 }

package/srv/service/admin-service.js

@@ -1,26 +1,35 @@
 "use strict";
 
 const cds = require("@sap/cds");
-const { EventProcessingStatus } = require("../../src");
-const config = require("../../src/config");
+
+const eventQueue = require("../../src");
 const distributedLock = require("../../src/shared/distributedLock");
 const redisPub = require("../../src/redis/redisPub");
+const publishEventHelper = require("./publishEventHelper");
+const commonHelper = require("../../src/shared/common");
+
+const COMPONENT_NAME = "/eventQueue/admin";
 
 module.exports = class AdminService extends cds.ApplicationService {
   async init() {
     const { Event: EventService, Lock: LockService } = this.entities;
     const { Event: EventDb } = cds.db.entities("sap.eventqueue");
+    const { publishEvent } = this.actions;
     const { landscape, space } = this.getLandscapeAndSpace();
 
     this.before("*", (req) => {
-      if (!config.enableAdminService) {
+      if (!eventQueue.config.enableAdminService) {
         req.reject(403, "Admin service is disabled by configuration");
       }
 
+      if (req.event === publishEvent.name.split(".")[1]) {
+        return;
+      }
+
       const headers = Object.assign({}, req.headers, req.req?.headers);
       const tenant = headers["z-id"] ?? req.data.tenant;
 
-      if (config.isMultiTenancy && tenant == null) {
+      if (eventQueue.config.isMultiTenancy && tenant == null) {
         req.reject(400, "Missing tenant ID in request header (z-id)");
       }
       req.headers ??= {};
@@ -46,7 +55,7 @@ module.exports = class AdminService extends cds.ApplicationService {
     });
 
     this.on("READ", LockService, async () => {
-      if (!config.redisEnabled) {
+      if (!eventQueue.config.redisEnabled) {
         return [];
       }
       const locks = await distributedLock.getAllLocksRedis();
@@ -59,14 +68,14 @@ module.exports = class AdminService extends cds.ApplicationService {
 
     this.on("setStatusAndAttempts", async (req) => {
       const tenant = req.headers["z-id"];
-      cds.log("eventQueue").info("Restarting processing for event queue");
+      cds.log(COMPONENT_NAME).info("Restarting processing for event queue");
       const updateData = {};
 
       if (Number.isInteger(req.data.attempts)) {
         updateData.attempts = req.data.attempts;
       }
 
-      if (Object.values(EventProcessingStatus).includes(req.data.status)) {
+      if (Object.values(eventQueue.EventProcessingStatus).includes(req.data.status)) {
         updateData.status = req.data.status;
       }
 
@@ -95,6 +104,32 @@ module.exports = class AdminService extends cds.ApplicationService {
       });
     });
 
+    this.on(publishEvent, async (req) => {
+      const logger = cds.log(COMPONENT_NAME);
+      try {
+        const { type, subType, referenceEntity, referenceEntityKey, payload, startAfter } = req.data;
+        const tenants = await publishEventHelper.resolveTenantInfos(req);
+        const eventOptions = commonHelper.cleanUndefined({
+          type,
+          subType,
+          referenceEntity,
+          referenceEntityKey,
+          payload,
+          startAfter,
+        });
+        const publishInfo = { count: tenants.length, type, subType, tenants: req.data.tenants };
+        logger.info("publishing event for tenant(s)", publishInfo);
+        for (const tenant of tenants) {
+          await cds.tx({ tenant }, async (tx) => {
+            await eventQueue.publishEvent(tx, { ...eventOptions });
+          });
+        }
+        logger.info("finished publishing event for tenant(s)", publishInfo);
+      } catch (err) {
+        logger.error("error publishing event", err);
+      }
+    });
+
     await super.init();
   }
 

package/srv/service/publishEventHelper.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const cdsHelper = require("../../src/shared/cdsHelper");
+
+/**
+ * @typedef TenantInfo
+ * @type object
+ * @property {string} tenantId
+ * @property {string} subdomain
+ */
+/**
+ * For service action interfaces, with a tenants = [...] data field this code
+ * resolves the inputs into a tenantInfos array.
+ *
+ * Inputs:
+ * - ["all"]   give me all tenants
+ * - ["self"]  give me just the context tenant
+ * - []        give me no tenant
+ * - ["<tenantId1>", "<tenantId2>", "<subdomain3>", "<subdomain4>",...]
+ *             give me those tenants where either tenantId or subdomain corresponds to the given inputs
+ *
+ * @returns {Promise<Array<TenantInfo>>} returns an array of {@link TenantInfo} objects.
+ */
+const resolveTenantInfos = async (context, { sortByTenantId = true } = {}) => {
+  let result = await _resolveTenantInfos(context);
+  if (sortByTenantId) {
+    result = result.sort(_orderByTenantId);
+  }
+  return result;
+};
+
+const _resolveTenantInfos = async (context) => {
+  if (!Array.isArray(context.data.tenants)) {
+    return [];
+  }
+  for (const tenant of context.data.tenants) {
+    if (tenant === "self") {
+      return [context.tenant];
+    }
+    if (["all", "*"].includes(tenant)) {
+      return await cdsHelper.getAllTenantIds();
+    }
+  }
+  const contextTenantsMap = Object.fromEntries(context.data.tenants.map((tenant) => [tenant, true]));
+  return (await cdsHelper.getAllTenantIds()).filter((tenantId) => contextTenantsMap[tenantId]);
+};
+
+const _orderByTenantId = (a, b) => a.localeCompare(b);
+
+module.exports = {
+  resolveTenantInfos,
+};