@cap-js-community/event-queue 2.1.0-beta.1 → 2.1.0-beta.3

package/db/Event.cds

@@ -24,6 +24,6 @@ entity Event: cuid {
     createdAt: Timestamp @cds.on.insert : $now;
     startAfter: Timestamp;
     context: LargeString;
-    error: String;
+    error: LargeString;
     namespace: String default 'default';
 }

package/package.json

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

@@ -504,10 +504,16 @@ class EventQueueProcessorBase {
         if (!data.startAfter && [EventProcessingStatus.Error, EventProcessingStatus.Open].includes(data.status)) {
           data.startAfter = new Date(
             Date.now() +
-              (EventProcessingStatus.Error ? this.#eventConfig.retryFailedAfter : this.#eventConfig.retryOpenAfter)
+              (data.status === EventProcessingStatus.Error
+                ? this.#eventConfig.retryFailedAfter
+                : this.#eventConfig.retryOpenAfter)
           );
         }
 
+        if (data.status === EventProcessingStatus.Open && !("attempts" in data)) {
+          data.attempts = { "-=": 1 };
+        }
+
         if (data.startAfter) {
           this.#eventSchedulerInstance.scheduleEvent(
             this.__context.tenant,

package/src/config.js

@@ -64,7 +64,7 @@ const ALLOWED_EVENT_OPTIONS_AD_HOC = [
   "checkForNextChunk",
   "retryFailedAfter",
   "propagateHeaders",
-  "propagatedContextProperties",
+  "propagateContextProperties",
   "retryOpenAfter",
   "multiInstanceProcessing",
   "kind",
@@ -518,7 +518,7 @@ class Config {
       ? Object.fromEntries(new Map(event.appInstances.map((a) => [a, true])))
       : null;
     event.propagateHeaders = event.propagateHeaders ?? [];
-    event.propagatedContextProperties = event.propagatedContextProperties ?? [];
+    event.propagateContextProperties = event.propagateContextProperties ?? [];
     event.retryFailedAfter = event.retryFailedAfter ?? DEFAULT_RETRY_AFTER;
     event.retryOpenAfter = event.retryOpenAfter ?? DEFAULT_RETRY_AFTER;
   }

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -64,7 +64,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
         }
       } else {
         for (const actionName in genericClusterEvents) {
-          const reg = new cds.Request({
+          const req = new cds.Request({
             event: EVENT_QUEUE_ACTIONS.CLUSTER,
             user: this.context.user,
             eventQueue: {
@@ -77,14 +77,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
                 this.#clusterByDataProperty(actionName, genericClusterEvents[actionName], propertyName, cb),
             },
           });
-          const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
+          const clusterResult = await this.__srvUnboxed.tx(this.context).send(req);
           if (this.#validateCluster(clusterResult)) {
             Object.assign(clusterMap, clusterResult);
           } else {
             this.logger.error(
               "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
               {
-                handler: reg.event,
+                handler: req.event,
                 clusterResult: JSON.stringify(clusterResult),
               }
             );
@@ -95,7 +95,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     }
 
     for (const actionName in specificClusterEvents) {
-      const reg = new cds.Request({
+      const req = new cds.Request({
         event: `${EVENT_QUEUE_ACTIONS.CLUSTER}.${actionName}`,
         user: this.context.user,
         eventQueue: {
@@ -108,14 +108,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
             this.#clusterByDataProperty(actionName, specificClusterEvents[actionName], propertyName, cb),
         },
       });
-      const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
+      const clusterResult = await this.__srvUnboxed.tx(this.context).send(req);
       if (this.#validateCluster(clusterResult)) {
         Object.assign(clusterMap, clusterResult);
       } else {
         this.logger.error(
           "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
           {
-            handler: reg.event,
+            handler: req.event,
             clusterResult: JSON.stringify(clusterResult),
           }
         );
@@ -267,12 +267,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return payload;
     }
 
-    const { reg, userId } = this.#buildDispatchData(this.context, payload, {
+    const { req, userId } = this.#buildDispatchData(payload, {
       queueEntries: [queueEntry],
     });
-    reg.event = handlerName;
-    await this.#setContextUser(this.context, userId, reg);
-    const data = await this.__srvUnboxed.tx(this.context).send(reg);
+    req.event = handlerName;
+    await this.#setContextUser(this.context, userId, req);
+    const data = await this.__srvUnboxed.tx(this.context).send(req);
     if (data) {
       payload.data = data;
       return payload;
@@ -288,12 +288,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return await super.hookForExceededEvents(exceededEvent);
     }
 
-    const { reg, userId } = this.#buildDispatchData(this.context, exceededEvent.payload, {
+    const { req, userId } = this.#buildDispatchData(exceededEvent.payload, {
       queueEntries: [exceededEvent],
     });
-    await this.#setContextUser(this.context, userId, reg);
-    reg.event = handlerName;
-    await this.__srvUnboxed.tx(this.context).send(reg);
+    await this.#setContextUser(this.context, userId, req);
+    req.event = handlerName;
+    await this.__srvUnboxed.tx(this.context).send(req);
   }
 
   // NOTE: Currently not exposed to CAP service; we wait for a valid use case
@@ -326,40 +326,47 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
 
   async processPeriodicEvent(processContext, key, 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);
+    const req = new cds.Event({ event: actionName, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    await this.#setContextUser(processContext, config.userId, req);
+    await this.__srvUnboxed.tx(processContext).emit(req);
   }
 
-  #buildDispatchData(context, payload, { key, queueEntries } = {}) {
+  #buildDispatchData(payload, { key, queueEntries } = {}) {
     const { useEventQueueUser } = this.eventConfig;
     const userId = useEventQueueUser ? config.userId : payload.contextUser;
-    const reg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
+    const req = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
     const invocationFn = payload._fromSend ? "send" : "emit";
-    delete reg._fromSend;
-    delete reg.contextUser;
-    reg.eventQueue = { processor: this, key, queueEntries, payload };
-    return { reg, userId, invocationFn };
+    delete req._fromSend;
+    delete req.contextUser;
+    req.eventQueue = { processor: this, key, queueEntries, payload };
+
+    if (this.eventConfig.propagateContextProperties?.length && this.transactionMode === "isolated" && cds.context) {
+      for (const prop of this.eventConfig.propagateContextProperties) {
+        req[prop] && (cds.context[prop] = req[prop]);
+      }
+    }
+
+    return { req, userId, invocationFn };
   }
 
-  async #setContextUser(context, userId, reg) {
+  async #setContextUser(context, userId, req) {
     const authInfo = await common.getAuthContext(context.tenant);
     context.user = new cds.User.Privileged({
       id: userId,
       authInfo,
       tokenInfo: authInfo?.token,
     });
-    if (reg) {
-      reg.user = context.user;
+    if (req) {
+      req.user = context.user;
     }
   }
 
   async processEvent(processContext, key, queueEntries, payload) {
     let statusTuple;
-    const { userId, invocationFn, reg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
+    const { userId, invocationFn, req } = this.#buildDispatchData(payload, { key, queueEntries });
     try {
-      await this.#setContextUser(processContext, userId, reg);
-      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](reg);
+      await this.#setContextUser(processContext, userId, req);
+      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](req);
       statusTuple = this.#determineResultStatus(result, queueEntries);
     } catch (err) {
       this.logger.error("error processing outboxed service call", err, {
@@ -374,7 +381,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       ]);
     }
 
-    await this.#publishFollowupEvents(processContext, reg, statusTuple);
+    await this.#publishFollowupEvents(processContext, req, statusTuple);
     return statusTuple;
   }
 

package/src/outbox/eventQueueAsOutbox.js

@@ -11,6 +11,8 @@ const CDS_EVENT_TYPE = "CAP_OUTBOX";
 const COMPONENT_NAME = "/eventQueue/eventQueueAsOutbox";
 const EVENT_QUEUE_SPECIFIC_FIELDS = ["startAfter", "referenceEntity", "referenceEntityKey", "namespace"];
 
+const TO_COPY = ["inbound", "event", "data", "queue", "results", "method", "path", "params", "entity", "service"];
+
 function outboxed(srv, customOpts) {
   if (!(new.target || customOpts)) {
     const former = srv[OUTBOXED];
@@ -43,7 +45,7 @@ function outboxed(srv, customOpts) {
 
     const outboxOpts = config.getEventConfig(CDS_EVENT_TYPE, subType, srvConfig.namespace);
     const eventHeaders = getPropagatedHeaders(outboxOpts, req);
-    const contextProperties = getPropagatedContextProperties(outboxOpts, req);
+    const contextProperties = getPropagateContextProperties(outboxOpts, req);
     if (["persistent-outbox", "persistent-queue"].includes(outboxOpts.kind)) {
       await _mapToEventAndPublish(req, srvConfig.namespace, subType, eventHeaders, contextProperties);
       return;
@@ -81,8 +83,8 @@ const getPropagatedHeaders = (config, req) => {
   return Object.assign(propagateHeaders, req.headers);
 };
 
-const getPropagatedContextProperties = (config, req) => {
-  return config.propagatedContextProperties.reduce((properties, name) => {
+const getPropagateContextProperties = (config, req) => {
+  return config.propagateContextProperties.reduce((properties, name) => {
     if (name in req.tx.context) {
       properties[name] = req.tx.context[name];
     }
@@ -102,18 +104,27 @@ const _mapToEventAndPublish = async (req, namespace, subType, eventHeaders, cont
       }
     }
   }
-
   const event = {
     contextUser: context.user.id,
     ...(req._fromSend || (req.reply && { _fromSend: true })), // send or emit
-    ...(req.inbound && { inbound: req.inbound }),
-    ...(req.event && { event: req.event }),
-    ...(req.data && { data: req.data }),
     ...(eventHeaders && { headers: eventHeaders }),
-    ...(req.query && { query: req.query }),
     ...(Object.keys(contextProperties).length && { ...contextProperties }),
   };
 
+  for (const prop of TO_COPY) {
+    if (req[prop]) {
+      event[prop] = req[prop];
+    }
+  }
+
+  if (req.query) {
+    event.query = typeof req.query.flat === "function" ? req.query.flat() : req.query;
+    delete event.query._target;
+    delete event.query.__target;
+    delete event.query.target;
+    delete event.data; // `req.data` should be a getter to whatever is in `req.query`
+  }
+
   await publishEvent(
     cds.tx(context),
     {