melperjs 2.0.0 → 2.0.1

package/lib/index.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Exception = Exception;
+exports.cookieDict = cookieDict;
+exports.cookieHeader = cookieHeader;
+exports.findKeyNode = findKeyNode;
+exports.foreignHttpError = foreignHttpError;
+exports.hashBcrypt = hashBcrypt;
+exports.isEmpty = isEmpty;
+exports.limitString = limitString;
+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.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 = {}) {
+  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 (0, _xss.default)(source, {
+    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": "2.0.1",
   "description": "Nodejs module to use predefined common functions and utilities",
   "keywords": [
     "helper",