@jayfong/x-server 2.119.0 → 3.0.0

package/lib/services/random.d.mts

@@ -0,0 +1,27 @@
+import { BaseService } from "./base.mjs";
+export declare class RandomService implements BaseService {
+  serviceName: string;
+  /**
+   * 24位。
+   *
+   * @see https://github.com/paralleldrive/cuid2
+   */
+  cuid2(): string;
+  /**
+   * [0-9 a-z A-Z]
+   */
+  generateAlphanumeric(length: number): string;
+  /**
+   * [a-z A-Z]
+   */
+  generateAlphabetic(length: number): string;
+  /**
+   * [0-9]
+   */
+  generateNumeric(length: number): string;
+}
+declare module '../x.mjs' {
+  interface X {
+    random: RandomService;
+  }
+}

package/lib/services/random.mjs

@@ -0,0 +1,42 @@
+import { createId } from "@paralleldrive/cuid2";
+import randomstring from "randomstring";
+// src/services/random.ts
+var RandomService = class {
+	serviceName = "random";
+	/**
+	* 24位。
+	*
+	* @see https://github.com/paralleldrive/cuid2
+	*/
+	cuid2() {
+		return createId();
+	}
+	/**
+	* [0-9 a-z A-Z]
+	*/
+	generateAlphanumeric(length) {
+		return randomstring.generate({
+			charset: "alphanumeric",
+			length
+		});
+	}
+	/**
+	* [a-z A-Z]
+	*/
+	generateAlphabetic(length) {
+		return randomstring.generate({
+			charset: "alphabetic",
+			length
+		});
+	}
+	/**
+	* [0-9]
+	*/
+	generateNumeric(length) {
+		return randomstring.generate({
+			charset: "numeric",
+			length
+		});
+	}
+};
+export { RandomService };

package/lib/services/rate_limit.d.mts

@@ -0,0 +1,37 @@
+import { BaseService } from "./base.mjs";
+import { MsValue } from "vtils";
+export interface RateLimitServiceLimitByCountOptions {
+  key: string;
+  ttl: MsValue;
+  count: number;
+}
+export interface RateLimitServiceLimitByCountOrFailOptions extends RateLimitServiceLimitByCountOptions {
+  message?: string;
+}
+export interface RateLimitServiceLimitByManyCountOptions {
+  key: string;
+  limits: Array<{
+    ttl: MsValue;
+    count: number;
+  }>;
+}
+export interface RateLimitServiceLimitByManyCountOrFailOptions extends RateLimitServiceLimitByManyCountOptions {
+  message?: string;
+  limits: Array<{
+    ttl: MsValue;
+    count: number;
+    message?: string;
+  }>;
+}
+export declare class RateLimitService implements BaseService {
+  serviceName: string;
+  limitByCount(options: RateLimitServiceLimitByCountOptions): Promise<number>;
+  limitByCountOrFail(options: RateLimitServiceLimitByCountOrFailOptions): Promise<number>;
+  limitByManyCount(options: RateLimitServiceLimitByManyCountOptions): Promise<true | number>;
+  limitByManyCountOrFail(options: RateLimitServiceLimitByManyCountOrFailOptions): Promise<void>;
+}
+declare module '../x.mjs' {
+  interface X {
+    rateLimit: RateLimitService;
+  }
+}

package/lib/services/rate_limit.mjs

@@ -0,0 +1,40 @@
+import { HttpError } from "../core/http_error.mjs";
+import { x } from "../x.mjs";
+import { ms } from "vtils";
+// src/services/rate_limit.ts
+var RateLimitService = class {
+	serviceName = "rateLimit";
+	async limitByCount(options) {
+		const cacheKey = `rateLimit_${options.key}`;
+		const remainingCount = await x.cache.get(cacheKey);
+		if (remainingCount == null) {
+			await x.cache.set(cacheKey, options.count, options.ttl);
+			return options.count;
+		}
+		if (remainingCount === 0) return 0;
+		await x.cache.decrease(cacheKey);
+		return remainingCount - 1;
+	}
+	async limitByCountOrFail(options) {
+		const count = await this.limitByCount(options);
+		if (count === 0) throw new HttpError.Forbidden(options.message);
+		return count;
+	}
+	async limitByManyCount(options) {
+		for (let i = 0; i < options.limits.length; i++) {
+			const item = options.limits[i];
+			const ttl = ms(item.ttl);
+			if (await this.limitByCount({
+				key: `${options.key}_${ttl}`,
+				ttl,
+				count: item.count
+			}) === 0) return i;
+		}
+		return true;
+	}
+	async limitByManyCountOrFail(options) {
+		const pass = await this.limitByManyCount(options);
+		if (pass !== true) throw new HttpError.Forbidden(options.limits[pass].message ?? options.message);
+	}
+};
+export { RateLimitService };

package/lib/services/redis.d.mts

@@ -0,0 +1,11 @@
+import { BaseService } from "./base.mjs";
+import { Redis, RedisOptions } from "ioredis";
+export interface RedisServiceOptions extends RedisOptions {}
+export declare class RedisService extends Redis implements BaseService {
+  serviceName: string;
+}
+declare module '../x.mjs' {
+  interface X {
+    redis: RedisService;
+  }
+}

package/lib/services/redis.mjs

@@ -0,0 +1,6 @@
+import { Redis } from "ioredis";
+// src/services/redis.ts
+var RedisService = class extends Redis {
+	serviceName = "redis";
+};
+export { RedisService };

package/lib/services/sensitive_words.d.mts

@@ -0,0 +1,29 @@
+import { BaseService } from "./base.mjs";
+export interface SensitiveWordsServiceOptions {
+  /** 敏感词列表 */
+  words: string[];
+}
+/**
+ * 敏感词服务。
+ */
+export declare class SensitiveWordsService implements BaseService {
+  serviceName: string;
+  private sensitiveWords;
+  constructor(options: SensitiveWordsServiceOptions);
+  /**
+   * 文本转换。
+   */
+  private transform;
+  /**
+   * 验证文本是否包含敏感词。
+   */
+  validate(text: string, every?: boolean): Promise<{
+    pass: boolean;
+    words: string[];
+  }>;
+}
+declare module '../x.mjs' {
+  interface X {
+    sensitiveWords: SensitiveWordsService;
+  }
+}

package/lib/services/sensitive_words.mjs

@@ -0,0 +1,37 @@
+import { memoize, removeBlankChars, removeNonWordChars, toHalfWidthString, uniq } from "vtils";
+import { phoneNumberRegExpBuilder } from "vtils/regexp";
+// src/services/sensitive_words.ts
+const phoneNumberRegExp = phoneNumberRegExpBuilder.build();
+const toRegExp = memoize((re) => new RegExp(re.substring(1, re.length - 1)), (re) => re);
+/**
+* 敏感词服务。
+*/
+var SensitiveWordsService = class {
+	serviceName = "sensitiveWords";
+	sensitiveWords = [];
+	constructor(options) {
+		this.sensitiveWords = uniq(options.words.map((word) => word.toLowerCase()));
+	}
+	/**
+	* 文本转换。
+	*/
+	transform(text) {
+		return removeBlankChars(removeNonWordChars(toHalfWidthString(text))).toLowerCase().replace(/([^a-zA-Z0-9])\1+/g, "$1");
+	}
+	/**
+	* 验证文本是否包含敏感词。
+	*/
+	async validate(text, every) {
+		text = this.transform(text);
+		const words = [];
+		for (const word of this.sensitiveWords) if (word === "<手机号>" ? phoneNumberRegExp.test(text) : word[0] === "/" && word[word.length - 1] === "/" ? toRegExp(word).test(text) : text.includes(word)) {
+			words.push(word);
+			if (!every) break;
+		}
+		return {
+			pass: !words.length,
+			words
+		};
+	}
+};
+export { SensitiveWordsService };

package/lib/services/sms.d.mts

@@ -0,0 +1,40 @@
+import { BaseService } from "./base.mjs";
+export type SmsServiceProvider = 'tencentCloud';
+export type SmsServiceOptions = {
+  provider: 'tencentCloud';
+  providerOptions: {
+    appId: string;
+    secretId: string;
+    secretKey: string;
+  };
+};
+export type SmsServiceSendPayload = {
+  provider: SmsServiceProvider;
+  signature: string;
+  templateId: string;
+  templateParamValues: string[];
+  phoneNumber: string;
+};
+export type SmsServiceSendResult = {
+  success: boolean;
+  message: string;
+  smsId: string;
+};
+export type SmsServiceErrorType = 'TEXT_INTERCEPTION' | 'PROVIDER_EXCEPTION' | 'RATE_LIMITATION' | 'NUMBER_EXCEPTION' | 'USER_REJECTION' | 'OTHERS';
+export declare class SmsService implements BaseService {
+  private options;
+  serviceName: string;
+  constructor(options: SmsServiceOptions);
+  send(payload: SmsServiceSendPayload): Promise<SmsServiceSendResult>;
+  /**
+   * 推断错误类型
+   *
+   * @param errMsg 错误信息
+   */
+  static inferErrorType(errMsg: string): SmsServiceErrorType;
+}
+declare module '../x.mjs' {
+  interface X {
+    sms: SmsService;
+  }
+}