biz-a-cli 2.3.70 → 2.3.71

package/package.json

@@ -1,73 +1,71 @@
 {
-  "name": "biz-a-cli",
-  "nameDev": "biz-a-cli-dev",
-  "version": "2.3.70",
-  "versionDev": "0.0.34",
-  "description": "",
-  "main": "bin/index.js",
-  "type": "module",
-  "engines": {
-    "node": ">=20.16.0",
-    "npm": ">=10.8.1"
-  },
-  "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch a",
-    "testOnce": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "dev": "node --watch server.js",
-    "hub": "set NODE_ENV=dev&& node --experimental-vm-modules bin/hub.js"
-  },
-  "author": "Imamatek",
-  "license": "ISC",
-  "bin": {
-    "uploadbiza": "bin/index.js",
-    "proxy": "bin/proxy.js",
-    "hub": "bin/hub.js",
-    "watcher": "bin/watcher.js",
-    "uploadapp": "bin/uploadApp.js",
-    "deleteapp": "bin/deleteApp.js",
-    "biza": "bin/app.js"
-  },
-  "dependencies": {
-    "axios": "^1.7.8",
-    "cloudflared": "^0.6.0",
-    "compression": "^1.7.5",
-    "cors": "^2.8.5",
-    "dayjs": "^1.11.10",
-    "express": "^4.18.3",
-    "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",
-    "uglify-js": "^3.19.3",
-    "web-push": "^3.6.7",
-    "winston": "^3.13.0",
-    "yargs": "^17.7.2"
-  },
-  "devDependencies": {
-    "jest": "^29.7.0"
-  },
-  "jest": {
-    "transform": {},
-    "testMatch": [
-      "<rootDir>/tests/**",
-      "!<rootDir>/tests/mockData",
-      "!<rootDir>/tests/mockData/**"
-    ],
-    "testPathIgnorePatterns": [
-      "<rootDir>/node_modules",
-      "<rootDir>/tests/mockData"
-    ],
-    "watchPathIgnorePatterns": [
-      "<rootDir>/node_modules",
-      "<rootDir>/tests/mockData"
-    ],
-    "coveragePathIgnorePatterns": [
-      "<rootDir>/node_modules",
-      "<rootDir>/tests/mockData",
-      "<rootDir>/tests/mockData/**"
-    ]
-  }
-}
+    "name": "biz-a-cli",
+    "version": "2.3.71",
+    "description": "",
+    "main": "bin/index.js",
+    "type": "module",
+    "engines": {
+        "node": ">=20.16.0",
+        "npm": ">=10.8.1"
+    },
+    "scripts": {
+        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch a",
+        "testOnce": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+        "dev": "node --watch server.js",
+        "hub": "set NODE_ENV=dev&& node --experimental-vm-modules bin/hub.js"
+    },
+    "author": "Imamatek",
+    "license": "ISC",
+    "bin": {
+        "uploadbiza": "bin/index.js",
+        "proxy": "bin/proxy.js",
+        "hub": "bin/hub.js",
+        "watcher": "bin/watcher.js",
+        "uploadapp": "bin/uploadApp.js",
+        "deleteapp": "bin/deleteApp.js",
+        "biza": "bin/app.js"
+    },
+    "dependencies": {
+        "axios": "^1.7.8",
+        "cloudflared": "^0.6.0",
+        "compression": "^1.7.5",
+        "cors": "^2.8.5",
+        "dayjs": "^1.11.10",
+        "express": "^4.18.3",
+        "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",
+        "uglify-js": "^3.19.3",
+        "web-push": "^3.6.7",
+        "winston": "^3.13.0",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "jest": "^29.7.0"
+    },
+    "jest": {
+        "transform": {},
+        "testMatch": [
+            "<rootDir>/tests/**",
+            "!<rootDir>/tests/mockData",
+            "!<rootDir>/tests/mockData/**"
+        ],
+        "testPathIgnorePatterns": [
+            "<rootDir>/node_modules",
+            "<rootDir>/tests/mockData"
+        ],
+        "watchPathIgnorePatterns": [
+            "<rootDir>/node_modules",
+            "<rootDir>/tests/mockData"
+        ],
+        "coveragePathIgnorePatterns": [
+            "<rootDir>/node_modules",
+            "<rootDir>/tests/mockData",
+            "<rootDir>/tests/mockData/**"
+        ]
+    }
+}

package/tests/app.test.js

@@ -96,7 +96,7 @@ describe('Biz-A Apps CLI', () => {
         })
 
         const stressTestCount = 10;
-        it.each(Array(stressTestCount).fill().map((v, i) => i + 1))(`shall compress and encrypt app scripts (stress test %p of ${stressTestCount})`, async (testNo) => {
+        it.each(Array(stressTestCount).fill().map((v, i) => i + 1))(`shall compress and encrypt app scripts (stress test %p of ${stressTestCount})`, async (testNo) => {
             const mockScripts = {
                 'a.js': {
                     act: 'get = function () {return {modelA: {}}}',
@@ -252,13 +252,130 @@ describe('Biz-A Apps CLI', () => {
             expect(logSpy.mock.calls[JEST_MESSAGE_TOTAL + 0][0]).toContain(`Finished packing ${Object.keys(mockScripts).length} files into "./upload/${appName.toLowerCase()}.tgz"`)
             expect(logSpy.mock.calls[JEST_MESSAGE_TOTAL + 1][0]).toContain(`Finished uploading "./upload/${appName.toLocaleLowerCase()}.tgz"`)
 
-            // fs.rmSync(mockDataFolder + '/' + appName, {recursive: true, force: true})
-        })
-
-        /*        it('Invalid script syntax', async ()=>{
-                    mockValidTemplates({
-                        'a.js' : {act: 'get = function () {return {modelA: {}}'} // missing close closure at the end
-                    })
+            // fs.rmSync(mockDataFolder + '/' + appName, {recursive: true, force: true})
+        })
+
+        it('shall support addApp body scripts when called from other function', async () => {
+            const appName = 'bodyScriptSourceApp'
+            const workingDir = mockDataFolder + '/' + appName
+            const mockAESKey = Buffer.from('hAnHadaJXJaq/9fCFMNmjkrB61CBPXJid6vbtXgG8Ug=', 'base64')
+            const expectedScript = '{"fromBody":{"id":1}}'
+
+            mockValidTemplates(appName, {})
+            mockIssuerKeyResponse()
+            process.env.BIZA_APP_SKIP_PARSE = '1'
+
+            try {
+                process.argv[1] = process.cwd() + '\\bin'
+                const { addApp } = await import('../bin/app.js')
+
+                const result = await addApp({
+                    workingDir,
+                    verbose: false,
+                    server: 'https://a.b.c',
+                    apiPort: 1205,
+                    dbIndex: 2,
+                    files: [{ name: 'a.js' }],
+                    body: {
+                        scripts: {
+                            'a.js': 'get = function () { return {fromBody: {id: 1}} }'
+                        }
+                    }
+                })
+
+                expect(result.success).toBe(true)
+                expect(axios.post).toHaveBeenCalledTimes(1)
+
+                const apiParams = axios.post.mock.calls[0][1]._parameters
+                const templateBuffer = Buffer.from(apiParams[2], 'base64')
+                const decryptScripts = {}
+                const stream = new Duplex()
+                stream.push(templateBuffer)
+                stream.push(null)
+                stream.pipe(
+                    tar.t({
+                        strict: true,
+                        sync: true,
+                        onReadEntry: entry => {
+                            const chunks = []
+                            entry.on('data', chunk => chunks.push(chunk))
+                            entry.on('end', () => {
+                                const cipherText = Buffer.from(Buffer.concat(chunks).toString(), 'base64')
+                                const decryptInitializeVector = cipherText.subarray(0, 16)
+                                const decryptData = cipherText.subarray(16)
+                                const decipher = createDecipheriv('aes-256-cbc', mockAESKey, decryptInitializeVector)
+                                const decrypted = Buffer.concat([decipher.update(decryptData), decipher.final()])
+                                decryptScripts[entry.path] = decrypted.toString()
+                            })
+                        }
+                    })
+                        .on('finish', () => stream.end())
+                )
+                await finished(stream)
+
+                expect(decryptScripts['a.js']).toBe(expectedScript)
+            } finally {
+                delete process.env.BIZA_APP_SKIP_PARSE
+            }
+        })
+
+        it('shall resolve app name from SYS$CONFIG APPLICATION_CONFIG and use it for upload', async () => {
+            const appName = 'metadataNameSourceApp'
+            const workingDir = mockDataFolder + '/' + appName
+
+            mockValidTemplates(appName, {})
+            mockIssuerKeyResponse()
+            axios.request = jest.fn().mockResolvedValue({
+                data: {
+                    data: JSON.stringify([
+                        {
+                            'SYS$CONFIG.NAME': 'APPLICATION_CONFIG',
+                            'SYS$CONFIG.DATA': JSON.stringify({
+                                metadata: {
+                                    name: 'BizA Sales App'
+                                }
+                            })
+                        }
+                    ])
+                }
+            })
+            process.env.BIZA_APP_SKIP_PARSE = '1'
+
+            try {
+                process.argv[1] = process.cwd() + '\\bin'
+                const { addApp } = await import('../bin/app.js')
+
+                const result = await addApp({
+                    workingDir,
+                    verbose: false,
+                    server: 'https://a.b.c',
+                    apiPort: 1205,
+                    dbIndex: 2,
+                    files: [{ name: 'applicationConfig.js' }],
+                    sub: 'metadata-sub',
+                    body: {
+                        scripts: {
+                            'applicationConfig.js': 'get = function () { return { metadata: { name: "Name From Body Must Be Ignored" } }; }'
+                        }
+                    }
+                })
+
+                expect(result.success).toBe(true)
+                expect(axios.post).toHaveBeenCalledTimes(1)
+                expect(axios.request).toHaveBeenCalledTimes(1)
+
+                const apiParams = axios.post.mock.calls[0][1]._parameters
+                expect(apiParams[1]).toBe('bizasalesapp')
+                expect(apiParams[3]).toHaveProperty('name', 'BizA Sales App')
+            } finally {
+                delete process.env.BIZA_APP_SKIP_PARSE
+            }
+        })
+
+        /*        it('Invalid script syntax', async ()=>{
+                    mockValidTemplates({
+                        'a.js' : {act: 'get = function () {return {modelA: {}}'} // missing close closure at the end
+                    })
                     mockIssuerKeyResponse()
                     await runCommand('add', '-s', 'https://a.b.c', '-p', '1205', '-i', '2', '-d', appFolderName, "-v")
         

package/tests/hubPublish.test.js

@@ -0,0 +1,220 @@
+import { Server as ioServer } from 'socket.io';
+import { createServer } from 'node:http';
+import { io as ioClient } from 'socket.io-client';
+import { jest } from '@jest/globals';
+
+const mockAddApp = jest.fn().mockResolvedValue({ success: true, data: { uploaded: true } });
+jest.unstable_mockModule('../bin/app.js', () => ({
+    addApp: mockAddApp
+}));
+
+const { streamEvent } = await import('../bin/hubEvent.js');
+
+let socketsBySubdomain = {};
+
+const createSockTunnel2CLI = (socket) => {
+    return (subdomain, responseCb) => {
+        const responseCallback = (error) => { if (responseCb) responseCb(error) }
+        let subdomainStr = subdomain.toString();
+
+        socketsBySubdomain[subdomainStr] = socket;
+        socket.subdomain = subdomainStr;
+
+        responseCallback(null);
+    }
+}
+
+const deleteSubdomain = (socket) => () => {
+    if (socket.subdomain) {
+        delete socketsBySubdomain[socket.subdomain];
+    }
+}
+
+const toPromise = (cb) => new Promise((resolve, reject) => {
+    cb(resolve)
+    setTimeout(() => reject(new Error('timeout')), 1000)
+})
+
+describe('Hub publish request tests', () => {
+    let bizAServerSocket, httpServer, port;
+
+    beforeAll((done) => {
+        httpServer = createServer();
+        bizAServerSocket = new ioServer(httpServer);
+        bizAServerSocket.on('connection', (socket) => {
+            socket.on('createTunnel', createSockTunnel2CLI(socket));
+            socket.on('disconnect', deleteSubdomain(socket));
+        });
+        httpServer.listen(() => {
+            port = httpServer.address().port;
+            done();
+        });
+    });
+
+    beforeEach(() => {
+        mockAddApp.mockClear();
+        delete process.env.BIZA_APP_SKIP_PARSE;
+    });
+
+    afterAll(() => {
+        bizAServerSocket.close();
+        httpServer.close();
+    });
+
+    test('publish-req should execute addApp and pass body scripts', async () => {
+        const subdomain = 'publish-room';
+        const socket = ioClient(`http://localhost:${port}`);
+        await streamEvent(socket, {
+            server: `http://localhost:${port}`,
+            subdomain,
+            hostname: 'localhost',
+            port: 212,
+            serverport: 3002,
+            dbindex: 7
+        });
+
+        const publishBody = {
+            options: {
+                workingDir: 'c:/tmp/app',
+                verbose: true,
+                server: 'https://srv',
+                apiPort: '1205',
+                dbIndex: '2',
+                sub: 'unit-sub',
+                files: [{ name: 'a.js' }]
+            },
+            scripts: {
+                'a.js': 'get = function () { return {unit: true} }'
+            }
+        };
+
+        const response = await toPromise(resolve => socketsBySubdomain[subdomain].emit(
+            'publish-req',
+            {
+                path: '/publish',
+                method: 'POST',
+                query: { subdomain },
+                body: publishBody,
+                headers: { 'content-type': 'application/json' }
+            },
+            (cb) => resolve(cb)
+        ));
+
+        expect(mockAddApp).toHaveBeenCalledTimes(1);
+        expect(mockAddApp).toHaveBeenCalledWith({
+            workingDir: 'c:/tmp/app',
+            verbose: true,
+            server: 'https://srv',
+            apiPort: 1205,
+            dbIndex: 2,
+            sub: 'unit-sub',
+            files: [{ name: 'a.js' }],
+            body: publishBody
+        });
+        expect(response).toStrictEqual({ success: true, data: { uploaded: true } });
+        expect(process.env.BIZA_APP_SKIP_PARSE).toBeUndefined();
+
+        socket.disconnect();
+    });
+
+    test('publish-req should treat data.body as direct addApp http payload', async () => {
+        const subdomain = 'publish-room-http';
+        const socket = ioClient(`http://localhost:${port}`);
+        await streamEvent(socket, {
+            server: `http://localhost:${port}`,
+            subdomain,
+            hostname: 'localhost',
+            port: 212,
+            serverport: 3002,
+            dbindex: 7
+        });
+
+        const publishBody = {
+            verbose: false,
+            fileList: [{ name: 'a.js' }],
+            scripts: {
+                'a.js': 'get = function () { return {direct: true} }'
+            }
+        };
+
+        const response = await toPromise(resolve => socketsBySubdomain[subdomain].emit(
+            'publish-req',
+            {
+                path: '/publish',
+                method: 'POST',
+                query: { subdomain },
+                body: publishBody,
+                headers: { 'content-type': 'application/json' }
+            },
+            (cb) => resolve(cb)
+        ));
+
+        expect(mockAddApp).toHaveBeenCalledTimes(1);
+        expect(mockAddApp).toHaveBeenCalledWith({
+            workingDir: expect.any(String),
+            verbose: false,
+            server: `http://localhost:${port}`,
+            apiPort: 212,
+            dbIndex: 7,
+            sub: subdomain,
+            files: [{ name: 'a.js' }],
+            body: publishBody
+        });
+        expect(response).toStrictEqual({ success: true, data: { uploaded: true } });
+        expect(process.env.BIZA_APP_SKIP_PARSE).toBeUndefined();
+
+        socket.disconnect();
+    });
+
+    test('publish-req should support double-wrapper payload from HTTP client', async () => {
+        const subdomain = 'publish-room-double-wrapper';
+        const socket = ioClient(`http://localhost:${port}`);
+        await streamEvent(socket, {
+            server: `http://localhost:${port}`,
+            subdomain,
+            hostname: 'localhost',
+            port: 212,
+            serverport: 3002,
+            dbindex: 7
+        });
+
+        const publishBody = {
+            fileList: [{ name: 'menu.json' }, { name: 'loginform.js' }],
+            scripts: {
+                'menu.json': '[{"menuName":"","caption":"Home","link":["./main"],"subMenu":[]}]',
+                'loginform.js': 'get = function () { return {model:{}, tableName:"", fields:[], functions:{ beforeLoadData: function (id) {} }}; };'
+            }
+        };
+
+        const response = await toPromise(resolve => socketsBySubdomain[subdomain].emit(
+            'publish-req',
+            {
+                path: '/publish',
+                method: 'POST',
+                query: { subdomain },
+                headers: { 'content-type': 'application/json' },
+                body: {
+                    method: 'POST',
+                    query: { subdomain },
+                    body: publishBody
+                }
+            },
+            (cb) => resolve(cb)
+        ));
+
+        expect(mockAddApp).toHaveBeenCalledTimes(1);
+        expect(mockAddApp).toHaveBeenCalledWith({
+            workingDir: expect.any(String),
+            verbose: false,
+            server: `http://localhost:${port}`,
+            apiPort: 212,
+            dbIndex: 7,
+            sub: subdomain,
+            files: [{ name: 'menu.json' }, { name: 'loginform.js' }],
+            body: publishBody
+        });
+        expect(response).toStrictEqual({ success: true, data: { uploaded: true } });
+
+        socket.disconnect();
+    });
+});