melperjs 1.0.0

package/LISENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mahmuthan Elbir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# MELPERJS
+
+Nodejs module to use predefined common functions and utilities
+
+## Installation
+
+To install use npm:
+
+```bash
+npm i melperjs
+```
+
+## Usage
+
+```javascript
+const helper = require("melperjs");
+
+
+(async () => {
+    console.log("ENDSWITH TH", helper._.endsWith("ENDSWITH", "TH"));
+    console.log(helper.exception("something went wrong"));
+    console.log(helper.time());
+    await helper.sleepMs(1000);
+    console.log(helper.time());
+    await helper.sleep(1);
+    console.log(helper.time());
+    try {
+        await helper.promiseTimeout(1000, helper.sleepMs(2000));
+    } catch (e) {
+        console.error(e.message);
+    }
+    console.log(helper.findKeyNode("c", {
+        a: {
+            b: {
+                x: 1,
+                y: 2,
+                c: {
+                    d: true
+                }
+            }
+        }
+    }));
+    console.log("1 empty", helper.isEmpty(1));
+    console.log("[] empty", helper.isEmpty([]));
+    console.log(helper.limitString("LONG TEXT", 7));
+    console.log(helper.safeString("<strong>SAFE TEXT</strong>"));
+    console.log(helper.randomWeighted({strongProbability: 1000, lowProbability: 1}));
+    console.log(helper.tokenHex(8));
+    console.log(helper.md5("data"));
+    const password = helper.hashBcrypt("plain");
+    console.log(password)
+    console.log("passwordHash", helper.verifyBcrypt("plain", password));
+    const cookies = helper.cookieDict(await axios.get("https://google.com"));
+    console.log(cookies);
+    console.log(helper.cookieHeader(cookies));
+    const proxy = helper.formatProxy("127.0.0.1:8080:id:pw-{SESSION}");
+    console.log(proxy);
+    console.log(helper.proxyObject(proxy));
+    console.log(await helper.proxify({mode: 4, proxy}));
+    console.log(helper.serverIP());
+    console.log("HTTP CODE: 401 FOREIGN", helper.foreignError(401));
+    console.log("HTTP CODE: 0 FOREIGN", helper.foreignError(0));
+    helper.createNumDir("test");
+    helper.createDir("test");
+    console.log("VERSIONED BY .GIT",  "v" + helper.getVersion());
+})();
+
+/*
+ENDSWITH TH true
+{ message: 'something went wrong', response: { status: 400 } }
+1697381865
+1697381866
+1697381867
+Promise timed out after 1000ms
+{ x: 1, y: 2, c: { d: true } }
+1 empty false
+[] empty true
+LONG...
+SAFE TEXT
+strongProbability
+16638f79
+8d777f385d3dfec8815d20f7496026dc
+$2b$10$TYGF7Pe8YkdZY.w8f4cUneUYDYvzKCEaXohUzCfz.JStoatMKa0Im
+passwordHash true
+{
+  '1P_JAR': '2023-10-15-14',
+  AEC: 'Ackid1QW89FoW9j6RUUZDe9RpJGJN9Flq0Qs0nnbt7AUHJBuDcf3FKulcg',
+  NID: '511=RtEjqdKHa6MQ3Qaxr1Jh-8ktRCWPmSkV7iuo0P1MsLdhyuOyN7u1gXTAL8ojUO85rmcjUpfoul5Ucx7cBUzoLZzs5HpAnF5exxGiPvSUQeQHWADHgio7hmIl62kjHMKWJmmYtRcRFsKI9sgMUPr1MhX4Me181cqtNUgi8OLtCzY'
+}
+1P_JAR=2023-10-15-14;AEC=Ackid1QW89FoW9j6RUUZDe9RpJGJN9Flq0Qs0nnbt7AUHJBuDcf3FKulcg;NID=511=RtEjqdKHa6MQ3Qaxr1Jh-8ktRCWPmSkV7iuo0P1MsLdhyuOyN7u1gXTAL8ojUO85rmcjUpfoul5Ucx7cBUzoLZzs5HpAnF5exxGiPvSUQeQHWADHgio7hmIl62kjHMKWJmmYtRcRFsKI9sgMUPr1MhX4Me181cqtNUgi8OLtCzY
+http://id:pw-{SESSION}@127.0.0.1:8080
+{
+  protocol: 'http',
+  host: '127.0.0.1',
+  port: 8080,
+  auth: { username: 'id', password: 'pw-{SESSION}' }
+}
+http://id:pw-1708fa06@127.0.0.1:8080
+192.168.1.2
+HTTP CODE: 401 FOREIGN false
+HTTP CODE: 0 FOREIGN true
+fatal: not a git repository (or any of the parent directories): .git
+VERSIONED BY .GIT v2310.151313
+ */
+```
+
+## License
+
+The MIT License (MIT). Please see [License File](LISENCE) for more information.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "melperjs",
+  "version": "1.0.0",
+  "description": "Nodejs module to use predefined common functions and utilities",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node test/script.js"
+  },
+  "keywords": [
+    "helper",
+    "mixins",
+    "lodash",
+    "common functions",
+    "javascript helper"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mahelbir/melperjs.git"
+  },
+  "author": "Mahmuthan Elbir",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.5.1",
+    "bcrypt": "^5.1.1",
+    "hpagent": "^1.2.0",
+    "lodash": "^4.17.21",
+    "set-cookie-parser": "^2.6.0",
+    "xss": "^1.0.14"
+  }
+}

package/src/index.js

@@ -0,0 +1,323 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const {networkInterfaces} = require('os');
+const {execSync} = require('child_process');
+
+const _ = require('lodash');
+const xss = require('xss');
+const axios = require('axios');
+const bcrypt = require('bcrypt');
+const setCookieParser = require('set-cookie-parser');
+const {HttpsProxyAgent} = require('hpagent');
+
+
+function exception(message, response = {}) {
+    response.status = response.status || 400;
+    return {
+        message: message,
+        response: response
+    }
+}
+
+function time() {
+    return Math.floor(Date.now() / 1000);
+}
+
+async function sleepMs(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+async function sleep(seconds) {
+    return await sleepMs(seconds * 1000);
+}
+
+function promiseTimeout(milliseconds, promise) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error('Promise timed out after ' + milliseconds + 'ms'));
+        }, milliseconds);
+
+        promise
+            .then(value => {
+                clearTimeout(timer);
+                resolve(value);
+            })
+            .catch(reason => {
+                clearTimeout(timer);
+                reject(reason);
+            });
+    });
+}
+
+function findKeyNode(key, node, pair = null) {
+    if (node && node.hasOwnProperty(key) && (pair ? node[key] === pair : true)) {
+        return node;
+    } else if (typeof node === 'object') {
+        for (let index in node) {
+            const result = findKeyNode(key, node[index], pair);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return null;
+}
+
+function isEmpty(value) {
+    if (typeof value === "number") {
+        return value === 0;
+    } else {
+        return _.isEmpty(value);
+    }
+}
+
+function limitString(str, limit = 35) {
+    str = str || "";
+    if (str.length <= limit) {
+        return str;
+    } else {
+        return str.substring(0, limit - 3) + "...";
+    }
+}
+
+function safeString(source) {
+    return xss(source, {
+        whiteList: {},
+        stripIgnoreTag: true,
+        stripIgnoreTagBody: ["script"]
+    });
+}
+
+function randomWeighted(dict) {
+    let elements = Object.keys(dict);
+    let weights = Object.values(dict);
+
+    let totalWeight = 0;
+    for (let weight of weights) {
+        totalWeight += weight;
+    }
+
+    let randomNum = Math.random() * totalWeight;
+    let weightSum = 0;
+
+    for (let i = 0; i < elements.length; i++) {
+        weightSum += weights[i];
+        if (randomNum <= weightSum) {
+            return elements[i];
+        }
+    }
+}
+
+function tokenHex(length) {
+    return crypto.randomBytes(Math.ceil(length / 2))
+        .toString('hex')
+        .slice(0, length);
+}
+
+function md5(data) {
+    return crypto.createHash('md5').update(data).digest("hex");
+}
+
+function hashBcrypt(plainText) {
+    return bcrypt.hashSync(plainText, bcrypt.genSaltSync(10));
+}
+
+function verifyBcrypt(plainText, hash) {
+    return bcrypt.compareSync(plainText, hash);
+}
+
+function cookieDict(res, decodeValues = false) {
+    let dict = {};
+    const cookies = setCookieParser.parse(res, {decodeValues: decodeValues});
+    for (let cookie of cookies) {
+        dict[cookie.name] = cookie.value;
+    }
+    return dict;
+}
+
+function cookieHeader(cookieDict) {
+    return Object.entries(cookieDict)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(';')
+}
+
+function formatProxy(proxy, protocol = "http") {
+    proxy = proxy.trim();
+    const splitByProtocol = proxy.split("://");
+    if (1 < splitByProtocol.length)
+        protocol = splitByProtocol[0];
+    proxy = splitByProtocol[splitByProtocol.length - 1];
+    if (!proxy.includes("@")) {
+        const proxyParts = proxy.split(":");
+        if (4 <= proxyParts.length) {
+            proxy = `${proxyParts[proxyParts.length - 2]}:${proxyParts[proxyParts.length - 1]}@`;
+            proxyParts.pop();
+            proxyParts.pop();
+            proxy += proxyParts.join(":");
+        }
+    }
+    const proxyParts = proxy.split(':');
+    const proxyEnd = parseInt(proxyParts[proxyParts.length - 1]);
+    const proxyStart = proxyParts[proxyParts.length - 2];
+    if (!proxyStart.includes(".")) {
+        proxyParts.pop();
+        proxyParts[proxyParts.length - 1] = crypto.randomInt(parseInt(proxyStart), proxyEnd + 1).toString();
+    }
+    return protocol + "://" + proxyParts.join(':');
+}
+
+function proxyObject(...args) {
+    let proxy = formatProxy(...args);
+    const splitByProtocol = proxy.split('://');
+    const splitById = splitByProtocol[splitByProtocol.length - 1].split('@');
+    const splitByConn = splitById[splitById.length - 1].split(':');
+    proxy = {
+        protocol: splitByProtocol[0],
+        host: splitByConn[0],
+        port: parseInt(splitByConn[1]),
+    };
+    if (1 < splitById.length) {
+        const splitByAuth = splitById[0].split(':');
+        proxy.auth = {
+            username: splitByAuth[0],
+            password: splitByAuth[1]
+        };
+    }
+    return proxy;
+}
+
+async function proxify(proxyConfig, callback = formatProxy) {
+    proxyConfig = proxyConfig || {};
+    const timeout = 7000;
+    if (proxyConfig.mode === 1) {
+        return callback(proxyConfig.proxy);
+    } else if (proxyConfig.mode === 2) {
+        const proxy = callback(proxyConfig.proxy);
+        try {
+            await axios.get(proxyConfig.resetApi, {timeout});
+        } catch {
+            return false;
+        }
+        await sleep(5);
+        for (let i = 0; i < 5; i++) {
+            try {
+                const res = await axios.get("https://api64.ipify.org", {
+                    timeout,
+                    httpsAgent: new HttpsProxyAgent({proxy, timeout: 7000})
+                });
+                if (res.status === 200)
+                    return proxy;
+            } catch {
+                await sleep(3);
+            }
+        }
+    } else if (proxyConfig.mode === 3) {
+        try {
+            const res = await axios.get(proxyConfig.resetApi, {timeout});
+            if (res.status === 200)
+                return callback(proxyConfig.proxy);
+        } catch {
+            return false;
+        }
+    } else if (proxyConfig.mode === 4) {
+        return callback(proxyConfig.proxy).replace("{SESSION}", tokenHex(8));
+    } else if (proxyConfig.mode === 5) {
+        try {
+            const lines = proxyConfig.proxy.split("\n");
+            const line = lines[crypto.randomInt(0, lines.length)];
+            return callback(line);
+        } catch {
+            return false;
+        }
+    }
+
+    return null;
+}
+
+function serverIP() {
+    const interfaces = networkInterfaces();
+    for (const devName in interfaces) {
+        const interfaceValue = interfaces[devName];
+        for (let i = 0; i < interfaceValue.length; i++) {
+            const alias = interfaceValue[i];
+            if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal)
+                return alias.address;
+        }
+    }
+    return '127.0.0.1';
+}
+
+function foreignError(httpCode) {
+    return (
+        httpCode === undefined ||
+        httpCode === null ||
+        httpCode === 0 ||
+        httpCode === 402 ||
+        httpCode === 407 ||
+        httpCode === 466 ||
+        500 <= httpCode
+    );
+}
+
+function createDir(directory) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, {recursive: true});
+        return true;
+    }
+    return null;
+}
+
+function createNumDir(mainDirectory) {
+    if (createDir(mainDirectory)) {
+        for (let i = 0; i <= 9; i++) {
+            fs.mkdir(path.join(mainDirectory, i.toString()), (err) => {
+                if (err)
+                    console.error(err);
+            });
+        }
+    }
+}
+
+function getVersion() {
+    try {
+        const date = new Date(execSync('git show -s --format=%ci HEAD').toString().trim());
+        const formatDatePart = (value) => value.toString().padStart(2, '0');
+        const year = date.getFullYear().toString().slice(-2);
+        const month = formatDatePart(date.getMonth() + 1);
+        const day = formatDatePart(date.getDate());
+        const hour = formatDatePart(date.getHours());
+        const minute = formatDatePart(date.getMinutes());
+        return parseFloat(`${year}${month}.${day}${hour}${minute}`);
+    } catch {
+        return 1.0;
+    }
+}
+
+module.exports = {
+    _,
+    exception,
+    time,
+    sleepMs,
+    sleep,
+    promiseTimeout,
+    findKeyNode,
+    isEmpty,
+    limitString,
+    safeString,
+    randomWeighted,
+    tokenHex,
+    md5,
+    hashBcrypt,
+    verifyBcrypt,
+    cookieDict,
+    cookieHeader,
+    formatProxy,
+    proxyObject,
+    proxify,
+    serverIP,
+    foreignError,
+    createDir,
+    createNumDir,
+    getVersion
+};

package/test/script.js

@@ -0,0 +1,52 @@
+const helper = require("../src/index");
+const axios = require("axios");
+
+
+(async () => {
+    console.log("ENDSWITH TH", helper._.endsWith("ENDSWITH", "TH"));
+    console.log(helper.exception("something went wrong"));
+    console.log(helper.time());
+    await helper.sleepMs(1000);
+    console.log(helper.time());
+    await helper.sleep(1);
+    console.log(helper.time());
+    try {
+        await helper.promiseTimeout(1000, helper.sleepMs(2000));
+    } catch (e) {
+        console.error(e.message);
+    }
+    console.log(helper.findKeyNode("c", {
+        a: {
+            b: {
+                x: 1,
+                y: 2,
+                c: {
+                    d: true
+                }
+            }
+        }
+    }));
+    console.log("1 empty", helper.isEmpty(1));
+    console.log("[] empty", helper.isEmpty([]));
+    console.log(helper.limitString("LONG TEXT", 7));
+    console.log(helper.safeString("<strong>SAFE TEXT</strong>"));
+    console.log(helper.randomWeighted({strongProbability: 1000, lowProbability: 1}));
+    console.log(helper.tokenHex(8));
+    console.log(helper.md5("data"));
+    const password = helper.hashBcrypt("plain");
+    console.log(password)
+    console.log("passwordHash", helper.verifyBcrypt("plain", password));
+    const cookies = helper.cookieDict(await axios.get("https://google.com"));
+    console.log(cookies);
+    console.log(helper.cookieHeader(cookies));
+    const proxy = helper.formatProxy("127.0.0.1:8080:id:pw-{SESSION}");
+    console.log(proxy);
+    console.log(helper.proxyObject(proxy));
+    console.log(await helper.proxify({mode: 4, proxy}));
+    console.log(helper.serverIP());
+    console.log("HTTP CODE: 401 FOREIGN", helper.foreignError(401));
+    console.log("HTTP CODE: 0 FOREIGN", helper.foreignError(0));
+    helper.createNumDir("test");
+    helper.createDir("test");
+    console.log("VERSIONED BY .GIT",  "v" + helper.getVersion());
+})();