@cap-js-community/event-queue 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "An event queue that enables secure transactional processing of asynchronous events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "files": [

package/src/EventQueueError.js

@@ -17,6 +17,7 @@ const ERROR_CODES = {
   DUPLICATE_EVENT_REGISTRATION: "DUPLICATE_EVENT_REGISTRATION",
   NO_MANUEL_INSERT_OF_PERIODIC: "NO_MANUEL_INSERT_OF_PERIODIC",
   LOAD_HIGHER_THAN_LIMIT: "LOAD_HIGHER_THAN_LIMIT",
+  SCHEMA_TENANT_MISMATCH: "SCHEMA_TENANT_MISMATCH",
 };
 
 const ERROR_CODES_META = {
@@ -63,6 +64,9 @@ const ERROR_CODES_META = {
   [ERROR_CODES.LOAD_HIGHER_THAN_LIMIT]: {
     message: "The defined load of an event is higher than the maximum defined limit. Check your configuration!",
   },
+  [ERROR_CODES.SCHEMA_TENANT_MISMATCH]: {
+    message: "The db client associated to the tenant context does not match! Processing will be skipped.",
+  },
 };
 
 class EventQueueError extends VError {
@@ -220,6 +224,17 @@ class EventQueueError extends VError {
       message
     );
   }
+
+  static dbClientSchemaMismatch(tenantId, dbClientSchema, serviceManagerSchema) {
+    const { message } = ERROR_CODES_META[ERROR_CODES.SCHEMA_TENANT_MISMATCH];
+    return new EventQueueError(
+      {
+        name: ERROR_CODES.SCHEMA_TENANT_MISMATCH,
+        info: { tenantId, dbClientSchema, serviceManagerSchema },
+      },
+      message
+    );
+  }
 }
 
 module.exports = EventQueueError;

package/src/EventQueueProcessorBase.js

@@ -532,6 +532,7 @@ class EventQueueProcessorBase {
     let result = [];
     const refDateStartAfter = new Date(Date.now() + this.#config.runInterval * 1.2);
     await executeInNewTransaction(this.__baseContext, "eventQueue-getQueueEntriesAndSetToInProgress", async (tx) => {
+      await this.checkTxConsistency(tx);
       const entries = await tx.run(
         SELECT.from(this.#config.tableNameEventQueue)
           .forUpdate({ wait: this.#config.forUpdateTimeout })
@@ -658,6 +659,46 @@ 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 mtxServiceManager = require("@sap/cds-mtxs/srv/plugins/hana/srv-mgr");
+      const schemaPromise = tx.run("SELECT CURRENT_SCHEMA FROM DUMMY");
+      const serviceManagerBindingsPromise = mtxServiceManager.getAll();
+      const [schema, serviceManagerBindings] = await Promise.allSettled([schemaPromise, serviceManagerBindingsPromise]);
+      if (schema.reason) {
+        errorHandler(schema.reason);
+        return;
+      }
+      if (serviceManagerBindings.reason) {
+        errorHandler(schema.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 (txSchema !== serviceManagerSchema) {
+      const err = EventQueueError.dbClientSchemaMismatch(tx.context.tenant, txSchema, serviceManagerSchema);
+      errorHandler(err);
+      throw err;
+    }
+  }
+
   async #selectLastSuccessfulPeriodicTimestamp() {
     const entry = await SELECT.one
       .from(this.#config.tableNameEventQueue)

package/src/config.js

@@ -56,6 +56,7 @@ class Config {
   #thresholdLoggingEventProcessing;
   #useAsCAPOutbox;
   #userId;
+  #enableTxConsistencyCheck;
   static #instance;
   constructor() {
     this.#logger = cds.log(COMPONENT_NAME);
@@ -462,6 +463,14 @@ class Config {
     return this.#userId;
   }
 
+  set enableTxConsistencyCheck(value) {
+    this.#enableTxConsistencyCheck = value;
+  }
+
+  get enableTxConsistencyCheck() {
+    return this.#enableTxConsistencyCheck;
+  }
+
   get isMultiTenancy() {
     return !!cds.requires.multitenancy;
   }

package/src/index.js

@@ -1,13 +1,7 @@
 "use strict";
 
 // TODO: how to deal with fatal logs
-// TODO: think about situations where isInitialized need to be checked - publishEvent access config which is not initialized
 // TODO: add tests for config --> similar to csn check
-// TODO: redis client check reconnect strategy
-
-// TODO: for test
-// --> deeper look into the functions e.g. getQueueEntriesAndSetToInProgress
-// TODO: add test for commit on event level and stuff like that
 
 module.exports = {
   ...require("./initialize"),

package/src/initialize.js

@@ -37,6 +37,7 @@ const CONFIG_VARS = [
   ["thresholdLoggingEventProcessing", 50],
   ["useAsCAPOutbox", false],
   ["userId", null],
+  ["enableTxConsistencyCheck", false],
 ];
 
 const initialize = async ({
@@ -53,6 +54,7 @@ const initialize = async ({
   thresholdLoggingEventProcessing,
   useAsCAPOutbox,
   userId,
+  enableTxConsistencyCheck,
 } = {}) => {
   // TODO: initialize check:
   // - content of yaml check
@@ -76,7 +78,8 @@ const initialize = async ({
     updatePeriodicEvents,
     thresholdLoggingEventProcessing,
     useAsCAPOutbox,
-    userId
+    userId,
+    enableTxConsistencyCheck
   );
 
   const logger = cds.log(COMPONENT);

package/src/processEventQueue.js

@@ -34,7 +34,7 @@ const processEventQueue = async (context, eventType, eventSubType, startTime = n
       return;
     }
     if (baseInstance.isPeriodicEvent) {
-      return await processPeriodicEvent(baseInstance);
+      return await processPeriodicEvent(context, baseInstance);
     }
     eventConfig.startTime = startTime;
     while (shouldContinue) {
@@ -93,6 +93,9 @@ 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,
     });
@@ -115,10 +118,7 @@ const reevaluateShouldContinue = (eventTypeInstance, iterationCounter, startTime
   return false;
 };
 
-const processPeriodicEvent = async (eventTypeInstance) => {
-  let queueEntry;
-  let processNext = true;
-
+const processPeriodicEvent = async (context, eventTypeInstance) => {
   const isPeriodicEventBlockedCb = config.isPeriodicEventBlockedCb;
   const params = [eventTypeInstance.eventType, eventTypeInstance.eventSubType, eventTypeInstance.context.tenant];
   let eventBlocked = false;
@@ -145,6 +145,8 @@ const processPeriodicEvent = async (eventTypeInstance) => {
   }
 
   try {
+    let queueEntry;
+    let processNext = true;
     while (processNext) {
       await executeInNewTransaction(
         eventTypeInstance.context,
@@ -207,6 +209,9 @@ const processPeriodicEvent = async (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/shared/cdsHelper.js

@@ -100,16 +100,22 @@ const getSubdomainForTenantId = async (tenantId) => {
     return null;
   }
   if (subdomainCache[tenantId]) {
-    return subdomainCache[tenantId];
-  }
-  try {
-    const ssp = await cds.connect.to("cds.xt.SaasProvisioningService");
-    const response = await ssp.get("/tenant", { subscribedTenantId: tenantId });
-    subdomainCache[tenantId] = response.subscribedSubdomain;
-    return response.subscribedSubdomain;
-  } catch (err) {
-    return null;
+    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 () => {

package/src/shared/redis.js

@@ -70,17 +70,16 @@ const createClientAndConnect = async (errorHandlerCreateClient) => {
   return client;
 };
 
-const subscribeRedisChannel = (channel, subscribeCb) => {
+const subscribeRedisChannel = (channel, subscribeHandler) => {
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error(`error from redis client for pub/sub failed for channel ${channel}`, err);
     subscriberChannelClientPromise[channel] = null;
-    setTimeout(() => subscribeRedisChannel(channel, subscribeCb), 5 * 1000).unref();
+    setTimeout(() => subscribeRedisChannel(channel, subscribeHandler), 5 * 1000).unref();
   };
-  subscriberChannelClientPromise[channel] = createClientAndConnect(errorHandlerCreateClient);
-  subscriberChannelClientPromise[channel]
+  subscriberChannelClientPromise[channel] = createClientAndConnect(errorHandlerCreateClient)
     .then((client) => {
       cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });
-      client.subscribe(channel, subscribeCb).catch(errorHandlerCreateClient);
+      client.subscribe(channel, subscribeHandler).catch(errorHandlerCreateClient);
     })
     .catch((err) => {
       cds