@avtechno/sfr 1.0.6 → 1.0.8

package/dist/mq.mjs

@@ -63,15 +63,18 @@ export class BaseMQ {
     }
 }
 /**
- * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
+ * BroadcastMQ class to handle different types of broadcast communication patterns: Fanout, Direct, and Topic.
  */
 export class BroadcastMQ extends BaseMQ {
     channel;
     type;
-    constructor(channel, type) {
+    exchange_options;
+    constructor(channel, type, exchange_options) {
         super(channel, type);
         this.channel = channel;
         this.type = type;
+        this.exchange_options = exchange_options;
+        this.exchange_options = exchange_options || { durable: false };
     }
     /**
      * Publishes a message to the specified exchange based on the communication pattern.
@@ -82,23 +85,23 @@ export class BroadcastMQ extends BaseMQ {
      * @param options - Additional publishing options.
      * @example
      * // Publish a message to a 'logsExchange' with a routing key 'error' for a routing pattern.
-     * const mq = new BroadcastMQ(channel, "Routing");
+     * const mq = new BroadcastMQ(channel, "Direct");
      * mq.publish("logsExchange", "error", { level: "error", message: "Something went wrong" });
      */
     async publish(exchange, key = "", payload, options) {
         switch (this.type) {
-            case "Publish-Subscribe": {
-                await this.channel.assertExchange(exchange, "fanout", { durable: false });
+            case "Fanout": {
+                await this.channel.assertExchange(exchange, "fanout", this.exchange_options);
                 this.channel.publish(exchange, key, encode_payload(payload), options);
                 break;
             }
-            case "Routing": {
-                await this.channel.assertExchange(exchange, "direct", { durable: false });
+            case "Direct": {
+                await this.channel.assertExchange(exchange, "direct", this.exchange_options);
                 this.channel.publish(exchange, key, encode_payload(payload), options);
                 break;
             }
             case "Topic": {
-                await this.channel.assertExchange(exchange, "topic", { durable: false });
+                await this.channel.assertExchange(exchange, "topic", this.exchange_options);
                 this.channel.publish(exchange, key, encode_payload(payload), options);
                 break;
             }
@@ -112,36 +115,39 @@ export class BroadcastMQ extends BaseMQ {
      * @param cfg - Configuration options for the consumer, including the callback function.
      * @param options - Additional consumption options.
      * @example
-     * // Subscribe to the 'logsExchange' for all 'error' messages in the Routing pattern.
-     * const mq = new BroadcastMQ(channel, "Routing");
+     * // Subscribe to the 'logsExchange' for all 'error' messages in the Direct pattern.
+     * const mq = new BroadcastMQ(channel, "Direct");
      * mq.subscribe("logsExchange", "error", { fn: handleErrorLogs, options: { noAck: true } });
      */
-    async subscribe(exchange, key, cfg, options) {
+    async subscribe(exchange, key, cfg) {
         let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
         switch (this.type) {
-            case "Publish-Subscribe": {
-                await this.channel.assertExchange(exchange, "fanout", { durable: false });
+            case "Fanout": {
+                await this.channel.assertExchange(exchange, "fanout", this.exchange_options);
                 const { queue } = await this.channel.assertQueue("", { exclusive: true });
                 this.channel.bindQueue(queue, exchange, "");
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
                 break;
             }
-            case "Routing": {
-                await this.channel.assertExchange(exchange, "direct", { durable: false });
+            case "Direct": {
+                await this.channel.assertExchange(exchange, "direct", this.exchange_options);
                 const { queue } = await this.channel.assertQueue("", { exclusive: true });
                 await this.channel.bindQueue(queue, exchange, key);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
                 break;
             }
             case "Topic": {
-                await this.channel.assertExchange(exchange, "topic", { durable: false });
+                await this.channel.assertExchange(exchange, "topic", this.exchange_options);
                 const { queue } = await this.channel.assertQueue("", { exclusive: true });
                 this.channel.bindQueue(queue, exchange, key);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
                 break;
             }
         }
     }
+    set_options(options) {
+        this.exchange_options = options;
+    }
 }
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
@@ -149,10 +155,13 @@ export class BroadcastMQ extends BaseMQ {
 export class TargetedMQ extends BaseMQ {
     channel;
     type;
-    constructor(channel, type) {
+    queue_options;
+    constructor(channel, type, queue_options) {
         super(channel, type);
         this.channel = channel;
         this.type = type;
+        this.queue_options = queue_options;
+        this.queue_options = queue_options || { durable: true };
     }
     /**
      * Sends a message to the specified queue depending on the communication pattern.
@@ -169,11 +178,11 @@ export class TargetedMQ extends BaseMQ {
         /* Alter produce strategy depending on the instance's configured comm pattern */
         switch (this.type) {
             case "Point-to-Point": {
-                await this.channel.assertQueue(binding);
+                await this.channel.assertQueue(binding, this.queue_options);
                 return this.channel.sendToQueue(binding, encode_payload(payload), options);
             }
             case "Request-Reply": {
-                await this.channel.assertQueue(binding);
+                await this.channel.assertQueue(binding, this.queue_options);
                 return this.channel.sendToQueue(binding, encode_payload(payload), options);
             }
         }
@@ -192,17 +201,20 @@ export class TargetedMQ extends BaseMQ {
         let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
         switch (this.type) {
             case "Point-to-Point": {
-                await this.channel.assertQueue(queue, cfg.queue_options);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+                await this.channel.assertQueue(queue, this.queue_options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
                 break;
             }
             case "Request-Reply": {
-                await this.channel.assertQueue(queue, cfg.queue_options);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+                await this.channel.assertQueue(queue, this.queue_options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
                 break;
             }
         }
     }
+    set_options(options) {
+        this.queue_options = options;
+    }
 }
 /* Helper Functions */
 /**

package/dist/sfr-pipeline.mjs

@@ -5,7 +5,7 @@ import { BroadcastMQ, TargetedMQ } from "./mq.mjs";
 import j2s from "joi-to-swagger";
 import { logger } from "./logger.mjs";
 const CWD = process.cwd();
-const PATTERNS = ["Point-to-Point", "Request-Reply", "Publish-Subscribe", "Routing", "Topic"];
+const PATTERNS = ["Point-to-Point", "Request-Reply", "Fanout", "Direct", "Topic"];
 const TARGETED_PATTERN = ["Point-to-Point", "Request-Reply"];
 export class SFRPipeline {
     cfg;
@@ -219,15 +219,13 @@ export class SFRPipeline {
                     /* bind validators */
                     if (mq instanceof TargetedMQ) {
                         mq.consume(dir, {
-                            consume_options: handler.consume_options,
-                            queue_options: handler.queue_options,
+                            options: handler.options,
                             fn: validator_fn
                         });
                     }
                     if (mq instanceof BroadcastMQ) {
                         mq.subscribe(dir, handler.key, {
-                            queue_options: handler.queue_options,
-                            consume_options: handler.consume_options,
+                            options: handler.options,
                             fn: validator_fn
                         });
                     }

package/dist/types/mq.d.mts

@@ -44,12 +44,13 @@ export declare class BaseMQ {
     reply(msg: ConsumeMessage, payload: any): Promise<void>;
 }
 /**
- * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
+ * BroadcastMQ class to handle different types of broadcast communication patterns: Fanout, Direct, and Topic.
  */
 export declare class BroadcastMQ extends BaseMQ {
     channel: Channel;
     protected type: CommunicationPattern;
-    constructor(channel: Channel, type: CommunicationPattern);
+    protected exchange_options?: Options.AssertExchange;
+    constructor(channel: Channel, type: CommunicationPattern, exchange_options?: Options.AssertExchange);
     /**
      * Publishes a message to the specified exchange based on the communication pattern.
      *
@@ -59,7 +60,7 @@ export declare class BroadcastMQ extends BaseMQ {
      * @param options - Additional publishing options.
      * @example
      * // Publish a message to a 'logsExchange' with a routing key 'error' for a routing pattern.
-     * const mq = new BroadcastMQ(channel, "Routing");
+     * const mq = new BroadcastMQ(channel, "Direct");
      * mq.publish("logsExchange", "error", { level: "error", message: "Something went wrong" });
      */
     publish(exchange: string, key: string, payload: any, options?: Options.Publish): Promise<void>;
@@ -71,11 +72,12 @@ export declare class BroadcastMQ extends BaseMQ {
      * @param cfg - Configuration options for the consumer, including the callback function.
      * @param options - Additional consumption options.
      * @example
-     * // Subscribe to the 'logsExchange' for all 'error' messages in the Routing pattern.
-     * const mq = new BroadcastMQ(channel, "Routing");
+     * // Subscribe to the 'logsExchange' for all 'error' messages in the Direct pattern.
+     * const mq = new BroadcastMQ(channel, "Direct");
      * mq.subscribe("logsExchange", "error", { fn: handleErrorLogs, options: { noAck: true } });
      */
-    subscribe(exchange: string, key: string, cfg: ConsumerConfig, options?: Options.Publish): Promise<void>;
+    subscribe(exchange: string, key: string, cfg: ConsumerConfig): Promise<void>;
+    set_options(options: Options.AssertExchange): void;
 }
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
@@ -83,7 +85,8 @@ export declare class BroadcastMQ extends BaseMQ {
 export declare class TargetedMQ extends BaseMQ {
     channel: Channel;
     protected type: CommunicationPattern;
-    constructor(channel: Channel, type: CommunicationPattern);
+    protected queue_options?: Options.AssertQueue;
+    constructor(channel: Channel, type: CommunicationPattern, queue_options?: Options.AssertQueue);
     /**
      * Sends a message to the specified queue depending on the communication pattern.
      *
@@ -107,4 +110,5 @@ export declare class TargetedMQ extends BaseMQ {
      * mq.consume("taskQueue", { fn: processTask, options: { noAck: true } });
      */
     consume(queue: string, cfg: ConsumerConfig): Promise<void>;
+    set_options(options: Options.AssertQueue): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avtechno/sfr",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "An opinionated way of writing services using ExpressJS.",
   "type": "module",
   "files": [
@@ -37,7 +37,7 @@
     "winston": "^3.17.0"
   },
   "devDependencies": {
-    "@types/amqplib": "^0.10.5",
+    "@types/amqplib": "^0.10.3",
     "@types/express": "^4.17.19",
     "@types/express-session": "^1.18.0",
     "@types/js-yaml": "^4.0.7",

package/src/mq.mts

@@ -64,13 +64,13 @@ export class BaseMQ{
 }
 
 /**
- * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
+ * BroadcastMQ class to handle different types of broadcast communication patterns: Fanout, Direct, and Topic.
  */
 export class BroadcastMQ extends BaseMQ{
-  constructor(public channel: Channel, protected type: CommunicationPattern) {
+  constructor(public channel: Channel, protected type: CommunicationPattern, protected exchange_options? : Options.AssertExchange) {
     super(channel, type);
+    this.exchange_options = exchange_options || { durable : false };
   }
-
   /**
    * Publishes a message to the specified exchange based on the communication pattern.
    * 
@@ -80,28 +80,28 @@ export class BroadcastMQ extends BaseMQ{
    * @param options - Additional publishing options.
    * @example
    * // Publish a message to a 'logsExchange' with a routing key 'error' for a routing pattern.
-   * const mq = new BroadcastMQ(channel, "Routing");
+   * const mq = new BroadcastMQ(channel, "Direct");
    * mq.publish("logsExchange", "error", { level: "error", message: "Something went wrong" });
    */
   async publish(exchange: string, key: string = "", payload: any, options?: Options.Publish) {
     switch (this.type) {
-    case "Publish-Subscribe": {
-      await this.channel.assertExchange(exchange, "fanout", { durable: false });
-      this.channel.publish(exchange, key, encode_payload(payload), options);
-      break;
-    }
+      case "Fanout": {
+        await this.channel.assertExchange(exchange, "fanout", this.exchange_options);
+        this.channel.publish(exchange, key, encode_payload(payload), options);
+        break;
+      }
 
-    case "Routing": {
-      await this.channel.assertExchange(exchange, "direct", { durable: false });
-      this.channel.publish(exchange, key, encode_payload(payload), options);
-      break;
-    }
+      case "Direct": {
+        await this.channel.assertExchange(exchange, "direct", this.exchange_options);
+        this.channel.publish(exchange, key, encode_payload(payload), options);
+        break;
+      }
 
-    case "Topic": {
-      await this.channel.assertExchange(exchange, "topic", { durable: false });
-      this.channel.publish(exchange, key, encode_payload(payload), options);
-      break;
-    }
+      case "Topic": {
+        await this.channel.assertExchange(exchange, "topic", this.exchange_options);
+        this.channel.publish(exchange, key, encode_payload(payload), options);
+        break;
+      }
     }
   }
 
@@ -113,55 +113,59 @@ export class BroadcastMQ extends BaseMQ{
    * @param cfg - Configuration options for the consumer, including the callback function.
    * @param options - Additional consumption options.
    * @example
-   * // Subscribe to the 'logsExchange' for all 'error' messages in the Routing pattern.
-   * const mq = new BroadcastMQ(channel, "Routing");
+   * // Subscribe to the 'logsExchange' for all 'error' messages in the Direct pattern.
+   * const mq = new BroadcastMQ(channel, "Direct");
    * mq.subscribe("logsExchange", "error", { fn: handleErrorLogs, options: { noAck: true } });
    */
   async subscribe(
     exchange: string,
     key: string,
     cfg: ConsumerConfig,
-    options?: Options.Publish
   ) {
     let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
 
     switch (this.type) {
-    case "Publish-Subscribe": {
-      await this.channel.assertExchange(exchange, "fanout", { durable: false });
+    case "Fanout": {
+      await this.channel.assertExchange(exchange, "fanout", this.exchange_options);
       const { queue } = await this.channel.assertQueue("", { exclusive: true });
 
       this.channel.bindQueue(queue, exchange, "");
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
       break;
     }
 
-    case "Routing": {
-      await this.channel.assertExchange(exchange, "direct", { durable: false });
+    case "Direct": {
+      await this.channel.assertExchange(exchange, "direct", this.exchange_options);
       const { queue } = await this.channel.assertQueue("", { exclusive: true });
       await this.channel.bindQueue(queue, exchange, key);
 
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), options);
+      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
       break;
     }
 
     case "Topic": {
-      await this.channel.assertExchange(exchange, "topic", { durable: false });
+      await this.channel.assertExchange(exchange, "topic", this.exchange_options);
       const { queue } = await this.channel.assertQueue("", { exclusive: true });
 
       this.channel.bindQueue(queue, exchange, key);
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), options);
+      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
       break;
     }
     }
   }
+
+  set_options(options : Options.AssertExchange){
+    this.exchange_options = options;
+  }
 }
 
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
  */
 export class TargetedMQ extends BaseMQ{
-  constructor(public channel: Channel, protected type: CommunicationPattern) {
+  constructor(public channel: Channel, protected type: CommunicationPattern, protected queue_options? : Options.AssertQueue) {
     super(channel, type);
+    this.queue_options = queue_options || { durable : true };
   }
   /**
    * Sends a message to the specified queue depending on the communication pattern.
@@ -177,15 +181,15 @@ export class TargetedMQ extends BaseMQ{
   async produce(binding: string, payload: any, options?: Options.Publish) {
     /* Alter produce strategy depending on the instance's configured comm pattern */
     switch (this.type) {
-    case "Point-to-Point": {
-      await this.channel.assertQueue(binding);
-      return this.channel.sendToQueue(binding, encode_payload(payload), options);
-    }
+      case "Point-to-Point": {
+        await this.channel.assertQueue(binding, this.queue_options);
+        return this.channel.sendToQueue(binding, encode_payload(payload), options);
+      }
 
-    case "Request-Reply": {
-      await this.channel.assertQueue(binding);
-      return this.channel.sendToQueue(binding, encode_payload(payload), options);
-    }
+      case "Request-Reply": {
+        await this.channel.assertQueue(binding, this.queue_options);
+        return this.channel.sendToQueue(binding, encode_payload(payload), options);
+      }
     }
   }
 
@@ -204,18 +208,23 @@ export class TargetedMQ extends BaseMQ{
 
     switch (this.type) {
       case "Point-to-Point": {
-        await this.channel.assertQueue(queue, cfg.queue_options);
-        this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+        await this.channel.assertQueue(queue, this.queue_options);
+        this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
         break;
       }
 
       case "Request-Reply": {
-        await this.channel.assertQueue(queue, cfg.queue_options);
-        this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
+        await this.channel.assertQueue(queue, this.queue_options);
+        this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
         break;
       }
     }
   }
+
+  
+  set_options(options : Options.AssertQueue){
+    this.queue_options = options;
+  }
 }
 
 /* Helper Functions */

package/src/sfr-pipeline.mts

@@ -8,7 +8,7 @@ import {logger} from "./logger.mjs";
 
 const CWD = process.cwd();
 
-const PATTERNS: CommunicationPattern[] = ["Point-to-Point", "Request-Reply", "Publish-Subscribe", "Routing", "Topic"];
+const PATTERNS: CommunicationPattern[] = ["Point-to-Point", "Request-Reply", "Fanout", "Direct", "Topic"];
 const TARGETED_PATTERN = ["Point-to-Point", "Request-Reply"];
 
 export class SFRPipeline {
@@ -231,16 +231,14 @@ export class SFRPipeline {
           /* bind validators */
           if (mq instanceof TargetedMQ) {
             mq.consume(dir, {
-              consume_options: handler.consume_options,
-              queue_options : handler.queue_options,
+              options : handler.options,
               fn: validator_fn
             })
           }
 
           if (mq instanceof BroadcastMQ) {
             mq.subscribe(dir, handler.key, {
-              queue_options : handler.queue_options,
-              consume_options: handler.consume_options,
+              options : handler.options,
               fn : validator_fn
             });
           }

package/src/types/index.d.ts

@@ -284,8 +284,7 @@ declare type QueueOptions   = import("amqplib").Options.AssertQueue;
 declare type ConsumeOptions = import("amqplib").Options.Consume;
 
 declare type ConsumerConfig = {
-  queue_options? : QueueOptions;
-  consume_options?: ConsumeOptions;
+  options?: ConsumeOptions;
   fn: ((msg: ConsumeMessage) => void);
 } & ThisType<ConsumerContext>;
 declare type ConsumerContext = {
@@ -298,18 +297,18 @@ declare type ConsumerContext = {
 /* Commons */
 type CommunicationPattern = (
   "Point-to-Point" |
-  "Publish-Subscribe" |
+  "Fanout" |
   "Request-Reply" |
-  "Routing" |
+  "Direct" |
   "Topic"
   /* "Scatter-Gather" */
 )
 
 declare type PatternMQSet = {
   "Point-to-Point": TargetedMQ;
-  "Publish-Subscribe": BroadcastMQ;
+  "Fanout": BroadcastMQ;
   "Request-Reply": TargetedMQ;
-  "Routing": TargetedMQ;
+  "Direct": TargetedMQ;
   "Topic": TargetedMQ;
 }
 
@@ -322,9 +321,9 @@ declare type MQHandlerDescriptor<V, H, C> = {
 
 declare type MQRequestHandlers<C> = {
   "Point-to-Point"?: MQRequestHandlerMap & ThisType<{ mq: Omit<TargetedMQ, "type" | "reply"> } & C>;
-  "Publish-Subscribe"?: MQRequestHandlerMap & ThisType<{ mq: Omit<BroadcastMQ, "type"> } & C>;
+  "Fanout"?: MQRequestHandlerMap & ThisType<{ mq: Omit<BroadcastMQ, "type"> } & C>;
   "Request-Reply"?: MQRequestHandlerMap & ThisType<{ mq: Omit<TargetedMQ, "type"> } & C>;
-  "Routing"?: RoutingHandlerMap & ThisType<{ mq: Omit<BroadcastMQ, "type"> } & C>;
+  "Direct"?: RoutingHandlerMap & ThisType<{ mq: Omit<BroadcastMQ, "type"> } & C>;
   "Topic"?: TopicHandlerMap & ThisType<{ mq: Omit<BroadcastMQ, "type"> } & C>;
 };
 
@@ -341,8 +340,7 @@ declare type TopicHandlerMap = {
 }
 
 declare type MQConsumeOptions = {
-  queue_options? : QueueOptions;
-  consume_options?: ConsumeOptions;
+  options?: ConsumeOptions;
   key? : string;
   fn: MQRequestHandler;
 }