@cap-js-community/event-queue 1.9.2 → 1.10.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.9.2",
+  "version": "1.10.0-beta.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",
@@ -23,6 +23,7 @@
   "scripts": {
     "test:unit": "jest --testPathIgnorePatterns=\"/test-integration/\"",
     "test:integration": "jest --testPathIgnorePatterns=\"/test/\" --runInBand --forceExit",
+    "voter:test:integration": "jest --testPathIgnorePatterns=\"/test/\" --forceExit",
     "test": "npm run test:unit && npm run test:integration",
     "test:all:coverage": "jest --runInBand --forceExit --collect-coverage",
     "test:prepare": "npm run build:ci --prefix=./test-integration/_env",
@@ -64,7 +65,8 @@
     "jest": "^29.7.0",
     "prettier": "^2.8.8",
     "sqlite3": "^5.1.7",
-    "@opentelemetry/api": "^1.9.0"
+    "@opentelemetry/api": "^1.9.0",
+    "@actions/core": "^1.11.1"
   },
   "homepage": "https://cap-js-community.github.io/event-queue/",
   "repository": {

package/src/config.js

@@ -36,6 +36,44 @@ const BASE_TABLES = {
   LOCK: "sap.eventqueue.Lock",
 };
 
+const ALLOWED_EVENT_OPTIONS_BASE = [
+  "type",
+  "subType",
+  "load",
+  "impl",
+  "transactionMode",
+  "deleteFinishedEventsAfterDays",
+  "useEventQueueUser",
+  "priority",
+  "keepAliveInterval",
+  "increasePriorityOverTime",
+  "keepAliveMaxInProgressTime",
+  "appNames",
+  "appInstances",
+  "internalEvent",
+];
+
+const ALLOWED_EVENT_OPTIONS_AD_HOC = [
+  ...ALLOWED_EVENT_OPTIONS_BASE,
+  "inheritTraceContext",
+  "selectMaxChunkSize",
+  "parallelEventProcessing",
+  "retryAttempts",
+  "processAfterCommit",
+  "checkForNextChunk",
+  "retryFailedAfter",
+  "multiInstanceProcessing",
+  "kind",
+];
+
+const ALLOWED_EVENT_OPTIONS_PERIODIC_EVENT = [
+  ...ALLOWED_EVENT_OPTIONS_BASE,
+  "interval",
+  "cron",
+  "utc",
+  "useCronTimezone",
+];
+
 class Config {
   #logger;
   #config;
@@ -286,7 +324,7 @@ class Config {
       });
   }
 
-  addCAPOutboxEvent(serviceName, config) {
+  addCAPOutboxEventBase(serviceName, config) {
     if (this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)]) {
       const index = this.#config.events.findIndex(
         (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
@@ -294,36 +332,49 @@ class Config {
       this.#config.events.splice(index, 1);
     }
 
-    const eventConfig = {
+    const eventConfig = this.#sanitizeParamsAdHocEvent({
       type: CAP_EVENT_TYPE,
       subType: serviceName,
-      load: config.load,
       impl: "./outbox/EventQueueGenericOutboxHandler",
-      selectMaxChunkSize: config.chunkSize,
+      kind: config.kind ?? "persistent-outbox",
+      selectMaxChunkSize: config.selectMaxChunkSize ?? config.chunkSize,
       parallelEventProcessing: config.parallelEventProcessing ?? (config.parallel && CAP_PARALLEL_DEFAULT),
-      retryAttempts: config.maxAttempts,
-      transactionMode: config.transactionMode,
-      processAfterCommit: config.processAfterCommit,
-      checkForNextChunk: config.checkForNextChunk,
-      deleteFinishedEventsAfterDays: config.deleteFinishedEventsAfterDays,
-      appNames: config.appNames,
-      appInstances: config.appInstances,
-      useEventQueueUser: config.useEventQueueUser,
-      retryFailedAfter: config.retryFailedAfter,
-      priority: config.priority,
-      multiInstanceProcessing: config.multiInstanceProcessing,
-      increasePriorityOverTime: config.increasePriorityOverTime,
-      keepAliveInterval: config.keepAliveInterval,
-      inheritTraceContext: true,
-      internalEvent: true,
-    };
+      retryAttempts: config.retryAttempts ?? config.maxAttempts,
+      ...config,
+    });
+    eventConfig.internalEvent = true;
 
     this.#basicEventTransformation(eventConfig);
+    this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
     this.#basicEventTransformationAfterValidate(eventConfig);
     this.#config.events.push(eventConfig);
     this.#eventMap[this.generateKey(CAP_EVENT_TYPE, serviceName)] = eventConfig;
   }
 
+  addCAPOutboxEventSpecificAction(serviceName, actionName) {
+    const subType = [serviceName, actionName].join(".");
+    if (this.#eventMap[this.generateKey(CAP_EVENT_TYPE, subType)]) {
+      const index = this.#config.events.findIndex(
+        (event) => event.type === CAP_EVENT_TYPE && event.subType === serviceName
+      );
+      this.#config.events.splice(index, 1);
+    }
+
+    const eventConfig = this.#sanitizeParamsAdHocEvent({
+      ...this.getEventConfig(CAP_EVENT_TYPE, serviceName),
+      ...this.getCdsOutboxEventSpecificConfig(serviceName, actionName),
+      subType,
+    });
+    eventConfig.internalEvent = true;
+
+    this.#basicEventTransformation(eventConfig);
+    this.#validateAdHocEvents(this.#eventMap, eventConfig, false);
+    this.#basicEventTransformationAfterValidate(eventConfig);
+    this.#config.events.push(eventConfig);
+    this.#eventMap[this.generateKey(CAP_EVENT_TYPE, subType)] = eventConfig;
+    return eventConfig;
+  }
+
   #unblockEventLocalState(key, tenant) {
     const map = this.#blockedEvents[key];
     if (!map) {
@@ -356,11 +407,59 @@ class Config {
     fileContent.periodicEvents ??= [];
     const events = this.#configEvents ?? {};
     const periodicEvents = this.#configPeriodicEvents ?? {};
+    const periodicCapServiceEvents = this.#cdsPeriodicOutboxServicesFromEnv();
     fileContent.events = fileContent.events.concat(this.#mapEnvEvents(events));
-    fileContent.periodicEvents = fileContent.periodicEvents.concat(this.#mapEnvEvents(periodicEvents));
+    fileContent.periodicEvents = fileContent.periodicEvents
+      .concat(this.#mapEnvEvents(periodicEvents))
+      .concat(this.#mapCapOutboxPeriodicEvent(periodicCapServiceEvents));
     this.fileContent = fileContent;
   }
 
+  #mapCapOutboxPeriodicEvent(periodicEventMap) {
+    return Object.values(periodicEventMap);
+  }
+
+  #cdsPeriodicOutboxServicesFromEnv() {
+    return Object.entries(cds.env.requires).reduce((result, [name, value]) => {
+      if (value.outbox?.events) {
+        for (const fnName in value.outbox.events) {
+          const base = { ...value.outbox };
+          const fnConfig = value.outbox.events[fnName];
+          if (fnConfig.interval || fnConfig.cron) {
+            if ("interval" in base || "cron" in base) {
+              this.#logger.error(
+                "The properties interval|cron must be defined in the event section and will be ignored in the outbox section.",
+                { serviceName: name }
+              );
+              delete base.cron;
+              delete base.interval;
+            }
+
+            result[fnName] = Object.assign(
+              {
+                type: CAP_EVENT_TYPE,
+                subType: `${name}.${fnName}`,
+                impl: "./outbox/EventQueueGenericOutboxHandler",
+                internalEvent: true,
+              },
+              base,
+              fnConfig
+            );
+          }
+        }
+      }
+      return result;
+    }, {});
+  }
+
+  getCdsOutboxEventSpecificConfig(serviceName, action) {
+    if (cds.env.requires[serviceName]?.outbox?.events?.[action]) {
+      return cds.env.requires[serviceName].outbox.events[action];
+    } else {
+      return null;
+    }
+  }
+
   #mapEnvEvents(events) {
     return Object.entries(events)
       .map(([key, event]) => {
@@ -379,19 +478,21 @@ class Config {
     config.events = config.events ?? [];
     config.periodicEvents = config.periodicEvents ?? [];
     this.#eventMap = config.events.reduce((result, event) => {
-      this.#basicEventTransformation(event);
-      this.#validateAdHocEvents(result, event);
-      this.#basicEventTransformationAfterValidate(event);
-      result[this.generateKey(event.type, event.subType)] = event;
+      const eventSanitized = this.#sanitizeParamsAdHocEvent(event);
+      this.#basicEventTransformation(eventSanitized);
+      this.#validateAdHocEvents(result, eventSanitized);
+      this.#basicEventTransformationAfterValidate(eventSanitized);
+      result[this.generateKey(eventSanitized.type, eventSanitized.subType)] = eventSanitized;
       return result;
     }, {});
     this.#eventMap = config.periodicEvents.reduce((result, event) => {
-      event.type = `${event.type}${SUFFIX_PERIODIC}`;
-      event.isPeriodic = true;
-      this.#basicEventTransformation(event);
-      this.#validatePeriodicConfig(result, event);
-      this.#basicEventTransformationAfterValidate(event);
-      result[this.generateKey(event.type, event.subType)] = event;
+      const eventSanitized = this.#sanitizeParamsPeriodicEventEvent(event);
+      eventSanitized.type = `${eventSanitized.type}${SUFFIX_PERIODIC}`;
+      eventSanitized.isPeriodic = true;
+      this.#basicEventTransformation(eventSanitized);
+      this.#validatePeriodicConfig(result, eventSanitized);
+      this.#basicEventTransformationAfterValidate(eventSanitized);
+      result[this.generateKey(eventSanitized.type, eventSanitized.subType)] = eventSanitized;
       return result;
     }, this.#eventMap);
     this.#config = config;
@@ -405,6 +506,23 @@ class Config {
     event.keepAliveMaxInProgressTime = event.keepAliveInterval * DEFAULT_MAX_FACTOR_STUCK_2_KEEP_ALIVE_INTERVAL;
   }
 
+  #sanitizeParamsBase(config, allowList) {
+    return Object.entries(config).reduce((result, [name, value]) => {
+      if (allowList.includes(name)) {
+        result[name] = value;
+      }
+      return result;
+    }, {});
+  }
+
+  #sanitizeParamsAdHocEvent(config) {
+    return this.#sanitizeParamsBase(config, ALLOWED_EVENT_OPTIONS_AD_HOC);
+  }
+
+  #sanitizeParamsPeriodicEventEvent(config) {
+    return this.#sanitizeParamsBase(config, ALLOWED_EVENT_OPTIONS_PERIODIC_EVENT);
+  }
+
   #basicEventTransformationAfterValidate(event) {
     event._appNameMap = event.appNames ? Object.fromEntries(new Map(event.appNames.map((a) => [a, true]))) : null;
     event._appInstancesMap = event.appInstances
@@ -498,16 +616,12 @@ class Config {
       throw EventQueueError.invalidInterval(event.type, event.subType, event.interval);
     }
 
-    if (event.multiInstanceProcessing) {
-      throw EventQueueError.multiInstanceProcessingNotAllowed(event.type, event.subType);
-    }
-
     this.#basicEventValidation(event);
   }
 
-  #validateAdHocEvents(eventMap, event) {
+  #validateAdHocEvents(eventMap, event, checkForDuplication = true) {
     const key = this.generateKey(event.type, event.subType);
-    if (eventMap[key] && !eventMap[key].isPeriodic) {
+    if (eventMap[key] && !eventMap[key].isPeriodic && checkForDuplication) {
       throw EventQueueError.duplicateEventRegistration(event.type, event.subType);
     }
 
@@ -540,7 +654,7 @@ class Config {
   }
 
   get events() {
-    return this.#config.events;
+    return Object.values(this.#eventMap).filter((e) => !e.isPeriodic);
   }
 
   set configEvents(value) {
@@ -556,7 +670,7 @@ class Config {
   }
 
   get periodicEvents() {
-    return this.#config.periodicEvents;
+    return Object.values(this.#eventMap).filter((e) => e.isPeriodic);
   }
 
   isPeriodicEvent(type, subType) {
@@ -564,7 +678,7 @@ class Config {
   }
 
   get allEvents() {
-    return this.#config.events.concat(this.#config.periodicEvents);
+    return Object.values(this.#eventMap);
   }
 
   get forUpdateTimeout() {

package/src/index.d.ts

@@ -194,7 +194,7 @@ declare class Config {
   blockEvent(type: any, subType: any, isPeriodic: any, tenant?: string): void;
   clearPeriodicEventBlockList(): void;
   unblockEvent(type: any, subType: any, isPeriodic: any, tenant?: string): void;
-  addCAPOutboxEvent(serviceName: any, config: any): void;
+  addCAPOutboxEventBase(serviceName: any, config: any): void;
   isEventBlocked(type: any, subType: any, isPeriodicEvent: any, tenant: any): any;
   set isEventQueueActive(value: boolean);
   get isEventQueueActive(): boolean;

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -15,9 +15,22 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     this.logger = cds.log(`${COMPONENT_NAME}/${eventSubType}`);
   }
 
+  async processPeriodicEvent(processContext, key, queueEntry) {
+    const [serviceName, action] = this.eventSubType.split(".");
+    const service = await cds.connect.to(serviceName);
+    const msg = new cds.Event({ event: action });
+    processContext.user = new cds.User.Privileged({
+      id: config.userId,
+      authInfo: await common.getTokenInfo(processContext.tenant),
+    });
+    processContext._eventQueue = { processor: this, key, queueEntries: [queueEntry] };
+    await cds.unboxed(service).tx(processContext)["emit"](msg);
+  }
+
   async processEvent(processContext, key, queueEntries, payload) {
     try {
-      const service = await cds.connect.to(this.eventSubType);
+      const [srvName] = this.eventSubType.split(".");
+      const service = await cds.connect.to(srvName);
       const { useEventQueueUser } = this.eventConfig;
       const userId = useEventQueueUser ? config.userId : payload.contextUser;
       const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);

package/src/outbox/eventQueueAsOutbox.js

@@ -20,16 +20,14 @@ function outboxed(srv, customOpts) {
   }
 
   const logger = cds.log(COMPONENT_NAME);
-  const outboxOpts = Object.assign(
+  let outboxOpts = Object.assign(
     {},
     (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
     (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
     customOpts || {}
   );
 
-  if (outboxOpts.kind === "persistent-outbox") {
-    config.addCAPOutboxEvent(srv.name, outboxOpts);
-  }
+  config.addCAPOutboxEventBase(srv.name, outboxOpts);
 
   const originalSrv = srv[UNBOXED] || srv;
   const outboxedSrv = Object.create(originalSrv);
@@ -42,9 +40,20 @@ function outboxed(srv, customOpts) {
   }
   outboxedSrv.handle = async function (req) {
     const context = req.context || cds.context;
+    outboxOpts = Object.assign(
+      {},
+      (typeof cds.requires.outbox === "object" && cds.requires.outbox) || {},
+      (typeof srv.options?.outbox === "object" && srv.options.outbox) || {},
+      customOpts || {}
+    );
+    config.addCAPOutboxEventBase(srv.name, outboxOpts);
+    const specificSettings = config.getCdsOutboxEventSpecificConfig(srv.name, req.method);
+    if (specificSettings) {
+      outboxOpts = config.addCAPOutboxEventSpecificAction(srv.name, req.event);
+    }
+
     if (outboxOpts.kind === "persistent-outbox") {
-      config.addCAPOutboxEvent(srv.name, outboxOpts);
-      await _mapToEventAndPublish(context, srv.name, req);
+      await _mapToEventAndPublish(context, srv.name, req, !!specificSettings);
       return;
     }
     context.on("succeeded", async () => {
@@ -70,7 +79,7 @@ function unboxed(srv) {
   return srv[UNBOXED] || srv;
 }
 
-const _mapToEventAndPublish = async (context, name, req) => {
+const _mapToEventAndPublish = async (context, name, req, actionSpecific) => {
   const eventQueueSpecificValues = {};
   for (const header in req.headers ?? {}) {
     for (const field of EVENT_QUEUE_SPECIFIC_FIELDS) {
@@ -93,7 +102,7 @@ const _mapToEventAndPublish = async (context, name, req) => {
 
   await publishEvent(cds.tx(context), {
     type: CDS_EVENT_TYPE,
-    subType: name,
+    subType: actionSpecific ? [name, req.event].join(".") : name,
     payload: JSON.stringify(event),
     ...eventQueueSpecificValues,
   });

package/src/runner/openEvents.js

@@ -4,6 +4,7 @@ const cds = require("@sap/cds");
 
 const eventConfig = require("../config");
 const { EventProcessingStatus } = require("../constants");
+const config = require("../config");
 
 const MS_IN_DAYS = 24 * 60 * 60 * 1000;
 
@@ -36,8 +37,9 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
   const result = [];
   for (const { type, subType } of entries) {
     if (eventConfig.isCapOutboxEvent(type)) {
+      const [srvName, actionName] = subType.split(".");
       cds.connect
-        .to(subType)
+        .to(srvName)
         .then((service) => {
           if (!filterAppSpecificEvents) {
             return; // will be done in finally
@@ -47,6 +49,9 @@ const getOpenQueueEntries = async (tx, filterAppSpecificEvents = true) => {
             return;
           }
           cds.outboxed(service);
+          if (actionName) {
+            config.addCAPOutboxEventSpecificAction(srvName, actionName);
+          }
           if (filterAppSpecificEvents) {
             if (eventConfig.shouldBeProcessedInThisApplication(type, subType)) {
               result.push({ type, subType });

package/src/shared/openTelemetry.js

@@ -45,12 +45,6 @@ const trace = async (context, label, fn, { attributes = {}, newRootSpan = false,
 
 const _startOtelTrace = async (ctxWithSpan, traceContext, span, fn) => {
   return otel.context.with(ctxWithSpan, async () => {
-    if (traceContext) {
-      cds.log("/eventQueue/telemetry").info("Linked span:", span.spanContext());
-      const carrier = {};
-      otel.propagation.inject(ctxWithSpan, carrier);
-      cds.log("/eventQueue/telemetry").info("Extracted trace context by inject", carrier);
-    }
     const onSuccess = (res) => {
       span.setStatus({ code: otel.SpanStatusCode.OK });
       return res;