biz-a-cli 2.3.73 → 2.3.74

package/bin/app.js

@@ -14,6 +14,7 @@ import path, { basename } from "node:path";
 import { env } from "../envs/env.js";
 import { prepareScript, encryptScript } from "./script.js";
 import { spawn } from "node:child_process";
+import { newMigration, runMigrations } from "./migrate.js";
 
 const getKeyFolderPath = () => {
 	const scriptPath =
@@ -654,6 +655,28 @@ const buildCli = () =>
 				})();
 			},
 		)
+		.command(
+			"migrate:new",
+			"Create a new blank migration file with an epoch timestamp",
+			(yargs) => {
+				return yargs.option("n", {
+					alias: "name",
+					describe:
+						'Name of the migration feature (e.g., "BPM", "Domain", "new feature_name")',
+					type: "string",
+					demandOption: true,
+				});
+			},
+			(commandOptions) => newMigration(commandOptions),
+		)
+		.command(
+			"migrate:run",
+			"Run pending DDL migrations from the /migrations folder",
+			{},
+			async (commandOptions) => {
+				await runMigrations(commandOptions);
+			},
+		)
 		.recommendCommands()
 		.demandCommand(1, "You need at least one command before moving on")
 		.strict();

package/bin/hub.js

@@ -20,6 +20,7 @@ import {
 	createSocketServer,
 } from "./directHubEvent.js";
 import { env } from "../envs/env.js";
+import { setGlobalConfig } from "../db/ds.js";
 
 const logger = createLogger({
 	level: "info",
@@ -52,7 +53,7 @@ const argv = yargs(process.argv.slice(2))
 	.usage("Usage: $0 [options]")
 	.options("s", {
 		alias: "server",
-		default: env.BIZA_SERVER_LINK,
+		// default: env.BIZA_SERVER_LINK, // handle by serverMode
 		describe: "(Required) Tunnel server endpoint",
 		type: "string",
 		demandOption: false,
@@ -106,12 +107,48 @@ const argv = yargs(process.argv.slice(2))
 	})
 	.options("hs", {
 		alias: "hubServer",
-		default: `${env.BIZA_HUB_SERVER_LINK}`,
+		// default: `${env.BIZA_HUB_SERVER_LINK}`, // handle by serverMode
 		describe: "BizA hub",
 		type: "string",
 		demandOption: false,
+	})
+	.options("serverMode", {
+		alias: "sMode",
+		describe: "Backend server mode: prod, dev, or backup",
+		type: "string",
+		// choices: ["prod", "dev", "backup"],
+		choices: ["prod", "dev"],
+		default: "prod",
 	}).argv;
 
+// Server endpoint mapping by mode
+const SERVER_ENDPOINTS = {
+	prod: {
+		server: env.BIZA_SERVER_LINK,
+		hub: env.BIZA_HUB_SERVER_LINK,
+	},
+	dev: {
+		server: "https://devServer.biz-a.id",
+		hub: "https://devHub.biz-a.id",
+	},
+	// backup: {
+	// 	server: "https://backupServer.biz-a.id",
+	// 	hub: "https://backupHub.biz-a.id",
+	// },
+};
+
+if (!argv.server) {
+	argv.server =
+		SERVER_ENDPOINTS[argv.serverMode]?.server ||
+		SERVER_ENDPOINTS.prod.server;
+}
+if (!argv.hubServer) {
+	argv.hubServer =
+		SERVER_ENDPOINTS[argv.serverMode]?.hub || SERVER_ENDPOINTS.prod.hub;
+}
+
+setGlobalConfig(argv);
+
 if (argv.help) {
 	yargs().showHelp();
 	process.exit();
@@ -137,6 +174,7 @@ import fs from "fs";
 import http from "http";
 import https from "https";
 import path from "node:path";
+import bpmRoutes from "../engine/bpm/routes.js";
 
 app.use(compression());
 app.use(cors());
@@ -154,6 +192,8 @@ app.use("/status", (req, res) => {
 	res.status(200).json(status(argv));
 });
 
+app.use("/bpm", bpmRoutes);
+
 // create HTTP(s) Server
 const keyFile = path.join(import.meta.dirname, "../cert/key.pem");
 const certFile = path.join(import.meta.dirname, "../cert/cert.pem");

package/bin/hubEvent.js

@@ -11,7 +11,7 @@ const packageJson = require("../package.json");
 import { deploymentListenerForHubServer } from "./deployEvent.js";
 import { execCLIScriptWorker, workerStats } from "../worker/cliWorkerPool.js";
 
-export const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
+export const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 28;
 export const RECONNECT_SOCKET_DELAY = 60 * 1000;
 const DISCONNECT_REASON_BY_SOCKET_SERVER = "io server disconnect";
 
@@ -131,15 +131,37 @@ export const streamEvent = async (socket, argv) =>
 			});
 		};
 
+		// const cliReqCb = async (data, callback) => {
+		// 	const { path, method, ...remainData } = data;
+
+		// 	const result = await axios.request({
+		// 		method: data.method,
+		// 		url: `${process.env.HOST || "http://localhost"}:${argv.serverport}/cb${path || ""}`,
+		// 		data: remainData,
+		// 	});
+		// 	callback(result.data);
+		// };
+
 		const cliReqCb = async (data, callback) => {
 			const { path, method, ...remainData } = data;
 
-			const result = await axios.request({
-				method: data.method,
-				url: `${process.env.HOST || "http://localhost"}:${argv.serverport}/cb${path || ""}`,
-				data: remainData,
-			});
-			callback(result.data);
+			try {
+				const result = await axios.request({
+					method: data.method,
+					url: `${process.env.HOST || "http://localhost"}:${argv.serverport}/cb${path || ""}`,
+					data: remainData,
+				});
+
+				callback(result.data);
+			} catch (error) {
+				if (error.response) {
+					callback(error.response.data);
+				} else {
+					callback(
+						`Proxy Error: Local CLI unreachable. ${error.message}`,
+					);
+				}
+			}
 		};
 
 		const publishReqCb = async (data, callback) => {
@@ -212,6 +234,7 @@ export const streamEvent = async (socket, argv) =>
 		socket.on("incomingClient", incomingHubCb);
 		socket.on("cli-req", cliReqCb);
 		socket.on("publish-req", publishReqCb);
+		socket.on("cliCommand", (data, cb) => handleCliCommand(data, cb, argv));
 
 		socket.on("disconnect", (reason) => {
 			console.log(
@@ -336,6 +359,75 @@ export const status = (argv) => {
 	};
 };
 
+const EngineRegistry = {
+	// ZERO-MEMORY LAZY REGISTRY. Lazy load the module into memory (Only impacts performance on the very first call)
+	"bpm/workflow": () => import("../engine/bpm/workflow.js"),
+	"bpm/workflowRT": () => import("../engine/bpm/workflow-runtime.js"),
+	// 'domain/system': () => import('../engine/domain/system.js') // example for Domain Engine
+};
+
+const handleCliCommand = async (data, cb, argv) => {
+	try {
+		const command = data.command.trim().toLowerCase();
+		switch (command) {
+			case "status":
+				cb(null, status(argv));
+				break;
+			case "runcliscript":
+				const liveTriggerPayload = {
+					arguments: argv,
+					body: data.scriptData ?? null,
+					path: "/live-trigger",
+					query: { scriptName: data.scriptName },
+					headers: { "user-agent": "biz-a-client-socket" },
+				};
+				cb(
+					null,
+					await execCLIScriptWorker(
+						{
+							url: `${argv["secure"] == true ? "https://" : "http://"}${argv["hostname"]}:${argv["port"]}`,
+							dbindex: argv["dbindex"],
+							subdomain: argv["subdomain"],
+						},
+						data.scriptName,
+						liveTriggerPayload,
+					),
+				);
+				break;
+			case "engine": {
+				// Ex: Extracts "bpm/instance" and "initiate" from "bpm/instance/initiate"
+				const targetParts = data.target.split("/");
+				const methodName = targetParts.pop();
+				const modulePath = targetParts.join("/");
+
+				if (!EngineRegistry[modulePath]) {
+					throw new Error(
+						`Engine target '${modulePath}' is not registered on this CLI.`,
+					);
+				}
+
+				const engineModule = await EngineRegistry[modulePath]();
+
+				if (typeof engineModule[methodName] !== "function") {
+					throw new Error(
+						`Method '${methodName}' does not exist on target '${modulePath}'.`,
+					);
+				}
+
+				const result = await engineModule[methodName](data.payload);
+
+				cb(null, { success: true, data: result });
+				break;
+			}
+
+			default:
+				cb(`Unknown CLI command '${command}'`, null);
+		}
+	} catch (err) {
+		cb(err.message || err, null);
+	}
+};
+
 export const clientListener = (socket, argv) => {
 	socket
 		.on("apiRequest", (reqData, resCB) => {
@@ -406,33 +498,6 @@ export const clientListener = (socket, argv) => {
 			}
 		})
 		.on("cliCommand", async (data, cb) => {
-			try {
-				const command = data.command.trim().toLowerCase();
-				switch (
-					command //ensure case insensitive
-				) {
-					case "status":
-						cb(null, status(argv));
-						break;
-					case "runcliscript":
-						cb(
-							null,
-							await execCLIScriptWorker(
-								{
-									url: `${argv["secure"] == true ? "https://" : "http://"}${argv["hostname"]}:${argv["port"]}`,
-									dbindex: argv["dbindex"],
-									subdomain: argv["subdomain"],
-								},
-								data.scriptName,
-								data.scriptData,
-							),
-						);
-						break;
-					default:
-						cb(`Unknown CLI command '${command}'`, null);
-				}
-			} catch (err) {
-				cb(err.message || err, null);
-			}
+			handleCliCommand(data, cb, argv);
 		});
 };

package/bin/migrate.js

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+import path from "node:path";
+import { queryData, save as dbSave, executeBlock } from "../db/db.js";
+
+const flattenSql = (sqlString) => {
+	return sqlString
+		.replace(/--.*$/gm, "") // 1. Strip all SQL comments
+		.split(/\r?\n/) // 2. Split into array of individual lines
+		.map((line) => line.trim()) // 3. Trim leading/trailing indentation
+		.filter((line) => line.length > 0) // 4. Remove empty lines entirely
+		.join(" "); // 5. Join safely with exactly one space
+};
+
+export const newMigration = (argv) => {
+	const dir = path.resolve(process.cwd(), "migrations");
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+
+	const safeName = argv.name
+		.trim()
+		.replace(/[\s-]+/g, "_")
+		.toLowerCase();
+	const filename = `${Date.now()}__${safeName}.sql`;
+
+	// Defensive Template: Bypasses are commented out by default.
+	// DDL must use `execute statement` inside the block to bypass compile-time checks.
+	const template = [
+		"-- To safely bypass this script if a main table already exists, uncomment the line below and replace MAIN_TABLE_NAME",
+		"-- -- @RunOnlyIfMissing: MAIN_TABLE_NAME",
+		"",
+		"EXECUTE BLOCK AS",
+		"BEGIN",
+		"    -- Write your DDL/SQL here using execute statement",
+		"    -- execute statement 'CREATE TABLE YOUR_TABLE(ID INT NOT NULL PRIMARY KEY);';",
+		"END",
+		"",
+	].join("\n");
+
+	fs.writeFileSync(path.join(dir, filename), template);
+	console.log(`[Success] Created new migration file: migrations/${filename}`);
+};
+
+export const runMigrations = async (argv) => {
+	const migrationsDir = path.resolve(process.cwd(), "migrations");
+
+	if (!fs.existsSync(migrationsDir)) {
+		console.log(
+			`[Migrate] No 'migrations' folder found at ${migrationsDir}`,
+		);
+		return { success: false, error: "Missing migrations folder" };
+	}
+
+	const apiConfig = {
+		url: `${argv.server}:${argv.apiPort}`,
+		dbindex: argv.dbIndex,
+		subdomain: argv.subdomain,
+		timeout: 30000,
+	};
+
+	const bootstrapMigrationTable = async () => {
+		const bootstrapSql = `
+			EXECUTE BLOCK AS
+			BEGIN
+				IF (NOT EXISTS(SELECT 1 FROM RDB$RELATIONS WHERE UPPER(RDB$RELATION_NAME) = 'SYS$MIGRATIONS')) THEN
+				BEGIN
+					EXECUTE STATEMENT 'CREATE GENERATOR SYS$MIGRATIONS_GEN;';
+					EXECUTE STATEMENT 'CREATE TABLE SYS$MIGRATIONS(ID INTEGER NOT NULL PRIMARY KEY, FILE_NAME VARCHAR(255) NOT NULL, EXECUTED_AT TIMESTAMP NOT NULL, CONSTRAINT UNQ_SYS$MIGRATIONS_FILE UNIQUE (FILE_NAME));';
+					EXECUTE STATEMENT 'CREATE TRIGGER SYS$MIGRATIONS_BI FOR SYS$MIGRATIONS ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW.ID IS NULL) THEN NEW.ID = GEN_ID(SYS$MIGRATIONS_GEN, 1); IF (NEW.EXECUTED_AT IS NULL) THEN NEW.EXECUTED_AT = ''NOW''; END';
+				END
+			END
+		`;
+		await executeBlock(flattenSql(bootstrapSql), apiConfig);
+	};
+
+	try {
+		const files = fs
+			.readdirSync(migrationsDir)
+			.filter((f) => f.endsWith(".sql"))
+			.sort();
+
+		if (files.length === 0) {
+			console.log(`[Migrate] Migrations folder is empty. Nothing to do.`);
+			return { success: true };
+		}
+
+		console.log(`[Migrate] Checking SYS$MIGRATIONS table...`);
+
+		await bootstrapMigrationTable();
+
+		const appliedParam = {
+			length: -1,
+			columns: [{ data: "SYS$MIGRATIONS.FILE_NAME", key: "file" }],
+		};
+		const appliedRes = await queryData(appliedParam, apiConfig, true);
+		const appliedFiles = Array.isArray(appliedRes)
+			? appliedRes.map((r) => r.file.trim())
+			: [];
+
+		for (const file of files) {
+			if (appliedFiles.includes(file)) continue;
+
+			console.log(`[Migrate] Executing ${file}...`);
+			const sqlContent = fs.readFileSync(
+				path.join(migrationsDir, file),
+				"utf8",
+			);
+
+			// BYPASS LOGIC: Evaluates strict start-of-line tag
+			const baselineMatch = sqlContent.match(
+				/^--\s*@RunOnlyIfMissing:\s*([A-Za-z0-9_$]+)/im,
+			);
+			if (baselineMatch) {
+				const targetTable = baselineMatch[1].toUpperCase();
+
+				const bypassCheckParam = {
+					length: 1,
+					filter: [
+						{
+							junction: "",
+							column: "RDB$RELATIONS.RDB$RELATION_NAME",
+							operator: "=",
+							value1: `'${targetTable}'`,
+						},
+					],
+					columns: [
+						{
+							data: "RDB$RELATIONS.RDB$RELATION_NAME",
+							key: "name",
+						},
+					],
+				};
+
+				const bypassCheckRes = await queryData(
+					bypassCheckParam,
+					apiConfig,
+					true,
+				);
+				if (bypassCheckRes && bypassCheckRes.length > 0) {
+					console.log(
+						`[Migrate] Bypass Triggered: ${targetTable} exists. Marking ${file} as done.`,
+					);
+					await dbSave(
+						{ SYS$MIGRATIONS: { id: null, file_name: file } },
+						apiConfig,
+					);
+					continue;
+				}
+			}
+
+			// mark migration current file as "Applied"
+			const trackerSql = `\n  INSERT INTO SYS$MIGRATIONS (FILE_NAME) VALUES ('${file}');\n`;
+			let rawSql = sqlContent.replace(/END\s*$/i, trackerSql + "END");
+
+			await executeBlock(flattenSql(rawSql), apiConfig);
+
+			console.log(`[Migrate] Success: ${file}`);
+		}
+
+		console.log(`[Migrate] Database is up to date.`);
+		return { success: true };
+	} catch (error) {
+		console.error(
+			`[Migrate] CRITICAL ERROR:`,
+			error?.response?.data?.error || error.message,
+		);
+		process.exit(1);
+	}
+};

package/callbackController.js

@@ -1,42 +1,64 @@
-import { loadCliScript, extractFunctionScript } from "./scheduler/datalib.js";
-
+// import { loadCliScript, extractFunctionScript } from "./scheduler/datalib.js";
+import { execCLIScriptWorker } from "./worker/cliWorkerPool.js";
 
 export function getInputScript(req) {
-    const args = req.app.settings.args;
-    return {
-        data: {
-            arguments: args,
-            body: req.body.body,
-            path: req.path,
-            query: req.body.query,
-            headers: req.body.headers,
-            socket: req.app.settings.socket,
-        },
-        selectedConfig: {
-            url: `http://${args.hostname}:${args.port}`,
-            dbindex: args.dbindex,
-            subdomain: args.subdomain
-        }
-    }
+	const args = req.app.settings.args;
+	return {
+		data: {
+			arguments: args,
+			body: req.body.body,
+			path: req.path,
+			query: req.body.query,
+			headers: req.body.headers,
+			// socket: req.app.settings.socket, // seem never used, and it can not be serialized to worker thread
+		},
+		selectedConfig: {
+			url: `http://${args.hostname}:${args.port}`,
+			dbindex: args.dbindex,
+			subdomain: args.subdomain,
+		},
+	};
 }
 
+// export async function runCliScript(req, res) {
+//     try {
+//         const { data, selectedConfig } = getInputScript(req);
+//         let script = await loadCliScript(selectedConfig, 'ID', req.body.query.scriptid);
+//         let functions = await extractFunctionScript(selectedConfig, script);
+//         if (functions) {
+//             console.info(`## Callback ID ${req.body.query.scriptid} Starts. ##`);
+
+//             let respon = await functions.onInit(data);
+//             res.send(respon);
+
+//             console.info(`## Callback ID ${req.body.query.scriptid} Finish. ##`);
+//         } else {
+//             res.send('CLI Script does not exist.');
+//         }
+//     } catch (error) {
+//         console.error(error);
+//         throw new Error(error);
+//     }
+// }
+
 export async function runCliScript(req, res) {
-    try {
-        const { data, selectedConfig } = getInputScript(req);
-        let script = await loadCliScript(selectedConfig, 'ID', req.body.query.scriptid);
-        let functions = await extractFunctionScript(selectedConfig, script);
-        if (functions) {
-            console.info(`## Callback ID ${req.body.query.scriptid} Starts. ##`);
-            
-            let respon = await functions.onInit(data);
-            res.send(respon);
-
-            console.info(`## Callback ID ${req.body.query.scriptid} Finish. ##`);
-        } else {
-            res.send('CLI Script does not exist.');
-        }
-    } catch (error) {
-        console.error(error);
-        throw new Error(error);
-    }
+	try {
+		const { data, selectedConfig } = getInputScript(req);
+
+		console.info(
+			`## Callback ID ${req.body.query.scriptid} Starts. ##`,
+		);
+
+		let respon = await execCLIScriptWorker(
+			selectedConfig,
+			{ searchBy: "ID", searchValue: req.body.query.scriptid },
+			data,
+		);
+
+		res.send(respon);
+		console.info(`## Callback ID ${req.body.query.scriptid} Finish. ##`);
+	} catch (error) {
+		console.error(error);
+		res.status(500).send(error.message || error);
+	}
 }

package/db/db.js

@@ -0,0 +1,37 @@
+import * as adapter from "./ds.js";
+
+export const queryData = async (param, config = {}) => {
+	return await adapter.queryData(param, config);
+};
+
+/**
+ *
+ * @param {Object} payload - The data to save.
+ * @param {Object} [config] - Optional configuration overrides.
+ * @param {string} [tableName] - Optional. If provided, wraps the payload for standard ORM (sendModel).
+ *                               If omitted, sends the raw payload (for Sibling/ACID orchestration) (sendORMPayload).
+ */
+export const save = async (payload, config = {}) => {
+	return await adapter.save(payload, config);
+};
+
+export const deleteMD = async (id, masterTable, detailTables, config = {}) => {
+	const payload = {
+		id: id,
+		master: masterTable,
+		detail: detailTables,
+	};
+	return await adapter.removeMD(payload, config);
+};
+
+export const remove = async (payload, config = {}) => {
+	return await adapter.remove(payload, config);
+};
+
+export const list = async (payload, config = {}) => {
+	return await adapter.list(payload, config);
+};
+
+export const executeBlock = async (sqlString, config = {}) => {
+	return await adapter.executeBlock(sqlString, config);
+};