@jayfong/x-server 2.119.0 → 3.0.0

package/lib/services/file_store.d.mts

@@ -0,0 +1,49 @@
+import { BaseService } from "./base.mjs";
+export type FileStoreServiceOptions = {
+  accessKey: string;
+  secretKey: string;
+  /** 如: cos.ap-guangzhou.myqcloud.com */
+  endpoint: string;
+  /** 如: image-311111 */
+  bucket: string;
+  /** 如: x */
+  dir: string;
+  /** 如: cdn.com */
+  cdnUrl: string;
+};
+export type FileStoreServiceGetUploadUrlPayload = {
+  fileName: string;
+  ttl: number;
+  keepName?: boolean;
+};
+export type FileStoreServiceGetUploadUrlResult = {
+  /** 文件类型 */
+  contentType: string;
+  /** 文件上传地址 */
+  uploadUrl: string;
+  /** 文件公开访问地址 */
+  publicUrl: string;
+};
+export type FileStoreServiceUploadPayload = {
+  /** 文件名 */
+  fileName: string;
+  /** 文件内容 */
+  content: Buffer;
+  keepName?: boolean;
+};
+export type FileStoreServiceUploadResult = FileStoreServiceGetUploadUrlResult;
+export declare class FileStoreService implements BaseService {
+  private options;
+  serviceName: string;
+  private endpoint;
+  private dir;
+  private cdnUrl;
+  constructor(options: FileStoreServiceOptions);
+  getUploadUrl(payload: FileStoreServiceGetUploadUrlPayload): Promise<FileStoreServiceGetUploadUrlResult>;
+  upload(payload: FileStoreServiceUploadPayload): Promise<FileStoreServiceUploadResult>;
+}
+declare module '../x.mjs' {
+  interface X {
+    fileStore: FileStoreService;
+  }
+}

package/lib/services/file_store.mjs

@@ -0,0 +1,58 @@
+import { x } from "../x.mjs";
+import { isUrl, ms } from "vtils";
+import { xr } from "@jayfong/x-request";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import mime from "mime";
+// src/services/file_store.ts
+var FileStoreService = class {
+	options;
+	serviceName = "fileStore";
+	endpoint = "";
+	dir = "";
+	cdnUrl = "";
+	constructor(options) {
+		this.options = options;
+		this.endpoint = isUrl(this.options.endpoint) ? this.options.endpoint : `https://${this.options.endpoint}`;
+		this.dir = this.options.dir ? `${this.options.dir.replace(/^\/+/, "").replace(/\/+$/, "")}` : "";
+		this.cdnUrl = (isUrl(this.options.cdnUrl) ? this.options.cdnUrl : `https://${this.options.cdnUrl}`).replace(/\/+$/, "");
+	}
+	async getUploadUrl(payload) {
+		const s3Client = new S3Client({
+			credentials: {
+				accessKeyId: this.options.accessKey,
+				secretAccessKey: this.options.secretKey
+			},
+			endpoint: this.endpoint,
+			region: "x"
+		});
+		const contentType = mime.getType(payload.fileName) || "application/octet-stream";
+		const fileName = payload.keepName ? payload.fileName : `${x.random.cuid2()}.${mime.getExtension(contentType)}`;
+		const dir = this.dir ? `${this.dir}/` : "";
+		const command = new PutObjectCommand({
+			Bucket: this.options.bucket,
+			Key: `${dir}${fileName}`,
+			ContentType: contentType
+		});
+		return {
+			contentType,
+			uploadUrl: await getSignedUrl(s3Client, command, { expiresIn: ms(payload.ttl, true) }),
+			publicUrl: `${this.cdnUrl}/${dir}${fileName}`
+		};
+	}
+	async upload(payload) {
+		const res = await this.getUploadUrl({
+			fileName: payload.fileName,
+			ttl: ms("1m"),
+			keepName: payload.keepName
+		});
+		await xr.post({
+			url: res.uploadUrl,
+			method: "PUT",
+			headers: { "Content-Type": res.contentType },
+			data: payload.content
+		});
+		return res;
+	}
+};
+export { FileStoreService };

package/lib/services/html.d.mts

@@ -0,0 +1,11 @@
+import { BaseService } from "./base.mjs";
+export declare class HtmlService implements BaseService {
+  serviceName: string;
+  escape(html: string): string;
+  unescape(html: string): string;
+}
+declare module '../x.mjs' {
+  interface X {
+    html: HtmlService;
+  }
+}

package/lib/services/html.mjs

@@ -0,0 +1,12 @@
+import { escapeHTML, unescapeHTML } from "fast-escape-html";
+// src/services/html.ts
+var HtmlService = class {
+	serviceName = "html";
+	escape(html) {
+		return escapeHTML(html);
+	}
+	unescape(html) {
+		return unescapeHTML(html);
+	}
+};
+export { HtmlService };

package/lib/services/jwt.d.mts

@@ -0,0 +1,33 @@
+import { BaseService } from "./base.mjs";
+import { MsValue } from "vtils";
+import jwt from "jsonwebtoken";
+import { LRUCache } from "lru-cache";
+import { RequiredBy } from "vtils/types";
+import { IncomingHttpHeaders } from "node:http";
+export interface JwtServiceJwtPayload extends Record<string, any> {}
+export interface JwtServiceOptions {
+  secret: string;
+  ttl: MsValue;
+  cache?: LRUCache.Options<string, JwtServiceJwtPayload, any>;
+  onVerify?: (payload: JwtServiceJwtPayload & RequiredBy<jwt.JwtPayload, 'iat' | 'exp'> & {
+    token: string;
+  }) => any;
+}
+export declare class JwtService implements BaseService {
+  private options;
+  serviceName: string;
+  private cache;
+  constructor(options: JwtServiceOptions);
+  sign<T extends JwtServiceJwtPayload>(payload: T, ttl?: MsValue): string;
+  verify<T extends JwtServiceJwtPayload>(token: string): Promise<T & {
+    token: string;
+  }>;
+  verifyFromHttpHeaders<T extends JwtServiceJwtPayload>(headers: IncomingHttpHeaders): Promise<T & {
+    token: string;
+  }>;
+}
+declare module '../x.mjs' {
+  interface X {
+    jwt: JwtService;
+  }
+}

package/lib/services/jwt.mjs

@@ -0,0 +1,42 @@
+import { HttpError } from "../core/http_error.mjs";
+import { ms } from "vtils";
+import jwt from "jsonwebtoken";
+import { LRUCache } from "lru-cache";
+import { differenceInMilliseconds, fromUnixTime } from "vtils/date";
+// src/services/jwt.ts
+var JwtService = class {
+	options;
+	serviceName = "jwt";
+	cache;
+	constructor(options) {
+		this.options = options;
+		if (options.cache) this.cache = new LRUCache(options.cache);
+	}
+	sign(payload, ttl = this.options.ttl) {
+		const token = jwt.sign(payload, this.options.secret, { expiresIn: ms(ttl, true) });
+		if (this.cache) this.cache.set(token, payload, { ttl: ms(ttl) });
+		return token;
+	}
+	async verify(token) {
+		const data = await new Promise((resolve, reject) => {
+			if (this.cache && this.cache.has(token)) resolve(this.cache.get(token));
+			else jwt.verify(token, this.options.secret, { ignoreExpiration: false }, (err, data) => {
+				if (err || !data || typeof data === "string" || !data.iat || !data.exp) reject(new HttpError.Unauthorized("data"));
+				else {
+					data.token = token;
+					if (this.cache) this.cache.set(token, data, { ttl: differenceInMilliseconds(fromUnixTime(data.exp), /* @__PURE__ */ new Date()) });
+					resolve(data);
+				}
+			});
+		});
+		await this.options.onVerify?.(data);
+		return data;
+	}
+	async verifyFromHttpHeaders(headers) {
+		const authorization = headers.authorization || headers["sec-websocket-protocol"] && `Bearer ${headers["sec-websocket-protocol"]}` || "";
+		if (!authorization) throw new HttpError.Unauthorized("header");
+		const [scheme, token = scheme] = authorization.split(" ");
+		return this.verify(token);
+	}
+};
+export { JwtService };

package/lib/services/log.d.mts

@@ -0,0 +1,37 @@
+import { BaseService } from "./base.mjs";
+import { Merge } from "vtils/types";
+export type LogServiceLevel = 'error' | 'info' | 'success';
+export type LogServiceDesc = Record<string, any> | any[];
+export type LogServiceWriter = 'file' | 'console';
+export type LogServicePayload = {
+  writer?: LogServiceWriter;
+  level: LogServiceLevel;
+  title: string;
+  desc?: LogServiceDesc;
+};
+export type LogServiceLogItem<K extends string = string> = Merge<LogServicePayload, {
+  traceId: string;
+  time: string;
+  desc: Record<K, any>;
+}>;
+export declare class LogService implements BaseService {
+  serviceName: string;
+  getLogFile(date: Date): string;
+  private get logFile();
+  private getLogWriter;
+  parseLogLineText<K extends string = string>(text: string, keysMap?: Record<string, string[]>): LogServiceLogItem<K>;
+  private log;
+  info: (title: string, desc?: LogServiceDesc) => void;
+  success: (title: string, desc?: LogServiceDesc) => void;
+  error: (title: string, desc?: LogServiceDesc) => void;
+  console: {
+    info: (title: string, desc?: LogServiceDesc) => void;
+    success: (title: string, desc?: LogServiceDesc) => void;
+    error: (title: string, desc?: LogServiceDesc) => void;
+  };
+}
+declare module '../x.mjs' {
+  interface X {
+    log: LogService;
+  }
+}

package/lib/services/log.mjs

@@ -0,0 +1,99 @@
+import { x } from "../x.mjs";
+import { memoize } from "vtils";
+import path from "node:path";
+import fs from "fs-extra";
+import { formatDate } from "vtils/date";
+// src/services/log.ts
+var LogService = class {
+	serviceName = "log";
+	getLogFile(date) {
+		const year = date.getFullYear();
+		const month = date.getMonth() + 1;
+		return path.join(x.dataDir, `log/${year}/${month < 10 ? `0${month}` : month}.log`);
+	}
+	get logFile() {
+		return this.getLogFile(/* @__PURE__ */ new Date());
+	}
+	getLogWriter = memoize((logFile) => {
+		fs.ensureFileSync(logFile);
+		return fs.createWriteStream(logFile, { flags: "a" });
+	}, (logFile) => logFile);
+	parseLogLineText(text, keysMap = {}) {
+		const segments = text.split(/\t+/);
+		if (segments[1].length < 10) segments.splice(1, 0, "");
+		const [time, traceId, level, title, ...desc] = segments;
+		return {
+			time,
+			traceId,
+			level,
+			title,
+			desc: desc.reduce((res, item, index) => {
+				if (keysMap[title]) res[keysMap[title][index]] = item;
+				else {
+					const i = item.indexOf(":");
+					res[item.substring(0, i)] = item.substring(i + 1);
+				}
+				return res;
+			}, {})
+		};
+	}
+	log(payload) {
+		const getContent = () => `${[
+			formatDate(/* @__PURE__ */ new Date(), "yyyy-mm-dd hh:ii:ss"),
+			...!x.ctx ? [] : [x.ctx.traceId],
+			payload.level,
+			payload.title,
+			...!payload.desc ? [] : Array.isArray(payload.desc) ? payload.desc : Object.keys(payload.desc).map((key) => `${key}:${payload.desc[key]}`)
+		].map((item) => String(item).replace(/[\r\n\t]+/g, " ")).join("	")}`;
+		if (payload.writer === "console") console[payload.level === "error" ? "error" : "log"](getContent());
+		else this.getLogWriter(this.logFile).write(`${getContent()}\n`);
+	}
+	info = (title, desc) => {
+		this.log({
+			level: "info",
+			title,
+			desc
+		});
+	};
+	success = (title, desc) => {
+		this.log({
+			level: "success",
+			title,
+			desc
+		});
+	};
+	error = (title, desc) => {
+		this.log({
+			level: "error",
+			title,
+			desc
+		});
+	};
+	console = {
+		info: (title, desc) => {
+			this.log({
+				writer: "console",
+				level: "info",
+				title,
+				desc
+			});
+		},
+		success: (title, desc) => {
+			this.log({
+				writer: "console",
+				level: "success",
+				title,
+				desc
+			});
+		},
+		error: (title, desc) => {
+			this.log({
+				writer: "console",
+				level: "error",
+				title,
+				desc
+			});
+		}
+	};
+};
+export { LogService };

package/lib/services/mail.d.mts

@@ -0,0 +1,22 @@
+import { BaseService } from "./base.mjs";
+import nodemailer from "nodemailer";
+export interface MailServiceOptions {
+  host: string;
+  port: number;
+  secure: boolean;
+  user: string;
+  pass: string;
+}
+export interface MailServiceSendOptions extends nodemailer.SendMailOptions {}
+export declare class MailService implements BaseService {
+  private options;
+  serviceName: string;
+  private transporter;
+  constructor(options: MailServiceOptions);
+  send(options: MailServiceSendOptions): Promise<any>;
+}
+declare module '../x.mjs' {
+  interface X {
+    mail: MailService;
+  }
+}

package/lib/services/mail.mjs

@@ -0,0 +1,28 @@
+import { x } from "../x.mjs";
+import nodemailer from "nodemailer";
+// src/services/mail.ts
+var MailService = class {
+	options;
+	serviceName = "mail";
+	transporter;
+	constructor(options) {
+		this.options = options;
+	}
+	async send(options) {
+		if (!this.transporter) {
+			this.transporter = nodemailer.createTransport({
+				host: this.options.host,
+				port: this.options.port,
+				secure: this.options.secure,
+				auth: {
+					user: this.options.user,
+					pass: this.options.pass
+				}
+			});
+			await this.transporter.verify();
+			x.dispose.add(() => this.transporter.close());
+		}
+		return this.transporter.sendMail(options);
+	}
+};
+export { MailService };

package/lib/services/pay.d.mts

@@ -0,0 +1,123 @@
+import { BaseService } from "./base.mjs";
+export interface PayServiceOptions {
+  /** 支付宝 */
+  alipay?: {
+    /** 应用 ID */
+    appId: string;
+    /** 商户应用私钥 */
+    privateKey: string;
+    /** 支付宝公钥，用于对返回结果验签 */
+    publicKey: string;
+  };
+  /** 微信支付(APIv3)，未实现回调验签，因此验证微信支付身份块不需要关心 */
+  wepay?: {
+    /** 公众号 APPID */
+    appId: string;
+    /** 商户 ID */
+    merchantId: string;
+    /** 商户API证书私钥 */
+    privateKey: string;
+    /** 商户API证书序列号 */
+    certificateSerialNumber: string;
+    /** 密钥，用于解密回调数据 */
+    secretKey: string;
+  };
+}
+export interface PayServicePrepareAlipayOptions {
+  /** 商品名称 */
+  goodsName: string;
+  /** 交易单号 */
+  tradeNumber: string;
+  /** 总金额 */
+  totalMoney: number;
+  /** 通知地址(POST) */
+  notifyUrl: string;
+  /** 返回地址 */
+  returnUrl?: string;
+}
+export interface PayServicePrepareAlipayResult {
+  /** 支付地址，需跳转过去 */
+  payUrl: string;
+}
+export interface PayServicePrepareWepayOptions {
+  /** 商品名称 */
+  goodsName: string;
+  /** 交易单号 */
+  tradeNumber: string;
+  /** 总金额 */
+  totalMoney: number;
+  /** 通知地址(POST) */
+  notifyUrl: string;
+  /** 公众号用户的 openid */
+  openid: string;
+}
+export interface PayServicePrepareWepayResult {
+  /** 支付参数，可直接传给 JSSDK 调用 */
+  payParams: {
+    appId: string;
+    timestamp: string;
+    nonceStr: string;
+    package: string;
+    signType: string;
+    paySign: string;
+  };
+}
+export interface PayServiceVerifyNotifyDataResult {
+  /**
+   * 渠道订单号。
+   *
+   * - 支付宝最长 `64` 位；
+   * - 微信支付最长 `32` 位。
+   */
+  channelOrderNo: string;
+}
+export interface PayServiceGetOrderInfoPayload {
+  /**
+   * 渠道。
+   */
+  channel: 'alipay' | 'wepay';
+  /**
+   * 商家订单号。
+   */
+  orderNo?: string;
+  /**
+   * 渠道订单号。
+   */
+  channelOrderNo?: string;
+}
+export interface PayServiceGetOrderInfoResult {
+  /**
+   * 商家订单号。
+   */
+  orderNo: string;
+  /**
+   * 渠道订单号。
+   *
+   * - 支付宝最长 `64` 位；
+   * - 微信支付最长 `32` 位。
+   */
+  channelOrderNo: string;
+  /**
+   * 订单状态。
+   */
+  status: 'success' | 'fail';
+}
+export declare class PayService implements BaseService {
+  private options;
+  serviceName: string;
+  private alipaySdk;
+  constructor(options: PayServiceOptions);
+  prepareAlipay(options: PayServicePrepareAlipayOptions): Promise<PayServicePrepareAlipayResult>;
+  prepareWepay(options: PayServicePrepareWepayOptions): Promise<PayServicePrepareWepayResult>;
+  verifyNotifyData(data: any): false | PayServiceVerifyNotifyDataResult;
+  verifyNotifyDataOrFail(data: any, message?: string): PayServiceVerifyNotifyDataResult;
+  getOrderInfo(payload: PayServiceGetOrderInfoPayload): Promise<PayServiceGetOrderInfoResult>;
+  private wepaySign;
+  private wepayDecrypt;
+  private wepayRequest;
+}
+declare module '../x.mjs' {
+  interface X {
+    pay: PayService;
+  }
+}

package/lib/services/pay.mjs

@@ -0,0 +1,157 @@
+import { HttpError } from "../core/http_error.mjs";
+import { xr } from "@jayfong/x-request";
+import crypto from "node:crypto";
+import { AlipayFormData, AlipaySdk } from "alipay-sdk";
+// src/services/pay.ts
+var PayService = class {
+	options;
+	serviceName = "pay";
+	alipaySdk;
+	constructor(options) {
+		this.options = options;
+	}
+	async prepareAlipay(options) {
+		if (!this.alipaySdk) this.alipaySdk = new AlipaySdk({
+			appId: this.options.alipay.appId,
+			privateKey: this.options.alipay.privateKey,
+			alipayPublicKey: this.options.alipay.publicKey
+		});
+		const formData = new AlipayFormData();
+		formData.setMethod("get");
+		formData.addField("notifyUrl", options.notifyUrl);
+		if (options.returnUrl) formData.addField("returnUrl", options.returnUrl);
+		formData.addField("bizContent", {
+			outTradeNo: options.tradeNumber,
+			productCode: "FAST_INSTANT_TRADE_PAY",
+			totalAmount: options.totalMoney,
+			subject: options.goodsName,
+			goodsType: "0",
+			passbackParams: "alipay"
+		});
+		return { payUrl: await this.alipaySdk.exec("alipay.trade.page.pay", {}, { formData }) };
+	}
+	async prepareWepay(options) {
+		const res = await this.wepayRequest("https://api.mch.weixin.qq.com/v3/pay/transactions/jsapi", {
+			appid: this.options.wepay.appId,
+			mchid: this.options.wepay.merchantId,
+			description: options.goodsName,
+			out_trade_no: options.tradeNumber,
+			attach: "wepay",
+			notify_url: options.notifyUrl,
+			amount: {
+				total: options.totalMoney * 100,
+				currency: "CNY"
+			},
+			payer: { openid: options.openid }
+		});
+		if (!res || !res.prepay_id) {
+			const error = res && res.message || "支付错误";
+			throw new Error(error);
+		}
+		const params = {
+			appId: this.options.wepay.appId,
+			timestamp: String(Math.round(Date.now() / 1e3)),
+			nonceStr: Math.random().toString().substr(2, 12),
+			package: `prepay_id=${res.prepay_id}`,
+			signType: "RSA",
+			paySign: ""
+		};
+		params.paySign = this.wepaySign([
+			params.appId,
+			params.timestamp,
+			params.nonceStr,
+			params.package
+		]);
+		return { payParams: params };
+	}
+	verifyNotifyData(data) {
+		try {
+			if (!data || typeof data !== "object") return false;
+			if (data.passback_params === "alipay") {
+				if (!this.alipaySdk?.checkNotifySign(data)) return false;
+				return { channelOrderNo: data.trade_no };
+			}
+			if (data.resource) {
+				const params = JSON.parse(this.wepayDecrypt(data.resource));
+				if (params.attach === "wepay") return { channelOrderNo: params.transaction_id };
+				return false;
+			}
+			return false;
+		} catch {
+			return false;
+		}
+	}
+	verifyNotifyDataOrFail(data, message) {
+		const res = this.verifyNotifyData(data);
+		if (!res) throw new HttpError.BadRequest(message);
+		return res;
+	}
+	async getOrderInfo(payload) {
+		if (payload.channel === "wepay") {
+			const res = await this.wepayRequest(payload.orderNo ? `https://api.mch.weixin.qq.com/v3/pay/transactions/out-trade-no/${payload.orderNo}?mchid=${this.options.wepay.merchantId}` : `https://api.mch.weixin.qq.com/v3/pay/transactions/id/${payload.channelOrderNo}?mchid=${this.options.wepay.merchantId}`);
+			return {
+				channelOrderNo: res.transaction_id,
+				orderNo: res.out_trade_no,
+				status: res.trade_state === "SUCCESS" ? "success" : "fail"
+			};
+		}
+		const res = await this.alipaySdk.exec("alipay.trade.query", { biz_content: payload.orderNo ? { out_trade_no: payload.orderNo } : { trade_no: payload.channelOrderNo } });
+		return {
+			channelOrderNo: res.trade_no,
+			orderNo: res.out_trade_no,
+			status: res.trade_status === "TRADE_SUCCESS" || res.trade_status === "TRADE_FINISHED" ? "success" : "fail"
+		};
+	}
+	wepaySign(data) {
+		return crypto.createSign("RSA-SHA256").update(data.map((v) => `${v}\n`).join("")).sign(this.options.wepay.privateKey, "base64");
+	}
+	wepayDecrypt(payload) {
+		const ciphertextBuffer = Buffer.from(payload.ciphertext, "base64");
+		const authTag = ciphertextBuffer.slice(ciphertextBuffer.length - 16);
+		const data = ciphertextBuffer.slice(0, ciphertextBuffer.length - 16);
+		const decipherIv = crypto.createDecipheriv("aes-256-gcm", this.options.wepay.secretKey, payload.nonce);
+		decipherIv.setAuthTag(Buffer.from(authTag));
+		decipherIv.setAAD(Buffer.from(payload.associated_data));
+		const decryptStr = decipherIv.update(data, void 0, "utf8");
+		decipherIv.final();
+		return decryptStr;
+	}
+	async wepayRequest(url, data) {
+		const path = url.replace(/^https?:\/\/[^/]+/, "");
+		const method = data == null ? "GET" : "POST";
+		const body = method === "POST" ? JSON.stringify(data) : "";
+		const params = {
+			method,
+			url: path,
+			time: String(Math.round(Date.now() / 1e3)),
+			rand: Math.random().toString().substr(2, 12),
+			body,
+			signature: ""
+		};
+		params.signature = this.wepaySign([
+			params.method,
+			params.url,
+			params.time,
+			params.rand,
+			params.body
+		]);
+		const Authorization = [
+			`WECHATPAY2-SHA256-RSA2048 `,
+			`mchid="${this.options.wepay.merchantId}",`,
+			`nonce_str="${params.rand}",`,
+			`signature="${params.signature}",`,
+			`timestamp="${params.time}",`,
+			`serial_no="${this.options.wepay.certificateSerialNumber}"`
+		].join("");
+		const { data: res } = method === "POST" ? await xr.postJson({
+			url,
+			headers: { Authorization },
+			data
+		}) : await xr.getJson({
+			url,
+			headers: { Authorization }
+		});
+		return res;
+	}
+};
+export { PayService };