@jayfong/x-server 2.119.0 → 3.1.1

package/lib/services/crypto.mjs

@@ -0,0 +1,141 @@
+import crypto from "node:crypto";
+// src/services/crypto.ts
+var CryptoService = class {
+	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) {
+		let base64 = Buffer.from(text).toString("base64");
+		base64 = base64.replace(/\+/g, "-");
+		base64 = base64.replace(/\//g, "_");
+		base64 = base64.replace(/=/g, "");
+		return base64;
+	}
+	/**
+	* 解码base64url格式的字符串
+	* base64url是一种用于URL的base64编码变体，它将标准base64中的'+'和'/'字符替换为'-'和'_'，以避免URL编码
+	* 此函数的作用是将base64url编码的字符串解码回原始字符串
+	*
+	* @param text 需要解码的base64url格式的字符串
+	* @returns 解码后的原始字符串
+	*/
+	base64UrlDecode(text) {
+		return Buffer.from(text.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+	}
+	/**
+	* 使用MD5算法对文本进行哈希处理
+	*
+	* @param text 需要进行哈希处理的文本
+	* @returns 返回经过MD5哈希处理后的字符串
+	*/
+	md5(text) {
+		return crypto.createHash("md5").update(text).digest("hex");
+	}
+	/**
+	* 使用SHA-1算法对文本进行哈希处理
+	*
+	* SHA-1是一种安全散列算法，它接收一个输入（在此例中为文本字符串），
+	* 并返回一个固定大小的160位散列值，通常以40位的十六进制数字表示
+	* 此函数用于将给定的文本转换为SHA-1散列值，常用于数据完整性校验或存储密码的散列值
+	*
+	* @param text 待哈希处理的文本字符串
+	* @returns 返回文本的SHA-1散列值，以十六进制字符串形式表示
+	*/
+	sha1(text) {
+		return crypto.createHash("sha1").update(text).digest("hex");
+	}
+	/**
+	* 使用SHA-256算法对文本进行哈希处理
+	*
+	* @param text 输入的文本字符串
+	* @returns 返回经过SHA-256哈希处理后的十六进制字符串
+	*/
+	sha256(text) {
+		return crypto.createHash("sha256").update(text).digest("hex");
+	}
+	/**
+	* 使用SHA-512算法对文本进行哈希处理
+	*
+	* @param text 输入的文本字符串
+	* @returns 返回经过SHA-512哈希处理后的字符串
+	*/
+	sha512(text) {
+		return crypto.createHash("sha512").update(text).digest("hex");
+	}
+	/**
+	* 使用给定的密钥对给定的字符串执行 AES 加密（加密模式为 ECB，填充方式为 PKCS7）。
+	*
+	* @param text - 要加密的字符串。
+	* @param key - 用于加密的密钥（仅支持16字节的密钥）。
+	*/
+	aesEncrypt(text, key) {
+		const cipher = crypto.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 = crypto.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) {
+		return this.aesEncrypt(JSON.stringify(payload), key);
+	}
+	/**
+	* 使用AES算法解密给定的文本，并将解密后的结果解析为JSON对象
+	*
+	* @param text 需要解密的加密文本
+	* @param key 解密用的密钥，必须与加密时使用的密钥相同
+	* @returns 返回解密后的JSON对象，类型为泛型T，根据调用时指定的类型解析
+	*/
+	aesDecryptJson(text, key) {
+		return JSON.parse(this.aesDecrypt(text, key));
+	}
+};
+export { CryptoService };

package/lib/services/db_value.d.mts

@@ -0,0 +1,60 @@
+import { BaseService } from "./base.mjs";
+export type DbValueServiceSimpleArrayOptions = {
+  /**
+   * 分隔符
+   *
+   * @default ,
+   */
+  separator?: string;
+  /**
+   * 前缀后缀
+   */
+  affix?: string;
+  /**
+   * 是否数字
+   */
+  number?: boolean;
+};
+export type DbValueServiceJsonObjectOptions<T> = {
+  transform?: {
+    add?: (value: T) => T;
+    get?: (value: T) => T;
+    update?: (value: T) => T;
+  };
+};
+export declare class DbValueService implements BaseService {
+  serviceName: string;
+  SimpleArray: {
+    new <T extends string | number = string>(options?: DbValueServiceSimpleArrayOptions): {
+      separator: string;
+      affix: string;
+      number: boolean;
+      add: (value?: T[], defaultValue?: T[]) => string;
+      get: (value?: string) => T[];
+      update: (value?: T[]) => string | undefined;
+    };
+  };
+  JsonArray: {
+    new <T = string>(): {
+      add: (value?: T[], defaultValue?: T[]) => string;
+      get: (value?: string) => T[];
+      update: (value?: T[]) => string | undefined;
+    };
+  };
+  JsonObject: {
+    new <T>(options?: DbValueServiceJsonObjectOptions<T>): {
+      options?: DbValueServiceJsonObjectOptions<T>;
+      hasTransformAdd: boolean;
+      hasTransformGet: boolean;
+      hasTransformUpdate: boolean;
+      add: (value?: T, defaultValue?: T) => string;
+      get: (value?: string) => T;
+      update: (value?: T) => string | undefined;
+    };
+  };
+}
+declare module '../x.mjs' {
+  interface X {
+    dbValue: DbValueService;
+  }
+}

package/lib/services/db_value.mjs

@@ -0,0 +1,64 @@
+import { isPlainObject } from "vtils";
+// src/services/db_value.ts
+var DbValueService = class {
+	serviceName = "dbValue";
+	SimpleArray = class {
+		separator;
+		affix;
+		number;
+		constructor(options) {
+			this.separator = options?.separator || ",";
+			this.affix = options?.affix || "";
+			this.number = !!options?.number;
+		}
+		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}`;
+		};
+		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;
+		};
+		update = (value) => {
+			const text = !value || !Array.isArray(value) ? void 0 : value.filter((v) => v != null && v !== "").join(this.separator);
+			return !text || !this.affix ? text : `${this.affix}${text}${this.affix}`;
+		};
+	};
+	JsonArray = class {
+		add = (value, defaultValue = []) => {
+			return JSON.stringify(!value || !Array.isArray(value) ? defaultValue : value);
+		};
+		get = (value) => {
+			return !value ? [] : JSON.parse(value);
+		};
+		update = (value) => {
+			return !value || !Array.isArray(value) ? void 0 : JSON.stringify(value);
+		};
+	};
+	JsonObject = class {
+		options;
+		hasTransformAdd = false;
+		hasTransformGet = false;
+		hasTransformUpdate = false;
+		constructor(options) {
+			this.options = options;
+			this.hasTransformAdd = !!options?.transform?.add;
+			this.hasTransformGet = !!options?.transform?.get;
+			this.hasTransformUpdate = !!options?.transform?.update;
+		}
+		add = (value, defaultValue = {}) => {
+			if (value && this.hasTransformAdd) value = this.options.transform.add(value);
+			return JSON.stringify(!value || !isPlainObject(value) ? defaultValue : value);
+		};
+		get = (value) => {
+			let result = !value ? {} : JSON.parse(value);
+			if (result && this.hasTransformGet) result = this.options.transform.get(result);
+			return result;
+		};
+		update = (value) => {
+			if (value && this.hasTransformUpdate) value = this.options.transform.update(value);
+			return !value || !isPlainObject(value) ? void 0 : JSON.stringify(value);
+		};
+	};
+};
+export { DbValueService };

package/lib/services/dingtalk.d.mts

@@ -0,0 +1,39 @@
+import { BaseService } from "./base.mjs";
+export interface DingtalkServiceOptions {
+  /**
+   * 访问口令。
+   */
+  accessToken: string;
+  /**
+   * 访问密钥。
+   */
+  secret: string;
+}
+export interface DingtalkServiceSendOptions {
+  /**
+   * 通知标题。
+   */
+  title: string;
+  /**
+   * 通知内容，Markdown 格式。
+   */
+  content: string;
+  /**
+   * 要提醒的人员，设为 `all` 表示 @ 所有人，设为手机号数组只 @ 指定人。
+   */
+  at?: 'all' | string[];
+}
+export declare class DingtalkService implements BaseService {
+  private options;
+  serviceName: string;
+  constructor(options: DingtalkServiceOptions);
+  send(options: DingtalkServiceSendOptions): Promise<{
+    errcode: number;
+    errmsg: string;
+  }>;
+}
+declare module '../x.mjs' {
+  interface X {
+    dingtalk: DingtalkService;
+  }
+}

package/lib/services/dingtalk.mjs

@@ -0,0 +1,44 @@
+import { xr } from "@jayfong/x-request";
+import crypto from "node:crypto";
+// src/services/dingtalk.ts
+var DingtalkService = class {
+	options;
+	serviceName = "dingtalk";
+	constructor(options) {
+		this.options = options;
+	}
+	async send(options) {
+		const timestamp = Date.now();
+		const sign = crypto.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 { data: body } = await xr.postJson({
+			url: "https://oapi.dingtalk.com/robot/send",
+			query: {
+				access_token: this.options.accessToken,
+				timestamp: `${timestamp}`,
+				sign
+			},
+			data
+		});
+		if (body.errcode !== 0) throw new Error(body.errmsg);
+		return body;
+	}
+};
+export { DingtalkService };

package/lib/services/dispose.d.mts

@@ -0,0 +1,17 @@
+import { BaseService } from "./base.mjs";
+export interface DisposeServiceOptions {
+  disposeOnExit?: boolean;
+}
+export declare class DisposeService implements BaseService {
+  private options?;
+  serviceName: string;
+  constructor(options?: DisposeServiceOptions | undefined);
+  private disposes;
+  add(fn: () => any): void;
+  dispose(): Promise<any[]>;
+}
+declare module '../x.mjs' {
+  interface X {
+    dispose: DisposeService;
+  }
+}

package/lib/services/dispose.mjs

@@ -0,0 +1,18 @@
+import onExit from "exit-hook";
+// src/services/dispose.ts
+var DisposeService = class {
+	options;
+	serviceName = "dispose";
+	constructor(options) {
+		this.options = options;
+		if (this.options?.disposeOnExit) onExit(() => this.dispose());
+	}
+	disposes = [];
+	add(fn) {
+		this.disposes.push(fn);
+	}
+	dispose() {
+		return Promise.all(this.disposes.map((dispose) => dispose()));
+	}
+};
+export { DisposeService };

package/lib/services/emoji.d.mts

@@ -0,0 +1,10 @@
+import { BaseService } from "./base.mjs";
+export declare class EmojiService implements BaseService {
+  serviceName: string;
+  unify(text: string): string;
+}
+declare module '../x.mjs' {
+  interface X {
+    emoji: EmojiService;
+  }
+}