biz-a-cli 2.3.32 → 2.3.34

package/mailController.js

@@ -6,19 +6,12 @@ function createEmailTransport(req, config) {
     );
 }
 
-export function sendMailWatcher(req) {
+export async function sendMailWatcher(req) {
     try {
-        let config = req.body.config;
-        const transporter = createEmailTransport(req, config);
-        transporter.sendMail(req.body.mailOptions, (err, info) => {
-            if (err) {
-                console.log(err.message);
-                return err.message;
-            } else {
-                console.log('Info:' + info);
-                return info;
-            }
-        })
+        const transporter = createEmailTransport(req, req.body.config);
+        const sendResult = await transporter.sendMail(req.body.mailOptions);
+
+        return sendResult;
     } catch (err) {
         console.log('Error: ' + err.message);
         return err.message;

package/package.json

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

package/scheduler/datalib.js

@@ -36,29 +36,26 @@ if (process.env.NODE_ENV !== 'production') {
 //     BIZA_SERVER_LINK = env.BIZA_SERVER_LINK;
 // };
 
-function mapData2Key(res, cols) {
+export function mapData2Key(res, cols) {
     return res.map(e => {
         return cols.reduce((o, k) => {
+            // o[k.key ?? k.data] = e[k.data]
             o[k.key ? k.key : k.data] = e[k.data]
             return o;
         }, {})
     })
 }
 
-function getUrlApi(config, methodName, isPost = true) {
+export function getUrlApi(config, methodName, isPost = true) {
     return `${config.url}/fina/rest/TOrmMethod/` +
         `${isPost ? '%22' : ''}${methodName}${isPost ? '%22' : ''}`
 }
 
-function json2Parameters(obj) {
-    return JSON.stringify(
-        {
-            _parameters: obj.map((el) => JSON.stringify(el))
-        }
-    );
+export function json2Parameters(obj) {
+    return JSON.stringify({ _parameters: obj.map((el) => JSON.stringify(el)) });
 }
 
-function getUrlAndParam(config, method, obj, path) {
+export function getUrlAndParam(config, method, obj, path) {
     return {
         url: getUrlApi(config, path),
         params: json2Parameters([
@@ -71,12 +68,38 @@ function getUrlAndParam(config, method, obj, path) {
     }
 }
 
-function getTableObj(model, tableName) {
+export function getTableObj(model, tableName) {
     let obj = {};
     obj[tableName] = model;
     return obj;
 }
 
+export function options(apiConfig) {
+    return {
+        headers: { 'content-type': 'text/plain' },
+        params: { subdomain: apiConfig.subdomain }
+    };
+}
+
+export async function json2fina(obj, apiConfig, raiseError = false) {
+    const url = getUrlApi(
+        {
+            url: apiConfig.url,
+            dbIndex: obj.dbIndex,
+            methodClass: 'TFinaMethod'
+        },
+        'json2fina'
+    );
+
+    const params = json2Parameters([obj]);
+    const res = await axios.post(url, params, options(apiConfig));
+
+    if (res.data?.error && raiseError) {
+        throw new Error(res.data.error);
+    }
+    return res;
+}
+
 export function sendModel(model, apiConfig, tableName) {
     const { url, params } = getUrlAndParam(
         apiConfig,
@@ -85,12 +108,7 @@ export function sendModel(model, apiConfig, tableName) {
         'orm'
     );
 
-    const options = {
-        headers: { 'content-type': 'text/plain' },
-        params: { subdomain: apiConfig.subdomain }
-    }
-
-    return axios.post(url, params, options)
+    return axios.post(url, params, options(apiConfig))
 }
 
 export async function queryData(param, apiConfig, mapField) {
@@ -105,12 +123,7 @@ export async function queryData(param, apiConfig, mapField) {
         'list'
     );
 
-    const options = {
-        headers: { 'content-type': 'text/plain' },
-        params: { subdomain: apiConfig.subdomain }
-    }
-
-    let res = await axios.post(url, params, options);
+    let res = await axios.post(url, params, options(apiConfig));
     res = res.data?.data ? JSON.parse(res.data.data) : res.data;
     return (!mapField || res.error) ? res : mapData2Key(res, param.columns);
 }
@@ -123,65 +136,80 @@ export async function crudData(param, apiConfig, method, path) {
         path
     );
 
-    const options = {
-        headers: { 'content-type': 'text/plain' },
-        params: { subdomain: apiConfig.subdomain }
-    }
-
-    const res = await axios.post(url, params, options);
+    const res = await axios.post(url, params, options(apiConfig));
     return res.data?.data ? JSON.parse(res.data.data) : res.data;
 }
 
 export async function genId(apiConfig, genName) {
     const url = `${getUrlApi(apiConfig, 'genId', false)}/${genName}/${apiConfig.dbindex}`;
-    const options = {
-        headers: { 'content-type': 'text/plain' },
-        params: { subdomain: apiConfig.subdomain }
-    }
-    const res = await axios.get(url, options);
+
+    const res = await axios.get(url, options(apiConfig));
     return res.data?.data ? JSON.parse(res.data.data) : res.data;
 }
 
-export function extractFunctionScript(data) {
+function runScriptInThisContext(script) {
+    return runInThisContext(script, { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });
+}
+
+export async function setLibrary(config, libraries) {
+    let libs = {};
+    for (const lib of libraries) {
+        const data = await loadCliScript(config, 'SCRIPT_NAME', lib);
+        const libFn = runScriptInThisContext(data[0].script);
+        Object.assign(libs, { lib: libFn().functions });
+    }
+
+    return libs;
+}
+
+export async function extractFunctionScript(selectedConfig, data) {
+    const config = getConfig(selectedConfig);
+
     if (data.error) {
         console.log(data.error, 'error')
         return
     }
     if (data.length == 0) return
 
-    const scriptFn = runInThisContext(data[0].script, { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });
+    const scriptFn = runScriptInThisContext(data[0].script);
     if (!scriptFn().functions) return
+
     let lib = {
         axios: axios.default,
         dayjs: dayjs.default,
         crypto: crypto,
-        log: logger,
+        log: logger
+    }
+
+    if (scriptFn().functions.useLibrary) {
+        Object.assign(lib, await setLibrary(config, scriptFn().functions.useLibrary()));
     }
     return scriptFn(lib).functions;
 }
 
-export function getQueryDataObsParameters(trigger) {
+export function getQueryDataPrmsParameters(column, value) {
     return {
         length: 1,
-        filter: [{ junction: '', column: 'ID', operator: '=', value1: `${trigger.scriptid}` }],
+        filter: [{ junction: '', column: column, operator: '=', value1: `'${value}'` }],
         columns: [{ data: "SYS$CLI_SCRIPT.SCRIPT", key: 'script' }]
     }
 }
 
-export function queryDataPromise(config, trigger) {
-    let param = getQueryDataObsParameters(trigger);
+export async function queryDataPromise(config, column, value) {
+    let param = getQueryDataPrmsParameters(column, value);
+    // let param = getQueryDataPrmsParameters(d);
 
-    return queryData(param, config, true);
+    return await queryData(param, config, true);
 }
 
 export function getConfig(config) {
     return (Array.isArray(config)) ? config[0] : config;
 }
 
-export function loadCliScript(selectedConfig, trigger) {
+export async function loadCliScript(selectedConfig, column, value) {
     const config = getConfig(selectedConfig);
 
-    return queryDataPromise(config, trigger);
+    return await queryDataPromise(config, column, value);
 }
 
 export function getInputData(config, trigger) {
@@ -195,7 +223,7 @@ export function getInputData(config, trigger) {
             subdomain: config.subdomain,
             smtp: {
                 user: config.smtp.auth.user,
-                pass:config.smtp.auth.pass,
+                pass: config.smtp.auth.pass,
                 host: config.smtp.host,
                 port: config.smtp.port,
                 secure: config.smtp.secure
@@ -207,7 +235,8 @@ export function getInputData(config, trigger) {
 
 export async function scheduleSubscription(config, data, trigger, needSetHistory, isTest = false) {
     try {
-        let functions = extractFunctionScript(data);
+        let functions = extractFunctionScript(config, data);
+
         if (functions) {
             if (!isTest) {  // next, change isTest to test better
                 functions.onInit(getInputData(config, trigger));
@@ -230,7 +259,7 @@ export async function scheduleSubscription(config, data, trigger, needSetHistory
 
 export async function checkSchedule(selectedConfig, trigger, needSetHistory) {
     try {
-        const data = await loadCliScript(selectedConfig, trigger);
+        const data = await loadCliScript(selectedConfig, 'ID', trigger.scriptid);
         await scheduleSubscription(selectedConfig, data, trigger, needSetHistory);
     } catch (error) {
         console.error(error);

package/tests/app.test.js

@@ -294,7 +294,7 @@ 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]).toBe('a.js : SyntaxError: Unexpected token: eof, expected: punc «}»')
+                    expect(errorSpy.mock.calls[0][0]).toStrictEqual({e: 'a.js:1:38: SyntaxError: Unexpected token: eof, expected: punc «}»'})
                 }
             ],
             [
@@ -305,11 +305,11 @@ describe('Biz-A Apps CLI', ()=>{
                     expect(logSpy.mock.calls[0][0]).toBe('===================\nA.JS\n===================')
                     expect(logSpy.mock.calls[1][0]).toBe('Minify : \nget=function(){return{modelA:{}}};modul.expor=get;')
                     expect(logSpy.mock.calls[2][0]).toBe('Running script with VM') // node sandbox (VN) error as console.log
-                    expect(logSpy.mock.calls[3][0]).toBe('a.js : ReferenceError: modul is not defined')
+                    expect(logSpy.mock.calls[3][0]).toBe("a.js : ReferenceError: modul is not defined")
                     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]).toBe("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
                 }
             ],
             [
@@ -323,7 +323,7 @@ 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]).toBe('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'})
                 }
             ],
         ]

package/tests/data.test.js

@@ -2,14 +2,27 @@ import { jest } from '@jest/globals'
 
 const mockInsertHistory = jest.fn();
 jest.unstable_mockModule("../scheduler/watcherController.js", () => ({
-    insertHistory: mockInsertHistory.mockResolvedValue('OK')
+    insertHistory: mockInsertHistory.mockResolvedValue('OK'),
 }))
 
+jest.unstable_mockModule('axios', () => { return { default: jest.fn() } })
+let axios = (await import('axios')).default
+
+axios.get = jest.fn()
+axios.post = jest.fn()
+
 const {
     scheduleSubscription,
     getConfig,
     getInputData,
-    getQueryDataObsParameters,
+    getQueryDataPrmsParameters,
+    mapData2Key,
+    getUrlApi,
+    json2Parameters,
+    getUrlAndParam,
+    getTableObj,
+    options,
+    setLibrary
 } = await import('../scheduler/datalib.js');
 
 describe('data test', () => {
@@ -135,16 +148,201 @@ describe('data test', () => {
     });
 
     test('get query data parameter', () => {
-        const trigger = {
-            scriptid: 12
-        }
-
-        expect(getQueryDataObsParameters(trigger)).toStrictEqual({
+        expect(getQueryDataPrmsParameters('ID', 12)).toStrictEqual({
             length: 1,
-            filter: [{ junction: '', column: 'ID', operator: '=', value1: '12' }],
+            filter: [{ junction: '', column: 'ID', operator: '=', value1: "'12'" }],
             columns: [{ data: "SYS$CLI_SCRIPT.SCRIPT", key: 'script' }]
         });
     });
 
+    test('should map data correctly when key is provided', () => {
+        const res = [
+            { id: 1, name: 'Alice' },
+            { id: 2, name: 'Bob' },
+        ];
+        const cols = [
+            { key: 'identifier', data: 'id' },
+            { key: 'fullName', data: 'name' },
+        ];
+
+        const result = mapData2Key(res, cols);
+        expect(result).toEqual([
+            { identifier: 1, fullName: 'Alice' },
+            { identifier: 2, fullName: 'Bob' },
+        ]);
+    });
+
+    test('should map data correctly when key is not provided', () => {
+        const res = [
+            { id: 1, name: 'Alice' },
+            { id: 2, name: 'Bob' },
+        ];
+        const cols = [
+            { data: 'id' },
+            { data: 'name' },
+        ];
+
+        const result = mapData2Key(res, cols);
+        expect(result).toEqual([
+            { id: 1, name: 'Alice' },
+            { id: 2, name: 'Bob' },
+        ]);
+    });
+
+    test('should handle an empty result set', () => {
+        const res = [];
+        const cols = [
+            { key: 'identifier', data: 'id' },
+            { key: 'fullName', data: 'name' },
+        ];
+
+        const result = mapData2Key(res, cols);
+        expect(result).toEqual([]);
+    });
+
+    test('should handle an empty column set', () => {
+        const res = [
+            { id: 1, name: 'Alice' },
+            { id: 2, name: 'Bob' },
+        ];
+        const cols = [];
+
+        const result = mapData2Key(res, cols);
+        expect(result).toEqual([{}, {}]);
+    });
+
+    test('should handle null and undefined values in the data', () => {
+        const res = [
+            { id: 1, name: null },
+            { id: null, name: 'Bob' },
+        ];
+        const cols = [
+            { key: 'identifier', data: 'id' },
+            { key: 'fullName', data: 'name' },
+        ];
+
+        const result = mapData2Key(res, cols);
+        expect(result).toEqual([
+            { identifier: 1, fullName: null },
+            { identifier: null, fullName: 'Bob' },
+        ]);
+    });
+
+    test('should return the correct URL for POST requests', () => {
+        const config = { url: 'http://example.com' };
+        const methodName = 'testMethod';
+        const isPost = true;
+        const expectedUrl = 'http://example.com/fina/rest/TOrmMethod/%22testMethod%22';
+
+        expect(getUrlApi(config, methodName, isPost)).toBe(expectedUrl);
+    });
+
+    test('should return the correct URL for GET requests', () => {
+        const config = { url: 'http://example.com' };
+        const methodName = 'testMethod';
+        const isPost = false;
+        const expectedUrl = 'http://example.com/fina/rest/TOrmMethod/testMethod';
+
+        expect(getUrlApi(config, methodName, isPost)).toBe(expectedUrl);
+    });
+
+    test('should convert an array of objects to a JSON string with a _parameters key', () => {
+        const input = [{ a: 1 }, { b: 2 }];
+        const expectedOutput = JSON.stringify({ _parameters: [JSON.stringify({ a: 1 }), JSON.stringify({ b: 2 })] });
+
+        expect(json2Parameters(input)).toBe(expectedOutput);
+    });
+
+    test('should handle an empty array', () => {
+        const input = [];
+        const expectedOutput = JSON.stringify({ _parameters: [] });
+
+        expect(json2Parameters(input)).toBe(expectedOutput);
+    });
+
+    test('should return correct url and params', () => {
+        const config = {
+            url: 'https://example.com',
+            dbindex: '1'
+        };
+        const method = 'POST';
+        const obj = { id: 1 };
+        const path = 'testMethod';
+        const result = getUrlAndParam(config, method, obj, path);
+
+        expect(result).toEqual({
+            url: 'https://example.com/fina/rest/TOrmMethod/%22testMethod%22',
+            params: "{\"_parameters\":[\"{\\\"dbIndex\\\":\\\"1\\\",\\\"method\\\":\\\"POST\\\",\\\"object\\\":{\\\"id\\\":1}}\"]}"
+        });
+    });
+
+    test('should get table object', () => {
+        const model = { id: 1, name: 'testModel' };
+        const tableName = 'testTable';
+
+        const result = getTableObj(model, tableName);
+
+        let expected = {};
+        expected[tableName] = model;
+        expect(result).toEqual(expected);
+    });
+
+    test('should return the correct headers and params', () => {
+        const apiConfig = { subdomain: 'example' };
+        const expectedResult = {
+            headers: { 'content-type': 'text/plain' },
+            params: { subdomain: 'example' }
+        };
+
+        const result = options(apiConfig);
+        expect(result).toEqual(expectedResult);
+    });
+
+    test('should handle missing subdomain in apiConfig', () => {
+        const apiConfig = {};
+        const expectedResult = {
+            headers: { 'content-type': 'text/plain' },
+            params: { subdomain: undefined }
+        };
+
+        const result = options(apiConfig);
+        expect(result).toEqual(expectedResult);
+    });
+
+    test('should set library if any', async () => {
+        axios.post.mockResolvedValueOnce(axios.post.mockResolvedValueOnce({
+            data: [
+                {
+                    'SYS$CLI_SCRIPT.SCRIPT': 'get = function () {\n' +
+                        '    return {\n' +
+                        '        functions: {\n' +
+                        '            yyy: function (data) {\n' +
+                        '                function doit() {\n' +
+                        '                    return {\n' +
+                        "                        abc: function () { return 'abc'; console.log('abc') },\n" +
+                        '                    }\n' +
+                        '                }\n' +
+                        '                return doit()\n' +
+                        '            },\n' +
+                        '            zzz: function () {\n' +
+                        "                return 'aaabbbccc';\n" +
+                        '            }\n' +
+                        '        }\n' +
+                        '    }\n' +
+                        '}'
+                }
+            ]
+        }))
+
+        const config = {};
+        const libraries = ['lib'];
+
+        const result = await setLibrary(config, libraries);
+
+        expect(result.lib.yyy().abc()).toStrictEqual('abc');
+        expect(result.lib.zzz()).toStrictEqual('aaabbbccc');
+    });
+
+
 })
 

package/tests/mailCtl.test.js

@@ -1,7 +1,7 @@
 
 import { jest } from '@jest/globals'
 
-const mockSendMail = jest.fn();
+let mockSendMail = jest.fn();
 const mockCreateTransport = jest.fn();
 mockCreateTransport.mockImplementation(() => ({
     sendMail: mockSendMail
@@ -16,7 +16,7 @@ const { sendMailWatcher } = await import('../mailController.js');
 describe('Mail Controller', () => {
     let req;
 
-    test('transporter.sendmailWatcher is called', () => {
+    test('transporter.sendmailWatcher is called', async () => {
         req = {
             body: {
                 companyname: 'abc',
@@ -26,9 +26,14 @@ describe('Mail Controller', () => {
             },
         }
 
-        sendMailWatcher(req);
+        mockSendMail.mockResolvedValue('OK');
+        expect(await sendMailWatcher(req)).toEqual('OK');
         expect(mockSendMail).toBeCalledTimes(1);
         expect(mockCreateTransport).toHaveBeenCalledWith({ smtp: 'test' });
 
+        mockSendMail.mockRejectedValue({ message: 'error' });
+        expect(await sendMailWatcher(req)).toEqual('error');
+
+        expect(mockSendMail).toBeCalledTimes(2);
     })
 })

package/tests/mockData/mockApp/a.js

@@ -0,0 +1 @@
+get = function () {return {modelA: {}}}

package/tests/mockData/mockApp/b.js

@@ -0,0 +1,2 @@
+const get = function () {
+return {"modelB": {id: null}}};

package/tests/mockData/mockApp/c.js

@@ -0,0 +1,4 @@
+let get = function () {return {modelC: {}, function: {func: () => { 
+return ["lib"];
+}
+}}};

package/tests/mockData/mockApp/d.js

@@ -0,0 +1,2 @@
+var get = function () {return {model: {}, tableName: "", fields: [], function: {}}};
+module.exports = get;

package/tests/mockData/mockApp/menu.json

@@ -0,0 +1,49 @@
+[
+                        {"menuName": "", "caption": "Home", "link": ["./main"],"subMenu": []},
+                        {"menuName": "", "caption": "Personalia","link": [], "subMenu": [
+                            {"menuName": "","caption": "Data Master","link": [], "subMenu": []},
+                            {
+                                "menuName": "",
+                                "caption": "Gaji",
+                                "link": [],
+                                "subMenu": [
+                                    {
+                                        "menuName": "",
+                                        "caption": "Parameter",
+                                        "link": [
+                                            "./form",
+                                            "gajiparam",
+                                            null
+                                        ],
+                                        "subMenu": []
+                                    },
+                                    {
+                                        "menuName": "",
+                                        "caption": "Perubahan",
+                                        "link": [],
+                                        "subMenu": [
+                                            {
+                                                "menuName": "",
+                                                "caption": "Form Perubahan Gaji",
+                                                "link": [
+                                                    "./form",
+                                                    "gajiubah",
+                                                    null
+                                                ],
+                                                "subMenu": []
+                                            },
+                                            {
+                                                "menuName": "",
+                                                "caption": "Daftar Perubahan Gaji",
+                                                "link": [
+                                                    "./list",
+                                                    "gajiubahdaftar"
+                                                ],
+                                                "subMenu": []
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]}
+                    ]