@jayfong/x-server 2.119.0 → 3.1.1

package/lib/_cjs/services/crypto.js

@@ -1,175 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.CryptoService = void 0;
-var _nodeCrypto = _interopRequireDefault(require("node:crypto"));
-class CryptoService {
-  constructor() {
-    this.serviceName = 'crypto';
-  }
-  /**
-   * 将给定的文本转换为 Base64 编码的字符串
-   *
-   * @param text 需要编码的原始文本
-   * @returns 返回 Base64 编码后的字符串
-   */
-  base64Encode(text) {
-    return Buffer.from(text).toString('base64');
-  }
-
-  /**
-   * 将 Base64 编码的字符串转换为 UTF-8 编码的字符串
-   *
-   * @param text Base64 编码的字符串
-   * @returns 转换后的 UTF-8 编码的字符串
-   */
-  base64Decode(text) {
-    return Buffer.from(text, 'base64').toString('utf8');
-  }
-
-  /**
-   * 将字符串文本编码为Base64 URL格式
-   *
-   * 此函数的目的是将输入的字符串转换为Base64编码，并进一步转换为URL安全的格式
-   * Base64标准字符集中的'+'和'/'在URL中有特殊意义，因此需要被替换为'-'和'_'
-   * 此外，Base64编码中用于填充的'='字符在URL中通常被视为不必要的，因此也会被移除
-   *
-   * @param text 需要被编码的字符串文本
-   * @returns 编码后的Base64 URL安全字符串
-   */
-  base64UrlEncode(text) {
-    // 将输入文本转换为Buffer对象，并进一步将其转换为Base64编码的字符串
-    let base64 = Buffer.from(text).toString('base64');
-
-    // 将Base64编码中的'+'替换为'-'，以适应URL安全要求
-    base64 = base64.replace(/\+/g, '-');
-
-    // 将Base64编码中的'/'替换为'_'，以适应URL安全要求
-    base64 = base64.replace(/\//g, '_');
-
-    // 移除Base64编码中用于填充的'='字符，以适应URL安全要求
-    base64 = base64.replace(/=/g, '');
-
-    // 返回经过URL安全处理的Base64编码字符串
-    return base64;
-  }
-
-  /**
-   * 解码base64url格式的字符串
-   * base64url是一种用于URL的base64编码变体，它将标准base64中的'+'和'/'字符替换为'-'和'_'，以避免URL编码
-   * 此函数的作用是将base64url编码的字符串解码回原始字符串
-   *
-   * @param text 需要解码的base64url格式的字符串
-   * @returns 解码后的原始字符串
-   */
-  base64UrlDecode(text) {
-    // 将base64url编码中的'-'和'_'替换回标准base64编码中的'+'和'/'
-    // 然后使用Node.js的Buffer对象从base64编码转换为utf8格式的字符串
-    return Buffer.from(text.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
-  }
-
-  /**
-   * 使用MD5算法对文本进行哈希处理
-   *
-   * @param text 需要进行哈希处理的文本
-   * @returns 返回经过MD5哈希处理后的字符串
-   */
-  md5(text) {
-    return _nodeCrypto.default.createHash('md5').update(text).digest('hex');
-  }
-
-  /**
-   * 使用SHA-1算法对文本进行哈希处理
-   *
-   * SHA-1是一种安全散列算法，它接收一个输入（在此例中为文本字符串），
-   * 并返回一个固定大小的160位散列值，通常以40位的十六进制数字表示
-   * 此函数用于将给定的文本转换为SHA-1散列值，常用于数据完整性校验或存储密码的散列值
-   *
-   * @param text 待哈希处理的文本字符串
-   * @returns 返回文本的SHA-1散列值，以十六进制字符串形式表示
-   */
-  sha1(text) {
-    return _nodeCrypto.default.createHash('sha1').update(text).digest('hex');
-  }
-
-  /**
-   * 使用SHA-256算法对文本进行哈希处理
-   *
-   * @param text 输入的文本字符串
-   * @returns 返回经过SHA-256哈希处理后的十六进制字符串
-   */
-  sha256(text) {
-    return _nodeCrypto.default.createHash('sha256').update(text).digest('hex');
-  }
-
-  /**
-   * 使用SHA-512算法对文本进行哈希处理
-   *
-   * @param text 输入的文本字符串
-   * @returns 返回经过SHA-512哈希处理后的字符串
-   */
-  sha512(text) {
-    return _nodeCrypto.default.createHash('sha512').update(text).digest('hex');
-  }
-
-  /**
-   * 使用给定的密钥对给定的字符串执行 AES 加密（加密模式为 ECB，填充方式为 PKCS7）。
-   *
-   * @param text - 要加密的字符串。
-   * @param key - 用于加密的密钥（仅支持16字节的密钥）。
-   */
-  aesEncrypt(text, key) {
-    const cipher = _nodeCrypto.default.createCipheriv('aes-128-ecb', key.substring(0, 16), null);
-    let encrypted = cipher.update(text, 'utf8', 'base64');
-    encrypted += cipher.final('base64');
-    return encrypted;
-  }
-
-  /**
-   * 使用给定的密钥对给定的字符串执行 AES 解密（解密模式为 ECB，填充方式为 PKCS7）。
-   *
-   * @param text - 要解密的字符串。
-   * @param key - 用于解密的密钥（仅支持16字节的密钥）。
-   */
-  aesDecrypt(text, key) {
-    const decipher = _nodeCrypto.default.createDecipheriv('aes-128-ecb', key.substring(0, 16), null);
-    let decrypted = decipher.update(text, 'base64', 'utf8');
-    decrypted += decipher.final('utf8');
-    return decrypted;
-  }
-
-  /**
-   * 使用AES加密算法对JSON数据进行加密
-   *
-   * 该方法首先将payload参数序列化为JSON字符串，然后使用指定的密钥进行AES加密
-   * 主要用于在传输敏感信息前，对数据进行加密处理，以确保数据的安全性
-   *
-   * @param payload 任何类型的对象，代表需要加密的原始数据
-   * @param key 字符串类型的密钥，用于AES加密算法
-   *            密钥需要符合AES加密算法的长度要求
-   * @returns 返回加密后的字符串数据
-   *          加密后的数据可以安全地进行网络传输或存储
-   */
-  aesEncryptJson(payload, key) {
-    // 将payload对象序列化为JSON字符串，以便进行加密处理
-    // 使用指定的密钥对序列化后的JSON字符串进行AES加密
-    // 返回加密后的数据，确保数据在传输或存储过程中的安全性
-    return this.aesEncrypt(JSON.stringify(payload), key);
-  }
-
-  /**
-   * 使用AES算法解密给定的文本，并将解密后的结果解析为JSON对象
-   *
-   * @param text 需要解密的加密文本
-   * @param key 解密用的密钥，必须与加密时使用的密钥相同
-   * @returns 返回解密后的JSON对象，类型为泛型T，根据调用时指定的类型解析
-   */
-  aesDecryptJson(text, key) {
-    // 使用指定的密钥对给定的加密数据进行AES解密
-    // 将解密后的数据反序列化为JSON对象，以便后续的处理
-    // 返回解密后的数据，确保数据在传输或存储过程中的安全性
-    return JSON.parse(this.aesDecrypt(text, key));
-  }
-}
-exports.CryptoService = CryptoService;

package/lib/_cjs/services/db_value.js

@@ -1,77 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.DbValueService = void 0;
-var _vtils = require("vtils");
-class DbValueService {
-  constructor() {
-    this.serviceName = 'dbValue';
-    this.SimpleArray = class {
-      constructor(options) {
-        this.separator = void 0;
-        this.affix = void 0;
-        this.number = void 0;
-        this.add = (value, defaultValue = []) => {
-          const text = (!value || !Array.isArray(value) ? defaultValue : value.filter(v => v != null && v !== '')).join(this.separator);
-          return !text || !this.affix ? text : `${this.affix}${text}${this.affix}`;
-        };
-        this.get = value => {
-          const res = !value ? [] : String(!this.affix ? value : value.substring(this.affix.length, value.length - this.affix.length)).split(this.separator).filter(v => v !== '');
-          return this.number ? res.map(Number) : res;
-        };
-        this.update = value => {
-          const text = !value || !Array.isArray(value) ? undefined : value.filter(v => v != null && v !== '').join(this.separator);
-          return !text || !this.affix ? text : `${this.affix}${text}${this.affix}`;
-        };
-        this.separator = options?.separator || ',';
-        this.affix = options?.affix || '';
-        this.number = !!options?.number;
-      }
-    };
-    this.JsonArray = class {
-      constructor() {
-        this.add = (value, defaultValue = []) => {
-          return JSON.stringify(!value || !Array.isArray(value) ? defaultValue : value);
-        };
-        this.get = value => {
-          return !value ? [] : JSON.parse(value);
-        };
-        this.update = value => {
-          return !value || !Array.isArray(value) ? undefined : JSON.stringify(value);
-        };
-      }
-    };
-    this.JsonObject = class {
-      constructor(options) {
-        this.options = void 0;
-        this.hasTransformAdd = false;
-        this.hasTransformGet = false;
-        this.hasTransformUpdate = false;
-        this.add = (value, defaultValue = {}) => {
-          if (value && this.hasTransformAdd) {
-            value = this.options.transform.add(value);
-          }
-          return JSON.stringify(!value || !(0, _vtils.isPlainObject)(value) ? defaultValue : value);
-        };
-        this.get = value => {
-          let result = !value ? {} : JSON.parse(value);
-          if (result && this.hasTransformGet) {
-            result = this.options.transform.get(result);
-          }
-          return result;
-        };
-        this.update = value => {
-          if (value && this.hasTransformUpdate) {
-            value = this.options.transform.update(value);
-          }
-          return !value || !(0, _vtils.isPlainObject)(value) ? undefined : JSON.stringify(value);
-        };
-        this.options = options;
-        this.hasTransformAdd = !!options?.transform?.add;
-        this.hasTransformGet = !!options?.transform?.get;
-        this.hasTransformUpdate = !!options?.transform?.update;
-      }
-    };
-  }
-}
-exports.DbValueService = DbValueService;

package/lib/_cjs/services/dingtalk.js

@@ -1,51 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.DingtalkService = void 0;
-var _nodeCrypto = _interopRequireDefault(require("node:crypto"));
-var _got = _interopRequireDefault(require("got"));
-class DingtalkService {
-  constructor(options) {
-    this.options = options;
-    this.serviceName = 'dingtalk';
-  }
-  async send(options) {
-    const timestamp = Date.now();
-    const sign = _nodeCrypto.default.createHmac('sha256', this.options.secret).update(`${timestamp}\n${this.options.secret}`).digest('base64');
-    const data = {
-      msgtype: 'markdown',
-      markdown: {
-        title: options.title,
-        text: options.content
-      },
-      at: {
-        atMobiles: Array.isArray(options.at) ? options.at : [],
-        isAtAll: options.at === 'all'
-      }
-    };
-    if (!data.at.isAtAll && data.at.atMobiles.length) {
-      const atMobiles = data.at.atMobiles.filter(mobile => !data.markdown.text.includes(`@${mobile}`));
-      if (atMobiles.length) {
-        const atMobilesText = atMobiles.map(mobile => `@${mobile}`).join(' ');
-        data.markdown.text += `<!-- ${atMobilesText} -->`;
-      }
-    }
-    const {
-      body
-    } = await _got.default.post('https://oapi.dingtalk.com/robot/send', {
-      responseType: 'json',
-      searchParams: {
-        access_token: this.options.accessToken,
-        timestamp: timestamp,
-        sign: sign
-      },
-      json: data
-    });
-    if (body.errcode !== 0) {
-      throw new Error(body.errmsg);
-    }
-    return body;
-  }
-}
-exports.DingtalkService = DingtalkService;

package/lib/_cjs/services/dispose.js

@@ -1,23 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.DisposeService = void 0;
-var _exitHook = _interopRequireDefault(require("exit-hook"));
-class DisposeService {
-  constructor(options) {
-    this.options = options;
-    this.serviceName = 'dispose';
-    this.disposes = [];
-    if (this.options?.disposeOnExit) {
-      (0, _exitHook.default)(() => this.dispose());
-    }
-  }
-  add(fn) {
-    this.disposes.push(fn);
-  }
-  dispose() {
-    return Promise.all(this.disposes.map(dispose => dispose()));
-  }
-}
-exports.DisposeService = DisposeService;