@avtechno/sfr 1.0.13 → 1.0.15

package/dist/example.mjs

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,84 @@
+/// <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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,239 @@
+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;
+    }
+}
+/**
+ * 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;
+            }
+        }
+    }
+    /**
+     * 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);
+    }
+    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

@@ -0,0 +1,454 @@
+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"];
+const DEBUG_FLAG = Boolean(process.env.DEBUG_SFR);
+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);
+        if (DEBUG_FLAG)
+            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];
+        const WS = protocols[1];
+        const MQ = protocols[2];
+        if (DEBUG_FLAG) {
+            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 };
+    }
+    // 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}`;
+                    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."});
+                                    }
+                                    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;
+                        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 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);
+                                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

@@ -0,0 +1,47 @@
+//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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,7 @@
+/// <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

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

package/dist/types/mq.d.mts

@@ -0,0 +1,114 @@
+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);
+}
+/**
+ * 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>;
+    /**
+     * 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>;
+    set_options(options: Options.AssertQueue): void;
+}

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,25 @@
+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 }));
+};

package/package.json

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

package/src/sfr-pipeline.mts

@@ -11,6 +11,8 @@ const CWD = process.cwd();
 const PATTERNS: CommunicationPattern[] = ["Point-to-Point", "Request-Reply", "Fanout", "Direct", "Topic"];
 const TARGETED_PATTERN = ["Point-to-Point", "Request-Reply"];
 
+const DEBUG_FLAG = Boolean(process.env.DEBUG_SFR);
+
 export class SFRPipeline {
   base_url: string;
   pattern_channels: PatternMQSet;
@@ -32,7 +34,7 @@ export class SFRPipeline {
     },
   }
 
-  constructor(private cfg: ParserCFG, private oas_cfg: OASConfig, private comms: SFRProtocols, private debug? : boolean) { }
+  constructor(private cfg: ParserCFG, private oas_cfg: OASConfig, private comms: SFRProtocols) { }
 
   async init(base_url?: string): Promise<ServiceDocuments> {
     this.base_url = base_url;
@@ -66,7 +68,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);
 
-    if(this.debug)this.print_to_console();
+    if(DEBUG_FLAG)this.print_to_console();
 
     return this.spec_generation(protocols);
   }
@@ -96,7 +98,7 @@ export class SFRPipeline {
     const WS: WSNamespaceDeclaration = protocols[1];
     const MQ: MQNamespaceDeclaration = protocols[2];
     
-    if(this.debug){
+    if(DEBUG_FLAG){
       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`)

package/src/types/index.d.ts

@@ -280,12 +280,16 @@ declare type ParserCFG = {
 
 declare type Channel = import("amqplib").Channel;
 declare type ConsumeMessage = import("amqplib").ConsumeMessage;
+declare type Message = import("amqplib").Message;
 declare type QueueOptions   = import("amqplib").Options.AssertQueue;
 declare type ConsumeOptions = import("amqplib").Options.Consume;
 
+declare type ParsedMessage = {
+  content : object
+} | Message
 declare type ConsumerConfig = {
   options?: ConsumeOptions;
-  fn: ((msg: ConsumeMessage) => void);
+  fn: ((msg: ParsedMessage) => void);
 } & ThisType<ConsumerContext>;
 declare type ConsumerContext = {
   name: string;
@@ -354,7 +358,7 @@ declare type TopicOptions = MQConsumeOptions & {
 }
 
 
-declare type MQRequestHandler = (msg: (ConsumeMessage & { content: any }) | null) => void;
+declare type MQRequestHandler = (msg:ParsedMessage) => void;
 
 
 declare type MQRequestCtx = {