biz-a-cli 2.3.78 → 2.3.79-15211

package/engine/bpm/bpm-agent.js

@@ -0,0 +1,372 @@
+import {
+	executeEffect,
+	executeTimerJob,
+	executeBackgroundTransition,
+} from "./workflow-runtime.js";
+import {
+	queryData,
+	save as dbSave,
+	executeBlock,
+	getGlobalConfig,
+} from "../../db/db.js";
+import dayjs from "dayjs";
+
+export function initBpmAgent(broker, services = "") {
+	const servicesHandleByAgent = services
+		.split(",")
+		.map((e) => e.trim().toUpperCase());
+	if (
+		!servicesHandleByAgent.includes("BPM") &&
+		!servicesHandleByAgent.includes("ALL")
+	) {
+		return;
+	}
+
+	console.log(`[BPM Agent] Initialized. Listening for smart triggers...`);
+
+	let isPollingEffects = false;
+	let isPollingTimers = false;
+
+	// ==========================================
+	// EVENT LISTENERS (The "Bus" Stops)
+	// ==========================================
+	broker.on("sys:tick", () => {
+		pollEffects();
+		pollTimers();
+	});
+
+	broker.on("bpm:externalTransition", async (payload) => {
+		try {
+			const { instanceId, transitionCode, entityData = {} } = payload;
+			const apiConfig = getGlobalConfig();
+
+			console.log(
+				`[BPM Agent] Received External Transition Intent '${transitionCode}' for Instance ${instanceId}`,
+			);
+
+			await executeBackgroundTransition(
+				{
+					instanceId: instanceId,
+					transitionCode: transitionCode,
+					entityData: entityData,
+					apiConfig: apiConfig,
+				},
+				"EXTERNAL_EVENT",
+			);
+
+			console.log(
+				`[BPM Agent] External Transition '${transitionCode}' executed successfully.`,
+			);
+		} catch (error) {
+			console.error(
+				`[BPM Agent] External Transition Failed:`,
+				error.message,
+			);
+		}
+	});
+
+	broker.on("bpm:effect", async (payload, ackCallback) => {
+		if (!payload || (!payload.id && !payload.ID)) {
+			pollEffects();
+			if (typeof ackCallback === "function")
+				ackCallback({ success: true, message: "Polling triggered" });
+			return;
+		}
+		await consumeEffect(payload, ackCallback);
+	});
+
+	broker.on("bpm:timerjob", async (payload, ackCallback) => {
+		if (!payload || (!payload.id && !payload.ID)) {
+			pollTimers();
+			if (typeof ackCallback === "function")
+				ackCallback({ success: true, message: "Polling triggered" });
+			return;
+		}
+		await consumeTimer(payload, ackCallback);
+	});
+
+	// ==========================================
+	// PRODUCERS (Database Pollers)
+	// ==========================================
+	async function pollEffects() {
+		if (isPollingEffects) return;
+		isPollingEffects = true;
+		try {
+			const effectQuery = {
+				length: 50,
+				columns: [
+					{ data: "SYS$BPM_EFFECT_LOG.ID", key: "id" },
+					{
+						data: "SYS$BPM_EFFECT_LOG.SYS$BPM_WF_INSTANCE_ID",
+						key: "sys$bpm_wf_instance_id",
+					},
+					{
+						data: "SYS$BPM_EFFECT_LOG.EFFECT_TYPE",
+						key: "effect_type",
+					},
+					{
+						data: "SYS$BPM_EFFECT_LOG.EVENT_NAME",
+						key: "event_name",
+					},
+					{
+						data: "SYS$BPM_EFFECT_LOG.PAYLOAD_EVALUATED",
+						key: "payload_evaluated",
+					},
+					{ data: "SYS$BPM_EFFECT_LOG.STATUS", key: "status" },
+					{
+						data: "SYS$BPM_EFFECT_LOG.RETRY_COUNT",
+						key: "retry_count",
+					},
+					{
+						data: "(CAST(SYS$BPM_EFFECT_LOG.EXECUTED_AT AS VARCHAR(24)))",
+						key: "executed_at",
+						alias: "executed_at",
+					},
+				],
+				filter: [
+					// {
+					// 	junction: "",
+					// 	column: "SYS$BPM_EFFECT_LOG.STATUS",
+					// 	operator: "in",
+					// 	value1: "('PENDING', 'RETRYING')",
+					// },
+
+					{
+						junction: "",
+						column: "SYS$BPM_EFFECT_LOG.STATUS",
+						operator: "=",
+						value1: "'PENDING'",
+					},
+					{
+						junction: "OR",
+						column: "SYS$BPM_EFFECT_LOG.STATUS",
+						operator: "=",
+						value1: "'RETRYING'",
+					},
+					// Filter out RETRYING records that haven't waited 60 seconds yet
+					{
+						junction: "AND",
+						column: "SYS$BPM_EFFECT_LOG.EXECUTED_AT",
+						operator: "<=",
+						value1: "DATEADD(-60 SECOND TO CURRENT_TIMESTAMP)",
+					},
+				],
+			};
+			const pendingEffects = (await queryData(effectQuery)) || [];
+
+			for (const rowData of pendingEffects) {
+				await consumeEffect(rowData, (ackResult) => {
+					if (
+						!ackResult.success &&
+						ackResult.reason !== "LOCKED_BY_OTHER"
+					) {
+						console.log(
+							`[BPM Agent] Effect ${rowData.id} failed:`,
+							ackResult.error,
+						);
+					}
+				});
+			}
+		} catch (e) {
+			console.error("[BPM Agent] Effect poll error:", e.message);
+		} finally {
+			isPollingEffects = false;
+		}
+	}
+
+	async function pollTimers() {
+		if (isPollingTimers) return;
+		isPollingTimers = true;
+
+		try {
+			const nowStr = dayjs().format("YYYY-MM-DD HH:mm:ss");
+			const timerQuery = {
+				length: 50,
+				columns: [
+					{ data: "SYS$BPM_TIMER_JOB.ID", key: "id" },
+					{
+						data: "SYS$BPM_TIMER_JOB.SYS$BPM_WF_INSTANCE_ID",
+						key: "sys$bpm_wf_instance_id",
+					},
+					{ data: "SYS$BPM_TIMER_JOB.STATE_CODE", key: "state_code" },
+					{ data: "SYS$BPM_TIMER_JOB.TIMER_TYPE", key: "timer_type" },
+				],
+				filter: [
+					{
+						junction: "",
+						column: "SYS$BPM_TIMER_JOB.STATUS",
+						operator: "=",
+						value1: "'OPEN'",
+					},
+					{
+						junction: "AND",
+						column: "SYS$BPM_TIMER_JOB.DUE_AT",
+						operator: "<=",
+						value1: `'${nowStr}'`,
+					},
+				],
+			};
+			const dueTimers = (await queryData(timerQuery)) || [];
+
+			for (const rowData of dueTimers) {
+				await consumeTimer(rowData, (ackResult) => {
+					if (
+						!ackResult.success &&
+						ackResult.reason !== "LOCKED_BY_OTHER"
+					) {
+						console.log(
+							`[BPM Agent] Timer ${rowData.id} failed:`,
+							ackResult.error,
+						);
+					}
+				});
+			}
+		} catch (e) {
+			console.error("[BPM Agent] Timer poll error:", e.message);
+		} finally {
+			isPollingTimers = false;
+		}
+	}
+
+	// ==========================================
+	// CONSUMERS (Executors)
+	// ==========================================
+	async function consumeEffect(payload, ackCallback) {
+		async function finalizeEffect(
+			id,
+			isSuccess,
+			payload,
+			errorMessage = "",
+		) {
+			if (isSuccess) {
+				await dbSave({
+					SYS$BPM_EFFECT_LOG: {
+						id,
+						status: "SUCCESS",
+						executed_at: new Date(),
+						error_message: "",
+					},
+				});
+			} else {
+				const currentRetry =
+					parseInt(payload.retry_count || payload.RETRY_COUNT, 10) ||
+					0;
+				const newRetryCount = currentRetry + 1;
+				const nextStatus = newRetryCount < 3 ? "RETRYING" : "FAILED";
+
+				await dbSave({
+					SYS$BPM_EFFECT_LOG: {
+						id,
+						status: nextStatus,
+						executed_at: new Date(),
+						retry_count: newRetryCount,
+						error_message: errorMessage,
+					},
+				});
+			}
+		}
+
+		const effectId = Number(payload.id || payload.ID);
+
+		try {
+			const lockSql = `
+				EXECUTE BLOCK RETURNS (CLAIMED INTEGER) AS
+				BEGIN
+					CLAIMED = 0;
+					UPDATE SYS$BPM_EFFECT_LOG SET STATUS = 'PROCESSING'
+					WHERE ID = ${effectId} AND STATUS IN ('PENDING', 'RETRYING');
+					IF (ROW_COUNT > 0) THEN CLAIMED = 1;
+					SUSPEND;
+				END
+			`;
+			const lockRes = await executeBlock(lockSql);
+			const lockData = lockRes?.data || lockRes;
+
+			if (!lockData || !lockData[0] || lockData[0].CLAIMED === 0) {
+				if (typeof ackCallback === "function")
+					ackCallback({
+						success: false,
+						reason: "LOCKED_BY_OTHER",
+						id: effectId,
+					});
+				return;
+			}
+
+			const engineResult = await executeEffect(payload);
+
+			await finalizeEffect(
+				effectId,
+				engineResult.success,
+				payload,
+				engineResult.error,
+			);
+
+			if (typeof ackCallback === "function") ackCallback(engineResult);
+		} catch (e) {
+			try {
+				await finalizeEffect(effectId, false, payload, e.message);
+			} catch (dbErr) {
+				console.error(
+					`[BPM Agent] FATAL: Could not revert Effect ${effectId}`,
+					dbErr.message,
+				);
+			}
+			if (typeof ackCallback === "function")
+				ackCallback({ success: false, error: e.message });
+		}
+	}
+
+	async function consumeTimer(payload, ackCallback) {
+		async function finalizeTimer(id, isSuccess) {
+			const dbPayload = isSuccess
+				? { id, status: "FIRED", fired_at: new Date() }
+				: { id, status: "OPEN" };
+
+			await dbSave({ SYS$BPM_TIMER_JOB: dbPayload });
+		}
+
+		const timerId = Number(payload.id || payload.ID);
+
+		try {
+			const lockSql = `
+				EXECUTE BLOCK RETURNS (CLAIMED INTEGER) AS
+				BEGIN
+					CLAIMED = 0;
+					UPDATE SYS$BPM_TIMER_JOB SET STATUS = 'PROCESSING'
+					WHERE ID = ${timerId} AND STATUS = 'OPEN';
+					IF (ROW_COUNT > 0) THEN CLAIMED = 1;
+					SUSPEND;
+				END
+			`;
+			const lockRes = await executeBlock(lockSql);
+			const lockData = lockRes?.data || lockRes;
+
+			if (!lockData || !lockData[0] || lockData[0].CLAIMED === 0) {
+				if (typeof ackCallback === "function")
+					ackCallback({
+						success: false,
+						reason: "LOCKED_BY_OTHER",
+						id: timerId,
+					});
+				return;
+			}
+
+			const engineResult = await executeTimerJob(payload);
+
+			await finalizeTimer(timerId, engineResult.success);
+
+			if (typeof ackCallback === "function") ackCallback(engineResult);
+		} catch (e) {
+			try {
+				await finalizeTimer(timerId, false);
+			} catch (dbErr) {
+				console.error(
+					`[BPM Agent] FATAL: Could not revert Timer ${timerId} to OPEN`,
+					dbErr.message,
+				);
+			}
+			if (typeof ackCallback === "function")
+				ackCallback({ success: false, error: e.message });
+		}
+	}
+}