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

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.1",
   "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,12 +42,13 @@
     "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",

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();
   }
 
   /**
@@ -537,10 +533,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 +660,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 +672,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,7 +64,6 @@ class Config {
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
   #userId;
-  #enableTxConsistencyCheck;
   #cleanupLocksAndEventsForDev;
   #redisOptions;
   static #instance;
@@ -479,14 +478,6 @@ class Config {
     return this.#userId;
   }
 
-  set enableTxConsistencyCheck(value) {
-    this.#enableTxConsistencyCheck = value;
-  }
-
-  get enableTxConsistencyCheck() {
-    return this.#enableTxConsistencyCheck;
-  }
-
   set cleanupLocksAndEventsForDev(value) {
     this.#cleanupLocksAndEventsForDev = value;
   }

package/src/initialize.js

@@ -32,7 +32,6 @@ const CONFIG_VARS = [
   ["thresholdLoggingEventProcessing", 50],
   ["useAsCAPOutbox", false],
   ["userId", null],
-  ["enableTxConsistencyCheck", false],
   ["cleanupLocksAndEventsForDev", false],
   ["redisOptions", {}],
 ];
@@ -48,7 +47,6 @@ const initialize = async ({
   thresholdLoggingEventProcessing,
   useAsCAPOutbox,
   userId,
-  enableTxConsistencyCheck,
   cleanupLocksAndEventsForDev,
   redisOptions,
 } = {}) => {
@@ -68,7 +66,6 @@ const initialize = async ({
     thresholdLoggingEventProcessing,
     useAsCAPOutbox,
     userId,
-    enableTxConsistencyCheck,
     cleanupLocksAndEventsForDev,
     redisOptions
   );

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/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/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 = {}),
+  },
+};