@cap-js-community/event-queue 1.4.2 → 1.4.4

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "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",
   "files": [
     "src",
     "db",

package/src/EventQueueProcessorBase.js

@@ -22,6 +22,7 @@ const SELECT_LIMIT_EVENTS_PER_TICK = 100;
 const TRIES_FOR_EXCEEDED_EVENTS = 3;
 const EVENT_START_AFTER_HEADROOM = 3 * 1000;
 const ETAG_CHECK_AFTER_MIN = 10;
+const SUFFIX_PERIODIC = "_PERIODIC";
 
 class EventQueueProcessorBase {
   #eventsWithExceededTries = [];
@@ -1095,7 +1096,7 @@ class EventQueueProcessorBase {
   }
 
   get eventType() {
-    return this.#eventType;
+    return this.#eventType.replace(SUFFIX_PERIODIC, "");
   }
 
   get eventSubType() {

package/src/config.js

@@ -242,8 +242,8 @@ class Config {
     return key;
   }
 
-  isEventBlocked(type, subType, tenant) {
-    const map = this.#blockedEvents[this.generateKey(type, subType)];
+  isEventBlocked(type, subType, isPeriodicEvent, tenant) {
+    const map = this.#blockedEvents[this.generateKey(`${type}${isPeriodicEvent ? SUFFIX_PERIODIC : ""}`, subType)];
     if (!map) {
       return false;
     }

package/src/dbHandler.js

@@ -55,21 +55,6 @@ const registerEventQueueDbHandler = (dbService) => {
   });
 };
 
-const registerBeforeDbHandler = (dbService) => {
-  if (!config.insertEventsBeforeCommit || registeredHandlers.beforeDbHandler) {
-    return;
-  }
-
-  registeredHandlers.beforeDbHandler = true;
-  dbService.before("COMMIT", async (req) => {
-    if (req.context._eventQueueEvents?.length) {
-      await cds.tx(req).run(INSERT.into(config.tableNameEventQueue).entries(req.context._eventQueueEvents));
-      req.context._eventQueueEvents = null;
-    }
-  });
-};
-
 module.exports = {
   registerEventQueueDbHandler,
-  registerBeforeDbHandler,
 };

package/src/index.d.ts

@@ -0,0 +1,138 @@
+import * as cds from "@sap/cds";
+
+export declare const EventProcessingStatus: {
+  Open: 0;
+  InProgress: 1;
+  Done: 2;
+  Error: 3;
+  Exceeded: 4;
+};
+
+declare type EventProcessingStatusKeysType = keyof typeof EventProcessingStatus;
+export declare type EventProcessingStatusType = (typeof EventProcessingStatus)[EventProcessingStatusKeysType];
+
+export declare const TransactionMode: {
+  isolated: "isolated";
+  alwaysCommit: "alwaysCommit";
+  alwaysRollback: "alwaysRollback";
+};
+
+export declare type TransactionModeType = keyof typeof TransactionMode;
+
+export declare const Priorities: {
+  Low: "low";
+  Medium: "medium";
+  High: "high";
+  VeryHigh: "veryHigh";
+};
+export declare type PrioritiesType = keyof typeof Priorities;
+
+interface RedisOptions {
+  host: string;
+  port: number;
+}
+
+interface InitializeParams {
+  configFilePath: string;
+  registerAsEventProcessor?: boolean;
+  processEventsAfterPublish?: boolean;
+  isEventQueueActive?: boolean;
+  runInterval?: number;
+  disableRedis?: boolean;
+  updatePeriodicEvents?: boolean;
+  thresholdLoggingEventProcessing?: number;
+  useAsCAPOutbox?: boolean;
+  userId?: string | null;
+  cleanupLocksAndEventsForDev?: boolean;
+  redisOptions?: RedisOptions;
+  insertEventsBeforeCommit?: boolean;
+}
+
+type CdsLogger = ReturnType<typeof cds.log>;
+
+export function initialize(params: InitializeParams): Promise<void>;
+
+type EventConfigType = {
+  type: string;
+  subType: string;
+  priority: string;
+  impl: string;
+  load: number;
+  interval: number;
+  internalEvent: boolean;
+  isPeriodic: boolean;
+};
+
+// Define Status Type
+type Status = 0 | 1 | 2 | 3 | 4;
+
+// Define Event Entity Type
+interface EventEntity {
+  type: string;
+  subType: string;
+  referenceEntity?: string;
+  referenceEntityKey?: string;
+  status: Status;
+  payload?: string;
+  attempts: number;
+  lastAttemptTimestamp?: string;
+  createdAt: string;
+  startAfter?: string;
+}
+
+interface EventEntityPublish {
+  type: string;
+  subType: string;
+  referenceEntity?: string;
+  referenceEntityKey?: string;
+  payload?: string;
+}
+
+interface QueueEntriesPayloadMap {
+  [key: string]: {
+    queueEntry: EventEntity;
+    payload: Object;
+  };
+}
+
+export declare class EventQueueProcessorBase {
+  constructor(context: cds.EventContext, eventType: string, eventSubType: string, config: EventConfigType);
+
+  processEvent(
+    processContext: cds.EventContext,
+    key: string,
+    queueEntries: EventEntity[],
+    payload: Object
+  ): Promise<Array<[string, EventProcessingStatusType]>>;
+
+  processPeriodicEvent(processContext: cds.EventContext, key: string, queueEntry: EventEntity): Promise<undefined>;
+  checkEventAndGeneratePayload(queueEntry: EventEntity): Promise<Object>;
+  addEventWithPayloadForProcessing(queueEntry: EventEntity, payload: Object): void;
+  clusterQueueEntries(queueEntriesWithPayloadMap: Object): void;
+  hookForExceededEvents(exceededEvent: EventEntity): Promise<void>;
+  clusterQueueEntries(queueEntriesWithPayloadMap: QueueEntriesPayloadMap): void;
+  getLastSuccessfulRunTimestamp(): Promise<string | null>;
+  getContextForEventProcessing(key: string): cds.EventContext;
+  getTxForEventProcessing(key: string): cds.Transaction;
+  setShouldRollbackTransaction(key: string): void;
+  shouldRollbackTransaction(key: string): boolean;
+
+  set logger(value: CdsLogger);
+  get logger(): CdsLogger;
+  get tx(): cds.Transaction;
+  get context(): cds.EventContext;
+  get isPeriodicEvent(): boolean;
+}
+
+export function publishEvent(
+  tx: cds.Transaction,
+  events: EventEntityPublish[] | EventEntityPublish,
+  skipBroadcast?: boolean
+): Promise<any>;
+
+export function processEventQueue(
+  context: cds.EventContext,
+  eventType: string,
+  eventSubType: string,
+  startTime: Date
+): Promise<any>;

package/src/index.js

@@ -1,6 +1,5 @@
 "use strict";
 
-// TODO: how to deal with fatal logs
 // TODO: add tests for config --> similar to csn check
 
 module.exports = {

package/src/initialize.js

@@ -81,7 +81,6 @@ const initialize = async ({
   cds.on("connect", (service) => {
     if (service.name === "db") {
       config.processEventsAfterPublish && dbHandler.registerEventQueueDbHandler(service);
-      config.insertEventsBeforeCommit && dbHandler.registerBeforeDbHandler(service);
       config.cleanupLocksAndEventsForDev && registerCleanupForDevDb().catch(() => {});
       initFinished.then(registerEventProcessors);
     }

package/src/processEventQueue.js

@@ -263,6 +263,7 @@ const _checkEventIsBlocked = async (baseInstance) => {
     eventBlocked = config.isEventBlocked(
       baseInstance.eventType,
       baseInstance.eventSubType,
+      baseInstance.isPeriodicEvent,
       baseInstance.context.tenant
     );
   }

package/src/publishEvent.js

@@ -47,8 +47,7 @@ const publishEvent = async (tx, events, skipBroadcast = false) => {
   }
 
   if (config.insertEventsBeforeCommit) {
-    tx.context._eventQueueEvents ??= [];
-    tx.context._eventQueueEvents = tx.context._eventQueueEvents.concat(events);
+    _registerHandlerAndAddEvents(tx, events);
   } else {
     tx._skipEventQueueBroadcase = skipBroadcast;
     const result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(eventsForProcessing));
@@ -57,6 +56,23 @@ const publishEvent = async (tx, events, skipBroadcast = false) => {
   }
 };
 
+const _registerHandlerAndAddEvents = (tx, events) => {
+  tx._eventQueue ??= { events: [], handlerRegistered: false };
+  tx._eventQueue.events = tx._eventQueue.events.concat(events);
+
+  if (tx._eventQueue.handlerRegistered) {
+    return;
+  }
+  tx._eventQueue.handlerRegistered = true;
+  tx.context.before("commit", async () => {
+    if (!tx._eventQueue.events?.length) {
+      return;
+    }
+    await tx.run(INSERT.into(config.tableNameEventQueue).entries(tx._eventQueue.events));
+    tx._eventQueue = null;
+  });
+};
+
 module.exports = {
   publishEvent,
 };

package/src/redis/redisPub.js

@@ -29,7 +29,9 @@ const broadcastEvent = async (tenantId, events) => {
       if (config.registerAsEventProcessor) {
         let context = {};
         if (tenantId) {
-          const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+          const user = await cds.tx({ tenant: tenantId }, async () => {
+            return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+          });
           context = {
             tenant: tenantId,
             user,

package/src/redis/redisSub.js

@@ -35,7 +35,9 @@ const _messageHandlerProcessEvents = async (messageData) => {
       return;
     }
 
-    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    const user = await cds.tx({ tenant: tenantId }, async () => {
+      return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    });
     const tenantContext = {
       tenant: tenantId,
       user,

package/src/runner/runner.js

@@ -111,6 +111,7 @@ const _executeEventsAllTenantsRedis = async (tenantIds) => {
 
     for (const tenantId of tenantIds) {
       await cds.tx({ tenant: tenantId }, async (tx) => {
+        tx.context.user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
         const entries = await openEvents.getOpenQueueEntries(tx);
         logger.info("broadcasting events for run", {
           tenantId,
@@ -136,7 +137,9 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
   const promises = [];
 
   for (const tenantId of tenantIds) {
-    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    const user = await cds.tx({ tenant: tenantId }, async () => {
+      return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    });
     const tenantContext = {
       tenant: tenantId,
       user,
@@ -180,7 +183,9 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
 const _executePeriodicEventsAllTenants = async (tenantIds) => {
   for (const tenantId of tenantIds) {
     try {
-      const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+      const user = await cds.tx({ tenant: tenantId }, async () => {
+        return new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+      });
       const tenantContext = {
         tenant: tenantId,
         user,