@nka212bg/backend-utils 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+```
+npm-backend by nka212bg
+
+Misc backend utils
+```

package/db/dbUtils.js

@@ -0,0 +1,36 @@
+// HELPERS
+exports.stripString = (input) => {
+    if (!input) return input;
+
+    return (
+        String(input)
+            // .replace(/([!@#$%^&*,/\\<>]| )+/g, " ")
+            .replace(/\/\*|\*\/| +/g, " ")
+            .replace(/(( +$)?(' *)( +$)?)+/g, "'")
+            .replace(/(( +$)?(" *)( +$)?)+/g, '"')
+            .replace(/\-+/g, "-")
+            .replace(/  +/g, "  ")
+            .trim()
+    );
+};
+
+exports.paramsSanitize = (params) => {
+    if (!params) return [];
+    if (!Array.isArray(params)) params = [params];
+
+    return params.map((param) => {
+        if (typeof param == "object" && param !== null) {
+            return JSON.stringify(param);
+        }
+
+        param = String(param).trim();
+        const pLowerCase = param.toLowerCase();
+
+        if (pLowerCase === "true") return 1;
+        if (pLowerCase === "false") return 0;
+        if (!param || pLowerCase == "null" || pLowerCase == "undefined") return undefined;
+        // if (!isNaN(param)) return Number(param);
+
+        return param;
+    });
+};

package/db/mysql2.js

@@ -0,0 +1,56 @@
+const { paramsSanitize, stripString } = require("./dbUtils");
+const { createPool } = require("mysql2");
+
+const pool = createPool({
+    host: process.env.MYSQL_HOST,
+    port: process.env.MYSQL_PORT,
+    user: process.env.MYSQL_USER,
+    password: process.env.MYSQL_PASSWORD,
+    database: process.env.MYSQL_DATABASE,
+    waitForConnections: true,
+    connectionLimit: 10,
+    queueLimit: 0,
+});
+
+exports.mysql = (sql, params) => {
+    // (SELECT JSON_ARRAYAGG(JSON_OBJECT('CountryId', CountryID)) FROM country) AS Countries  // JSON_ARRAYAGG and JSON_OBJECT demos
+    return new Promise((resolve) => {
+        try {
+            sql = stripString(sql);
+            if (!sql) throw "Missing sql";
+
+            if (params?.length) {
+                const queryPlaceholdersLength = (sql.match(/\?/g) || []).length; // [?]
+                if (queryPlaceholdersLength < params.length) {
+                    params.splice(queryPlaceholdersLength, params.length);
+                } else if (queryPlaceholdersLength > params.length) {
+                    params = params.concat(Array(queryPlaceholdersLength - params.length).fill(params[params.length - 1]));
+                }
+            }
+
+            pool.query(sql, paramsSanitize(params), function (error, data) {
+                const changes = this._rows?.[0]?.affectedRows;
+                if (!error) {
+                    if (/^INSERT/gi.test(sql)) {
+                        const targetDB = /INTO\s(.*?) /i.exec(sql)[1];
+                        pool.query(`SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE CONSTRAINT_NAME = 'PRIMARY' AND TABLE_NAME = '${targetDB}' LIMIT 1`, [], function (error, tableName) {
+                            tableName = tableName?.[0].COLUMN_NAME;
+                            if (!tableName) return resolve({ error, data: undefined, changes });
+
+                            pool.query(`SELECT MAX(${tableName}) AS ${tableName} FROM ${targetDB}`, [], function (error, tableValue) {
+                                tableValue = tableValue?.[0];
+                                resolve({ error, data: tableValue || undefined, changes });
+                            });
+                        });
+                        return;
+                    }
+                }
+
+                !data?.length && (data = undefined);
+                resolve({ error, data, changes });
+            });
+        } catch (error) {
+            resolve({ error, data: undefined, changes: 0 });
+        }
+    });
+};

package/db/sqlite3.js

@@ -0,0 +1,99 @@
+const { paramsSanitize, stripString } = require("./dbUtils");
+const sqlite3 = require("sqlite3").verbose();
+
+const dbs = {};
+let vacuumed = [];
+let day = new Date().getDate();
+
+setInterval(() => {
+    const now = new Date();
+    if (day != now.getDate()) {
+        day = now.getDate();
+        vacuumed = [];
+    }
+    for (const e in dbs) {
+        if (dbs[e].time + 1000 * 60 * 5 < now.getTime()) {
+            if (dbs[e].vacuum && !vacuumed.includes(e)) {
+                vacuumed.push(e);
+                dbs[e].run("VACUUM");
+            }
+            dbs[e].close();
+            delete dbs[e];
+        }
+    }
+}, 1000 * 60);
+
+exports.sqlite = (dbName, sql, params = []) => {
+    return new Promise(async (resolve) => {
+        try {
+            sql = stripString(sql);
+            if (!sql) throw "Missing sql";
+            const isWrite = /^(INSERT|DELETE|UPDATE)/i.test(sql);
+            const queryPlaceholdersLength = (sql.match(/\?/g) || []).length; // [?]
+
+            if (queryPlaceholdersLength < params.length) {
+                params.splice(queryPlaceholdersLength, params.length);
+            } else if (queryPlaceholdersLength > params.length) {
+                params = params.concat(Array(queryPlaceholdersLength - params.length).fill(params[params.length - 1]));
+            }
+
+            let dbError;
+            if (!dbs[dbName]) {
+                let db;
+                await new Promise(async (resolve) => {
+                    db = new sqlite3.Database(dbName, (error) => {
+                        dbError = error;
+                        resolve();
+                    });
+                });
+
+                if (dbError) throw dbError;
+
+                db.time = Date.now();
+                dbs[dbName] = db;
+
+                // some db settings here
+                dbs[dbName].run("pragma synchronous = normal");
+
+                if (dbName.endsWith("/main.db")) {
+                    dbs[dbName].run("pragma temp_store = memory").run("pragma mmap_size = 3000000000");
+                }
+            }
+
+            dbs[dbName][isWrite ? "run" : "all"](sql, paramsSanitize(params), function (error, res) {
+                if (error) return resolve({ error });
+
+                !res?.length && (res = undefined);
+                const changes = this.changes;
+
+                if (/^INSERT/i.test(sql)) {
+                    const targetDB = /INTO\s(.*?) /i.exec(sql)[1];
+                    const insertId = this.lastID;
+                    return dbs[dbName].all(`SELECT name FROM pragma_table_info(?) WHERE pk = 1 LIMIT 1`, [targetDB], function (error, insertData) {
+                        insertData = insertData?.[0] ? { [insertData[0].name]: insertId } : undefined;
+
+                        resolve({ error, data: insertData, changes });
+                        printError(error);
+                    });
+                } else {
+                    resolve({ error, data: res, changes });
+                    printError(error);
+
+                    if (/^DELETE/i.test(sql)) dbs[dbName].vacuum = true;
+                }
+            });
+        } catch (error) {
+            try {
+                dbs[dbName].close();
+            } catch {}
+
+            delete dbs[dbName];
+            resolve({ error, data: undefined });
+            printError(error);
+        }
+
+        function printError(error) {
+            error && console.error(`SQLite error\n--> ${dbName}\n--> ${sql}\n--> ${error.message || String(error)}`);
+        }
+    });
+};

package/location/index.js

@@ -0,0 +1,88 @@
+const { readFileSync } = require("fs");
+const { locales, timeZones } = require(`./localelib`);
+
+// Load the db in the memory
+const Reader = require("@maxmind/geoip2-node").Reader;
+const GeoDB = Reader.openBuffer(readFileSync(`${__dirname}/GeoLite2-City.mmdb`));
+
+exports.userIp = (req) => {
+    if (!req) throw new Error("Request object is missing, can't work like that! That's absurd!!!");
+
+    let ip = (req.headers["x-forwarded-for"] || req.socket?.remoteAddress || req.connection?.remoteAddress || req.ip)?.split(",")[0].replace(/::ffff:/gi, "");
+
+    // if (["127.0.0.1", "::1"].includes(ip)) return "146.70.185.8";
+    return ip;
+};
+
+// user geo
+exports.location = ({ req, ip }) => {
+    let userIP;
+    try {
+        if (!ip && !req) throw "missing_required";
+        userIP = ip || this.userIp(req);
+        const geo = GeoDB.city(userIP);
+
+        const country = locales[geo.country.isoCode];
+        country.isoCode = geo.country.isoCode;
+
+        const data = {
+            ...country,
+            ...timeZones[country?.timeZone],
+            ...this.userDevice(req?.headers["user-agent"]),
+
+            ipAddress: userIP,
+            city: geo.city?.names.en || "",
+            postalCode: geo.postal?.code || "",
+            coordinates: geo.location,
+            traits: geo.traits,
+        };
+
+        return { data };
+    } catch (error) {
+        return {
+            error: {
+                error,
+                ipAddress: userIP,
+                msg: "Invalid or not existing IP",
+            },
+        };
+    }
+};
+
+exports.userDevice = (userAgent) => {
+    try {
+        if (!userAgent) throw "no_user_agent";
+
+        const getBrowser = () => {
+            if (/trident/i.test(userAgent)) return "msie";
+            if (/ope?ra?|opr/i.test(userAgent)) return "opera";
+            if (/edge?/i.test(userAgent)) return "edge";
+            if (/chrome/i.test(userAgent)) return "chrome";
+            if (/firefox/i.test(userAgent)) return "firefox";
+            if (/safari/i.test(userAgent)) return "safari";
+        };
+
+        const getOS = () => {
+            if (/Win/i.test(userAgent)) return "windows";
+            if (/Linux/i.test(userAgent)) return "linux";
+            if (/Mac/i.test(userAgent)) return "mac";
+            if (/Android/i.test(userAgent)) return "android";
+            if (/iPhone/i.test(userAgent)) return "iPhone";
+            if (/CrOS/i.test(userAgent)) return "chromeOS";
+            if (/WebOS/i.test(userAgent)) return "webOS";
+        };
+
+        const res = {
+            browser: getBrowser(),
+            os: getOS(),
+            device: /Mobile|Phone|Android|Pad|Pod|BlackBerry|IEMobile/i.test(userAgent) ? "mobile" : "desktop",
+        };
+
+        return {
+            ...res,
+            string: `${res.browser},${res.os},${res.device}`,
+        };
+    } catch (error) {
+        return {};
+    }
+};