@triophore/falconjs 1.0.0

package/falcon.js

@@ -0,0 +1,1644 @@
+require("dotenv").config({ quiet: true, debug: false });
+const config = process.env;
+const crypto = require("crypto");
+const mongoose = require("mongoose");
+const bcrypt = require("bcrypt");
+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 Scooter = require("@hapi/scooter");
+const { createServer } = require("node:http");
+const logo = require("./core/logo").logo;
+const Joi = require("joi");
+const Boom = require("@hapi/boom");
+const { ConfigurationError, ValidationError } = require("./core/errors");
+const { RateLimiterMemory } = require("rate-limiter-flexible");
+const mongooseToJoi = require("./core/uitls/mongoose_to_joi");
+
+/**
+ * Represents the Falcon Server Core.
+ * Handles initialization of Database, Redis, MQTT, Workers, and Hapi.js HTTP Server.
+ *
+ * @class
+ * @example
+ * const app = new Falcon(__dirname);
+ * app.setAuthStrategy(async (server, config) => {
+ * // Custom auth logic
+ * });
+ * await app.init();
+ */
+class Falcon {
+  // #models = {}
+
+  /**
+     * Creates an instance of the Falcon Server.
+     * @constructor
+     * @param {String} basePath - The absolute path to the application root (usually __dirname).
+     * @throws {Error} Will throw an error if the 'settings.js' file is missing in the basePath.
+     */
+  constructor(basePath) {
+    // Validate input
+    if (!basePath || typeof basePath !== 'string') {
+      throw new ValidationError('basePath must be a valid string');
+    }
+
+    // Check if settings file exists
+    const settingsPath = path.join(basePath, "settings.js");
+    if (!fs.existsSync(settingsPath)) {
+      throw new ConfigurationError(`Settings file not found at: ${settingsPath}`);
+    }
+
+    this.SETTINGS = require(settingsPath).settings;
+    this.db = null;
+    this.redisClient = null;
+    this.httpServer = null;
+    this.socketIoConfig = this.SETTINGS || null;
+    this.models = {};
+    this.CONTEXT = {};
+    this.CONTEXT["models"] = {};
+    this.CONTEXT["env"] = config;
+    this.CONTEXT["services"] = [];
+    this.CONTEXT["workers"] = {};
+    this.aedes = null;
+    this.mqttClient = null;
+    this.mqttServer = null;
+    this.mqttPort = null;
+    this.CONTEXT["mqtt"] = null;
+    this.CONTEXT["settings"] = this.SETTINGS;
+
+    if (this.SETTINGS.log) {
+      this.CONTEXT["logger"] = require("./core/logger/log4js").getLogger(
+        this.SETTINGS.log,
+      );
+    }
+
+    this.config = config;
+    this.basePath = basePath;
+    this.CONTEXT["custom"] = {};
+    this.customAuthHandler = null;
+  }
+
+  /**
+   * Adds a custom context to the Falcon instance that can be accessed throughout the application.
+   * The context is stored with special delimiters to avoid naming conflicts.
+   * 
+   * @param {string} customContextName - The name identifier for the custom context
+   * @param {*} customContext - The context data/object to store (can be any type)
+   * @returns {Falcon} The current Falcon instance for method chaining
+   * 
+   * @example
+   * const app = new Falcon(__dirname);
+   * app.addContext('database', { host: 'localhost', port: 5432 });
+   * app.addContext('cache', redisClient);
+   */
+  addContext(customContextName, customContext) {
+    if (!customContextName || typeof customContextName !== 'string') {
+      throw new ValidationError('customContextName must be a non-empty string');
+    }
+    this.CONTEXT["custom"]["$$" + customContextName + "$$"] = customContext;
+    return this;
+  }
+
+  /**
+   * Retrieves a previously stored custom context by name.
+   * Note: This method has a bug - it doesn't return the context value.
+   * 
+   * @param {string} custom_context_name - The name identifier of the context to retrieve
+   * @returns {Falcon} The current Falcon instance (should return the context value)
+   * 
+   * @example
+   * const dbConfig = app.getContext('database');
+   * 
+   * @todo Fix return statement to actually return the context value
+   */
+  getContext(custom_context_name) {
+    return this.CONTEXT["custom"]["$$" + custom_context_name + "$$"];
+  }
+
+  /**
+   * Removes a custom context from the Falcon instance if it exists.
+   * 
+   * @param {string} custom_context_name - The name identifier of the context to remove
+   * @returns {Falcon} The current Falcon instance for method chaining
+   * 
+   * @example
+   * app.removeContext('database');
+   */
+  removeContext(custom_context_name) {
+    if (
+      this.CONTEXT["custom"].hasOwnProperty("$$" + custom_context_name + "$$")
+    ) {
+      delete this.CONTEXT["custom"]["$$" + custom_context_name + "$$"];
+    }
+    return this;
+  }
+
+  /**
+   * Validates environment variables using Joi schema.
+   * Ensures required environment variables are present and have valid values.
+   * 
+   * @private
+   * @throws {Error} Throws error if environment validation fails
+   */
+  async #validateEnv() {
+    const schema = Joi.object({
+      MODE: Joi.string().valid('DEV', 'PROD').default('DEV'),
+      MQTT_PORT: Joi.number().optional(),
+      MQTT_URL: Joi.string().optional(),
+      REDIS_ENABLE: Joi.string().valid('true', 'false').default('false'),
+      REDIS_URL: Joi.string().when('REDIS_ENABLE', { is: 'true', then: Joi.required() })
+    }).unknown();
+
+    const { error, value } = schema.validate(process.env);
+    if (error) {
+      throw new Error(`Config validation error: ${error.message}`);
+    }
+    this.config = value; // Update config with defaults
+    this.CONTEXT["env"] = this.config;
+
+    if (!process.env.MODE) {
+      this.CONTEXT["logger"]?.warn("MODE not set in env, defaulting to PROD");
+    }
+  }
+
+  #isDev() {
+    return process.env.MODE == "DEV" ? true : false;
+  }
+
+  async #mqtt_aedes() {
+    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 () {
+      this.CONTEXT["logger"].info(
+        "MQTT server started and listening on port ",
+        this.mqtt_port,
+      );
+    });
+    this.CONTEXT["mqtt"] = this.mqtt_server;
+  }
+  async #mqtt_external() {
+    this.CONTEXT["mqtt"] = null;
+  }
+
+  async #mqtt() {
+    if (this.SETTINGS.mqtt) {
+      if (this.SETTINGS.mqtt.internal) {
+        await this.#mqtt_aedes();
+      } else {
+        if (this.SETTINGS.mqtt.external) {
+          await this.#mqtt_external();
+        } else {
+          await this.#mqtt_aedes();
+        }
+      }
+    } else {
+      await this.#mqtt_aedes();
+    }
+  }
+
+  async #Prep() {
+    this.CONTEXT["logger"].info("");
+    this.CONTEXT["logger"].info("");
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info("TRIOPHORE SERVER");
+    this.CONTEXT["logger"].info("Developed and maintained by");
+    this.CONTEXT["logger"].info(logo);
+    this.CONTEXT["logger"].info("Triophore");
+    this.CONTEXT["logger"].info("visit us on : https://triophore.com");
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info("Starting server");
+    this.CONTEXT["logger"].info("Date :: " + Date.now());
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info("");
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info("Starting bind for services");
+    this.CONTEXT["logger"].info("Date :: " + Date.now());
+    this.CONTEXT["logger"].info("Binding complete");
+    this.CONTEXT["logger"].info(
+      "......................................................................",
+    );
+    this.CONTEXT["logger"].info("");
+    this.CONTEXT["logger"].info("MQTT Service details");
+    this.CONTEXT["logger"].info("launching worker process....");
+  }
+
+  /**
+   * Initializes the Falcon server with all configured components.
+   * This method sets up graceful shutdown handlers, database connections, Redis, 
+   * models, HTTP server, MQTT client, Socket.IO, and runs post-initialization hooks.
+   * 
+   * @async
+   * @returns {Promise<Falcon>} The current Falcon instance after successful initialization
+   * @throws {Error} Throws error if any initialization step fails
+   * 
+   * @example
+   * const app = new Falcon(__dirname);
+   * await app.init();
+   * await app.runServer();
+   */
+  async init() {
+    await this.#validateEnv();
+    this.setupGracefulShutdown();
+    await this.#Prep();
+    await this.#startService();
+    await this.#startServiceDB();
+    await this.#startRedis();
+    // this.CONTEXT["return"] = require("./core/uitls/return").return_obj;
+    await this.#loadModels();
+    await this.#startHttpServer();
+    await this.#loadRoutes();
+    await this.#startMqttClient();
+    await this.#startSocketIO();
+    await this.#generateSwaggerSchemas(); // Generate schemas before routes
+    await this.#startCrudRoutes(); // Added CRUD generation
+
+    await this.#Postinit();
+
+    // Final immutable context
+    const deepFreeze = (obj) => {
+      if (typeof obj !== "object" || obj === null) return obj;
+      Object.freeze(obj);
+      Object.keys(obj).forEach(key => {
+        const value = obj[key];
+        if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+          deepFreeze(value);
+        }
+      });
+      return obj;
+    };
+
+    // Deep freeze the most critical parts
+    const immutableModels = deepFreeze({ ...this.CONTEXT.models });
+    const immutableValidators = deepFreeze({ ...this.CONTEXT.validators });
+
+    // Create final frozen context
+    this.CONTEXT = Object.freeze({
+      ...this.CONTEXT,
+      models: immutableModels,
+      validators: immutableValidators,
+      // Allow custom to remain mutable (for flexibility)
+      custom: this.CONTEXT.custom || {},
+    });
+
+    this.CONTEXT.logger.info("Falcon ready — CONTEXT is now immutable and protected!");
+    return this;
+  }
+
+  async #startService() {
+    if (this.SETTINGS.hasOwnProperty("services")) {
+      if (this.SETTINGS.services.length > 0) {
+        this.CONTEXT["logger"].info(
+          "-----------------Spawning Services----------------",
+        );
+        this.CONTEXT["logger"].info(
+          "......................................................................",
+        );
+        this._spawnServices(this.SETTINGS.services);
+        this.CONTEXT["logger"].info(
+          "......................................................................",
+        );
+        this.CONTEXT["logger"].info(
+          "-----------------Spawning Services----------------",
+        );
+      } else {
+        this.CONTEXT["logger"].info(
+          "-----------------Spawning Services----------------",
+        );
+        this.CONTEXT["logger"].info(
+          "......................................................................",
+        );
+        this.CONTEXT["logger"].info("No services registered..");
+        this.CONTEXT["logger"].info(
+          "......................................................................",
+        );
+        this.CONTEXT["logger"].info(
+          "-----------------Spawning Services----------------",
+        );
+      }
+    }
+  }
+
+  async #Postinit() {
+    if (this.SETTINGS.postInit) {
+      let post_file_path = path.join(
+        this.basePath,
+        "init",
+        this.SETTINGS.postInit + ".js",
+      );
+      if (fs.existsSync(post_file_path)) {
+        await require(post_file_path).run(this.CONTEXT);
+      }
+    }
+  }
+
+  async #startServiceDB() {
+    if (this.SETTINGS.database) {
+      if (this.SETTINGS.database.mongodb) {
+        if (this.#isDev()) {
+          mongoose.set("debug", true);
+          this.CONTEXT["logger"].debug("Mongoose ODM is set in Debug Mode");
+          this.CONTEXT["logger"].info("Mongoose Log will be collected");
+        }
+        await mongoose.connect(this.SETTINGS.database.mongodb.database, {}); //useNewUrlParser: true, useUnifiedTopology: true
+        mongoose.set("debug", (collectionName, method, query, doc) => {
+          this.CONTEXT["logger"].info(
+            `MONGOOSE ==> ${collectionName}.${method}`,
+            JSON.stringify(query),
+            doc,
+          );
+        });
+        this.db = mongoose.connection.db;
+        this.CONTEXT["logger"].info("MongoDB connected");
+        this.CONTEXT["db"] = this.db;
+        this.CONTEXT["mongoose"] = mongoose;
+      }
+    }
+  }
+
+  /**
+   * Registers a plugin with the Falcon server. Plugins can extend server functionality
+   * for different components like server middleware, Socket.IO handlers, or Mongoose plugins.
+   * 
+   * @async
+   * @param {Object} pluginObj - The plugin configuration object
+   * @param {string} pluginObj.type - Plugin type: 'server', 'socketio', 'mongoose', or 'falcon'
+   * @param {*} pluginObj.plugin - The actual plugin implementation
+   * @returns {Promise<Falcon>} The current Falcon instance for method chaining
+   * @throws {Error} Throws error if plugin type is invalid
+   * 
+   * @example
+   * await app.AddPlugin({
+   *   type: 'server',
+   *   plugin: myHapiPlugin
+   * });
+   */
+  async AddPlugin(pluginObj) {
+    this.CONTEXT["logger"].info("Plugin added");
+    await this.#regsiterPlugin(pluginObj);
+    return this;
+  }
+
+  async #regsiterPlugin(pluginObj) {
+    switch (pluginObj.type) {
+      case "server":
+        // this.middleware.push(pluginObj);
+        break;
+      case "socketio":
+        // this.controllers.push(pluginObj);
+        break;
+      case "mongoose":
+        break;
+      case "falcon":
+        break;
+      default:
+        throw new Error(`Invalid plugin type: ${pluginObj.type}`);
+    }
+  }
+
+  /**
+   * Asynchronously checks if a given path exists and is a directory.
+   * This utility method provides safe directory existence checking with proper error handling.
+   * 
+   * @async
+   * @param {string} directoryPath - The file system path to check
+   * @returns {Promise<boolean>} True if path exists and is a directory, false if path doesn't exist
+   * @throws {Error} Throws error for permission issues or other file system errors (not ENOENT)
+   * 
+   * @example
+   * const exists = await app.checkDirectoryAsync('./models');
+   * if (exists) {
+   *   console.log('Models directory found');
+   * }
+   * 
+   * @example
+   * try {
+   *   const isDir = await app.checkDirectoryAsync('/restricted/path');
+   * } catch (error) {
+   *   console.error('Permission denied or other error:', error.message);
+   * }
+   */
+  async checkDirectoryAsync(directoryPath) {
+    try {
+      // Use fs.promises.stat() to get file statistics
+      const stats = await fs.promises.stat(directoryPath);
+      // Check if the path exists AND if it's a directory
+      return stats.isDirectory();
+    } catch (error) {
+      // Check if the error is "No such file or directory" (ENOENT)
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      // For other errors (permissions, etc.), re-throw the error
+      throw error;
+    }
+  }
+
+  /**
+   * Recursively finds all JavaScript files in a directory.
+   * Skips hidden directories and test files for efficiency.
+   * 
+   * @private
+   * @param {string} dir - Directory to search
+   * @param {string[]} files - Array to collect file paths (used for recursion)
+   * @returns {Promise<string[]>} Array of JavaScript file paths
+   */
+  async #findJsFilesRecursively(dir, files = []) {
+    const items = await fs.promises.readdir(dir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+
+      if (item.isDirectory() && !item.name.startsWith('.')) {
+        await this.#findJsFilesRecursively(fullPath, files);
+      }
+      else if (item.isFile() && item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Builds a clean route path from file system path.
+   * Converts folder structure to REST-style paths with parameter support.
+   * 
+   * @private
+   * @param {string} relativePath - Relative path from routes directory
+   * @returns {string} Clean route path
+   */
+  #buildRoutePath(relativePath) {
+    let routePath = '/' + path.dirname(relativePath)
+      .replace(/\\/g, '/')
+      .replace(/\/index$/gi, '')
+      .replace(/\/_/g, '/:')
+      .replace(/_/g, '-')
+      .replace(/(^|\/)\[([^\]]+)\]/g, '$1:$2');
+
+    const baseName = path.basename(relativePath, '.js');
+    if (baseName !== 'index') {
+      let segment = baseName
+        .replace(/^_/, ':')
+        .replace(/_/g, '-')
+        .replace(/^\[([^\]]+)\]$/, ':$1');
+      routePath = path.posix.join(routePath, segment);
+    }
+
+    return routePath.replace(/\/+$/, '') || '/';
+  }
+
+  /**
+   * Finds the best matching validator for a route.
+   * 
+   * @private
+   * @param {string} baseName - Base filename without extension
+   * @param {string} relativePath - Relative path from routes directory
+   * @param {Object} validators - Available validators
+   * @returns {string|null} Validator name or null if not found
+   */
+  #findBestValidatorName(baseName, relativePath, validators) {
+    const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+    const candidates = [
+      baseName,
+      baseName + 'Payload',
+      path.dirname(relativePath).split(path.sep).pop() + baseName,
+      capitalize(baseName),
+      baseName.replace(/Handler$/i, ''),
+    ];
+    for (const c of candidates) {
+      if (validators[c]) return c;
+    }
+    return null;
+  }
+
+  async #startRedis() {
+    if (this.config.REDIS_ENABLE === "true") {
+      this.CONTEXT["logger"].info("Redis enabled!");
+      this.redis_client = await redis
+        .createClient({
+          url: this.config.REDIS_URL,
+        })
+        .on("error", (err) =>
+          this.CONTEXT["logger"].error(`Error connecting to Redis ${err}`),
+        )
+        .on("ready", () =>
+          this.CONTEXT["logger"].info(`Connected to Redis ${config.REDIS_URL}`),
+        )
+        .connect();
+      this.CONTEXT["redis"] = this.redis_client;
+    } else {
+      this.CONTEXT["logger"].warn("Redis disabled");
+      this.CONTEXT["redis"] = false;
+    }
+  }
+
+  /**
+   * Dynamically adds a route to the Hapi.js server after initialization.
+   * This allows for runtime route registration beyond the initial setup.
+   * 
+   * @async
+   * @param {Object} route - Hapi.js route configuration object
+   * @param {string} route.method - HTTP method (GET, POST, PUT, DELETE, etc.)
+   * @param {string} route.path - Route path with optional parameters
+   * @param {Function} route.handler - Route handler function
+   * @param {Object} [route.options] - Additional route options (auth, validation, etc.)
+   * @returns {Promise<Falcon>} The current Falcon instance for method chaining
+   * 
+   * @example
+   * await app.addRoute({
+   *   method: 'GET',
+   *   path: '/api/health',
+   *   handler: (request, h) => ({ status: 'ok' })
+   * });
+   */
+  async addRoute(route) {
+    await this.httpServer.route(route);
+    return this;
+  }
+
+  /**
+   * Loads routes recursively from the routes directory with automatic validation and Swagger documentation.
+   * Supports nested folder structures and automatic validator matching.
+   * 
+   * @private
+   * @async
+   */
+  async #loadRoutes() {
+    const routesDir = path.join(this.basePath, "routes");
+    const validatorsDir = path.join(this.basePath, "validators");
+
+    if (!fs.existsSync(routesDir)) {
+      this.CONTEXT["logger"]?.info("No routes/ folder — skipping");
+      return;
+    }
+
+    // Load validators (for validation + Swagger schemas)
+    const validators = {};
+    if (fs.existsSync(validatorsDir)) {
+      const files = await this.#findJsFilesRecursively(validatorsDir);
+      for (const file of files) {
+        const name = path.basename(file, '.js');
+        try {
+          const schema = require(file);
+          if (schema && typeof schema.describe === 'function') {
+            validators[name] = schema;
+          }
+        } catch (e) { /* ignore */ }
+      }
+    }
+    this.CONTEXT.validators = validators;
+
+    // Register Swagger first (needs to be before routes)
+    await this.#registerSwagger();
+
+    this.CONTEXT["logger"].info("Loading routes with validation + Swagger docs...");
+
+    const routeFiles = await this.#findJsFilesRecursively(routesDir);
+
+    for (const filePath of routeFiles) {
+      const relativePath = path.relative(routesDir, filePath);
+      const baseName = path.basename(filePath, '.js');
+      let routePath = this.#buildRoutePath(relativePath);
+      this.CONTEXT["logger"].info("Route Name : " + routePath);
+
+      try {
+        const routeModule = require(filePath);
+        const register = typeof routeModule === 'function' ? routeModule : routeModule.route?.bind(routeModule);
+
+        if (typeof register !== 'function') continue;
+
+        // Find validator + extract schema
+        const validatorName = this.#findBestValidatorName(baseName, relativePath, validators);
+        const validator = validatorName ? validators[validatorName] : null;
+
+        // Auto-generate tag from folder
+        const tag = path.dirname(relativePath).split(path.sep)[0] || 'api';
+
+        const wrappedRoute = async (server, ctx) => {
+          // Add auto-generated route info to context
+          ctx.route = {
+            path: routePath,
+            tag: tag,
+            validator: validator,
+            validatorName: validatorName
+          };
+
+          await register(ctx); // Only pass context, server is already in ctx.server
+        };
+
+        await wrappedRoute(this.httpServer, this.CONTEXT);
+
+        const valMark = validator ? 'Validated + Documented' : 'Documented';
+        this.CONTEXT["logger"].info(`${valMark} ${routePath} ← ${relativePath}`);
+      } catch (err) {
+        this.CONTEXT["logger"].error(`Route failed: ${filePath}`, err.message);
+      }
+    }
+
+    this.CONTEXT["logger"].info("API fully documented at /documentation");
+  }
+
+  /**
+   * Registers Swagger UI for API documentation if enabled in settings.
+   * 
+   * @private
+   * @async
+   */
+  async #registerSwagger() {
+    if (!this.SETTINGS.swagger?.enabled) return;
+
+    const Inert = require('@hapi/inert');
+    const Vision = require('@hapi/vision');
+    const HapiSwagger = require('hapi-swagger');
+
+    const swaggerOptions = {
+      info: {
+        title: this.SETTINGS.name || 'Falcon API',
+        version: require(path.join(this.basePath, 'package.json')).version || '1.0.0',
+      },
+      schemes: ['http', 'https'],
+      grouping: 'tags',
+      tags: [
+        { name: 'api', description: 'General API' },
+        { name: 'auth', description: 'Authentication' },
+        { name: 'users', description: 'User operations' },
+      ],
+      documentationPath: this.SETTINGS.swagger.path || '/documentation',
+
+      validatorUrl: null,
+      reuseDefinitions: true,
+    };
+
+    await this.httpServer.register([
+      Inert,
+      Vision,
+      {
+        plugin: HapiSwagger,
+        options: swaggerOptions
+      }
+    ]);
+
+    this.CONTEXT["logger"].info(`Swagger UI → http://localhost:${this.SETTINGS.http.port}${swaggerOptions.documentationPath}`);
+  }
+
+  async #loadModels() {
+    /*MODELS*/
+    if (this.CONTEXT["mongoose"]) {
+      let files = await fsp.readdir(
+        path.join(this.basePath, "models", "mongo"),
+      );
+      const jsFiles = files.filter((file) => path.extname(file) === ".js");
+      this.CONTEXT["logger"].info(
+        "-----------------Registering Model----------------",
+      );
+      for (let i = 0; i < jsFiles.length; i++) {
+        console.log(path.join(this.basePath, "models", "mongo", jsFiles[i]));
+        await this._load_model_name(
+          path.join(this.basePath, "models", "mongo", jsFiles[i]),
+        );
+      }
+      // for (let mindex = 0; mindex < _models.length; mindex++) {
+      //   const model = _models[mindex];
+      //   if (await fsp.exists(path.join(this.basePath, "models", model + ".js"))) {
+      //     await this.#load_model_name(model);
+      //   } else {
+      //     this.CONTEXT["logger"].error("Model file not found :: " + model)
+      //   }
+      // }
+      this.CONTEXT["logger"].info(
+        "-----------------Registering Model----------------",
+      );
+    }
+
+    /*MODELS*/
+    // this.CONTEXT["models"] = models;
+  }
+
+  async #startHttpServer() {
+    //creating server object
+    this.httpServer = null;
+    this.httpServer = Hapi.server({
+      port: this.SETTINGS.http.port,
+      host: this.SETTINGS.http.host,
+      routes: {
+        cors: true,
+      },
+      debug: { request: ['error'] } // Enable better error logging
+    });
+
+    // Set Joi as the validator for the server
+    this.httpServer.validator(Joi);
+    this.httpServer.events.on("log", (event, tags) => {
+      this.CONTEXT["logger"].error(
+        `Server error: ${event.error ? event.error.message : "unknown"} -- ${tags}`,
+      );
+    });
+    this.httpServer.events.on("request", (request, event, tags) => {
+      this.CONTEXT["logger"].info(`Server request: ${request}  ${event}`);
+    });
+
+    //Enable Blipp
+    await this.httpServer.register({
+      plugin: Blipp,
+      options: { showAuth: true },
+    });
+
+    // Health Checks
+    await this.httpServer.register({
+      plugin: require('hapi-alive'),
+      options: {
+        path: '/health',
+        tags: ['health', 'monitor'],
+        responses: {
+          healthy: { message: 'I am healthy' },
+          unhealthy: { message: 'I am unhealthy' }
+        }
+      }
+    });
+
+    // Rate Limiter
+    const rateLimiter = new RateLimiterMemory({
+      points: 10, // 10 points
+      duration: 1, // per second
+    });
+
+    this.httpServer.ext('onPreHandler', async (request, h) => {
+      try {
+        await rateLimiter.consume(request.info.remoteAddress);
+        return h.continue;
+      } catch (rejRes) {
+        throw Boom.tooManyRequests('Rate limit exceeded');
+      }
+    });
+
+    // Security Headers
+    this.httpServer.ext('onPreResponse', (request, h) => {
+      const response = request.response;
+      if (response.isBoom) {
+        return h.continue;
+      }
+      response.header('X-Frame-Options', 'DENY');
+      response.header('X-Content-Type-Options', 'nosniff');
+      response.header('X-XSS-Protection', '1; mode=block');
+      response.header('Strict-Transport-Security', 'max-age=63072000; includeSubDomains; preload');
+      return h.continue;
+    });
+
+    await this.#registerAuth();
+
+    //hapi scooter
+    await this.httpServer.register(Scooter);
+    this.CONTEXT["logger"].info(await this.httpServer.plugins.blipp.info());
+
+    if (this.#isDev()) {
+      this.CONTEXT["logger"].info("-----------------DEV MODE----------------");
+      this.CONTEXT["logger"].info("-----------------DEV MODE----------------");
+      this.CONTEXT["logger"].info("-----------------DEV MODE----------------");
+    }
+
+    this.CONTEXT["server"] = this.httpServer;
+
+    this.httpServer.events.on("response", (request) => {
+      this.CONTEXT["logger"].info(
+        request.info.remoteAddress +
+        ": " +
+        request.method.toUpperCase() +
+        " " +
+        request.path +
+        " --> " +
+        request.response.statusCode,
+      );
+    });
+    this.CONTEXT["logger"].info(
+      "-----------------Registered Routes----------------",
+    );
+    await this.httpServer
+      .table()
+      .forEach((route) =>
+        this.CONTEXT["logger"].info(`${route.method}\t${route.path}`),
+      );
+    this.CONTEXT["logger"].info(
+      "-----------------Registered Routes----------------",
+    );
+  }
+
+  /**
+   * Registers a custom authentication strategy for the Hapi.js server.
+   * This method allows complete control over authentication setup and MUST be called before init().
+   * The handler function receives the Falcon context including the server instance.
+   * 
+   * @param {Function} handler - Async function that configures authentication
+   * @param {Object} handler.context - Falcon context object containing server, logger, etc.
+   * @param {Object} handler.context.server - Hapi.js server instance
+   * @param {Object} handler.context.logger - Logger instance
+   * @returns {Falcon} The current Falcon instance for method chaining
+   * 
+   * @example
+   * // Custom JWT authentication
+   * falcon.setAuthStrategy(async (context) => {
+   *   await context.server.register(require('hapi-auth-jwt2'));
+   *   context.server.auth.strategy('jwt', 'jwt', {
+   *     key: process.env.JWT_SECRET,
+   *     validate: async (decoded) => {
+   *       const user = await getUserById(decoded.id);
+   *       return { isValid: !!user, credentials: user };
+   *     }
+   *   });
+   *   context.server.auth.default('jwt');
+   * });
+   */
+  setAuthStrategy(handler) {
+    this.customAuthHandler = handler;
+    return this;
+  }
+
+  async #registerAuth() {
+    // 1. Check if the user provided their own logic
+    if (this.customAuthHandler) {
+      this.CONTEXT["logger"].info("Registering CUSTOM Auth Strategy...");
+
+      // Execute the user's function, passing the Hapi server instance
+      await this.customAuthHandler(this.CONTEXT);
+
+      return this;
+    }
+
+    // 2. Register the default Falcon auth plugin if auth is configured in settings
+    if (this.SETTINGS.auth && Object.keys(this.SETTINGS.auth).length > 0) {
+      this.CONTEXT["logger"].info("Registering Falcon Auth Plugin...");
+
+      // Pass context to server app for auth plugin access
+      this.httpServer.app.falconContext = this.CONTEXT;
+
+      const { plugin } = require('./FalconAuthPlugin');
+      await this.httpServer.register({
+        plugin: plugin,
+        options: this.SETTINGS.auth
+      });
+
+      // Store auth instance for Socket.IO use
+      this.CONTEXT["auth"] = this.httpServer.app.falconAuth;
+    } else {
+      this.CONTEXT["logger"].info("No auth configuration found - skipping auth setup");
+    }
+
+    return this;
+  }
+
+  /**
+   * Starts the Hapi.js HTTP server and begins listening for incoming requests.
+   * This method should be called after init() to actually start serving traffic.
+   * The server will listen on the host and port specified in settings.
+   * 
+   * @async
+   * @returns {Promise<void>} Resolves when the server has started successfully
+   * @throws {Error} Throws error if server fails to start
+   * 
+   * @example
+   * const app = new Falcon(__dirname);
+   * await app.init();
+   * await app.runServer();
+   * console.log('Server running on', app.CONTEXT.server.info.uri);
+   */
+  async runServer() {
+    await this.CONTEXT["server"].start();
+  }
+
+  async #startSocketIO() {
+    if (this.socketIoConfig) {
+      const io = new Server(this.httpServer.listener, this.socketIoConfig);
+
+      // Add authentication middleware if auth is configured
+      if (this.CONTEXT["auth"]) {
+        const authMiddleware = this.CONTEXT["auth"].createSocketIOMiddleware();
+        io.use(authMiddleware);
+        this.CONTEXT["logger"].info("Socket.IO authentication middleware enabled");
+      }
+
+      // Store Socket.IO instance in context
+      this.CONTEXT["io"] = io;
+
+      // Load socket handlers from socket/ directory
+      await this.#loadSocketHandlers(io);
+
+      // Basic connection handling
+      io.on('connection', (socket) => {
+        this.CONTEXT["logger"].info(`Socket.IO client connected: ${socket.id}`);
+
+        if (socket.authenticated) {
+          this.CONTEXT["logger"].info(`Authenticated user: ${socket.user?.id || 'unknown'}`);
+        }
+
+        socket.on('disconnect', () => {
+          this.CONTEXT["logger"].info(`Socket.IO client disconnected: ${socket.id}`);
+        });
+      });
+
+    } else {
+      this.CONTEXT["logger"].info("Socket.IO config not found!");
+    }
+  }
+
+  async #loadSocketHandlers(io) {
+    const socketDir = path.join(this.basePath, 'sockets');
+
+    if (!fs.existsSync(socketDir)) {
+      this.CONTEXT["logger"].info("Socket handlers directory not found, skipping");
+      return;
+    }
+
+    const files = fs.readdirSync(socketDir).filter(file => file.endsWith('.js'));
+
+    for (const file of files) {
+      const filePath = path.join(socketDir, file);
+      const handlerName = path.basename(file, '.js');
+
+      try {
+        const handlerModule = require(filePath);
+        const handler = typeof handlerModule === 'function' ? handlerModule : handlerModule.handler;
+
+        if (typeof handler === 'function') {
+          await handler(io, this.CONTEXT);
+          this.CONTEXT["logger"].info(`Socket handler loaded: ${handlerName}`);
+        }
+      } catch (err) {
+        this.CONTEXT["logger"].error(`Failed to load socket handler ${handlerName}:`, err.message);
+      }
+    }
+  }
+
+  async #startInternalMqttClient(urlObj) {
+    const mqttUrl = this.SETTINGS.mqtt.internal;
+    this.mqttClient = mqtt.connect(`${config.MQTT_URL}`);
+    this.CONTEXT["mqttClient"] = this.mqttClient;
+    this.mqttClient.on("connect", () => {
+      this.mqttClient.subscribe("service_utils", (err) => {
+        this.CONTEXT["logger"].info(
+          "mqtt connected and subscribed to utility service",
+        );
+      });
+
+      // Subscribe to WebSocket topics
+      this.mqttClient.subscribe("websocket_broadcast", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_broadcast");
+      });
+      this.mqttClient.subscribe("websocket_emit_group", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_emit_group");
+      });
+      this.mqttClient.subscribe("websocket_emit_socket", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_emit_socket");
+      });
+    });
+
+    // Handle MQTT messages for WebSocket bridging
+    this.mqttClient.on("message", (topic, message) => {
+      this.#handleMqttToWebSocket(topic, message);
+    });
+  }
+
+  async #startExternalMqttClient() {
+    this.mqttClient = mqtt.connect(`${config.MQTT_URL}`);
+    this.CONTEXT["mqttClient"] = this.mqttClient;
+    this.mqttClient.on("connect", () => {
+      this.mqttClient.subscribe("service_utils", (err) => {
+        this.CONTEXT["logger"].info(
+          "mqtt connected and subscribed to utility service",
+        );
+      });
+
+      // Subscribe to WebSocket topics
+      this.mqttClient.subscribe("websocket_broadcast", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_broadcast");
+      });
+      this.mqttClient.subscribe("websocket_emit_group", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_emit_group");
+      });
+      this.mqttClient.subscribe("websocket_emit_socket", (err) => {
+        this.CONTEXT["logger"].info("mqtt subscribed to websocket_emit_socket");
+      });
+    });
+
+    // Handle MQTT messages for WebSocket bridging
+    this.mqttClient.on("message", (topic, message) => {
+      this.#handleMqttToWebSocket(topic, message);
+    });
+  }
+
+  #handleMqttToWebSocket(topic, message) {
+    if (!this.CONTEXT["io"]) return;
+
+    try {
+      const data = JSON.parse(message.toString());
+      const io = this.CONTEXT["io"];
+
+      switch (topic) {
+        case "websocket_broadcast":
+          io.emit(data.event || 'message', data.payload || data);
+          this.CONTEXT["logger"].debug(`WebSocket broadcast: ${data.event}`);
+          break;
+
+        case "websocket_emit_group":
+          if (data.room) {
+            io.to(data.room).emit(data.event || 'message', data.payload || data);
+            this.CONTEXT["logger"].debug(`WebSocket emit to room ${data.room}: ${data.event}`);
+          }
+          break;
+
+        case "websocket_emit_socket":
+          if (data.socketId) {
+            io.to(data.socketId).emit(data.event || 'message', data.payload || data);
+            this.CONTEXT["logger"].debug(`WebSocket emit to socket ${data.socketId}: ${data.event}`);
+          }
+          break;
+      }
+    } catch (err) {
+      this.CONTEXT["logger"].error(`Failed to handle MQTT to WebSocket message:`, err.message);
+    }
+  }
+
+  async #startMqttClient() {
+    if (this.SETTINGS.mqtt) {
+      if (this.SETTINGS.mqtt.internal) {
+        await this.#startInternalMqttClient(this.SETTINGS.mqtt.internal);
+      } else {
+        if (this.SETTINGS.mqtt.external) {
+          await this.#startExternalMqttClient(this.SETTINGS.mqtt.external);
+        } else {
+          await this.#startInternalMqttClient(this.SETTINGS.mqtt.internal);
+        }
+      }
+    }
+  }
+
+  /**
+   *
+   * Get Socket IO middle ware
+   * @returns Falcon instance
+   */
+  registerSocketIOMiddleware() {
+    return this;
+  }
+
+
+  async #validate(decoded, request, h) {
+    await this.validateAuth(decoded, request, h, this.CONTEXT);
+  }
+
+
+
+  // --- LOADER FUNCTION --- //
+  async _load_model_name(name) {
+    let _temp = await require(name)(mongoose);
+    this.models[path.basename(name).trim()] = _temp;
+    this.CONTEXT["models"][path.basename(name).trim()] = _temp;
+    this.CONTEXT["logger"].info(name + "  model registered");
+  }
+  async #load_route_name(name, server) {
+    await require(path.join(this.basePath, "routes", name)).route(
+      server,
+      models,
+      logger,
+    );
+    this.CONTEXT["logger"].info(name + "  route registered");
+  }
+  // --- LOADER FUNCTION --- //
+
+  /**
+   * Starts a worker process with the given arguments.
+   * Workers are spawned as separate Node.js processes.
+   * 
+   * @param {string} worker_name - Name of the worker file (without .js extension)
+   * @param {Object} args - Arguments to pass to the worker
+   * @returns {Promise<Object>} Worker process information
+   */
+  async startWorker(worker_name, args = {}) {
+    const worker_file = path.join(this.basePath, "workers", worker_name + ".js");
+
+    if (!fs.existsSync(worker_file)) {
+      throw new Error(`Worker file not found: ${worker_file}`);
+    }
+
+    const args_json = JSON.stringify(args);
+    const base64Args = Buffer.from(args_json, "utf8").toString("base64");
+
+    const worker_process = spawn(process.execPath, [worker_file, base64Args], {
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    worker_process.stdout.setEncoding("utf8");
+    worker_process.stderr.setEncoding("utf8");
+
+    worker_process.stdout.on("data", (data) => {
+      this.CONTEXT["logger"].info(`[WORKER-${worker_name}] ${data}`);
+    });
+
+    worker_process.stderr.on("data", (data) => {
+      this.CONTEXT["logger"].error(`[WORKER-${worker_name}] ERROR: ${data}`);
+    });
+
+    worker_process.on("close", (code) => {
+      this.CONTEXT["logger"].info(`[WORKER-${worker_name}] Exited with code ${code}`);
+    });
+
+    worker_process.on("error", (err) => {
+      this.CONTEXT["logger"].error(`[WORKER-${worker_name}] Failed to start:`, err);
+    });
+
+    // Store worker reference
+    if (!this.CONTEXT["workers"]) {
+      this.CONTEXT["workers"] = {};
+    }
+
+    this.CONTEXT["workers"][worker_name] = {
+      pid: worker_process.pid,
+      process: worker_process,
+      started: new Date(),
+      args: args
+    };
+
+    this.CONTEXT["logger"].info(`Worker ${worker_name} started with PID ${worker_process.pid}`);
+    return this.CONTEXT["workers"][worker_name];
+  }
+
+  /**
+   * Sends a message to a worker via MQTT.
+   * 
+   * @param {string} worker_name - Name of the worker
+   * @param {*} message - Message to send
+   * @param {string} [action='job'] - Action type (job, ping, etc.)
+   */
+  sendToWorker(worker_name, message, action = 'job') {
+    if (this.mqtt_client) {
+      const topic = `worker_${worker_name}_${action}`;
+      const payload = typeof message === 'string' ? message : JSON.stringify(message);
+      this.mqtt_client.publish(topic, payload);
+      this.CONTEXT["logger"].info(`Message sent to worker ${worker_name} on topic ${topic}`);
+    } else {
+      this.CONTEXT["logger"].warn("MQTT client not available, cannot send message to worker");
+    }
+  }
+
+  /**
+   * Sends a message to a service via MQTT.
+   * 
+   * @param {string} service_name - Name of the service
+   * @param {*} message - Message to send
+   */
+  sendToService(service_name, message) {
+    if (this.mqtt_client) {
+      const topic = `service_${service_name}`;
+      const payload = typeof message === 'string' ? message : JSON.stringify(message);
+      this.mqtt_client.publish(topic, payload);
+      this.CONTEXT["logger"].info(`Message sent to service ${service_name}`);
+    } else {
+      this.CONTEXT["logger"].warn("MQTT client not available, cannot send message to service");
+    }
+  }
+
+  /**
+   * Broadcasts a message to all websocket clients.
+   * 
+   * @param {*} data - Data to broadcast
+   */
+  broadcastToWebsockets(data) {
+    if (this.mqtt_client) {
+      this.mqtt_client.publish('websocket_broadcast', JSON.stringify(data));
+      this.CONTEXT["logger"].info("Message broadcasted to websockets");
+    }
+  }
+
+  #workers() {
+    // Legacy method - keeping for backward compatibility
+    this.CONTEXT.startWorker = this.startWorker.bind(this);
+  }
+
+  _spawnServices(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(this.basePath, "services", file + ".js");
+
+      // Use process.execPath to ensure we use the same Node binary
+      const cprocess = spawn(process.execPath, [s_path], spawnOptions);
+
+      cprocess.stdout.on("data", (data) => {
+        this.CONTEXT["logger"].info(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+        this.CONTEXT["logger"].info(data.toString());
+        this.CONTEXT["logger"].info(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+      });
+      cprocess.stderr.on("data", (data) => {
+        this.CONTEXT["logger"].error(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+        this.CONTEXT["logger"].error(data.toString());
+        this.CONTEXT["logger"].error(
+          `------------------------SERVICE - ${file}----------------`,
+        );
+      });
+
+      cprocess.on('error', (err) => {
+        this.CONTEXT["logger"].error(`Failed to spawn service ${file}:`, err);
+      });
+
+      cprocess.on('exit', (code, signal) => {
+        if (code !== 0) {
+          this.CONTEXT["logger"].warn(`Service ${file} exited with code ${code} and signal ${signal}`);
+        } else {
+          this.CONTEXT["logger"].info(`Service ${file} exited gracefully.`);
+        }
+      });
+
+      this.CONTEXT["services"].push({
+        pid: cprocess.pid,
+        stdout: cprocess.stdout,
+        stderr: cprocess.stderr,
+      });
+    });
+  }
+
+  /**
+   * Gracefully closes all active connections and cleans up resources.
+   * This method safely shuts down HTTP server, database connections, Redis client,
+   * MQTT connections, and terminates spawned service processes.
+   * 
+   * @async
+   * @returns {Promise<void>} Resolves when all cleanup operations complete
+   * 
+   * @example
+   * // Manual cleanup
+   * await app.cleanup();
+   * 
+   * // Automatic cleanup on process signals (handled by setupGracefulShutdown)
+   * process.on('SIGTERM', async () => {
+   *   await app.cleanup();
+   *   process.exit(0);
+   * });
+   */
+  async cleanup() {
+    if (this.CONTEXT["logger"]) {
+      this.CONTEXT["logger"].info("Starting cleanup process...");
+    }
+
+    // Close HTTP server
+    if (this.httpServer) {
+      await this.httpServer.stop();
+      this.httpServer = null;
+    }
+
+    // Close MongoDB connection
+    if (this.db && mongoose.connection.readyState === 1) {
+      await mongoose.connection.close();
+      this.db = null;
+    }
+
+    // Close Redis connection
+    if (this.redis_client && this.redis_client.isOpen) {
+      await this.redis_client.quit();
+      this.redis_client = null;
+    }
+
+    // Close MQTT connections
+    if (this.mqtt_client && this.mqtt_client.connected) {
+      await this.mqtt_client.end();
+      this.mqtt_client = null;
+    }
+
+    if (this.mqtt_server) {
+      this.mqtt_server.close();
+      this.mqtt_server = null;
+    }
+
+    // Kill spawned services
+    if (this.CONTEXT["services"] && this.CONTEXT["services"].length > 0) {
+      this.CONTEXT["services"].forEach(service => {
+        if (service.pid) {
+          process.kill(service.pid, 'SIGTERM');
+        }
+      });
+    }
+
+    if (this.CONTEXT["logger"]) {
+      this.CONTEXT["logger"].info("Cleanup completed");
+    }
+  }
+
+  /**
+   * Sets up graceful shutdown handlers for process signals and uncaught exceptions.
+   * Automatically registers handlers for SIGTERM, SIGINT, uncaughtException, and unhandledRejection.
+   * When any of these events occur, the cleanup method is called before process termination.
+   * 
+   * @returns {void}
+   * 
+   * @example
+   * // Called automatically in init(), but can be called manually if needed
+   * app.setupGracefulShutdown();
+   * 
+   * // The following signals will trigger graceful shutdown:
+   * // - SIGTERM (termination request)
+   * // - SIGINT (interrupt signal, Ctrl+C)
+   * // - uncaughtException (unhandled errors)
+   * // - unhandledRejection (unhandled promise rejections)
+   */
+  setupGracefulShutdown() {
+    const signals = ['SIGINT', 'SIGTERM'];
+    const logger = this.CONTEXT["logger"] || console;
+
+    signals.forEach((signal) => {
+      process.on(signal, async () => {
+        logger.info(`Received ${signal}. Starting graceful shutdown...`);
+
+        try {
+          if (this.httpServer) {
+            await this.httpServer.stop({ timeout: 10000 });
+            logger.info('HTTP server stopped');
+            this.httpServer = null;
+          }
+
+          if (this.db && mongoose.connection.readyState === 1) {
+            await mongoose.connection.close();
+            logger.info('MongoDB connection closed');
+            this.db = null;
+          }
+
+          if (this.redis_client && this.redis_client.isOpen) {
+            await this.redis_client.quit();
+            logger.info('Redis connection closed');
+            this.redis_client = null;
+          }
+
+          if (this.mqtt_client && this.mqtt_client.connected) {
+            this.mqtt_client.end();
+            logger.info('MQTT client disconnected');
+            this.mqtt_client = null;
+          }
+
+          if (this.mqtt_server) {
+            this.mqtt_server.close();
+            logger.info('MQTT server closed');
+            this.mqtt_server = null;
+          }
+
+          // Kill spawned services
+          if (this.CONTEXT["services"] && this.CONTEXT["services"].length > 0) {
+            this.CONTEXT["services"].forEach(service => {
+              if (service.pid) {
+                process.kill(service.pid, 'SIGTERM');
+              }
+            });
+            logger.info('Services terminated');
+          }
+
+          logger.info('Graceful shutdown complete. Exiting.');
+          process.exit(0);
+        } catch (err) {
+          logger.error('Error during graceful shutdown:', err);
+          process.exit(1);
+        }
+      });
+    });
+
+    process.on('uncaughtException', async (err) => {
+      logger.error('Uncaught Exception:', err);
+      await this.cleanup();
+      process.exit(1);
+    });
+
+    process.on('unhandledRejection', async (reason) => {
+      console.log(reason)
+      logger.error('Unhandled Rejection:', reason);
+      await this.cleanup();
+      process.exit(1);
+    });
+  }
+
+
+  async #generateSwaggerSchemas() {
+    this.CONTEXT["swagger_schema"] = {};
+    if (this.CONTEXT["models"]) {
+      for (const [name, model] of Object.entries(this.CONTEXT["models"])) {
+        try {
+          if (model.schema) {
+            this.CONTEXT["swagger_schema"][name] = mongooseToJoi(model.schema).label(model.modelName || name);
+          }
+        } catch (e) {
+          this.CONTEXT["logger"].error(`Failed to generate swagger schema for ${name}`, e);
+        }
+      }
+    }
+  }
+
+
+
+  async #startCrudRoutes() {
+    if (!this.SETTINGS.crud || Object.keys(this.SETTINGS.crud).length === 0) return;
+
+    this.CONTEXT["logger"].info("Starting Auto-Generated CRUD Routes...");
+
+    const allowedOps = ['create', 'read', 'update', 'delete', 'paginate'];
+
+    for (const [modelName, config] of Object.entries(this.SETTINGS.crud)) {
+      // 1. Validate Model Exists
+      // Models are stored in context with .js extension usually, wait, loaded models keys might vary
+      // Let's check against loaded models. The loader uses filenames as keys usually.
+      // We need to find the matching model key.
+      const modelKey = Object.keys(this.CONTEXT.models).find(k => k.replace(/\.js$/, '') === modelName);
+
+      if (!modelKey) {
+        this.CONTEXT["logger"].warn(`CRUD Gen: Model "${modelName}" not found in loaded models. Skipping.`);
+        continue;
+      }
+
+      const Model = this.CONTEXT.models[modelKey];
+      let ops = [];
+
+      // 2. Parse Config
+      if (config === 'all') {
+        ops = allowedOps;
+      } else if (Array.isArray(config)) {
+        // Validate ops
+        const invalidOps = config.filter(op => !allowedOps.includes(op));
+        if (invalidOps.length > 0) {
+          this.CONTEXT["logger"].warn(`CRUD Gen: Invalid operations [${invalidOps.join(', ')}] config for model "${modelName}". Ignoring ENTIRE model.`);
+          continue;
+        }
+        ops = config;
+      } else {
+        this.CONTEXT["logger"].warn(`CRUD Gen: Invalid config format for model "${modelName}". Expected "all" or array. Skipping.`);
+        continue;
+      }
+
+      this.CONTEXT["logger"].info(`CRUD Gen: Generating [${ops.join(', ')}] for ${modelName}`);
+
+      const basePath = `/crud/${modelName}`;
+
+      // Retrieve Joi Schema from Context
+      const joiSchema = this.CONTEXT["swagger_schema"][modelName] || this.CONTEXT["swagger_schema"][modelKey];
+
+      // 3. Generate Routes
+      if (ops.includes('create')) {
+        this.httpServer.route({
+          method: 'POST',
+          path: basePath,
+          options: {
+            tags: ['api'],
+            description: `Create a new ${modelName}`,
+            notes: `Auto-generated create route for ${modelName}`,
+            validate: {
+              payload: joiSchema
+            }
+          },
+          handler: async (request, h) => {
+            try {
+              const doc = await Model.create(request.payload);
+              return h.response(doc).code(201);
+            } catch (err) {
+              return h.response({ error: err.message }).code(500);
+            }
+          }
+        });
+      }
+
+      if (ops.includes('read')) { // Get By ID
+        this.httpServer.route({
+          method: 'GET',
+          path: `${basePath}/{id}`,
+          options: {
+            tags: ['api'],
+            description: `Get ${modelName} by ID`,
+            notes: `Auto-generated get by id route for ${modelName}`
+          },
+          handler: async (request, h) => {
+            try {
+              const doc = await Model.findById(request.params.id);
+              if (!doc) return h.response({ error: "Not Found" }).code(404);
+              return doc;
+            } catch (err) {
+              return h.response({ error: err.message }).code(500);
+            }
+          }
+        });
+      }
+
+      if (ops.includes('update')) {
+        this.httpServer.route({
+          method: 'PUT',
+          path: `${basePath}/{id}`,
+          options: {
+            tags: ['api'],
+            description: `Update ${modelName} by ID`,
+            notes: `Auto-generated update route for ${modelName}`,
+            validate: {
+              payload: joiSchema
+            }
+          },
+          handler: async (request, h) => {
+            try {
+              const doc = await Model.findByIdAndUpdate(request.params.id, request.payload, { new: true });
+              if (!doc) return h.response({ error: "Not Found" }).code(404);
+              return doc;
+            } catch (err) {
+              return h.response({ error: err.message }).code(500);
+            }
+          }
+        });
+      }
+
+      if (ops.includes('delete')) {
+        this.httpServer.route({
+          method: 'DELETE',
+          path: `${basePath}/{id}`,
+          options: {
+            tags: ['api'],
+            description: `Delete ${modelName} by ID`,
+            notes: `Auto-generated delete route for ${modelName}`
+          },
+          handler: async (request, h) => {
+            try {
+              const doc = await Model.findByIdAndDelete(request.params.id);
+              if (!doc) return h.response({ error: "Not Found" }).code(404);
+              return { message: "Deleted successfully", id: doc._id };
+            } catch (err) {
+              return h.response({ error: err.message }).code(500);
+            }
+          }
+        });
+      }
+
+      if (ops.includes('paginate')) {
+        this.httpServer.route({
+          method: 'GET',
+          path: basePath,
+          options: {
+            tags: ['api'],
+            description: `Paginate ${modelName}`,
+            notes: `Auto-generated pagination route for ${modelName}`
+          },
+          handler: async (request, h) => {
+            try {
+              const page = parseInt(request.query.page) || 1;
+              const limit = parseInt(request.query.limit) || 10;
+              const skip = (page - 1) * limit;
+
+              // Basic filtering support can be added here if needed
+              const docs = await Model.find({}).skip(skip).limit(limit);
+              const total = await Model.countDocuments({});
+
+              return {
+                data: docs,
+                pagination: {
+                  page,
+                  limit,
+                  total,
+                  pages: Math.ceil(total / limit)
+                }
+              };
+            } catch (err) {
+              return h.response({ error: err.message }).code(500);
+            }
+          }
+        });
+      }
+    }
+  }
+
+
+}
+
+module.exports = Falcon;
+