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

package/cds-plugin.js

@@ -6,5 +6,5 @@ const eventQueue = require("./src");
 const COMPONENT_NAME = "/eventQueue/plugin";
 
 if (!cds.build.register && cds.env.eventQueue) {
-  eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
+  module.exports = eventQueue.initialize().catch((err) => cds.log(COMPONENT_NAME).error(err));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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",
   "files": [
@@ -42,15 +42,16 @@
     "node": ">=18"
   },
   "dependencies": {
-    "redis": "4.6.13",
-    "verror": "1.10.1",
-    "yaml": "2.4.1"
+    "@sap/xssec": "^3.6.1",
+    "redis": "^4.6.13",
+    "verror": "^1.10.1",
+    "yaml": "^2.4.1"
   },
   "devDependencies": {
-    "@cap-js/hana": "^0.0.6",
+    "@cap-js/hana": "^0.1.0",
     "@cap-js/sqlite": "^1.5.0",
-    "@sap/cds": "^7.7.0",
-    "@sap/cds-dk": "^7.5.1",
+    "@sap/cds": "^7.8.0",
+    "@sap/cds-dk": "^7.8.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jest": "^27.9.0",

package/src/EventQueueProcessorBase.js

@@ -23,8 +23,6 @@ const TRIES_FOR_EXCEEDED_EVENTS = 3;
 const EVENT_START_AFTER_HEADROOM = 3 * 1000;
 const ETAG_CHECK_AFTER_MIN = 10;
 
-let serviceBindingCache = null;
-
 class EventQueueProcessorBase {
   #eventsWithExceededTries = [];
   #exceededTriesExceeded = [];
@@ -72,8 +70,6 @@ class EventQueueProcessorBase {
     this.__txMap = {};
     this.__txRollback = {};
     this.__queueEntries = [];
-
-    this.#checkGlobalContextToLocalContext();
   }
 
   /**
@@ -283,22 +279,33 @@ class EventQueueProcessorBase {
       eventSubType: this.#eventSubType,
     });
     const statusMap = this.commitOnEventLevel || returnMap ? {} : this.__statusMap;
-    try {
-      queueEntryProcessingStatusTuple.forEach(([id, processingStatus]) =>
-        this.#determineAndAddEventStatusToMap(id, processingStatus, statusMap)
-      );
-    } catch (error) {
+    const errorHandler = (error) => {
       queueEntries.forEach((queueEntry) =>
         this.#determineAndAddEventStatusToMap(queueEntry.ID, EventProcessingStatus.Error, statusMap)
       );
       this.logger.error(
         "The supplied status tuple doesn't have the required structure. Setting all entries to error.",
-        error,
-        {
-          eventType: this.#eventType,
-          eventSubType: this.#eventSubType,
-        }
+        ...[
+          error,
+          {
+            eventType: this.#eventType,
+            eventSubType: this.#eventSubType,
+          },
+        ].filter((a) => a)
+      );
+    };
+
+    if (!queueEntryProcessingStatusTuple) {
+      errorHandler();
+      return statusMap;
+    }
+
+    try {
+      queueEntryProcessingStatusTuple.forEach(([id, processingStatus]) =>
+        this.#determineAndAddEventStatusToMap(id, processingStatus, statusMap)
       );
+    } catch (error) {
+      errorHandler(error);
     }
     return statusMap;
   }
@@ -537,10 +544,7 @@ class EventQueueProcessorBase {
   async getQueueEntriesAndSetToInProgress() {
     let result = [];
     const refDateStartAfter = new Date(Date.now() + this.#config.runInterval * 1.2);
-    this.#checkGlobalContextToLocalContext();
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
-      this.#checkGlobalContextToLocalContext();
-      await this.checkTxConsistency(tx);
       const entries = await tx.run(
         SELECT.from(this.#config.tableNameEventQueue)
           .forUpdate({ wait: this.#config.forUpdateTimeout })
@@ -667,57 +671,6 @@ class EventQueueProcessorBase {
     return result;
   }
 
-  async checkTxConsistency(tx) {
-    if (!this.#config.enableTxConsistencyCheck) {
-      return;
-    }
-
-    const errorHandler = (err) =>
-      this.logger.error("tx consistency check failed!", err, {
-        type: this.eventType,
-        subType: this.eventSubType,
-        txTenant: tx.context.tenant,
-        globalCdsTenant: cds.context.tenant,
-      });
-    let txSchema, serviceManagerSchema;
-    try {
-      const schemaPromise = tx.run("SELECT CURRENT_SCHEMA FROM DUMMY");
-      const [schema, serviceManagerBindings] = await Promise.allSettled([schemaPromise, this.#getServiceBindings()]);
-      if (schema.reason) {
-        errorHandler(schema.reason);
-        return;
-      }
-      if (serviceManagerBindings.reason) {
-        errorHandler(serviceManagerBindings.reason);
-        return;
-      }
-
-      txSchema = schema.value[0].CURRENT_SCHEMA;
-      serviceManagerSchema = serviceManagerBindings.value.find((t) => t.labels.tenant_id[0] === tx.context.tenant)
-        .credentials.schema;
-    } catch (err) {
-      errorHandler(err);
-    }
-    if (serviceManagerSchema && txSchema !== serviceManagerSchema) {
-      const err = EventQueueError.dbClientSchemaMismatch(tx.context.tenant, txSchema, serviceManagerSchema);
-      errorHandler(err);
-      throw err;
-    }
-  }
-
-  async #getServiceBindings() {
-    if (!(serviceBindingCache && serviceBindingCache.expireTs >= Date.now())) {
-      const mtxServiceManager = require("@sap/cds-mtxs/srv/plugins/hana/srv-mgr");
-      serviceBindingCache = {
-        expireTs: Date.now() + 10 * 60 * 1000,
-        value: mtxServiceManager.getAll().catch(() => {
-          serviceBindingCache = null;
-        }),
-      };
-    }
-    return await serviceBindingCache.value;
-  }
-
   async #selectLastSuccessfulPeriodicTimestamp() {
     const entry = await SELECT.one
       .from(this.#config.tableNameEventQueue)
@@ -730,48 +683,6 @@ class EventQueueProcessorBase {
     return entry.lastAttemptsTs;
   }
 
-  #checkGlobalContextToLocalContext() {
-    if (!this.#config.enableTxConsistencyCheck) {
-      return;
-    }
-    if (this.__context.tenant !== cds.context.tenant) {
-      throw EventQueueError.globalCdsContextNotMatchingLocal(
-        JSON.stringify(
-          {
-            correlationId: cds.context.id,
-            tenantId: cds.context.tenant,
-            timestamp: cds.context.timestamp,
-            base: JSON.stringify(
-              {
-                correlationId: cds.context.context?.id,
-                tenantId: cds.context.context?.tenant,
-                timestamp: cds.context.context?.timestamp,
-              },
-              null,
-              2
-            ),
-          },
-          null,
-          2
-        ),
-        JSON.stringify(
-          {
-            correlationId: this.__context.id,
-            tenantId: this.__context.tenant,
-            timestamp: this.__context.timestamp,
-            base: JSON.stringify({
-              correlationId: this.__context.context?.id,
-              tenantId: this.__context.context?.tenant,
-              timestamp: this.__context.context?.timestamp,
-            }),
-          },
-          null,
-          2
-        )
-      );
-    }
-  }
-
   #handleDelayedEvents(delayedEvents) {
     for (const delayedEvent of delayedEvents) {
       this.#eventSchedulerInstance.scheduleEvent(

package/src/config.js

@@ -64,9 +64,9 @@ class Config {
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
   #userId;
-  #enableTxConsistencyCheck;
   #cleanupLocksAndEventsForDev;
   #redisOptions;
+  #insertEventsBeforeCommit;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -479,14 +479,6 @@ class Config {
     return this.#userId;
   }
 
-  set enableTxConsistencyCheck(value) {
-    this.#enableTxConsistencyCheck = value;
-  }
-
-  get enableTxConsistencyCheck() {
-    return this.#enableTxConsistencyCheck;
-  }
-
   set cleanupLocksAndEventsForDev(value) {
     this.#cleanupLocksAndEventsForDev = value;
   }
@@ -503,6 +495,14 @@ class Config {
     return this.#redisOptions;
   }
 
+  set insertEventsBeforeCommit(value) {
+    this.#insertEventsBeforeCommit = value;
+  }
+
+  get insertEventsBeforeCommit() {
+    return this.#insertEventsBeforeCommit;
+  }
+
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }

package/src/dbHandler.js

@@ -6,8 +6,17 @@ const { broadcastEvent } = require("./redis/redisPub");
 const config = require("./config");
 
 const COMPONENT_NAME = "/eventQueue/dbHandler";
+const registeredHandlers = {
+  eventQueueDbHandler: false,
+  beforeDbHandler: false,
+};
 
 const registerEventQueueDbHandler = (dbService) => {
+  if (registeredHandlers.eventQueueDbHandler) {
+    return;
+  }
+
+  registeredHandlers.eventQueueDbHandler = true;
   const def = dbService.model.definitions[config.tableNameEventQueue];
   dbService.after("CREATE", def, (_, req) => {
     if (req.tx._skipEventQueueBroadcase) {
@@ -46,6 +55,21 @@ 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/initialize.js

@@ -15,6 +15,7 @@ const redis = require("./shared/redis");
 const eventQueueAsOutbox = require("./outbox/eventQueueAsOutbox");
 const { getAllTenantIds } = require("./shared/cdsHelper");
 const { EventProcessingStatus } = require("./constants");
+const distributedLock = require("./shared/distributedLock");
 
 const readFileAsync = promisify(fs.readFile);
 
@@ -32,9 +33,9 @@ const CONFIG_VARS = [
   ["thresholdLoggingEventProcessing", 50],
   ["useAsCAPOutbox", false],
   ["userId", null],
-  ["enableTxConsistencyCheck", false],
   ["cleanupLocksAndEventsForDev", false],
   ["redisOptions", {}],
+  ["insertEventsBeforeCommit", false],
 ];
 
 const initialize = async ({
@@ -48,9 +49,9 @@ const initialize = async ({
   thresholdLoggingEventProcessing,
   useAsCAPOutbox,
   userId,
-  enableTxConsistencyCheck,
   cleanupLocksAndEventsForDev,
   redisOptions,
+  insertEventsBeforeCommit,
 } = {}) => {
   if (config.initialized) {
     return;
@@ -68,9 +69,9 @@ const initialize = async ({
     thresholdLoggingEventProcessing,
     useAsCAPOutbox,
     userId,
-    enableTxConsistencyCheck,
     cleanupLocksAndEventsForDev,
-    redisOptions
+    redisOptions,
+    insertEventsBeforeCommit
   );
 
   const logger = cds.log(COMPONENT);
@@ -80,6 +81,7 @@ 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);
     }
@@ -169,6 +171,7 @@ const mixConfigVarsWithEnv = (...args) => {
 
 const registerCdsShutdown = () => {
   cds.on("shutdown", async () => {
+    await distributedLock.shutdownHandler();
     await Promise.allSettled([redis.closeMainClient(), closeSubscribeClient()]);
   });
 };

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -23,6 +23,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       delete msg._fromSend;
       delete msg.contextUser;
       processContext.user = new cds.User.Privileged(userId);
+      processContext._eventQueue = { processor: this, key, queueEntries, payload };
       await cds.unboxed(service).tx(processContext)[invocationFn](msg);
     } catch (err) {
       status = EventProcessingStatus.Error;

package/src/processEventQueue.js

@@ -96,9 +96,6 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
     }
   } catch (err) {
     cds.log(COMPONENT_NAME).error("Processing event queue failed with unexpected error.", err, {
-      tenantId: context?.tenant,
-      tenantIdBase: baseInstance?.context?.tenant,
-      globalTenantId: cds.context?.tenant,
       eventType,
       eventSubType,
     });
@@ -188,9 +185,6 @@ const processPeriodicEvent = async (context, eventTypeInstance) => {
     cds.log(COMPONENT_NAME).error("Processing periodic events failed with unexpected error.", err, {
       eventType: eventTypeInstance?.eventType,
       eventSubType: eventTypeInstance?.eventSubType,
-      tenantId: context?.tenant,
-      tenantIdBase: eventTypeInstance?.context?.tenant,
-      globalTenantId: cds.context?.tenant,
     });
   } finally {
     await eventTypeInstance?.handleReleaseLock();

package/src/publishEvent.js

@@ -45,10 +45,16 @@ const publishEvent = async (tx, events, skipBroadcast = false) => {
       throw EventQueueError.manuelPeriodicEventInsert(type, subType);
     }
   }
-  tx._skipEventQueueBroadcase = skipBroadcast;
-  const result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(eventsForProcessing));
-  tx._skipEventQueueBroadcase = false;
-  return result;
+
+  if (config.insertEventsBeforeCommit) {
+    tx.context._eventQueueEvents ??= [];
+    tx.context._eventQueueEvents = tx.context._eventQueueEvents.concat(events);
+  } else {
+    tx._skipEventQueueBroadcase = skipBroadcast;
+    const result = await tx.run(INSERT.into(config.tableNameEventQueue).entries(eventsForProcessing));
+    tx._skipEventQueueBroadcase = false;
+    return result;
+  }
 };
 
 module.exports = {

package/src/redis/redisPub.js

@@ -7,7 +7,7 @@ const cds = require("@sap/cds");
 const redis = require("../shared/redis");
 const { checkLockExistsAndReturnValue } = require("../shared/distributedLock");
 const config = require("../config");
-const { getSubdomainForTenantId } = require("../shared/cdsHelper");
+const common = require("../shared/common");
 const { runEventCombinationForTenant } = require("../runner/runnerHelper");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
@@ -29,13 +29,10 @@ const broadcastEvent = async (tenantId, events) => {
       if (config.registerAsEventProcessor) {
         let context = {};
         if (tenantId) {
-          const subdomain = await getSubdomainForTenantId(tenantId);
-          const user = new cds.User.Privileged(config.userId);
+          const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
           context = {
-            // NOTE: we need this because of logging otherwise logs would not contain the subdomain
             tenant: tenantId,
             user,
-            http: { req: { authInfo: { getSubdomain: () => subdomain } } },
           };
         }
 

package/src/redis/redisSub.js

@@ -4,8 +4,8 @@ const cds = require("@sap/cds");
 
 const redis = require("../shared/redis");
 const config = require("../config");
-const { getSubdomainForTenantId } = require("../shared/cdsHelper");
 const runnerHelper = require("../runner/runnerHelper");
+const common = require("../shared/common");
 
 const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
 const COMPONENT_NAME = "/eventQueue/redisSub";
@@ -35,13 +35,10 @@ const _messageHandlerProcessEvents = async (messageData) => {
       return;
     }
 
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const user = new cds.User.Privileged(config.userId);
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
     const tenantContext = {
       tenant: tenantId,
       user,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
     };
 
     if (!config.getEventConfig(type, subType)) {

package/src/runner/openEvents.js

@@ -31,6 +31,7 @@ const getOpenQueueEntries = async (tx) => {
   for (const { type, subType } of entries) {
     if (type.startsWith("CAP_OUTBOX")) {
       if (cds.requires[subType]) {
+        await cds.connect.to(subType).catch(() => {});
         result.push({ type, subType });
       } else {
         const service = await cds.connect.to(subType).catch(() => {});

package/src/runner/runner.js

@@ -9,9 +9,8 @@ const WorkerQueue = require("../shared/WorkerQueue");
 const cdsHelper = require("../shared/cdsHelper");
 const distributedLock = require("../shared/distributedLock");
 const SetIntervalDriftSafe = require("../shared/SetIntervalDriftSafe");
-const { getSubdomainForTenantId } = require("../shared/cdsHelper");
 const periodicEvents = require("../periodicEvents");
-const { hashStringTo32Bit } = require("../shared/common");
+const common = require("../shared/common");
 const config = require("../config");
 const redisPub = require("../redis/redisPub");
 const openEvents = require("./openEvents");
@@ -80,7 +79,7 @@ const _multiTenancyRedis = async () => {
 };
 
 const _checkPeriodicEventUpdate = async (tenantIds) => {
-  const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
+  const hash = common.hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
     return await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
@@ -137,13 +136,10 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
   const promises = [];
 
   for (const tenantId of tenantIds) {
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const user = new cds.User.Privileged(config.userId);
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
     const tenantContext = {
       tenant: tenantId,
       user,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
     };
     const events = await cds.tx(tenantContext, async (tx) => {
       return await openEvents.getOpenQueueEntries(tx);
@@ -184,13 +180,10 @@ const _executeEventsAllTenants = async (tenantIds, runId) => {
 const _executePeriodicEventsAllTenants = async (tenantIds) => {
   for (const tenantId of tenantIds) {
     try {
-      const subdomain = await getSubdomainForTenantId(tenantId);
-      const user = new cds.User.Privileged(config.userId);
+      const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
       const tenantContext = {
         tenant: tenantId,
         user,
-        // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-        http: { req: { authInfo: { getSubdomain: () => subdomain } } },
       };
       await cds.tx(tenantContext, async ({ context }) => {
         if (!config.redisEnabled) {
@@ -350,7 +343,7 @@ const _checkPeriodicEventsSingleTenant = async (context) => {
   try {
     logger.info("executing updating periodic events", {
       tenantId: context.tenant,
-      subdomain: context.http?.req.authInfo.getSubdomain(),
+      subdomain: context.user?.authInfo?.getSubdomain(),
     });
     await periodicEvents.checkAndInsertPeriodicEvents(context);
   } catch (err) {

package/src/shared/cdsHelper.js

@@ -4,8 +4,7 @@ const VError = require("verror");
 const cds = require("@sap/cds");
 
 const config = require("../config");
-
-const subdomainCache = {};
+const common = require("./common");
 
 const VERROR_CLUSTER_NAME = "ExecuteInNewTransactionError";
 const COMPONENT_NAME = "/eventQueue/cdsHelper";
@@ -24,7 +23,7 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const user = new cds.User.Privileged(config.userId);
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(context.tenant) });
     if (cds.db.kind === "hana") {
       await cds.tx(
         {
@@ -33,7 +32,6 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
           locale: context.locale,
           user,
           headers: context.headers,
-          http: context.http,
         },
         async (tx) => {
           tx.context._ = context._ ?? {};
@@ -51,7 +49,6 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
             locale: context.locale,
             user,
             headers: context.headers,
-            http: context.http,
           },
           async (tx) => fn(tx, ...parameters)
         );
@@ -102,29 +99,6 @@ class TriggerRollback extends VError {
   }
 }
 
-const getSubdomainForTenantId = async (tenantId) => {
-  if (!config.isMultiTenancy) {
-    return null;
-  }
-  if (subdomainCache[tenantId]) {
-    return await subdomainCache[tenantId];
-  }
-  subdomainCache[tenantId] = new Promise((resolve) => {
-    cds.connect
-      .to("cds.xt.SaasProvisioningService")
-      .then((ssp) => {
-        ssp
-          .get("/tenant", { subscribedTenantId: tenantId })
-          .then((response) => {
-            resolve(response.subscribedSubdomain);
-          })
-          .catch(() => resolve(null));
-      })
-      .catch(() => resolve(null));
-  });
-  return await subdomainCache[tenantId];
-};
-
 const getAllTenantIds = async () => {
   if (!config.isMultiTenancy) {
     return null;
@@ -150,6 +124,5 @@ const isFakeTenant = (tenantId) => /00000000-0000-4000-8000-\d{12}/.test(tenantI
 module.exports = {
   executeInNewTransaction,
   TriggerRollback,
-  getSubdomainForTenantId,
   getAllTenantIds,
 };

package/src/shared/common.js

@@ -1,6 +1,18 @@
 "use strict";
 
 const crypto = require("crypto");
+const { promisify } = require("util");
+
+const cds = require("@sap/cds");
+const xssec = require("@sap/xssec");
+
+const getAuthTokenAsync = promisify(xssec.requests.requestClientCredentialsToken);
+const getCreateSecurityContextAsync = promisify(xssec.createSecurityContext);
+
+let authInfoCache = {};
+const MARGIN_AUTH_INFO_EXPIRY = 60 * 1000;
+const COMPONENT_NAME = "/eventQueue/common";
+
 const arrayToFlatMap = (array, key = "ID") => {
   return array.reduce((result, element) => {
     result[element[key]] = element;
@@ -61,4 +73,43 @@ const processChunkedSync = (inputs, chunkSize, chunkHandler) => {
 
 const hashStringTo32Bit = (value) => crypto.createHash("sha256").update(String(value)).digest("base64").slice(0, 32);
 
-module.exports = { arrayToFlatMap, limiter, isValidDate, processChunkedSync, hashStringTo32Bit };
+const _getNewAuthInfo = async (tenantId) => {
+  try {
+    const token = await getAuthTokenAsync(null, cds.requires.auth.credentials, null, tenantId);
+    const authInfo = await getCreateSecurityContextAsync(token, cds.requires.auth.credentials);
+    authInfoCache[tenantId].expireTs = authInfo.getExpirationDate().getTime() - MARGIN_AUTH_INFO_EXPIRY;
+    return authInfo;
+  } catch (err) {
+    authInfoCache[tenantId] = null;
+    cds.log(COMPONENT_NAME).warn("failed to request authInfo", err);
+  }
+};
+
+const getAuthInfo = async (tenantId) => {
+  if (!cds.requires?.auth?.credentials) {
+    return null; // no credentials not authInfo
+  }
+
+  // not existing or existing but expired
+  if (
+    !authInfoCache[tenantId] ||
+    (authInfoCache[tenantId] && authInfoCache[tenantId].expireTs && Date.now() > authInfoCache[tenantId].expireTs)
+  ) {
+    authInfoCache[tenantId] ??= {};
+    authInfoCache[tenantId].value = _getNewAuthInfo(tenantId);
+    authInfoCache[tenantId].expireTs = null;
+  }
+  return await authInfoCache[tenantId].value;
+};
+
+module.exports = {
+  arrayToFlatMap,
+  limiter,
+  isValidDate,
+  processChunkedSync,
+  hashStringTo32Bit,
+  getAuthInfo,
+  __: {
+    clearAuthInfoCache: () => (authInfoCache = {}),
+  },
+};

package/src/shared/distributedLock.js

@@ -6,6 +6,10 @@ const cdsHelper = require("./cdsHelper");
 
 const KEY_PREFIX = "EVENT_QUEUE";
 
+const existingLocks = {};
+
+const REDIS_COMMAND_OK = "OK";
+
 const acquireLock = async (context, key, { tenantScoped = true, expiryTime = config.globalTxTimeout } = {}) => {
   const fullKey = _generateKey(context, tenantScoped, key);
   if (config.redisEnabled) {
@@ -59,7 +63,11 @@ const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true",
     PX: expiryTime,
     ...(overrideValue ? null : { NX: true }),
   });
-  return result === "OK";
+  const isOk = result === REDIS_COMMAND_OK;
+  if (isOk) {
+    existingLocks[fullKey] = 1;
+  }
+  return isOk;
 };
 
 const _checkLockExistsRedis = async (context, fullKey) => {
@@ -78,6 +86,7 @@ const _checkLockExistsDb = async (context, fullKey) => {
 const _releaseLockRedis = async (context, fullKey) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
   await client.del(fullKey);
+  delete existingLocks[fullKey];
 };
 
 const _releaseLockDb = async (context, fullKey) => {
@@ -133,9 +142,14 @@ const _generateKey = (context, tenantScoped, key) => {
   return `${KEY_PREFIX}_${keyParts.join("##")}`;
 };
 
+const shutdownHandler = async () => {
+  await Promise.allSettled(Object.keys(existingLocks).map((key) => _releaseLockRedis(null, key)));
+};
+
 module.exports = {
   acquireLock,
   releaseLock,
   checkLockExistsAndReturnValue,
   setValueWithExpire,
+  shutdownHandler,
 };