verteilen-core 1.4.3 → 1.4.4

package/dist/computed.d.ts

@@ -11,3 +11,4 @@ export * as ClientParameter from './client/database';
 export * as ClientResource from './client/resource';
 export * as ClientShell from './client/shell';
 export * as Execute_WebhookServerManager from './script/webhook_server_manager';
+export * as ServerIO from './server/io2';

package/dist/computed.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Execute_WebhookServerManager = exports.ClientShell = exports.ClientResource = exports.ClientParameter = exports.ClientOS = exports.ClientJavascript = exports.ClientHttp = exports.ClientJobParameter = exports.ClientJobExecute = exports.ClientExecute = exports.ClientCluster = exports.Client = exports.ClientAnalysis = void 0;
+exports.ServerIO = exports.Execute_WebhookServerManager = exports.ClientShell = exports.ClientResource = exports.ClientParameter = exports.ClientOS = exports.ClientJavascript = exports.ClientHttp = exports.ClientJobParameter = exports.ClientJobExecute = exports.ClientExecute = exports.ClientCluster = exports.Client = exports.ClientAnalysis = void 0;
 exports.ClientAnalysis = __importStar(require("./client/analysis"));
 exports.Client = __importStar(require("./client/client"));
 exports.ClientCluster = __importStar(require("./client/cluster"));
@@ -47,3 +47,4 @@ exports.ClientParameter = __importStar(require("./client/database"));
 exports.ClientResource = __importStar(require("./client/resource"));
 exports.ClientShell = __importStar(require("./client/shell"));
 exports.Execute_WebhookServerManager = __importStar(require("./script/webhook_server_manager"));
+exports.ServerIO = __importStar(require("./server/io2"));

package/dist/server/io.d.ts

@@ -1,4 +1,3 @@
-import { MongoClient } from "mongodb";
 import { Project, RecordType, Database, UserProfile, Library, ExecutionLog, Node, Task, Job } from "../interface";
 export interface MemoryData {
     projects: Array<Project>;
@@ -43,7 +42,5 @@ export interface RecordIOBase {
 }
 export declare const _CreateRecordMemoryLoader: (loader: MemoryData, type: RecordType) => RecordIOLoader;
 export declare const _CreateRecordIOLoader: (loader: RecordIOBase, memory: MemoryData, type: RecordType, folder: string, ext?: string) => RecordIOLoader;
-export declare const _CreateRecordMongoLoader: (loader: MongoClient, memory: MemoryData, type: RecordType, db: string, collection: string) => RecordIOLoader;
 export declare const CreateRecordMemoryLoader: (loader: MemoryData) => RecordLoader;
 export declare const CreateRecordIOLoader: (loader: RecordIOBase, memory: MemoryData) => RecordLoader;
-export declare const CreateRecordMongoLoader: (url: string, memory: MemoryData) => RecordLoader;

package/dist/server/io.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateRecordMongoLoader = exports.CreateRecordIOLoader = exports.CreateRecordMemoryLoader = exports._CreateRecordMongoLoader = exports._CreateRecordIOLoader = exports._CreateRecordMemoryLoader = void 0;
-const mongodb_1 = require("mongodb");
+exports.CreateRecordIOLoader = exports.CreateRecordMemoryLoader = exports._CreateRecordIOLoader = exports._CreateRecordMemoryLoader = void 0;
 const interface_1 = require("../interface");
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const permissionHelper = (x, uuid) => {
@@ -367,58 +366,6 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
     };
 };
 exports._CreateRecordIOLoader = _CreateRecordIOLoader;
-const _CreateRecordMongoLoader = (loader, memory, type, db, collection) => {
-    const mem = (0, exports._CreateRecordMemoryLoader)(memory, type);
-    return {
-        load_all: async (cache, token) => {
-            if (cache)
-                return mem.load_all(cache, token);
-            const database = loader.db(db);
-            const col = database.collection(collection);
-            const data = await col.find({}).toArray();
-            const exec = data.map(x => {
-                return mem.save(x.uuid, JSON.stringify(x), token);
-            });
-            await Promise.all(exec);
-            return mem.load_all(cache, token);
-        },
-        delete_all: async (token) => {
-            const c = await mem.delete_all(token);
-            const database = loader.db(db);
-            const col = database.collection(collection);
-            const exec = c.map(x => {
-                return col.deleteOne({ uuid: x });
-            });
-            await Promise.all(exec);
-            return c;
-        },
-        list_all: async (token) => {
-            return mem.list_all(token);
-        },
-        save: async (uuid, data, token) => {
-            const r = await mem.save(uuid, data, token);
-            if (!r)
-                return false;
-            const database = loader.db(db);
-            const col = database.collection(collection);
-            col.findOneAndUpdate({ uuid: uuid }, JSON.parse(data));
-            return true;
-        },
-        load: async (uuid, token) => {
-            return mem.load(uuid, token);
-        },
-        delete: async (uuid, token) => {
-            const r = await mem.delete(uuid, token);
-            if (!r)
-                return false;
-            const database = loader.db(db);
-            const col = database.collection(collection);
-            await col.deleteOne({ uuid: uuid });
-            return true;
-        }
-    };
-};
-exports._CreateRecordMongoLoader = _CreateRecordMongoLoader;
 const CreateRecordMemoryLoader = (loader) => {
     return {
         project: (0, exports._CreateRecordMemoryLoader)(loader, interface_1.RecordType.PROJECT),
@@ -445,17 +392,3 @@ const CreateRecordIOLoader = (loader, memory) => {
     };
 };
 exports.CreateRecordIOLoader = CreateRecordIOLoader;
-const CreateRecordMongoLoader = (url, memory) => {
-    const loader = new mongodb_1.MongoClient(url);
-    return {
-        project: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.PROJECT, interface_1.MONGODB_NAME, "project"),
-        task: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.TASK, interface_1.MONGODB_NAME, "task"),
-        job: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.JOB, interface_1.MONGODB_NAME, "job"),
-        database: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.DATABASE, interface_1.MONGODB_NAME, "database"),
-        node: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.NODE, interface_1.MONGODB_NAME, "node"),
-        log: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.LOG, interface_1.MONGODB_NAME, "log"),
-        lib: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.LIB, interface_1.MONGODB_NAME, "lib"),
-        user: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.USER, interface_1.MONGODB_NAME, "user"),
-    };
-};
-exports.CreateRecordMongoLoader = CreateRecordMongoLoader;

package/dist/server/io2.d.ts

@@ -0,0 +1,5 @@
+import { MongoClient } from "mongodb";
+import { RecordType } from "../interface";
+import { MemoryData, RecordIOLoader, RecordLoader } from "./io";
+export declare const _CreateRecordMongoLoader: (loader: MongoClient, memory: MemoryData, type: RecordType, db: string, collection: string) => RecordIOLoader;
+export declare const CreateRecordMongoLoader: (url: string, memory: MemoryData) => RecordLoader;

package/dist/server/io2.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRecordMongoLoader = exports._CreateRecordMongoLoader = void 0;
+const mongodb_1 = require("mongodb");
+const interface_1 = require("../interface");
+const io_1 = require("./io");
+const _CreateRecordMongoLoader = (loader, memory, type, db, collection) => {
+    const mem = (0, io_1._CreateRecordMemoryLoader)(memory, type);
+    return {
+        load_all: async (cache, token) => {
+            if (cache)
+                return mem.load_all(cache, token);
+            const database = loader.db(db);
+            const col = database.collection(collection);
+            const data = await col.find({}).toArray();
+            const exec = data.map(x => {
+                return mem.save(x.uuid, JSON.stringify(x), token);
+            });
+            await Promise.all(exec);
+            return mem.load_all(cache, token);
+        },
+        delete_all: async (token) => {
+            const c = await mem.delete_all(token);
+            const database = loader.db(db);
+            const col = database.collection(collection);
+            const exec = c.map(x => {
+                return col.deleteOne({ uuid: x });
+            });
+            await Promise.all(exec);
+            return c;
+        },
+        list_all: async (token) => {
+            return mem.list_all(token);
+        },
+        save: async (uuid, data, token) => {
+            const r = await mem.save(uuid, data, token);
+            if (!r)
+                return false;
+            const database = loader.db(db);
+            const col = database.collection(collection);
+            col.findOneAndUpdate({ uuid: uuid }, JSON.parse(data));
+            return true;
+        },
+        load: async (uuid, token) => {
+            return mem.load(uuid, token);
+        },
+        delete: async (uuid, token) => {
+            const r = await mem.delete(uuid, token);
+            if (!r)
+                return false;
+            const database = loader.db(db);
+            const col = database.collection(collection);
+            await col.deleteOne({ uuid: uuid });
+            return true;
+        }
+    };
+};
+exports._CreateRecordMongoLoader = _CreateRecordMongoLoader;
+const CreateRecordMongoLoader = (url, memory) => {
+    const loader = new mongodb_1.MongoClient(url);
+    return {
+        project: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.PROJECT, interface_1.MONGODB_NAME, "project"),
+        task: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.TASK, interface_1.MONGODB_NAME, "task"),
+        job: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.JOB, interface_1.MONGODB_NAME, "job"),
+        database: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.DATABASE, interface_1.MONGODB_NAME, "database"),
+        node: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.NODE, interface_1.MONGODB_NAME, "node"),
+        log: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.LOG, interface_1.MONGODB_NAME, "log"),
+        lib: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.LIB, interface_1.MONGODB_NAME, "lib"),
+        user: (0, exports._CreateRecordMongoLoader)(loader, memory, interface_1.RecordType.USER, interface_1.MONGODB_NAME, "user"),
+    };
+};
+exports.CreateRecordMongoLoader = CreateRecordMongoLoader;

package/package.json

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

package/src/computed.ts

@@ -16,4 +16,8 @@ export * as ClientShell from './client/shell'
 /**
  * Scripts
  */
-export * as Execute_WebhookServerManager from './script/webhook_server_manager'
+export * as Execute_WebhookServerManager from './script/webhook_server_manager'
+/**
+ * Server
+ */
+export * as ServerIO from './server/io2'

package/src/server/io.ts

@@ -462,68 +462,6 @@ export const _CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData, ty
         }
     }
 }
-/**
- * **Create the interface for record mongoDB storage**\
- * @param loader MongoDB loader client
- * @param memory Memory loader interface
- * @param type Type of storage
- * @param db Database name
- * @param collection Collection from database
- * @returns Interface for calling
- */
-export const _CreateRecordMongoLoader = (loader:MongoClient, memory:MemoryData, type:RecordType, db:string, collection:string):RecordIOLoader => {
-    const mem = _CreateRecordMemoryLoader(memory, type)
-    return {
-        load_all: async (cache: boolean, token?: string): Promise<Array<string>> => {
-            if(cache) return mem.load_all(cache, token)
-            const database = loader.db(db) 
-            const col = database.collection(collection)
-            const data = await col.find({}).toArray()
-            const exec = data.map(x => {
-                return mem.save(x.uuid, JSON.stringify(x), token)
-            })
-            await Promise.all(exec)
-            return mem.load_all(cache, token)
-        },
-        delete_all: async (token?: string): Promise<Array<string>> => {
-            // Memory action
-            const c = await mem.delete_all(token)
-            const database = loader.db(db) 
-            const col = database.collection(collection)
-            // Get the removed uuids and delete from disk
-            const exec = c.map(x => {
-                return col.deleteOne({ uuid: x })
-            })
-            await Promise.all(exec)
-            return c
-        },
-        list_all: async (token?: string): Promise<Array<string>> => {
-            return mem.list_all(token)
-        },
-        save: async (uuid: string, data: string, token?: string): Promise<boolean> => {
-            const r = await mem.save(uuid, data, token)
-            if(!r) return false
-
-            const database = loader.db(db) 
-            const col = database.collection(collection)
-            col.findOneAndUpdate({ uuid: uuid }, JSON.parse(data))
-            return true
-        },
-        load: async (uuid: string, token?: string): Promise<string> => {
-            return mem.load(uuid, token)
-        },
-        delete: async (uuid: string, token?: string): Promise<boolean> => {
-            const r = await mem.delete(uuid, token)
-            if(!r) return false
-
-            const database = loader.db(db) 
-            const col = database.collection(collection)
-            await col.deleteOne({ uuid: uuid })
-            return true
-        }
-    }
-}
-
 
 /**
  * **Create the interface for record memory storage**\
@@ -561,23 +499,4 @@ export const CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData):Rec
         lib: _CreateRecordIOLoader(loader, memory, RecordType.LIB, "lib"),
         user: _CreateRecordIOLoader(loader, memory, RecordType.USER, "user"),
     }
-}
-/**
- * **Create the interface for record mongoDB storage**\
- * @param url MongoDB URL
- * @param memory loader memory loader interface
- * @returns 
- */
-export const CreateRecordMongoLoader = (url:string, memory:MemoryData):RecordLoader => {
-    const loader:MongoClient = new MongoClient(url)
-    return {
-        project: _CreateRecordMongoLoader(loader, memory, RecordType.PROJECT, MONGODB_NAME, "project"),
-        task: _CreateRecordMongoLoader(loader, memory, RecordType.TASK, MONGODB_NAME, "task"),
-        job: _CreateRecordMongoLoader(loader, memory, RecordType.JOB, MONGODB_NAME, "job"),
-        database: _CreateRecordMongoLoader(loader, memory, RecordType.DATABASE, MONGODB_NAME, "database"),
-        node: _CreateRecordMongoLoader(loader, memory, RecordType.NODE, MONGODB_NAME, "node"),
-        log: _CreateRecordMongoLoader(loader, memory, RecordType.LOG, MONGODB_NAME, "log"),
-        lib: _CreateRecordMongoLoader(loader, memory, RecordType.LIB, MONGODB_NAME, "lib"),
-        user: _CreateRecordMongoLoader(loader, memory, RecordType.USER, MONGODB_NAME, "user"),
-    }
 }

package/src/server/io2.ts

@@ -0,0 +1,85 @@
+import { MongoClient } from "mongodb"
+import { RecordType, MONGODB_NAME } from "../interface"
+import { MemoryData, RecordIOLoader, _CreateRecordMemoryLoader, RecordLoader } from "./io"
+
+/**
+ * **Create the interface for record mongoDB storage**\
+ * @param loader MongoDB loader client
+ * @param memory Memory loader interface
+ * @param type Type of storage
+ * @param db Database name
+ * @param collection Collection from database
+ * @returns Interface for calling
+ */
+export const _CreateRecordMongoLoader = (loader:MongoClient, memory:MemoryData, type:RecordType, db:string, collection:string):RecordIOLoader => {
+    const mem = _CreateRecordMemoryLoader(memory, type)
+    return {
+        load_all: async (cache: boolean, token?: string): Promise<Array<string>> => {
+            if(cache) return mem.load_all(cache, token)
+            const database = loader.db(db) 
+            const col = database.collection(collection)
+            const data = await col.find({}).toArray()
+            const exec = data.map(x => {
+                return mem.save(x.uuid, JSON.stringify(x), token)
+            })
+            await Promise.all(exec)
+            return mem.load_all(cache, token)
+        },
+        delete_all: async (token?: string): Promise<Array<string>> => {
+            // Memory action
+            const c = await mem.delete_all(token)
+            const database = loader.db(db) 
+            const col = database.collection(collection)
+            // Get the removed uuids and delete from disk
+            const exec = c.map(x => {
+                return col.deleteOne({ uuid: x })
+            })
+            await Promise.all(exec)
+            return c
+        },
+        list_all: async (token?: string): Promise<Array<string>> => {
+            return mem.list_all(token)
+        },
+        save: async (uuid: string, data: string, token?: string): Promise<boolean> => {
+            const r = await mem.save(uuid, data, token)
+            if(!r) return false
+
+            const database = loader.db(db) 
+            const col = database.collection(collection)
+            col.findOneAndUpdate({ uuid: uuid }, JSON.parse(data))
+            return true
+        },
+        load: async (uuid: string, token?: string): Promise<string> => {
+            return mem.load(uuid, token)
+        },
+        delete: async (uuid: string, token?: string): Promise<boolean> => {
+            const r = await mem.delete(uuid, token)
+            if(!r) return false
+
+            const database = loader.db(db) 
+            const col = database.collection(collection)
+            await col.deleteOne({ uuid: uuid })
+            return true
+        }
+    }
+}
+
+/**
+ * **Create the interface for record mongoDB storage**\
+ * @param url MongoDB URL
+ * @param memory loader memory loader interface
+ * @returns 
+ */
+export const CreateRecordMongoLoader = (url:string, memory:MemoryData):RecordLoader => {
+    const loader:MongoClient = new MongoClient(url)
+    return {
+        project: _CreateRecordMongoLoader(loader, memory, RecordType.PROJECT, MONGODB_NAME, "project"),
+        task: _CreateRecordMongoLoader(loader, memory, RecordType.TASK, MONGODB_NAME, "task"),
+        job: _CreateRecordMongoLoader(loader, memory, RecordType.JOB, MONGODB_NAME, "job"),
+        database: _CreateRecordMongoLoader(loader, memory, RecordType.DATABASE, MONGODB_NAME, "database"),
+        node: _CreateRecordMongoLoader(loader, memory, RecordType.NODE, MONGODB_NAME, "node"),
+        log: _CreateRecordMongoLoader(loader, memory, RecordType.LOG, MONGODB_NAME, "log"),
+        lib: _CreateRecordMongoLoader(loader, memory, RecordType.LIB, MONGODB_NAME, "lib"),
+        user: _CreateRecordMongoLoader(loader, memory, RecordType.USER, MONGODB_NAME, "user"),
+    }
+}