biz-a-cli 2.3.73 → 2.3.75

package/engine/bpm/workflow-runtime.js

@@ -0,0 +1,1136 @@
+import { queryData, save as dbSave, deleteMD } from "../../db/db.js";
+import vm from "node:vm";
+
+// ================
+// INTERNAL HELPERS
+// ================
+
+function buildStateEntryDetails(targetStateDef, isTerminal, instanceId) {
+	const details = { tasks: [], standaloneTimers: [] };
+	if (!targetStateDef || isTerminal) return details;
+
+	const taskEnabled = Number(targetStateDef.task_enabled) === 1;
+	const slaMinutes = Number(targetStateDef.sla_duration_minutes) || null;
+
+	if (taskEnabled) {
+		let assignedUser = null;
+		if (
+			targetStateDef.assignment_type === "USER" &&
+			targetStateDef.assignment_value
+		) {
+			assignedUser = parseInt(targetStateDef.assignment_value, 10);
+		}
+
+		const newTask = {
+			id: null,
+			state_code: targetStateDef.state_code,
+			name: targetStateDef.task_name,
+			status: "OPEN",
+			assignment_type: targetStateDef.assignment_type,
+			assignment_value: targetStateDef.assignment_value,
+			assigned_user_id: assignedUser,
+			sla_minutes: slaMinutes,
+		};
+
+		if (slaMinutes && slaMinutes > 0) {
+			newTask.SYS$BPM_TIMER_JOB = [
+				{
+					id: null,
+					sys$bpm_wf_instance_id: instanceId
+						? Number(instanceId)
+						: null,
+					state_code: targetStateDef.state_code,
+					timer_type: "SLA_TIMEOUT",
+					sla_minutes: slaMinutes,
+					status: "OPEN",
+				},
+			];
+		}
+		details.tasks.push(newTask);
+	} else if (slaMinutes && slaMinutes > 0) {
+		details.standaloneTimers.push({
+			id: null,
+			sys$bpm_wf_instance_id: instanceId ? Number(instanceId) : null,
+			sys$bpm_task_id: null,
+			state_code: targetStateDef.state_code,
+			timer_type: "SLA_TIMEOUT",
+			sla_minutes: slaMinutes,
+			status: "OPEN",
+		});
+	}
+
+	return details;
+}
+
+async function evaluateGuardRule(guardType, guardRuleKey, entityData) {
+	if (guardType !== "BUSINESS_RULE" || !guardRuleKey) {
+		return { isPassed: true, errorMsg: "" };
+	}
+	try {
+		// Create a secure, isolated sandbox object containing ONLY entityData as 'm'
+		const sandbox = { m: entityData };
+		vm.createContext(sandbox);
+
+		// Execute the expression securely, wrap it in () to evaluate as boolean expression
+		// `return (${guardRuleKey});`
+		const result = vm.runInContext(`(${guardRuleKey})`, sandbox, {
+			timeout: 1000,
+		});
+		const isPassed = Boolean(result);
+
+		return {
+			isPassed,
+			errorMsg: isPassed ? "" : `Requirement not met: ${guardRuleKey}`,
+		};
+	} catch (error) {
+		// console.error("Biz-A Guard Error:", error);
+		return {
+			isPassed: false,
+			errorMsg: `Invalid guard expression syntax.`,
+		};
+	}
+}
+
+// ===============
+// ENGINE ENDPOINT
+// ===============
+
+export async function initiate(payload) {
+	const { entityType, entityId, workflowDefId, apiConfig, userId } = payload;
+
+	let wfParam;
+
+	if (workflowDefId) {
+		wfParam = {
+			length: 1,
+			columns: [
+				{ data: "SYS$BPM_WORKFLOW_DEF.ID", key: "id" },
+				{
+					data: "SYS$BPM_WORKFLOW_DEF.INITIAL_STATE_CODE",
+					key: "initial_state_code",
+				},
+				{ data: "SYS$BPM_WORKFLOW_DEF.STATUS", key: "status" },
+				{ data: "SYS$BPM_WORKFLOW_DEF.VERSION", key: "version" },
+			],
+			filter: [
+				{
+					junction: "",
+					column: "SYS$BPM_WORKFLOW_DEF.ID",
+					operator: "=",
+					value1: workflowDefId,
+				},
+				{
+					junction: "AND",
+					column: "SYS$BPM_WORKFLOW_DEF.STATUS",
+					operator: "=",
+					value1: "'PUBLISHED'",
+				},
+			],
+		};
+	} else {
+		if (!entityType) {
+			throw new Error(
+				"Must provide either 'workflowDefId' or 'entityType' to start a workflow.",
+			);
+		}
+		wfParam = {
+			length: 1,
+			columns: [
+				{ data: "SYS$BPM_WORKFLOW_DEF.ID", key: "id" },
+				{
+					data: "SYS$BPM_WORKFLOW_DEF.INITIAL_STATE_CODE",
+					key: "initial_state_code",
+				},
+				{ data: "SYS$BPM_WORKFLOW_DEF.STATUS", key: "status" },
+				{ data: "SYS$BPM_WORKFLOW_DEF.VERSION", key: "version" },
+			],
+			filter: [
+				{
+					junction: "",
+					column: "SYS$BPM_WORKFLOW_DEF.ENTITY_TYPE",
+					operator: "=",
+					value1: `'${entityType}'`,
+				},
+				{
+					junction: "AND",
+					column: "SYS$BPM_WORKFLOW_DEF.STATUS",
+					operator: "=",
+					value1: "'PUBLISHED'",
+				},
+			],
+			order: [{ column: "VERSION", dir: "desc" }],
+		};
+	}
+
+	const wfDefs = await queryData(wfParam, apiConfig);
+
+	if (!wfDefs || wfDefs.length === 0) {
+		throw new Error(
+			`Action Denied: No published workflow found for ${entityType || "ID: " + workflowDefId}.`,
+		);
+	}
+
+	const def = wfDefs[0];
+	const actualDefId = workflowDefId || def.id;
+
+	const stateParam = {
+		length: 1,
+		columns: [
+			{ data: "SYS$BPM_STATE_DEF.STATE_CODE", key: "state_code" },
+			{ data: "SYS$BPM_STATE_DEF.TASK_ENABLED", key: "task_enabled" },
+			{ data: "SYS$BPM_STATE_DEF.TASK_NAME", key: "task_name" },
+			{
+				data: "SYS$BPM_STATE_DEF.ASSIGNMENT_TYPE",
+				key: "assignment_type",
+			},
+			{
+				data: "SYS$BPM_STATE_DEF.ASSIGNMENT_VALUE",
+				key: "assignment_value",
+			},
+			{
+				data: "SYS$BPM_STATE_DEF.SLA_DURATION_MINUTES",
+				key: "sla_duration_minutes",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_STATE_DEF.SYS$BPM_WORKFLOW_DEF_ID",
+				operator: "=",
+				value1: actualDefId,
+			},
+			{
+				junction: "AND",
+				column: "SYS$BPM_STATE_DEF.STATE_CODE",
+				operator: "=",
+				value1: `'${def.initial_state_code}'`,
+			},
+		],
+	};
+
+	const states = await queryData(stateParam, apiConfig);
+	const initialStateDef = states.length > 0 ? states[0] : null;
+	const entryDetails = buildStateEntryDetails(initialStateDef, false, null);
+
+	const instanceModel = {
+		id: null,
+		sys$bpm_workflow_def_id: actualDefId,
+		entity_type: entityType,
+		entity_id: String(entityId),
+		current_state_code: def.initial_state_code,
+		status: "ACTIVE",
+		version_no: def.version,
+		created_by: userId || null,
+		SYS$BPM_STATE_HISTORY: [
+			{
+				from_state_code: null,
+				to_state_code: def.initial_state_code,
+				trigger_type: "SYSTEM",
+				actor_type: "USER",
+				actor_id: userId || null,
+				request_id: `START_${entityType}_${entityId}_${new Date().getTime()}`,
+			},
+		],
+		SYS$BPM_TASK: entryDetails.tasks,
+		SYS$BPM_TIMER_JOB: entryDetails.standaloneTimers,
+	};
+
+	const result = await dbSave(
+		{ SYS$BPM_WF_INSTANCE: instanceModel },
+		apiConfig,
+	);
+	return result.data;
+}
+
+export async function availableTransitions(payload) {
+	const { instanceId, userRoles = [], entityData = {}, apiConfig } = payload;
+
+	const instParam = {
+		length: 1,
+		columns: [
+			{
+				data: "SYS$BPM_WF_INSTANCE.SYS$BPM_WORKFLOW_DEF_ID",
+				key: "def_id",
+			},
+			{
+				data: "SYS$BPM_WF_INSTANCE.CURRENT_STATE_CODE",
+				key: "current_state",
+			},
+			{ data: "SYS$BPM_WF_INSTANCE.STATUS", key: "status" },
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_WF_INSTANCE.ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+
+	const instRes = await queryData(instParam, apiConfig);
+	if (!instRes || instRes.length === 0)
+		throw new Error(`Instance ${instanceId} not found.`);
+
+	const instance = instRes[0];
+	const currentStatus = String(instance.status).toUpperCase();
+
+	if (currentStatus !== "ACTIVE") {
+		throw new Error(
+			`Action Denied: Cannot view transitions. Instance is currently ${currentStatus}.`,
+		);
+	}
+
+	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.LABEL", key: "label" },
+			{
+				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: instance.def_id,
+			},
+			{
+				junction: "AND",
+				column: "SYS$BPM_TRANS_DEF.FROM_STATE_CODE",
+				operator: "=",
+				value1: `'${instance.current_state}'`,
+			},
+		],
+	};
+
+	const rawTransitions = await queryData(transParam, apiConfig);
+	if (!rawTransitions || rawTransitions.length === 0) return [];
+
+	const permittedTransitions = [];
+	for (const t of rawTransitions) {
+		const roleQuery = {
+			length: -1,
+			columns: [
+				{ data: "SYS$BPM_TRANS_ROLE.ROLE_CODE", key: "role_code" },
+			],
+			filter: [
+				{
+					junction: "",
+					column: "SYS$BPM_TRANS_ROLE.SYS$BPM_TRANS_DEF_ID",
+					operator: "=",
+					value1: t.id,
+				},
+			],
+		};
+		const requiredRoles = (await queryData(roleQuery, apiConfig)) || [];
+
+		if (requiredRoles.length === 0) {
+			permittedTransitions.push(t);
+		} else {
+			const hasRole = requiredRoles.some((rr) =>
+				userRoles.includes(String(rr.role_code).toUpperCase()),
+			);
+			if (hasRole) permittedTransitions.push(t);
+		}
+	}
+
+	const evaluatedTransitions = [];
+	for (const t of permittedTransitions) {
+		const guard = await evaluateGuardRule(
+			t.guard_type,
+			t.guard_rule_key,
+			entityData,
+		);
+		evaluatedTransitions.push({
+			...t,
+			isGuardPassed: guard.isPassed,
+			guardHint: guard.isPassed ? "" : ` [DISABLED: ${guard.errorMsg}]`,
+		});
+	}
+
+	return evaluatedTransitions;
+}
+
+export async function executeTransition(payload) {
+	const {
+		instanceId,
+		transition,
+		userRoles = [],
+		entityData = {},
+		apiConfig,
+		userId,
+	} = payload;
+
+	const instParam = {
+		length: 1,
+		columns: [
+			{
+				data: "SYS$BPM_WF_INSTANCE.SYS$BPM_WORKFLOW_DEF_ID",
+				key: "wf_def_id",
+			},
+			{ data: "SYS$BPM_WF_INSTANCE.STATUS", key: "status" },
+			{
+				data: "SYS$BPM_WF_INSTANCE.CURRENT_STATE_CODE",
+				key: "current_state_code",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_WF_INSTANCE.ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+	const instances = await queryData(instParam, apiConfig);
+	if (!instances || instances.length === 0)
+		throw new Error(`Instance ID ${instanceId} not found.`);
+	const instanceRecord = instances[0];
+
+	const currentStatus = String(instanceRecord.status).toUpperCase();
+	if (currentStatus !== "ACTIVE")
+		throw new Error(`Action Denied: Instance is ${currentStatus}.`);
+	if (instanceRecord.current_state_code !== transition.from_state_code)
+		throw new Error(
+			`Action Denied: State has changed. Expected '${transition.from_state_code}'.`,
+		);
+
+	const guard = await evaluateGuardRule(
+		transition.guard_type,
+		transition.guard_rule_key,
+		entityData,
+	);
+	if (!guard.isPassed) throw new Error(`Action Denied: ${guard.errorMsg}`);
+
+	const wfDefId = Number(instanceRecord.wf_def_id);
+
+	const stateParam = {
+		length: 1,
+		columns: [
+			{ data: "SYS$BPM_STATE_DEF.STATE_CODE", key: "state_code" },
+			{ data: "SYS$BPM_STATE_DEF.TASK_ENABLED", key: "task_enabled" },
+			{ data: "SYS$BPM_STATE_DEF.TASK_NAME", key: "task_name" },
+			{
+				data: "SYS$BPM_STATE_DEF.ASSIGNMENT_TYPE",
+				key: "assignment_type",
+			},
+			{
+				data: "SYS$BPM_STATE_DEF.ASSIGNMENT_VALUE",
+				key: "assignment_value",
+			},
+			{
+				data: "SYS$BPM_STATE_DEF.SLA_DURATION_MINUTES",
+				key: "sla_duration_minutes",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_STATE_DEF.SYS$BPM_WORKFLOW_DEF_ID",
+				operator: "=",
+				value1: String(wfDefId),
+			},
+			{
+				junction: "AND",
+				column: "SYS$BPM_STATE_DEF.STATE_CODE",
+				operator: "=",
+				value1: `'${transition.to_state_code}'`,
+			},
+		],
+	};
+	const states = await queryData(stateParam, apiConfig);
+	const targetStateDef = states.length > 0 ? states[0] : null;
+
+	const effectsQuery = {
+		length: -1,
+		columns: [
+			{
+				data: "SYS$BPM_TRANS_EFFECT_DEF.EFFECT_TYPE",
+				key: "effect_type",
+			},
+			{ data: "SYS$BPM_TRANS_EFFECT_DEF.EVENT_NAME", key: "event_name" },
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TRANS_EFFECT_DEF.SYS$BPM_TRANS_DEF_ID",
+				operator: "=",
+				value1: transition.id,
+			},
+		],
+	};
+	const effects = (await queryData(effectsQuery, apiConfig)) || [];
+
+	const outgoingTransQuery = {
+		length: 1,
+		columns: [{ data: "SYS$BPM_TRANS_DEF.ID", key: "id" }],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TRANS_DEF.SYS$BPM_WORKFLOW_DEF_ID",
+				operator: "=",
+				value1: String(wfDefId),
+			},
+			{
+				junction: "AND",
+				column: "SYS$BPM_TRANS_DEF.FROM_STATE_CODE",
+				operator: "=",
+				value1: `'${transition.to_state_code}'`,
+			},
+		],
+	};
+	const outgoingTrans =
+		(await queryData(outgoingTransQuery, apiConfig)) || [];
+	const isTerminal = outgoingTrans.length === 0;
+
+	const rolesQuery = {
+		length: -1,
+		columns: [{ data: "SYS$BPM_TRANS_ROLE.ROLE_CODE", key: "role_code" }],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TRANS_ROLE.SYS$BPM_TRANS_DEF_ID",
+				operator: "=",
+				value1: transition.id,
+			},
+		],
+	};
+	const requiredRoles = (await queryData(rolesQuery, apiConfig)) || [];
+
+	if (requiredRoles.length > 0) {
+		const hasRole = requiredRoles.some((rr) =>
+			userRoles.includes(String(rr.role_code).toUpperCase()),
+		);
+		if (!hasRole)
+			throw new Error(
+				`Action Denied: You lack the required authorization role to execute this transition.`,
+			);
+	}
+
+	const tasksTimers = await fetchInstanceTasksAndTimers({
+		instanceId,
+		apiConfig,
+	});
+
+	const rawTasks = tasksTimers[0] || [];
+	const rawTimers = tasksTimers[1] || [];
+
+	const openTask = rawTasks.find(
+		(t) => t.status === "OPEN" || t.STATUS === "OPEN",
+	);
+	if (openTask) {
+		openTask.status = "DONE";
+		openTask.completed_by = userId;
+		openTask.closed_reason = "TRANSITIONED";
+	}
+
+	rawTimers.forEach((t) => {
+		if (t.status === "OPEN" || t.STATUS === "OPEN") t.status = "CANCELLED";
+	});
+
+	const oldStandaloneTimers = rawTimers.filter(
+		(t) => !t.sys$bpm_task_id && !t.SYS$BPM_TASK_ID,
+	);
+
+	const oldTaskTimers = rawTimers.filter(
+		(t) => t.sys$bpm_task_id || t.SYS$BPM_TASK_ID,
+	);
+
+	const processedTasks = rawTasks.map((t) => {
+		const myOldTimers = oldTaskTimers.filter(
+			(tmr) =>
+				String(tmr.sys$bpm_task_id || tmr.SYS$BPM_TASK_ID) ===
+				String(t.id || t.ID),
+		);
+		if (myOldTimers.length > 0) {
+			t.SYS$BPM_TIMER_JOB = myOldTimers;
+		}
+		return t;
+	});
+
+	const entryDetails = buildStateEntryDetails(
+		targetStateDef,
+		isTerminal,
+		instanceId,
+	);
+
+	const transitionPayload = {
+		SYS$BPM_WF_INSTANCE: {
+			id: Number(instanceId),
+			current_state_code: transition.to_state_code,
+			status: isTerminal ? "COMPLETED" : "ACTIVE",
+			SYS$BPM_TIMER_JOB: [
+				...oldStandaloneTimers,
+				...entryDetails.standaloneTimers,
+			],
+			SYS$BPM_TASK: [...processedTasks, ...entryDetails.tasks],
+		},
+		SYS$BPM_STATE_HISTORY: {
+			id: null,
+			sys$bpm_wf_instance_id: Number(instanceId),
+			from_state_code: transition.from_state_code,
+			to_state_code: transition.to_state_code,
+			sys$bpm_trans_def_id: transition.id,
+			trigger_type: "MANUAL",
+			actor_type: "USER",
+			actor_id: userId,
+			request_id: `TRANS_${transition.transition_code}_${instanceId}_${new Date().getTime()}`,
+		},
+	};
+
+	if (effects && effects.length > 0) {
+		transitionPayload.SYS$BPM_EFFECT_LOG = effects.map((eff) => ({
+			id: null,
+			sys$bpm_wf_instance_id: Number(instanceId),
+			sys$bpm_trans_def_id: transition.id,
+			effect_type: eff.effect_type,
+			event_name: eff.event_name,
+			status: "PENDING",
+			retry_count: 0,
+		}));
+	}
+
+	const result = await dbSave(transitionPayload, apiConfig);
+	return result.data;
+}
+
+export async function terminate(payload) {
+	const { instanceId, apiConfig, userId } = payload;
+
+	const queryParam = {
+		length: 1,
+		columns: [
+			{ data: "SYS$BPM_WF_INSTANCE.STATUS", key: "status" },
+			{
+				data: "SYS$BPM_WF_INSTANCE.CURRENT_STATE_CODE",
+				key: "current_state_code",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_WF_INSTANCE.ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+
+	const records = (await queryData(queryParam, apiConfig)) || [];
+	if (records.length === 0)
+		throw new Error(`Instance ID ${instanceId} not found.`);
+
+	const currentStatus = String(records[0].status).toUpperCase();
+	const currentStateCode = records[0].current_state_code;
+
+	if (currentStatus === "TERMINATED" || currentStatus === "COMPLETED") {
+		throw new Error(`Action Denied: Instance is already ${currentStatus}.`);
+	}
+	if (currentStatus !== "ACTIVE") {
+		throw new Error(
+			`Action Denied: Cannot terminate instance with status ${currentStatus}.`,
+		);
+	}
+
+	const tasksTimers = await fetchInstanceTasksAndTimers({
+		instanceId,
+		apiConfig,
+	});
+	const rawTasks = tasksTimers[0] || [];
+	const rawTimers = tasksTimers[1] || [];
+
+	rawTasks.forEach((t) => {
+		if (t.status === "OPEN" || t.STATUS === "OPEN") {
+			t.status = "CANCELLED";
+			t.closed_reason = "TERMINATED";
+		}
+	});
+
+	rawTimers.forEach((t) => {
+		if (t.status === "OPEN" || t.STATUS === "OPEN") t.status = "CANCELLED";
+	});
+
+	const standaloneTimers = rawTimers.filter(
+		(t) => !t.sys$bpm_task_id && !t.SYS$BPM_TASK_ID,
+	);
+	const taskTimers = rawTimers.filter(
+		(t) => t.sys$bpm_task_id || t.SYS$BPM_TASK_ID,
+	);
+
+	const processedTasks = rawTasks.map((t) => {
+		const myOldTimers = taskTimers.filter(
+			(tmr) =>
+				String(tmr.sys$bpm_task_id || tmr.SYS$BPM_TASK_ID) ===
+				String(t.id || t.ID),
+		);
+		if (myOldTimers.length > 0) t.SYS$BPM_TIMER_JOB = myOldTimers;
+		return t;
+	});
+
+	const ormPayload = {
+		SYS$BPM_WF_INSTANCE: {
+			id: Number(instanceId),
+			status: "TERMINATED",
+			SYS$BPM_TASK: processedTasks,
+			SYS$BPM_TIMER_JOB: standaloneTimers,
+		},
+		SYS$BPM_STATE_HISTORY: {
+			id: null,
+			sys$bpm_wf_instance_id: Number(instanceId),
+			from_state_code: currentStateCode,
+			to_state_code: currentStateCode,
+			trigger_type: "MANUAL",
+			actor_type: "USER",
+			actor_id: userId || null,
+			request_id: `TERMINATE_${instanceId}_${new Date().getTime()}`,
+		},
+	};
+
+	const result = await dbSave(ormPayload, apiConfig);
+	return result.data;
+}
+
+export async function remove(payload) {
+	const { instanceId, apiConfig } = payload;
+	const detailTables = [
+		"SYS$BPM_STATE_HISTORY",
+		"SYS$BPM_TASK",
+		"SYS$BPM_TIMER_JOB",
+		"SYS$BPM_EFFECT_LOG",
+	];
+
+	const result = await deleteMD(
+		Number(instanceId),
+		"SYS$BPM_WF_INSTANCE",
+		detailTables,
+		apiConfig,
+	);
+	return result.data;
+}
+
+export async function myTasks(payload) {
+	const { userRoles = [], apiConfig } = payload;
+
+	if (userRoles.length === 0) return [];
+
+	const roleSqlArray = userRoles.map((r) => `'${r}'`).join(",");
+
+	const param = {
+		length: -1,
+		columns: [
+			{ data: "SYS$BPM_TASK.ID", key: "id" },
+			{ data: "SYS$BPM_TASK.SYS$BPM_WF_INSTANCE_ID", key: "instance_id" },
+			{ data: "SYS$BPM_TASK.NAME", key: "name", title: "Task Name" },
+			{
+				data: "(CAST(SYS$BPM_TASK.CREATED_AT AS VARCHAR(24)))",
+				key: "created_at",
+				title: "Assigned At",
+				alias: "created_at",
+			},
+			{
+				data: "(CAST(SYS$BPM_TASK.DUE_AT AS VARCHAR(24)))",
+				key: "due_date",
+				title: "Due At",
+				alias: "due_date",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TASK.STATUS",
+				operator: "=",
+				value1: "'OPEN'",
+			},
+			{
+				junction: "and",
+				column: "SYS$BPM_TASK.ASSIGNMENT_TYPE",
+				operator: "=",
+				value1: "'ROLE'",
+			},
+			{
+				junction: "and",
+				column: "SYS$BPM_TASK.ASSIGNMENT_VALUE",
+				operator: "in",
+				value1: `(${roleSqlArray})`,
+			},
+		],
+	};
+
+	const res = await queryData(param, apiConfig);
+	return res || [];
+}
+
+async function fetchInstanceTasksAndTimers(payload) {
+	const { instanceId, apiConfig } = payload;
+
+	const taskQuery = {
+		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" },
+			{ data: "SYS$BPM_TASK.ASSIGNMENT_TYPE", key: "assignment_type" },
+			{ data: "SYS$BPM_TASK.ASSIGNMENT_VALUE", key: "assignment_value" },
+			{ data: "SYS$BPM_TASK.ASSIGNED_USER_ID", key: "assigned_user_id" },
+			{ data: "SYS$BPM_TASK.SLA_MINUTES", key: "sla_minutes" },
+			{ data: "SYS$BPM_TASK.COMPLETED_BY", key: "completed_by" },
+			{ data: "SYS$BPM_TASK.CLOSED_REASON", key: "closed_reason" },
+			{
+				data: "(CAST(SYS$BPM_TASK.CREATED_AT AS VARCHAR(24)))",
+				key: "created_at",
+				alias: "CREATED_AT",
+			},
+			{
+				data: "(CAST(SYS$BPM_TASK.DUE_AT AS VARCHAR(24)))",
+				key: "due_at",
+				alias: "DUE_AT",
+			},
+			{
+				data: "(CAST(SYS$BPM_TASK.COMPLETED_AT AS VARCHAR(24)))",
+				key: "completed_at",
+				alias: "COMPLETED_AT",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TASK.SYS$BPM_WF_INSTANCE_ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+
+	const timerQuery = {
+		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",
+			},
+			{ data: "SYS$BPM_TIMER_JOB.STATE_CODE", key: "state_code" },
+			{ data: "SYS$BPM_TIMER_JOB.TIMER_TYPE", key: "timer_type" },
+			{ data: "SYS$BPM_TIMER_JOB.STATUS", key: "status" },
+			{ data: "SYS$BPM_TIMER_JOB.SLA_MINUTES", key: "sla_minutes" },
+			{
+				data: "(CAST(SYS$BPM_TIMER_JOB.DUE_AT AS VARCHAR(24)))",
+				key: "due_at",
+				alias: "DUE_AT",
+			},
+			{
+				data: "(CAST(SYS$BPM_TIMER_JOB.FIRED_AT AS VARCHAR(24)))",
+				key: "fired_at",
+				alias: "FIRED_AT",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TIMER_JOB.SYS$BPM_WF_INSTANCE_ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+
+	return await Promise.all([
+		queryData(taskQuery, apiConfig),
+		queryData(timerQuery, apiConfig),
+	]);
+}
+
+export async function instanceState(payload) {
+	const { instanceId, apiConfig } = payload;
+	const instanceQuery = {
+		length: -1,
+		columns: [
+			{ data: "SYS$BPM_WF_INSTANCE.ID", key: "id" },
+			{
+				data: "SYS$BPM_WF_INSTANCE.SYS$BPM_WORKFLOW_DEF_ID",
+				key: "SYS$BPM_WORKFLOW_DEF_ID",
+			},
+			{ data: "SYS$BPM_WF_INSTANCE.ENTITY_TYPE", key: "entity_type" },
+			{ data: "SYS$BPM_WF_INSTANCE.ENTITY_ID", key: "entity_id" },
+			{
+				data: "SYS$BPM_WF_INSTANCE.CURRENT_STATE_CODE",
+				key: "current_state_code",
+			},
+			{ data: "SYS$BPM_WF_INSTANCE.STATUS", key: "status" },
+			{ data: "SYS$BPM_WF_INSTANCE.VERSION_NO", key: "version_no" },
+			{
+				data: "(CAST(SYS$BPM_WF_INSTANCE.STARTED_AT AS VARCHAR(24)))",
+				key: "started_at",
+				alias: "started_at",
+			},
+			{
+				data: "(CAST(SYS$BPM_WF_INSTANCE.ENDED_AT AS VARCHAR(24)))",
+				key: "ended_at",
+				alias: "ended_at",
+			},
+			{ data: "SYS$BPM_WF_INSTANCE.CREATED_BY", key: "created_by" },
+			{
+				data: "(CAST(SYS$BPM_WF_INSTANCE.UPDATED_AT AS VARCHAR(24)))",
+				key: "updated_at",
+				alias: "updated_at",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_WF_INSTANCE.ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+	return await queryData(instanceQuery, apiConfig);
+}
+
+export async function instanceLogs(payload) {
+	const { instanceId, apiConfig } = payload;
+	const historyQuery = {
+		length: -1,
+		columns: [
+			{ data: "SYS$BPM_STATE_HISTORY.ID", key: "id" },
+			{
+				data: "SYS$BPM_STATE_HISTORY.SYS$BPM_TRANS_DEF_ID",
+				key: "sys$bpm_trans_def_id",
+			},
+			{
+				data: "SYS$BPM_STATE_HISTORY.FROM_STATE_CODE",
+				key: "from_state_code",
+			},
+			{
+				data: "SYS$BPM_STATE_HISTORY.TO_STATE_CODE",
+				key: "to_state_code",
+			},
+			{
+				data: "SYS$BPM_STATE_HISTORY.TRIGGER_TYPE",
+				key: "trigger_type",
+			},
+			{
+				data: "SYS$BPM_STATE_HISTORY.ACTOR_TYPE",
+				key: "actor_type",
+			},
+			{ data: "SYS$BPM_STATE_HISTORY.ACTOR_ID", key: "actor_id" },
+			{ data: "SYS$BPM_STATE_HISTORY.REQUEST_ID", key: "request_id" },
+			{
+				data: "(CAST(SYS$BPM_STATE_HISTORY.CREATED_AT AS VARCHAR(24)))",
+				key: "created_at",
+				alias: "created_at",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_STATE_HISTORY.SYS$BPM_WF_INSTANCE_ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+		orders: [{ column: "SYS$BPM_STATE_HISTORY.CREATED_AT", dir: "DESC" }],
+	};
+	return await queryData(historyQuery, apiConfig);
+}
+
+export async function instanceTasks(payload) {
+	const { instanceId, openOnly, apiConfig } = payload;
+	const filters = [
+		{
+			junction: "",
+			column: "SYS$BPM_TASK.SYS$BPM_WF_INSTANCE_ID",
+			operator: "=",
+			value1: String(instanceId),
+		},
+	];
+
+	if (openOnly) {
+		filters.push({
+			junction: "AND",
+			column: "SYS$BPM_TASK.STATUS",
+			operator: "=",
+			value1: "'OPEN'",
+		});
+	}
+
+	const taskQuery = {
+		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" },
+			{ data: "SYS$BPM_TASK.ASSIGNMENT_TYPE", key: "assignment_type" },
+			{ data: "SYS$BPM_TASK.ASSIGNMENT_VALUE", key: "assignment_value" },
+			{ data: "SYS$BPM_TASK.ASSIGNED_USER_ID", key: "assigned_user_id" },
+			{
+				data: "(CAST(SYS$BPM_TASK.CREATED_AT AS VARCHAR(24)))",
+				key: "created_at",
+				alias: "created_at",
+			},
+			{
+				data: "(CAST(SYS$BPM_TASK.DUE_AT AS VARCHAR(24)))",
+				key: "due_at",
+				alias: "due_at",
+			},
+			{ data: "SYS$BPM_TASK.SLA_MINUTES", key: "sla_minutes" },
+			{
+				data: "(CAST(SYS$BPM_TASK.COMPLETED_AT AS VARCHAR(24)))",
+				key: "completed_at",
+				alias: "completed_at",
+			},
+			{ data: "SYS$BPM_TASK.COMPLETED_BY", key: "completed_by" },
+			{ data: "SYS$BPM_TASK.CLOSED_REASON", key: "closed_reason" },
+		],
+		filter: filters,
+		orders: [{ column: "SYS$BPM_TASK.CREATED_AT", dir: "DESC" }],
+	};
+	return await queryData(taskQuery, apiConfig);
+}
+
+export async function instanceTimers(payload) {
+	const { instanceId, apiConfig } = payload;
+	const timerQuery = {
+		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",
+			},
+			{ data: "SYS$BPM_TIMER_JOB.STATE_CODE", key: "state_code" },
+			{ data: "SYS$BPM_TIMER_JOB.TIMER_TYPE", key: "timer_type" },
+			{
+				data: "(CAST(SYS$BPM_TIMER_JOB.DUE_AT AS VARCHAR(24)))",
+				key: "due_at",
+				alias: "due_at",
+			},
+			{ data: "SYS$BPM_TIMER_JOB.SLA_MINUTES", key: "sla_minutes" },
+			{ data: "SYS$BPM_TIMER_JOB.STATUS", key: "status" },
+			{
+				data: "(CAST(SYS$BPM_TIMER_JOB.FIRED_AT AS VARCHAR(24)))",
+				key: "fired_at",
+				alias: "fired_at",
+			},
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_TIMER_JOB.SYS$BPM_WF_INSTANCE_ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+	};
+	return await queryData(timerQuery, apiConfig);
+}
+
+export async function instanceEffectLogs(payload) {
+	const { instanceId, apiConfig } = payload;
+	const effectQuery = {
+		length: -1,
+		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.CREATED_AT AS VARCHAR(24)))",
+				key: "created_at",
+				alias: "created_at",
+			},
+			{
+				data: "(CAST(SYS$BPM_EFFECT_LOG.EXECUTED_AT AS VARCHAR(24)))",
+				key: "executed_at",
+				alias: "executed_at",
+			},
+			{ data: "SYS$BPM_EFFECT_LOG.ERROR_MESSAGE", key: "error_message" },
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_EFFECT_LOG.SYS$BPM_WF_INSTANCE_ID",
+				operator: "=",
+				value1: String(instanceId),
+			},
+		],
+		orders: [{ column: "SYS$BPM_EFFECT_LOG.CREATED_AT", dir: "DESC" }],
+	};
+	return await queryData(effectQuery, apiConfig);
+}
+
+export async function retryEffect(payload) {
+	const { effectId, apiConfig } = payload;
+
+	const effectQuery = {
+		length: -1,
+		columns: [
+			{ data: "SYS$BPM_EFFECT_LOG.ID", key: "id" },
+			{ data: "SYS$BPM_EFFECT_LOG.RETRY_COUNT", key: "retry_count" },
+		],
+		filter: [
+			{
+				junction: "",
+				column: "SYS$BPM_EFFECT_LOG.ID",
+				operator: "=",
+				value1: String(effectId),
+			},
+		],
+	};
+	const effectRes = await queryData(effectQuery, apiConfig);
+
+	if (!effectRes.data || effectRes.data.length === 0) {
+		throw new Error("Effect not found.");
+	}
+
+	const currentRetry = parseInt(effectRes.data[0].retry_count, 10) || 0;
+
+	const dbModel = {
+		id: effectId,
+		status: "PENDING",
+		retry_count: currentRetry + 1,
+		error_message: "",
+	};
+
+	const result = await dbSave({ SYS$BPM_EFFECT_LOG: dbModel });
+	return result.data;
+}