@triophore/falconjs 1.0.0

package/core/check_collection.js

@@ -0,0 +1,9 @@
+module.exports.collectionExists = async function (db, collectionName) {
+    try {
+      const collections = await db.listCollections({ name: collectionName }).toArray();
+      return collections.length > 0;
+    } catch (error) {
+      console.error("Error checking collection existence:", error);
+      return false; // Or throw the error, depending on your error handling
+    }
+}

package/core/crypto/encrypt_decrypt.js

@@ -0,0 +1,19 @@
+require('dotenv').config();
+const config = process.env;
+const crypto = require('crypto');
+
+// Encryption function
+module.exports.encrypt = function(text) {
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(config.ENCRYPT_KEY), Buffer.from('0123456789abcdef'));
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return encrypted.toString('hex');
+}
+
+// Decryption function
+module.exports.decrypt = function(encryptedText) {
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(config.ENCRYPT_KEY), Buffer.from('0123456789abcdef'));
+    let decrypted = decipher.update(Buffer.from(encryptedText, 'hex'));
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString();
+}

package/core/errors.js

@@ -0,0 +1,48 @@
+/**
+ * Custom error classes for Falcon.js framework
+ */
+
+class FalconError extends Error {
+    constructor(message, code = 'FALCON_ERROR') {
+        super(message);
+        this.name = 'FalconError';
+        this.code = code;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+class ConfigurationError extends FalconError {
+    constructor(message) {
+        super(message, 'CONFIG_ERROR');
+        this.name = 'ConfigurationError';
+    }
+}
+
+class ValidationError extends FalconError {
+    constructor(message) {
+        super(message, 'VALIDATION_ERROR');
+        this.name = 'ValidationError';
+    }
+}
+
+class DatabaseError extends FalconError {
+    constructor(message) {
+        super(message, 'DATABASE_ERROR');
+        this.name = 'DatabaseError';
+    }
+}
+
+class AuthenticationError extends FalconError {
+    constructor(message) {
+        super(message, 'AUTH_ERROR');
+        this.name = 'AuthenticationError';
+    }
+}
+
+module.exports = {
+    FalconError,
+    ConfigurationError,
+    ValidationError,
+    DatabaseError,
+    AuthenticationError
+};

package/core/logger/log4js.js

@@ -0,0 +1,89 @@
+const log4js = require("log4js");
+require('dotenv').config();
+
+const config = process.env;
+
+/**
+ * Creates and returns a configured log4js logger based on config_type
+ * @param {"file"|"stdio"|"both"} config_type - Where to log
+ * @returns {log4js.Logger}
+ */
+module.exports.getLogger = function (config_type = "both") {
+  // Normalize config_type
+  let type = "both";
+
+  if (typeof config_type === 'string') {
+    type = config_type;
+  } else if (typeof config_type === 'object' && config_type !== null) {
+    type = config_type.type || "both";
+  }
+
+  type = type.toLowerCase().trim();
+
+  if (!["file", "stdio", "both"].includes(type)) {
+    throw new Error(`Invalid config_type: ${type}. Use 'file', 'stdio', or 'both'.`);
+  }
+
+  // Custom layout with Unix timestamp in milliseconds
+  log4js.addLayout('unixTimestampMillisLayout', () => {
+    return (logEvent) => {
+      const unixTimestampMillis = logEvent.startTime.getTime();
+      const logData = logEvent.data.map(item => {
+        try {
+          if (item instanceof Error) {
+            return item.stack || item.message;
+          }
+          return typeof item === 'object' && item !== null
+            ? JSON.stringify(item)
+            : String(item);
+        } catch (error) {
+          if (error.message.includes('circular')) {
+            return '[Circular]';
+          }
+          return `[Error: ${error.message}]`;
+        }
+      }).join(' ');
+
+      return `[${unixTimestampMillis}] [${logEvent.level.levelStr}] ${logData}`;
+    };
+  });
+
+  // Build appenders dynamically
+  const appenders = {};
+  const categoryAppenders = [];
+
+  // File Appender
+  if (type === "file" || type === "both") {
+    appenders.file = {
+      type: "file",
+      filename: config.LOG_FILE_NAME || "log/server.log",
+      maxLogSize: config.LOG_MAX_SIZE || "5M",
+      backups: parseInt(config.LOG_BACKUPS, 10) || 10,
+      compress: config.LOG_COMPRESS !== "false", // default true
+      layout: { type: 'unixTimestampMillisLayout' }
+    };
+    categoryAppenders.push("file");
+  }
+
+  // Console (stdio) Appender
+  if (type === "stdio" || type === "both") {
+    appenders.console = {
+      type: "stdout", // or "stderr" for errors only
+      layout: { type: 'unixTimestampMillisLayout' }
+    };
+    categoryAppenders.push("console");
+  }
+
+  // Configure log4js
+  log4js.configure({
+    appenders,
+    categories: {
+      default: {
+        appenders: categoryAppenders,
+        level: config.LOG_LEVEL || "trace"
+      }
+    }
+  });
+
+  return log4js.getLogger();
+};

package/core/logo.js

@@ -0,0 +1,3 @@
+module.exports.logo =`     ▄▖▄▖▄▖▄▖▄▖▖▖▄▖▄▖▄▖
+                            ▐ ▙▘▐ ▌▌▙▌▙▌▌▌▙▘▙▖
+                            ▐ ▌▌▟▖▙▌▌ ▌▌▙▌▌▌▙▖`

package/core/mongo/generateModelfromJsonFile.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Infers Mongoose schema type from a JavaScript value
+ * @param {*} value
+ * @returns {String} Mongoose schema type
+ */
+function inferType(value) {
+  if (value === null || value === undefined) return 'Mixed';
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[Mixed]';
+    const itemType = inferType(value[0]);
+    return `[${itemType}]`;
+  }
+  switch (typeof value) {
+    case 'string':
+      // Detect common string subtypes
+      if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) return 'Date';
+      if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return 'Date';
+      if (value.length > 100) return 'String'; // Long text
+      return 'String';
+    case 'number':
+      return Number.isInteger(value) ? 'Number' : 'Number'; // Mongoose uses Number for both
+    case 'boolean':
+      return 'Boolean';
+    case 'object':
+      if (value instanceof Date) return 'Date';
+      return 'Object';
+    default:
+      return 'Mixed';
+  }
+}
+
+/**
+ * Recursively generates Mongoose schema definition from JSON object
+ * @param {Object} obj
+ * @param {Number} depth
+ * @returns {Object} Schema definition
+ */
+function generateSchemaDefinition(obj, depth = 0) {
+  if (depth > 10) return {}; // Prevent infinite recursion
+
+  const schema = {};
+
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const value = obj[key];
+      const type = inferType(value);
+
+      if (type === 'Object' && typeof value === 'object' && !Array.isArray(value) && value !== null) {
+        schema[key] = generateSchemaDefinition(value, depth + 1);
+      } else if (type.startsWith('[')) {
+        const arrayItemType = type.slice(1, -1);
+        if (arrayItemType === 'Object') {
+          schema[key] = [generateSchemaDefinition(value[0] || {}, depth + 1)];
+        } else {
+          schema[key] = {
+            type: `[${arrayItemType}]`,
+            default: []
+          };
+        }
+      } else {
+        schema[key] = { type };
+        if (value === null) schema[key].default = null;
+      }
+    }
+  }
+
+  return schema;
+}
+
+/**
+ * Converts schema definition to Mongoose Schema string
+ * @param {Object} schemaDef
+ * @param {String} indent
+ * @returns {String}
+ */
+function schemaToString(schemaDef, indent = '  ') {
+  let str = '{\n';
+
+  const keys = Object.keys(schemaDef);
+  keys.forEach((key, index) => {
+    const field = schemaDef[key];
+    const isLast = index === keys.length - 1;
+
+    if (typeof field === 'object' && field.type && field.type.startsWith('[')) {
+      const arrayType = field.type.slice(1, -1);
+      if (arrayType === 'Object') {
+        // Nested array of objects
+        str += `${indent}  ${key}: [${schemaToString(field[0], indent + '    ')}\n${indent}  ]`;
+      } else {
+        str += `${indent}  ${key}: { type: ${field.type}${field.default !== undefined ? `, default: ${JSON.stringify(field.default)}` : ''} }`;
+      }
+    } else if (typeof field === 'object' && !field.type && Object.keys(field).length > 0) {
+      // Nested object
+      str += `${indent}  ${key}: ${schemaToString(field, indent + '  ')}`;
+    } else if (typeof field === 'object' && field.type) {
+      str += `${indent}  ${key}: { type: ${field.type}${field.default !== undefined ? `, default: ${JSON.stringify(field.default)}` : ''} }`;
+    }
+
+    str += isLast ? '\n' : ',\n';
+  });
+
+  str += `${indent}}`;
+  return str;
+}
+
+/**
+ * Main function to generate Mongoose model from JSON
+ * @param {Object} jsonData
+ * @param {String} modelName
+ * @returns {String} Complete Mongoose model code
+ */
+function generateMongooseModel(jsonData, modelName = 'MyModel') {
+  const schemaDef = generateSchemaDefinition(jsonData);
+  const schemaString = schemaToString(schemaDef);
+
+  return `const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const ${modelName}Schema = new Schema(
+${schemaString}
+);
+
+module.exports = mongoose.model('${modelName}', ${modelName}Schema);
+`;
+}

package/core/mongo/mongoSchmeFromJson.js

@@ -0,0 +1,90 @@
+// createMongooseSchema.js
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+/**
+ * Maps custom type → Mongoose type
+ */
+const typeMap = {
+  string: String,
+  number: Number,
+  boolean: Boolean,
+  date: Date,
+  objectid: mongoose.Types.ObjectId,
+  mixed: Schema.Types.Mixed,
+  array: Array,
+  object: Object
+};
+
+/**
+ * Converts custom schema field to Mongoose field definition
+ */
+function convertField(field) {
+  if (!field || !field.type) return {};
+
+  const mongooseField = {};
+  const typeKey = field.type.toLowerCase();
+
+  // Set type
+  if (typeKey === 'array' && field.items) {
+    const itemSchema = convertField(field.items);
+    mongooseField.type = [itemSchema.type ? new Schema(itemSchema) : itemSchema];
+  } 
+  else if (typeKey === 'object' && field.properties) {
+    const subSchema = {};
+    for (const [key, subField] of Object.entries(field.properties)) {
+      subSchema[key] = convertField(subField);
+    }
+    mongooseField.type = subSchema;
+  } 
+  else {
+    mongooseField.type = typeMap[typeKey] || Schema.Types.Mixed;
+  }
+
+  // Add options
+  if (field.required === true) mongooseField.required = true;
+  if (field.unique === true) mongooseField.unique = true;
+  if (field.index === true) mongooseField.index = true;
+  if (field.default !== undefined) {
+    mongooseField.default = field.default === 'now' ? Date.now : field.default;
+  }
+  if (field.trim === true) mongooseField.trim = true;
+  if (field.lowercase === true) mongooseField.lowercase = true;
+  if (field.uppercase === true) mongooseField.uppercase = true;
+  if (field.enum) mongooseField.enum = field.enum;
+
+  return mongooseField;
+}
+
+/**
+ * Main function: JSON → Mongoose Schema
+ * @param {Object} config
+ * @returns {{ schema: mongoose.Schema, modelName: string }}
+ */
+function createMongooseSchemaFromJson(config) {
+  if (!config || !config.name || !config.schema) {
+    throw new Error('Invalid config: must have "name" and "schema"');
+  }
+
+  const { name, schema: schemaDef, options = {} } = config;
+  const mongooseSchemaDef = {};
+
+  // Convert each field
+  for (const [fieldName, fieldDef] of Object.entries(schemaDef)) {
+    mongooseSchemaDef[fieldName] = convertField(fieldDef);
+  }
+
+  // Create Mongoose Schema
+  const mongooseSchema = new Schema(mongooseSchemaDef, {
+    timestamps: options.timestamps || false,
+    ...options
+  });
+
+  return {
+    modelName: name,
+    schema: mongooseSchema
+  };
+}
+
+// Export
+module.exports = { createMongooseSchemaFromJson };

package/core/parse_num.js

@@ -0,0 +1,8 @@
+module.exports.parse_num = function(str){
+  const parsedInt = parseInt(str);
+  if (isNaN(parsedInt)) {
+    return "NO_NUM";
+  } else {
+    return parsedInt;
+  }
+}

package/core/rannum.js

@@ -0,0 +1,33 @@
+const crypto = require('crypto');
+
+module.exports.generateRandomnumericString = function (length) {
+  if (typeof length !== 'number' || length <= 0) {
+    throw new Error('Length must be a positive number.');
+  }
+
+  const characters = '0123456789';
+  const charactersLength = characters.length;
+
+  let result = '';
+
+  // More cryptographically secure approach using randomBytes (recommended)
+  const randomBytes = crypto.randomBytes(length);
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = randomBytes[i] % charactersLength;  // Get index within character set
+    result += characters.charAt(randomIndex);
+  }
+  return result;
+
+
+  // Less secure approach (if absolutely needed and you understand the risks)
+  //  -  Not recommended for production systems where security is critical.
+  //  -  Uses Math.random(), which is not cryptographically strong.
+  /*
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * charactersLength);
+    result += characters.charAt(randomIndex);
+  }
+  return result;
+  */
+}

package/core/ranstring.js

@@ -0,0 +1,33 @@
+const crypto = require('crypto');
+
+module.exports.generateRandomAlphanumericString = function (length) {
+  if (typeof length !== 'number' || length <= 0) {
+    throw new Error('Length must be a positive number.');
+  }
+
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  const charactersLength = characters.length;
+
+  let result = '';
+
+  // More cryptographically secure approach using randomBytes (recommended)
+  const randomBytes = crypto.randomBytes(length);
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = randomBytes[i] % charactersLength;  // Get index within character set
+    result += characters.charAt(randomIndex);
+  }
+  return result;
+
+
+  // Less secure approach (if absolutely needed and you understand the risks)
+  //  -  Not recommended for production systems where security is critical.
+  //  -  Uses Math.random(), which is not cryptographically strong.
+  /*
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * charactersLength);
+    result += characters.charAt(randomIndex);
+  }
+  return result;
+  */
+}

package/core/recursive-require-call.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Recursively require CJS modules and call a function with arguments
+ * @param {string} dir - Directory to scan
+ * @param {string} [functionName='getValue'] - Function name to call
+ * @param {any[]} [args=[]] - Arguments to pass to the function
+ * @param {RegExp} [fileFilter=/\.(js|cjs)$/i] - File filter
+ * @returns {Promise<Array<{file: string, value: any, error?: string}>>}
+ */
+async function requireAndCallRecursively(dir, functionName = 'getValue', args = [], fileFilter = /\.(js|cjs)$/i) {
+  const results = [];
+
+  async function scan(currentDir) {
+    let files;
+    try {
+      files = await fs.promises.readdir(currentDir);
+    } catch (err) {
+      results.push({ file: currentDir, error: `Read dir error: ${err.message}` });
+      return;
+    }
+
+    for (const file of files) {
+      const fullPath = path.join(currentDir, file);
+      let stat;
+
+      try {
+        stat = await fs.promises.stat(fullPath);
+      } catch (err) {
+        results.push({ file: fullPath, error: `Stat error: ${err.message}` });
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        if (file === 'node_modules' || file === '.git' || file.startsWith('.')) {
+          continue;
+        }
+        await scan(fullPath);
+      } else if (stat.isFile() && fileFilter.test(file)) {
+        let moduleExport;
+        try {
+          delete require.cache[require.resolve(fullPath)];
+          moduleExport = require(fullPath);
+        } catch (err) {
+          results.push({ file: fullPath, error: `Require error: ${err.message}` });
+          continue;
+        }
+
+        let value;
+        try {
+          let fn = null;
+
+          // Resolve function in various export patterns
+          if (typeof moduleExport === 'function') {
+            fn = moduleExport;
+          } else if (moduleExport && typeof moduleExport[functionName] === 'function') {
+            fn = moduleExport[functionName];
+          } else if (moduleExport?.default && typeof moduleExport.default === 'function') {
+            fn = moduleExport.default;
+          } else if (moduleExport?.default && typeof moduleExport.default[functionName] === 'function') {
+            fn = moduleExport.default[functionName];
+          }
+
+          if (fn) {
+            value = await Promise.resolve(fn(...args));
+          } else {
+            value = { warning: 'No callable function found', export: moduleExport };
+          }
+        } catch (err) {
+          results.push({ file: fullPath, value: null, error: `Call error: ${err.message}` });
+          continue;
+        }
+
+        results.push({ file: fullPath, value });
+      }
+    }
+  }
+
+  await scan(path.resolve(dir));
+  return results;
+}
+
+// === CLI Usage ===
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log('Usage: node script.js <directory> <functionName> [arg1] [arg2] ...');
+    console.log('Example: node script.js ./modules getValue 123 "hello"');
+    process.exit(1);
+  }
+
+  const targetDir = args[0];
+  const funcName = args[1];
+  const funcArgs = args.slice(2).map(arg => {
+    // Try to parse JSON or numbers
+    try {
+      return JSON.parse(arg);
+    } catch {
+      return arg;
+    }
+  });
+
+  requireAndCallRecursively(targetDir, funcName, funcArgs)
+    .then(results => {
+      console.log(`\nScanned ${results.length} file(s):\n`);
+      results.forEach(r => {
+        if (r.error) {
+          console.error(`Failed: ${r.file}\n   → ${r.error}`);
+        } else {
+          const val = typeof r.value === 'object' ? JSON.stringify(r.value, null, 2) : r.value;
+          console.log(`Success: ${r.file}\n   → ${val}`);
+        }
+      });
+    })
+    .catch(err => {
+      console.error('Fatal error:', err);
+    });
+}
+
+module.exports = { requireAndCallRecursively };

package/core/uitls/mongoose_to_joi.js

@@ -0,0 +1,72 @@
+const Joi = require('joi');
+const mongoose = require('mongoose');
+
+/**
+ * Converts a Mongoose schema to a Joi schema.
+ * @param {mongoose.Schema} schema - The Mongoose schema to convert.
+ * @returns {Joi.ObjectSchema} The converted Joi schema.
+ */
+function mongooseToJoi(schema) {
+    if (!schema) return Joi.object();
+
+    const joiSchema = {};
+
+    schema.eachPath((path, type) => {
+        if (path === '_id' || path === '__v') return; // Skip internal fields
+
+        let joiType;
+        const instance = type.instance;
+        const options = type.options || {};
+
+        if (instance === 'String') {
+            joiType = Joi.string();
+            if (options.enum) {
+                joiType = joiType.valid(...options.enum);
+            }
+        } else if (instance === 'Number') {
+            joiType = Joi.number();
+        } else if (instance === 'Boolean') {
+            joiType = Joi.boolean();
+        } else if (instance === 'Date') {
+            joiType = Joi.date();
+        } else if (instance === 'Array') {
+            // Basic array support - checking if it has a sub-schema or just a type
+            if (type.caster && type.caster.instance) {
+                // Array of primitives
+                const subInstance = type.caster.instance;
+                if (subInstance === 'String') joiType = Joi.array().items(Joi.string());
+                else if (subInstance === 'Number') joiType = Joi.array().items(Joi.number());
+                else if (subInstance === 'Boolean') joiType = Joi.array().items(Joi.boolean());
+                else joiType = Joi.array();
+            } else if (type.schema) {
+                // Array of subdocuments
+                const subSchema = mongooseToJoi(type.schema);
+                joiType = Joi.array().items(subSchema);
+            } else {
+                joiType = Joi.array();
+            }
+        } else if (instance === 'Embedded') {
+            // Nested Object
+            if (type.schema) {
+                joiType = mongooseToJoi(type.schema);
+            } else {
+                joiType = Joi.object();
+            }
+        } else if (instance === 'ObjectID') {
+            joiType = Joi.string().regex(/^[0-9a-fA-F]{24}$/, 'ObjectId');
+        } else {
+            // Fallback for unknown types
+            joiType = Joi.any();
+        }
+
+        if (options.required) {
+            joiType = joiType.required();
+        }
+
+        joiSchema[path] = joiType;
+    });
+
+    return Joi.object(joiSchema);
+}
+
+module.exports = mongooseToJoi;

package/core/uitls/return.js

@@ -0,0 +1,7 @@
+module.exports.return_obj = function(status,data,notify = false){
+    return {
+        status : status,
+        data : data,
+        notify : notify
+    }
+}