@ecopex/ecopex-framework 1.0.0

package/database/seeds/timezones.js

@@ -0,0 +1,149 @@
+/**
+ * Seed the timezones table with unique offsets.
+ * @param { import("knex").Knex } knex
+ */
+exports.seed = async function(knex) {
+    // Inserts seed entries with unique offsets
+    await knex('timezones').insert([
+        {
+            timezone_id: 1,
+            name: 'Greenwich Mean Time',
+            code: 'GMT',
+            offset: '+00:00',
+            gmt: 'GMT+0'
+        },
+        {
+            timezone_id: 2,
+            name: 'Central European Time',
+            code: 'CET',
+            offset: '+01:00',
+            gmt: 'GMT+1'
+        },
+        {
+            timezone_id: 3,
+            name: 'Eastern European Time',
+            code: 'EET',
+            offset: '+02:00',
+            gmt: 'GMT+2'
+        },
+        {
+            timezone_id: 4,
+            name: 'Moscow Standard Time',
+            code: 'MSK',
+            offset: '+03:00',
+            gmt: 'GMT+3'
+        },
+        {
+            timezone_id: 5,
+            name: 'Pakistan Standard Time',
+            code: 'PKT',
+            offset: '+05:00',
+            gmt: 'GMT+5'
+        },
+        {
+            timezone_id: 6,
+            name: 'India Standard Time',
+            code: 'IST',
+            offset: '+05:30',
+            gmt: 'GMT+5:30'
+        },
+        {
+            timezone_id: 7,
+            name: 'Bangladesh Standard Time',
+            code: 'BST',
+            offset: '+06:00',
+            gmt: 'GMT+6'
+        },
+        {
+            timezone_id: 8,
+            name: 'Indochina Time',
+            code: 'ICT',
+            offset: '+07:00',
+            gmt: 'GMT+7'
+        },
+        {
+            timezone_id: 9,
+            name: 'China Standard Time',
+            code: 'CST',
+            offset: '+08:00',
+            gmt: 'GMT+8'
+        },
+        {
+            timezone_id: 10,
+            name: 'Japan Standard Time',
+            code: 'JST',
+            offset: '+09:00',
+            gmt: 'GMT+9'
+        },
+        {
+            timezone_id: 11,
+            name: 'Australian Eastern Standard Time',
+            code: 'AEST',
+            offset: '+10:00',
+            gmt: 'GMT+10'
+        },
+        {
+            timezone_id: 12,
+            name: 'New Zealand Standard Time',
+            code: 'NZST',
+            offset: '+12:00',
+            gmt: 'GMT+12'
+        },
+        {
+            timezone_id: 13,
+            name: 'Atlantic Standard Time',
+            code: 'AST',
+            offset: '-04:00',
+            gmt: 'GMT-4'
+        },
+        {
+            timezone_id: 14,
+            name: 'Eastern Standard Time',
+            code: 'EST',
+            offset: '-05:00',
+            gmt: 'GMT-5'
+        },
+        {
+            timezone_id: 15,
+            name: 'Central Standard Time',
+            code: 'CST',
+            offset: '-06:00',
+            gmt: 'GMT-6'
+        },
+        {
+            timezone_id: 16,
+            name: 'Mountain Standard Time',
+            code: 'MST',
+            offset: '-07:00',
+            gmt: 'GMT-7'
+        },
+        {
+            timezone_id: 17,
+            name: 'Pacific Standard Time',
+            code: 'PST',
+            offset: '-08:00',
+            gmt: 'GMT-8'
+        },
+        {
+            timezone_id: 18,
+            name: 'Alaska Standard Time',
+            code: 'AKST',
+            offset: '-09:00',
+            gmt: 'GMT-9'
+        },
+        {
+            timezone_id: 19,
+            name: 'Hawaii-Aleutian Standard Time',
+            code: 'HST',
+            offset: '-10:00',
+            gmt: 'GMT-10'
+        },
+        {
+            timezone_id: 20,
+            name: 'Samoa Standard Time',
+            code: 'SST',
+            offset: '-11:00',
+            gmt: 'GMT-11'
+        }
+    ]).onConflict('timezone_id').ignore();
+};

package/ecosystem.config.js

@@ -0,0 +1,26 @@
+require('dotenv').config({
+    path: './.env'
+});
+
+module.exports = {
+    apps: [
+        // {
+        //     name: 'sb-system-api',
+        //     script: './backend/workers/api.js',
+        //     watch: process.env.NODE_ENV === 'development',
+        //     ignore_watch: ['node_modules', 'database', 'logs', '*.log', '*.json'],
+        // },
+        {
+            name: 'sb-system-admin',
+            script: './workers/admin.js',
+            watch: process.env.NODE_ENV === 'development',
+            ignore_watch: ['node_modules', 'database', 'logs', '*.log', '*.json']
+        },
+        // {
+        //     name   : "sb-system-admin-dev",
+        //     cwd    : "./admin",
+        //     script : "bun",
+        //     args   : "run dev"
+        // },
+    ]
+};

package/env.example

@@ -0,0 +1,73 @@
+# ===========================================
+# SB System Environment Configuration
+# ===========================================
+
+# Application Environment
+NODE_ENV=development
+LOG_LEVEL=info
+
+# Server Configuration
+HOST=0.0.0.0
+API_PORT=3000
+ADMIN_PORT=3001
+
+# Database Configuration
+DB_HOST=localhost
+DB_PORT=3306
+DB_USER=root
+DB_PASSWORD=your_password_here
+DB_NAME=sb_system
+
+# Alternative: Use DATABASE_URL for production
+# DATABASE_URL=mysql://username:password@host:port/database
+
+# CORS Configuration
+CORS_ORIGIN=*
+
+# PM2 Process Management
+API_INSTANCES=1
+API_EXEC_MODE=fork
+ADMIN_INSTANCES=1
+ADMIN_EXEC_MODE=fork
+
+# Internationalization
+DEFAULT_LOCALE=en
+SUPPORTED_LOCALES=en,tr,es
+
+# Security (for production)
+# JWT_SECRET=your_jwt_secret_here
+# BCRYPT_ROUNDS=12
+# SESSION_SECRET=your_session_secret_here
+
+# Redis (for caching/sessions)
+# REDIS_HOST=localhost
+# REDIS_PORT=6379
+# REDIS_PASSWORD=
+
+# Email Configuration (for notifications)
+# SMTP_HOST=smtp.gmail.com
+# SMTP_PORT=587
+# SMTP_USER=your_email@gmail.com
+# SMTP_PASS=your_app_password
+# FROM_EMAIL=noreply@yoursystem.com
+
+# File Upload Configuration
+# UPLOAD_MAX_SIZE=10485760
+# UPLOAD_ALLOWED_TYPES=image/jpeg,image/png,image/gif,application/pdf
+
+# Rate Limiting
+# RATE_LIMIT_WINDOW_MS=900000
+# RATE_LIMIT_MAX_REQUESTS=100
+
+# Logging
+# LOG_FILE_PATH=./logs/app.log
+# LOG_MAX_SIZE=10m
+# LOG_MAX_FILES=5
+
+# Monitoring
+# HEALTH_CHECK_INTERVAL=30000
+# METRICS_ENABLED=true
+
+# Development Tools
+# DEBUG=sb_system:*
+# NODE_OPTIONS=--max-old-space-size=4096

package/knexfile.js

@@ -0,0 +1,3 @@
+require('dotenv').config();
+
+module.exports = require('./config/database');

package/libraries/2fa.js

@@ -0,0 +1,22 @@
+const twofactor = require("node-2fa");
+
+const generate_2fa_secret = (account = '') => {
+    const newSecret = twofactor.generateSecret({ name: process.env.NAME || 'System', account });
+    return newSecret
+}
+
+const generate_2fa_token = (secret = '') => {
+    const token = twofactor.generateToken(secret);
+    return token
+}
+
+const verify_2fa_token = (secret = '', token = '') => {
+    const isValid = twofactor.verifyToken(secret, token);
+    return isValid
+}
+
+module.exports = {
+    generate_2fa_secret,
+    generate_2fa_token,
+    verify_2fa_token
+}

package/libraries/aws.js

@@ -0,0 +1,63 @@
+const { S3Client } = require("@aws-sdk/client-s3");
+const { Upload } = require("@aws-sdk/lib-storage");
+const fs = require('fs');
+
+// Config
+
+// UPLOAD Base
+const uploadBase = __dirname + '../uploads/'
+
+// The name of the bucket that you have created
+const BUCKET_NAME = process.env.AWS_BUCKET_NAME;
+
+
+const uploadAws = async (filePath, contentType) => {
+
+    const client = new S3Client({
+        bucketEndpoint: BUCKET_NAME,
+        region: process.env.AWS_REGION,
+        credentials: {
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID
+        }
+    });
+
+    let uploadStatus = false
+
+    // Read content from the file
+    const fileContent = await fs.readFileSync(uploadBase + filePath);
+
+    // Setting up S3 upload parameters
+    const params = {
+        ACL: 'public-read',
+        Bucket: BUCKET_NAME,
+        Key: filePath, // File name you want to save as in S3
+        Body: fileContent,
+        ContentType: contentType
+    };
+
+    // Uploading files to the bucket
+    try {
+
+        const uploadAws = await Upload({
+            client,
+            params
+        });
+        fs.unlinkSync(uploadBase + filePath);
+        
+        return {
+            status: true,
+            uploadAws
+        }
+
+    } catch (error) {
+        return {
+            status: false,
+            msg: error
+        };   
+    }
+}
+
+module.exports = {
+    uploadAws
+}

package/libraries/bcrypt.js

@@ -0,0 +1,284 @@
+const bcrypt = require('bcryptjs');
+
+/**
+ * Bcrypt Library Class
+ * Provides methods for password hashing, comparison, and salt generation
+ */
+class Bcrypt {
+  constructor(saltRounds = 12) {
+    this.saltRounds = saltRounds;
+  }
+
+  /**
+   * Hash a password using bcrypt
+   * @param {string} password - The password to hash
+   * @param {number} saltRounds - Number of salt rounds (optional, uses instance default)
+   * @returns {Promise<string>} Hashed password
+   */
+  async hash(password, saltRounds = this.saltRounds) {
+    try {
+      if (!password || typeof password !== 'string') {
+        throw new Error('Password must be a non-empty string');
+      }
+
+      if (saltRounds < 4 || saltRounds > 31) {
+        throw new Error('Salt rounds must be between 4 and 31');
+      }
+
+      return await bcrypt.hash(password, saltRounds);
+    } catch (error) {
+      throw new Error(`Bcrypt Hash Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Compare a password with its hash
+   * @param {string} password - The plain text password
+   * @param {string} hash - The hashed password to compare against
+   * @returns {Promise<boolean>} True if password matches, false otherwise
+   */
+  async compare(password, hash) {
+    try {
+      if (!password || typeof password !== 'string') {
+        throw new Error('Password must be a non-empty string');
+      }
+
+      if (!hash || typeof hash !== 'string') {
+        throw new Error('Hash must be a non-empty string');
+      }
+
+      return await bcrypt.compare(password, hash);
+    } catch (error) {
+      throw new Error(`Bcrypt Compare Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate a salt
+   * @param {number} saltRounds - Number of salt rounds (optional, uses instance default)
+   * @returns {Promise<string>} Generated salt
+   */
+  async genSalt(saltRounds = this.saltRounds) {
+    try {
+      if (saltRounds < 4 || saltRounds > 31) {
+        throw new Error('Salt rounds must be between 4 and 31');
+      }
+
+      return await bcrypt.genSalt(saltRounds);
+    } catch (error) {
+      throw new Error(`Bcrypt GenSalt Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Hash a password with a specific salt
+   * @param {string} password - The password to hash
+   * @param {string} salt - The salt to use
+   * @returns {Promise<string>} Hashed password
+   */
+  async hashWithSalt(password, salt) {
+    try {
+      if (!password || typeof password !== 'string') {
+        throw new Error('Password must be a non-empty string');
+      }
+
+      if (!salt || typeof salt !== 'string') {
+        throw new Error('Salt must be a non-empty string');
+      }
+
+      return await bcrypt.hash(password, salt);
+    } catch (error) {
+      throw new Error(`Bcrypt HashWithSalt Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get the number of rounds used in a hash
+   * @param {string} hash - The bcrypt hash
+   * @returns {number} Number of rounds used
+   */
+  getRounds(hash) {
+    try {
+      if (!hash || typeof hash !== 'string') {
+        throw new Error('Hash must be a non-empty string');
+      }
+
+      return bcrypt.getRounds(hash);
+    } catch (error) {
+      throw new Error(`Bcrypt GetRounds Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a hash needs to be upgraded (rehashed with more rounds)
+   * @param {string} hash - The bcrypt hash to check
+   * @param {number} minRounds - Minimum rounds required (optional, uses instance default)
+   * @returns {boolean} True if hash needs upgrading, false otherwise
+   */
+  needsUpgrade(hash, minRounds = this.saltRounds) {
+    try {
+      if (!hash || typeof hash !== 'string') {
+        throw new Error('Hash must be a non-empty string');
+      }
+
+      const currentRounds = this.getRounds(hash);
+      return currentRounds < minRounds;
+    } catch (error) {
+      throw new Error(`Bcrypt NeedsUpgrade Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Upgrade a hash to use more rounds
+   * @param {string} password - The original password
+   * @param {string} oldHash - The old hash
+   * @param {number} newRounds - New number of rounds (optional, uses instance default)
+   * @returns {Promise<string>} New upgraded hash
+   */
+  async upgradeHash(password, oldHash, newRounds = this.saltRounds) {
+    try {
+      if (!password || typeof password !== 'string') {
+        throw new Error('Password must be a non-empty string');
+      }
+
+      if (!oldHash || typeof oldHash !== 'string') {
+        throw new Error('Old hash must be a non-empty string');
+      }
+
+      // Verify the old password first
+      const isValid = await this.compare(password, oldHash);
+      if (!isValid) {
+        throw new Error('Invalid password for hash upgrade');
+      }
+
+      // Generate new hash with more rounds
+      return await this.hash(password, newRounds);
+    } catch (error) {
+      throw new Error(`Bcrypt UpgradeHash Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate password strength
+   * @param {string} password - The password to validate
+   * @param {Object} options - Validation options
+   * @returns {Object} Validation result with isValid and errors
+   */
+  validatePassword(password, options = {}) {
+    const defaults = {
+      minLength: 8,
+      requireUppercase: true,
+      requireLowercase: true,
+      requireNumbers: true,
+      requireSpecialChars: true,
+      maxLength: 128
+    };
+
+    const config = { ...defaults, ...options };
+    const errors = [];
+
+    if (!password || typeof password !== 'string') {
+      return { isValid: false, errors: ['Password must be a string'] };
+    }
+
+    if (password.length < config.minLength) {
+      errors.push(`Password must be at least ${config.minLength} characters long`);
+    }
+
+    if (password.length > config.maxLength) {
+      errors.push(`Password must be no more than ${config.maxLength} characters long`);
+    }
+
+    if (config.requireUppercase && !/[A-Z]/.test(password)) {
+      errors.push('Password must contain at least one uppercase letter');
+    }
+
+    if (config.requireLowercase && !/[a-z]/.test(password)) {
+      errors.push('Password must contain at least one lowercase letter');
+    }
+
+    if (config.requireNumbers && !/\d/.test(password)) {
+      errors.push('Password must contain at least one number');
+    }
+
+    if (config.requireSpecialChars && !/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password)) {
+      errors.push('Password must contain at least one special character');
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Set the default number of salt rounds
+   * @param {number} saltRounds - Number of salt rounds
+   */
+  setSaltRounds(saltRounds) {
+    if (saltRounds < 4 || saltRounds > 31) {
+      throw new Error('Salt rounds must be between 4 and 31');
+    }
+    this.saltRounds = saltRounds;
+  }
+
+  /**
+   * Get the current number of salt rounds
+   * @returns {number} Current salt rounds
+   */
+  getSaltRounds() {
+    return this.saltRounds;
+  }
+
+  /**
+   * Generate a random password
+   * @param {Object} options - Password generation options
+   * @returns {string} Generated password
+   */
+  generatePassword(options = {}) {
+    const defaults = {
+      length: 16,
+      includeUppercase: true,
+      includeLowercase: true,
+      includeNumbers: true,
+      includeSpecialChars: true,
+      excludeSimilar: true
+    };
+
+    const config = { ...defaults, ...options };
+    let charset = '';
+
+    if (config.includeLowercase) {
+      charset += 'abcdefghijklmnopqrstuvwxyz';
+    }
+
+    if (config.includeUppercase) {
+      charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    }
+
+    if (config.includeNumbers) {
+      charset += '0123456789';
+    }
+
+    if (config.includeSpecialChars) {
+      charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';
+    }
+
+    if (config.excludeSimilar) {
+      charset = charset.replace(/[il1Lo0O]/g, '');
+    }
+
+    if (charset.length === 0) {
+      throw new Error('At least one character type must be included');
+    }
+
+    let password = '';
+    for (let i = 0; i < config.length; i++) {
+      password += charset.charAt(Math.floor(Math.random() * charset.length));
+    }
+
+    return password;
+  }
+}
+
+module.exports = Bcrypt;