@cap-js-community/event-queue 0.1.50 → 0.1.52

package/src/shared/PerformanceTracer.js

@@ -36,9 +36,7 @@ class PerformanceTracer {
     //determine, if an options object was provided as first argument
     if (
       typeof args?.[0] === "object" &&
-      (args[0].quantity >= 0 ||
-        args[0].threshold > 0 ||
-        args[0].additionalQuantityThreshold > 0)
+      (args[0].quantity >= 0 || args[0].threshold > 0 || args[0].additionalQuantityThreshold > 0)
     ) {
       options = args.shift();
     }

package/src/shared/SetIntervalDriftSafe.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const COMPONENT = "eventQueue/SetIntervalDriftSafe";
+
+class SetIntervalDriftSafe {
+  #adjustedInterval;
+  #interval;
+  #expectedCycleTime = 0;
+  #nextTickScheduledFor;
+  #logger;
+
+  constructor(interval) {
+    this.#interval = interval;
+    this.#adjustedInterval = interval;
+    this.#logger = cds.log(COMPONENT);
+  }
+
+  run(fn) {
+    const now = Date.now();
+    if (this.#expectedCycleTime === 0) {
+      this.#expectedCycleTime = now + this.#interval;
+    } else if (now + this.#interval - this.#nextTickScheduledFor < this.#interval) {
+      this.#logger.info("overlapping ticks, skipping this run");
+      return;
+    } else {
+      this.#adjustedInterval = this.#interval - (now - this.#expectedCycleTime);
+      this.#expectedCycleTime += this.#interval;
+    }
+    this.#nextTickScheduledFor = now + this.#adjustedInterval;
+    setTimeout(() => {
+      this.run(fn);
+      fn();
+    }, this.#adjustedInterval);
+  }
+}
+
+module.exports = SetIntervalDriftSafe;

package/src/shared/WorkerQueue.js

@@ -32,31 +32,20 @@ class WorkerQueue {
     this.__runningPromises.push(promise);
     promise
       .finally(() => {
-        this.__runningPromises.splice(
-          this.__runningPromises.indexOf(promise),
-          1
-        );
+        this.__runningPromises.splice(this.__runningPromises.indexOf(promise), 1);
         this._checkForNext();
       })
       .then((...results) => {
         resolve(...results);
       })
       .catch((err) => {
-        cds
-          .log(COMPONENT_NAME)
-          .error(
-            "Error happened in WorkQueue. Errors should be caught before! Error:",
-            err
-          );
+        cds.log(COMPONENT_NAME).error("Error happened in WorkQueue. Errors should be caught before! Error:", err);
         reject(err);
       });
   }
 
   _checkForNext() {
-    if (
-      !this.__queue.length ||
-      this.__runningPromises.length >= this.__concurrencyLimit
-    ) {
+    if (!this.__queue.length || this.__runningPromises.length >= this.__concurrencyLimit) {
       return;
     }
     const [cb, resolve, reject] = this.__queue.shift();

package/src/shared/cdsHelper.js

@@ -20,13 +20,7 @@ const COMPONENT_NAME = "eventQueue/cdsHelper";
  * @param info {object} Additional information object attached to logging
  * @returns {Promise<boolean>} Promise resolving to true if everything worked fine / false if an error occurred
  */
-async function executeInNewTransaction(
-  context = {},
-  transactionTag,
-  fn,
-  args,
-  { info = {} } = {}
-) {
+async function executeInNewTransaction(context = {}, transactionTag, fn, args, { info = {} } = {}) {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
   try {
@@ -48,10 +42,7 @@ async function executeInNewTransaction(
     } else {
       const contextTx = cds.tx(context);
       const contextTxState = contextTx.ready;
-      if (
-        !contextTxState ||
-        ["committed", "rolled back"].includes(contextTxState)
-      ) {
+      if (!contextTxState || ["committed", "rolled back"].includes(contextTxState)) {
         await cds.tx(
           {
             id: context.id,

package/src/shared/common.js

@@ -56,10 +56,7 @@ class Funnel {
     }
 
     // map function call to promise
-    const p =
-      f.constructor.name === "AsyncFunction"
-        ? f(...args)
-        : Promise.resolve().then(() => f(...args));
+    const p = f.constructor.name === "AsyncFunction" ? f(...args) : Promise.resolve().then(() => f(...args));
 
     // create promise for book keeping
     const workload = p.finally(() => {
@@ -100,9 +97,7 @@ const limiter = async (limit, payloads, iterator) => {
     returnPromises.push(p);
 
     if (limit <= payloads.length) {
-      const e = p
-        .catch(() => {})
-        .finally(() => runningPromises.splice(runningPromises.indexOf(e), 1));
+      const e = p.catch(() => {}).finally(() => runningPromises.splice(runningPromises.indexOf(e), 1));
       runningPromises.push(e);
       if (limit <= runningPromises.length) {
         await Promise.race(runningPromises);

package/src/shared/distributedLock.js

@@ -8,10 +8,7 @@ const { getConfigInstance } = require("../config");
 const acquireLock = async (
   context,
   key,
-  {
-    tenantScoped = true,
-    expiryTime = config.getConfigInstance().globalTxTimeout,
-  } = {}
+  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
@@ -25,11 +22,7 @@ const setValueWithExpire = async (
   context,
   key,
   value,
-  {
-    tenantScoped = true,
-    expiryTime = config.getConfigInstance().globalTxTimeout,
-    overrideValue = false,
-  } = {}
+  { tenantScoped = true, expiryTime = config.getConfigInstance().globalTxTimeout, overrideValue = false } = {}
 ) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
@@ -54,11 +47,7 @@ const releaseLock = async (context, key, { tenantScoped = true } = {}) => {
   }
 };
 
-const checkLockExistsAndReturnValue = async (
-  context,
-  key,
-  { tenantScoped = true } = {}
-) => {
+const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.getConfigInstance().redisEnabled) {
     return await _checkLockExistsRedis(context, fullKey);
@@ -67,12 +56,7 @@ const checkLockExistsAndReturnValue = async (
   }
 };
 
-const _acquireLockRedis = async (
-  context,
-  fullKey,
-  expiryTime,
-  { value = "true", overrideValue = false } = {}
-) => {
+const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
   const client = await redis.createMainClientAndConnect();
   const result = await client.set(fullKey, value, {
     PX: expiryTime,
@@ -89,17 +73,9 @@ 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)
-      );
-    }
-  );
+  await cdsHelper.executeInNewTransaction(context, "distributedLock-checkExists", async (tx) => {
+    result = await tx.run(SELECT.one.from(configInstance.tableNameEventLock).where("code =", fullKey));
+  });
   return result?.value;
 };
 
@@ -110,69 +86,49 @@ 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 cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
+    await tx.run(DELETE.from(configInstance.tableNameEventLock).where("code =", fullKey));
+  });
 };
 
-const _acquireLockDB = async (
-  context,
-  fullKey,
-  expiryTime,
-  { value = "true", overrideValue = false } = {}
-) => {
+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 cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
+    try {
+      await tx.run(
+        INSERT.into(configInstance.tableNameEventLock).entries({
+          code: fullKey,
+          value,
+        })
+      );
+      result = true;
+    } catch (err) {
+      let currentEntry;
+
+      if (!overrideValue) {
+        currentEntry = await tx.run(
+          SELECT.one
+            .from(configInstance.tableNameEventLock)
+            .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
+            .where("code =", fullKey)
+        );
+      }
+      if (overrideValue || (currentEntry && new Date(currentEntry.createdAt).getTime() + expiryTime <= Date.now())) {
         await tx.run(
-          INSERT.into(configInstance.tableNameEventLock).entries({
-            code: fullKey,
-            value,
-          })
+          UPDATE.entity(configInstance.tableNameEventLock)
+            .set({
+              createdAt: new Date().toISOString(),
+              value,
+            })
+            .where("code =", currentEntry.code)
         );
         result = true;
-      } catch (err) {
-        let currentEntry;
-
-        if (!overrideValue) {
-          currentEntry = await tx.run(
-            SELECT.one
-              .from(configInstance.tableNameEventLock)
-              .forUpdate({ wait: config.getConfigInstance().forUpdateTimeout })
-              .where("code =", fullKey)
-          );
-        }
-        if (
-          overrideValue ||
-          (currentEntry &&
-            new Date(currentEntry.createdAt).getTime() + expiryTime <=
-              Date.now())
-        ) {
-          await tx.run(
-            UPDATE.entity(configInstance.tableNameEventLock)
-              .set({
-                createdAt: new Date().toISOString(),
-                value,
-              })
-              .where("code =", currentEntry.code)
-          );
-          result = true;
-        } else {
-          result = false;
-        }
+      } else {
+        result = false;
       }
     }
-  );
+  });
   return result;
 };
 

package/src/shared/redis.js

@@ -15,9 +15,7 @@ const createMainClientAndConnect = () => {
   }
 
   const errorHandlerCreateClient = (err) => {
-    cds
-      .log(COMPONENT_NAME)
-      .error("error from redis client for pub/sub failed", err);
+    cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
     subscriberClientPromise = null;
     setTimeout(createMainClientAndConnect, 5 * 1000).unref();
   };