hola-server 1.0.10 → 2.0.1

package/core/bash.js

@@ -1,345 +1,294 @@
+/**
+ * @fileoverview Bash command execution and SSH utility functions.
+ * @module core/bash
+ */
+
 const fs = require('fs');
 const { exec } = require("child_process");
 const { random_code } = require('./random');
 const { is_log_debug, is_log_error, log_debug, log_error } = require('../db/db');
 
 const LOG_BASH = "bash";
-
-const get_log_file = async () => {
-    const home = await run_simple_local_cmd("echo ~");
-    const log_dir = `${home}/.hola/ssh`;
-    await run_local_cmd(`mkdir -p ${log_dir}`);
-    return `${log_dir}/l_${random_code()}.log`;
-}
+const SSH_OPTIONS = "-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no";
 
 /**
- * Run script and get stdout
- * @param {host info,contains user,ip and password} host
- * @param {commands to run} script
- * @returns 
+ * Execute command with unified logging and error handling.
+ * @param {string} cmd - Command to execute.
+ * @param {Object} options - Exec options.
+ * @param {string} error_msg - Error message prefix.
+ * @param {string} success_msg - Success message prefix.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
  */
-const run_script = async (host, script, log_extra) => {
+const exec_with_logging = (cmd, options, error_msg, success_msg, log_extra) => {
     return new Promise((resolve) => {
-        exec(`ssh ${host.auth} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p ${host.port} ${host.user}@${host.ip} /bin/bash <<'EOT'\n ${script} \nEOT\n`, { maxBuffer: 1024 * 150000 }, (error, stdout) => {
+        exec(cmd, options, (error, stdout) => {
             if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error running on host:" + host.name + " the script:" + script + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error running the script:" + script + ",error:" + error });
+                if (is_log_error()) log_error(LOG_BASH, `${error_msg}, error:${error}`, log_extra);
+                resolve({ stdout, err: `${error_msg}, error:${error}` });
             } else {
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing on host:" + host.name + ", script:" + script + ",stdout:" + stdout, log_extra);
-                }
-                resolve({ stdout: stdout });
+                if (is_log_debug()) log_debug(LOG_BASH, `${success_msg}, stdout:${stdout}`, log_extra);
+                resolve({ stdout });
             }
         });
     });
 };
 
 /**
- * Run script and get stdout and this use file redirect to avoid progress bar issue
- * @param {host info,contains user,ip and password} host
- * @param {commands to run} script
- * @returns 
+ * Get temporary log file path.
+ * @returns {Promise<string>} Path to temporary log file.
+ */
+const get_log_file = async () => {
+    const home = await run_simple_local_cmd("echo ~");
+    const log_dir = `${home}/.hola/ssh`;
+    await run_local_cmd(`mkdir -p ${log_dir}`);
+    return `${log_dir}/l_${random_code()}.log`;
+};
+
+/**
+ * Build SSH command prefix.
+ * @param {Object} host - Host configuration.
+ * @returns {string} SSH command prefix.
+ */
+const build_ssh_prefix = (host) => `ssh ${host.auth} ${SSH_OPTIONS} -p ${host.port} ${host.user}@${host.ip}`;
+
+/**
+ * Build SCP command.
+ * @param {Object} host - Host configuration.
+ * @param {string} src - Source path.
+ * @param {string} dest - Destination path.
+ * @param {boolean} to_remote - True if copying to remote.
+ * @returns {string} SCP command.
+ */
+const build_scp_cmd = (host, src, dest, to_remote) => {
+    const remote_path = `${host.user}@${host.ip}:${to_remote ? dest : src}`;
+    const local_path = to_remote ? src : dest;
+    const [first, second] = to_remote ? [local_path, remote_path] : [remote_path, local_path];
+    return `scp ${host.auth} ${SSH_OPTIONS} -P ${host.port} -q ${first} ${second}`;
+};
+
+/**
+ * Run script on remote host via SSH.
+ * @param {Object} host - Host info with user, ip, port, auth, name.
+ * @param {string} script - Commands to run.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
+ */
+const run_script = (host, script, log_extra) => {
+    const cmd = `${build_ssh_prefix(host)} /bin/bash <<'EOT'\n ${script} \nEOT\n`;
+    return exec_with_logging(cmd, { maxBuffer: 1024 * 150000 },
+        `error running on host:${host.name} script:${script}`,
+        `executing on host:${host.name}, script:${script}`, log_extra);
+};
+
+/**
+ * Run script on remote host with file redirect to avoid progress bar issues.
+ * @param {Object} host - Host info with user, ip, port, auth, name.
+ * @param {string} script - Commands to run.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
  */
 const run_script_extra = async (host, script, log_extra) => {
     const log_file = await get_log_file();
+    const cmd = `${build_ssh_prefix(host)} /bin/bash <<'EOT' > ${log_file} \n ${script} \nEOT\n`;
 
     return new Promise((resolve) => {
-        exec(`ssh ${host.auth} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p ${host.port} ${host.user}@${host.ip} /bin/bash <<'EOT' > ${log_file} \n ${script} \nEOT\n`, { maxBuffer: 1024 * 150000 }, (error, stdout) => {
+        exec(cmd, { maxBuffer: 1024 * 150000 }, (error, stdout) => {
             if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error running on host:" + host.name + " the script:" + script + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error running the script:" + script + ",error:" + error });
+                if (is_log_error()) log_error(LOG_BASH, `error running on host:${host.name} script:${script}, error:${error}`, log_extra);
+                resolve({ stdout, err: `error running script:${script}, error:${error}` });
             } else {
                 const output = fs.readFileSync(log_file, { encoding: 'utf8', flag: 'r' });
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing on host:" + host.name + ", script:" + script + ",stdout:" + output, log_extra);
-                }
-                resolve({ stdout: output });
+                if (is_log_debug()) log_debug(LOG_BASH, `executing on host:${host.name}, script:${script}, stdout:${output}`, log_extra);
                 fs.unlinkSync(log_file);
+                resolve({ stdout: output });
             }
         });
     });
 };
 
-const run_script_file = async (host, script_file, log_extra) => {
-    return new Promise((resolve) => {
-        exec(`ssh ${host.auth} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p ${host.port} ${host.user}@${host.ip} /bin/bash < ${script_file}`, (error, stdout) => {
-            if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error running on host:" + host.name + " the script_file:" + script_file + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error running the script:" + script_file + ",error:" + error });
-            } else {
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing on host:" + host.name + ", script_file:" + script_file + ",stdout:" + stdout, log_extra);
-                }
-                resolve({ stdout: stdout });
-            }
-        });
-    });
+/**
+ * Run script file on remote host.
+ * @param {Object} host - Host info.
+ * @param {string} script_file - Path to local script file.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
+ */
+const run_script_file = (host, script_file, log_extra) => {
+    const cmd = `${build_ssh_prefix(host)} /bin/bash < ${script_file}`;
+    return exec_with_logging(cmd, {},
+        `error running on host:${host.name} script_file:${script_file}`,
+        `executing on host:${host.name}, script_file:${script_file}`, log_extra);
 };
 
 /**
- * Run command in local host
- * @param {command to execute} cmd 
- * @returns 
+ * Run command on local host.
+ * @param {string} cmd - Command to execute.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
  */
-const run_local_cmd = async (cmd, log_extra) => {
-    return new Promise((resolve) => {
-        exec(cmd, { maxBuffer: 1024 * 15000000 }, (error, stdout) => {
-            if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error running on local host with cmd:" + cmd + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error running the cmd:" + cmd + ",error:" + error }, log_extra);
-            } else {
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing on local host with cmd:" + cmd + ",stdout:" + stdout, log_extra);
-                }
-                resolve({ stdout: stdout });
-            }
-        });
-    });
+const run_local_cmd = (cmd, log_extra) => {
+    return exec_with_logging(cmd, { maxBuffer: 1024 * 15000000 },
+        `error running on local host cmd:${cmd}`,
+        `executing on local host cmd:${cmd}`, log_extra);
 };
 
 /**
- * Scp remote file to local file
- * @param {remote host} host 
- * @param {remote file path} remote_file 
- * @param {local file path} locale_file 
- * @returns 
+ * SCP remote file to local.
+ * @param {Object} host - Remote host info.
+ * @param {string} remote_file - Remote file path.
+ * @param {string} local_file - Local file path.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
  */
-const scp = async (host, remote_file, local_file, log_extra) => {
-    return new Promise((resolve) => {
-        exec(`scp ${host.auth} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -P ${host.port} -q ${host.user}@${host.ip}:${remote_file} ${local_file}`, (error, stdout) => {
-            if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error scp on host:" + host.name + " remote:" + remote_file + ",local:" + local_file + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error scp:" + remote_file + " to locale:" + local_file + ",err:" + error });
-            } else {
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing scp on host:" + host.name + ", remote:" + remote_file + ",local:" + local_file + ",stdout:" + stdout, log_extra);
-                }
-                resolve({ stdout: stdout });
-            }
-        });
-    });
+const scp = (host, remote_file, local_file, log_extra) => {
+    const cmd = build_scp_cmd(host, remote_file, local_file, false);
+    return exec_with_logging(cmd, {},
+        `error scp on host:${host.name} remote:${remote_file}, local:${local_file}`,
+        `executing scp on host:${host.name}, remote:${remote_file}, local:${local_file}`, log_extra);
 };
 
 /**
- * Scp local file to remote file
- * @param {remote host} host 
- * @param {local file path} locale_file 
- * @param {remote file path} remote_file 
- * @returns 
+ * SCP local file to remote.
+ * @param {Object} host - Remote host info.
+ * @param {string} local_file - Local file path.
+ * @param {string} remote_file - Remote file path.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<{stdout: string, err?: string}>} Command result.
  */
-const scpr = async (host, local_file, remote_file, log_extra) => {
-    return new Promise((resolve) => {
-        exec(`scp ${host.auth} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -P ${host.port} -q ${local_file} ${host.user}@${host.ip}:${remote_file}`, (error, stdout) => {
-            if (error) {
-                if (is_log_error()) {
-                    log_error(LOG_BASH, "error scpr on host:" + host.name + " remote:" + remote_file + ",local:" + local_file + ",error:" + error, log_extra);
-                }
-                resolve({ stdout: stdout, err: "error scp:" + remote_file + " to locale:" + local_file + ",err:" + error });
-            } else {
-                if (is_log_debug()) {
-                    log_debug(LOG_BASH, "executing scpr on host:" + host.name + ", remote:" + remote_file + ",local:" + local_file + ",stdout:" + stdout, log_extra);
-                }
-                resolve({ stdout: stdout });
-            }
-        });
-    });
+const scpr = (host, local_file, remote_file, log_extra) => {
+    const cmd = build_scp_cmd(host, local_file, remote_file, true);
+    return exec_with_logging(cmd, {},
+        `error scpr on host:${host.name} remote:${remote_file}, local:${local_file}`,
+        `executing scpr on host:${host.name}, remote:${remote_file}, local:${local_file}`, log_extra);
 };
 
 /**
- *Just run simple command and get result directly 
- * @param {host info,contains user,ip and password} host 
- * @param {command to run} cmd 
- * @returns 
+ * Run simple command on remote host and get trimmed result.
+ * @param {Object} host - Host info.
+ * @param {string} cmd - Command to run.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<string|null>} Trimmed output or null on error.
  */
 const run_simple_cmd = async (host, cmd, log_extra) => {
     const { err, stdout } = await run_script(host, cmd, log_extra);
-    if (err) {
-        return null;
-    } else {
-        return stdout.trim();
-    }
-}
+    return err ? null : stdout.trim();
+};
 
 /**
- *Just run simple command and get result directly 
- * @param {command to run} cmd 
- * @returns 
+ * Run simple command locally and get trimmed result.
+ * @param {string} cmd - Command to run.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<string|null>} Trimmed output or null on error.
  */
 const run_simple_local_cmd = async (cmd, log_extra) => {
     const { err, stdout } = await run_local_cmd(cmd, log_extra);
-    if (err) {
-        return null;
-    } else {
-        return stdout.trim();
-    }
-}
+    return err ? null : stdout.trim();
+};
 
 /**
- * Use regular expression to match the pattern to get some part of value
-        Speed: Unknown
-        Manufacturer: NO DIMM
-        Serial Number: NO DIMM
-        Asset Tag:
-        Part Number: NO DIMM
-        Rank: Unknown
-        Configured Memory Speed: Unknown
-        Minimum Voltage: 1.2 V
-        Maximum Voltage: 1.2 V
-        Configured Voltage: 1.2 V
-
- * @param {stdout of the run_cmd} stdout 
- * @param {key to retrieve info} key 
- * @returns 
+ * Extract info from stdout using regex pattern matching.
+ * @param {string} stdout - Command output.
+ * @param {string} key - Key to search for.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {string[]} Array of matched values.
  */
 const get_info = (stdout, key, log_extra) => {
     const word_key = key.split(" ").join("\\s+");
     const regex = new RegExp(`\n\\s?${word_key}\\s?:(.*)\\s`, 'g');
-    if (is_log_debug()) {
-        log_debug(LOG_BASH, "get_info and regex:" + JSON.stringify(regex), log_extra);
-    }
+    if (is_log_debug()) log_debug(LOG_BASH, `get_info regex:${JSON.stringify(regex)}`, log_extra);
 
-    const results = stdout.matchAll(regex);
-
-    const matched = [];
-    for (let result of results) {
-        matched.push(result[1].trim());
-    }
-
-    if (is_log_debug()) {
-        log_debug(LOG_BASH, "get_info and matched:" + JSON.stringify(matched), log_extra);
-    }
+    const matched = [...stdout.matchAll(regex)].map(result => result[1].trim());
+    if (is_log_debug()) log_debug(LOG_BASH, `get_info matched:${JSON.stringify(matched)}`, log_extra);
     return matched;
-}
-
-/**
- * Get the lines of array
- * @param {array of lines} array 
- * @param {array of line number to get,use range to define the lines} lines 
- * @returns 
- */
-const get_lines = (array, lines) => {
-    const result = [];
-    lines.forEach(line => {
-        result.push(array[line]);
-    });
-    return result;
-}
+};
 
 /**
- * Read all the lines to object such as lscpu to retrieve all the cpu info
-    Core(s) per socket:  28
-    Socket(s):           2
-    NUMA node(s):        2
-    Vendor ID:           GenuineIntel
-    CPU family:          6
-    Model:               85
-    Model name:          Intel(R) Xeon(R) Gold 6258R CPU @ 2.70GHz
-    Stepping:            7
-    CPU MHz:             2965.749
-    CPU max MHz:         4000.0000
-    CPU min MHz:         1000.0000
-    BogoMIPS:            5400.00
-    Virtualization:      VT-x
-    L1d cache:           32K
-    L1i cache:           32K
-
- * @param {stdout of the run_cmd} stdout 
- * @param {delimiter to split} delimiter 
- * @param {lines to retrieve} lines 
- * @param {only retrieve the value that has the same property in config} config 
- * @returns 
+ * Read key-value pairs from stdout.
+ * @param {string} stdout - Command output.
+ * @param {string} [delimiter=":"] - Key-value delimiter.
+ * @param {number[]} [lines] - Specific lines to read.
+ * @param {Object} [config] - Filter config for keys.
+ * @param {boolean} [exclude_mode] - If true, exclude keys in config.
+ * @returns {Object} Parsed key-value object.
  */
 const read_key_value_line = (stdout, delimiter = ":", lines, config, exclude_mode) => {
-    const obj = {};
-    if (!stdout) {
-        return obj;
-    }
+    if (!stdout) return {};
 
     const contents = stdout.toString().split(/(?:\r\n|\r|\n)/g);
-    const line_texts = lines ? get_lines(contents, lines) : contents;
-    line_texts.forEach(content => {
+    const line_texts = lines ? lines.map(i => contents[i]) : contents;
+
+    return line_texts.reduce((obj, content) => {
         const key_value = content.split(delimiter);
-        if (key_value.length == 2) {
-            const key = key_value[0].trim();
-            if (key && !config || (exclude_mode != true && config && config[key]) || exclude_mode == true && config && !config[`!${key}`]) {
-                obj[key] = key_value[1].trim();
-            }
-        }
-    });
-    return obj;
-}
+        if (key_value.length !== 2) return obj;
 
+        const key = key_value[0].trim();
+        const should_include = !config ||
+            (exclude_mode !== true && config[key]) ||
+            (exclude_mode === true && !config[`!${key}`]);
 
-/**
- * Use delimeter to split the line and retrieve the info
- *
-    MODEL                                     SIZE
-    INTEL SSDSC2KB03                          3.5T
-    INTEL SSDPE2KE032T7                       2.9T
+        if (key && should_include) obj[key] = key_value[1].trim();
+        return obj;
+    }, {});
+};
 
- * @param {stdout of the run_cmd} stdout 
- * @param {the attribute keys} keys 
- * @param {the lines to ignore} ignore 
- * @param {delimiter to split the line} delimiter 
- * @returns 
+/**
+ * Read structured lines into array of objects.
+ * @param {string} stdout - Command output.
+ * @param {string[]} keys - Attribute keys for columns.
+ * @param {number} [ignore=1] - Lines to skip at start.
+ * @param {string} [delimiter="  "] - Column delimiter.
+ * @returns {Object[]} Array of parsed objects.
  */
 const read_obj_line = (stdout, keys, ignore = 1, delimiter = "  ") => {
-    const results = [];
-    if (!stdout) {
-        return results;
-    }
+    if (!stdout) return [];
 
-    const contents = stdout.toString().split(/(?:\r\n|\r|\n)/g);
-    const line_texts = contents.slice(ignore);
-    line_texts.forEach(content => {
-        const values = content.split(delimiter);
-        if (values && values.length > 0 && values[0].trim().length > 0) {
-            const obj = {};
-            const attrs = values.filter(f => f.trim().length > 0);
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                const value = attrs[i];
-                value && (obj[key] = value.trim());
-            }
-            results.push(obj);
-        }
-    });
-    return results;
-}
+    return stdout.toString().split(/(?:\r\n|\r|\n)/g)
+        .slice(ignore)
+        .filter(content => content.trim().length > 0)
+        .map(content => {
+            const attrs = content.split(delimiter).filter(f => f.trim().length > 0);
+            return keys.reduce((obj, key, i) => {
+                if (attrs[i]) obj[key] = attrs[i].trim();
+                return obj;
+            }, {});
+        });
+};
 
 /**
- * Retrive attributes value and put it to obj
- * @param {host info,contains user,ip and password} host
- * @param {*} attrs  {name:"attr name",cmd:"command to get the attr"}
+ * Get multiple system attributes from remote host.
+ * @param {Object} host - Host info.
+ * @param {Array<{name: string, cmd: string}>} attrs - Attributes to fetch.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<Object>} Object with attribute values.
  */
 const get_system_attributes = async (host, attrs, log_extra) => {
-    const obj = {};
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        const value = await run_simple_cmd(host, attr.cmd, log_extra);
-        value && (obj[attr.name] = value);
-    }
-    return obj;
-}
+    const results = await Promise.all(attrs.map(attr => run_simple_cmd(host, attr.cmd, log_extra)));
+    return attrs.reduce((obj, attr, i) => {
+        if (results[i]) obj[attr.name] = results[i];
+        return obj;
+    }, {});
+};
 
+/**
+ * Stop process on remote host if running.
+ * @param {Object} host - Host info.
+ * @param {string} process_name - Process name to stop.
+ * @param {string} stop_cmd - Command to stop the process.
+ * @param {boolean} [using_full] - Use pgrep -f for full command match.
+ * @param {Object} [log_extra] - Additional logging context.
+ * @returns {Promise<boolean>} True if process was running and stopped.
+ */
 const stop_process = async (host, process_name, stop_cmd, using_full, log_extra) => {
-    const grep_cmd = using_full == true ? `pgrep -f "${process_name}" | wc -l` : `pgrep ${process_name} | wc -l`;
+    const grep_cmd = using_full ? `pgrep -f "${process_name}" | wc -l` : `pgrep ${process_name} | wc -l`;
     const { stdout } = await run_script(host, grep_cmd, log_extra);
     const has_process = stdout && parseInt(stdout) > 0;
-    if (has_process) {
-        await run_script(host, stop_cmd, log_extra);
-    }
+    if (has_process) await run_script(host, stop_cmd, log_extra);
     return has_process;
-}
+};
 
-module.exports = { stop_process, scp, scpr, run_script, run_script_extra, run_script_file, run_simple_cmd, run_local_cmd, run_simple_local_cmd, get_info, get_system_attributes, read_key_value_line, read_obj_line };
+module.exports = {
+    stop_process, scp, scpr, run_script, run_script_extra, run_script_file,
+    run_simple_cmd, run_local_cmd, run_simple_local_cmd, get_info,
+    get_system_attributes, read_key_value_line, read_obj_line
+};

package/core/chart.js

@@ -1,36 +1,46 @@
+/**
+ * @fileoverview Chart data processing utility functions.
+ * @module core/chart
+ */
+
 const { has_value } = require("./validate");
 
-const set_chart_header = (arr1, prefix) => {
-    if (!arr1 || arr1.length < 1) {
-        return;
-    }
-    const headers = arr1[0];
-    if (!headers || headers.length < 1) {
-        return;
-    }
+/**
+ * Set chart header prefix for all columns except the first.
+ * @param {Array[]} arr - 2D array with headers in first row.
+ * @param {string} prefix - Prefix to add to header names.
+ */
+const set_chart_header = (arr, prefix) => {
+    if (!arr || arr.length < 1) return;
+    const headers = arr[0];
+    if (!headers || headers.length < 1) return;
     for (let i = 1; i < headers.length; i++) {
         headers[i] = `${prefix}${headers[i]}`;
     }
-}
+};
 
+/**
+ * Merge two chart data arrays by combining columns.
+ * @param {Array[]} arr1 - First 2D data array (will be modified).
+ * @param {Array[]} arr2 - Second 2D data array to merge.
+ */
 const merge_chart_data = (arr1, arr2) => {
-    if (!arr1 || arr1.length < 2 || !arr2 || arr2.length < 2) {
-        return;
-    }
+    if (!arr1 || arr1.length < 2 || !arr2 || arr2.length < 2) return;
 
     const max = Math.max(arr1.length, arr2.length);
     const arr1_cols = arr1[0].length;
     const arr2_cols = arr2[0].length;
+
     for (let i = 0; i < max; i++) {
         if (!has_value(arr1[i])) {
-            arr1[i] = [...new Array(arr1_cols)].map(o => "");
+            arr1[i] = [...new Array(arr1_cols)].map(() => "");
             arr1[i][0] = arr2[i][0];
         }
         if (!has_value(arr2[i])) {
-            arr2[i] = [...new Array(arr2_cols)].map(o => "");
+            arr2[i] = [...new Array(arr2_cols)].map(() => "");
         }
         arr1[i] = [...arr1[i], ...arr2[i].splice(1)];
     }
-}
+};
 
-module.exports = { set_chart_header, merge_chart_data }
+module.exports = { set_chart_header, merge_chart_data };

package/core/cron.js

@@ -1,10 +1,21 @@
+/**
+ * @fileoverview Cron job scheduling utility functions.
+ * @module core/cron
+ */
+
 const node_cron = require('node-cron');
 
-const init_cron = async (crons, tasks) => {
+/**
+ * Initialize and start cron jobs.
+ * @param {string[]} crons - Array of cron expressions.
+ * @param {Function[]} tasks - Array of task functions to execute.
+ * @param {string} [timezone="Asia/Shanghai"] - Timezone for scheduling.
+ */
+const init_cron = async (crons, tasks, timezone = "Asia/Shanghai") => {
     crons.forEach((cron, index) => {
-        const schedule = node_cron.schedule(cron, () => { tasks[index](); }, { scheduled: true, timezone: "Asia/Shanghai" });
+        const schedule = node_cron.schedule(cron, () => tasks[index](), { scheduled: true, timezone });
         schedule.start();
     });
-}
+};
 
 module.exports = { init_cron };