groupmq-plus 1.1.1 → 1.1.3

package/dist/index.cjs

@@ -240,6 +240,7 @@ var Job = class Job {
 		this.timestamp = args.timestamp;
 		this.orderMs = args.orderMs;
 		this.status = args.status ?? "unknown";
+		this.parentId = args.parentId;
 	}
 	async getState() {
 		return this.status ?? "unknown";
@@ -288,6 +289,39 @@ var Job = class Job {
 	async waitUntilFinished(timeoutMs = 0) {
 		return this.queue.waitUntilFinished(this.id, timeoutMs);
 	}
+	/**
+	* Get all child jobs of this job (if it's a parent in a flow).
+	* @returns Array of child Job instances
+	*/
+	async getChildren() {
+		return this.queue.getFlowChildren(this.id);
+	}
+	/**
+	* Get the return values of all child jobs in a flow.
+	* @returns Object mapping child job IDs to their return values
+	*/
+	async getChildrenValues() {
+		return this.queue.getFlowResults(this.id);
+	}
+	/**
+	* Get the number of remaining child jobs that haven't completed yet.
+	* @returns Number of remaining dependencies, or null if not a parent job
+	*/
+	async getDependenciesCount() {
+		return this.queue.getFlowDependencies(this.id);
+	}
+	/**
+	* Get the parent job of this job (if it's a child in a flow).
+	* @returns Parent Job instance, or undefined if no parent or parent was deleted
+	*/
+	async getParent() {
+		if (!this.parentId) return void 0;
+		try {
+			return await this.queue.getJob(this.parentId);
+		} catch (_e) {
+			return;
+		}
+	}
 	static fromReserved(queue, reserved, meta) {
 		return new Job({
 			queue,
@@ -327,6 +361,7 @@ var Job = class Job {
 		const failedReason = (raw.failedReason ?? raw.lastErrorMessage) || void 0;
 		const stacktrace = (raw.stacktrace ?? raw.lastErrorStack) || void 0;
 		const returnvalue = raw.returnvalue ? safeJsonParse$1(raw.returnvalue) : void 0;
+		const parentId = raw.parentId || void 0;
 		return new Job({
 			queue,
 			id,
@@ -345,7 +380,8 @@ var Job = class Job {
 			returnvalue,
 			timestamp: timestampMs || Date.now(),
 			orderMs,
-			status: knownStatus ?? coerceStatus(raw.status)
+			status: knownStatus ?? coerceStatus(raw.status),
+			parentId
 		});
 	}
 	static async fromStore(queue, id) {
@@ -364,6 +400,7 @@ var Job = class Job {
 		const failedReason = (raw.failedReason ?? raw.lastErrorMessage) || void 0;
 		const stacktrace = (raw.stacktrace ?? raw.lastErrorStack) || void 0;
 		const returnvalue = raw.returnvalue ? safeJsonParse$1(raw.returnvalue) : void 0;
+		const parentId = raw.parentId || void 0;
 		const [inProcessing, inDelayed] = await Promise.all([queue.redis.zscore(`${queue.namespace}:processing`, id), queue.redis.zscore(`${queue.namespace}:delayed`, id)]);
 		let status = raw.status;
 		if (inProcessing !== null) status = "active";
@@ -389,7 +426,8 @@ var Job = class Job {
 			returnvalue,
 			timestamp: timestampMs || Date.now(),
 			orderMs,
-			status: coerceStatus(status)
+			status: coerceStatus(status),
+			parentId
 		});
 	}
 };
@@ -637,6 +675,38 @@ var Queue = class {
 		}
 		return parsed;
 	}
+	/**
+	* Gets all child job IDs for a parent job in a flow.
+	* @param parentId The ID of the parent job
+	* @returns An array of child job IDs
+	*/
+	async getFlowChildrenIds(parentId) {
+		return this.r.smembers(`${this.ns}:flow:children:${parentId}`);
+	}
+	/**
+	* Gets all child jobs for a parent job in a flow.
+	* @param parentId The ID of the parent job
+	* @returns An array of Job instances for all children
+	*/
+	async getFlowChildren(parentId) {
+		const ids = await this.getFlowChildrenIds(parentId);
+		if (ids.length === 0) return [];
+		const pipe = this.r.multi();
+		for (const id of ids) pipe.hgetall(`${this.ns}:job:${id}`);
+		const rows = await pipe.exec();
+		const jobs = [];
+		for (let i = 0; i < ids.length; i++) {
+			const id = ids[i];
+			const raw = rows?.[i]?.[1] || {};
+			if (!raw || Object.keys(raw).length === 0) {
+				this.logger.warn(`Skipping child job ${id} - not found (likely cleaned up)`);
+				continue;
+			}
+			const job = Job.fromRawHash(this, id, raw);
+			jobs.push(job);
+		}
+		return jobs;
+	}
 	async addSingle(opts) {
 		const now = Date.now();
 		let delayUntil = 0;
@@ -2520,7 +2590,10 @@ var _Worker = class extends TypedEventEmitter {
 		const oldest = Array.from(this.jobsInProgress)[0];
 		const now = Date.now();
 		return {
-			job: oldest.job,
+			job: Job.fromReserved(this.q, oldest.job, {
+				processedOn: oldest.ts,
+				status: "active"
+			}),
 			processingTimeMs: now - oldest.ts
 		};
 	}
@@ -2530,7 +2603,10 @@ var _Worker = class extends TypedEventEmitter {
 	getCurrentJobs() {
 		const now = Date.now();
 		return Array.from(this.jobsInProgress).map((item) => ({
-			job: item.job,
+			job: Job.fromReserved(this.q, item.job, {
+				processedOn: item.ts,
+				status: "active"
+			}),
 			processingTimeMs: now - item.ts
 		}));
 	}
@@ -2560,7 +2636,7 @@ var _Worker = class extends TypedEventEmitter {
 				} catch (e) {
 					const isConnErr = this.q.isConnectionError(e);
 					if (!isConnErr || !this.stopping) this.logger.error(`Heartbeat error for job ${job.id}:`, e instanceof Error ? e.message : String(e));
-					this.onError?.(e, job);
+					this.onError?.(e, Job.fromReserved(this.q, job, { status: "active" }));
 					if (!isConnErr || !this.stopping) this.emit("error", e instanceof Error ? e : new Error(String(e)));
 				}
 			}, minInterval);
@@ -2571,7 +2647,11 @@ var _Worker = class extends TypedEventEmitter {
 			heartbeatDelayTimer = setTimeout(() => {
 				startHeartbeat();
 			}, heartbeatThreshold);
-			const handlerResult = await this.handler(job);
+			const jobInstance = Job.fromReserved(this.q, job, {
+				processedOn: jobStartWallTime,
+				status: "active"
+			});
+			const handlerResult = await this.handler(jobInstance);
 			if (heartbeatDelayTimer) clearTimeout(heartbeatDelayTimer);
 			if (hbTimer) clearInterval(hbTimer);
 			const finishedAtWall = Date.now();
@@ -2595,7 +2675,11 @@ var _Worker = class extends TypedEventEmitter {
 	* Handle job failure: emit events, retry or dead-letter
 	*/
 	async handleJobFailure(err, job, jobStartWallTime) {
-		this.onError?.(err, job);
+		const jobInstance = Job.fromReserved(this.q, job, {
+			processedOn: jobStartWallTime,
+			status: "active"
+		});
+		this.onError?.(err, jobInstance);
 		this.blockingStats.consecutiveEmptyReserves = 0;
 		this.emptyReserveBackoffMs = 0;
 		try {
@@ -2681,9 +2765,122 @@ function sleep(ms) {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
+//#endregion
+//#region src/strategies/priority-strategy.ts
+var PriorityStrategy = class {
+	constructor(options = {}) {
+		this.cache = /* @__PURE__ */ new Map();
+		this.overrides = /* @__PURE__ */ new Map();
+		this.algorithmConfig = options.algorithm ?? { type: "weighted-random" };
+		this.defaultPriority = options.defaultPriority ?? 1;
+		this.cacheTtlMs = options.cacheTtlMs ?? 5e3;
+		this.onGetPriority = options.onGetPriority;
+	}
+	/**
+	* 手动覆盖某个组的优先级（优先级高于 Redis 配置和 getPriority）
+	* 主要用于测试或临时调整
+	*/
+	setPriority(groupId, priority) {
+		this.overrides.set(groupId, priority);
+	}
+	/**
+	* 清除手动覆盖，恢复使用 Redis 配置或 getPriority
+	*/
+	clearPriority(groupId) {
+		this.overrides.delete(groupId);
+	}
+	/**
+	* 获取组的基础优先级
+	* 优先级来源顺序：overrides > cache > onGetPriority(config) 或 config.priority
+	*/
+	async resolvePriority(queue, groupId) {
+		const override = this.overrides.get(groupId);
+		if (override !== void 0) return override;
+		const now = Date.now();
+		const cached = this.cache.get(groupId);
+		if (cached && cached.expiresAt > now) return cached.priority;
+		const config = await queue.getGroupConfig(groupId);
+		let priority;
+		if (this.onGetPriority) priority = await this.onGetPriority(groupId, config);
+		else priority = config.priority !== 1 ? config.priority : this.defaultPriority;
+		if (this.cacheTtlMs > 0) this.cache.set(groupId, {
+			priority,
+			expiresAt: now + this.cacheTtlMs
+		});
+		return priority;
+	}
+	/**
+	* 严格优先级算法：总是返回优先级最高的组
+	*/
+	selectByStrict(groups) {
+		groups.sort((a, b) => b.priority - a.priority);
+		return groups[0].groupId;
+	}
+	/**
+	* 加权随机算法：根据优先级计算概率选择
+	* 使用 minWeightRatio 确保低优先级组也有机会
+	*/
+	selectByWeightedRandom(groups) {
+		if (groups.length === 1) return groups[0].groupId;
+		const minWeightRatio = this.algorithmConfig.minWeightRatio ?? .1;
+		const minWeight = Math.max(...groups.map((g) => g.priority)) * minWeightRatio;
+		const weights = groups.map((g) => ({
+			groupId: g.groupId,
+			weight: Math.max(g.priority, minWeight)
+		}));
+		const totalWeight = weights.reduce((sum, w) => sum + w.weight, 0);
+		let random = Math.random() * totalWeight;
+		for (const w of weights) {
+			random -= w.weight;
+			if (random <= 0) return w.groupId;
+		}
+		return groups[0].groupId;
+	}
+	/**
+	* 时间衰减算法：等待时间越长，优先级加成越高
+	*/
+	selectByAging(groups) {
+		const now = Date.now();
+		const intervalMs = this.algorithmConfig.intervalMs ?? 6e4;
+		const adjustedGroups = groups.map((g) => {
+			let ageBonus = 0;
+			if (g.oldestTimestamp) {
+				const waitTime = now - g.oldestTimestamp;
+				ageBonus = Math.floor(waitTime / intervalMs);
+			}
+			return {
+				groupId: g.groupId,
+				adjustedPriority: g.priority + ageBonus
+			};
+		});
+		adjustedGroups.sort((a, b) => b.adjustedPriority - a.adjustedPriority);
+		return adjustedGroups[0].groupId;
+	}
+	async getNextGroup(queue) {
+		const readyGroups = await queue.getReadyGroups(0, 100);
+		if (readyGroups.length === 0) return null;
+		const groupInfos = await Promise.all(readyGroups.map(async (groupId) => {
+			const priority = await this.resolvePriority(queue, groupId);
+			const info = {
+				groupId,
+				priority
+			};
+			if (this.algorithmConfig.type === "aging") info.oldestTimestamp = await queue.getGroupOldestTimestamp(groupId);
+			return info;
+		}));
+		switch (this.algorithmConfig.type) {
+			case "strict": return this.selectByStrict(groupInfos);
+			case "aging": return this.selectByAging(groupInfos);
+			case "weighted-random":
+			default: return this.selectByWeightedRandom(groupInfos);
+		}
+	}
+};
+
 //#endregion
 exports.BullBoardGroupMQAdapter = BullBoardGroupMQAdapter;
 exports.Job = Job;
+exports.PriorityStrategy = PriorityStrategy;
 exports.Queue = Queue;
 exports.UnrecoverableError = UnrecoverableError;
 exports.Worker = Worker;