biz-a-cli 2.3.78 → 2.3.79-15211

package/engine/bpm/workflow-runtime.js

@@ -1,5 +1,12 @@
-import { queryData, save as dbSave, deleteMD } from "../../db/db.js";
+import {
+	queryData,
+	save as dbSave,
+	deleteMD,
+	getGlobalConfig,
+} from "../../db/db.js";
 import vm from "node:vm";
+import { execCLIScriptWorker } from "../../worker/cliWorkerPool.js";
+import axios from "axios";
 
 // ================
 // INTERNAL HELPERS
@@ -243,7 +250,13 @@ export async function initiate(payload) {
 }
 
 export async function availableTransitions(payload) {
-	const { instanceId, userRoles = [], entityData = {}, apiConfig } = payload;
+	const {
+		instanceId,
+		userRoles = [],
+		entityData = {},
+		triggerType = "USER_EVENT",
+		apiConfig,
+	} = payload;
 
 	const instParam = {
 		length: 1,
@@ -311,6 +324,12 @@ export async function availableTransitions(payload) {
 				operator: "=",
 				value1: `'${instance.current_state}'`,
 			},
+			{
+				junction: "AND",
+				column: "SYS$BPM_TRANS_DEF.TRIGGER_TYPE",
+				operator: "=",
+				value1: `'${triggerType}'`,
+			},
 		],
 	};
 
@@ -461,6 +480,10 @@ export async function executeTransition(payload) {
 				key: "effect_type",
 			},
 			{ data: "SYS$BPM_TRANS_EFFECT_DEF.EVENT_NAME", key: "event_name" },
+			{
+				data: "SYS$BPM_TRANS_EFFECT_DEF.PAYLOAD_TEMPLATE",
+				key: "payload_template",
+			},
 		],
 		filter: [
 			{
@@ -583,7 +606,7 @@ export async function executeTransition(payload) {
 			from_state_code: transition.from_state_code,
 			to_state_code: transition.to_state_code,
 			sys$bpm_trans_def_id: transition.id,
-			trigger_type: "MANUAL",
+			trigger_type: "USER_EVENT",
 			actor_type: "USER",
 			actor_id: userId,
 			request_id: `TRANS_${transition.transition_code}_${instanceId}_${new Date().getTime()}`,
@@ -597,6 +620,7 @@ export async function executeTransition(payload) {
 			sys$bpm_trans_def_id: transition.id,
 			effect_type: eff.effect_type,
 			event_name: eff.event_name,
+			payload_evaluated: eff.payload_template || null,
 			status: "PENDING",
 			retry_count: 0,
 		}));
@@ -691,7 +715,7 @@ export async function terminate(payload) {
 			sys$bpm_wf_instance_id: Number(instanceId),
 			from_state_code: currentStateCode,
 			to_state_code: currentStateCode,
-			trigger_type: "MANUAL",
+			trigger_type: "USER_EVENT",
 			actor_type: "USER",
 			actor_id: userId || null,
 			request_id: `TERMINATE_${instanceId}_${new Date().getTime()}`,
@@ -779,10 +803,6 @@ async function fetchInstanceTasksAndTimers(payload) {
 		length: -1,
 		columns: [
 			{ data: "SYS$BPM_TASK.ID", key: "id" },
-			{
-				data: "SYS$BPM_TASK.SYS$BPM_WF_INSTANCE_ID",
-				key: "sys$bpm_wf_instance_id",
-			},
 			{ data: "SYS$BPM_TASK.STATE_CODE", key: "state_code" },
 			{ data: "SYS$BPM_TASK.NAME", key: "name" },
 			{ data: "SYS$BPM_TASK.STATUS", key: "status" },
@@ -822,10 +842,6 @@ async function fetchInstanceTasksAndTimers(payload) {
 		length: -1,
 		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.SYS$BPM_TASK_ID",
 				key: "sys$bpm_task_id",
@@ -950,7 +966,7 @@ export async function instanceLogs(payload) {
 				value1: String(instanceId),
 			},
 		],
-		orders: [{ column: "SYS$BPM_STATE_HISTORY.CREATED_AT", dir: "DESC" }],
+		order: [{ column: "SYS$BPM_STATE_HISTORY.CREATED_AT", dir: "ASC" }],
 	};
 	return await queryData(historyQuery, apiConfig);
 }
@@ -1009,7 +1025,7 @@ export async function instanceTasks(payload) {
 			{ data: "SYS$BPM_TASK.CLOSED_REASON", key: "closed_reason" },
 		],
 		filter: filters,
-		orders: [{ column: "SYS$BPM_TASK.CREATED_AT", dir: "DESC" }],
+		order: [{ column: "SYS$BPM_TASK.CREATED_AT", dir: "ASC" }],
 	};
 	return await queryData(taskQuery, apiConfig);
 }
@@ -1093,7 +1109,7 @@ export async function instanceEffectLogs(payload) {
 				value1: String(instanceId),
 			},
 		],
-		orders: [{ column: "SYS$BPM_EFFECT_LOG.CREATED_AT", dir: "DESC" }],
+		order: [{ column: "SYS$BPM_EFFECT_LOG.CREATED_AT", dir: "ASC" }],
 	};
 	return await queryData(effectQuery, apiConfig);
 }
@@ -1105,6 +1121,7 @@ export async function retryEffect(payload) {
 		length: -1,
 		columns: [
 			{ data: "SYS$BPM_EFFECT_LOG.ID", key: "id" },
+			{ data: "SYS$BPM_EFFECT_LOG.STATUS", key: "status" },
 			{ data: "SYS$BPM_EFFECT_LOG.RETRY_COUNT", key: "retry_count" },
 		],
 		filter: [
@@ -1116,21 +1133,376 @@ export async function retryEffect(payload) {
 			},
 		],
 	};
-	const effectRes = await queryData(effectQuery, apiConfig);
 
-	if (!effectRes.data || effectRes.data.length === 0) {
-		throw new Error("Effect not found.");
+	const effectRes = await queryData(effectQuery, apiConfig);
+	if (!effectRes || effectRes.length !== 1) {
+		throw new Error("Effect not found or found duplicate effects");
 	}
 
-	const currentRetry = parseInt(effectRes.data[0].retry_count, 10) || 0;
+	if (effectRes[0].status !== "FAILED") {
+		throw new Error("Action Denied: You can only retry FAILED effects.");
+	}
 
 	const dbModel = {
 		id: effectId,
-		status: "PENDING",
-		retry_count: currentRetry + 1,
+		status: "RETRYING",
 		error_message: "",
 	};
 
 	const result = await dbSave({ SYS$BPM_EFFECT_LOG: dbModel });
 	return result.data;
 }
+
+// ==========================================
+// BACKGROUND JOB EXECUTION BOUNDARIES
+// ==========================================
+
+export async function executeBackgroundTransition(payload, triggerType) {
+	const { instanceId, transitionCode, entityData = {}, apiConfig } = payload;
+
+	// 1. Reuse availableTransitions to automatically enforce Guard Rules and Trigger Types!
+	const validTransitions = await availableTransitions({
+		instanceId: Number(instanceId),
+		userRoles: ["SYSTEM"],
+		entityData: entityData,
+		apiConfig: apiConfig,
+		triggerType: triggerType, // Dynamic: "SYSTEM_EVENT" or "EXTERNAL_EVENT"
+	});
+
+	// 2. Find the exact matching transition
+	const target = validTransitions.find(
+		(t) =>
+			String(t.transition_code).toUpperCase() ===
+			String(transitionCode).toUpperCase(),
+	);
+
+	if (!target) {
+		throw new Error(
+			`Background Transition '${transitionCode}' failed. It is invalid, blocked by Guards, or is not a ${triggerType}.`,
+		);
+	}
+
+	// 3. Execute natively
+	await executeTransition({
+		instanceId: Number(instanceId),
+		transition: target,
+		userRoles: ["SYSTEM"],
+		entityData: entityData,
+		apiConfig: apiConfig,
+		userId: 0,
+	});
+}
+
+/**
+ * Executes the pure business logic for a BPM Effect.
+ * @param {Object} effectData - The raw row data from SYS$BPM_EFFECT_LOG
+ * @returns {Object} { success: boolean, message?: string, error?: string }
+ */
+export async function executeEffect(effectData) {
+	const effectType = String(
+		effectData.effect_type || effectData.EFFECT_TYPE,
+	).toUpperCase();
+	const eventName = effectData.event_name || effectData.EVENT_NAME;
+
+	console.log(
+		`[BPM Engine] Executing Effect [${effectType}] for Instance ${effectData.sys$bpm_wf_instance_id || effectData.SYS$BPM_WF_INSTANCE_ID}`,
+	);
+
+	try {
+		const rawPayload =
+			effectData.payload_evaluated || effectData.PAYLOAD_EVALUATED;
+		let parsedPayload = {};
+		if (rawPayload) {
+			try {
+				parsedPayload =
+					typeof rawPayload === "string"
+						? JSON.parse(rawPayload)
+						: rawPayload;
+			} catch (e) {
+				parsedPayload = { rawData: rawPayload };
+			}
+		}
+
+		const apiConfig = getGlobalConfig();
+
+		if (effectType === "CLI_SCRIPT") {
+			console.log(`[BPM Engine] Bridging Script: ${eventName}`);
+			const scriptResult = await execCLIScriptWorker(
+				apiConfig,
+				eventName,
+				parsedPayload,
+			);
+
+			// --- if cliScript of Effect need to run executeTransition ---
+			if (scriptResult && scriptResult.executeTransition) {
+				const targetCode = scriptResult.executeTransition;
+				const instanceId = Number(
+					effectData.sys$bpm_wf_instance_id ||
+						effectData.SYS$BPM_WF_INSTANCE_ID,
+				);
+				delete scriptResult.executeTransition;
+
+				await executeBackgroundTransition(
+					{
+						instanceId: instanceId,
+						transitionCode: targetCode,
+						entityData: parsedPayload || {},
+						apiConfig: apiConfig,
+					},
+					"SYSTEM_EVENT",
+				);
+			}
+
+			return {
+				success: true,
+				message: `Effect executed successfully.`,
+				data: scriptResult,
+			};
+		} else if (effectType === "HTTP") {
+			console.log(
+				`[BPM Engine] Executing HTTP Request: ${parsedPayload.url}`,
+			);
+			const response = await axios({
+				method: parsedPayload.method || "POST",
+				url: parsedPayload.url,
+				data: parsedPayload.data || {},
+				headers: parsedPayload.headers || {},
+			});
+			if (response.status >= 400) {
+				throw new Error(
+					`HTTP Error: ${response.status} - ${response.statusText}`,
+				);
+			}
+		} else if (effectType === "WEBHOOK") {
+			console.log(
+				`[BPM Engine] Dispatching Webhook: ${parsedPayload.url}`,
+			);
+			axios({
+				method: parsedPayload.method || "POST",
+				url: parsedPayload.url,
+				data: parsedPayload.data || {},
+				headers: parsedPayload.headers || {},
+			}).catch((err) => {
+				console.log(
+					`[BPM Engine] Webhook Silent Failure (${eventName}): ${err.message}`,
+				);
+			});
+		} else {
+			throw new Error(`Unrecognized EFFECT_TYPE: ${effectType}`);
+		}
+
+		return { success: true, message: `Effect executed successfully.` };
+	} catch (error) {
+		return {
+			success: false,
+			error: error.message || "Unknown execution error",
+		};
+	}
+}
+
+/**
+ * Executes the pure business logic for a BPM Timer / SLA breach.
+ * @param {Object} timerData - The raw row data from SYS$BPM_TIMER_JOB
+ * @returns {Object} { success: boolean, message?: string, error?: string }
+ */
+export async function executeTimerJob(timerData) {
+	console.log(
+		`[BPM Engine] Firing Timer [${timerData.timer_type || timerData.TIMER_TYPE}] for Instance ${timerData.sys$bpm_wf_instance_id || timerData.SYS$BPM_WF_INSTANCE_ID}`,
+	);
+
+	try {
+		const type = String(
+			timerData.timer_type || timerData.TIMER_TYPE,
+		).toUpperCase();
+		const instanceId =
+			timerData.sys$bpm_wf_instance_id ||
+			timerData.SYS$BPM_WF_INSTANCE_ID;
+		const stateCode = timerData.state_code || timerData.STATE_CODE;
+		const apiConfig = getGlobalConfig();
+
+		if (type === "SLA_TIMEOUT") {
+			// 1. Look up Workflow Def ID
+			const instRes = await queryData(
+				{
+					length: 1,
+					columns: [
+						{
+							data: "SYS$BPM_WF_INSTANCE.SYS$BPM_WORKFLOW_DEF_ID",
+							key: "def_id",
+						},
+					],
+					filter: [
+						{
+							junction: "",
+							column: "SYS$BPM_WF_INSTANCE.ID",
+							operator: "=",
+							value1: String(instanceId),
+						},
+					],
+				},
+				apiConfig,
+			);
+
+			if (!instRes || instRes.length === 0)
+				throw new Error("Workflow Instance not found.");
+
+			// 2. Look up State Configuration
+			const stateRes = await queryData(
+				{
+					length: 1,
+					columns: [
+						{
+							data: "SYS$BPM_STATE_DEF.TIMEOUT_ACTION_TYPE",
+							key: "timeout_action_type",
+						},
+						{
+							data: "SYS$BPM_STATE_DEF.TIMEOUT_EVENT_NAME",
+							key: "timeout_event_name",
+						},
+					],
+					filter: [
+						{
+							junction: "",
+							column: "SYS$BPM_STATE_DEF.SYS$BPM_WORKFLOW_DEF_ID",
+							operator: "=",
+							value1: String(instRes[0].def_id),
+						},
+						{
+							junction: "AND",
+							column: "SYS$BPM_STATE_DEF.STATE_CODE",
+							operator: "=",
+							value1: `'${stateCode}'`,
+						},
+					],
+				},
+				apiConfig,
+			);
+
+			if (stateRes && stateRes.length > 0) {
+				const actionType = String(
+					stateRes[0].timeout_action_type || "",
+				).toUpperCase();
+				const eventName = stateRes[0].timeout_event_name;
+
+				if (actionType === "EMIT EVENT" && eventName) {
+					const generatedPayload = JSON.stringify({
+						instanceId: Number(instanceId),
+					});
+					await dbSave(
+						{
+							SYS$BPM_EFFECT_LOG: {
+								id: null,
+								sys$bpm_wf_instance_id: Number(instanceId),
+								effect_type: "CLI_SCRIPT",
+								event_name: eventName,
+								payload_evaluated: generatedPayload, // INJECT IT HERE
+								status: "PENDING",
+								retry_count: 0,
+							},
+						},
+						apiConfig,
+					);
+				} else if (actionType === "AUTO TRANSITION") {
+					const transParam = {
+						length: -1,
+						columns: [
+							{ data: "SYS$BPM_TRANS_DEF.ID", key: "id" },
+							{
+								data: "SYS$BPM_TRANS_DEF.TRANSITION_CODE",
+								key: "transition_code",
+							},
+							{
+								data: "SYS$BPM_TRANS_DEF.FROM_STATE_CODE",
+								key: "from_state_code",
+							},
+							{
+								data: "SYS$BPM_TRANS_DEF.TO_STATE_CODE",
+								key: "to_state_code",
+							},
+							{
+								data: "SYS$BPM_TRANS_DEF.GUARD_TYPE",
+								key: "guard_type",
+							},
+							{
+								data: "SYS$BPM_TRANS_DEF.GUARD_RULE_KEY",
+								key: "guard_rule_key",
+							},
+						],
+						filter: [
+							{
+								junction: "",
+								column: "SYS$BPM_TRANS_DEF.SYS$BPM_WORKFLOW_DEF_ID",
+								operator: "=",
+								value1: String(instRes[0].def_id),
+							},
+							{
+								junction: "AND",
+								column: "SYS$BPM_TRANS_DEF.FROM_STATE_CODE",
+								operator: "=",
+								value1: `'${stateCode}'`,
+							},
+							{
+								junction: "AND",
+								column: "SYS$BPM_TRANS_DEF.TRIGGER_TYPE",
+								operator: "=",
+								value1: "'TIMER_EVENT'",
+							},
+						],
+					};
+
+					const timerTransitions = await queryData(
+						transParam,
+						apiConfig,
+					);
+					if (!timerTransitions || timerTransitions.length === 0) {
+						throw new Error(
+							`SLA Breached but no TIMER_EVENT transition found for state ${stateCode}`,
+						);
+					}
+
+					let validTransition = null;
+					for (const t of timerTransitions) {
+						// Assuming empty entityData for timer execution; Domain updates should happen prior to timer trigger
+						const guard = await evaluateGuardRule(
+							t.guard_type,
+							t.guard_rule_key,
+							{},
+						);
+						if (guard.isPassed) {
+							if (validTransition)
+								throw new Error(
+									"Ambiguous timer flow: Multiple valid TIMER_EVENT paths.",
+								);
+							validTransition = t;
+						}
+					}
+
+					if (!validTransition) {
+						throw new Error(
+							"SLA Breached but no TIMER_EVENT transition passed the guard rules.",
+						);
+					}
+
+					await executeTransition({
+						instanceId: Number(instanceId),
+						transition: validTransition,
+						userRoles: ["SYSTEM"],
+						entityData: {},
+						apiConfig: apiConfig,
+						userId: null,
+					});
+				}
+			}
+		}
+
+		return {
+			success: true,
+			message: `Timer ${timerData.id || timerData.ID} fired successfully.`,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error.message || "Unknown timer execution error",
+		};
+	}
+}

package/engine/bpm/workflow.js

@@ -144,7 +144,7 @@ export async function publish(payload) {
 					`${trans.fromStateCode}_TO_${trans.toStateCode}_${index}`,
 				from_state_code: trans.fromStateCode,
 				to_state_code: trans.toStateCode,
-				trigger_type: trans.triggerType || "MANUAL",
+				trigger_type: trans.triggerType || "USER_EVENT",
 				label: trans.label,
 				guard_type: trans.guardType || null,
 				guard_rule_key: trans.guardRuleKey || null,

package/engine/domain/system.js

@@ -0,0 +1,74 @@
+export const publishApp = async (data, argv = {}) => {
+	try {
+		process.env.BIZA_APP_SKIP_PARSE = "1";
+		const { addApp } = await import("../../bin/app.js");
+
+		const sourcePayload = Object.prototype.hasOwnProperty.call(
+			data || {},
+			"body",
+		)
+			? data.body
+			: data?.data;
+		const requestBody =
+			typeof sourcePayload === "string"
+				? JSON.parse(sourcePayload || "{}")
+				: sourcePayload || {};
+		const hasTransportEnvelope =
+			requestBody &&
+			typeof requestBody === "object" &&
+			typeof requestBody.body === "object" &&
+			(Object.prototype.hasOwnProperty.call(requestBody, "method") ||
+				Object.prototype.hasOwnProperty.call(requestBody, "query") ||
+				Object.prototype.hasOwnProperty.call(requestBody, "headers"));
+		const unwrappedPayload = hasTransportEnvelope
+			? requestBody.body
+			: requestBody;
+		const publishPayload =
+			unwrappedPayload &&
+			typeof unwrappedPayload === "object" &&
+			unwrappedPayload.addApp &&
+			typeof unwrappedPayload.addApp === "object"
+				? unwrappedPayload.addApp
+				: unwrappedPayload;
+		const params =
+			publishPayload &&
+			typeof publishPayload === "object" &&
+			typeof publishPayload.options === "object"
+				? publishPayload.options
+				: publishPayload && typeof publishPayload === "object"
+					? publishPayload
+					: {};
+		const toNumber = (value, fallback) => {
+			const parsed = Number(value);
+			return Number.isFinite(parsed) ? parsed : fallback;
+		};
+
+		const response = await addApp({
+			workingDir: params.workingDir || process.cwd(),
+			verbose: !!params.verbose,
+			server: argv.server || params.server || "http://localhost",
+			apiPort: toNumber(argv.port, toNumber(params.apiPort, 212)),
+			dbIndex: toNumber(argv.dbindex, toNumber(params.dbIndex, 2)),
+			sub:
+				argv.subdomain ||
+				params.sub ||
+				params.subdomain ||
+				data?.domainId,
+			files: params.files || params.fileList,
+			body: publishPayload,
+		});
+
+		return response;
+	} catch (error) {
+		return {
+			success: false,
+			error: error?.message || error,
+		};
+	} finally {
+		delete process.env.BIZA_APP_SKIP_PARSE;
+	}
+};
+
+export function publish(payload, argv = {}) {
+	return publishApp(payload, argv);
+}

package/migrations/1777727892577__bpm.sql

@@ -61,7 +61,7 @@ BEGIN
       TRANSITION_CODE VARCHAR(100) NOT NULL,
       FROM_STATE_CODE VARCHAR(100) NOT NULL,
       TO_STATE_CODE VARCHAR(100) NOT NULL,
-      TRIGGER_TYPE VARCHAR(30) DEFAULT ''MANUAL'' NOT NULL,
+      TRIGGER_TYPE VARCHAR(30) DEFAULT ''USER_EVENT'' NOT NULL,
       LABEL VARCHAR(100),
       GUARD_TYPE VARCHAR(30),
       GUARD_RULE_KEY VARCHAR(100),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "biz-a-cli",
-	"version": "2.3.78",
+	"version": "2.3.79-15211",
 	"description": "",
 	"main": "bin/index.js",
 	"type": "module",

package/readme.md

@@ -82,4 +82,29 @@
 	hub --server [BizA Hub Server] --sub [subdomain] --hostname [ip_API] --port [port_API] --publish [true]
 
 	Example :
-		hub --server https://server.biz-a.id --sub imamatek --hostname localhost --port 212 --publish
+		hub --server https://server.biz-a.id --sub imamatek --hostname localhost --port 212 --publish
+
+
+## IV. Scalability
+
+  ### a. Monolithic Mode (Default)
+	hub --mode monolithic --server [BizA Hub Server] --sub [subdomain]
+
+	Example :
+		hub --server https://server.biz-a.id --sub imamatek
+
+  ### b. Dispatcher Mode (Load Balancer & ESB)
+	hub --mode dispatcher --server [BizA Hub Server] --sub [subdomain]
+
+	Example :
+		hub --mode dispatcher --server https://server.biz-a.id --sub imamatek
+
+  ### c. Multiple Agent Mode (Worker Nodes)
+	hub --mode agent --dispatcherUrl [Dispatcher URL] --services [Services] --sp [Port]
+
+	Example :
+		hub --mode agent --dispatcherUrl http://localhost:3000 --services BPM,EMAIL --sp 3001
+		hub --mode agent --dispatcherUrl http://localhost:3000 --services BPM,EMAIL --sp 3002
+
+> [!TIP]
+>    When running multiple Agents on the same server, always define unique ports using --sp to avoid collisions.

package/scheduler/datalib.js

@@ -176,7 +176,11 @@ export async function setLibrary(config, libraries, defaultLib) {
 	return libs;
 }
 
-export async function extractFunctionScript(selectedConfig, data) {
+export async function extractFunctionScript(
+	selectedConfig,
+	data,
+	extraLib = {},
+) {
 	const config = getConfig(selectedConfig);
 
 	if (data.error) {
@@ -197,6 +201,7 @@ export async function extractFunctionScript(selectedConfig, data) {
 		crypto: crypto,
 		log: logger,
 		data: { sendModel, queryData, crudData, genId, getUrlAndParam },
+		...extraLib,
 	};
 
 	if (scriptFn().functions.useLibrary) {