@jayfong/x-server 2.118.1 → 3.0.0

package/lib/core/define_task.mjs

@@ -0,0 +1,102 @@
+import { x } from "../x.mjs";
+import { ms } from "vtils";
+import assert from "node:assert";
+import Queue$1 from "bull";
+// src/core/define_task.ts
+function defineTask(options) {
+	const queue = new Queue$1(options.name, {
+		redis: {
+			...x.redis.options,
+			maxRetriesPerRequest: null,
+			enableReadyCheck: false
+		},
+		prefix: `${x.appId}_task`,
+		defaultJobOptions: {
+			removeOnComplete: true,
+			removeOnFail: true
+		}
+	});
+	queue.process(options.concurrency || 1, async (job) => {
+		return options.handle(job.data);
+	});
+	return queue;
+}
+function defineSliceTask(options) {
+	const task = defineTask({
+		name: options.name,
+		concurrency: 1,
+		handle: async (data) => {
+			const list = (data.count ? await x.redis.multi([[
+				"lrange",
+				data.redisKey,
+				`-${data.count}`,
+				"-1"
+			], [
+				"ltrim",
+				data.redisKey,
+				"0",
+				`-${data.count + 1}`
+			]]).exec() : await x.redis.multi([[
+				"lrange",
+				data.redisKey,
+				"0",
+				"-1"
+			], ["del", data.redisKey]]).exec())[0][1].reverse().map((item) => JSON.parse(item));
+			if (list.length) return options.handle(list, data.key);
+		}
+	});
+	const addAction = async (data, addOptions) => {
+		const redisKeyPrefix = `${x.appId}_batch_task_${options.name}`;
+		const key = addOptions?.key || "";
+		const duration = addOptions?.duration != null ? ms(addOptions.duration) : typeof options.duration === "function" ? ms(options.duration(key)) : options.duration && ms(options.duration);
+		const threshold = addOptions?.threshold || typeof options.threshold && (typeof options.threshold === "function" ? options.threshold(key) : options.threshold);
+		const thresholdTimeout = addOptions?.thresholdTimeout != null ? ms(addOptions.thresholdTimeout) : typeof options.thresholdTimeout === "function" ? ms(options.thresholdTimeout(key)) : options.thresholdTimeout && ms(options.thresholdTimeout);
+		assert(duration != null || threshold != null, "参数 threshold 和 duration 必须至少设置 1 个");
+		const redisKey = !key ? redisKeyPrefix : `${redisKeyPrefix}_${key}`;
+		const res = await x.redis.multi([["llen", redisKey], [
+			"lpush",
+			redisKey,
+			JSON.stringify(data)
+		]]).exec();
+		const count = parseInt(res[0][1], 10) + 1;
+		if (duration != null) {
+			if (count === 1) await task.add({
+				key,
+				redisKey
+			}, { delay: duration });
+		} else if (threshold != null) {
+			const delayTaskId = redisKey;
+			const prevJob = await task.getJob(delayTaskId);
+			if (count === threshold) {
+				await prevJob?.remove();
+				await task.add({
+					key,
+					redisKey
+				});
+			} else if (thresholdTimeout) {
+				if (!prevJob) await task.add({
+					key,
+					redisKey
+				}, {
+					jobId: delayTaskId,
+					delay: thresholdTimeout
+				});
+			}
+		}
+	};
+	const addTask = defineTask({
+		name: `${options.name}_add`,
+		concurrency: 1,
+		handle: async (payload) => {
+			await addAction(payload.data, payload.options);
+		}
+	});
+	return { add: async (data, addOptions) => {
+		const delay = addOptions.delay && ms(addOptions.delay) || 0;
+		await addTask.add({
+			data,
+			options: addOptions
+		}, { delay });
+	} };
+}
+export { defineSliceTask, defineTask };

package/lib/core/get_handler_url.d.mts

@@ -0,0 +1,2 @@
+import { HandlerPath, HandlerPayloadMap } from "@a/x/routes";
+export declare function getHandlerUrl<T extends HandlerPath>(path: T, query?: Partial<HandlerPayloadMap[T]>): string;

package/lib/core/get_handler_url.mjs

@@ -0,0 +1,7 @@
+import { x } from "../x.mjs";
+import { createUrlQueryString } from "vtils";
+// src/core/get_handler_url.ts
+function getHandlerUrl(path, query) {
+	return `${x.env.APP_URL.replace(/\/+$/, "")}${path}${query ? `?${createUrlQueryString(query)}` : ""}`;
+}
+export { getHandlerUrl };

package/lib/core/handler.d.mts

@@ -0,0 +1,16 @@
+import { XHandler } from "./types.mjs";
+import * as vae from "vtils/vae";
+import { RequiredDeep } from "vtils/types";
+import { HandlerMethodMap, HandlerPath, HandlerPayloadMap, HandlerResultMap } from "@a/x/routes";
+export declare class Handler<TReqData extends any = void, TResData extends any = void, TReqMethod extends XHandler.Method = XHandler.Method, TReqDataRequired = RequiredDeep<TReqData>> {
+  readonly options: XHandler.Options<TReqData, TResData, TReqMethod>;
+  readonly requestDataSchemaVae: vae.VaeSchemaOf<TReqDataRequired>;
+  private requestHandle;
+  constructor(options: XHandler.Options<TReqData, TResData, TReqMethod>);
+  handle: XHandler.Handle<TReqData, TResData, TReqMethod>;
+  private handleHttp;
+  private handleWs;
+  private static hooks;
+  static addHook(hook: XHandler.Hook): void;
+}
+export type { HandlerMethodMap, HandlerPath, HandlerPayloadMap, HandlerResultMap };

package/lib/core/handler.mjs

@@ -0,0 +1,132 @@
+import { HttpError } from "./http_error.mjs";
+import { DisposeService } from "../services/dispose.mjs";
+import { ctxStorage } from "./ctx_storage.mjs";
+import { HttpRedirect } from "./http_redirect.mjs";
+import { Server } from "./server.mjs";
+import { HTTPError, ParseError, RequestError, TimeoutError } from "got";
+import LZString from "lz-string";
+import { DataPacker, asyncLimit, base64UrlEncode, rot13, toSingleLineString } from "vtils";
+import * as vae from "vtils/vae";
+// src/core/handler.ts
+var Handler = class Handler {
+	options;
+	requestDataSchemaVae;
+	requestHandle;
+	constructor(options) {
+		this.options = options;
+		if (options.requestDataSchemaVae) {
+			const res = typeof options.requestDataSchemaVae === "function" ? options.requestDataSchemaVae(new vae.VaeSchemaBuilder()) : options.requestDataSchemaVae;
+			this.requestDataSchemaVae = res instanceof vae.VaeSchema ? res : new vae.VaeObjectSchema(res);
+		}
+		if (options.concurrency != null) {
+			if (typeof options.concurrency === "number") this.requestHandle = asyncLimit(async (data, ctx) => options.handle(data, ctx), { concurrency: options.concurrency });
+			else {
+				const { count, groupBy } = options.concurrency;
+				this.requestHandle = asyncLimit(async (data, ctx) => options.handle(data, ctx), {
+					concurrency: count,
+					groupBy
+				});
+			}
+		} else this.requestHandle = options.handle;
+	}
+	handle = async (data, ctx) => {
+		if (Handler.hooks.length) await Promise.all(Handler.hooks.map((hook) => hook(this.options, data, ctx)));
+		let useAsyncContext = !!Server.options.useAsyncContext;
+		if (this.options.useAsyncContext != null) useAsyncContext = this.options.useAsyncContext;
+		ctx.setHeader("x-trace-id", ctx.traceId);
+		if (this.options.requestMethod === "WS") return useAsyncContext ? ctxStorage.run(ctx, () => this.handleWs(data, ctx)) : this.handleWs(data, ctx);
+		return useAsyncContext ? ctxStorage.run(ctx, () => this.handleHttp(data, ctx)) : this.handleHttp(data, ctx);
+	};
+	handleHttp = async (data, ctx) => {
+		if (this.options.parseRequestData) data = await this.options.parseRequestData(data, ctx);
+		if (this.requestDataSchemaVae) {
+			const res = this.requestDataSchemaVae.parse(data, {
+				abortEarly: true,
+				preserveUnknownKeys: false
+			});
+			if (res.success) data = res.data;
+			else throw new HttpError.BadRequest(res.issues[0].message);
+		}
+		try {
+			let res = await this.requestHandle(data, ctx);
+			if (res instanceof HttpRedirect) {
+				ctx.redirect(res.url, res.permanently);
+				return {};
+			}
+			if (this.options.responseContentType) ctx.setHeader("Content-Type", this.options.responseContentType);
+			if (this.options.responseDataPack) res = DataPacker.packAsRawType(res);
+			if (this.options.responseDataObfuscate) res = { "_#": LZString.compress(JSON.stringify(res)) };
+			if (this.options.responseDataEncrypt && Server.options.responseEncryptAlgorithm) {
+				if (Server.options.responseEncryptAlgorithm === "simple") res = { _$: rot13(base64UrlEncode(`${Date.now()}${JSON.stringify(res)}`)) };
+			}
+			return res == null ? {} : res;
+		} catch (err) {
+			if (HttpError.isHttpError(err)) throw err;
+			if (err instanceof HTTPError || err instanceof RequestError || err instanceof TimeoutError || err instanceof ParseError) console.error("网络请求错误", {
+				error: `${err.code || ""}__${err.name || ""}__${err.message || ""}`,
+				response: err.response?.body && err.options.responseType !== "buffer" ? toSingleLineString(String(err.response.body), 100) : "",
+				method: err.options.method,
+				url: err.options.url.toString(),
+				headers: JSON.stringify(err.options.headers || {}),
+				query: (err.options.search ?? err.options.searchParams?.toString()) || "",
+				body: (err.options.json ? JSON.stringify(err.options.json) : err.options.form ? new URLSearchParams(err.options.form).toString() : err.options.body?.toString()) || ""
+			});
+			else console.error("服务器错误", err);
+			throw new HttpError.InternalServerError("服务异常，请稍后再试");
+		}
+	};
+	handleWs = async (_data, ctx) => {
+		const dispose = new DisposeService();
+		ctx.ws.on("message", async (payload) => {
+			try {
+				const _ = JSON.parse(payload.toString("utf8"));
+				const send = (data) => {
+					ctx.ws.send(JSON.stringify({
+						id: _.id,
+						data
+					}));
+				};
+				const process = async (type, fn) => {
+					if (_.type === type) {
+						let sent = false;
+						try {
+							await fn({
+								data: _.data,
+								send: (data) => {
+									sent = true;
+									return send(data);
+								},
+								dispose
+							});
+							if (!sent) send();
+						} catch (err) {
+							const _err = HttpError.isHttpError(err) ? err : new HttpError.InternalServerError();
+							send({
+								statusCode: _err.statusCode,
+								error: _err.name,
+								message: _err.message
+							});
+						}
+					}
+				};
+				if (_.type === "ping") send();
+				else await this.options.handle(process, ctx);
+			} catch (err) {
+				const _err = HttpError.isHttpError(err) ? err : new HttpError.InternalServerError();
+				ctx.ws.send(JSON.stringify({
+					statusCode: _err.statusCode,
+					error: _err.name,
+					message: _err.message
+				}));
+			}
+		});
+		ctx.ws.on("close", () => {
+			dispose.dispose();
+		});
+	};
+	static hooks = [];
+	static addHook(hook) {
+		this.hooks.push(hook);
+	}
+};
+export { Handler };

package/lib/core/http_error.d.mts

@@ -0,0 +1,2 @@
+import HttpError from "http-errors";
+export { HttpError };

package/lib/core/http_error.mjs

@@ -0,0 +1 @@
+export { default as HttpError } from "http-errors";