@avtechno/sfr 1.0.11 → 1.0.13

package/package.json

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

package/src/mq.mts

@@ -45,22 +45,7 @@ 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);
-  }
 }
 
 /**
@@ -221,7 +206,22 @@ export class TargetedMQ extends BaseMQ{
     }
   }
 
-  
+  /**
+   * 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);
+  }
   set_options(options : Options.AssertQueue){
     this.queue_options = options;
   }

package/src/sfr-pipeline.mts

@@ -32,7 +32,7 @@ export class SFRPipeline {
     },
   }
 
-  constructor(private cfg: ParserCFG, private oas_cfg: OASConfig, private comms: SFRProtocols) { }
+  constructor(private cfg: ParserCFG, private oas_cfg: OASConfig, private comms: SFRProtocols, private debug? : boolean) { }
 
   async init(base_url?: string): Promise<ServiceDocuments> {
     this.base_url = base_url;
@@ -66,7 +66,7 @@ export class SFRPipeline {
     protocols = Object.fromEntries(Object.entries(protocols).filter(([k])=> this.comms[k]).map(([k, v])=> [k, v]));
     await this.fn_binding(protocols);
 
-    this.print_to_console();
+    if(this.debug)this.print_to_console();
 
     return this.spec_generation(protocols);
   }
@@ -93,11 +93,14 @@ export class SFRPipeline {
     //Import SFRs
     const protocols = await Promise.all(sfr_paths.map((protocol) => import_sfrs(protocol)));
     const REST: RESTNamespaceDeclaration = protocols[0];
-    logger.info(`${Object.keys(protocols[0]).length} REST SFR`)
     const WS: WSNamespaceDeclaration = protocols[1];
-    logger.info(`${Object.keys(protocols[1]).length} WS SFR`)
     const MQ: MQNamespaceDeclaration = protocols[2];
-    logger.info(`${Object.keys(protocols[2]).length} MQ SFR`)
+    
+    if(this.debug){
+      logger.info(`${Object.keys(protocols[0]).length} REST SFR`)
+      logger.info(`${Object.keys(protocols[1]).length} WS SFR`)
+      logger.info(`${Object.keys(protocols[2]).length} MQ SFR`)
+    }
 
     return { REST, WS, MQ } as NamespaceDeclaration;
   }
@@ -137,7 +140,7 @@ export class SFRPipeline {
       Object.entries(handlers).forEach(([method, handler_map]) => {
         for (const [name, handler] of Object.entries(handler_map).filter(([k]) => validators[k])) {
           const dir = `${base_dir}/${namespace}/${name}`;
-          console.log(dir)
+          
           const validator = validators[name];
           const validator_type = typeof validator !== "function" ? "joi" : "multer";
 
@@ -146,13 +149,16 @@ export class SFRPipeline {
             case "joi": {
               comms[method.toLowerCase() as RESTRequestType](dir, (req, res, next) => {
                 let error: string | boolean = true;
-
+                
                 if (is_public) {
                   //if(!req.session.user)return res.status(401).json({error : "Session not found."});
                 }
-
-                error = template(validator, method === "GET" ? req.query : req.body);
-                if (error) return res.status(400).json({ error });
+                
+                const validator_keys = Object.keys(validator);
+                if(validator_keys.length){
+                  error = template(validator, method === "GET" ? req.query : req.body);
+                  if (error) return res.status(400).json({ error });
+                }
                 next();
               });
             } break;
@@ -207,25 +213,28 @@ export class SFRPipeline {
           //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);
-
-            if (error) {
-              if (mq instanceof TargetedMQ) {
-                if (error) {
-                  switch (pattern) {
-                    case "Request-Reply": mq.reply(msg, { error }); break;
-                    default: mq.channel.reject(msg, false);
+            const validator_keys = Object.keys(validator);
+
+            if(validator_keys.length){
+              const error = template(validator, msg.content);
+              
+              if (error) {
+                if (mq instanceof TargetedMQ) {
+                  if (error) {
+                    switch (pattern) {
+                      case "Request-Reply": mq.reply(msg, { error }); break;
+                      default: mq.channel.reject(msg, false);
+                    }
                   }
                 }
-              }
 
-              if (mq instanceof BroadcastMQ) {
-                mq.channel.reject(msg, false);
-              }
+                if (mq instanceof BroadcastMQ)mq.channel.reject(msg, false);
 
-              return; //Return immediately to avoid executing handler fn (which may contain reply or ack calls.)
+                return; //Return immediately to avoid executing handler fn (which may contain reply or ack calls.)
+              }
             }
 
+
             handler.fn(msg);
           }
 

package/dist/example.mjs

@@ -1,33 +0,0 @@
-import Joi from "joi";
-import { REST } from "./templates.mjs";
-export default REST({
-    cfg: {
-        base_dir: "example",
-        public: false,
-    },
-    validators: {
-        "get-something": {
-            "name": Joi.string().required(),
-            "age": Joi.number().required(),
-        }
-    },
-    handlers: {
-        GET: {
-            "get-something": {
-                description: "Get something I guess?",
-                async fn(req, res) {
-                    const result = await this.db_call();
-                    res.status(200).json({
-                        data: result
-                    });
-                }
-            }
-        }
-    },
-    controllers: {
-        async db_call() {
-            /* Perform database calls here through accessing the "this" context (if injections are set) */
-            return "Something";
-        }
-    }
-});

package/dist/index.mjs

@@ -1,84 +0,0 @@
-/// <reference path="types/index.d.ts" />
-import yaml from "js-yaml";
-import path from "path";
-import fs from "fs/promises";
-import { REST, WS, MQ } from "./templates.mjs";
-import { SFRPipeline } from "./sfr-pipeline.mjs";
-import { MQLib, BroadcastMQ, TargetedMQ } from "./mq.mjs";
-const cwd = process.cwd();
-export default async (cfg, oas_cfg, connectors, base_url) => {
-    //TODO: Verify connectors
-    const sfr = new SFRPipeline(cfg, oas_cfg, connectors);
-    // Returned service artifacts for both OpenAPI and AsyncAPI are written into the server directory
-    // An express static endpoint is pointed to this directory for service directory.
-    const documents = await sfr.init(base_url);
-    write_service_discovery(cfg, documents); //Writes services to output dir (cfg.out)
-    return {
-        ...oas_cfg,
-        documents
-    };
-};
-async function write_service_discovery(cfg, documents) {
-    //Setup files in case they do not exist.
-    //Setup output folder
-    await fs.mkdir(path.join(cwd, cfg.out), { recursive: true });
-    // Loop over each protocol
-    for (let [protocol, documentation] of Object.entries(documents)) {
-        //Strictly await for setup to create dirs for each protocol.
-        await fs.mkdir(path.join(cwd, cfg.out, protocol.toLowerCase()), { recursive: true });
-        //Convert documentation into service manifest.
-        //OpenAPI Documents  : paths
-        //AsyncAPI Documents : channels
-        switch (protocol) {
-            case "REST":
-                {
-                    documentation = documentation;
-                    for (const [path, methods] of Object.entries(documentation.paths)) {
-                        write_to_file(cfg, `rest/${path}`, methods);
-                    }
-                }
-                break;
-            case "WS":
-                {
-                }
-                break;
-            case "MQ": {
-                documentation = documentation;
-                write_to_file(cfg, "mq/index.yaml", documentation);
-            }
-        }
-    }
-}
-//Tasked with recursively creating directories and spec files.
-async function write_to_file(cfg, dir, data) {
-    //Path is a slash(/) delimited string, with the end delimiter indicating the filename to be used.
-    const paths = dir.split("/");
-    //Indicates a root file
-    if (paths.length === 1) {
-        await fs.writeFile(path.join(cwd, cfg.out, paths[0]), yaml.dump(data), { flag: "w+" });
-    }
-    else { //Indicates a nested file
-        const file = paths.pop(); //Pops the path array to be used for dir creation
-        await fs.mkdir(path.join(cwd, cfg.out, ...paths), { recursive: true });
-        fs.writeFile(path.join(cwd, cfg.out, ...paths, `${file}.yml`), yaml.dump(data), { flag: "w+" });
-    }
-}
-function inject(injections) {
-    SFRPipeline.injections.rest.handlers = {
-        ...SFRPipeline.injections.rest.handlers,
-        ...injections.handlers
-    };
-    SFRPipeline.injections.rest.controllers = {
-        ...SFRPipeline.injections.rest.controllers,
-        ...injections.controllers
-    };
-    SFRPipeline.injections.mq.handlers = {
-        ...SFRPipeline.injections.mq.handlers,
-        ...injections.handlers
-    };
-    SFRPipeline.injections.mq.controllers = {
-        ...SFRPipeline.injections.mq.controllers,
-        ...injections.controllers
-    };
-}
-export { REST, WS, MQ, MQLib, BroadcastMQ, TargetedMQ, inject };

package/dist/logger.mjs

@@ -1,37 +0,0 @@
-import winston from 'winston';
-// Define log levels
-const levels = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    http: 3,
-    verbose: 4,
-    debug: 5,
-    silly: 6,
-};
-// Define colors for each level
-const colors = {
-    error: 'red',
-    warn: 'yellow',
-    info: 'green',
-    http: 'magenta',
-    verbose: 'cyan',
-    debug: 'blue',
-    silly: 'gray',
-};
-// Add colors to Winston
-winston.addColors(colors);
-// Define the format for logs
-const format = winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }), winston.format.colorize({ all: true }), winston.format.printf((info) => `${info.timestamp} ${info.level}: ${info.message}${info.metadata ? ` ${JSON.stringify(info.metadata)}` : ''}`));
-// Create the Winston logger
-const logger = winston.createLogger({
-    level: process.env.NODE_ENV === 'development' && Boolean(process.env.DEBUG_SFR) ? 'debug' : 'info',
-    levels,
-    format,
-    transports: [
-        // Console transport
-        new winston.transports.Console(),
-    ],
-});
-// Export the logger
-export { logger };

package/dist/mq.mjs

@@ -1,239 +0,0 @@
-import { connect } from "amqplib";
-/**
- * MQLib class for establishing a connection to the message queue and creating channels.
- */
-export class MQLib {
-    connection;
-    channel;
-    /**
-     * Initializes the connection and channel to the message queue.
-     *
-     * @param MQ_URL - The URL of the message queue.
-     * @example
-     * const mqLib = new MQLib();
-     * await mqLib.init("amqp://localhost");
-     */
-    async init(MQ_URL) {
-        await connect(MQ_URL)
-            .then(async (v) => {
-            //@ts-ignore
-            this.connection = v;
-            this.channel = await v.createChannel();
-        });
-    }
-    /**
-     * Returns the connection object.
-     *
-     * @returns The connection object to the message queue.
-     */
-    get_connection() {
-        return this.connection;
-    }
-    /**
-     * Returns the channel object.
-     *
-     * @returns The channel object to the message queue.
-     */
-    get_channel() {
-        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: Fanout, Direct, and Topic.
- */
-export class BroadcastMQ extends BaseMQ {
-    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.
-     *
-     * @param exchange - The name of the exchange to send the message to.
-     * @param key - The routing key or pattern to use, depending on the communication pattern.
-     * @param payload - The message to be sent.
-     * @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, "Direct");
-     * mq.publish("logsExchange", "error", { level: "error", message: "Something went wrong" });
-     */
-    async publish(exchange, key = "", payload, options) {
-        switch (this.type) {
-            case "Fanout": {
-                await this.channel.assertExchange(exchange, "fanout", this.exchange_options);
-                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", this.exchange_options);
-                this.channel.publish(exchange, key, encode_payload(payload), options);
-                break;
-            }
-        }
-    }
-    /**
-     * Subscribes to an exchange to receive messages based on the communication pattern.
-     *
-     * @param exchange - The name of the exchange to subscribe to.
-     * @param key - The routing key or pattern to listen for.
-     * @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 Direct pattern.
-     * const mq = new BroadcastMQ(channel, "Direct");
-     * mq.subscribe("logsExchange", "error", { fn: handleErrorLogs, options: { noAck: true } });
-     */
-    async subscribe(exchange, key, cfg) {
-        let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
-        switch (this.type) {
-            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.options);
-                break;
-            }
-            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)), cfg.options);
-                break;
-            }
-            case "Topic": {
-                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)), cfg.options);
-                break;
-            }
-        }
-    }
-    set_options(options) {
-        this.exchange_options = options;
-    }
-}
-/**
- * TargetedMQ class to handle Point-to-Point and Request-Reply communication patterns.
- */
-export class TargetedMQ extends BaseMQ {
-    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.
-     *
-     * @param binding - The name of the queue or binding to send the message to.
-     * @param payload - The message to be sent.
-     * @param options - Additional publishing options.
-     * @example
-     * // Send a message to a queue for point-to-point communication
-     * const mq = new TargetedMQ(channel, "Point-to-Point");
-     * mq.produce("taskQueue", { taskId: 1, action: "process" });
-     */
-    async produce(binding, payload, options) {
-        /* Alter produce strategy depending on the instance's configured comm pattern */
-        switch (this.type) {
-            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, this.queue_options);
-                return this.channel.sendToQueue(binding, encode_payload(payload), options);
-            }
-        }
-    }
-    /**
-     * Consumes messages from the specified queue based on the communication pattern.
-     *
-     * @param queue - The name of the queue to consume messages from.
-     * @param cfg - Configuration options for the consumer, including the callback function.
-     * @example
-     * // Consume a message from the 'taskQueue' in a Point-to-Point communication pattern
-     * const mq = new TargetedMQ(channel, "Point-to-Point");
-     * mq.consume("taskQueue", { fn: processTask, options: { noAck: true } });
-     */
-    async consume(queue, cfg) {
-        let fn = cfg.fn.bind({ channel: this.channel, type: this.type });
-        switch (this.type) {
-            case "Point-to-Point": {
-                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, this.queue_options);
-                this.channel.consume(queue, (v) => fn(parse_payload(v)), cfg.options);
-                break;
-            }
-        }
-    }
-    set_options(options) {
-        this.queue_options = options;
-    }
-}
-/* Helper Functions */
-/**
- * Parses the payload of a message.
- *
- * @param msg - The consumed message.
- * @returns The parsed message content.
- */
-function parse_payload(msg) {
-    if (!msg)
-        return {};
-    return { ...msg, content: JSON.parse(msg.content.toString()) };
-}
-/**
- * Encodes a message as a Buffer to be sent over the message queue.
- *
- * @param msg - The message to be encoded.
- * @returns The encoded message as a Buffer.
- */
-function encode_payload(msg) {
-    return Buffer.from(JSON.stringify(msg));
-}

package/dist/sfr-pipeline.mjs

@@ -1,446 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { template } from "./util.mjs";
-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", "Fanout", "Direct", "Topic"];
-const TARGETED_PATTERN = ["Point-to-Point", "Request-Reply"];
-export class SFRPipeline {
-    cfg;
-    oas_cfg;
-    comms;
-    base_url;
-    pattern_channels;
-    mount_data = {
-        rest: 0,
-        ws: 0,
-        mq: 0
-    };
-    /* Contains values that are injected into each protocol's handlers. */
-    static injections = {
-        rest: {
-            handlers: {},
-            controllers: {}
-        },
-        mq: {
-            handlers: {},
-            controllers: {}
-        },
-    };
-    constructor(cfg, oas_cfg, comms) {
-        this.cfg = cfg;
-        this.oas_cfg = oas_cfg;
-        this.comms = comms;
-    }
-    async init(base_url) {
-        this.base_url = base_url;
-        if (this.comms["MQ"]) {
-            //Create channels for each type of Communication Pattern
-            const channels = await Promise.all(PATTERNS.map(async (v) => {
-                const mq = TARGETED_PATTERN.includes(v) ? new TargetedMQ(this.comms["MQ"], v) : new BroadcastMQ(this.comms["MQ"], v);
-                return [v, mq];
-            }));
-            this.pattern_channels = Object.fromEntries(channels);
-            SFRPipeline.injections.rest.handlers = {
-                ...SFRPipeline.injections.rest.handlers,
-                mq: this.pattern_channels
-            };
-            SFRPipeline.injections.mq.handlers = {
-                ...SFRPipeline.injections.mq.handlers,
-                mq: this.pattern_channels
-            };
-        }
-        //Declarations for each protocol in key/value pairs.
-        let protocols = await this.file_parsing();
-        //Filter protocols that have been parsed if its' associated SFRProtocol has been defined
-        /* @ts-ignore */
-        protocols = Object.fromEntries(Object.entries(protocols).filter(([k]) => this.comms[k]).map(([k, v]) => [k, v]));
-        await this.fn_binding(protocols);
-        this.print_to_console();
-        return this.spec_generation(protocols);
-    }
-    // Handles the parsing of SFR files from the directory specified under cfg.out config.
-    // It returns a standard NamespaceDeclaration containing each declaration of each supported protocol.
-    async file_parsing() {
-        //These are the officially supported protocols of the SFR library
-        const SUPPORTED_PROTOCOLS = ["rest", "ws", "mq"];
-        /*
-          Look for folders that match the supported protocols listed above in the designated directory
-      
-          cfg.root = "Specifies the working directory"
-          cfg.path = "Specifies the API directory i.e: where SFR files reside"
-          cfg.out  = "Specifies the directory where the resulting OAS documents are outputted"
-        */
-        const directory = path.join(CWD, this.cfg.root);
-        let paths = SUPPORTED_PROTOCOLS.map((v) => path.join(directory, `${this.cfg.path}/${v}`));
-        //Create the directories if it doesn't exist.
-        await Promise.all(paths.map((v) => fs.mkdir(v, { recursive: true })));
-        //Recursively retrieve all SFRs of each protocol
-        let sfr_paths = await Promise.all(paths.map((path) => resolve_sfrs(path)));
-        //Import SFRs
-        const protocols = await Promise.all(sfr_paths.map((protocol) => import_sfrs(protocol)));
-        const REST = protocols[0];
-        logger.info(`${Object.keys(protocols[0]).length} REST SFR`);
-        const WS = protocols[1];
-        logger.info(`${Object.keys(protocols[1]).length} WS SFR`);
-        const MQ = protocols[2];
-        logger.info(`${Object.keys(protocols[2]).length} MQ SFR`);
-        return { REST, WS, MQ };
-    }
-    // Handles the binding of the components of each SFR (e.g: executing validators of matching endpoints, injecting controllers to each handler, etc.)
-    //Owing to their differing nature, spec generation and fn_binding is handled this way so as to split up the individual logics involved in parsing them. 
-    async fn_binding(protocols) {
-        Object.entries(protocols).forEach(([protocol, declaration]) => {
-            switch (protocol) {
-                case "REST":
-                    this.bind_rest_fns(declaration);
-                    break;
-                case "WS":
-                    this.bind_ws_fns(declaration);
-                    break;
-                case "MQ":
-                    this.bind_mq_fns(declaration);
-                    break;
-            }
-        });
-    }
-    /* Fn Binding */
-    async bind_rest_fns(declaration) {
-        const comms = this.comms["REST"];
-        if (!comms)
-            throw new Error(`FN Binding failed: \nREST protocol lacks it's associated SFRProtocols`);
-        Object.entries(declaration).forEach(([namespace, module]) => {
-            let { cfg, validators, handlers } = module.content;
-            //Set base_directory
-            /*
-              Directory Order:
-              this.base_url -> Folder Structure -> cfg.base_dir
-            */
-            let base_dir = "";
-            if (this.base_url)
-                base_dir = `/${this.base_url}`;
-            if (module.dir)
-                base_dir += `/${module.dir.toString().replaceAll(",", "/")}`;
-            if (cfg.base_dir)
-                base_dir += `/${cfg.base_dir}`;
-            logger.info(`[SFR ${module.name}] resolved path: ${base_dir}/${namespace}`);
-            const is_public = Boolean(cfg.public);
-            //Loop over all methods and their respective handlers
-            Object.entries(handlers).forEach(([method, handler_map]) => {
-                for (const [name, handler] of Object.entries(handler_map).filter(([k]) => validators[k])) {
-                    const dir = `${base_dir}/${namespace}/${name}`;
-                    console.log(dir);
-                    const validator = validators[name];
-                    const validator_type = typeof validator !== "function" ? "joi" : "multer";
-                    /* bind validators */
-                    switch (validator_type) {
-                        case "joi":
-                            {
-                                comms[method.toLowerCase()](dir, (req, res, next) => {
-                                    let error = true;
-                                    if (is_public) {
-                                        //if(!req.session.user)return res.status(401).json({error : "Session not found."});
-                                    }
-                                    error = template(validator, method === "GET" ? req.query : req.body);
-                                    if (error)
-                                        return res.status(400).json({ error });
-                                    next();
-                                });
-                            }
-                            break;
-                        case "multer":
-                            {
-                                comms[method.toLowerCase()](dir, validator);
-                                /* @ts-ignore */
-                                comms.use((err, req, res, next) => {
-                                    let temp = { error: err.message, details: err.cause };
-                                    if (err)
-                                        return res.status(400).json(temp);
-                                    next();
-                                });
-                            }
-                            break;
-                    }
-                    /* Bind to express app */
-                    comms[method.toLowerCase()](dir, handler.fn);
-                    this.mount_data.rest++;
-                }
-            });
-        });
-    }
-    async bind_ws_fns(declaration) {
-    }
-    async bind_mq_fns(declaration) {
-        const comms = this.comms["MQ"];
-        if (!comms)
-            throw new Error(`FN Binding failed: \nMQ protocol lacks it's associated SFRProtocols`);
-        Object.entries(declaration).forEach(([namespace, module]) => {
-            let { cfg, validators, handlers } = module.content;
-            //Set base_directory
-            let base_dir = cfg.base_dir ? `/${cfg.base_dir}` : "";
-            if (this.base_url)
-                base_dir = `/${this.base_url}/${base_dir}`;
-            if (module.dir)
-                base_dir = `${module.dir.toString().replaceAll(",", "/")}/${base_dir}`;
-            const is_public = Boolean(cfg.public);
-            //Loop over all methods and their respective handlers
-            Object.entries(handlers).forEach(([pattern, handler_map]) => {
-                //Get associated MQ for pattern
-                let mq = this.pattern_channels[pattern];
-                //Get all valid handlers (i.e: those with matching validators)
-                const valid_handlers = Object.entries(handler_map).filter(([k]) => validators[k]);
-                //Loop over each handler
-                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.
-                    let validator_fn = function (msg) {
-                        const error = template(validator, msg.content);
-                        if (error) {
-                            if (mq instanceof TargetedMQ) {
-                                if (error) {
-                                    switch (pattern) {
-                                        case "Request-Reply":
-                                            mq.reply(msg, { error });
-                                            break;
-                                        default: mq.channel.reject(msg, false);
-                                    }
-                                }
-                            }
-                            if (mq instanceof BroadcastMQ) {
-                                mq.channel.reject(msg, false);
-                            }
-                            return; //Return immediately to avoid executing handler fn (which may contain reply or ack calls.)
-                        }
-                        handler.fn(msg);
-                    };
-                    /* bind validators */
-                    if (mq instanceof TargetedMQ) {
-                        mq.consume(dir, {
-                            options: handler.options,
-                            fn: validator_fn
-                        });
-                    }
-                    if (mq instanceof BroadcastMQ) {
-                        mq.subscribe(dir, handler.key, {
-                            options: handler.options,
-                            fn: validator_fn
-                        });
-                    }
-                    this.mount_data.mq++;
-                }
-            });
-        });
-    }
-    // Generate OpenAPI and AsyncAPI specification.
-    spec_generation(protocols) {
-        // Holds the key/value pair of protocols and their respective API Documentation
-        const documents = Object.entries(protocols).map(([protocol, declaration]) => {
-            switch (protocol) {
-                case "REST": return [protocol, this.generate_open_api_document(declaration)];
-                case "WS": return [protocol, this.generate_async_api_document(declaration)];
-                case "MQ": return [protocol, this.generate_async_api_document(declaration)];
-                default: throw new Error(`Failed to generate SFR Spec: ${protocol} protocol is unknown.`);
-            }
-        });
-        return Object.fromEntries(documents);
-    }
-    generate_open_api_document(declaration) {
-        // This will hold the final OpenAPI Document.
-        const spec = {
-            openapi: "3.0.0",
-            info: Object.assign({}, this.oas_cfg),
-            paths: {}
-        };
-        // Iterate through each protocol (e.g., REST, WS, MQ)
-        Object.entries(declaration).forEach(([namespace, module]) => {
-            const { cfg, handlers, validators } = module.content;
-            //Set base_directory
-            let base_dir = cfg.base_dir ? `/${cfg.base_dir}/` : "/";
-            if (this.base_url)
-                base_dir = `/${this.base_url}${base_dir}`;
-            if (module.dir)
-                base_dir = `${module.dir.toString().replaceAll(",", "/")}/${base_dir}`;
-            // Collect the OpenAPI path object for each handler (method)
-            for (let [method, handler_map] of Object.entries(handlers)) {
-                //Transform method to lowercase
-                method = method.toLowerCase();
-                // Define the operation (method) for this endpoint
-                for (const [endpoint, body] of Object.entries(handler_map)) {
-                    const validator = validators[endpoint];
-                    // Skip if no matching validator
-                    if (!validator)
-                        continue;
-                    const validator_type = typeof validator !== "function" ? "joi" : "multer";
-                    //Default tags are used for service and router level classification (developer platform)
-                    let default_tags = [
-                        `sfr-router:${namespace}`,
-                        `sfr-service:${this.oas_cfg.title || "unspecified"}`
-                    ];
-                    if (body.tags && Array.isArray(body.tags))
-                        default_tags.push(...body.tags);
-                    const operation_id = `${base_dir}${namespace}/${endpoint}`;
-                    const document = {
-                        operationId: `${method.toUpperCase()}:${operation_id}`,
-                        summary: body.summary || "",
-                        description: body.description || "",
-                        tags: default_tags,
-                        public: Boolean(cfg.public),
-                        responses: {
-                            "200": {
-                                description: "Successful operation",
-                                content: { "application/json": { schema: { type: "object" } } }
-                            },
-                            "400": {
-                                description: "An error has occured",
-                                content: { "application/json": { schema: { type: "object" } } }
-                            }
-                        }
-                    };
-                    //Insert either a parameter or a requestBody according to the method type
-                    if (validator_type === "joi") {
-                        document[method === "GET" ? "parameters" : "requestBody"] = j2s(validator).swagger;
-                    }
-                    //Haven't found a library for converting multer validators to swagger doc
-                    if (validator_type === "multer") {
-                    }
-                    //Create path if it does not exist.
-                    if (!spec.paths[operation_id])
-                        spec.paths[operation_id] = {};
-                    if (!spec.paths[operation_id][method.toLowerCase()])
-                        spec.paths[operation_id][method.toLowerCase()] = document;
-                }
-            }
-        });
-        //Conform to OAPI standards by appending "x-property" on each field under "meta"
-        /* @ts-ignore */
-        spec.info.meta = Object.fromEntries(Object.entries(spec.info.meta).map(([k, v]) => [`x-${k}`, v]));
-        return spec;
-    }
-    // Method to generate an AsyncAPI document from an MQNamespaceDeclaration
-    generate_async_api_document(declaration) {
-        // This will hold the final AsyncAPI Document.
-        const spec = {
-            asyncapi: '3.0.0',
-            info: Object.assign({}, this.oas_cfg),
-            channels: {},
-            operations: {},
-            components: {
-                messages: {},
-            },
-        };
-        //Conform to OAPI standards by appending "x-property" on each field under "meta"
-        /* @ts-ignore */
-        spec.info.meta = Object.fromEntries(Object.entries(spec.info.meta).map(([k, v]) => [`x-${k}`, v]));
-        Object.entries(declaration).forEach(([namespace, module]) => {
-            let { cfg, validators, handlers } = module.content;
-            //Set base_directory
-            let base_dir = cfg.base_dir ? `/${cfg.base_dir}/` : "";
-            if (this.base_url)
-                base_dir = `/${this.base_url}/${base_dir}`;
-            if (module.dir)
-                base_dir = `${module.dir.toString().replaceAll(",", "/")}/${base_dir}`;
-            const is_public = Boolean(cfg.public);
-            //Loop over all methods and their respective handlers
-            Object.entries(handlers).forEach(([pattern, handler_map]) => {
-                //Get associated MQ for pattern
-                let mq = this.pattern_channels[pattern];
-                //Get all valid handlers (i.e: those with matching validators)
-                const valid_handlers = Object.entries(handler_map).filter(([k]) => validators[k]);
-                //Loop over each handler
-                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 channel_document = {
-                        address: dir,
-                        messages: {}
-                    };
-                    const operation_document = {
-                        action: "receive",
-                        summary: handler.summary || "",
-                        description: handler.description || "",
-                        channel: `#/channels/${name}`
-                    };
-                    //Insert either a parameter or a requestBody according to the method type
-                    if (validator_type === "joi") {
-                        channel_document.messages[`${name}-message`] = {
-                            name: `${name}-message`,
-                            payload: j2s(validator).swagger
-                        };
-                    }
-                    //Haven't found a library for converting multer validators to swagger doc
-                    if (validator_type === "multer") {
-                    }
-                    spec.channels[name] = channel_document;
-                    spec.operations[name] = operation_document;
-                }
-            });
-        });
-        return spec;
-    }
-    // Method to print SFR info to console
-    print_to_console() {
-        console.log(`____________________________
-|                          | Mounted  
-| ░██████╗███████╗██████╗░ | REST : ${this.mount_data.rest}  
-| ██╔════╝██╔════╝██╔══██╗ | WS   : ${this.mount_data.ws}  
-| ╚█████╗░█████╗░░██████╔╝ | MQ   : ${this.mount_data.mq}  
-| ░╚═══██╗██╔══╝░░██╔══██╗ |-----------
-| ██████╔╝██║░░░░░██║░░██║ | Protocols 
-| ╚═════╝░╚═╝░░░░░╚═╝░░╚═╝ | REST : ${this.comms["REST"] ? "✅" : "❌"} 
-| Single File Router       | MQ   : ${this.comms["MQ"] ? "✅" : "❌"} 
-|                          | WS   : ${this.comms["WS"] ? "✅" : "❌"} 
-¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯`);
-    }
-}
-/* Utility fns */
-/* File Parsing */
-async function resolve_sfrs(dir, prefix) {
-    //Get Directory Contents
-    const contents = await fs.readdir(dir);
-    const results = [];
-    //Loop over contents
-    await Promise.all(contents.map(async (v) => {
-        const content_path = path.join(dir, v);
-        const is_dir = (await fs.lstat(content_path)).isDirectory();
-        //If Directory, perform a recursion and return output of contents.map fn.
-        if (is_dir) {
-            const dir_output = await resolve_sfrs(content_path, prefix ? `${prefix}/${v}` : v);
-            results.push(dir_output);
-            return;
-        }
-        ;
-        let output = { name: v, path: content_path };
-        if (prefix)
-            output.dir = prefix.split("/");
-        results.push(output);
-    }));
-    return results.flat();
-}
-async function import_sfrs(protocol_files) {
-    const protocols = await Promise.all(protocol_files.map(async (v) => {
-        const import_task = await import(`file:///${v.path}`);
-        return [v.name.replace(".mjs", ""), {
-                ...v,
-                content: import_task.default
-            }];
-    }));
-    //Removes SFRs without body.
-    return Object.fromEntries(protocols.filter((v) => v[1].content));
-}
-// Method to generate JSON schema for the payload based on handler metadata
-function generate_json_schema(metadata) {
-    return {
-        type: 'object',
-        properties: {
-            example_field: {
-                type: 'string',
-                ...metadata
-            },
-        },
-        required: ['example_field'],
-    };
-}

package/dist/templates.mjs

@@ -1,47 +0,0 @@
-//Previous Name: RequestHandlerFactory
-//Dependencies are imported and used by the functions below
-import { SFRPipeline } from "./sfr-pipeline.mjs";
-export function REST(struct) {
-    const validators = struct.validators || {};
-    const controllers = struct.controllers || {};
-    const handlers = struct.handlers || {};
-    const cfg = struct.cfg || {};
-    //Bind controller injections to each controllers
-    Object.entries(controllers).map(([k, v]) => controllers[k] = v.bind({ ...SFRPipeline.injections.rest.controllers }));
-    //Bind handler injections and SFR controllers into each handlers.
-    Object.entries(handlers).forEach(([method, handlermap]) => {
-        Object.entries(handlermap).forEach(([k, v]) => {
-            /* @ts-ignore */
-            handlers[method][k] = { ...v, fn: v.fn.bind({ ...controllers, ...SFRPipeline.injections.rest.handlers }) };
-        });
-    });
-    /* @ts-ignore */
-    return { validators, controllers, handlers, cfg };
-}
-export function WS(struct) {
-    const validators = struct.validators || {};
-    const controllers = struct.controllers || {};
-    const handlers = struct.handlers || {};
-    const cfg = struct.cfg || {};
-    //Dependency injection happens here...npm
-    return { validators, controllers, handlers, cfg };
-}
-export function MQ(struct) {
-    const validators = struct.validators || {};
-    const controllers = struct.controllers || {};
-    const handlers = struct.handlers || {};
-    const cfg = struct.cfg || {};
-    //Bind controller injections to each controllers
-    Object.entries(controllers).map(([k, v]) => controllers[k] = v.bind({ ...SFRPipeline.injections.mq.controllers }));
-    //Bind handler injections and SFR controllers into each handlers.
-    Object.entries(handlers).forEach(([pattern, handlermap]) => {
-        Object.entries(handlermap).forEach(([k, v]) => {
-            /* @ts-ignore */
-            const { mq } = (SFRPipeline.injections.mq.handlers || {});
-            /* @ts-ignore */
-            handlers[pattern][k] = { ...v, fn: v.fn.bind({ ...controllers, mq: mq ? mq[pattern] : null }) };
-        });
-    });
-    /* @ts-ignore */
-    return { validators, controllers, handlers, cfg };
-}

package/dist/types/example.d.mts

@@ -1,11 +0,0 @@
-declare const _default: {
-    GET: {
-        "get-something": {
-            description: string;
-            fn(req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>): Promise<void>;
-        };
-    };
-} & {
-    db_call(): Promise<string>;
-};
-export default _default;

package/dist/types/index.d.mts

@@ -1,7 +0,0 @@
-/// <reference path="../../src/types/index.d.ts" />
-import { REST, WS, MQ } from "./templates.mjs";
-import { MQLib, BroadcastMQ, TargetedMQ } from "./mq.mjs";
-declare const _default: (cfg: ParserCFG, oas_cfg: OASConfig, connectors: SFRProtocols, base_url?: string) => Promise<ServiceManifest>;
-export default _default;
-declare function inject(injections: InjectedFacilities): void;
-export { REST, WS, MQ, MQLib, BroadcastMQ, TargetedMQ, inject };

package/dist/types/logger.d.mts

@@ -1,3 +0,0 @@
-import winston from 'winston';
-declare const logger: winston.Logger;
-export { logger };

package/dist/types/mq.d.mts

@@ -1,114 +0,0 @@
-import { ChannelModel, Options, Channel, ConsumeMessage } from "amqplib";
-/**
- * MQLib class for establishing a connection to the message queue and creating channels.
- */
-export declare class MQLib {
-    private connection?;
-    private channel?;
-    /**
-     * Initializes the connection and channel to the message queue.
-     *
-     * @param MQ_URL - The URL of the message queue.
-     * @example
-     * const mqLib = new MQLib();
-     * await mqLib.init("amqp://localhost");
-     */
-    init(MQ_URL: string): Promise<void>;
-    /**
-     * Returns the connection object.
-     *
-     * @returns The connection object to the message queue.
-     */
-    get_connection(): ChannelModel;
-    /**
-     * Returns the channel object.
-     *
-     * @returns The channel object to the message queue.
-     */
-    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: Fanout, Direct, and Topic.
- */
-export declare class BroadcastMQ extends BaseMQ {
-    channel: Channel;
-    protected 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.
-     *
-     * @param exchange - The name of the exchange to send the message to.
-     * @param key - The routing key or pattern to use, depending on the communication pattern.
-     * @param payload - The message to be sent.
-     * @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, "Direct");
-     * mq.publish("logsExchange", "error", { level: "error", message: "Something went wrong" });
-     */
-    publish(exchange: string, key: string, payload: any, options?: Options.Publish): Promise<void>;
-    /**
-     * Subscribes to an exchange to receive messages based on the communication pattern.
-     *
-     * @param exchange - The name of the exchange to subscribe to.
-     * @param key - The routing key or pattern to listen for.
-     * @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 Direct pattern.
-     * const mq = new BroadcastMQ(channel, "Direct");
-     * mq.subscribe("logsExchange", "error", { fn: handleErrorLogs, options: { noAck: true } });
-     */
-    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.
- */
-export declare class TargetedMQ extends BaseMQ {
-    channel: Channel;
-    protected 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.
-     *
-     * @param binding - The name of the queue or binding to send the message to.
-     * @param payload - The message to be sent.
-     * @param options - Additional publishing options.
-     * @example
-     * // Send a message to a queue for point-to-point communication
-     * const mq = new TargetedMQ(channel, "Point-to-Point");
-     * mq.produce("taskQueue", { taskId: 1, action: "process" });
-     */
-    produce(binding: string, payload: any, options?: Options.Publish): Promise<boolean>;
-    /**
-     * Consumes messages from the specified queue based on the communication pattern.
-     *
-     * @param queue - The name of the queue to consume messages from.
-     * @param cfg - Configuration options for the consumer, including the callback function.
-     * @example
-     * // Consume a message from the 'taskQueue' in a Point-to-Point communication pattern
-     * const mq = new TargetedMQ(channel, "Point-to-Point");
-     * mq.consume("taskQueue", { fn: processTask, options: { noAck: true } });
-     */
-    consume(queue: string, cfg: ConsumerConfig): Promise<void>;
-    set_options(options: Options.AssertQueue): void;
-}

package/dist/types/sfr-pipeline.d.mts

@@ -1,33 +0,0 @@
-export declare class SFRPipeline {
-    private cfg;
-    private oas_cfg;
-    private comms;
-    base_url: string;
-    pattern_channels: PatternMQSet;
-    mount_data: {
-        rest: number;
-        ws: number;
-        mq: number;
-    };
-    static injections: {
-        rest: {
-            handlers: {};
-            controllers: {};
-        };
-        mq: {
-            handlers: {};
-            controllers: {};
-        };
-    };
-    constructor(cfg: ParserCFG, oas_cfg: OASConfig, comms: SFRProtocols);
-    init(base_url?: string): Promise<ServiceDocuments>;
-    private file_parsing;
-    private fn_binding;
-    private bind_rest_fns;
-    private bind_ws_fns;
-    private bind_mq_fns;
-    private spec_generation;
-    private generate_open_api_document;
-    private generate_async_api_document;
-    private print_to_console;
-}

package/dist/types/templates.d.mts

@@ -1,8 +0,0 @@
-export declare function REST<V, H, C>(struct: RESTHandlerDescriptor<V, H, C>): H & C;
-export declare function WS<V, H, C>(struct: WSHandlerDescriptor<V, H, C>): {
-    validators: RequestValidators;
-    controllers: RequestControllers;
-    handlers: WSRequestHandlers;
-    cfg: SFRConfig;
-};
-export declare function MQ<V, H, C>(struct: MQHandlerDescriptor<V, H, C>): H & C;

package/dist/types/util.d.mts

@@ -1,7 +0,0 @@
-import { Response } from "express";
-import Joi from "joi";
-export declare function get_stats(dirs: string[], base_dir: string): Promise<string[]>;
-export declare function assess_namespace(stats: string[], dir: string): Promise<any>;
-export declare const template: (rule: object, v: object) => string | false;
-export declare const object_id: Joi.StringSchema<string>;
-export declare const handle_res: (controller: Promise<any>, res: Response) => void;

package/dist/util.mjs

@@ -1,25 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import Joi from "joi";
-export async function get_stats(dirs, base_dir) {
-    let temp = await Promise.all(dirs.map((v) => fs.lstat(path.join(base_dir, v)).then((stats) => ({ stats, dir: v }))));
-    const result = temp.filter(({ stats }) => stats.isFile()).map((v) => v.dir);
-    return result;
-}
-export async function assess_namespace(stats, dir) {
-    let dirs = stats.map((v) => `file:///${dir.replaceAll("\\", "/")}/${v}`);
-    const result = await Promise.all(dirs.map((d) => import(d).then((v) => [d.replace(".mjs", "").substring(d.lastIndexOf("/") + 1), v.default]))).then(Object.fromEntries);
-    return result;
-}
-export const template = (rule, v) => _validate(Joi.object(rule).validate(v));
-function _validate(expression) {
-    let result = expression.error;
-    return result ? result.details[0].message : false;
-}
-export const object_id = Joi.string().hex().length(24).required();
-/* QoLs */
-export const handle_res = (controller, res) => {
-    controller
-        .then((data) => res.json({ data }))
-        .catch((error) => res.status(400).json({ error }));
-};