biz-a-cli 2.3.42 → 2.3.52

package/bin/directHubEvent.js

@@ -0,0 +1,57 @@
+import axios from 'axios'
+import { IDLE_SOCKET_TIMEOUT_MILLISECONDS } from './hubEvent.js'
+import { Tunnel as QuickTunnel } from 'cloudflared'
+
+export async function localhostTunnel(port){
+    function notifyUser(){
+        console.log(`${new Date()}: Direct hub only available within local LAN. Please restart CLI to try again.`)
+    }
+    const qt = QuickTunnel.quick('127.0.0.1:'+port)
+    qt.on('Disconnected', ()=>{console.log('DISCONNECTED');notifyUser()})
+    let url = await new Promise((resolve)=>{
+        let tunnelURL = ''
+        qt.once('url', (qtUrl)=>{console.log('URL obtained');tunnelURL=qtUrl})
+        qt.once('connected', (conn)=>{console.log('CONNECTED', conn); resolve(tunnelURL)})
+        qt.once('exit', (code)=>{resolve('')})
+        qt.once('error', (err)=>{resolve('')})
+    })
+    if (!url) {
+        notifyUser()
+    }
+    return url
+}
+
+export function directHubEvent(serverSocket, argv){
+    serverSocket.on('connection', (clientSocket) => {
+        if (process.env.NODE_ENV !== 'production') {
+            console.log('BizA Client Socket', clientSocket.id)
+            clientSocket.on('disconnect', (reason)=>{console.log(`Socket ${clientSocket.id} disconnected. Reason : ${reason}`)})
+        }
+        clientSocket.on('APISocket', (reqData, resCB)=>{
+            const socketResponse = (resp)=>{return {status: resp.status, statusText: resp.statusText, headers: resp.headers, body: resp.data, url: `${argv['hostname']}:${argv['port']+resp.config.url}`}}
+            if (argv['subdomain'].localeCompare(reqData.subDomain)==0) {
+                const apiAddress = `${argv['secure']==true ? 'https://' : 'http://'}${argv['hostname']}:${argv['port']}`
+                axios.request({
+                    timeout: IDLE_SOCKET_TIMEOUT_MILLISECONDS,
+                    baseURL: apiAddress,
+                    url: reqData.path,
+                    method: reqData.method,
+                    headers: reqData.headers,
+                    data: reqData.body,
+                    // decompress: false, // if we need to interfered default Agent compression
+                    responseType: reqData.responseType,
+                    maxContentLength: Infinity,
+                })
+                .then(response=>{
+                    resCB(null, socketResponse(response))
+                })
+                .catch(error=>{
+                    resCB(error, null)
+                })
+            }
+            else {
+                resCB({status: 401, statusText: 'bad subdomain', url: `${argv['hostname']}:${argv['port']+reqData.path}`}, null)
+            }
+        })
+    })
+}

package/bin/hub.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 
 import yargs from 'yargs';
-import { io as ioc } from "socket.io-client";
+import { io as ioClient } from "socket.io-client";
 import hubEvent from './hubEvent.js'
 import { createLogger, transports, format } from "winston";
+import { Server as ioServer } from 'socket.io'
+import os from 'node:os'
+import { directHubEvent, localhostTunnel }from './directHubEvent.js'
 
 const logger = createLogger({
     level: 'info',
@@ -27,7 +30,7 @@ process.on('unhandledRejection', (err) => {  //debug
     logger.error('Unhandled Rejection:', err)
 });
 
-const port = 3002;
+const defaultPort = 3002;
 const argv = yargs(process.argv.slice(2))
     .usage('Usage: $0 [options]')
     .options('s', {
@@ -39,34 +42,46 @@ const argv = yargs(process.argv.slice(2))
     })
     .options('sub', {
         alias: 'subdomain',
-        describe: '(Required) Public URL the tunnel server is forwarding to us',
+        describe: 'Public URL the tunnel server is forwarding to us',
         type: 'string',
         demandOption: true
     })
     .options('h', {
         alias: 'hostname',
         default: '127.0.0.1',
-        describe: '(Required) Address of local server for forwarding over socket-tunnel',
+        describe: 'Address of API server for forwarding over socket-tunnel. Please emit "HTTP" or "HTTPS" from address',
         type: 'string',
         demandOption: true
     })
-    .options('d', {
-        alias: 'dbindex',
-        default: 2,
-        describe: '(Required) Biz-A Database Index (Callback Feature)',
-        type: 'number',
-        demandOption: false
-    })
     .options('p', {
         alias: 'port',
         default: 212,
-        describe: 'Port of local server for forwarding over socket-tunnel',
+        describe: 'Port of API server for forwarding over socket-tunnel',
+        type: 'number',
+        demandOption: false
+    })
+    .options('secure', {
+        default: false,
+        describe: 'Is API server using ssl (HTTPS) ?',
+        type: 'boolean',
+        demandOption: false
+    })
+    .options('publish', {
+        default: true,
+        describe: 'Will the CLI be published to the internet??',
+        type: 'boolean',
+        demandOption: false
+    })
+    .options('d', {
+        alias: 'dbindex',
+        default: 2,
+        describe: 'Biz-A Database Index (Callback Feature)',
         type: 'number',
         demandOption: false
     })
     .options('sp', {
         alias: 'serverport',
-        default: port,
+        default: defaultPort,
         describe: 'Express Port (Callback Feature)',
         type: 'number',
         demandOption: false
@@ -89,12 +104,15 @@ if (!argv['server'] || !argv['subdomain'] || !argv['port']) {
     }
 }
 
-//
 import express from 'express';
 import compression from 'compression';
 import cors from 'cors';
 const app = express();
 import { runCliScript } from '../callbackController.js'
+import fs from "fs"
+import http from 'http'
+import https from 'https'
+import path from 'node:path'
 
 app.use(compression());
 app.use(cors());
@@ -102,17 +120,42 @@ app.use(express.json({ limit: '100mb' }));
 
 app.set('args', argv);
 
-
 app.use('/cb', runCliScript);
 
-app.listen((argv.serverport || port), () => {
-    console.log(`Biz-A is listening at ${process.env.HOST || 'http://localhost'}:${argv.serverport || port} `);
+
+// create HTTP(s) Server
+const keyFile = path.join(import.meta.dirname,  "../cert/key.pem")
+const certFile = path.join(import.meta.dirname,  "../cert/cert.pem")
+const rootFile = path.join(import.meta.dirname,  "../cert/root.pem")
+const isHttps = (fs.existsSync(keyFile) && fs.existsSync(certFile) && fs.existsSync(rootFile))
+const getProtocol = ()=>(isHttps ? 'Https://' : 'Http://')
+let server = isHttps ? https.createServer({key: fs.readFileSync(keyFile), cert: fs.readFileSync(certFile), ca: fs.readFileSync(rootFile),}, app) : http.createServer(app)
+
+
+// publish CLI with tunnel
+argv.publicUrl = (argv.publish==true) ? await localhostTunnel(argv.serverport) : ''
+
+// prepare CLI Address
+argv.cliAddress = ()=>{
+    const ip = Object.values(os.networkInterfaces()).flat().reduce((ip, {family, address, internal})=> ip || !internal && family==='IPv4' && address, undefined)
+    return {ip, port: argv.serverport, address: `${ip}:${argv.serverport}`, publicUrl: argv.publicUrl}
+}
+const cliAddress = argv.cliAddress()
+server.listen(argv.serverport, () => {
+    console.log(`${new Date()}: CLI is listening at ${getProtocol() + (process.env.HOST || cliAddress.ip || 'localhost')}:${cliAddress.port} `);
 });
-//
 
-let socket = ioc(argv['server']);
-hubEvent(socket, argv);
 
-app.set('socket', socket)
+// BizA CLI as socket client to BizA SERVER
+await hubEvent(ioClient(argv['server'], {query: {cliAddress: cliAddress.address }}), argv);
+console.log(`${new Date()}: CLI connected to BizA Server using sub domain "${argv['subdomain']}"`)
+
+
+// BizA CLI as socket server for BizA CLIENT
+const serverCORSOrigin = ['https://biz-a.id', 'https://test.biz-a.id', /\.biz-a\.id$/].concat((process.env.NODE_ENV === 'production') ? [] : [`http://${cliAddress.ip}:4200`, 'http://localhost:4200'])
+// console.log('Allowed Origins', serverCORSOrigin)
+directHubEvent(new ioServer(server, {cors: {origin: serverCORSOrigin}}), argv)
+console.log(`${new Date()}: CLI is listening at "${cliAddress.publicUrl ? cliAddress.publicUrl : cliAddress.address}"`)
+
 
 export { app }

package/bin/hubEvent.js

@@ -1,62 +1,112 @@
 import axios from 'axios';
 import net from 'node:net';
+import tls from 'node:tls';
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const ss = require('socket.io-stream');  //SCY: Temporary, next will be replaced with import
+import { Transform } from 'node:stream'
+// import { pipeline } from 'node:stream'
 
-const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
+export const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
+
+export const socketAgent = isUsingHttps=>(isUsingHttps==true) ? tls : net
 
 export default async (socket, argv) => new Promise((resolve, reject) => {
+
     const connectCb = () => {
-        console.log(new Date() + ': connected to socket server');
-        console.log(new Date() + ': requesting subdomain ' + argv['subdomain'] + ' via ' + argv['server']);
+        // console.log(new Date() + ': connected to BizA Server');
+        // console.log(new Date() + ': requesting subdomain ' + argv['subdomain'] + ' via ' + argv['server']);
 
         socket.emit('createTunnel', argv['subdomain'], (err) => {
             if (err) {
                 console.log(new Date() + ': [error] ' + err);
                 reject(err);
             } else {
-                console.log(new Date() + ': registered with server successfully');
+                // console.log(new Date() + ': registered with server successfully');
 
-                // clean and concat requested url
-                let url;
-                // let subdomain = argv['subdomain'].toString();
-                let server = argv['server'].toString();
+                // // clean and concat requested url
+                // let url;
+                // // let subdomain = argv['subdomain'].toString();
+                // let server = argv['server'].toString();
 
-                url = server;
+                // url = server;
 
-                // resolve promise with requested URL
-                resolve(url);
+                // // resolve promise with requested URL
+                // resolve(url);
+
+                resolve(argv['server'].toString());
             }
         });
     }
+
     const incomingHubCb = (clientId) => {
-        console.log(clientId, 'incoming clientId')
-        let client = net.connect(argv['port'], argv['hostname']);
+        // console.log(clientId, 'incoming clientId')
+
+        let addCLIAddressAsResponseHeader = new Transform({
+            transform(chunk, encoding, next){
+                const apiResponse = chunk.toString().toLowerCase()
+                const cliAddress = argv.cliAddress()
+                if ( (apiResponse.indexOf('200 ok') > -1) && (apiResponse.indexOf('server: datasnaphttpservice') > -1) && (cliAddress.publicUrl || cliAddress.address)) {
+                    // don't use string to insert additional headers, chunk can have mixed content of string and binary data
+                    const response = Buffer.from(chunk)
+                    const delimiter = '\r\n\r\n'
+                    const delimiterPos = response.indexOf(delimiter)
+                    const header = Buffer.concat([
+                        Buffer.copyBytesFrom(response, 0, delimiterPos),
+                        Buffer.from(
+                            '\r\n' +
+                            'Access-Control-Expose-Headers: biza-cli-address\r\n' +
+                            `biza-cli-address: ${cliAddress.publicUrl ? cliAddress.publicUrl : cliAddress.address}\r\n` +
+                            '\r\n'
+                        )
+                    ])
+                    const body = (response.length>delimiterPos+delimiter.length) ? Buffer.copyBytesFrom(response, delimiterPos+4) : Buffer.from('')
+                    this.push(body.length>0 ? Buffer.concat([header, body]) : header)
+                }
+                else {
+                    this.push(chunk)
+                }
+                next()
+            }
+        })
 
+        // let client = net.connect(argv['port'], argv['hostname']);
+        let client = socketAgent(argv['secure']).connect(argv['port'], argv['hostname']);
         client.on('connect', () => {
-            console.log(`client connected to ${argv['hostname']}:${argv['port']}`)
+            // console.log(`client connected to ${argv['hostname']}:${argv['port']}`)
             let s = ss.createStream();
-            s.pipe(client).pipe(s);
+
+            // s.pipe(client).pipe(s);
+            s.pipe(client).pipe(addCLIAddressAsResponseHeader).pipe(s)
+
+            // use pipeline for better performance, back pressure, memory management, error handling and clean up
+            // pipeline(s, client, addCLIAddressAsResponseHeader, s, (err)=>{if (err) {console.error(err)}}) // Not work well with heroku
 
             s.on('end', () => {
-                client.destroy();
-            });
+                client.destroy()
+            })
+
+            socket.once(clientId, ()=>{ // hub server shall notify us to end pipeline as soon as possible
+                client.end()
+            })
+
             ss(socket).emit(clientId, s);
         })
 
         client.setTimeout(IDLE_SOCKET_TIMEOUT_MILLISECONDS);
-        client.on('timeout', () => {
-            client.end();
+        client.on('timeout', () => { // in case client not notify to end pipeline, then inactivity timeout will end it
+            client.end()
         });
 
-        client.on('error', () => {
+        client.on('error', (err) => {
             // handle connection refusal (create a stream and immediately close it)
+            console.error('API Error : ', err)
             let s = ss.createStream();
             ss(socket).emit(clientId, s);
             s.end();
         });
     }
+
     const cliReqCb = async (data, callback) => {
         const { path, method, ...remainData } = data;
 
@@ -67,6 +117,7 @@ export default async (socket, argv) => new Promise((resolve, reject) => {
         })
         callback(result.data);
     }
+
     socket.on('connect', connectCb);
     socket.on('incomingClient', incomingHubCb)
     socket.on('cli-req', cliReqCb);

package/mailController.js

@@ -6,7 +6,7 @@ function createEmailTransport(req, config) {
     );
 }
 
-export async function sendMailWatcher(req) {
+export async function sendMailCliScript(req) {
     try {
         const transporter = createEmailTransport(req, req.body.config);
         const sendResult = await transporter.sendMail(req.body.mailOptions);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "biz-a-cli",
   "nameDev": "biz-a-cli-dev",
-  "version": "2.3.42",
+  "version": "2.3.52",
   "versionDev": "0.0.30",
   "description": "",
   "main": "bin/index.js",
@@ -28,7 +28,8 @@
     "biza": "bin/app.js"
   },
   "dependencies": {
-    "axios": "^1.6.8",
+    "axios": "^1.7.8",
+    "cloudflared": "^0.6.0",
     "compression": "^1.7.5",
     "cors": "^2.8.5",
     "dayjs": "^1.11.10",
@@ -36,6 +37,7 @@
     "mongodb": "^6.5.0",
     "net": "^1.0.2",
     "nodemailer": "^6.9.12",
+    "socket.io": "^4.7.5",
     "socket.io-client": "^4.7.5",
     "socket.io-stream": "^0.9.1",
     "tar": "^7.4.0",
@@ -45,8 +47,7 @@
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "jest": "^29.7.0",
-    "socket.io": "^4.7.5"
+    "jest": "^29.7.0"
   },
   "jest": {
     "transform": {},

package/readme.md

@@ -61,4 +61,25 @@
 
 
 > [!CAUTION]
-> **The *uploadBizA*, *uploadApp*, *deleteApp* commands are deprecated and will be removed in the future.**
+> **The *uploadBizA*, *uploadApp*, *deleteApp* commands are deprecated and will be removed in the future.**
+
+
+## III. Hub
+
+  ### a. Using HTTP
+	hub --server [BizA Hub Server] --sub [subdomain] --hostname [ip_API] --port [port_API]
+
+	Example :
+		hub --server https://biz-a.herokuapp.com --sub imamatek --hostname localhost --port 212
+
+  ### b. Using HTTPs (SSL)
+	hub --server [BizA Hub Server] --sub [subdomain] --hostname [ip_API] --port [port_API] --secure
+
+	Example :
+		hub --server https://biz-a.herokuapp.com --sub imamatek --hostname localhost --port 212 --secure
+		
+  ### c. Publish Hub
+	hub --server [BizA Hub Server] --sub [subdomain] --hostname [ip_API] --port [port_API] --publish [true]
+
+	Example :
+		hub --server https://biz-a.herokuapp.com --sub imamatek --hostname localhost --port 212 --publish=false

package/scheduler/datalib.js

@@ -221,13 +221,7 @@ export function getInputData(config, trigger) {
             dbindex: config.dbindex,
             finaDbIndex: config.finaDbIndex,
             subdomain: config.subdomain,
-            smtp: {
-                user: config.smtp.auth.user,
-                pass: config.smtp.auth.pass,
-                host: config.smtp.host,
-                port: config.smtp.port,
-                secure: config.smtp.secure
-            }
+            smtp: config.smtp
         },
         body: trigger.data
     }
@@ -235,7 +229,7 @@ export function getInputData(config, trigger) {
 
 export async function scheduleSubscription(config, data, trigger, needSetHistory, isTest = false) {
     try {
-        let functions = extractFunctionScript(config, data);
+        let functions = await extractFunctionScript(config, data);
 
         if (functions) {
             if (!isTest) {  // next, change isTest to test better

package/tests/data.test.js

@@ -22,7 +22,8 @@ const {
     getUrlAndParam,
     getTableObj,
     options,
-    setLibrary
+    setLibrary,
+    extractFunctionScript
 } = await import('../scheduler/datalib.js');
 
 describe('data test', () => {
@@ -44,7 +45,7 @@ describe('data test', () => {
         "    }" +
         "}";
 
-    test('check schedule subscription no history', () => {
+    test('check schedule subscription no history', async () => {
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -59,11 +60,11 @@ describe('data test', () => {
             name: 'New Watcher 1',
         }
 
-        scheduleSubscription(config, data, trigger, false, true);
+        await scheduleSubscription(config, data, trigger, false, true);
         expect(mockInsertHistory).toBeCalledTimes(0);
     });
 
-    test('check schedule subscription with history', () => {
+    test('check schedule subscription with history', async () => {
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -79,7 +80,7 @@ describe('data test', () => {
             name: 'New Watcher 1'
         }
 
-        scheduleSubscription(config, data, trigger, true, true);
+        await scheduleSubscription(config, data, trigger, true, true);
         expect(mockInsertHistory).toBeCalledTimes(1);
     });
 
@@ -111,21 +112,12 @@ describe('data test', () => {
             arguments: {
                 hostname: 'localhost',
                 port: 212,
-                dbindex: 2,
-                finaDbIndex: 1,
-                subdomain: 'abc',
-                smtp: {
-                    user: 'abc',
-                    pass: '123',
-                    host: 'mail.imamatek.com',
-                    port: 465,
-                    secure: true
-                }
+                dbindex: config.dbindex,
+                finaDbIndex: config.finaDbIndex,
+                subdomain: config.subdomain,
+                smtp: config.smtp
             },
-            body: {
-                _id: 1,
-                name: 'New Watcher 1'
-            }
+            body: trigger.data
         });
     });
 
@@ -346,6 +338,81 @@ describe('data test', () => {
         expect(result.libCb.zzz()).toStrictEqual({ "defA": "A", "defB": "B" });
     });
 
+    test('should return undefined when data has error', async () => {
+        const config = {};
+        const data = { error: 'error' };
+
+        const actual = await extractFunctionScript(config, data);
+        const expected = undefined;
+
+        expect(actual).toStrictEqual(expected);
+    });
+
+    test('should return undefined when no data', async () => {
+        const config = {};
+        const data = [];
+
+        const actual = await extractFunctionScript(config, data);
+        const expected = undefined;
+
+        expect(actual).toStrictEqual(expected);
+    });
+
+    test('should return undefined when no functions', async () => {
+        const config = {};
+        const data = [{
+            script: 'get = function () {\n' +
+                '    return {}\n' +
+                '}'
+        }];
+
+        const actual = await extractFunctionScript(config, data);
+        const expected = undefined;
+
+        expect(actual).toStrictEqual(expected);
+    });
+
+    test('should return onInit', async () => {
+        const config = {};
+        const data = [{
+            script: 'get = function () {\n' +
+                '    return {\n' +
+                '        functions: {\n' +
+                '            onInit: function (data) {\n' +
+                "                return 'OK'\n" +
+                '            }\n' +
+                '        }\n' +
+                '    }\n' +
+                '}'
+        }];
+
+        const actual = await extractFunctionScript(config, data);
+        const expected = 'OK';
+
+        expect(actual.onInit()).toStrictEqual(expected);
+    });
 
+    // test('should return useLibrary', async () => {  // not work, cannot mock useLibrary. Try later
+    //     const config = {};
+    //     const data = [{
+    //         script: 'get = function () {\n' +
+    //             '    return {\n' +
+    //             '        functions: {\n' +
+    //             '            onInit: function (data) {\n' +
+    //             "                return 'OK'\n" +
+    //             '            },\n' +
+    //             '            useLibrary: function () {\n' +
+    //             '                return ["lib"];\n' +
+    //             '            }\n' +
+    //             '        }\n' +
+    //             '    }\n' +
+    //             '}'
+    //     }];
+
+    //     const actual = await extractFunctionScript(config, data);
+    //     const expected = 'OK';
+
+    //     expect(actual.onInit()).toStrictEqual(expected);
+    // });
 })
 

package/tests/mailCtl.test.js

@@ -11,12 +11,12 @@ jest.unstable_mockModule('nodemailer', () => ({
     createTransport: (data) => mockCreateTransport(data)
 }))
 
-const { sendMailWatcher } = await import('../mailController.js');
+const { sendMailCliScript } = await import('../mailController.js');
 
 describe('Mail Controller', () => {
     let req;
 
-    test('transporter.sendmailWatcher is called', async () => {
+    test('transporter.sendMailCliScript is called', async () => {
         req = {
             body: {
                 companyname: 'abc',
@@ -27,12 +27,12 @@ describe('Mail Controller', () => {
         }
 
         mockSendMail.mockResolvedValue('OK');
-        expect(await sendMailWatcher(req)).toEqual('OK');
+        expect(await sendMailCliScript(req)).toEqual('OK');
         expect(mockSendMail).toBeCalledTimes(1);
         expect(mockCreateTransport).toHaveBeenCalledWith({ smtp: 'test' });
 
         mockSendMail.mockRejectedValue({ message: 'error' });
-        expect(await sendMailWatcher(req)).toEqual('error');
+        expect(await sendMailCliScript(req)).toEqual('error');
 
         expect(mockSendMail).toBeCalledTimes(2);
     })