@mhubcloud/tms_core 3.3.0 → 3.4.0-beta.1

package/dist/index.js

@@ -28,14 +28,117 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   DefaultPublisher: () => defaultPublisher,
+  broker: () => broker_exports,
   publisher: () => publisher,
   testUtils: () => testUtils_exports,
   utils: () => utils_exports
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
+
+// src/broker.ts
+var broker_exports = {};
+__export(broker_exports, {
+  dispatchEvent: () => dispatchEvent,
+  logToCosmosDb: () => logToCosmosDb,
+  resolveEvent: () => resolveEvent
+});
+var import_cosmos = require("@azure/cosmos");
+var import_service_bus = require("@azure/service-bus");
+var serviceBusConnectionString = process.env.ServiceBusConnectionString;
+var cosmosConnectionString = process.env.CosmosDbConnectionString;
+var cosmosDatabaseName = process.env.CosmosDbDatabaseName;
+var cosmosContainerName = process.env.CosmosEventsContainerName;
+var serviceBusClient;
+var cosmosClient;
+var senders = {};
+function resolveEvent(eventCode, publisherConfig) {
+  if (!publisherConfig) {
+    const envConfig = process.env.Broker_PublisherConfig;
+    publisherConfig = envConfig ? JSON.parse(envConfig) : {};
+  }
+  const publishers = [];
+  for (const publisher2 of Object.keys(publisherConfig)) {
+    const publisherEvents = publisherConfig[publisher2];
+    if (publisherEvents[0] === "*") {
+      let matchesExcluded = false;
+      if (Array.isArray(publisherEvents[1]) && publisherEvents[1].length > 0) {
+        for (const event of publisherEvents[1]) {
+          if (matchesExcluded) {
+            break;
+          }
+          if (typeof event === "string") {
+            const regex = new RegExp(event);
+            matchesExcluded = regex.test(eventCode);
+          }
+        }
+      }
+      if (!matchesExcluded) {
+        publishers.push(publisher2);
+      }
+    } else {
+      let match = false;
+      for (const event of publisherEvents) {
+        if (typeof event === "string") {
+          const regex = new RegExp(event);
+          match = regex.test(eventCode);
+        }
+        if (match) {
+          publishers.push(publisher2);
+        }
+      }
+    }
+  }
+  if (publishers.length === 0) {
+    return null;
+  }
+  return publishers;
+}
+async function dispatchEvent(message, queues) {
+  if (!serviceBusClient) {
+    if (!serviceBusConnectionString) {
+      throw new Error("Service Bus connection string is missing.");
+    }
+    serviceBusClient = new import_service_bus.ServiceBusClient(serviceBusConnectionString);
+  }
+  await Promise.all(
+    queues.map(async (queue) => {
+      try {
+        let sender;
+        if (senders[queue]) {
+          sender = senders[queue];
+        } else {
+          senders[queue] = serviceBusClient.createSender(queue);
+          sender = senders[queue];
+        }
+        await sender.sendMessages({ body: message });
+      } catch (e) {
+        console.log(`Sending to queue ${queue} failed`);
+      }
+    })
+  );
+}
+async function logToCosmosDb(message, logger) {
+  if (!cosmosClient) {
+    if (!cosmosConnectionString) {
+      throw new Error("Cosmos DB connection string is missing.");
+    }
+    cosmosClient = new import_cosmos.CosmosClient(cosmosConnectionString);
+  }
+  if (!cosmosDatabaseName) {
+    throw new Error("Cosmos DB database name is missing.");
+  }
+  if (!cosmosContainerName) {
+    throw new Error("Cosmos DB events container name is missing.");
+  }
+  try {
+    await cosmosClient.database(cosmosDatabaseName).container(cosmosContainerName).items.create(message);
+  } catch (e) {
+    utils_exports.logException(logger, e);
+  }
+}
 
 // src/utils/utils.ts
 var utils_exports = {};
@@ -747,6 +850,7 @@ var publisher = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DefaultPublisher,
+  broker,
   publisher,
   testUtils,
   utils

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mhubcloud/tms_core",
-  "version": "3.3.0",
+  "version": "3.4.0-beta.1",
   "description": "Core function for mHub Cloud TMS publishers",
   "homepage": "https://mhubcloud.com/",
   "license": "Apache 2.0",
@@ -16,7 +16,9 @@
     "conversion API"
   ],
   "dependencies": {
+    "@azure/cosmos": "^4.4.1",
     "@azure/data-tables": "^13.2.2",
+    "@azure/service-bus": "^7.9.5",
     "ajv": "^8.12.0",
     "applicationinsights": "^2.6.0"
   },
@@ -34,7 +36,7 @@
     "mocha": "^10.2.0",
     "prettier": "^2.8.8",
     "ts-node": "^10.9.1",
-    "tsup": "^6.7.0",
+    "tsup": "^8.5.0",
     "typescript": "^4.9.5"
   },
   "scripts": {

package/src/broker.ts

@@ -0,0 +1,137 @@
+import { CosmosClient } from '@azure/cosmos';
+import { ServiceBusClient, ServiceBusSender } from '@azure/service-bus';
+import { utils } from '.';
+import { ServiceBusMessage } from './types/ServiceBusMessage';
+const serviceBusConnectionString = process.env.ServiceBusConnectionString;
+const cosmosConnectionString = process.env.CosmosDbConnectionString;
+const cosmosDatabaseName = process.env.CosmosDbDatabaseName;
+const cosmosContainerName = process.env.CosmosEventsContainerName;
+let serviceBusClient: ServiceBusClient | undefined;
+let cosmosClient: CosmosClient | undefined;
+const senders: Record<string, ServiceBusSender> = {};
+
+export type PublisherConfig = Record<string, string[] | string[][]>;
+
+/**
+ * Evaluates an event against publisher configurations
+ * @param eventCode event.code parameter of the event
+ * @param publisherConfig object containing publisher event consumption configurations
+ * @returns list of publishers for which an event is relevant.
+ */
+export function resolveEvent(
+  eventCode: string,
+  publisherConfig?: PublisherConfig,
+) {
+  if (!publisherConfig) {
+    const envConfig = process.env.Broker_PublisherConfig;
+    publisherConfig = envConfig ? JSON.parse(envConfig) : {};
+  }
+
+  const publishers = [];
+
+  for (const publisher of Object.keys(publisherConfig)) {
+    const publisherEvents = publisherConfig[publisher];
+    if (publisherEvents[0] === '*') {
+      let matchesExcluded = false;
+      // Checking whether event matches any of the excluded events
+      if (Array.isArray(publisherEvents[1]) && publisherEvents[1].length > 0) {
+        for (const event of publisherEvents[1]) {
+          if (matchesExcluded) {
+            break;
+          }
+
+          if (typeof event === 'string') {
+            const regex = new RegExp(event);
+            matchesExcluded = regex.test(eventCode);
+          }
+        }
+      }
+      if (!matchesExcluded) {
+        publishers.push(publisher);
+      }
+    } else {
+      let match = false;
+
+      for (const event of publisherEvents) {
+        if (typeof event === 'string') {
+          const regex = new RegExp(event);
+          match = regex.test(eventCode);
+        }
+
+        if (match) {
+          publishers.push(publisher);
+        }
+      }
+    }
+  }
+
+  if (publishers.length === 0) {
+    return null;
+  }
+
+  return publishers;
+}
+
+/**
+ * Sends an event to Service Bus
+ * @param message event to be sent
+ * @param queues list of Service Bus queues to send the event to
+ */
+export async function dispatchEvent(
+  message: Record<string, string>,
+  queues: string[],
+) {
+  if (!serviceBusClient) {
+    if (!serviceBusConnectionString) {
+      throw new Error('Service Bus connection string is missing.');
+    }
+    serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
+  }
+
+  await Promise.all(
+    queues.map(async (queue) => {
+      try {
+        let sender;
+        if (senders[queue]) {
+          sender = senders[queue];
+        } else {
+          senders[queue] = serviceBusClient!.createSender(queue);
+          sender = senders[queue];
+        }
+        await sender.sendMessages({ body: message });
+      } catch (e) {
+        console.log(`Sending to queue ${queue} failed`);
+      }
+    }),
+  );
+}
+
+/**
+ * Logs an event to Cosmos DB
+ * @param message event to be logged
+ */
+export async function logToCosmosDb(message: ServiceBusMessage) {
+  if (!cosmosClient) {
+    if (!cosmosConnectionString) {
+      throw new Error('Cosmos DB connection string is missing.');
+    }
+    cosmosClient = new CosmosClient(cosmosConnectionString);
+  }
+
+  if (!cosmosDatabaseName) {
+    throw new Error('Cosmos DB database name is missing.');
+  }
+
+  if (!cosmosContainerName) {
+    throw new Error('Cosmos DB events container name is missing.');
+  }
+
+  try {
+    await cosmosClient
+      .database(cosmosDatabaseName)
+      .container(cosmosContainerName)
+      .items.create(message);
+  } catch (e) {
+    utils.logException(e as Error);
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+import * as broker from './broker';
 import { defaultPublisher } from './defaultPublisher';
 import { affiliatePort } from './publishers/affiliatePort';
 import { cj } from './publishers/cj';
@@ -26,4 +27,4 @@ export const publisher = {
   AffiliatePort: affiliatePort,
 };
 
-export { utils, defaultPublisher as DefaultPublisher, testUtils };
+export { broker, utils, defaultPublisher as DefaultPublisher, testUtils };

package/src/utils/utils.ts

@@ -88,7 +88,7 @@ export function logEvent(
 /**
  * Logs exception to Azure Function context and to Application Insights (if configured)
  */
-export function logException(log: Logger, exception: Error) {
+export function logException(exception: Error) {
   // log.warn(exception.message);
   aiClient?.trackException({ exception: exception });
 }