biz-a-cli 2.3.53 → 2.3.55

package/bin/app.js

@@ -22,9 +22,10 @@ yargs(process.argv.slice(2))
 })
 .option("i", {
     alias: "dbIndex",
+    default: 2,
     describe: "database index",
     type: "number",
-    demandOption: true
+    demandOption: false
 })
 .option("sub", {
     alias: "subdomain",
@@ -34,10 +35,10 @@ yargs(process.argv.slice(2))
 })
 .option("p", {
     alias: "apiPort",
+    default : 212,
     describe: "FINA API Port",
-    type: "string",
+    type: "number",
     demandOption: false,
-    default : "212"
 })
 .command('add', 'Add Biz-A Application',
     {
@@ -262,8 +263,8 @@ yargs(process.argv.slice(2))
                     console.error('Nothing to upload. Please recheck your app folder.')
                 }
             } catch (e) {
-                // console.error(e.response?.data ? e.response.data : e)
-                console.error({e})
+                console.error(e.response?.data ? e.response.data : e)
+                // console.error({e})
             }
         }
 

package/bin/directHubEvent.js

@@ -1,57 +1,49 @@
-import axios from 'axios'
-import { IDLE_SOCKET_TIMEOUT_MILLISECONDS } from './hubEvent.js'
+import { apiRequestListener } 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', ()=>{notifyUser()})
-    let url = await new Promise((resolve)=>{
-        let tunnelURL = ''
-        qt.once('url', (qtUrl)=>{tunnelURL=qtUrl})
-        qt.once('connected', (conn)=>{resolve(tunnelURL)})
-        qt.once('exit', (code)=>{resolve('')})
-        qt.once('error', (err)=>{resolve('')})
+export async function localhostTunnel(port, notifier){
+    let tunnelUrl = ''
+    let qt = QuickTunnel.quick('127.0.0.1:'+port)
+    qt.on('url', (qtUrl)=>{
+        // console.log('qt url', qtUrl)
+        tunnelUrl = qtUrl
     })
-    if (!url) {
-        notifyUser()
-    }
-    return url
+    qt.on('connected', (conn)=>{
+        // console.log('qt connect', conn)
+        notifier(tunnelUrl)
+        console.log(`${new Date()}: Connected to Direct Hub at public URL`)
+    })
+    qt.on('disconnected', (conn)=>{
+        // console.log('qt disconnect', conn)
+        notifier('')
+        qt.stop
+    })
+    qt.on('error', (err)=>{
+        // console.log('qt err', err)
+        notifier('')
+        qt.stop
+    })
+    qt.on('exit', (code)=>{
+        // console.log('qt exit', code)
+        notifier('')
+        console.log(`${new Date()}: Direct Hub is not available, will try to reinitiate it in 5 minutes. Error code : `, code)
+        setTimeout(()=>{qt = localhostTunnel(port, notifier)}, 5*60000)
+    })
+    // qt.on('stdout', (data)=>{
+    //     console.log('qt stdout', data)
+    // })
+    // qt.on('stderr', (data)=>{
+    //     console.log('qt stderr', data)
+    // })
+    return qt
 }
 
 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}`)})
+            console.log(clientSocket.id, 'connected')
+            clientSocket.on('disconnect', (reason)=>{console.log(`${clientSocket.id||'Direct Hub'} 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)
-            }
-        })
+        apiRequestListener(clientSocket, argv)
     })
 }

package/bin/hub.js

@@ -2,7 +2,7 @@
 
 import yargs from 'yargs';
 import { io as ioClient } from "socket.io-client";
-import hubEvent from './hubEvent.js'
+import { streamEvent, hubEvent } from './hubEvent.js'
 import { createLogger, transports, format } from "winston";
 import { Server as ioServer } from 'socket.io'
 import os from 'node:os'
@@ -38,7 +38,7 @@ const argv = yargs(process.argv.slice(2))
         default: 'https://biz-a.herokuapp.com',
         describe: '(Required) Tunnel server endpoint',
         type: 'string',
-        demandOption: true
+        demandOption: false
     })
     .options('sub', {
         alias: 'subdomain',
@@ -51,7 +51,7 @@ const argv = yargs(process.argv.slice(2))
         default: '127.0.0.1',
         describe: 'Address of API server for forwarding over socket-tunnel. Please emit "HTTP" or "HTTPS" from address',
         type: 'string',
-        demandOption: true
+        demandOption: false
     })
     .options('p', {
         alias: 'port',
@@ -86,6 +86,12 @@ const argv = yargs(process.argv.slice(2))
         type: 'number',
         demandOption: false
     })
+    .options('hub', {
+        default: 'https://biz-a-hub-ed77b066db87.herokuapp.com/',
+        describe: 'BizA hub',
+        type: 'string',
+        demandOption: false
+    })
     .argv;
 
 if (argv.help) {
@@ -122,7 +128,6 @@ app.set('args', argv);
 
 app.use('/cb', runCliScript);
 
-
 // create HTTP(s) Server
 const keyFile = path.join(import.meta.dirname,  "../cert/key.pem")
 const certFile = path.join(import.meta.dirname,  "../cert/cert.pem")
@@ -130,32 +135,35 @@ 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}
+    return {ip, port: argv.serverport, address: `${ip}:${argv.serverport}`, publicUrl: argv.connectedPublicUrl, hubUrl: argv.connectedHubUrl}
 }
-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} `);
+    const info = argv.cliAddress()
+    console.log(`${new Date()}: CLI is listening at ${getProtocol() + (process.env.HOST || info.ip || 'localhost')}:${info.port} `);
 });
 
+await streamEvent(ioClient(argv['server'], {query: {isSockStream: true }}), argv); // as socket client to BizA SERVER
 
-// 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}"`)
+// as socket client to BizA HUB
+if (argv.hub) {
+    hubEvent(ioClient(argv['hub'], { reconnectionDelay: 5*60*1000, reconnectionDelayMax: 5*60*1000, query: {isCLI: true, room: argv['subdomain']} }), argv, (url)=>{
+        if (url!==argv.connectedHubUrl) {
+            argv.connectedHubUrl = url
+        }
+    })
+}
 
+// as socket server from BizA Client
+const serverCORSOrigin = ['https://biz-a.id', 'https://test.biz-a.id', /\.biz-a\.id$/].concat((process.env.NODE_ENV === 'production') ? [] : [`http://${argv.cliAddress().ip}:4200`, 'http://localhost:4200'])
+directHubEvent(new ioServer(server, {cors: {origin: serverCORSOrigin}}), argv);
+if (argv.publish==true) {
+    localhostTunnel(argv.serverport, (url)=>{ // publish CLI
+        if (url!==argv.connectedPublicUrl) {
+            argv.connectedPublicUrl = url
+        }
+    })
+}
 
 export { app }

package/bin/hubEvent.js

@@ -7,33 +7,19 @@ const ss = require('socket.io-stream');  //SCY: Temporary, next will be replaced
 import { Transform } from 'node:stream'
 // import { pipeline } from 'node:stream'
 
-export const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
+const IDLE_SOCKET_TIMEOUT_MILLISECONDS = 1000 * 30;
 
 export const socketAgent = isUsingHttps=>(isUsingHttps==true) ? tls : net
 
-export default async (socket, argv) => new Promise((resolve, reject) => {
+export const streamEvent = async (socket, argv) => new Promise((resolve, reject) => {
 
     const connectCb = () => {
-        // 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');
-
-                // // clean and concat requested url
-                // let url;
-                // // let subdomain = argv['subdomain'].toString();
-                // let server = argv['server'].toString();
-
-                // url = server;
-
-                // // resolve promise with requested URL
-                // resolve(url);
-
+                console.log(`${new Date()}: Connected to BizA Server at ${argv.server} using sub domain "${argv['subdomain']}"`)
                 resolve(argv['server'].toString());
             }
         });
@@ -42,11 +28,11 @@ export default async (socket, argv) => new Promise((resolve, reject) => {
     const incomingHubCb = (clientId) => {
         // console.log(clientId, 'incoming clientId')
 
-        let addCLIAddressAsResponseHeader = new Transform({
+        const 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)) {
+                if ( (apiResponse.indexOf('200 ok') > -1) && (apiResponse.indexOf('server: datasnaphttpservice') > -1)) {
                     // 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'
@@ -55,8 +41,10 @@ export default async (socket, argv) => new Promise((resolve, reject) => {
                         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` +
+                            'Access-Control-Expose-Headers: biza-cli-address, biza-hub-address\r\n' +
+                            // `biza-cli-address: ${cliAddress.address}\r\n` + // if we need directHub with local LAN
+                            (cliAddress.publicUrl ? `biza-cli-address: ${cliAddress.publicUrl}\r\n` : '') +
+                            (cliAddress.hubUrl ? `biza-hub-address: ${cliAddress.hubUrl}\r\n` : '') +
                             '\r\n'
                         )
                     ])
@@ -121,4 +109,61 @@ export default async (socket, argv) => new Promise((resolve, reject) => {
     socket.on('connect', connectCb);
     socket.on('incomingClient', incomingHubCb)
     socket.on('cli-req', cliReqCb);
-})
+})
+
+export const hubEvent = (socket, argv, notifier)=>{
+    let id
+    socket.on('connect', ()=>{
+        id = socket.id
+        notifier(argv['hub'])
+        console.log(`${new Date()}: Connected to BizA Hub at ${argv['hub']} using sub domain "${argv['subdomain']}" with id "${id}"`)
+    })
+    socket.on('disconnect', (reason)=>{
+        notifier('')
+        console.log(`${new Date()}: ${id||''} disconnected from BizA Hub. Reason: ${reason}`)
+    })
+    const logError = msg=>{console.log(`${new Date()}: ${id||''} connection error to BizA Hub. Error : ${msg}`)}
+    socket.on('connect_error', (error)=>{
+        notifier('')
+        logError(error.message)
+    })
+    socket.on('error', (error)=>{
+        notifier('')
+        logError(error)
+    })
+    apiRequestListener(socket, argv)
+}
+
+export const apiRequestListener = (socket, argv)=>{
+    socket.on('apiRequest', (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: (reqData.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/package.json

@@ -1,14 +1,14 @@
 {
   "name": "biz-a-cli",
   "nameDev": "biz-a-cli-dev",
-  "version": "2.3.53",
-  "versionDev": "0.0.30",
+  "version": "2.3.55",
+  "versionDev": "0.0.34",
   "description": "",
   "main": "bin/index.js",
   "type": "module",
   "engines": {
-    "node": "^20.16.0",
-    "npm": "^10.8.1"
+    "node": ">=20.16.0",
+    "npm": ">=10.8.1"
   },
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch a",

package/readme.md

@@ -82,4 +82,4 @@
 	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
+		hub --server https://biz-a.herokuapp.com --sub imamatek --hostname localhost --port 212 --publish

package/scheduler/timer.js

@@ -1,7 +1,6 @@
 import { checkSchedule } from "./datalib.js"
 import { getWatchers, getHistories } from "./watcherController.js";
 import { isItTime, loopTimer } from "./watcherlib.js"
-import { setInterval } from 'timers/promises';
 import { getCompanyObjectId, getSelectedConfig } from "../scheduler/configController.js";
 import { historyRecordToJson, watcherRecordToJson, setUtcDate } from "./converter.js";
 
@@ -46,31 +45,44 @@ export async function runHistory(histories, config, watchers, now) {
     }
 }
 
+export async function runRecentSchedule(intervalTime, config) {
+    const result = await getWatchers(config);
+    const watchers = watcherRecordToJson(result);
+
+    for (const watcher of watchers) {
+        loopTimer(watcher.timer, intervalTime, config, true);
+    }
+
+    // reload == true ?
+}
+
+export async function* setConstantInterval(interval, start) {  //SCY BZ 4169
+    let nextTime = start;
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, nextTime - Date.now()));
+        yield nextTime;
+        nextTime += interval;
+    }
+}
 
 export const runScheduler = async (companyName) => {
     const company = await getCompanyObjectId(companyName);
     const config = await getSelectedConfig(company._id);
 
-    Promise.all([getHistories(config), getWatchers(config)])
-        .then(([historyResult, watcherResult]) => {
-            const histories = historyRecordToJson(historyResult);
-            const watchers = watcherRecordToJson(watcherResult);
-            runHistory(histories, config, watchers, new Date());
-        });
+    Promise.all([getHistories(config), getWatchers(config)]).then(([historyResult, watcherResult]) => {
+        const histories = historyRecordToJson(historyResult);
+        const historyWatchers = watcherRecordToJson(watcherResult);
+        runHistory(histories, config, historyWatchers, new Date());
+    });
+
 
     let intervalStartTime = '';
-    for await (const startTime of setInterval(SCHEDULE_INTERVAL, Date.now())) {
+    for await (const intervalTime of setConstantInterval(SCHEDULE_INTERVAL, Date.now())) {
         if (!intervalStartTime) {
-            console.log('Interval Time starts at :', new Date(startTime));
-            intervalStartTime = new Date(startTime);
-        }
-        
-        const result = await getWatchers(config);
-        const watchers = watcherRecordToJson(result);
-        for (const watcher of watchers) {
-            loopTimer(watcher.timer, Date.now(), config, true);
+            console.log('Interval Time starts at :', new Date(intervalTime));
+            intervalStartTime = new Date(intervalTime);
         }
 
-        // // reload == true ?
+        await runRecentSchedule(intervalTime, config);
     }
 }

package/tests/app.test.js

@@ -9,8 +9,8 @@ import { env } from "../envs/env.js"
 describe('Biz-A Apps CLI', ()=>{
 
     let originalOptions, originalCWD, axios
-    const logSpy = jest.spyOn(global.console, 'log')
-    const errorSpy = jest.spyOn(global.console, 'error')
+    const logSpy = jest.spyOn(global.console, 'log').mockImplementation()
+    const errorSpy = jest.spyOn(global.console, 'error').mockImplementation()
 
     async function runCommand(...options){
         process.argv[1] = process.cwd()+'\\bin' // mock the key root folder
@@ -294,7 +294,8 @@ describe('Biz-A Apps CLI', ()=>{
                     expect(logSpy.mock.calls[0][0]).toBe('===================\nA.JS\n===================')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»'})
+                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»'})
+                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»')
                 }
             ],
             [
@@ -309,7 +310,8 @@ describe('Biz-A Apps CLI', ()=>{
                     expect(logSpy.mock.calls[4][0]).toBe('Running script with Import function')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : ReferenceError: modul is not defined'}) // ES6 import error
+                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : ReferenceError: modul is not defined'}) // ES6 import error
+                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js : ReferenceError: modul is not defined')// ES6 import error
                 }
             ],
             [
@@ -323,7 +325,8 @@ describe('Biz-A Apps CLI', ()=>{
                     expect(logSpy.mock.calls[3][0]).toBe('Running script with Import function')
 
                     expect(errorSpy.mock.calls.length).toBe(1)
-                    expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result'})
+                    // expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result'})
+                    expect(errorSpy.mock.calls[0][0]).toStrictEqual('a.js : Failed to compile template script.\nPlease make sure the script is correct and not returning empty result')
                 }
             ],
         ]

package/tests/data.test.js

@@ -46,6 +46,8 @@ describe('data test', () => {
         "}";
 
     test('check schedule subscription no history', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -62,9 +64,13 @@ describe('data test', () => {
 
         await scheduleSubscription(config, data, trigger, false, true);
         expect(mockInsertHistory).toBeCalledTimes(0);
+        expect(logSpy).toHaveBeenCalledWith('Run Schedule : New Watcher 1');
+
+        logSpy.mockRestore();
     });
 
     test('check schedule subscription with history', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
         const config = {
             _id: 'ffffffff2ae49fab9ea654e1',
             url: 'http://localhost:212',
@@ -82,6 +88,9 @@ describe('data test', () => {
 
         await scheduleSubscription(config, data, trigger, true, true);
         expect(mockInsertHistory).toBeCalledTimes(1);
+        expect(logSpy).toHaveBeenCalledWith('Run Recent Schedule : New Watcher 1');
+
+        logSpy.mockRestore();
     });
 
     test('get input data', () => {
@@ -339,6 +348,8 @@ describe('data test', () => {
     });
 
     test('should return undefined when data has error', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         const config = {};
         const data = { error: 'error' };
 
@@ -346,6 +357,9 @@ describe('data test', () => {
         const expected = undefined;
 
         expect(actual).toStrictEqual(expected);
+        expect(logSpy).toHaveBeenCalledWith('error', 'error');
+
+        logSpy.mockRestore();
     });
 
     test('should return undefined when no data', async () => {

package/tests/hub.test.js

@@ -1,13 +1,19 @@
-import { Server } from 'socket.io';
+import { Server as ioServer } from 'socket.io';
 import { createServer } from 'node:http'
-import hubEvent from '../bin/hubEvent.js'
-import { io as ioc } from "socket.io-client";
+import { streamEvent, hubEvent, socketAgent } from '../bin/hubEvent.js'
+import { io as ioClient } from "socket.io-client";
 import { jest } from '@jest/globals';
 import axios from "axios";
+import net from 'node:net'
+import tls from 'node:tls'
+import ss from 'socket.io-stream'
+import { Writable, pipeline } from 'node:stream'
+import { text } from 'node:stream/consumers'
+import { directHubEvent } from '../bin/directHubEvent.js'
 
 let socketsBySubdomain = {};
 
-const createSocket2CLI = (socket) => {
+const createSockTunnel2CLI = (socket) => {
     return (subdomain, responseCb) => {
         const responseCallback = (error) => { if (responseCb) responseCb(error) }
         let subdomainStr = subdomain.toString();
@@ -31,39 +37,52 @@ const toPromise = (cb) => new Promise((resolve, reject) => {
     setTimeout(() => reject(new Error('timeout')), 1000)
 })
 
-describe('cli req test', () => {
-    let io, port;
+describe('Hub event tests', () => {
+    let bizAServer_ServerSocket, port;
+    let cliHttpServer
+
     const startSocket = function startSocket(server) {
-        let io = new Server(server);
+        let io = new ioServer(server);
         io.on('connection', (socket) => {
-            socket.on('createTunnel', createSocket2CLI(socket));
+            socket.on('createTunnel', createSockTunnel2CLI(socket));
             socket.on('disconnect', deleteSubdomain(socket));
         });
-
         return io;
     }
 
+    function freeSocketClient(sock){
+        if (sock) {
+            if (sock.connected) {
+                sock.off()
+                sock.disconnect()
+            }
+            sock.destroy()
+            sock = undefined
+        }
+    }
+
     beforeAll((done) => {
-        const httpServer = createServer()
-        io = startSocket(httpServer)
+        cliHttpServer = createServer()
+        bizAServer_ServerSocket = startSocket(cliHttpServer)
 
-        httpServer.listen(async () => {
-            port = httpServer.address().port;
+        cliHttpServer.listen(async () => {
+            port = cliHttpServer.address().port;
             done()
         })
     })
 
     afterAll(() => {
-        io.close();
+        bizAServer_ServerSocket.close();
     })
 
     test('request to cli', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
         let mockedRequest = jest.spyOn(axios, 'request').mockReturnValue({ data: 'OK' });
 
         let socket;
         try {
-            socket = ioc(`http://localhost:${port}`);
-            await hubEvent(socket, {
+            socket = ioClient(`http://localhost:${port}`);
+            await streamEvent(socket, {
                 server: `http://localhost:${port}`,
                 subdomain: 'scy',
                 hostname: 'localhost',
@@ -103,8 +122,300 @@ describe('cli req test', () => {
             });
 
             socket.disconnect();
+
+            expect(logSpy).toHaveBeenCalledWith('error', 'error');
+
+            logSpy.mockRestore();
         } catch (error) {
             console.log(error);
         }
     })
+
+    test('should used correct socket agent', ()=>{
+        expect(socketAgent(false)).toBe(net)
+        expect(socketAgent(true)).toBe(tls)
+    })
+
+    test('should access API with scheme of BizA Client <--https--> BizA Server <--socket stream--> BizA CLI <--socket--> API', async ()=>{
+        const uniqueId = '123456' // this is used for make sure BizA Server will get correct response from BizA CLI
+        const subdomain = 'hub'
+
+        let cliToBizAServerSocket // mocking of socket client from BizA CLI to BizA Server
+        let mockAPIServer // mocking of FINA API Datasnap server. We need to used TCP Server to test data flow using socket, so don't used HTTP Server
+        let cliToAPISocket // mocking of socket client from BizA CLI to FINA API Datasnap Server
+
+        try {
+
+            cliToBizAServerSocket = ioClient(`http://localhost:${port}`)
+            await streamEvent(cliToBizAServerSocket, {
+                server: `http://localhost:${port}`,
+                subdomain,
+                hostname: '127.0.0.1',
+                port: 212,
+                serverport: 3002,
+                cliAddress: ()=>{return {ip: '59.60.1.22', port: '3002', address: `59.60.1.22:3002`, publicUrl: 'https://some.public.url', hubUrl: 'https://some.hub.url'}},
+                hub: 'https://some.hub.url'
+            })
+
+            mockAPIServer = net.createServer((clientSocket)=>{
+                cliToAPISocket = clientSocket
+                clientSocket.on('data', (data)=>{
+                    if (data.toString().toUpperCase()==='POST /SUCCESS HTTP/1.1') {
+                        clientSocket.write('HTTP/1.1 200 Ok\r\nServer: datasnapHTTPService\r\n\r\n')
+                    }
+                    else if (data.toString().toUpperCase()==='POST /FAIL HTTP/1.1') {
+                        clientSocket.write('HTTP/1.1 403 Forbidden\r\nServer: datasnapHTTPService\r\n\r\n')
+                    }
+                })
+            })
+            await toPromise(resolve=>{mockAPIServer.listen({port: 212, host: '127.0.0.1'}, ()=>{resolve()})})
+
+            const getResponse = async (httpRawRequest)=>{
+                let tunnelStream // mocking of socket stream between BizA CLI and BizA Server, also act as mocking of HTTP Request from BizA Client
+                let outputStream // mocking of HTTP Response received by BizA Client
+                try {
+                    let outputContent = []
+                    outputStream = new Writable({
+                        write(chunk, encoding, next){
+                            outputContent.push(chunk)
+                            cliToAPISocket.end() // Imitate API Server to finish sending response, it will call end "tunnelStream" and lastly it will close "outputStream"
+                            next()
+                        }
+                    })
+                    tunnelStream = await toPromise(resolve => {
+                        ss(socketsBySubdomain[subdomain]).once(uniqueId, (stream)=>{
+                            pipeline(stream, outputStream, (err)=>{if (err) console.error(err)})
+                            resolve(stream)
+                        })
+                        socketsBySubdomain[subdomain].emit('incomingClient', uniqueId)
+                    })
+
+                    tunnelStream.write(httpRawRequest)
+                    await text(tunnelStream) // this will try to read data from "cliToAPISocket" -> "transformStream" -> "tunnelStream" -> "outputStream"
+                    return outputContent.toString()
+                }
+                finally {
+                    if (tunnelStream) tunnelStream.destroy()
+                    if (outputStream) outputStream.destroy()
+                    freeSocketClient(cliToAPISocket)
+                }
+            }
+
+            expect(await getResponse('POST /success HTTP/1.1')).toBe(
+                'HTTP/1.1 200 Ok\r\n' +
+                'Server: datasnapHTTPService\r\n'+
+                'Access-Control-Expose-Headers: biza-cli-address, biza-hub-address\r\n'+
+                'biza-cli-address: https://some.public.url\r\n' +
+                'biza-hub-address: https://some.hub.url\r\n\r\n'
+            )
+
+            expect(await getResponse('POST /fail HTTP/1.1')).toBe(
+                'HTTP/1.1 403 Forbidden\r\n' +
+                'Server: datasnapHTTPService\r\n\r\n'
+            )
+        }
+        finally {
+            freeSocketClient(cliToBizAServerSocket)
+            if (mockAPIServer) mockAPIServer.close()
+        }
+    })
+
+    describe('should access API with scheme of BizA Client <--socket tunnel--> BizA CLI <--http--> API', ()=>{
+        const apiAddress = '127.0.0.1'
+        const subdomain = 'directHub'
+        let cliSocketServer // mocking of CLI socket server
+        let clientToCliSocket // mocking of socket client from BizA Client to BizA CLI
+        let mockedRequest
+
+        beforeEach(()=>{
+            mockedRequest = jest.spyOn(axios, 'request')
+            mockedRequest.mockClear()
+        })
+
+        beforeAll(()=>{
+            cliSocketServer = new ioServer(9999)// mocking of CLI socket server
+            directHubEvent(cliSocketServer, {subdomain, hostname: apiAddress, port, secure: false})
+
+            clientToCliSocket = ioClient('http://localhost:9999')
+        })
+
+        afterAll(()=>{
+            freeSocketClient(clientToCliSocket)
+            if (cliSocketServer) {
+                cliSocketServer.close()
+            }
+        })
+
+        test('should return success response', async ()=>{
+            mockedRequest.mockResolvedValueOnce({
+                status: 200,
+                statusText: 'Success',
+                headers: {'res-header': 'aa'},
+                data: 'body of response',
+                config: {baseURL: 'localhost', url: '/test'}
+            })
+
+            const [error, response] = await toPromise(resolve => {
+                clientToCliSocket.emit(
+                    'apiRequest'
+                    , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request', responseType: 'json'}
+                    , (res, err)=>{resolve([res, err])}
+                )
+            })
+
+            expect(response).toStrictEqual({
+                status: 200,
+                statusText: 'Success',
+                headers: {'res-header': 'aa'},
+                body: 'body of response',
+                url: `${apiAddress}:${port}/test`
+            })
+
+            expect(error).toBe(null)
+
+            expect(mockedRequest).toHaveBeenCalledWith({
+                timeout: 30*1000,
+                baseURL: `http://127.0.0.1:${port}`,
+                url: '/test',
+                method: "POST",
+                headers: {'req-header': 'aa'},
+                data: 'body of request',
+                // decompress: false,
+                responseType: 'json',
+                maxContentLength: Infinity,
+            })
+        })
+
+        test('should return fail response', async ()=>{
+            const mockErrorResponse = {response: {
+                status: 400,
+                statusText: 'Failed',
+                headers: {'res-header': 'aa'},
+                data: 'body of response',
+                config: {baseURL: 'localhost', url: '/test'}
+            }}
+            mockedRequest.mockRejectedValueOnce(mockErrorResponse)
+
+            const [error, response] = await toPromise(resolve => {
+                clientToCliSocket.emit(
+                    'apiRequest'
+                    , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request', responseType: 'arraybuffer'}
+                    , (res, err)=>{resolve([res, err])}
+                )
+            })
+
+            expect(response).toBe(null)
+
+            expect(error).toStrictEqual(mockErrorResponse)
+
+            expect(mockedRequest).toHaveBeenCalledWith({
+                timeout: 30*1000,
+                baseURL: `http://127.0.0.1:${port}`,
+                url: '/test',
+                method: "POST",
+                headers: {'req-header': 'aa'},
+                data: 'body of request',
+                // decompress: false,
+                responseType: 'arraybuffer',
+                maxContentLength: Infinity,
+            })
+        })
+
+        test('should return bad subdomain response', async ()=>{
+            const [error, response] = await toPromise(resolve => {
+                clientToCliSocket.emit(
+                    'apiRequest'
+                    , {subDomain: 'wrong subdomain', method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request'}
+                    , (res, err)=>{resolve([res, err])}
+                )
+            })
+
+            expect(response).toBe(null)
+
+            expect(error).toStrictEqual({
+                status: 401,
+                statusText: 'bad subdomain',
+                url: `${apiAddress}:${port}/test`
+            })
+
+            expect(mockedRequest).not.toHaveBeenCalledWith()
+        })
+    })
+
+    test('should access API with scheme of BizA Client <--socket--> BizA Hub <--socket--> BizA CLI <--http--> API', async ()=>{
+        const subdomain = 'roomA'
+        let cliToHubSocket
+        let hubToCLISocket
+        let hubServer
+
+        try {
+            mockedRequest = jest.spyOn(axios, 'request')
+            mockedRequest.mockClear()
+            mockedRequest.mockResolvedValueOnce({
+                status: 200,
+                statusText: 'Success',
+                headers: {'res-header': 'aa'},
+                data: 'body of response',
+                config: {baseURL: 'localhost', url: '/test'}
+            })
+
+            hubServer = new ioServer(9998)
+            hubServer.on('connection', (sock)=>hubToCLISocket = sock)
+
+            cliToHubSocket = ioClient('http://localhost:9998')
+            hubEvent(
+                cliToHubSocket,
+                {
+                    server: `http://localhost:${port}`,
+                    subdomain,
+                    hostname: '127.0.0.1',
+                    port,
+                    serverport: 3002,
+                    cliAddress: ()=>{return {ip: '59.60.1.22', port: '3002', address: `59.60.1.22:3002`, publicUrl: 'https://some.tunnel.url'}},
+                    hub: 'https://some.hub.url'
+                },
+                (hubUrl)=>{
+                    expect(hubUrl).toBe('https://some.hub.url')
+                }
+            )
+
+            await toPromise(resolve => cliToHubSocket.once('connect', ()=>resolve()))
+
+            const [error, response] = await toPromise(resolve => {
+                    hubToCLISocket.emit(
+                    'apiRequest'
+                    , {subDomain: subdomain, method: 'POST', path: '/test', headers: {'req-header': 'aa'}, body: 'body of request', responseType: 'json'}
+                    , (res, err)=>{resolve([res, err])}
+                )
+            })
+
+            expect(response).toStrictEqual({
+                status: 200,
+                statusText: 'Success',
+                headers: {'res-header': 'aa'},
+                body: 'body of response',
+                url: `127.0.0.1:${port}/test`
+            })
+
+            expect(error).toBe(null)
+
+            expect(mockedRequest).toHaveBeenCalledWith({
+                timeout: 30*1000,
+                baseURL: `http://127.0.0.1:${port}`,
+                url: '/test',
+                method: "POST",
+                headers: {'req-header': 'aa'},
+                data: 'body of request',
+                responseType: 'json',
+                maxContentLength: Infinity,
+            })
+        }
+        finally {
+            freeSocketClient(cliToHubSocket)
+            if (hubServer) {
+                hubServer.close()
+            }
+        }
+    })
+
 })

package/tests/mailCtl.test.js

@@ -17,6 +17,8 @@ describe('Mail Controller', () => {
     let req;
 
     test('transporter.sendMailCliScript is called', async () => {
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+
         req = {
             body: {
                 companyname: 'abc',
@@ -35,5 +37,8 @@ describe('Mail Controller', () => {
         expect(await sendMailCliScript(req)).toEqual('error');
 
         expect(mockSendMail).toBeCalledTimes(2);
+        expect(logSpy).toHaveBeenCalledWith('Error: error');
+
+        logSpy.mockRestore();
     })
 })

package/tests/timer.test.js

@@ -1,4 +1,31 @@
 import { jest } from '@jest/globals'
+const { ObjectId } = await import('mongodb');
+
+const CONFIGS = [{
+    companyObjectId: new ObjectId('62948492f7d559fba6f32196')
+}]
+
+const RAW_WATCHERS = [{
+    watcher_id: 1,
+    company_id: '62948492f7d559fba6f32196',
+    timer_id: 1,
+    timer_watcher_id: 1,
+    name: 'New Watcher 1',
+    active: true,
+    timezone: 'Asia/Jakarta',
+    templateName: 'cekUser.js',
+    seq: 0,
+    daily_days: '0,1,2,3,4,5,6',
+    weekly_ordinal: '',
+    weekly_days: '',
+    monthly_days: '',
+    minutely_everymin: 1,
+    minutely_time_from: '08:00',
+    minutely_time_to: '22:00',
+    hourly_hours: '',
+    scriptid: 1,
+    cli_script: 'abc'
+}];
 
 const mockCheckSchedule = jest.fn();
 jest.unstable_mockModule("../scheduler/datalib.js", () => ({
@@ -9,13 +36,29 @@ jest.unstable_mockModule("../scheduler/datalib.js", () => ({
     delay: jest.fn().mockResolvedValue('OK')
 }))
 
+jest.unstable_mockModule("../scheduler/watcherController.js", () => ({
+    getWatchers: jest.fn(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return RAW_WATCHERS;
+    }),
+    getHistories: jest.fn().mockResolvedValue('OK')
+}))
+
+const mockLoopTimer = jest.fn();
+jest.unstable_mockModule("../scheduler/watcherLib.js", () => ({
+    loopTimer: mockLoopTimer.mockResolvedValue('OK'),
+    isItTime: jest.fn().mockResolvedValue('OK'),
+}))
+
 const {
-    SCHEDULE_INTERVAL,
+    // SCHEDULE_INTERVAL,
     getSelectedData,
     increaseInterval,
-    runHistory
+    runHistory,
+    runRecentSchedule,
+    setConstantInterval
 } = await import('../scheduler/timer.js');
-const { ObjectId } = await import('mongodb');
+
 
 describe('timer and mitigation test', () => {
     test('increase interval', async () => {
@@ -60,9 +103,7 @@ describe('timer and mitigation test', () => {
                 // latestRun: new Date(decreaseInterval(NOW)).toISOString()
             }
         ]
-        const CONFIGS = [{
-            companyObjectId: new ObjectId('62948492f7d559fba6f32196')
-        }]
+
         const WATCHERS = [
             {
                 _id: new ObjectId('65c34bd674ae2595b5efb5a7'),
@@ -89,4 +130,58 @@ describe('timer and mitigation test', () => {
         await runHistory(HISTORIES, CONFIGS, WATCHERS, new Date('2024-02-29T07:00:00.000Z'));
         expect(mockCheckSchedule).toBeCalledTimes(3);
     });
+
+    test('run recent schedule with delay functions', async () => {
+        const startTime = Date.now();
+
+        const WATCHER_CONVERTED = [{
+            "_id": 1,
+            "watcherObjectId": 1,
+            "name": "New Watcher 1",
+            "active": true,
+            "timezone": "Asia/Jakarta",
+            "templateName": "cekUser.js",
+            "seq": 0,
+            "scriptid": 1,
+            "script": "\"abc\"",
+            "daily": [0, 1, 2, 3, 4, 5, 6],
+            "minutely": {
+                "everyMin": 1,
+                "from": "08:00",
+                "to": "22:00"
+            }
+        }];
+
+        await runRecentSchedule(startTime, CONFIGS[0]);
+        expect(mockLoopTimer).toHaveBeenCalledWith(WATCHER_CONVERTED, startTime, CONFIGS[0], true);
+    });
+
+    test('constant interval', async () => {
+        jest.useFakeTimers();
+        jest.spyOn(global, 'setTimeout');
+
+        const interval = 1000;
+        const startTime = Date.now();
+        const generator = setConstantInterval(interval, startTime);
+
+        let results = [];
+
+        const fetchNextValue = async () => {
+            const next = generator.next();
+            jest.advanceTimersByTime(interval);
+
+            return (await next).value;
+        };
+
+        results.push(await fetchNextValue());
+        results.push(await fetchNextValue());
+        results.push(await fetchNextValue());
+
+        expect(results[0]).toBe(startTime);
+        expect(results[1]).toBe(startTime + interval);
+        expect(results[2]).toBe(startTime + 2 * interval);
+        expect(results[3]).toBe(undefined);
+
+        jest.useRealTimers();
+    });
 })

package/tests/watcher.test.js

@@ -97,8 +97,10 @@ describe('isItTime', () => {
                 to: '17:00'
             }
         }
+        expect(isItTime(dataWatcher, '2023-11-7 9:00:00')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 9:00:01')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 9:05:01')).toBe(true)
+        expect(isItTime(dataWatcher, '2023-11-7 17:00:00')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 17:00:01')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 16:55:59')).toBe(true)
         expect(isItTime(dataWatcher, '2023-11-7 8:59:59')).toBe(false)