biz-a-cli 2.3.72 → 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/directHubEvent.js

@@ -1,86 +1,100 @@
-import { clientListener, RECONNECT_SOCKET_DELAY } from './hubEvent.js'
-import { deploymentListenerForVSCode } from './deployEvent.js'
-import { Tunnel as QuickTunnel } from 'cloudflared'
-import { Server as ioServer } from 'socket.io'
+import { clientListener, RECONNECT_SOCKET_DELAY } from "./hubEvent.js";
+import { deploymentListenerForVSCode } from "./deployEvent.js";
+import { Tunnel as QuickTunnel } from "cloudflared";
+import { Server as ioServer } from "socket.io";
 
-export const CLIENT_ROOM = 'clientRoom'
+export const CLIENT_ROOM = "clientRoom";
 
-export async function localhostTunnel(port, notifier){
-    let tunnelUrl = '';
-    let qt = QuickTunnel.quick('127.0.0.1:'+port);
-    function reconnectTunnel(){
-        setTimeout(()=>{qt = localhostTunnel(port, notifier)}, RECONNECT_SOCKET_DELAY);
-    };
-    qt.on('url', (qtUrl)=>{
-        // console.log('qt url', qtUrl)
-        tunnelUrl = qtUrl;
-    })
-    .on('connected', (conn)=>{
-        // console.log('qt connect', conn)
-        notifier(tunnelUrl);
-        console.log(`${new Date()}: Connected to Direct Hub at public URL ${tunnelUrl}`)
-    })
-    .on('disconnected', (conn)=>{
-        // console.log('qt disconnect', conn)
-        notifier('');
-        qt.stop();
-    })
-    .on('error', (err)=>{
-        // console.log('qt err', err)
-        notifier('');
-        qt.stop();
-    })
-    .on('exit', (code)=>{
-        // console.log('qt exit', code)
-        notifier('');
-        console.log(`${new Date()}: Direct Hub is not available, will try to reinitiate it in ${RECONNECT_SOCKET_DELAY/1000} seconds. Error code : `, code);
-        reconnectTunnel();
-    // })
-    // on('stdout', (data)=>{
-    //     console.log('qt stdout', data)
-    // })
-    // on('stderr', (data)=>{
-    //     console.log('qt stderr', data)
-    });
-    return qt
+export async function localhostTunnel(port, notifier) {
+	let tunnelUrl = "";
+	let qt = QuickTunnel.quick("127.0.0.1:" + port);
+	function reconnectTunnel() {
+		setTimeout(() => {
+			qt = localhostTunnel(port, notifier);
+		}, RECONNECT_SOCKET_DELAY);
+	}
+	qt.on("url", (qtUrl) => {
+		// console.log('qt url', qtUrl)
+		tunnelUrl = qtUrl;
+	})
+		.on("connected", (conn) => {
+			// console.log('qt connect', conn)
+			notifier(tunnelUrl);
+			console.log(
+				`${new Date()}: Connected to Direct Hub at public URL ${tunnelUrl}`,
+			);
+		})
+		.on("disconnected", (conn) => {
+			// console.log('qt disconnect', conn)
+			notifier("");
+			qt.stop();
+		})
+		.on("error", (err) => {
+			// console.log('qt err', err)
+			notifier("");
+			qt.stop();
+		})
+		.on("exit", (code) => {
+			// console.log('qt exit', code)
+			notifier("");
+			console.log(
+				`${new Date()}: Direct Hub is not available, will try to reinitiate it in ${RECONNECT_SOCKET_DELAY / 1000} seconds. Error code : `,
+				code,
+			);
+			reconnectTunnel();
+			// })
+			// on('stdout', (data)=>{
+			//     console.log('qt stdout', data)
+			// })
+			// on('stderr', (data)=>{
+			//     console.log('qt stderr', data)
+		});
+	return qt;
 }
 
-export function directHubEvent(serverSocket, argv){
-    serverSocket.on('connection', (clientSocket) => {
+export function directHubEvent(serverSocket, argv) {
+	serverSocket.on("connection", (clientSocket) => {
+		const setConnectListeners = (sock) => {
+			// shall not log in production mode
+			if (process.env.NODE_ENV !== "production") {
+				const id = `<${sock.handshake?.query?.isClient ? `Client` : sock.handshake?.query?.isDeploy ? "Deployer" : "Anonymous"}> ${sock.id}`;
+				console.log(id, `connected`);
+				sock.on("disconnect", (reason) => {
+					console.log(id, `disconnected. Reason : ${reason}`);
+				});
+			}
+		};
 
-        const setConnectListeners = (sock)=>{
-            // shall not log in production mode
-            if (process.env.NODE_ENV !== 'production') {
-                const id = `<${sock.handshake?.query?.isClient ? `Client` : sock.handshake?.query?.isDeploy ? 'Deployer' : 'Anonymous'}> ${sock.id}`;
-                console.log(id, `connected`)
-                sock.on('disconnect', (reason)=>{
-                    console.log(id, `disconnected. Reason : ${reason}`)
-                })
-            };
-        };
-
-        if (clientSocket.handshake.query.isClient) {
-            setConnectListeners(clientSocket);
-            clientListener(clientSocket, argv);
-            clientSocket.join(CLIENT_ROOM);
-        }
-        else if (clientSocket.handshake.query.isDeploy) {
-            setConnectListeners(clientSocket);
-            deploymentListenerForVSCode(clientSocket, argv)
-        } else {
-            clientSocket.disconnect();
-        }
-    })
+		if (clientSocket.handshake.query.isClient) {
+			setConnectListeners(clientSocket);
+			clientListener(clientSocket, argv);
+			clientSocket.join(CLIENT_ROOM);
+		} else if (clientSocket.handshake.query.isDeploy) {
+			setConnectListeners(clientSocket);
+			deploymentListenerForVSCode(clientSocket, argv);
+		} else {
+			clientSocket.disconnect();
+		}
+	});
 }
 
-export function createSocketServer(httpServer, cliIpAddress='127.0.0.1'){
-    return new ioServer(
-        httpServer,
-        {
-            cors: {origin: ['https://biz-a.id', 'https://test.biz-a.id', /\.biz-a\.id$/, 'vscode-file://vscode-app', /\.vscode-cdn\.net$/].concat((process.env.NODE_ENV === 'production') ? [] : [`http://${cliIpAddress}:4200`, 'http://localhost:4200'])},
-            maxHttpBufferSize: 1e8, // 100 MB
-            pingInterval: 35000, // default = 25000
-            pingTimeout: 30000 // default = 20000
-        }
-    );
-};
+export function createSocketServer(httpServer, cliIpAddress = "127.0.0.1") {
+	return new ioServer(httpServer, {
+		cors: {
+			origin: [
+				"https://biz-a.id",
+				"https://test.biz-a.id",
+				/\.biz-a\.id$/,
+				"vscode-file://vscode-app",
+				/\.vscode-cdn\.net$/,
+			].concat(
+				process.env.NODE_ENV === "production"
+					? []
+					: [`http://${cliIpAddress}:4200`, "http://localhost:4200"],
+			),
+		},
+		maxHttpBufferSize: 1e8, // 100 MB
+		pingInterval: 35000, // default = 25000
+		pingTimeout: 30000, // default = 20000
+	});
+}

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

@@ -9,8 +9,9 @@ import os from "node:os";
 const packageJson = require("../package.json");
 // import { pipeline } from 'node:stream'
 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";
 
@@ -130,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) => {
@@ -211,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(
@@ -315,6 +339,7 @@ export const status = (argv) => {
 			memoryUsage: `${(process.memoryUsage().rss / (1024 * 1024)).toFixed(2)} MB`,
 			nodeVersion: process.version,
 			uptime: getUptime(),
+			workers: workerStats(),
 		},
 		api: {
 			address: `${argv.hostname}:${argv.port}`,
@@ -334,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) => {
@@ -404,19 +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;
-					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);
+	}
+};