verteilen-core 1.0.16 → 1.1.1

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./src/computed"), exports);
 __exportStar(require("./src/interface"), exports);
+__exportStar(require("./src/server"), exports);

package/dist/src/interface/enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParameterTemplateText = exports.ProjectTemplateText = exports.JobType2Text = exports.JobTypeText = exports.JobResultText = exports.ConnectionText = exports.JobCategoryText = exports.ExecuteStateText = exports.DataTypeText = exports.ServiceMode = exports.JavascriptLib = exports.RenderUpdateType = exports.ExecuteState = exports.ParameterTemplate = exports.ProjectTemplate = exports.JobType2 = exports.JobType = exports.ConditionResult = exports.JobCategory = exports.FrontendUpdate = exports.ResourceType = exports.DataTypeBase = exports.DataType = exports.SocketState = void 0;
+exports.ParameterTemplateText = exports.ProjectTemplateText = exports.JobType2Text = exports.JobTypeText = exports.JobResultText = exports.ConnectionText = exports.JobCategoryText = exports.ExecuteStateText = exports.DataTypeText = exports.ServiceMode = exports.JavascriptLib = exports.RecordType = exports.RenderUpdateType = exports.ExecuteState = exports.ParameterTemplate = exports.ProjectTemplate = exports.JobType2 = exports.JobType = exports.ConditionResult = exports.JobCategory = exports.FrontendUpdate = exports.ResourceType = exports.DataTypeBase = exports.DataType = exports.SocketState = void 0;
 var SocketState;
 (function (SocketState) {
     SocketState[SocketState["CONNECTING"] = 0] = "CONNECTING";
@@ -103,6 +103,15 @@ var RenderUpdateType;
     RenderUpdateType[RenderUpdateType["Node"] = 2] = "Node";
     RenderUpdateType[RenderUpdateType["Parameter"] = 4] = "Parameter";
 })(RenderUpdateType || (exports.RenderUpdateType = RenderUpdateType = {}));
+var RecordType;
+(function (RecordType) {
+    RecordType[RecordType["PROJECT"] = 0] = "PROJECT";
+    RecordType[RecordType["PARAMETER"] = 1] = "PARAMETER";
+    RecordType[RecordType["NODE"] = 2] = "NODE";
+    RecordType[RecordType["LOG"] = 3] = "LOG";
+    RecordType[RecordType["LIB"] = 4] = "LIB";
+    RecordType[RecordType["USER"] = 5] = "USER";
+})(RecordType || (exports.RecordType = RecordType = {}));
 var JavascriptLib;
 (function (JavascriptLib) {
     JavascriptLib[JavascriptLib["ALL"] = 127] = "ALL";

package/dist/src/interface/server.js

@@ -50,6 +50,7 @@ const CreateRootPermission = () => {
 exports.CreateRootPermission = CreateRootPermission;
 const CreateRootUser = () => {
     return {
+        uuid: (0, uuid_1.v6)(),
         token: (0, uuid_1.v6)(),
         type: UserType.ROOT,
         preference: {

package/dist/src/script/execute_manager.js

@@ -38,7 +38,7 @@ class ExecuteManager extends runner_1.ExecuteManager_Runner {
             this.current_projects = this.record.projects;
             this.current_nodes = [];
             this.record.nodes.forEach(x => {
-                const n = this.websocket_manager.targets.find(y => y.uuid == x.ID);
+                const n = this.websocket_manager.targets.find(y => y.uuid == x.uuid);
                 if (n != undefined)
                     this.current_nodes.push(n);
             });

package/dist/src/script/socket_manager.js

@@ -57,7 +57,7 @@ class WebsocketManager {
         this.server_update = () => this.sendUpdate();
         this.server_record = (ns) => {
             ns.forEach(x => {
-                this.serverconnect(x.url, x.ID);
+                this.serverconnect(x.url, x.uuid);
             });
         };
         this.shell_open = (uuid) => {
@@ -184,16 +184,17 @@ class WebsocketManager {
             const data = [];
             this.targets.forEach(x => {
                 if (x.websocket.readyState == interface_1.SocketState.CLOSED) {
-                    data.push({ ID: x.uuid, url: x.websocket.url });
+                    data.push({ uuid: x.uuid, url: x.websocket.url });
                 }
             });
-            data.forEach(d => this.removeByUUID(d.ID));
+            data.forEach(d => this.removeByUUID(d.uuid));
             data.forEach(d => {
-                this.serverconnect(d.url, d.ID);
+                this.serverconnect(d.url, d.uuid);
             });
             result = this.targets.map(x => {
                 return {
-                    ID: x.uuid,
+                    s: false,
+                    uuid: x.uuid,
                     state: x.websocket.readyState,
                     url: x.websocket.url,
                     connection_rate: x.ms,

package/dist/src/server/io.js

@@ -0,0 +1,181 @@
+"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 });
+exports.CreateRecordMongoLoader = exports.CreateRecordIOLoader = exports.CreateRecordMemoryLoader = exports._CreateRecordIOLoader = exports._CreateRecordMemoryLoader = void 0;
+const interface_1 = require("../interface");
+const _CreateRecordMemoryLoader = (loader, type) => {
+    const get_array = (type) => {
+        switch (type) {
+            default:
+            case interface_1.RecordType.PROJECT: return loader.projects;
+            case interface_1.RecordType.PARAMETER: return loader.parameter;
+            case interface_1.RecordType.NODE: return loader.nodes;
+            case interface_1.RecordType.LOG: return loader.logs;
+            case interface_1.RecordType.LIB: return loader.libs;
+            case interface_1.RecordType.USER: return loader.user;
+        }
+    };
+    return {
+        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            return get_array(type).map(x => JSON.stringify(x));
+        }),
+        delete_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            const arr = get_array(type).map(x => JSON.stringify(x));
+            arr.splice(0, arr.length);
+        }),
+        list_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            return get_array(type).map(x => x.uuid);
+        }),
+        save: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
+            const arr = get_array(type);
+            const b = arr.findIndex(x => name == x.uuid);
+            if (b != -1)
+                arr[b] = JSON.parse(data);
+            else
+                arr.push(JSON.parse(data));
+        }),
+        load: (name) => __awaiter(void 0, void 0, void 0, function* () {
+            const arr = get_array(type);
+            const b = arr.find(x => name == x.uuid);
+            return b ? JSON.stringify(b) : "";
+        }),
+        rename: (name, newname) => __awaiter(void 0, void 0, void 0, function* () {
+            const arr = get_array(type);
+            const b = arr.findIndex(x => x.uuid == name);
+            if (b != -1)
+                arr[b].uuid = newname;
+        }),
+        delete: (name) => __awaiter(void 0, void 0, void 0, function* () {
+            const arr = get_array(type);
+            const b = arr.findIndex(x => x.uuid == name);
+            if (b != -1)
+                arr.splice(b, 1);
+        })
+    };
+};
+exports._CreateRecordMemoryLoader = _CreateRecordMemoryLoader;
+const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
+    const get_array = (type) => {
+        switch (type) {
+            default:
+            case interface_1.RecordType.PROJECT: return memory.projects;
+            case interface_1.RecordType.PARAMETER: return memory.parameter;
+            case interface_1.RecordType.NODE: return memory.nodes;
+            case interface_1.RecordType.LOG: return memory.logs;
+            case interface_1.RecordType.LIB: return memory.libs;
+            case interface_1.RecordType.USER: return memory.user;
+        }
+    };
+    return {
+        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            const files = yield loader.read_dir_file(root);
+            const r = files.map(x => loader.read_string(x, { encoding: 'utf8', flag: 'r' }));
+            const p = yield Promise.all(r);
+            const arr = get_array(type);
+            arr.splice(0, arr.length);
+            arr.push(...p.map(x => JSON.parse(x)));
+            return p;
+        }),
+        delete_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (loader.exists(root))
+                yield loader.rm(root);
+            yield loader.mkdir(root);
+            const arr = get_array(type);
+            arr.splice(0, arr.length);
+        }),
+        list_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            return loader.read_dir_file(root);
+        }),
+        save: (name, data) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            const file = loader.join(root, name + ext);
+            yield loader.write_string(file, data);
+            const arr = get_array(type);
+            const b = arr.findIndex(x => x.uuid == name);
+            if (b != -1)
+                arr.push(JSON.parse(data));
+            else
+                arr[b] = JSON.parse(data);
+        }),
+        load: (name, cache) => __awaiter(void 0, void 0, void 0, function* () {
+            if (cache) {
+                const arr = get_array(type);
+                const b = arr.findIndex(x => x.uuid == name);
+                if (b != -1)
+                    return arr[b];
+            }
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            const file = loader.join(root, name + ext);
+            return loader.read_string(file);
+        }),
+        rename: (name, newname) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            const oldfile = loader.join(root, name + ext);
+            const newfile = loader.join(root, newname + ext);
+            yield loader.cp(oldfile, newfile);
+            yield loader.rm(oldfile);
+            const arr = get_array(type);
+            const b = arr.findIndex(x => x.uuid == name);
+            if (b != -1)
+                arr[b].uuid = newname;
+        }),
+        delete: (name) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, folder);
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            const file = loader.join(root, name + ext);
+            yield loader.rm(file);
+            const arr = get_array(type);
+            const b = arr.findIndex(x => x.uuid == name);
+            if (b != -1)
+                arr.splice(b, 1);
+        })
+    };
+};
+exports._CreateRecordIOLoader = _CreateRecordIOLoader;
+const CreateRecordMemoryLoader = (loader) => {
+    return {
+        project: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.PROJECT),
+        parameter: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.PARAMETER),
+        node: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.NODE),
+        log: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.LOG),
+        lib: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.LIB),
+        user: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.USER),
+    };
+};
+exports.CreateRecordMemoryLoader = CreateRecordMemoryLoader;
+const CreateRecordIOLoader = (loader, memory) => {
+    return {
+        project: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.PROJECT, "record"),
+        parameter: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.PARAMETER, "parameter"),
+        node: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.NODE, "node"),
+        log: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.LOG, "log"),
+        lib: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.LIB, "lib", ""),
+        user: (0, exports._CreateRecordIOLoader)(loader, memory, interface_1.RecordType.USER, "user"),
+    };
+};
+exports.CreateRecordIOLoader = CreateRecordIOLoader;
+const CreateRecordMongoLoader = (loader, folder, ext = ".json") => {
+};
+exports.CreateRecordMongoLoader = CreateRecordMongoLoader;

package/dist/src/server/plugin.js

@@ -0,0 +1,290 @@
+"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 });
+exports.CreatePluginLoader = exports.GetCurrentPlugin = void 0;
+const GetCurrentPlugin = (loader) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => __awaiter(void 0, void 0, void 0, function* () {
+        const b = {
+            plugins: [],
+            templates: []
+        };
+        const root = loader.join(loader.root, 'template');
+        const root2 = loader.join(loader.root, 'plugin');
+        if (!loader.exists(root))
+            yield loader.mkdir(root);
+        if (!loader.exists(root2))
+            yield loader.mkdir(root2);
+        const files = (yield loader.read_dir_file(root)).filter(x => x.endsWith('.json'));
+        const _configs = files.map(file => loader.read_string(loader.join(root, file), { encoding: 'utf-8' }));
+        const configs = (yield Promise.all(_configs)).map(x => JSON.parse(x));
+        for (let index = 0; index < configs.length; index++) {
+            const config = configs[index];
+            const ps = config.projects.map(x => ({
+                value: -1,
+                group: x.group,
+                filename: x.filename,
+                title: x.title
+            }));
+            const ps2 = config.parameters.map(x => ({
+                value: -1,
+                group: x.group,
+                filename: x.filename,
+                title: x.title
+            }));
+            b.templates.push({
+                name: files[index].replace('.json', ''),
+                project: ps,
+                parameter: ps2,
+                url: config.url
+            });
+        }
+        const files2 = (yield loader.read_dir_dir(root2)).filter(x => x.endsWith('.json'));
+        const p_config2 = files2.map(file => {
+            return loader.read_string(loader.join(root2, file), { encoding: 'utf-8' });
+        });
+        const configs2 = (yield Promise.all(p_config2)).map(x => JSON.parse(x));
+        for (let index = 0; index < configs2.length; index++) {
+            const config = configs2[index];
+            config.title = files2[index].replace('.json', '');
+            b.plugins.push(config);
+        }
+        resolve(b);
+        return b;
+    }));
+});
+exports.GetCurrentPlugin = GetCurrentPlugin;
+const CreatePluginLoader = (loader, memory, socket, feedback) => {
+    return {
+        load_all: () => __awaiter(void 0, void 0, void 0, function* () {
+            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+            memory.templates = cp.templates;
+            memory.plugins = cp.plugins;
+            return cp;
+        }),
+        get_project: (group, filename) => {
+            let find = false;
+            let result = undefined;
+            for (let x of memory.templates) {
+                for (let y of x.project) {
+                    if (y.group == group && y.filename == filename) {
+                        result = JSON.stringify(y);
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                    break;
+            }
+            return result;
+        },
+        get_parameter: (group, filename) => {
+            let find = false;
+            let result = undefined;
+            for (let x of memory.templates) {
+                for (let y of x.parameter) {
+                    if (y.group == group && y.filename == filename) {
+                        result = JSON.stringify(y);
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                    break;
+            }
+            return result;
+        },
+        get_plugin: () => __awaiter(void 0, void 0, void 0, function* () {
+            return memory.plugins;
+        }),
+        import_template: (name, url, token) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, 'template');
+            const error_children = [];
+            const tokens = [undefined, ...token.split(' ')];
+            const content_folder = loader.join(root, name);
+            const project_folder = loader.join(content_folder, 'project');
+            const parameter_folder = loader.join(content_folder, 'parameter');
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            let req = {};
+            let ob = undefined;
+            for (let t of tokens) {
+                if (t == undefined) {
+                    req = { method: 'GET', cache: "no-store" };
+                }
+                else {
+                    req = {
+                        method: 'GET',
+                        cache: "no-store",
+                        headers: {
+                            "Authorization": t ? `Bearer ${t}` : ''
+                        }
+                    };
+                }
+                try {
+                    const res = yield fetch(url, req);
+                    const tex = yield res.text();
+                    ob = JSON.parse(tex);
+                    break;
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+            if (ob == undefined) {
+                const p = { title: "Import Failed", type: "error", message: `Cannot find the json from url ${url}, or maybe just the wrong token` };
+                const h = { name: "makeToast", data: JSON.stringify(p) };
+                if (feedback.electron) {
+                    feedback.electron("makeToast", JSON.stringify(p));
+                }
+                if (feedback.socket) {
+                    feedback.socket(JSON.stringify(h));
+                }
+                return memory;
+            }
+            ob.url = url;
+            loader.write_string(loader.join(root, name + '.json'), JSON.stringify(ob, null, 4));
+            if (!loader.exists(content_folder))
+                loader.mkdir(content_folder);
+            if (!loader.exists(project_folder))
+                loader.mkdir(project_folder);
+            if (!loader.exists(parameter_folder))
+                loader.mkdir(parameter_folder);
+            const folder = url.substring(0, url.lastIndexOf('/'));
+            const project_calls = [];
+            const parameter_calls = [];
+            ob.projects.forEach((p) => {
+                project_calls.push(fetch(folder + "/" + p.filename + '.json', req));
+            });
+            const pss = yield Promise.all(project_calls);
+            const project_calls2 = pss.map(x => x.text());
+            const pss_result = yield Promise.all(project_calls2);
+            pss_result.forEach((text, index) => {
+                const n = ob.projects[index].filename + '.json';
+                try {
+                    const project = JSON.parse(text);
+                    loader.write_string(loader.join(project_folder, n), JSON.stringify(project, null, 4));
+                }
+                catch (error) {
+                    console.log("Parse error:\n", text);
+                    error_children.push([`Import Project ${n} Error`, error.message]);
+                }
+            });
+            ob.parameters.forEach((p) => {
+                parameter_calls.push(fetch(folder + "/" + p.filename + '.json', req));
+            });
+            const pss2 = yield Promise.all(parameter_calls);
+            const parameter_calls2 = pss2.map(x => x.text());
+            const pss_result2 = yield Promise.all(parameter_calls2);
+            pss_result2.forEach((text, index) => {
+                const n = ob.parameters[index].filename + '.json';
+                try {
+                    const parameter = JSON.parse(text);
+                    loader.write_string(loader.join(parameter_folder, n), JSON.stringify(parameter, null, 4));
+                }
+                catch (error) {
+                    console.log("Parse error:\n", text);
+                    error_children.push([`Import Parameter ${n} Error`, error.message]);
+                }
+            });
+            for (let x of error_children) {
+                const p = { title: x[0], type: "error", message: x[1] };
+                const h = { name: "makeToast", data: JSON.stringify(p) };
+                if (feedback.electron) {
+                    feedback.electron("makeToast", JSON.stringify(p));
+                }
+                if (feedback.socket) {
+                    feedback.socket(JSON.stringify(h));
+                }
+                return memory;
+            }
+            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+            memory.templates = cp.templates;
+            memory.plugins = cp.plugins;
+            return cp;
+        }),
+        import_plugin: (name, url, token) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, 'plugin');
+            const tokens = [undefined, ...token.split(' ')];
+            if (!loader.exists(root))
+                yield loader.mkdir(root);
+            let req = {};
+            let ob = undefined;
+            for (let t of tokens) {
+                if (t == undefined) {
+                    req = { method: 'GET', cache: "no-store" };
+                }
+                else {
+                    req = {
+                        method: 'GET',
+                        cache: "no-store",
+                        headers: {
+                            "Authorization": t ? `Bearer ${t}` : ''
+                        }
+                    };
+                }
+                let tex = "";
+                try {
+                    const res = yield fetch(url, req);
+                    tex = yield res.text();
+                    ob = JSON.parse(tex);
+                    console.log("Fetch plugin json successfully");
+                    break;
+                }
+                catch (error) {
+                    console.warn(error, tex);
+                }
+            }
+            if (ob == undefined) {
+                const p = { title: "Import Failed", type: "error", message: `Cannot find the json from url ${url}, or maybe just the wrong token` };
+                const h = { name: "makeToast", data: JSON.stringify(p) };
+                if (feedback.electron) {
+                    feedback.electron("makeToast", JSON.stringify(p));
+                }
+                if (feedback.socket) {
+                    feedback.socket(JSON.stringify(h));
+                }
+                return memory;
+            }
+            ob.url = url;
+            loader.write_string(loader.join(root, name + '.json'), JSON.stringify(ob, null, 4));
+            const cp = yield (0, exports.GetCurrentPlugin)(loader);
+            memory.templates = cp.templates;
+            memory.plugins = cp.plugins;
+            return cp;
+        }),
+        delete_template: (name) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, 'template');
+            if (loader.exists(loader.join(root, name + '.json')))
+                yield loader.rm(loader.join(root, name + '.json'));
+            if (loader.exists(loader.join(root, name)))
+                yield loader.rm(loader.join(root, name));
+        }),
+        delete_plugin: (name) => __awaiter(void 0, void 0, void 0, function* () {
+            const root = loader.join(loader.root, 'plugin');
+            if (loader.exists(loader.join(root, name + '.json')))
+                yield loader.rm(loader.join(root, name + '.json'));
+        }),
+        plugin_download: (uuid, plugin, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+            const p = JSON.parse(plugin);
+            const p2 = Object.assign(Object.assign({}, p), { token: tokens.split(' ') });
+            const t = socket(uuid);
+            const h = { name: 'plugin_download', data: p2 };
+            t === null || t === void 0 ? void 0 : t.websocket.send(JSON.stringify(h));
+        }),
+        plugin_remove: (uuid, plugin) => __awaiter(void 0, void 0, void 0, function* () {
+            const p = JSON.parse(plugin);
+            const t = socket(uuid);
+            const h = { name: 'plugin_remove', data: p };
+            t === null || t === void 0 ? void 0 : t.websocket.send(JSON.stringify(h));
+        }),
+    };
+};
+exports.CreatePluginLoader = CreatePluginLoader;

package/dist/src/server/server.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const io_1 = require("./io");
+class Server {
+    constructor() {
+        this.memory = {
+            projects: [],
+            parameter: [],
+            nodes: [],
+            logs: [],
+            libs: [],
+            user: [],
+        };
+        this.plugin = {
+            templates: [],
+            plugins: [],
+        };
+        this.io = undefined;
+        this.loader = undefined;
+        this.plugin_loader = undefined;
+        this.LoadFromDisk = () => {
+            const ts = [
+                this.current_loader.project.load_all(),
+                this.current_loader.parameter.load_all(),
+                this.current_loader.node.load_all(),
+                this.current_loader.log.load_all(),
+                this.current_loader.lib.load_all(),
+                this.current_loader.user.load_all(),
+            ];
+            return Promise.all(ts);
+        };
+        this.memory_loader = (0, io_1.CreateRecordMemoryLoader)(this.memory);
+    }
+    get current_loader() {
+        if (this.loader)
+            return this.loader;
+        return this.memory_loader;
+    }
+}
+exports.Server = Server;

package/dist/src/server.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./server/server"), exports);
+__exportStar(require("./server/io"), exports);

package/dist/test/client/execute.test.js

@@ -27,7 +27,8 @@ describe("Client Execute Test", () => {
             script: "",
             string_args: ["Not Exist"],
             number_args: [],
-            boolean_args: []
+            boolean_args: [],
+            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();
@@ -42,7 +43,8 @@ describe("Client Execute Test", () => {
             script: "",
             string_args: [process.cwd()],
             number_args: [],
-            boolean_args: []
+            boolean_args: [],
+            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();

package/dist/test/client/task.test.js

@@ -17,7 +17,8 @@ describe("Express Test", () => {
             script: "",
             string_args: str,
             number_args: [],
-            boolean_args: []
+            boolean_args: [],
+            id_args: [],
         };
     };
     const generateTask = (Job, property, cronjob) => {

package/index.ts

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

package/package.json

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