@mhubcloud/tms_core 3.4.0-beta.1 → 3.4.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mhubcloud/tms_core",
-  "version": "3.4.0-beta.1",
+  "version": "3.4.0-beta.3",
   "description": "Core function for mHub Cloud TMS publishers",
   "homepage": "https://mhubcloud.com/",
   "license": "Apache 2.0",

package/src/broker.ts

@@ -1,7 +1,7 @@
 import { CosmosClient } from '@azure/cosmos';
 import { ServiceBusClient, ServiceBusSender } from '@azure/service-bus';
-import { utils } from '.';
 import { ServiceBusMessage } from './types/ServiceBusMessage';
+import * as utils from './utils/utils';
 const serviceBusConnectionString = process.env.ServiceBusConnectionString;
 const cosmosConnectionString = process.env.CosmosDbConnectionString;
 const cosmosDatabaseName = process.env.CosmosDbDatabaseName;
@@ -10,128 +10,135 @@ let serviceBusClient: ServiceBusClient | undefined;
 let cosmosClient: CosmosClient | undefined;
 const senders: Record<string, ServiceBusSender> = {};
 
-export type PublisherConfig = Record<string, string[] | string[][]>;
+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) : {};
-  }
+export const broker = {
+  /**
+   * 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.
+   */
+  resolveEvent: function (
+    eventCode: string,
+    publisherConfig?: PublisherConfig,
+  ) {
+    if (!publisherConfig) {
+      const envConfig = process.env.Broker_PublisherConfig;
+      publisherConfig = envConfig ? JSON.parse(envConfig) : {};
+    }
 
-  const publishers = [];
+    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;
-          }
+    for (const publisher of Object.keys(publisherConfig)) {
+      const publisherEvents = publisherConfig[publisher];
+      if (publisherEvents) {
+        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 (typeof event === 'string') {
+                const regex = new RegExp(event);
+                matchesExcluded = regex.test(eventCode);
+              }
+            }
           }
-        }
-      }
-      if (!matchesExcluded) {
-        publishers.push(publisher);
-      }
-    } else {
-      let match = false;
+          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);
-        }
+          for (const event of publisherEvents) {
+            if (typeof event === 'string') {
+              const regex = new RegExp(event);
+              match = regex.test(eventCode);
+            }
 
-        if (match) {
-          publishers.push(publisher);
+            if (match) {
+              publishers.push(publisher);
+            }
+          }
         }
       }
     }
-  }
 
-  if (publishers.length === 0) {
-    return null;
-  }
+    if (publishers.length === 0) {
+      return null;
+    }
 
-  return publishers;
-}
+    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.');
+  /**
+   * Sends an event to Service Bus
+   * @param message event to be sent
+   * @param queues list of Service Bus queues to send the event to
+   */
+  dispatchEvent: async function (
+    message: Record<string, string>,
+    queues: string[],
+  ) {
+    if (!serviceBusClient) {
+      if (!serviceBusConnectionString) {
+        throw new Error('Service Bus connection string is missing.');
+      }
+      serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
     }
-    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 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`);
         }
-        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.');
+  /**
+   * Logs an event to Cosmos DB
+   * @param message event to be logged
+   */
+  logToCosmosDb: async function (message: ServiceBusMessage) {
+    if (!cosmosClient) {
+      if (!cosmosConnectionString) {
+        throw new Error('Cosmos DB connection string is missing.');
+      }
+      cosmosClient = new CosmosClient(cosmosConnectionString);
     }
-    cosmosClient = new CosmosClient(cosmosConnectionString);
-  }
 
-  if (!cosmosDatabaseName) {
-    throw new Error('Cosmos DB database name is missing.');
-  }
+    if (!cosmosDatabaseName) {
+      throw new Error('Cosmos DB database name is missing.');
+    }
 
-  if (!cosmosContainerName) {
-    throw new Error('Cosmos DB events container 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);
-  }
-}
+    try {
+      await cosmosClient
+        .database(cosmosDatabaseName)
+        .container(cosmosContainerName)
+        .items.create(message);
+    } catch (e) {
+      utils.logException(e as Error);
+    }
+  },
+};