@cap-js-community/event-queue 0.2.1 → 0.2.3

package/src/shared/distributedLock.js

@@ -3,15 +3,10 @@
 const redis = require("./redis");
 const config = require("../config");
 const cdsHelper = require("./cdsHelper");
-const { getConfigInstance } = require("../config");
 
-const acquireLock = async (
-  context,
-  key,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout } = {}
-) => {
+const acquireLock = async (context, key, { tenantScoped = true, expiryTime = config.globalTxTimeout } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime);
   } else {
     return await _acquireLockDB(context, fullKey, expiryTime);
@@ -22,10 +17,10 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout, overrideValue = false } = {}
+  { tenantScoped = true, expiryTime = config.globalTxTimeout, overrideValue = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, {
       value,
       overrideValue,
@@ -40,7 +35,7 @@ const setValueWithExpire = async (
 
 const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _releaseLockRedis(context, fullKey);
   } else {
     return await _releaseLockDb(context, fullKey);
@@ -49,7 +44,7 @@ const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
 
 const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
-  if (config.getConfigInstance().redisEnabled) {
+  if (config.redisEnabled) {
     return await _checkLockExistsRedis(context, fullKey);
   } else {
     return await _checkLockExistsDb(context, fullKey);
@@ -72,9 +67,8 @@ const _checkLockExistsRedis = async (context, fullKey) => {
 
 const _checkLockExistsDb = async (context, fullKey) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-checkExists", async (tx) => {
-    result = await tx.run(SELECT.one.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    result = await tx.run(SELECT.one.from(config.tableNameEventLock).where("code =", fullKey));
   });
   return result?.value;
 };
@@ -85,19 +79,17 @@ const _releaseLockRedis = async (context, fullKey) => {
 };
 
 const _releaseLockDb = async (context, fullKey) => {
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
-    await tx.run(DELETE.from(configInstance.tableNameEventLock).where("code =", fullKey));
+    await tx.run(DELETE.from(config.tableNameEventLock).where("code =", fullKey));
   });
 };
 
 const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   let result;
-  const configInstance = getConfigInstance();
   await cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
     try {
       await tx.run(
-        INSERT.into(configInstance.tableNameEventLock).entries({
+        INSERT.into(config.tableNameEventLock).entries({
           code: fullKey,
           value,
         })
@@ -109,14 +101,14 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
       if (!overrideValue) {
         currentEntry = await tx.run(
           SELECT.one
-            .from(configInstance.tableNameEventLock)
-            .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
+            .from(config.tableNameEventLock)
+            .forUpdate({ wait: config.forUpdateTimeout })
             .where("code =", fullKey)
         );
       }
       if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
         await tx.run(
-          UPDATE.entity(configInstance.tableNameEventLock)
+          UPDATE.entity(config.tableNameEventLock)
             .set({
               createdAt: new Date().toISOString(),
               value,

package/src/shared/{EventScheduler.js → eventScheduler.js}

@@ -3,8 +3,9 @@
 const cds = require("@sap/cds");
 
 const { broadcastEvent } = require("../redisPubSub");
+const config = require("./../config");
 
-const COMPONENT_NAME = "eventQueue/shared/EventScheduler";
+const COMPONENT_NAME = "eventQueue/shared/eventScheduler";
 
 let instance;
 class EventScheduler {
@@ -12,10 +13,8 @@ class EventScheduler {
   constructor() {}
 
   scheduleEvent(tenantId, type, subType, startAfter) {
-    const startAfterSeconds = startAfter.getSeconds();
-    const secondsUntilNextTen = 10 - (startAfterSeconds % 10);
-    const roundUpDate = new Date(startAfter.getTime() + secondsUntilNextTen * 1000);
-    const key = [tenantId, type, subType, roundUpDate.toISOString()].join("##");
+    const { date, relative } = this.calculateOffset(type, subType, startAfter);
+    const key = [tenantId, type, subType, date.toISOString()].join("##");
     if (this.#scheduledEvents[key]) {
       return; // event combination already scheduled
     }
@@ -23,7 +22,7 @@ class EventScheduler {
     cds.log(COMPONENT_NAME).info("scheduling event queue run for delayed event", {
       type,
       subType,
-      delaySeconds: (roundUpDate.getTime() - Date.now()) / 1000,
+      delaySeconds: (date.getTime() - Date.now()) / 1000,
     });
     setTimeout(() => {
       delete this.#scheduledEvents[key];
@@ -32,10 +31,24 @@ class EventScheduler {
           tenantId,
           type,
           subType,
-          scheduledFor: roundUpDate.toISOString(),
+          scheduledFor: date.toISOString(),
         });
       });
-    }, roundUpDate.getTime() - Date.now()).unref();
+    }, relative).unref();
+  }
+
+  calculateOffset(type, subType, startAfter) {
+    const eventConfig = config.getEventConfig(type, subType);
+    const scheduleWithoutDelay = config.isPeriodicEvent(type, subType) && eventConfig.interval < 30 * 1000;
+    const date = scheduleWithoutDelay ? startAfter : this.calculateFutureTime(startAfter, 10);
+
+    return { date, relative: date.getTime() - Date.now() };
+  }
+
+  calculateFutureTime(date, seoncds) {
+    const startAfterSeconds = date.getSeconds();
+    const secondsUntil = seoncds - (startAfterSeconds % seoncds);
+    return new Date(date.getTime() + secondsUntil * 1000);
   }
 
   clearScheduledEvents() {