verteilen-core 1.2.4 → 1.2.7

package/dist/util/console_handle.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Util_Server_Console_Proxy = exports.Util_Server_Console = void 0;
+const interface_1 = require("../interface");
+class Util_Server_Console {
+    receivedPack = (model, record) => {
+        const pass = model.manager.Register();
+        if (pass == -1) {
+            model.record.running = false;
+            model.record.stop = true;
+            return false;
+        }
+        model.record.projects = record.projects;
+        model.record.nodes = record.nodes;
+        model.record.project_state = model.record.projects.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        model.record.project_index = pass;
+        model.record.project = record.projects[pass].uuid;
+        model.record.task_index = 0;
+        model.record.task_state = model.record.projects[0].task.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        model.record.task_state[0].state = interface_1.ExecuteState.RUNNING;
+        model.record.task_detail = [];
+        const task = model.record.projects[model.record.project_index]?.task[model.record.task_index];
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1;
+        for (let i = 0; i < count; i++) {
+            model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        model.manager.Update();
+        return true;
+    };
+}
+exports.Util_Server_Console = Util_Server_Console;
+class Util_Server_Console_Proxy {
+    model;
+    constructor(_model) {
+        this.model = _model;
+    }
+    get execute_proxy() {
+        const d = {
+            executeProjectStart: (data) => { this.execute_project_start(data); },
+            executeProjectFinish: (data) => { this.execute_project_finish(data); },
+            executeTaskStart: (data) => { this.execute_task_start(data); },
+            executeTaskFinish: (data) => { this.execute_task_finish(data); },
+            executeSubtaskStart: (data) => { this.execute_subtask_start(data); },
+            executeSubtaskUpdate: (data) => { this.execute_subtask_update(data); },
+            executeSubtaskFinish: (data) => { this.execute_subtask_end(data); },
+            executeJobStart: (data) => { this.execute_job_start(data); },
+            executeJobFinish: (data) => { this.execute_job_finish(data); },
+            feedbackMessage: (data) => { this.feedback_message(data); },
+            updateDatabase: (data) => { this.update_runtime_database(data); }
+        };
+        return d;
+    }
+    execute_project_start = (d) => {
+        const index = d[1];
+        if (index == -1)
+            return;
+        this.model.record.project = d[0].uuid;
+        this.model.record.project_index = index;
+        this.model.record.project_state[index].state = interface_1.ExecuteState.RUNNING;
+        this.model.record.task_state = this.model.record.projects[index].task.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        this.model.record.task_detail = [];
+        const task = this.model.record.projects[this.model.record.project_index]?.task[this.model.record.task_index];
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1;
+        for (let i = 0; i < count; i++) {
+            this.model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        console.log("project start: ", this.model.record.projects.length, index);
+    };
+    execute_project_finish = (d) => {
+        if (this.model.record.process_type >= 1) {
+            this.model.record.running = false;
+            this.model.record.stop = true;
+        }
+        const index = d[1];
+        const size = this.model.record.projects.length;
+        if (index == -1)
+            return;
+        this.model.record.project = "";
+        this.model.record.project_state[index].state = interface_1.ExecuteState.FINISH;
+        this.model.record.para = undefined;
+        console.log("project finish: ", this.model.record.projects.length, index);
+        if (index == size - 1) {
+            this.model.record.command.push(['clean']);
+        }
+    };
+    execute_task_start = (d) => {
+        if (this.model.record.project_index == -1)
+            return;
+        const index = this.model.record.projects[this.model.record.project_index].task.findIndex(x => x.uuid == d[0].uuid);
+        if (index == -1)
+            return;
+        this.model.record.useCron = d[0].cronjob;
+        this.model.record.task = d[0].uuid;
+        this.model.record.task_index = index;
+        this.model.record.task_state[index].state = interface_1.ExecuteState.RUNNING;
+        for (let i = 0; i < index; i++)
+            this.model.record.task_state[i].state = interface_1.ExecuteState.FINISH;
+        for (let i = index + 1; i < this.model.record.task_state.length; i++)
+            this.model.record.task_state[i].state = interface_1.ExecuteState.NONE;
+        this.model.record.task_detail = [];
+        const p = this.model.record.projects[this.model.record.project_index];
+        const t = p.task[this.model.record.task_index];
+        const count = this.model.manager.get_task_state_count(t);
+        for (let i = 0; i < count; i++) {
+            this.model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+    };
+    execute_task_finish = (d) => {
+        if (this.model.record.process_type == 2) {
+            this.model.record.running = false;
+            this.model.record.stop = true;
+        }
+        if (this.model.record.project_index == -1)
+            return;
+        const index = this.model.record.projects[this.model.record.project_index].task.findIndex(x => x.uuid == d.uuid);
+        if (index == -1)
+            return;
+        this.model.record.useCron = false;
+        this.model.record.task = "";
+        this.model.record.task_state[index].state = interface_1.ExecuteState.FINISH;
+        if (index + 1 < this.model.record.task_state.length - 1) {
+            this.model.record.task_state[index + 1].state = interface_1.ExecuteState.RUNNING;
+        }
+    };
+    execute_subtask_start = (d) => {
+        try {
+            this.model.record.task_detail[d[1]].node = d[2] ?? '';
+            this.model.record.task_detail[d[1]].state = interface_1.ExecuteState.RUNNING;
+        }
+        catch (error) {
+            console.error(`execute_subtask_start`, error.message);
+        }
+    };
+    execute_subtask_update = (d) => {
+        if (this.model.record.task_detail.length > d[1]) {
+            this.model.record.task_detail[d[1]].node = d[2];
+            this.model.record.task_detail[d[1]].state = d[3];
+        }
+        else {
+            console.error(`subtask_start ${d[1]} is out of range: ${this.model.record.task_detail.length}`);
+        }
+    };
+    execute_subtask_end = (d) => {
+        try {
+            this.model.record.task_detail[d[1]].state = interface_1.ExecuteState.FINISH;
+        }
+        catch (error) {
+            console.error(`execute_subtask_end`, error.message);
+        }
+    };
+    execute_job_start = (d) => {
+        if (this.model.record.project_index == -1)
+            return;
+        if (!this.model.record.useCron) {
+            this.model.record.task_detail[0].node = d[2];
+        }
+    };
+    execute_job_finish = (d) => {
+        if (d[3] == 1) {
+            const task = this.model.record.projects[this.model.record.project_index].task[this.model.record.task_index];
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid);
+            if (index != -1 && task.jobs[index].category == interface_1.JobCategory.Condition) {
+                const cr = task.jobs[index].number_args[0];
+                if (cr == interface_1.ConditionResult.None)
+                    return;
+                this.model.record.command.push(['stop']);
+                let timer;
+                timer = setInterval(() => {
+                    if (this.model.record.running == false) {
+                        clearInterval(timer);
+                        const state = (cr == interface_1.ConditionResult.ThrowTask || cr == interface_1.ConditionResult.ThrowProject) ? interface_1.ExecuteState.ERROR : interface_1.ExecuteState.SKIP;
+                        const target = this.model.record.task_detail[d[1]];
+                        if (target != undefined) {
+                            target.state = state;
+                        }
+                        if (cr == interface_1.ConditionResult.Pause)
+                            return;
+                        if (cr == interface_1.ConditionResult.SkipProject || cr == interface_1.ConditionResult.ThrowProject) {
+                            this.model.record.command.push(['skip', 0, state]);
+                            if (this.model.record.project.length > 0) {
+                                if (this.model.record.process_type == 0) {
+                                    this.model.record.command.push(['execute', this.model.record.process_type]);
+                                }
+                            }
+                        }
+                        else if (cr == interface_1.ConditionResult.SkipTask || cr == interface_1.ConditionResult.ThrowTask) {
+                            this.model.record.command.push(['skip', 1, state]);
+                            if (this.model.record.project.length > 0) {
+                                if (this.model.record.process_type == 0) {
+                                    this.model.record.command.push(['execute', this.model.record.process_type]);
+                                }
+                            }
+                        }
+                    }
+                }, 1000);
+            }
+        }
+    };
+    feedback_message = (d) => {
+        if (d.index == undefined || d.index == -1)
+            return;
+        const container = this.model.record.task_detail[d.index];
+        if (container != undefined) {
+            container.message.push(d.message);
+            if (container.message.length > interface_1.MESSAGE_LIMIT) {
+                container.message.shift();
+            }
+        }
+    };
+    update_runtime_database = (d) => {
+        this.model.record.para = d;
+    };
+}
+exports.Util_Server_Console_Proxy = Util_Server_Console_Proxy;

package/dist/util/log_handle.d.ts

@@ -0,0 +1,23 @@
+import { ExecutePair, ExecuteProxy, ExecuteState, FeedBack, Job, Log, Database, Preference, Project, Task } from "../interface";
+export declare class Util_Server_Log_Proxy {
+    model: ExecutePair;
+    logs: Log;
+    preference: Preference;
+    private task_index;
+    private uuid;
+    private get target_log();
+    constructor(_model: ExecutePair, _log: Log, _preference: Preference);
+    get execute_proxy(): ExecuteProxy;
+    execute_project_start: (d: [Project, number]) => Promise<void>;
+    execute_project_finish: (d: [Project, number]) => void;
+    execute_task_start: (d: [Task, number]) => void;
+    execute_task_finish: (d: Task) => void;
+    execute_subtask_start: (d: [Task, number, string]) => void;
+    execute_subtask_update: (d: [Task, number, string, ExecuteState]) => void;
+    execute_subtask_end: (d: [Task, number, string]) => void;
+    execute_job_start: (d: [Job, number, string]) => void;
+    execute_job_finish: (d: [Job, number, string, number]) => void;
+    feedback_message: (d: FeedBack) => void;
+    update_runtime_database: (d: Database) => void;
+    getnewname: (name: string) => Promise<string>;
+}

package/dist/util/log_handle.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Util_Server_Log_Proxy = void 0;
+const uuid_1 = require("uuid");
+const interface_1 = require("../interface");
+const fs = __importStar(require("fs"));
+class Util_Server_Log_Proxy {
+    model;
+    logs;
+    preference;
+    task_index = 0;
+    uuid = '';
+    get target_log() {
+        return this.logs.logs.find(x => x.uuid == this.uuid);
+    }
+    constructor(_model, _log, _preference) {
+        this.model = _model;
+        this.logs = _log;
+        this.preference = _preference;
+    }
+    get execute_proxy() {
+        const d = {
+            executeProjectStart: (data) => { this.execute_project_start(data); },
+            executeProjectFinish: (data) => { this.execute_project_finish(data); },
+            executeTaskStart: (data) => { this.execute_task_start(data); },
+            executeTaskFinish: (data) => { this.execute_task_finish(data); },
+            executeSubtaskStart: (data) => { this.execute_subtask_start(data); },
+            executeSubtaskUpdate: (data) => { this.execute_subtask_update(data); },
+            executeSubtaskFinish: (data) => { this.execute_subtask_end(data); },
+            executeJobStart: (data) => { this.execute_job_start(data); },
+            executeJobFinish: (data) => { this.execute_job_finish(data); },
+            feedbackMessage: (data) => { this.feedback_message(data); },
+            updateDatabase: (data) => { this.update_runtime_database(data); }
+        };
+        return d;
+    }
+    execute_project_start = async (d) => {
+        const target = this.model.record.projects[this.model.record.project_index];
+        const title = await this.getnewname(target.title);
+        this.uuid = (0, uuid_1.v6)();
+        const newlog = {
+            uuid: this.uuid,
+            filename: title,
+            dirty: true,
+            output: this.preference.log,
+            project: target,
+            state: interface_1.ExecuteState.RUNNING,
+            start_timer: Date.now(),
+            database: d[0].database,
+            end_timer: 0,
+            logs: target.task.map(x => {
+                return {
+                    start_timer: 0,
+                    end_timer: 0,
+                    task_state: {
+                        uuid: x.uuid,
+                        state: interface_1.ExecuteState.NONE
+                    },
+                    task_detail: []
+                };
+            })
+        };
+        this.logs.logs = [newlog].concat(this.logs.logs);
+    };
+    execute_project_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        this.target_log.state = interface_1.ExecuteState.FINISH;
+        this.target_log.end_timer = Date.now();
+        this.target_log.dirty = true;
+    };
+    execute_task_start = (d) => {
+        if (this.target_log == undefined)
+            return;
+        const index = this.target_log.project.task.findIndex(x => x.uuid == d[0].uuid);
+        if (index == -1)
+            return;
+        this.task_index = index;
+        this.target_log.logs[this.task_index].task_detail = [];
+        const p = this.model.record.projects[this.model.record.project_index];
+        const t = p.task[this.task_index];
+        const count = this.model.manager.get_task_state_count(t);
+        for (let i = 0; i < count; i++) {
+            this.target_log.logs[this.task_index].task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        if (this.target_log.logs.length > this.task_index) {
+            this.target_log.logs[this.task_index].task_state.state = interface_1.ExecuteState.RUNNING;
+            this.target_log.logs[this.task_index].start_timer = Date.now();
+            this.target_log.dirty = true;
+        }
+    };
+    execute_task_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs.length > this.task_index) {
+            this.target_log.logs[this.task_index].task_state.state = interface_1.ExecuteState.FINISH;
+            this.target_log.logs[this.task_index].end_timer = Date.now();
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_start = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = interface_1.ExecuteState.RUNNING;
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_update = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = d[3];
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_end = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = interface_1.ExecuteState.FINISH;
+            this.target_log.dirty = true;
+        }
+    };
+    execute_job_start = (d) => {
+    };
+    execute_job_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (d[3] == 1) {
+            const currentLog = this.target_log;
+            const task = currentLog.project.task[this.task_index];
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid);
+            if (index != -1 && task.jobs[index].category == interface_1.JobCategory.Condition) {
+                const cr = task.jobs[index].number_args[0];
+                if (cr == interface_1.ConditionResult.None)
+                    return;
+                const state = (cr == interface_1.ConditionResult.ThrowTask || cr == interface_1.ConditionResult.ThrowProject) ? interface_1.ExecuteState.ERROR : interface_1.ExecuteState.SKIP;
+                const target = this.model.record.task_detail[d[1]];
+                if (target != undefined) {
+                    target.state = state;
+                }
+                currentLog.logs[this.task_index].task_state.state = state;
+                if (cr == interface_1.ConditionResult.Pause)
+                    return;
+                if (cr == interface_1.ConditionResult.SkipProject || cr == interface_1.ConditionResult.ThrowProject) {
+                    currentLog.state = state;
+                }
+            }
+        }
+    };
+    feedback_message = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (d.index == undefined || d.index == -1)
+            return;
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d.index) {
+            this.target_log.logs[this.task_index].task_detail[d.index].message.push(d.message);
+            this.target_log.dirty = true;
+        }
+        else {
+            console.warn("Try access message by index but failed: ", d);
+        }
+    };
+    update_runtime_database = (d) => {
+        if (this.target_log != undefined) {
+            this.target_log.database = d;
+            this.target_log.dirty = true;
+        }
+    };
+    getnewname = async (name) => {
+        const root = "data/log";
+        let count = 0;
+        let filename = name;
+        let p = `${root}/${filename}`;
+        while (fs.existsSync(p + ".json")) {
+            count = count + 1;
+            filename = `${name} ${count}`;
+            p = `${root}/${filename}`;
+        }
+        return filename;
+    };
+}
+exports.Util_Server_Log_Proxy = Util_Server_Log_Proxy;

package/index.ts

@@ -1,6 +1 @@
-// ? Cannot be import in browser
-export * from './src/computed'
-// ? Can be import in browser
-export * from './src/interface'
-// ? Cannot be import in browser
-export * from './src/server'
+export * from "./dist/index"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verteilen-core",
-  "version": "1.2.4",
+  "version": "1.2.7",
   "license": "MIT",
   "homepage": "https://verteilen.github.io/wiki/",
   "author": "Elly",

package/src/index.ts

@@ -0,0 +1,6 @@
+// ? Cannot be import in browser
+export * from './computed'
+// ? Can be import in browser
+export * from './interface'
+// ? Cannot be import in browser
+export * from './server'

package/test/TEST.d.ts

@@ -0,0 +1 @@
+export {};

package/test/TEST.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const pem = __importStar(require("pem"));
+const https = __importStar(require("https"));
+const ws = __importStar(require("ws"));
+let h = undefined;
+let w = undefined;
+async function get_pem() {
+    return new Promise(resolve => {
+        pem.createCertificate({ days: 1, selfSigned: true }, (err, keys) => {
+            resolve([keys.clientKey, keys.certificate]);
+        });
+    });
+}
+async function start_server() {
+    const pems = await get_pem();
+    h = https.createServer({ key: pems[0], cert: pems[1], minVersion: 'TLSv1.2', maxVersion: 'TLSv1.3' }, (req, res) => {
+        res.writeHead(200);
+        res.end('HTTPS server is running');
+    });
+    h.addListener('upgrade', (req, res, head) => console.log('UPGRADE:', req.url));
+    w = new ws.Server({ server: h });
+    w.on('listening', (socket) => {
+        console.log("Listen Event");
+    });
+    w.on('error', (err) => {
+        console.log("Error Event");
+    });
+    w.on('connection', (socket) => {
+        socket.on('message', (data) => {
+            console.log("Recevied Data: ", data.toString());
+        });
+    });
+    h.listen(10000, () => {
+        console.log("Listen to 10000");
+    });
+}
+async function start_client() {
+    return new Promise((resolve) => {
+        const cli = new ws.WebSocket("wss://127.0.0.1:10000", { agent: new https.Agent(), rejectUnauthorized: false });
+        cli.on('error', (err) => {
+            console.log("Socket Error: ", err);
+        });
+        setTimeout(() => {
+            cli.send("Hello World");
+            cli.close();
+            resolve(undefined);
+        }, 1000);
+    });
+}
+async function main() {
+    await start_server();
+    await start_client();
+}
+main();

package/test/client/execute.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{dist/test → test}/client/execute.test.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const job_execute_1 = require("../../src/client/job_execute");
 const interface_1 = require("../../src/interface");
@@ -17,7 +8,7 @@ describe("Client Execute Test", () => {
     afterAll(() => {
         execute = undefined;
     });
-    test("Testing condition (OS when path not exist)", () => __awaiter(void 0, void 0, void 0, function* () {
+    test("Testing condition (OS when path not exist)", async () => {
         job = {
             index: 0,
             uuid: "UUID",
@@ -31,9 +22,9 @@ describe("Client Execute Test", () => {
             id_args: [],
         };
         execute = new job_execute_1.ClientJobExecute((str) => console.log(str), (str) => console.log(str), job, undefined, { plugins: [] });
-        yield expect(execute.execute()).rejects.toBeDefined();
-    }));
-    test("Testing condition (OS when path exist)", () => __awaiter(void 0, void 0, void 0, function* () {
+        await expect(execute.execute()).rejects.toBeDefined();
+    });
+    test("Testing condition (OS when path exist)", async () => {
         job = {
             index: 0,
             uuid: "UUID",
@@ -47,6 +38,6 @@ describe("Client Execute Test", () => {
             id_args: [],
         };
         execute = new job_execute_1.ClientJobExecute((str) => console.log(str), (str) => console.log(str), job, undefined, { plugins: [] });
-        yield expect(execute.execute()).resolves.toBeDefined();
-    }));
+        await expect(execute.execute()).resolves.toBeDefined();
+    });
 });

package/test/client/javascript.test.d.ts

@@ -0,0 +1 @@
+export {};