@avtechno/sfr 1.0.3 → 1.0.4

package/dist/mq.mjs

@@ -38,13 +38,38 @@ export class MQLib {
         return this.channel;
     }
 }
+export class BaseMQ {
+    channel;
+    type;
+    constructor(channel, type) {
+        this.channel = channel;
+        this.type = type;
+    }
+    /**
+     * Sends a reply to the message sender in a Request-Reply pattern.
+     *
+     * @param msg - The original message to reply to.
+     * @param payload - The reply message to send back to the requester.
+     * @example
+     * // Send a response back to the client in a Request-Reply pattern
+     * const mq = new TargetedMQ(channel, "Request-Reply");
+     * mq.reply(msg, { result: "Processed successfully" });
+     */
+    async reply(msg, payload) {
+        if (this.type !== "Request-Reply")
+            return;
+        this.channel.sendToQueue(msg.properties.replyTo, encode_payload(payload), { correlationId: msg.properties.correlationId });
+        this.channel.ack(msg);
+    }
+}
 /**
  * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
  */
-export class BroadcastMQ {
+export class BroadcastMQ extends BaseMQ {
     channel;
     type;
     constructor(channel, type) {
+        super(channel, type);
         this.channel = channel;
         this.type = type;
     }
@@ -98,7 +123,7 @@ export class BroadcastMQ {
                 await this.channel.assertExchange(exchange, "fanout", { durable: false });
                 const { queue } = await this.channel.assertQueue("", { exclusive: true });
                 this.channel.bindQueue(queue, exchange, "");
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
                 break;
             }
             case "Routing": {
@@ -121,10 +146,11 @@ export class BroadcastMQ {
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
  */
-export class TargetedMQ {
+export class TargetedMQ extends BaseMQ {
     channel;
     type;
     constructor(channel, type) {
+        super(channel, type);
         this.channel = channel;
         this.type = type;
     }
@@ -152,22 +178,6 @@ export class TargetedMQ {
             }
         }
     }
-    /**
-     * Sends a reply to the message sender in a Request-Reply pattern.
-     *
-     * @param msg - The original message to reply to.
-     * @param payload - The reply message to send back to the requester.
-     * @example
-     * // Send a response back to the client in a Request-Reply pattern
-     * const mq = new TargetedMQ(channel, "Request-Reply");
-     * mq.reply(msg, { result: "Processed successfully" });
-     */
-    async reply(msg, payload) {
-        if (this.type !== "Request-Reply")
-            return;
-        this.channel.sendToQueue(msg.properties.replyTo, encode_payload(payload), { correlationId: msg.properties.correlationId });
-        this.channel.ack(msg);
-    }
     /**
      * Consumes messages from the specified queue based on the communication pattern.
      *
@@ -182,13 +192,13 @@ export class TargetedMQ {
         let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
         switch (this.type) {
             case "Point-to-Point": {
-                await this.channel.assertQueue(queue);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
+                await this.channel.assertQueue(queue, cfg.queue_options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
                 break;
             }
             case "Request-Reply": {
-                await this.channel.assertQueue(queue);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
+                await this.channel.assertQueue(queue, cfg.queue_options);
+                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
                 break;
             }
         }

package/dist/sfr-pipeline.mjs

@@ -196,7 +196,7 @@ export class SFRPipeline {
                 for (let [name, handler] of valid_handlers) {
                     const dir = `${base_dir}${namespace}/${name}`;
                     const validator = validators[name];
-                    const validator_type = typeof validator !== "function" ? "joi" : "multer"; // TODO: Dynamically update parameter content based on validator type.
+                    //const validator_type = typeof validator !== "function" ? "joi" : "multer"; // TODO: Dynamically update parameter content based on validator type.
                     let validator_fn = function (msg) {
                         const error = template(validator, msg.content);
                         if (error) {
@@ -219,33 +219,17 @@ export class SFRPipeline {
                     /* bind validators */
                     if (mq instanceof TargetedMQ) {
                         mq.consume(dir, {
-                            options: handler.options,
+                            consume_options: handler.consume_options,
+                            queue_options: handler.queue_options,
                             fn: validator_fn
                         });
                     }
                     if (mq instanceof BroadcastMQ) {
-                        switch (pattern) {
-                            case "Publish-Subscribe":
-                                {
-                                    mq.subscribe(dir, handler.key, {
-                                        options: handler.options,
-                                        fn: validator_fn
-                                    });
-                                }
-                                break;
-                            case "Routing": {
-                                mq.subscribe(dir, handler.key, {
-                                    options: handler.options,
-                                    fn: validator_fn
-                                });
-                            }
-                            case "Topic": {
-                                mq.subscribe(dir, handler.key, {
-                                    options: handler.options,
-                                    fn: validator_fn
-                                });
-                            }
-                        }
+                        mq.subscribe(dir, handler.key, {
+                            queue_options: handler.queue_options,
+                            consume_options: handler.consume_options,
+                            fn: validator_fn
+                        });
                     }
                     this.mount_data.mq++;
                 }

package/dist/types/mq.d.mts

@@ -27,10 +27,26 @@ export declare class MQLib {
      */
     get_channel(): Channel;
 }
+export declare class BaseMQ {
+    channel: Channel;
+    protected type: CommunicationPattern;
+    constructor(channel: Channel, type: CommunicationPattern);
+    /**
+     * Sends a reply to the message sender in a Request-Reply pattern.
+     *
+     * @param msg - The original message to reply to.
+     * @param payload - The reply message to send back to the requester.
+     * @example
+     * // Send a response back to the client in a Request-Reply pattern
+     * const mq = new TargetedMQ(channel, "Request-Reply");
+     * mq.reply(msg, { result: "Processed successfully" });
+     */
+    reply(msg: ConsumeMessage, payload: any): Promise<void>;
+}
 /**
  * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
  */
-export declare class BroadcastMQ {
+export declare class BroadcastMQ extends BaseMQ {
     channel: Channel;
     protected type: CommunicationPattern;
     constructor(channel: Channel, type: CommunicationPattern);
@@ -64,7 +80,7 @@ export declare class BroadcastMQ {
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
  */
-export declare class TargetedMQ {
+export declare class TargetedMQ extends BaseMQ {
     channel: Channel;
     protected type: CommunicationPattern;
     constructor(channel: Channel, type: CommunicationPattern);
@@ -80,17 +96,6 @@ export declare class TargetedMQ {
      * mq.produce("taskQueue", { taskId: 1, action: "process" });
      */
     produce(binding: string, payload: any, options?: Options.Publish): Promise<boolean>;
-    /**
-     * Sends a reply to the message sender in a Request-Reply pattern.
-     *
-     * @param msg - The original message to reply to.
-     * @param payload - The reply message to send back to the requester.
-     * @example
-     * // Send a response back to the client in a Request-Reply pattern
-     * const mq = new TargetedMQ(channel, "Request-Reply");
-     * mq.reply(msg, { result: "Processed successfully" });
-     */
-    reply(msg: ConsumeMessage, payload: any): Promise<void>;
     /**
      * Consumes messages from the specified queue based on the communication pattern.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avtechno/sfr",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "An opinionated way of writing services using ExpressJS.",
   "type": "module",
   "files": [

package/src/mq.mts

@@ -43,11 +43,33 @@ export class MQLib {
   }
 }
 
+export class BaseMQ{
+  constructor(public channel: Channel, protected type: CommunicationPattern) {}
+  /**
+   * Sends a reply to the message sender in a Request-Reply pattern.
+   * 
+   * @param msg - The original message to reply to.
+   * @param payload - The reply message to send back to the requester.
+   * @example
+   * // Send a response back to the client in a Request-Reply pattern
+   * const mq = new TargetedMQ(channel, "Request-Reply");
+   * mq.reply(msg, { result: "Processed successfully" });
+   */
+  async reply(msg: ConsumeMessage, payload: any) {
+    if (this.type !== "Request-Reply") return;
+
+    this.channel.sendToQueue(msg.properties.replyTo, encode_payload(payload), {correlationId : msg.properties.correlationId});
+    this.channel.ack(msg);
+  }
+}
+
 /**
  * BroadcastMQ class to handle different types of broadcast communication patterns: Publish-Subscribe, Routing, and Topic.
  */
-export class BroadcastMQ {
-  constructor(public channel: Channel, protected type: CommunicationPattern) {}
+export class BroadcastMQ extends BaseMQ{
+  constructor(public channel: Channel, protected type: CommunicationPattern) {
+    super(channel, type);
+  }
 
   /**
    * Publishes a message to the specified exchange based on the communication pattern.
@@ -109,7 +131,7 @@ export class BroadcastMQ {
       const { queue } = await this.channel.assertQueue("", { exclusive: true });
 
       this.channel.bindQueue(queue, exchange, "");
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
+      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_options);
       break;
     }
 
@@ -137,9 +159,10 @@ export class BroadcastMQ {
 /**
  * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
  */
-export class TargetedMQ {
-  constructor(public channel: Channel, protected type: CommunicationPattern) {}
-
+export class TargetedMQ extends BaseMQ{
+  constructor(public channel: Channel, protected type: CommunicationPattern) {
+    super(channel, type);
+  }
   /**
    * Sends a message to the specified queue depending on the communication pattern.
    * 
@@ -166,23 +189,6 @@ export class TargetedMQ {
     }
   }
 
-  /**
-   * Sends a reply to the message sender in a Request-Reply pattern.
-   * 
-   * @param msg - The original message to reply to.
-   * @param payload - The reply message to send back to the requester.
-   * @example
-   * // Send a response back to the client in a Request-Reply pattern
-   * const mq = new TargetedMQ(channel, "Request-Reply");
-   * mq.reply(msg, { result: "Processed successfully" });
-   */
-  async reply(msg: ConsumeMessage, payload: any) {
-    if (this.type !== "Request-Reply") return;
-
-    this.channel.sendToQueue(msg.properties.replyTo, encode_payload(payload), {correlationId : msg.properties.correlationId});
-    this.channel.ack(msg);
-  }
-
   /**
    * Consumes messages from the specified queue based on the communication pattern.
    * 
@@ -197,17 +203,17 @@ export class TargetedMQ {
     let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
 
     switch (this.type) {
-    case "Point-to-Point": {
-      await this.channel.assertQueue(queue);
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
-      break;
-    }
-
-    case "Request-Reply": {
-      await this.channel.assertQueue(queue);
-      this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
-      break;
-    }
+      case "Point-to-Point": {
+        await this.channel.assertQueue(queue, cfg.queue_options);
+        this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.consume_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);
+        break;
+      }
     }
   }
 }

package/src/sfr-pipeline.mts

@@ -205,7 +205,7 @@ export class SFRPipeline {
         for (let [name, handler] of valid_handlers) {
           const dir = `${base_dir}${namespace}/${name}`;
           const validator = validators[name];
-          const validator_type = typeof validator !== "function" ? "joi" : "multer"; // TODO: Dynamically update parameter content based on validator type.
+          //const validator_type = typeof validator !== "function" ? "joi" : "multer"; // TODO: Dynamically update parameter content based on validator type.
 
           let validator_fn = function (msg: ConsumeMessage) {
             const error = template(validator, msg.content);
@@ -231,34 +231,18 @@ export class SFRPipeline {
           /* bind validators */
           if (mq instanceof TargetedMQ) {
             mq.consume(dir, {
-              options: handler.options,
+              consume_options: handler.consume_options,
+              queue_options : handler.queue_options,
               fn: validator_fn
             })
           }
 
           if (mq instanceof BroadcastMQ) {
-            switch (pattern) {
-              case "Publish-Subscribe": {
-                mq.subscribe(dir, handler.key, {
-                  options: handler.options,
-                  fn: validator_fn
-                })
-              } break;
-
-              case "Routing": {
-                mq.subscribe(dir, handler.key, {
-                  options: handler.options,
-                  fn: validator_fn
-                });
-              }
-
-              case "Topic": {
-                mq.subscribe(dir, handler.key, {
-                  options: handler.options,
-                  fn : validator_fn
-                });
-              }
-            }
+            mq.subscribe(dir, handler.key, {
+              queue_options : handler.queue_options,
+              consume_options: handler.consume_options,
+              fn : validator_fn
+            });
           }
 
           this.mount_data.mq++;

package/src/types/index.d.ts

@@ -20,6 +20,7 @@ declare type Socket = import("socket.io").Socket;
 declare type BroadcastMQ = import("../mq.mts").BroadcastMQ;
 declare type TargetedMQ = import("../mq.mts").TargetedMQ;
 
+
 declare enum PROTOCOLS {
   REST = "REST",
   WS = "WS",
@@ -279,10 +280,12 @@ declare type ParserCFG = {
 
 declare type Channel = import("amqplib").Channel;
 declare type ConsumeMessage = import("amqplib").ConsumeMessage;
+declare type QueueOptions   = import("amqplib").Options.AssertQueue;
 declare type ConsumeOptions = import("amqplib").Options.Consume;
 
 declare type ConsumerConfig = {
-  options?: ConsumeOptions;
+  queue_options : QueueOptions;
+  consume_options?: ConsumeOptions;
   fn: ((msg: ConsumeMessage) => void);
 } & ThisType<ConsumerContext>;
 declare type ConsumerContext = {
@@ -338,9 +341,9 @@ declare type TopicHandlerMap = {
 }
 
 declare type MQConsumeOptions = {
-  options?: ConsumeOptions;
+  queue_options : QueueOptions;
+  consume_options?: ConsumeOptions;
   key? : string;
-  queue?: string[];
   fn: MQRequestHandler;
 }