@ecopex/ecopex-framework 1.0.0

package/libraries/controls.js

@@ -0,0 +1,113 @@
+const emailValidation = (email = '') => {
+    return String(email).toLowerCase().match(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/);
+}
+
+const phoneValidation = (phone = '') => {
+    return String(phone).match(/^[\+]?([0-9][\s]?|[0-9]?)([(][0-9]{3}[)][\s]?|[0-9]{3}[-\s\.]?)[0-9]{3}[-\s\.]?[0-9]{4,6}$/im);
+}
+
+function randomChars(length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+
+const randomNumber = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+
+function getIpAddress(req = {}) {
+    return req.headers['x-forwarded-for'] ||
+        req.socket.remoteAddress ||
+        null;
+}
+
+const roundTo = (n, digits) => {
+    if (digits === undefined) {
+        digits = 0;
+    }
+
+    var multiplicator = Math.pow(10, digits);
+    n = parseFloat((n * multiplicator).toFixed(11));
+    var test =(Math.round(n) / multiplicator);
+    return +(test.toFixed(digits));
+}
+
+function validateLatLng(lat, lng) {
+    let pattern = new RegExp('^-?([1-8]?[1-9]|[1-9]0)\\.{1}\\d{1,6}');
+
+    return pattern.test(lat) && pattern.test(lng);
+}
+
+const checkCoordinates = (address, paths) => {
+
+    if (paths) {
+
+        const allPaths = paths.c[0].reduce((o, n) => {
+            o.lngs.push(parseFloat(n.lng));
+            o.lats.push(parseFloat(n.lat));
+            return o
+        }, { lngs: [], lats: [] })
+
+        const minimumLng = Math.min(...allPaths.lngs)
+        const maximumLng = Math.max(...allPaths.lngs)
+        const minimumLat = Math.min(...allPaths.lats)
+        const maximumLat = Math.max(...allPaths.lats)
+
+        if (parseFloat(address.lng) >= minimumLng && parseFloat(address.lng) <= maximumLng && parseFloat(address.lat) >= minimumLat && parseFloat(address.lat) <= maximumLat) {
+            return true
+        } else {
+            return false
+        }
+
+    } else {
+        return false
+    }
+
+}
+
+const checkPassoword = (password) => {
+    return /^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])\S{8,}$/.test(password)
+}
+
+const sleep = async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+const ipcheck = (req, whitelists = '') => {
+
+    const client_ip = req.headers['cf-connecting-ip'] || (req.headers['x-real-ip'] || req.ip)
+
+    // whitelist split
+    const whiteips = typeof whitelists === 'string' && whitelists != '' ? whitelists.split(',').map(n => n.trim()) : []
+
+    const status = whiteips.length > 0 ? whiteips.includes(client_ip) : true
+
+    if(!status) {
+        console.error(client_ip, whiteips, req.headers);
+    }
+
+    // check if exists
+    return {
+        status: status,
+        client_ip: client_ip
+    }
+}
+
+module.exports = {
+    emailValidation,
+    phoneValidation,
+    randomChars,
+    randomNumber,
+    validateLatLng,
+    checkCoordinates,
+    getIpAddress,
+    checkPassoword,
+    ipcheck,
+    sleep,
+    roundTo
+}

package/libraries/date.js

@@ -0,0 +1,14 @@
+const dayjs = require('dayjs');
+const utc = require('dayjs/plugin/utc')
+const timezone = require("dayjs/plugin/timezone");
+dayjs.extend(utc)
+dayjs.extend(timezone)
+
+const getUtcFormated = (date = new Date()) => {
+    return dayjs(date).utc().format('YYYY-MM-DD HH:mm:ss')
+}
+
+module.exports = {
+    getUtcFormated,
+    dayjs
+}

package/libraries/general.js

@@ -0,0 +1,8 @@
+// title case a string
+const titleCase = (str) => {
+    return str.replace(/_/g, ' ').replace(/\b\w/g, char => char.toUpperCase());
+}
+
+module.exports = {
+    titleCase
+}

package/libraries/image.js

@@ -0,0 +1,57 @@
+const resizer = require('node-image-resizer');
+const basePath = __dirname + '../uploads/'
+
+let resizerOpts = {
+    all: {
+        path: basePath + 'thumbnails/',
+        quality: 80
+    },
+    versions: [{
+        prefix: '',
+        width: 800,
+        height: 800
+    }]
+}
+
+const resize = async (filePath, resizeSetup = false, quality = 80, directory = false) => {
+
+    if(directory) {
+        resizerOpts.all.path = basePath + directory + '/'
+    }
+
+    const resizeOptsAll = JSON.parse(JSON.stringify(resizerOpts))
+    resizeOptsAll.all.quality = quality
+
+    if (resizeSetup) {
+        resizeOptsAll.versions = resizeSetup.reduce((o,n) => {
+            const version = Object.assign({}, resizeOptsAll.versions[0], n)
+            version.prefix = 'resize_' + version.width + 'x' + version.height + '_'
+            o.push(version)
+            return o
+        }, [])
+    }
+
+    try {
+        const resizedImages = await resizer(basePath + filePath, resizeOptsAll);
+
+        return {
+            status: true,
+            files: resizedImages.reduce((o,n,k) => {
+                o.push({
+                    width: resizeOptsAll.versions[k].width,
+                    height: resizeOptsAll.versions[k].height,
+                    fileUrl: n.replace(basePath, '')
+                })
+                return o
+            },[])
+        };
+    } catch (error) {
+        return {
+            status: false
+        }
+    }
+}
+
+module.exports = {
+    resize
+}

package/libraries/jwt.js

@@ -0,0 +1,178 @@
+const jwt = require('jsonwebtoken');
+
+/**
+ * JWT Library Class
+ * Provides methods for JWT token operations including sign, verify, and decode
+ */
+class JWT {
+  constructor(secretKey = process.env.JWT_SECRET || 'default-secret-key') {
+    this.secretKey = secretKey;
+    this.defaultExpiresIn = '1d';
+  }
+
+  /**
+   * Sign a payload and create a JWT token
+   * @param {Object} payload - The payload to encode
+   * @param {Object} options - JWT options (expiresIn, algorithm, etc.)
+   * @returns {string} JWT token
+   */
+  sign(payload, options = {}) {
+    try {
+      const defaultOptions = {
+        expiresIn: this.defaultExpiresIn,
+        algorithm: 'HS256'
+      };
+
+      const signOptions = { ...defaultOptions, ...options };
+      
+      return jwt.sign(payload, this.secretKey, signOptions);
+    } catch (error) {
+      throw new Error(`JWT Sign Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Verify and decode a JWT token
+   * @param {string} token - The JWT token to verify
+   * @param {Object} options - Verification options
+   * @returns {Object} Decoded payload
+   */
+  verify(token, options = {}) {
+    try {
+      const verifyOptions = {
+        algorithms: ['HS256'],
+        ...options
+      };
+      
+      return jwt.verify(token, this.secretKey, verifyOptions);
+    } catch (error) {
+      if (error.name === 'TokenExpiredError') {
+        return false;
+      } else if (error.name === 'JsonWebTokenError') {
+        return false;
+      } else if (error.name === 'NotBeforeError') {
+        return false;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  /**
+   * Decode a JWT token without verification
+   * @param {string} token - The JWT token to decode
+   * @param {Object} options - Decode options
+   * @returns {Object} Decoded payload (not verified)
+   */
+  decode(token, options = {}) {
+    try {
+      return jwt.decode(token, options);
+    } catch (error) {
+      throw new Error(`JWT Decode Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a token is expired without throwing an error
+   * @param {string} token - The JWT token to check
+   * @returns {boolean} True if token is expired, false otherwise
+   */
+  isExpired(token) {
+    try {
+      const decoded = this.decode(token);
+      if (!decoded || !decoded.exp) {
+        return true;
+      }
+      
+      const currentTime = Math.floor(Date.now() / 1000);
+      return decoded.exp < currentTime;
+    } catch (error) {
+      return true;
+    }
+  }
+
+  /**
+   * Get token expiration time
+   * @param {string} token - The JWT token
+   * @returns {Date|null} Expiration date or null if invalid
+   */
+  getExpirationTime(token) {
+    try {
+      const decoded = this.decode(token);
+      if (!decoded || !decoded.exp) {
+        return null;
+      }
+      
+      return new Date(decoded.exp * 1000);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Refresh a token by creating a new one with the same payload
+   * @param {string} token - The JWT token to refresh
+   * @param {Object} options - New token options
+   * @returns {string} New JWT token
+   */
+  refresh(token, options = {}) {
+    try {
+      const decoded = this.verify(token);
+      
+      // Remove standard JWT claims that shouldn't be copied
+      const { iat, exp, nbf, jti, ...payload } = decoded;
+      
+      return this.sign(payload, options);
+    } catch (error) {
+      throw new Error(`JWT Refresh Error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a token with custom expiration
+   * @param {Object} payload - The payload to encode
+   * @param {string|number} expiresIn - Expiration time (e.g., '1h', '7d', 3600)
+   * @returns {string} JWT token
+   */
+  createToken(payload, expiresIn = this.defaultExpiresIn) {
+    return this.sign(payload, { expiresIn });
+  }
+
+  /**
+   * Create a short-lived token (e.g., for email verification)
+   * @param {Object} payload - The payload to encode
+   * @param {string|number} expiresIn - Expiration time (default: '15m')
+   * @returns {string} JWT token
+   */
+  createShortToken(payload, expiresIn = '15m') {
+    return this.sign(payload, { expiresIn });
+  }
+
+  /**
+   * Create a long-lived token (e.g., for refresh tokens)
+   * @param {Object} payload - The payload to encode
+   * @param {string|number} expiresIn - Expiration time (default: '30d')
+   * @returns {string} JWT token
+   */
+  createLongToken(payload, expiresIn = '30d') {
+    return this.sign(payload, { expiresIn });
+  }
+
+  /**
+   * Set a new secret key
+   * @param {string} secretKey - New secret key
+   */
+  setSecretKey(secretKey) {
+    this.secretKey = secretKey;
+  }
+
+  /**
+   * Get the current secret key (masked for security)
+   * @returns {string} Masked secret key
+   */
+  getSecretKey() {
+    return this.secretKey ? `${this.secretKey.substring(0, 4)}...` : 'Not set';
+  }
+}
+
+module.exports = JWT;

package/libraries/knex.js

@@ -0,0 +1,7 @@
+const knex = require('knex');
+
+const config = require('@root/config/database');
+
+const db = knex(config[process.env.NODE_ENV || 'development']);
+
+module.exports = db;

package/libraries/slug.js

@@ -0,0 +1,14 @@
+const slugify = require('slugify')
+
+const returnSlug = (title = "") => {
+    return slugify(title.toLowerCase(), {
+        replacement: '-',  // replace spaces with replacement character, defaults to `-`
+        remove: undefined, // remove characters that match regex, defaults to `undefined`
+        lower: false,      // convert to lower case, defaults to `false`
+        strict: false,     // strip special characters except replacement, defaults to `false`
+        locale: 'en',      // language code of the locale to use
+        trim: true         // trim leading and trailing replacement chars, defaults to `true`
+    })
+}
+
+module.exports = returnSlug

package/libraries/stores.js

@@ -0,0 +1,22 @@
+const db = require('@root/libraries/knex');
+
+class Store {
+    constructor() {
+        this.db = db;
+        this.currencies = new Map();
+    }
+
+    async init() {
+        await this.get_currencies();
+    }
+
+    async get_currencies() {
+        const currencies = await this.db('currencies').select('currency_id', 'name', 'code', 'symbol');
+        currencies.forEach(currency => {
+            this.currencies.set(currency.currency_id, currency);
+        });
+        return this.currencies;
+    }
+}
+
+module.exports = new Store();

package/libraries/upload.js

@@ -0,0 +1,194 @@
+const fs = require('fs');
+const axios = require('axios');
+const { randomChars, sleep } = require('./controls');
+const uploadBase = __dirname + '/../uploads/'
+const { resize: resizeImage } = require('./image')
+const sizeOf = require('image-size');
+const returnSlug = require('./slug')
+const { uploadAws } = require('./aws');
+
+const uploadFile = async (fileObject = {}, prefix = '', directory = '', resizeOpts = false) => {
+
+    try {
+
+        if (directory != '' && !fs.existsSync(uploadBase + directory)) {
+            await fs.mkdirSync(uploadBase + directory);
+        }
+        
+        let fileExt = fileObject.filename.split('.')
+        fileExt = fileExt[fileExt.length - 1];
+        const fileName = returnSlug((prefix != '' ? prefix + '_' : '') + '_' + randomChars(16)) + '.' + fileExt
+        directory = directory != '' ? directory + '/' : ''
+
+        await fs.writeFileSync(uploadBase + directory + fileName, fileObject._buf)
+
+        return await createReturnData(fileName, directory, resizeOpts, fileObject)
+
+    } catch (error) {
+        return {
+            status: false,
+            error
+        }
+
+    }
+
+}
+
+const createReturnData = async (fileName = '', directory = '', resizeOpts = false, fileObject = false) => {
+
+    let returnData = {
+        status: false
+    }
+
+    let awsError = false
+
+    if (resizeOpts) {
+        returnData = await resizeImage(directory + fileName, resizeOpts, 90, directory.replace(/\//g, ''))
+        returnData.resize = true
+    } else {
+        let dimensions = {}
+
+        if(fileObject && fileObject.mimetype.includes('image')) {
+            try {
+                dimensions = sizeOf(uploadBase + directory + fileName)
+            } catch (error) {
+                dimensions = {}
+            }
+        }
+
+        returnData = {
+            status: true,
+            resize: false,
+            file: {
+                width: dimensions.width || 'none',
+                height: dimensions.height || 'none',
+                field: fileObject.fieldname,
+                encoding: fileObject.encoding,
+                mimetype: fileObject.mimetype,
+                fileUrl: directory + fileName
+            }
+        }
+    }
+
+    if(process.env.AWS_STATUS == 'true') {
+
+        await sleep(1000);
+
+        if (returnData.resize) {
+            if (returnData.files.length > 0) {
+                for (let rfi = 0; rfi < returnData.files.length; rfi++) {
+                    const file = returnData.files[rfi];
+                    let statusUploadAws = await uploadAws(file.fileUrl, fileObject.mimetype)
+                    
+                    if(!statusUploadAws.status) {
+                        awsError = {
+                            status: false,
+                            msg: "aws_upload_error"
+                        }
+                    }
+                    
+                    fs.unlinkSync(uploadBase + file.fileUrl)
+                }
+            }
+        } else {
+            let statusUploadAws = await uploadAws(returnData.file.fileUrl, returnData.file.mimetype)
+
+            if (!statusUploadAws.status) {
+                awsError = {
+                    status: false,
+                    messages: "aws_upload_error"
+                }
+            }
+            fs.unlinkSync(uploadBase + returnData.file.fileUrl)
+        }
+    }
+
+    if (returnData.resize) {
+        fs.unlinkSync(uploadBase + directory + fileName)
+    }
+    
+    if(awsError) {
+        return awsError
+    } else {
+        return returnData
+    }
+
+}
+
+const downloadFile = async (fileUrl = "", directory = '') => {
+
+    try {
+
+        if (directory != '' && !fs.existsSync(uploadBase + directory)) {
+            await fs.mkdirSync(uploadBase + directory);
+        }
+
+        const fileName = randomChars(3) + new Date().getTime() + '.jpg'
+        directory = directory != '' ? directory + '/' : ''
+
+        const writer = await fs.createWriteStream(uploadBase + directory + fileName);
+
+        axios({
+            method: 'GET',
+            url: fileUrl,
+            responseType: 'stream',
+        }).then(response => {
+
+            //ensure that the user can call `then()` only when the file has
+            //been downloaded entirely.
+
+            return new Promise((resolve, reject) => {
+
+                response.data.pipe(writer);
+                let error = null;
+
+                writer.on('error', err => {
+                    error = err;
+                    writer.close();
+                    reject(err);
+                });
+
+                writer.on('close', () => {
+                    if (!error) {
+                    resolve(true);
+                    }
+                    //no need to call the reject here, as it will have been called in the
+                    //'error' stream;
+                });
+            });
+        });
+
+        return createReturnData(fileName, directory, false)
+
+    } catch (error) {
+        return {
+            status: false,
+            messages: error
+        }
+    }
+}
+
+const deleteFile = async (fileName = '') => {
+
+    try {
+
+        if (fs.existsSync(uploadBase + fileName)) {
+            await fs.unlinkSync(uploadBase + fileName)
+        }
+        
+        return {
+            status: true
+        }
+    } catch (error) {
+        return {
+            status: false
+        }
+    }
+
+}
+
+module.exports = {
+    uploadFile,
+    downloadFile,
+    deleteFile
+}

package/locales/en/messages.json

@@ -0,0 +1,4 @@
+{
+    "record_not_found": "Record not found",
+    "internal_server_error": "Internal server error"
+}

package/locales/en/sql.json

@@ -0,0 +1,3 @@
+{
+    "er_dup_entry": "Duplicate entry"
+}

package/locales/en/validation.json

@@ -0,0 +1,52 @@
+{
+  "validation": {
+    "required": "The field '{field}' is required",
+    "minLength": "The field '{field}' must be at least {min} characters long",
+    "maxLength": "The field '{field}' must be at most {max} characters long",
+    "min": "The field '{field}' must be at least {min}",
+    "max": "The field '{field}' must be at most {max}",
+    "email": "The field '{field}' must be a valid email address",
+    "integer": "The field '{field}' must be an integer",
+    "string": "The field '{field}' must be a string",
+    "boolean": "The field '{field}' must be a boolean",
+    "enum": "The field '{field}' must be one of: {enum}",
+    "format": "The field '{field}' format is invalid",
+    "pattern": "The field '{field}' does not match the required pattern",
+    "unique": "The field '{field}' must be unique",
+    "exists": "The field '{field}' does not exist",
+    "invalid": "The field '{field}' is invalid",
+    "tooShort": "The field '{field}' is too short",
+    "tooLong": "The field '{field}' is too long",
+    "invalidEmail": "Please provide a valid email address",
+    "weakPassword": "Password must be at least 6 characters long",
+    "invalidRole": "Role must be one of: admin, user, moderator"
+  },
+  "errors": {
+    "validation": "Validation Error",
+    "server": "Internal Server Error",
+    "notFound": "Resource not found",
+    "unauthorized": "Unauthorized access",
+    "forbidden": "Access forbidden",
+    "conflict": "Resource conflict",
+    "badRequest": "Bad Request"
+  },
+  "messages": {
+    "userCreated": "User created successfully",
+    "userUpdated": "User updated successfully",
+    "userDeleted": "User deleted successfully",
+    "userNotFound": "User not found",
+    "emailExists": "Email already exists",
+    "invalidCredentials": "Invalid credentials",
+    "accessDenied": "Access denied",
+    "languageChanged": "Language changed to {language}",
+    "adminCreated": "Admin created successfully",
+    "adminUpdated": "Admin updated successfully",
+    "adminDeleted": "Admin deleted successfully",
+    "adminNotFound": "Admin not found",
+    "twoFactorEnabled": "Two-factor authentication enabled",
+    "twoFactorDisabled": "Two-factor authentication disabled",
+    "phoneVerified": "Phone number verified successfully",
+    "invalidVerificationCode": "Invalid verification code",
+    "verificationCodeExpired": "Verification code has expired"
+  }
+}