@nka212bg/backend-utils 0.1.0

package/misc.js

@@ -0,0 +1,463 @@
+const { existsSync, mkdirSync, readdirSync, readFileSync, readFile, statSync, copyFile, copyFileSync, unlink, unlinkSync, rmdirSync, lstatSync } = require("fs");
+const sharp = require("sharp");
+
+exports.slugFormatter = (text) => {
+    text = (text || "")
+        .toLowerCase()
+        .replace(/%n|%y/g, " ")
+        .replace(/([^\d\p{L}-]| )+/gu, " ")
+        .trim()
+        .replace(/\s+/g, "-");
+
+    return text;
+};
+
+exports.cookies = ({ cookies, ...options }) => {
+    return {
+        get(key) {
+            // const cookies = Object.fromEntries(new URLSearchParams(document.cookie.replace(/; /g, "&")));
+            const cookies = JSON.parse(`{"${req.headers?.cookie.replace(/=/g, '":"').replace(/; /g, '","')}"}`);
+            return key ? cookies[key] : cookies;
+        },
+        set({ key, value, domain, path, age = 99999999 }) {
+            let cookie = `${key}=${value}; max-age=${age};`;
+
+            path = path || options.path || "/";
+            cookie += ` Path=${path};`;
+
+            domain = domain || options.domain || location.hostname;
+            cookie += ` Domain=${domain};`;
+
+            if (options.sameSite) cookie += ` SameSite=${options.sameSite};`;
+            if (options.partitioned) cookie += ` Partitioned;`;
+            if (options.secure) cookie += ` Secure;`;
+
+            document.cookie = cookie;
+        },
+        remove({ key, domain, path = "/" }) {
+            let cookie = `${key}=; expires=Sat, Jan 01 2022 00:00:00 UTC;`;
+
+            path = path || options.path || "/";
+            cookie += ` Path=${path};`;
+
+            domain = domain || options.domain || location.hostname;
+            cookie += ` Domain=${domain};`;
+
+            if (options.sameSite) cookie += ` SameSite=${options.sameSite};`;
+            if (options.partitioned) cookie += ` Partitioned;`;
+            if (options.secure) cookie += ` Secure;`;
+
+            document.cookie = cookie;
+        },
+    };
+};
+
+exports.codeSnippet = (text, { color = "brown" } = {}) => {
+    const props = {
+        _sl_: { exp: "<\\/", color: null, code: "&lt;&#47;" },
+        _sr_: { exp: "\\/>", color: null, code: "&#47;&gt;" },
+        _docStart_: { exp: "<!", color: null, code: "&lt;!" },
+        _lt_: { exp: "<", color: null, code: "&lt;" },
+        _gt_: { exp: ">", color: null, code: "&gt;" },
+        _op_: { exp: "\\(", color: null, code: "&#40;" },
+        _cp_: { exp: "\\)", color: null, code: "&#41;" },
+        _sq_: { exp: "'", color: null, code: "&apos;" },
+        _dq_: { exp: '"', color: null, code: "&quot;" },
+        "src=": { exp: "src=", color: null, code: null },
+        // _eq_: { exp: "=", color: null, code: "&#61;" },
+    };
+
+    Object.keys(props).forEach((e) => {
+        text = text.replace(RegExp(props[e].exp, "g"), e);
+    });
+
+    Object.keys(props).forEach((e) => {
+        text = text.replace(RegExp(e, "g"), `<span style="color: ${props[e].color || color}">${props[e].code || e}</span>`);
+    });
+
+    // text = text.replace(/(<\w[^>]*>|<\/[^>]+>)/g, `<span style="color: ${color}">$1</span>`);
+    text = text.replace(/(\.{2,})+/g, `<span style="color: ${color}">$1</span>`);
+
+    return text;
+};
+
+exports.createToken = ({ length = 14, type } = {}) => {
+    const chars = "ABCDQFGHIJKLMNOPQRSTUVWXYZabcdqfghijklmnopqrstuvwxyz";
+    const nums = "1234567890";
+
+    if (type == "number") return mixer(nums, length);
+    if (type == "date") return mixer(chars, 1) + mixer(nums + chars + nums, length - 7) + parseInt(Date.now() / 100000000) + mixer(chars, 1);
+    return mixer(chars, 1) + mixer(nums + chars + nums, length - 2) + mixer(chars, 1);
+
+    function mixer(string, length) {
+        if (string.length > length) string = string + string;
+
+        return string
+            .split("")
+            .sort(() => 0.5 - Math.random())
+            .join("")
+            .substring(0, length);
+    }
+};
+
+exports.handlebars = ({ template, ...params } = {}) => {
+    const placeholders = template.match(/(\{\{)(.*?)(\}\})/g);
+
+    for (const p in params) {
+        const placeholder = placeholders.find((e) => e.includes(p));
+        if (!placeholder) continue;
+
+        template = template.replace(RegExp(placeholder, "g"), params[p]);
+    }
+
+    return template;
+};
+
+exports.shortCount = (value, type) => {
+    value = Number(value);
+    if (isNaN(value)) return value;
+
+    let units = {
+        trillion: "T",
+        billion: "B",
+        million: "M",
+        thousand: "K",
+    };
+
+    if (type == "disk") {
+        units = {
+            trillion: " tb",
+            billion: " gb",
+            million: " mb",
+            thousand: " kb",
+        };
+    }
+
+    if (value > 1000000000000) return (value / 1000000000000).toFixed(1) + units.trillion;
+    if (value > 1000000000) return (value / 1000000000).toFixed(1) + units.billion;
+    if (value > 1000000) return (value / 1000000).toFixed(1) + units.million;
+    if (value > 1000) return (value / 1000).toFixed(1) + units.thousand;
+    return value + (type == "disk" ? " bites" : "");
+};
+
+exports.saveFile = (file, destinationPath, callback) => {
+    const path = destinationPath.replace(/[^/]+$/, "");
+    !existsSync(path) && mkdirSync(path, { recursive: true });
+
+    copyFile(file, destinationPath, (err) => {
+        callback && callback(err);
+        setTimeout(() => unlink(file, (err) => err && console.log(err)), 10000);
+    });
+};
+
+exports.fileServe = ({ filePath, res, download, img } = {}) => {
+    readFile(filePath, (error, file) => {
+        if (error) return res.status(404).end();
+        if (img && file.includes("/svg")) res.setHeader("Content-Type", "image/svg+xml");
+
+        download ? res.download(filePath) : res.end(file);
+    });
+};
+
+// { file: files[file], writePath: imagePath, width: 200, height: 200, type: "jpeg" }
+exports.saveImage = ({ file, writePath, width, height, loop = 0, quality = 85, maxSize = 200, type }) => {
+    file.sizeKb = file.size / 1000;
+    let animated = true;
+
+    // console.log("file.sizeKb  --> ", file.sizeKb);
+    // console.log("file.type  --> ", file.type);
+
+    if (file.sizeKb > maxSize) animated = false;
+
+    if (!type && file.mimetype.includes("svg")) {
+        this.saveFile(file.filepath, writePath);
+        return {};
+    }
+
+    return new Promise(async (resolve) => {
+        try {
+            const path = writePath.replace(/[^/]+$/, "");
+            !existsSync(path) && mkdirSync(path, { recursive: true });
+
+            const img = sharp(file.filepath, { animated });
+            const metaData = await img.metadata();
+
+            if (!type) type = metaData.format;
+            if (/jpe?g/gi.test(type)) img.flatten({ background: "#ffffff" });
+
+            // resize
+            if (width || height) {
+                if (metaData.height < height || metaData.width > metaData.height) height = undefined;
+                if (metaData.width < width || metaData.width < metaData.height) width = undefined;
+
+                img.resize({
+                    width,
+                    height,
+                });
+            }
+
+            // type
+            img[type]({ quality, mozjpeg: true, loop });
+
+            img.withMetadata();
+
+            img.toFile(writePath, (error) => {
+                resolve({ error });
+                setTimeout(() => unlink(file.filepath, (err) => err && console.error(err)), 10000);
+            });
+        } catch (error) {
+            resolve({ error });
+        }
+    });
+};
+
+// Delete files or dirs recursive
+exports.deleteFolder = (path, pathTemp) => {
+    if (existsSync(path)) {
+        if (lstatSync(path).isDirectory()) {
+            var files = readdirSync(path);
+            if (!files.length) return rmdirSync(path);
+            for (var file in files) {
+                var currentPath = path + "/" + files[file];
+                if (!existsSync(currentPath)) continue;
+                if (lstatSync(currentPath).isFile()) {
+                    unlinkSync(currentPath);
+                    continue;
+                }
+                if (lstatSync(currentPath).isDirectory() && !readdirSync(currentPath).length) {
+                    rmdirSync(currentPath);
+                } else {
+                    this.deleteFolder(path + "/" + files[file], path);
+                }
+            }
+            this.deleteFolder(path);
+        } else {
+            unlinkSync(path);
+        }
+    }
+    if (pathTemp) this.deleteFolder(pathTemp);
+};
+
+exports.copyFolder = (source, destination) => {
+    if (!existsSync(destination)) mkdirSync(destination, { recursive: true });
+
+    readdirSync(source).forEach((item) => {
+        const sourcePath = `${source}/${item}`;
+        const destinationPath = `${destination}/${item}`;
+
+        if (lstatSync(sourcePath).isDirectory()) {
+            this.copyFolder(sourcePath, destinationPath);
+        } else {
+            copyFileSync(sourcePath, destinationPath);
+        }
+    });
+};
+
+exports.dirSize = (path) => {
+    let size = 0;
+    try {
+        const rootStat = statSync(path);
+        if (rootStat.isFile()) return rootStat.size;
+
+        const files = readdirSync(path);
+
+        for (const file of files || []) {
+            const filePath = path + "/" + file;
+            const stats = statSync(filePath);
+
+            if (stats.isFile()) {
+                size += stats.size;
+            } else if (stats.isDirectory()) {
+                size += this.dirSize(filePath);
+            }
+        }
+    } catch {}
+
+    return size;
+};
+
+exports.arrayToObject = (obj, objKey) => {
+    if (!Array.isArray(obj) || !objKey) return obj;
+
+    const temp = {};
+    obj.forEach((objectItem) => {
+        temp[objectItem[objKey]] = objectItem;
+    });
+    return temp;
+};
+
+exports.fileBase64 = (filePath) => {
+    try {
+        return readFileSync(filePath, { encoding: "base64" });
+    } catch (error) {
+        return "#";
+    }
+};
+
+exports.newURL = (url) => {
+    url = new URL(url);
+    url = {
+        href: url.href,
+        origin: url.origin,
+        protocol: url.protocol,
+        host: url.host,
+        hostname: url.hostname,
+        port: url.port,
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash,
+        referer: url.hostname.replace(/^www\./, ""),
+    };
+
+    if (url.port) url.referer += `_port_${url.port}`;
+
+    return url;
+};
+
+exports.crypto = ({ salt, embedSalt } = {}) => {
+    salt = String(salt).trim();
+    const createToken = this.createToken;
+
+    return {
+        do(string) {
+            try {
+                string = JSON.stringify(string);
+            } catch {
+                string = String(string);
+            }
+
+            let encripted = encodeURIComponent(string).split("").map(textToChars).map(applySaltToChar).map(byteHex).join("");
+
+            if (embedSalt) {
+                const pos = Math.floor(Math.random() * encripted.length);
+                const embed = `hWg${createToken({ length: Math.floor(Math.random() * 40) + 10 })}rtFg${salt}gdS${createToken({ length: Math.floor(Math.random() * 40) + 10 })}Ire`;
+
+                encripted = encripted.substring(0, pos) + embed + encripted.substring(pos);
+            }
+
+            return encripted;
+        },
+        undo(string) {
+            // TODO pattern in .env
+            const tokenPattern = /hWg(.*)rtFg(.*)gdS(.*)Ire/;
+            let token;
+
+            if (tokenPattern.test(string)) {
+                token = string.match(tokenPattern)?.[2];
+                string = string.replace(tokenPattern, "");
+                salt = token;
+            }
+
+            try {
+                string = string.trim();
+
+                const decodedString = string
+                    .match(/.{1,2}/g)
+                    .map((hex) => parseInt(hex, 16))
+                    .map(applySaltToChar)
+                    .map((charCode) => String.fromCharCode(charCode))
+                    .join("");
+
+                let data = decodeURIComponent(decodedString);
+
+                try {
+                    data = JSON.parse(data);
+                } catch {}
+
+                return { data, token };
+            } catch (error) {
+                return { error: "wrong_salt" };
+            }
+        },
+    };
+
+    function textToChars(text) {
+        return text.split("").map((c) => c.charCodeAt(0));
+    }
+
+    function applySaltToChar(code) {
+        return textToChars(salt).reduce((a, b) => a ^ b, code);
+    }
+
+    function byteHex(n) {
+        return ("0" + Number(n).toString(16)).slice(-2);
+    }
+};
+
+exports.secToTime = (seconds) => {
+    if (!(seconds = parseInt(seconds))) return;
+
+    const years = seconds / 60 / 60 / 24 / 30.5 / 12;
+    const months = seconds / 60 / 60 / 24 / 30.5;
+    const days = seconds / 60 / 60 / 24;
+    const hours = seconds / 60 / 60;
+    const minutes = seconds / 60;
+    seconds = parseInt(seconds % 60);
+
+    if (years >= 1) return parseInt(years) + "y " + parseInt(months % 12) + "m " + parseInt(days % 30.5) + "d";
+    if (months >= 1) return parseInt(months) + "m " + parseInt(days % 30.5) + "d " + parseInt(hours % 24) + "h";
+    if (days >= 1) return parseInt(days) + "d " + parseInt(hours % 24) + "h";
+    if (hours >= 1) return parseInt(hours) + "h " + doMinutes(minutes) + "min";
+    return parseInt(minutes) + "min " + (seconds < 10 ? "0" + seconds : seconds) + "s";
+
+    function doMinutes(minutes) {
+        minutes = parseInt(minutes % 60);
+        return minutes < 10 ? "0" + minutes : minutes;
+    }
+};
+
+exports.urlMetadata = async ({ url }) => {
+    let fileExtension, dataType, body;
+
+    try {
+        const tempUrl = new URL(url);
+        const fxIndex = tempUrl.pathname.lastIndexOf(".");
+        fileExtension = fxIndex < 0 ? null : tempUrl.pathname.substring(fxIndex + 1)?.match(/\w+/)[0];
+
+        let fetchRes = await fetch(url);
+
+        const sizeKb = parseInt(Number(fetchRes.headers?.get("content-length")) / 1000);
+        let contentType = fetchRes.headers?.get("content-type")?.split("/") || [];
+        let contentGroup = contentType[0];
+        let fileType = contentType[1]?.match(/[\w+.-]+/)[0];
+
+        contentType = `${contentGroup}/${fileType}`;
+
+        if (/html|xhtml/.test(fileType)) {
+            dataType = "html";
+        } else if (/image|audio|video|application/.test(contentGroup) && !/^xml|json|javascript/.test(fileType)) {
+            dataType = "dataSrc";
+        } else {
+            dataType = "plain";
+        }
+
+        if (sizeKb > 2000) {
+            body = "";
+        } else if (dataType == "dataSrc") {
+            body = await fetchRes.arrayBuffer();
+
+            var binary = "";
+            var bytes = new Uint8Array(body);
+            var len = bytes.byteLength;
+            for (var i = 0; i < len; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+
+            body = `data:${contentType};base64,` + btoa(binary);
+        } else {
+            body = await fetchRes.text();
+
+            try {
+                body = JSON.parse(body);
+                contentType = "application/json";
+                contentGroup = "application";
+                fileType = "json";
+                dataType = "json";
+            } catch {}
+        }
+
+        return { data: { contentType, contentGroup, fileType, dataType, sizeKb, fileExtension, body } };
+    } catch (error) {
+        return { error: String(error) };
+    }
+};

package/os.js

@@ -0,0 +1,53 @@
+const si = require("systeminformation");
+const osUtils = require("os-utils");
+const os = require("os");
+const { statfsSync } = require("fs");
+const { shortCount, secToTime } = require("./misc");
+
+let cpuUsage, temperature;
+const serverStart = Date.now();
+
+exports.osStatus = () => {
+    const now = Date.now();
+
+    try {
+        return {
+            serverUptime: secToTime((now - serverStart) / 1000),
+            machineUptime: secToTime(os.uptime()),
+            memoryUsage: shortCount(os.totalmem() - os.freemem(), "disk"),
+            freeMemory: shortCount(os.freemem(), "disk"),
+            totalMemory: shortCount(os.totalmem(), "disk"),
+            os: os.type(),
+            hostname: os.hostname(),
+            temperature,
+            cpuUsage: cpuUsage + "%",
+            ...diskSpace(__basedir),
+        };
+    } catch (error) {
+        console.log("error --> ", error);
+        return { error };
+    }
+};
+
+setInterval(handleInterval, 1000 * 30);
+
+function handleInterval() {
+    osUtils.cpuUsage((v) => {
+        cpuUsage = Math.ceil(v * 100);
+    });
+
+    si.cpuTemperature().then((tmp) => {
+        temperature = Number(tmp.main?.toFixed(2));
+    });
+}
+
+function diskSpace(path = "/") {
+    const space = statfsSync(path);
+
+    return {
+        disk_user_available: shortCount(space.bsize * space.bavail, "disk"),
+        disk_total_available: shortCount(space.bsize * space.bfree, "disk"),
+        disk_capacity: shortCount(space.bsize * space.blocks, "disk"),
+        disk_files: shortCount(space.files),
+    };
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "@nka212bg/backend-utils",
+    "author": "nka212bg",
+    "version": "0.1.0",
+    "repository": {
+        "type": "git",
+        "url": "https://gitlab.com/nka212bg/npm-backend.git"
+    },
+    "keywords": [
+        "misc"
+    ],
+    "dependencies": {
+        "@maxmind/geoip2-node": "^5.0.0",
+        "systeminformation": "^5.21.24",
+        "nodemailer": "^6.9.14",
+        "os-utils": "^0.0.14",
+        "stripe": "^14.23.0",
+        "mysql2": "^3.11.0",
+        "sqlite3": "^5.1.7",
+        "sharp": "^0.33.5",
+        "ws": "^7.3.0"
+    }
+}

package/session.js

@@ -0,0 +1,145 @@
+const { existsSync, readFileSync, writeFileSync } = require("fs");
+
+const sessionStateFile = `${__basedir}/state/session.json`;
+const SESSION = existsSync(sessionStateFile) ? JSON.parse(readFileSync(sessionStateFile, "utf8") || "{}") : {};
+
+setInterval(() => {
+    // delete expired sessions
+    const now = Date.now();
+    Object.keys(SESSION).forEach((e) => {
+        SESSION[e].expireTime < now && delete SESSION[e];
+    });
+
+    // save the sessions in file
+    writeFileSync(sessionStateFile, JSON.stringify(SESSION));
+}, 60000);
+
+// session C.R.U.D.
+exports.session = {
+    set(payload = {}) {
+        // payload.set => {token: 23456546, whatever: 'someValue', whatever_2: 'someValue'}
+        if (!payload.token) return { error: "missing_token" };
+
+        const token = payload.token;
+        delete payload.token;
+
+        if (!Object.keys(payload).length) return { error: "empty_payload" };
+
+        const now = Date.now();
+
+        if (SESSION[token]) {
+            if (payload.expirePeriod) SESSION[token].expireTime = now + payload.expirePeriod;
+
+            SESSION[token] = { ...SESSION[token], ...payload };
+            return;
+        }
+
+        if (!payload.expirePeriod) payload.expirePeriod = 60000 * 60 * 24 * 7; // 7days
+        payload.expireTime = now + payload.expirePeriod;
+
+        SESSION[token] = payload;
+        return { ...payload, expireIn: payload.expirePeriod + 60000 };
+    },
+
+    get(payload = {}) {
+        if ("token" in payload) {
+            if (!SESSION[payload.token]) return;
+            return { ...SESSION[payload.token], expireIn: SESSION[payload.token].expireTime - Date.now() + 60000 };
+        }
+
+        // payload => {id: 23456546}
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+        const sessions = [];
+
+        for (let token in SESSION) {
+            if (SESSION[token][_key] == _value) sessions.push({ ...SESSION[token], token });
+        }
+        return sessions;
+    },
+
+    update(payload = {}) {
+        // payload => {id: 23456546, whatever: 'someValue', whatever_2: 'someValue'}
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+        delete payload[_key];
+
+        if (!Object.keys(payload).length) return;
+
+        if (_key == "token") {
+            SESSION[_value] = { ...SESSION[_value], ...payload };
+            return;
+        }
+
+        for (let token in SESSION) {
+            if (SESSION[token][_key] == _value) SESSION[token] = { ...SESSION[token], ...payload };
+        }
+    },
+
+    delete(payload = {}) {
+        if (payload.token) {
+            return delete SESSION[payload.token];
+        }
+
+        // payload => {user_id: 23456546}
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+
+        for (let s in SESSION) {
+            if (SESSION[s][_key] == _value) delete SESSION[s];
+        }
+    },
+};
+
+// -------- check or get ban users --------
+const banListFile = `${__basedir}/state/banList.json`;
+const BAN_LIST = existsSync(banListFile) ? JSON.parse(readFileSync(banListFile, "utf8") || "{}") : {};
+exports.banList = {
+    isBanned(payload) {
+        // payload = {ip: 123.67.432.43}
+        // payload = {email: 'test@gmail.com'}
+
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+
+        BAN_LIST[_key]?.includes(_value);
+    },
+    banUser(payload) {
+        // payload = {whatever: 'someValue'}
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+
+        if (BAN_LIST[_key]?.includes(_value)) return;
+        if (!BAN_LIST[_key]) BAN_LIST[_key] = [];
+
+        BAN_LIST[_key].push(_value);
+        writeFileSync(banListFile, JSON.stringify(BAN_LIST));
+    },
+    unBanUser(payload) {
+        // payload = {whatever: 'someValue'}
+        const _key = Object.keys(payload)[0];
+        const _value = Object.values(payload)[0];
+
+        const index = BAN_LIST[_key]?.indexOf(_value) || -1;
+        if (index > -1) {
+            BAN_LIST[_key].splice(index, 1);
+            writeFileSync(banListFile, JSON.stringify(BAN_LIST));
+        }
+    },
+};
+
+// rpm -> requests per minute
+let IP_REGISTER = {};
+exports.firewall = (ip, { rpm = 200 } = {}) => {
+    if (IP_REGISTER[ip] >= rpm) return true;
+    IP_REGISTER[ip] = (IP_REGISTER[ip] += 1) || 1;
+};
+setInterval(() => (IP_REGISTER = {}), 120000);
+
+exports.sessionStat = () => {
+    return {
+        sessions: SESSION,
+        firewall: IP_REGISTER,
+        banList: BAN_LIST,
+    };
+};