npm - @triophore/falconjs - Versions diffs - 1.0.0 - Mend

@triophore/falconjs 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

package/FalconAuthPlugin.js +473 -0
package/LICENSE +21 -0
package/README.md +2 -0
package/core/auth.js +200 -0
package/core/cache/redis_cacher.js +7 -0
package/core/check_collection.js +9 -0
package/core/crypto/encrypt_decrypt.js +19 -0
package/core/errors.js +48 -0
package/core/logger/log4js.js +89 -0
package/core/logo.js +3 -0
package/core/mongo/generateModelfromJsonFile.js +128 -0
package/core/mongo/mongoSchmeFromJson.js +90 -0
package/core/parse_num.js +8 -0
package/core/rannum.js +33 -0
package/core/ranstring.js +33 -0
package/core/recursive-require-call.js +121 -0
package/core/uitls/mongoose_to_joi.js +72 -0
package/core/uitls/return.js +7 -0
package/falcon.js +1644 -0
package/falconAuthPlugin.js +17 -0
package/falconBaseService.js +532 -0
package/falconBaseWorker.js +540 -0
package/index.js +4 -0
package/out/Falcon.html +777 -0
package/out/falcon.js.html +525 -0
package/out/fonts/OpenSans-Bold-webfont.eot +0 -0
package/out/fonts/OpenSans-Bold-webfont.svg +1830 -0
package/out/fonts/OpenSans-Bold-webfont.woff +0 -0
package/out/fonts/OpenSans-BoldItalic-webfont.eot +0 -0
package/out/fonts/OpenSans-BoldItalic-webfont.svg +1830 -0
package/out/fonts/OpenSans-BoldItalic-webfont.woff +0 -0
package/out/fonts/OpenSans-Italic-webfont.eot +0 -0
package/out/fonts/OpenSans-Italic-webfont.svg +1830 -0
package/out/fonts/OpenSans-Italic-webfont.woff +0 -0
package/out/fonts/OpenSans-Light-webfont.eot +0 -0
package/out/fonts/OpenSans-Light-webfont.svg +1831 -0
package/out/fonts/OpenSans-Light-webfont.woff +0 -0
package/out/fonts/OpenSans-LightItalic-webfont.eot +0 -0
package/out/fonts/OpenSans-LightItalic-webfont.svg +1835 -0
package/out/fonts/OpenSans-LightItalic-webfont.woff +0 -0
package/out/fonts/OpenSans-Regular-webfont.eot +0 -0
package/out/fonts/OpenSans-Regular-webfont.svg +1831 -0
package/out/fonts/OpenSans-Regular-webfont.woff +0 -0
package/out/index.html +65 -0
package/out/scripts/linenumber.js +25 -0
package/out/scripts/prettify/Apache-License-2.0.txt +202 -0
package/out/scripts/prettify/lang-css.js +2 -0
package/out/scripts/prettify/prettify.js +28 -0
package/out/styles/jsdoc-default.css +358 -0
package/out/styles/prettify-jsdoc.css +111 -0
package/out/styles/prettify-tomorrow.css +132 -0
package/package.json +106 -0
package/settings.js +1 -0

package/out/falcon.js.html ADDED Viewed

@@ -0,0 +1,525 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>JSDoc: Source: falcon.js</title>
+    <script src="scripts/prettify/prettify.js"> </script>
+    <script src="scripts/prettify/lang-css.js"> </script>
+    <!--[if lt IE 9]>
+      <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
+    <![endif]-->
+    <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
+    <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
+</head>
+<body>
+<div id="main">
+    <h1 class="page-title">Source: falcon.js</h1>
+    <section>
+        <article>
+            <pre class="prettyprint source linenums"><code>require("dotenv").config({ quiet: true, debug: false });
+const config = process.env;
+const crypto = require("crypto");
+const mongoose = require("mongoose");
+const bcrypt = require("bcrypt");
+// const mongoosePaginate = require('mongoose-paginate-v2');
+const Hapi = require("@hapi/hapi");
+const Blipp = require("blipp");
+const Inert = require("@hapi/inert");
+const path = require("path");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const Crumb = require("@hapi/crumb");
+const JWT = require("jsonwebtoken");
+const { v4: uuidv4 } = require("uuid");
+const { Server } = require("socket.io");
+const redis = require("redis");
+const axios = require("axios");
+const spawn = require("child_process").spawn;
+const customParser = require("socket.io-msgpack-parser");
+const encrypt = require("./core/crypto/encrypt_decrypt").encrypt;
+const decrypt = require("./core/crypto/encrypt_decrypt").decrypt;
+const mqtt = require("mqtt");
+const logger = require("./core/logger/log4js").getlogger();
+const Scooter = require("@hapi/scooter");
+const { createServer } = require("node:http");
+const logo = require("./core/logo").logo;
+/**
+ * Represents a Falcon Server.
+ * @constructor
+ */
+class Falcon {
+  // #models = {}
+  constructor() {
+    //check if settings files in the directory
+    if (!fs.existsSync(path.join(__dirname, "settings.js"))) {
+      throw "Settings file not found !";
+    }
+    this.SETTINGS = require("./settings.js").settings;
+    this.db = null;
+    this.redis_client = null;
+    this.http_server = null;
+    this._socket_io_config = {};
+    this.models = {};
+    this.CONTEXT = {};
+    this.CONTEXT["models"] = {};
+    this.CONTEXT["env"] = config;
+    this.CONTEXT["services"] = [];
+    this.CONTEXT["workers"] = {};
+    this.aedes = require("aedes")();
+    this.mqtt_client = false;
+    this.mqtt_server = require("net").createServer(this.aedes.handle);
+    this.mqtt_port = process.env.MQTT_PORT;
+    this.mqtt_server.listen(this.mqtt_port, function () {
+      logger.info("MQTT server started and listening on port ", this.mqtt_port);
+    });
+    this.CONTEXT["mqtt"] = this.mqtt_server;
+    this.CONTEXT["settings"] = this.SETTINGS;
+    this.CONTEXT["logger"] = logger;
+    this.config = config;
+  }
+  #isDev() {
+    return process.env.MODE == "DEV" ? true : false;
+  }
+  async #Prep() {
+    logger.info(
+      "......................................................................",
+    );
+    logger.info("TRIOPHORE SERVER");
+    logger.info("Developed and maintained by");
+    logger.info(logo);
+    logger.info("Triophore");
+    logger.info("visit us on : https://triophore.com");
+    logger.info(
+      "......................................................................",
+    );
+    logger.info(
+      "......................................................................",
+    );
+    logger.info("Starting server");
+    logger.info("Date :: " + Date.now());
+    logger.info(
+      "......................................................................",
+    );
+    logger.info("");
+    logger.info(
+      "......................................................................",
+    );
+    logger.info("Starting bind for services");
+    logger.info("Date :: " + Date.now());
+    logger.info("Binding complete");
+    logger.info(
+      "......................................................................",
+    );
+    logger.info("");
+    logger.info("MQTT Service details");
+    logger.info("launching worker process....");
+  }
+  /**
+   * starts the initializing process
+   * @returns context
+   */
+  async init() {
+    await this.#Prep();
+    await this.#startService();
+    await this.#startMongoDB();
+    await this.#startRedis();
+    // this.CONTEXT["return"] = require("./core/uitls/return").return_obj;
+    await this.#loadModels();
+    await this.#startHttpServer();
+    await this.#startMqttClient();
+    await this.#startSocketIO();
+    await this.#Postinit();
+    return this;
+  }
+  async #startService() {
+    if (this.SETTINGS.hasOwnProperty("services")) {
+      if (this.SETTINGS.services.length > 0) {
+        logger.info("-----------------Spawning Services----------------");
+        logger.info(
+          "......................................................................",
+        );
+        this.#services(this.SETTINGS.services);
+        logger.info(
+          "......................................................................",
+        );
+        logger.info("-----------------Spawning Services----------------");
+      } else {
+        logger.info("-----------------Spawning Services----------------");
+        logger.info(
+          "......................................................................",
+        );
+        logger.info("No worker registered..");
+        logger.info(
+          "......................................................................",
+        );
+        logger.info("-----------------Spawning Services----------------");
+      }
+    }
+  }
+  async #Postinit() {
+    if (this.SETTINGS.postInit) {
+      var post_file_path = path.join(
+        __dirname,
+        "init",
+        this.SETTINGS.postInit + ".js",
+      );
+      if (fs.existsSync(post_file_path)) {
+        await require(post_file_path).run(this.CONTEXT);
+      }
+    }
+  }
+  async #startMongoDB() {
+    if (this.#isDev()) {
+      mongoose.set("debug", true);
+      logger.debug("Mongoose ODM is set in Debug Mode");
+      logger.info("Mongoose Log will be collected");
+    }
+    await mongoose.connect(config.MONGODB_URL, {}); //useNewUrlParser: true, useUnifiedTopology: true
+    mongoose.set("debug", (collectionName, method, query, doc) => {
+      logger.info(
+        `MONGOOSE ==> ${collectionName}.${method}`,
+        JSON.stringify(query),
+        doc,
+      );
+    });
+    this.db = mongoose.connection.db;
+    logger.info("MongoDB connected");
+    this.CONTEXT["db"] = this.db;
+    this.CONTEXT["mongoose"] = mongoose;
+  }
+  async #startRedis() {
+    if (this.config.REDIS_ENABLE === "true") {
+      logger.info("Redis enabled!");
+      this.redis_client = await redis
+        .createClient({
+          url: this.config.REDIS_URL,
+        })
+        .on("error", (err) => logger.error(`Error connecting to Redis ${err}`))
+        .on("ready", () =>
+          logger.info(`Connected to Redis ${config.REDIS_URL}`),
+        )
+        .connect();
+      this.CONTEXT["redis"] = this.redis_client;
+    } else {
+      logger.warn("Redis disabled");
+      this.CONTEXT["redis"] = false;
+    }
+  }
+  /**
+   *
+   * @param {*} route for connecting
+   * @returns context
+   */
+  async addRoute(route) {
+    await this.http_server.route(route);
+    return this;
+  }
+  async #loadModels() {
+    /*MODELS*/
+    logger.info("-----------------Registering Model----------------");
+    for (let mindex = 0; mindex &lt; this.SETTINGS.models.length; mindex++) {
+      const model = this.SETTINGS.models[mindex];
+      await this.#load_model_name(model);
+    }
+    logger.info("-----------------Registering Model----------------");
+    /*MODELS*/
+    // this.CONTEXT["models"] = models;
+  }
+  async #startHttpServer() {
+    //creating server object
+    this.http_server = null;
+    this.http_server = Hapi.server({
+      port: process.env.HTTP_PORT,
+      host: process.env.HTTP_HOST,
+      routes: {
+        cors: true,
+      },
+    });
+    this.http_server.events.on("log", (event, tags) => {
+      logger.error(
+        `Server error: ${event.error ? event.error.message : "unknown"} -- ${tags}`,
+      );
+    });
+    this.http_server.events.on("request", (request, event, tags) => {
+      logger.info(`Server request: ${request}  ${event}`);
+    });
+    await this.http_server.register({
+      plugin: Blipp,
+      options: { showAuth: true },
+    });
+    await this.registerAuth();
+    await this.http_server.register(Scooter);
+    logger.info(await this.http_server.plugins.blipp.info());
+    if (this.#isDev()) {
+      logger.info("-----------------DEV MODE----------------");
+      logger.info("-----------------DEV MODE----------------");
+      logger.info("-----------------DEV MODE----------------");
+    }
+    this.CONTEXT["server"] = this.http_server;
+    /* ROUTES */
+    for (let rindex = 0; rindex &lt; this.SETTINGS.routes.length; rindex++) {
+      const route = this.SETTINGS.routes[rindex];
+      await require("./routes/" + route).route(this.CONTEXT);
+    }
+    this.http_server.events.on("response", function (request) {
+      logger.info(
+        request.info.remoteAddress +
+        ": " +
+        request.method.toUpperCase() +
+        " " +
+        request.path +
+        " --> " +
+        request.response.statusCode,
+      );
+    });
+    logger.info("-----------------Registered Routes----------------");
+    await this.http_server
+      .table()
+      .forEach((route) => logger.info(`${route.method}\t${route.path}`));
+    logger.info("-----------------Registered Routes----------------");
+  }
+   /**
+   * Starts the server
+   */
+  async runServer() {
+    await this.CONTEXT["server"].start();
+  }
+  async #startSocketIO() {
+    var io = new Server(this.http_server.listener, _socket_io_config);
+  }
+  async #startMqttClient() {
+    this.mqtt_client = mqtt.connect(`${config.MQTT_URL}`);
+    this.CONTEXT["mqtt_client"] = this.mqtt_client;
+    this.mqtt_client.on("connect", () => {
+      this.mqtt_client.subscribe("service_utils", (err) => {
+        logger.info("mqtt connected and subscribed to utility service");
+      });
+      this.mqtt_client.subscribe("websocket_broadcast", (err) => {
+        logger.info("mqtt connected and subscribed to utility service");
+      });
+    });
+  }
+   /**
+   *
+   * Get Socket IO middle ware
+   * @returns context
+   */
+  registerSocketIOMiddleware() {
+    return this;
+  }
+   /**
+   * Override this function to handle your own auth
+   */
+  async registerAuth() {
+    await this.http_server.register(require("hapi-auth-jwt2"));
+    this.http_server.auth.strategy("jwt", "jwt", {
+      key: config.JWT_SECRET, // Never Share your secret key
+      validate: this.#validate, // validate function defined above
+    });
+    this.http_server.auth.default("jwt");
+    return this;
+  }
+  async #validate(decoded, request, h) {
+    await this.validateAuth(decoded, request, h, this.CONTEXT)
+  }
+   /**
+    * Handler for auth validation
+   */
+  async validateAuth(decoded, request, h, context) {
+    logger.info("jwt_validate");
+    logger.info(request.path);
+    logger.info(decoded);
+    logger.info("jwt_validate");
+    if (decoded == null || decoded == undefined) {
+      return { isValid: false };
+    } else {
+      //JSON.parse(decrypt(decoded))
+      // return { isValid: true  };
+      if (decoded.hasOwnProperty("token") &amp;&amp; decoded.hasOwnProperty("uid")) {
+        if (decoded.uid &amp;&amp; decoded.token) {
+          try {
+            var _temp = false;
+            var jwt_cache = await CONTEXT["redis"].get(
+              "login_" + decoded.token,
+            );
+            logger.info(`Redis data from cache ${jwt_cache}`);
+            if (jwt_cache) {
+              _temp = JSON.parse(jwt_cache);
+            } else {
+              _temp_db = await CONTEXT["models"]["user"].findById(
+                decoded.token,
+              );
+              if (_temp_db) {
+                await CONTEXT["redis"].set(
+                  "login_" + decoded.token,
+                  JSON.stringify(_temp_db),
+                  { EX: 60 },
+                );
+              }
+              _temp = _temp_db;
+            }
+            if (_temp) {
+              return { isValid: true, credentials: _temp };
+            } else {
+              return { isValid: false };
+            }
+          } catch (error) {
+            return { isValid: false };
+          }
+        } else {
+          return { isValid: false };
+        }
+      } else {
+        return { isValid: false };
+      }
+    }
+  }
+  // --- LOADER FUNCTION --- //
+  async #load_model_name(name) {
+    var _temp = await require("./models/" + name)(mongoose);
+    this.models[name] = _temp;
+    this.CONTEXT["models"][name] = _temp;
+    logger.info(name + "  model registered");
+  }
+  async #load_route_name(name, server) {
+    await require("./routes/" + name).route(server, models, logger);
+    logger.info(name + "  route registered");
+  }
+  // --- LOADER FUNCTION --- //
+  #workers() {
+    this.CONTEXT.startWorker = async function (worker_name, args = {}) {
+      if (this.CONTEXT.workers.hasOwnProperty(worker_name)) {
+        const service_file = `./workers/${this.CONTEXT.workers[worker_name]}.js`;
+        const args_json = JSON.stringify(args);
+        const buffer = Buffer.from(jsonString, "utf8");
+        const base64String = buffer.toString("base64");
+        var service_worker = spawn('node', [service_file, base64String], { env: { ...process.env } });
+        service_worker.stdout.setEncoding('utf8');
+        service_worker.stderr.setEncoding('utf8');
+        logger.info("Settings EMAIL Worker")
+        service_worker.stdout.on('data', function (data) {
+            logger.info("-------EMAIL WORKER-------")
+            logger.info(data)
+            logger.info("-------EMAIL WORKER-------")
+        });
+        service_worker.stderr.on('data', function (data) {
+            logger.error("-------EMAIL WORKER ERROR-------")
+            logger.error(data)
+            logger.error("-------EMAIL WORKER ERROR-------")
+        });
+        service_worker.on('close', function (code) {
+            logger.info("-------EMAIL WORKER CLOSED-------")
+            logger.info(code)
+            logger.info("-------EMAIL WORKER CLOSED-------")
+        });
+      } else {
+      }
+    };
+  }
+  #services(filesToRun) {
+    filesToRun.forEach((file) => {
+      const spawnOptions = {
+        stdio: ["pipe", "pipe", "pipe"], // Pipe stdout and stderr to our custom logging function
+        env: { ...process.env, LOG4JS_LOGGER_LEVEL: "DEBUG" }, // Set the Log4js logger level for each process
+      };
+      const s_path = path.join(__dirname, "services", file + ".js");
+      console.log(s_path);
+      // Spawn a new process using childProcess.spawn()
+      const cprocess = spawn("node", [s_path], spawnOptions);
+      // Pipe stdout and stderr to our custom logging function
+      // process.stdout.pipe(process.stdout);
+      // process.stderr.pipe(process.stderr);
+      cprocess.stdout.on("data", (data) => {
+        logger.info(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+        logger.info(data.toString());
+        logger.info(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+      });
+      cprocess.stderr.on("data", (data) => {
+        logger.error(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+        logger.error(data.toString());
+        logger.error(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+      });
+      this.CONTEXT["services"].push({
+        pid: cprocess.pid,
+        stdout: cprocess.stdout,
+        stderr: cprocess.stderr,
+      });
+    });
+  }
+}
+module.exports = Falcon;
+</code></pre>
+        </article>
+    </section>
+</div>
+<nav>
+    <h2><a href="index.html">Home</a></h2><h3>Classes</h3><ul><li><a href="Falcon.html">Falcon</a></li></ul>
+</nav>
+<br class="clear">
+<footer>
+    Documentation generated by <a href="https://github.com/jsdoc/jsdoc">JSDoc 4.0.5</a> on Sun Oct 19 2025 12:00:49 GMT+0530 (India Standard Time)
+</footer>
+<script> prettyPrint(); </script>
+<script src="scripts/linenumber.js"> </script>
+</body>
+</html>

package/out/fonts/OpenSans-Bold-webfont.eot ADDED Viewed

Binary file