melperjs 2.0.0 → 3.0.0

package/README.md

@@ -21,7 +21,7 @@ const nodeHelper = require("melperjs/node");
 const axios = require("axios");
 
 (async () => {
-    console.log(helper.Exception("something went wrong"));
+    console.log(helper.Exception("something went wrong", {status: 500}, "axios error"));
     console.log(helper.time());
     await helper.sleepMs(1000);
     console.log(helper.time());
@@ -43,8 +43,12 @@ const axios = require("axios");
             }
         }
     }));
-    console.log("1 empty", helper.isEmpty(1));
-    console.log("[] empty", helper.isEmpty([]));
+    console.log("str empty", helper.checkEmpty(""));
+    console.log("1 empty", helper.checkEmpty(1));
+    console.log("[] empty", helper.checkEmpty([]));
+    console.log(helper.upperCaseFirst("first letter upper"));
+    console.log(helper.lowerCaseFirst("First Letter Lower"));
+    console.log(helper.titleString("THIS mUsT be Title"));
     console.log(helper.limitString("LONG TEXT", 7));
     console.log(helper.safeString("<strong>SAFE TEXT</strong>"));
     console.log(helper.randomString(32, true, true));
@@ -75,33 +79,41 @@ const axios = require("axios");
 })();
 
 /*
-{ message: 'something went wrong', response: { status: 400 } }
-1700522762
-1700522763
-1700522764
+{
+  name: 'AxiosError',
+  message: 'something went wrong',
+  response: { status: 500 }
+}
+1700529489
+1700529490
+1700529491
 Promise timed out after 1000ms
 { x: 1, y: 2, c: { d: true } }
+str empty true
 1 empty false
 [] empty true
+First letter upper
+first Letter Lower
+This Must Be Title
 LONG...
 SAFE TEXT
-i9ULmdbboTDL7NPgJRiY1i6O1x0D71wG
-91d59653
-50fe22be-a4e9-46cd-b73b-da5669ca43b4
+15WY89Q4yAMCzPmNsU0ANGX2eiOz7Gfy
+9eb93429
+7e1fb299-251c-4a75-bb37-f7cc3a730121
 strongProbability
-kpG7GBnGf8kK2JGwSNe8EaIdkrKl5OEr
-4f592b6e
-e7947cc3-d975-446c-82ec-fc77d84a67bb
+STIhrofUYVAQ4anplyJW2T7GEwSJkuk7
+6db791a1
+0cbef42d-a277-4f66-8bcc-e4de337c2b56
 strongProbability
 8d777f385d3dfec8815d20f7496026dc
-$2b$10$m3gbDZMz6P/NKtOBtcJPTe5Dt9TtGaFVE5M.F07QR4bLHoKuezfpm
+$2b$10$IsuTscKKHbcf6sBp7BrCOOcg6A8v32G9UxzdYN3Y6xyMaUynweYX2
 passwordHash true
 {
-  '1P_JAR': '2023-11-20-23',
-  AEC: 'Ackid1QUUwFH8ZlfrHR1RFoG3nbxsOvmYckU_mnIw4Z6cE4ue9_mbng2mmU',
-  NID: '511=m55MFOJ7XlxlkanJtm0q7eK5PkaePFQiaxEeMcAR_ojuPBWZ0bqw6tbDq4VGuT2CrTNgGWw_lLECx100Qlm1bRBNYEx_0wWtVNCh582q9-zhvQFSDbAI3vDtl-vMlMbpv_6JYJ7YBhGf1S6zbqv6Q84hlbLBOIg8Dt633-b5b94'
+  '1P_JAR': '2023-11-21-01',
+  AEC: 'Ackid1TlDwA2YJw3rzP5t3x5vBdxZt-4AzkhdwLahUVpj3vhdVHvPlw0VWM',
+  NID: '511=tD21gyuziCvCgZSQZd5h_xDFOF6df8AhkFy0iXq9MwHG9K8J3FEkT7L0CACgjJhGDVQFoZG_Pwi2Wo8Kf7NnmvcNGVmk-lDhY768PI9sVSUmSHIYwpfsuVvG4NwNwk3iPNKmbqaC_H-YVGZhEJVn2c6YYUVxE0oEDtfuyPhGOXw'
 }
-1P_JAR=2023-11-20-23;AEC=Ackid1QUUwFH8ZlfrHR1RFoG3nbxsOvmYckU_mnIw4Z6cE4ue9_mbng2mmU;NID=511=m55MFOJ7XlxlkanJtm0q7eK5PkaePFQiaxEeMcAR_ojuPBWZ0bqw6tbDq4VGuT2CrTNgGWw_lLECx100Qlm1bRBNYEx_0wWtVNCh582q9-zhvQFSDbAI3vDtl-vMlMbpv_6JYJ7YBhGf1S6zbqv6Q84hlbLBOIg8Dt633-b5b94
+1P_JAR=2023-11-21-01;AEC=Ackid1TlDwA2YJw3rzP5t3x5vBdxZt-4AzkhdwLahUVpj3vhdVHvPlw0VWM;NID=511=tD21gyuziCvCgZSQZd5h_xDFOF6df8AhkFy0iXq9MwHG9K8J3FEkT7L0CACgjJhGDVQFoZG_Pwi2Wo8Kf7NnmvcNGVmk-lDhY768PI9sVSUmSHIYwpfsuVvG4NwNwk3iPNKmbqaC_H-YVGZhEJVn2c6YYUVxE0oEDtfuyPhGOXw
 http://id:pw-{SESSION}@127.0.0.1:8080
 {
   protocol: 'http',
@@ -109,7 +121,7 @@ http://id:pw-{SESSION}@127.0.0.1:8080
   port: 8080,
   auth: { username: 'id', password: 'pw-{SESSION}' }
 }
-http://id:pw-06cbcd75@127.0.0.1:8080
+http://id:pw-527ef984@127.0.0.1:8080
 127.0.0.1
 HTTP CODE: 401 FOREIGN false
 HTTP CODE: 407 FOREIGN (Failed Proxy Auth) true

package/lib/index.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Exception = Exception;
+exports.checkEmpty = checkEmpty;
+exports.cookieDict = cookieDict;
+exports.cookieHeader = cookieHeader;
+exports.findKeyNode = findKeyNode;
+exports.foreignHttpError = foreignHttpError;
+exports.hashBcrypt = hashBcrypt;
+exports.limitString = limitString;
+exports.lowerCaseFirst = lowerCaseFirst;
+exports.pascalCase = pascalCase;
+exports.promiseTimeout = promiseTimeout;
+exports.randomHex = randomHex;
+exports.randomString = randomString;
+exports.randomUuid = randomUuid;
+exports.randomWeighted = randomWeighted;
+exports.safeString = safeString;
+exports.sleep = sleep;
+exports.sleepMs = sleepMs;
+exports.time = time;
+exports.titleString = titleString;
+exports.upperCaseFirst = upperCaseFirst;
+exports.verifyBcrypt = verifyBcrypt;
+var _ = _interopRequireWildcard(require("lodash"));
+var _xss = _interopRequireDefault(require("xss"));
+var _bcrypt = _interopRequireDefault(require("bcrypt"));
+var _setCookieParser = _interopRequireDefault(require("set-cookie-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function Exception(message, response = {}, name = null) {
+  response.status = response.status || 400;
+  return {
+    name: pascalCase(name),
+    message,
+    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 checkEmpty(value) {
+  if (typeof value === "number") {
+    return value === 0;
+  } else {
+    return _.isEmpty(value);
+  }
+}
+function pascalCase(str) {
+  return upperCaseFirst(_.camelCase(str));
+}
+function upperCaseFirst(str) {
+  str = str || "";
+  return _.upperCase(str[0]) + str.slice(1);
+}
+function lowerCaseFirst(str) {
+  str = str || "";
+  return _.lowerCase(str[0]) + str.slice(1);
+}
+function titleString(str) {
+  str = str || "";
+  return str.split(' ').map(word => _.capitalize(word)).join(' ');
+}
+function limitString(str, limit = 35) {
+  str = str || "";
+  if (str.length <= limit) {
+    return str;
+  } else {
+    return str.substring(0, limit - 3) + "...";
+  }
+}
+function safeString(str) {
+  str = str || "";
+  return (0, _xss.default)(str, {
+    whiteList: {},
+    stripIgnoreTag: true,
+    stripIgnoreTagBody: ["script"]
+  });
+}
+function randomString(length, useNumbers = true, useUppercase = false) {
+  const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz';
+  const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  const numbers = '0123456789';
+  let characters = lowercaseChars;
+  if (useUppercase) characters += uppercaseChars;
+  if (useNumbers) characters += numbers;
+  let randomString = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    randomString += characters[randomIndex];
+  }
+  return randomString;
+}
+function randomHex(length) {
+  let result = '';
+  const characters = '0123456789abcdef';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters[randomIndex];
+  }
+  return result;
+}
+function randomUuid(useDashes = true) {
+  let d = Date.now();
+  const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+function randomWeighted(dict, randomFunc = totalWeight => Math.random() * totalWeight) {
+  let elements = Object.keys(dict);
+  let weights = Object.values(dict);
+  let totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  let randomNum = randomFunc(totalWeight);
+  let weightSum = 0;
+  for (let i = 0; i < elements.length; i++) {
+    weightSum += weights[i];
+    if (randomNum <= weightSum) {
+      return elements[i];
+    }
+  }
+}
+function hashBcrypt(plainText) {
+  return _bcrypt.default.hashSync(plainText, _bcrypt.default.genSaltSync(10));
+}
+function verifyBcrypt(plainText, hash) {
+  return _bcrypt.default.compareSync(plainText, hash);
+}
+function cookieDict(res, decodeValues = false) {
+  let dict = {};
+  const cookies = _setCookieParser.default.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 foreignHttpError(httpCode) {
+  return httpCode === undefined || httpCode === null || httpCode === 0 || httpCode === 402 || httpCode === 407 || httpCode === 466 || 500 <= httpCode;
+}

package/lib/node.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDir = createDir;
+exports.createNumDir = createNumDir;
+exports.formatProxy = formatProxy;
+exports.getVersion = getVersion;
+exports.md5 = md5;
+exports.proxify = proxify;
+exports.proxyObject = proxyObject;
+exports.serverIp = serverIp;
+exports.tokenHex = tokenHex;
+exports.tokenString = tokenString;
+exports.tokenUuid = tokenUuid;
+exports.tokenWeighted = tokenWeighted;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _crypto = _interopRequireDefault(require("crypto"));
+var _os = require("os");
+var _child_process = require("child_process");
+var _axios = _interopRequireDefault(require("axios"));
+var _hpagent = require("hpagent");
+var _index = require("./index.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function tokenString(length, useNumbers = true, useUppercase = false) {
+  const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz';
+  const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  const numbers = '0123456789';
+  let characters = lowercaseChars;
+  if (useUppercase) characters += uppercaseChars;
+  if (useNumbers) characters += numbers;
+  let randomString = '';
+  while (randomString.length < length) {
+    const byte = _crypto.default.randomBytes(1)[0];
+    const index = byte % characters.length;
+    if (byte < 256 - 256 % characters.length) {
+      randomString += characters[index];
+    }
+  }
+  return randomString;
+}
+function tokenHex(length) {
+  return _crypto.default.randomBytes(Math.ceil(length / 2)).toString('hex').slice(0, length);
+}
+function tokenUuid(useDashes = true) {
+  const uuid = _crypto.default.randomUUID().toString();
+  return useDashes ? uuid : uuid.replaceAll("-", "");
+}
+function tokenWeighted(dict) {
+  return (0, _index.randomWeighted)(dict, _crypto.default.randomInt);
+}
+function serverIp() {
+  const interfaces = (0, _os.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.address.startsWith("192.168.") && !alias.internal) return alias.address;
+    }
+  }
+  return '127.0.0.1';
+}
+function getVersion() {
+  try {
+    const date = new Date((0, _child_process.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;
+  }
+}
+function createDir(directory) {
+  if (!_fs.default.existsSync(directory)) {
+    _fs.default.mkdirSync(directory, {
+      recursive: true
+    });
+    return true;
+  }
+  return false;
+}
+function createNumDir(mainDirectory) {
+  createDir(mainDirectory);
+  for (let i = 0; i <= 9; i++) {
+    try {
+      createDir(_path.default.join(mainDirectory, i.toString()));
+    } catch (e) {
+      console.error(`createNumDir:${i}`, e.message);
+    }
+  }
+}
+function md5(data) {
+  return _crypto.default.createHash('md5').update(data).digest("hex");
+}
+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.default.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.default.get(proxyConfig.resetApi, {
+        timeout
+      });
+    } catch {
+      return false;
+    }
+    await (0, _index.sleep)(5);
+    for (let i = 0; i < 5; i++) {
+      try {
+        const res = await _axios.default.get("https://api64.ipify.org", {
+          timeout,
+          httpsAgent: new _hpagent.HttpsProxyAgent({
+            proxy,
+            timeout: 7000
+          })
+        });
+        if (res.status === 200) return proxy;
+      } catch {
+        await (0, _index.sleep)(3);
+      }
+    }
+  } else if (proxyConfig.mode === 3) {
+    try {
+      const res = await _axios.default.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.default.randomInt(0, lines.length)];
+      return callback(line);
+    } catch {
+      return false;
+    }
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melperjs",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Nodejs module to use predefined common functions and utilities",
   "keywords": [
     "helper",

package/src/index.js

@@ -1,13 +1,14 @@
-import  * as _ from "lodash";
+import * as _ from "lodash";
 import xss from "xss";
 import bcrypt from "bcrypt";
 import setCookieParser from "set-cookie-parser";
 
-export function Exception(message, response = {}) {
+export function Exception(message, response = {}, name = null) {
     response.status = response.status || 400;
     return {
-        message: message,
-        response: response
+        name: pascalCase(name),
+        message,
+        response,
     }
 }
 
@@ -55,7 +56,7 @@ export function findKeyNode(key, node, pair = null) {
     return null;
 }
 
-export function isEmpty(value) {
+export function checkEmpty(value) {
     if (typeof value === "number") {
         return value === 0;
     } else {
@@ -63,6 +64,28 @@ export function isEmpty(value) {
     }
 }
 
+export function pascalCase(str){
+    return upperCaseFirst(_.camelCase(str));
+}
+
+export function upperCaseFirst(str) {
+    str = str || "";
+    return _.upperCase(str[0]) + str.slice(1);
+}
+
+export function lowerCaseFirst(str) {
+    str = str || "";
+    return _.lowerCase(str[0]) + str.slice(1);
+}
+
+export function titleString(str) {
+    str = str || "";
+    return str
+        .split(' ')
+        .map(word => _.capitalize(word))
+        .join(' ');
+}
+
 export function limitString(str, limit = 35) {
     str = str || "";
     if (str.length <= limit) {
@@ -72,8 +95,9 @@ export function limitString(str, limit = 35) {
     }
 }
 
-export function safeString(source) {
-    return xss(source, {
+export function safeString(str) {
+    str = str || "";
+    return xss(str, {
         whiteList: {},
         stripIgnoreTag: true,
         stripIgnoreTagBody: ["script"]

package/test/script.js

@@ -4,7 +4,7 @@ import axios from "axios"
 
 
 (async () => {
-    console.log(helper.Exception("something went wrong"));
+    console.log(helper.Exception("something went wrong", {status: 500}, "axios error"));
     console.log(helper.time());
     await helper.sleepMs(1000);
     console.log(helper.time());
@@ -26,8 +26,12 @@ import axios from "axios"
             }
         }
     }));
-    console.log("1 empty", helper.isEmpty(1));
-    console.log("[] empty", helper.isEmpty([]));
+    console.log("str empty", helper.checkEmpty(""));
+    console.log("1 empty", helper.checkEmpty(1));
+    console.log("[] empty", helper.checkEmpty([]));
+    console.log(helper.upperCaseFirst("first letter upper"));
+    console.log(helper.lowerCaseFirst("First Letter Lower"));
+    console.log(helper.titleString("THIS mUsT be Title"));
     console.log(helper.limitString("LONG TEXT", 7));
     console.log(helper.safeString("<strong>SAFE TEXT</strong>"));
     console.log(helper.randomString(32, true, true));