@cap-js-community/event-queue 1.9.3 → 1.10.0-beta.1

package/package.json

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

@@ -243,7 +243,7 @@ class EventQueueProcessorBase {
    * This can be useful for e.g. multiple tasks have been scheduled and always the same user should be informed.
    * In this case the events should be clustered together and only one mail should be sent.
    */
-  clusterQueueEntries(queueEntriesWithPayloadMap) {
+  async clusterQueueEntries(queueEntriesWithPayloadMap) {
     Object.entries(queueEntriesWithPayloadMap).forEach(([key, { queueEntry, payload }]) => {
       this.addEntryToProcessingMap(key, queueEntry, payload);
     });

package/src/config.js

@@ -36,6 +36,45 @@ 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",
+  "timeBucket",
+];
+
+const ALLOWED_EVENT_OPTIONS_PERIODIC_EVENT = [
+  ...ALLOWED_EVENT_OPTIONS_BASE,
+  "interval",
+  "cron",
+  "utc",
+  "useCronTimezone",
+];
+
 class Config {
   #logger;
   #config;
@@ -286,7 +325,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 +333,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 +408,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 +479,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 +507,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 +617,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);
     }
 
@@ -516,6 +631,14 @@ class Config {
     }
     event.inheritTraceContext = event.inheritTraceContext ?? DEFAULT_INHERIT_TRACE_CONTEXT;
 
+    if (event.timeBucket) {
+      try {
+        CronExpressionParser.parse(event.timeBucket);
+      } catch {
+        throw EventQueueError.cantParseCronExpression(event.type, event.subType, event.timeBucket);
+      }
+    }
+
     this.#basicEventValidation(event);
   }
 
@@ -540,7 +663,7 @@ class Config {
   }
 
   get events() {
-    return this.#config.events;
+    return Object.values(this.#eventMap).filter((e) => !e.isPeriodic);
   }
 
   set configEvents(value) {
@@ -556,7 +679,7 @@ class Config {
   }
 
   get periodicEvents() {
-    return this.#config.periodicEvents;
+    return Object.values(this.#eventMap).filter((e) => e.isPeriodic);
   }
 
   isPeriodicEvent(type, subType) {
@@ -564,7 +687,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,21 +15,222 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     this.logger = cds.log(`${COMPONENT_NAME}/${eventSubType}`);
   }
 
+  async getQueueEntriesAndSetToInProgress() {
+    const [serviceName] = this.eventSubType.split(".");
+    this.__srv = await cds.connect.to(serviceName);
+    this.__srvUnboxed = cds.unboxed(this.__srv);
+    const { handlers, clusterRelevant, specificClusterRelevant } = this.__srvUnboxed.handlers.on.reduce(
+      (result, handler) => {
+        if (handler.on.startsWith("clusterQueueEntries")) {
+          if (handler.on.split(".").length === 2) {
+            result.specificClusterRelevant = true;
+          } else {
+            result.clusterRelevant = true;
+          }
+        }
+
+        result.handlers[handler.on] = handler.on;
+        return result;
+      },
+      { handlers: {}, clusterRelevant: false, specificClusterRelevant: false }
+    );
+    this.__onHandlers = handlers;
+    this.__genericClusterHandler = clusterRelevant;
+    this.__specificClusterHandler = specificClusterRelevant;
+    await this.#setContextUser(this.context, config.userId);
+    return super.getQueueEntriesAndSetToInProgress();
+  }
+
+  // NOTE: issue here: if events are not sorted before it might not be unique here:
+  //       - we have service events
+  //       - we have action specific events
+  // 1. I need to collect all action names
+  // 2. I need to check for which actions a handler exits
+  // 3. For actions with specific existing handler --> call specific action
+  // 4. For all others call generic handler
+  // NOTE: OVERALL idea is that the handler returns the cluster map and MUST not call any baseImpl functions!
+  //      --> structure is a map of { key: { queueEntries: [], payload: {} }
+  // TODO: document that clusterQueueEntries is now async!!!
+  // TODO: validate that return structure is as expected
+  async clusterQueueEntries(queueEntriesWithPayloadMap) {
+    if (!this.__genericClusterRelevantAndAvailable && !this.__specificClusterRelevantAndAvailable) {
+      return super.clusterQueueEntries(queueEntriesWithPayloadMap);
+    }
+    const { genericClusterEvents, specificClusterEvents } = this.#clusterByAction(queueEntriesWithPayloadMap);
+    if (Object.keys(genericClusterEvents).length) {
+      if (!this.__genericClusterRelevantAndAvailable) {
+        await super.clusterQueueEntries(genericClusterEvents);
+      } else {
+        const msg = new cds.Request({
+          event: "clusterQueueEntries",
+          data: { queueEntriesWithPayloadMap: genericClusterEvents },
+          eventQueue: {
+            processor: this,
+            clusterByPayloadProperty: (propertyName) =>
+              EventQueueGenericOutboxHandler.clusterByPayloadProperty(genericClusterEvents, propertyName),
+            clusterByEventProperty: (propertyName) =>
+              EventQueueGenericOutboxHandler.clusterByEventProperty(genericClusterEvents, propertyName),
+          },
+        });
+        const handlerCluster = await this.__srvUnboxed.tx(this.context).send(msg);
+        this.#addToProcessingMap(handlerCluster);
+      }
+    }
+
+    for (const actionName in specificClusterEvents) {
+      const msg = new cds.Request({
+        event: `clusterQueueEntries.${actionName}`,
+        data: { queueEntriesWithPayloadMap: specificClusterEvents[actionName] },
+        eventQueue: {
+          processor: this,
+          clusterByPayloadProperty: (propertyName) =>
+            EventQueueGenericOutboxHandler.clusterByPayloadProperty(specificClusterEvents[actionName], propertyName),
+          clusterByEventProperty: (propertyName) =>
+            EventQueueGenericOutboxHandler.clusterByEventProperty(specificClusterEvents[actionName], propertyName),
+        },
+      });
+      const handlerCluster = await this.__srvUnboxed.tx(this.context).send(msg);
+      this.#addToProcessingMap(handlerCluster);
+    }
+  }
+
+  static clusterByPayloadProperty(queueEntriesWithPayloadMap, propertyName) {
+    return Object.entries(queueEntriesWithPayloadMap).reduce((result, [, { queueEntry, payload }]) => {
+      result[payload[propertyName]] ??= {
+        queueEntries: [],
+        payload,
+      };
+      result[payload[propertyName]].queueEntries.push(queueEntry);
+      return result;
+    }, {});
+  }
+
+  static clusterByEventProperty(queueEntriesWithPayloadMap, propertyName) {
+    return Object.entries(queueEntriesWithPayloadMap).reduce((result, [, { queueEntry, payload }]) => {
+      result[queueEntry[propertyName]] ??= {
+        queueEntries: [],
+        payload,
+      };
+      result[queueEntry[propertyName]].queueEntries.push(queueEntry);
+      return result;
+    }, {});
+  }
+
+  #clusterByAction(queueEntriesWithPayloadMap) {
+    return Object.entries(queueEntriesWithPayloadMap).reduce(
+      (result, [eventId, clusterData]) => {
+        const hasSpecificClusterHandler = this.#hasEventSpecificClusterHandler(clusterData.queueEntry);
+        if (hasSpecificClusterHandler && this.__specificClusterRelevantAndAvailable) {
+          result.specificClusterEvents[clusterData.payload.event] ??= {};
+          result.specificClusterEvents[clusterData.payload.event][eventId] = clusterData;
+        } else {
+          result.genericClusterEvents[eventId] = clusterData;
+        }
+        return result;
+      },
+      { genericClusterEvents: {}, specificClusterEvents: {} }
+    );
+  }
+
+  #addToProcessingMap(handlerCluster) {
+    for (const clusterKey in handlerCluster) {
+      const { payload, queueEntries } = handlerCluster[clusterKey];
+      for (const queueEntry of queueEntries) {
+        this.addEntryToProcessingMap(clusterKey, queueEntry, payload);
+      }
+    }
+  }
+
+  // NOTE: Currently not exposed to CAP service; I don't see any valid use case at this time
+  modifyQueueEntry(queueEntry) {
+    super.modifyQueueEntry(queueEntry);
+    const hasSpecificClusterHandler = this.#hasEventSpecificClusterHandler(queueEntry);
+    if (this.__specificClusterHandler && hasSpecificClusterHandler) {
+      this.__specificClusterRelevantAndAvailable = true;
+    }
+    if (this.__genericClusterHandler && !hasSpecificClusterHandler) {
+      this.__genericClusterRelevantAndAvailable = true;
+    }
+  }
+
+  #hasEventSpecificClusterHandler(queueEntry) {
+    return !!this.__onHandlers[["clusterQueueEntries", queueEntry.payload.event].join(".")];
+  }
+
+  async checkEventAndGeneratePayload(queueEntry) {
+    const payload = await super.checkEventAndGeneratePayload(queueEntry);
+    const { event } = payload;
+    const handlerName = this.#checkHandlerExists("checkEventAndGeneratePayload", event);
+    if (!handlerName) {
+      return payload;
+    }
+
+    const { msg, userId } = this.#buildDispatchData(this.context, payload, {
+      queueEntries: [queueEntry],
+    });
+    msg.event = handlerName;
+    await this.#setContextUser(this.context, userId);
+    const data = await this.__srvUnboxed.tx(this.context).send(msg);
+    if (data) {
+      payload.data = data;
+      return payload;
+    } else {
+      return null;
+    }
+  }
+
+  // simple here as per entry
+  async hookForExceededEvents(exceededEvent) {
+    return await super.hookForExceededEvents(exceededEvent);
+  }
+
+  async beforeProcessingEvents() {
+    return await super.beforeProcessingEvents();
+  }
+
+  // maybe async getter on req.data // only for periodic events
+  // getLastSuccessfulRunTimestamp
+
+  #checkHandlerExists(eventQueueFn, event) {
+    const specificHandler = this.__onHandlers[[eventQueueFn, event].join(".")];
+    if (specificHandler) {
+      return specificHandler;
+    }
+
+    const genericHandler = this.__onHandlers[eventQueueFn];
+    return genericHandler ?? null;
+  }
+
+  async processPeriodicEvent(processContext, key, queueEntry) {
+    const [, action] = this.eventSubType.split(".");
+    const msg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    await this.#setContextUser(processContext, config.userId);
+    await this.__srvUnboxed.tx(processContext).emit(msg);
+  }
+
+  #buildDispatchData(context, payload, { key, queueEntries } = {}) {
+    const { useEventQueueUser } = this.eventConfig;
+    const userId = useEventQueueUser ? config.userId : payload.contextUser;
+    const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
+    const invocationFn = payload._fromSend ? "send" : "emit";
+    delete msg._fromSend; // TODO: this changes the source object --> check after multiple invocations
+    delete msg.contextUser;
+    msg.eventQueue = { processor: this, key, queueEntries, payload };
+    return { msg, userId, invocationFn };
+  }
+
+  async #setContextUser(context, userId) {
+    context.user = new cds.User.Privileged({
+      id: userId,
+      authInfo: await common.getTokenInfo(this.baseContext.tenant),
+    });
+  }
+
   async processEvent(processContext, key, queueEntries, payload) {
     try {
-      const service = await cds.connect.to(this.eventSubType);
-      const { useEventQueueUser } = this.eventConfig;
-      const userId = useEventQueueUser ? config.userId : payload.contextUser;
-      const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
-      const invocationFn = payload._fromSend ? "send" : "emit";
-      delete msg._fromSend;
-      delete msg.contextUser;
-      processContext.user = new cds.User.Privileged({
-        id: userId,
-        authInfo: await common.getTokenInfo(processContext.tenant),
-      });
-      processContext._eventQueue = { processor: this, key, queueEntries, payload };
-      const result = await cds.unboxed(service).tx(processContext)[invocationFn](msg);
+      const { userId, invocationFn, msg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
+      await this.#setContextUser(processContext, userId);
+      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](msg);
       return this.#determineResultStatus(result, queueEntries);
     } catch (err) {
       this.logger.error("error processing outboxed service call", err, {

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/processEventQueue.js

@@ -79,7 +79,7 @@ const processEventQueue = async (context, eventType, eventSubType) => {
         await executeInNewTransaction(context, `eventQueue-processing-${eventType}##${eventSubType}`, async (tx) => {
           eventTypeInstance.processEventContext = tx.context;
           try {
-            eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
+            await eventTypeInstance.clusterQueueEntries(eventTypeInstance.queueEntriesWithPayloadMap);
             await processEventMap(eventTypeInstance);
           } catch (err) {
             eventTypeInstance.handleErrorDuringClustering(err);

package/src/publishEvent.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { CronExpressionParser } = require("cron-parser");
+
 const config = require("./config");
 const common = require("./shared/common");
 const EventQueueError = require("./EventQueueError");
@@ -60,6 +62,10 @@ const publishEvent = async (
     if (addTraceContext) {
       event.context = JSON.stringify({ traceContext: openTelemetry.getCurrentTraceContext() });
     }
+
+    if (eventConfig.timeBucket) {
+      event.startAfter ??= CronExpressionParser.parse(eventConfig.timeBucket).next().toISOString();
+    }
   }
   if (config.insertEventsBeforeCommit && !skipInsertEventsBeforeCommit) {
     _registerHandlerAndAddEvents(tx, events);

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 });