@wocker/core 1.0.18 → 1.0.19-dev.1

package/lib/makes/Config.d.ts

@@ -1,9 +1,8 @@
-import { AppConfig, AppConfigProperties } from "./AppConfig";
-export type ConfigProperties = AppConfigProperties;
-/**
- * @deprecated
- * @see AppConfig
- */
-export declare abstract class Config extends AppConfig {
-    protected constructor(data: ConfigProperties);
+export type ConfigProperties = {
+    name: string;
+};
+export declare class Config<T extends ConfigProperties> {
+    name: string;
+    constructor(data: T);
+    toObject(): T;
 }

package/lib/makes/Config.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
-const AppConfig_1 = require("./AppConfig");
-/* istanbul ignore next */
-/**
- * @deprecated
- * @see AppConfig
- */
-class Config extends AppConfig_1.AppConfig {
+class Config {
     constructor(data) {
-        super(data);
+        this.name = data.name;
+    }
+    toObject() {
+        return Object.keys(this)
+            .reduce((res, key) => {
+            res[key] = this[key];
+            return res;
+        }, {});
     }
 }
 exports.Config = Config;

package/lib/makes/ConfigCollection.d.ts

@@ -0,0 +1,14 @@
+import { Config, ConfigProperties } from "./Config";
+interface Constructible<P extends ConfigProperties, C extends Config<P>> {
+    new (props: P): C;
+}
+export declare class ConfigCollection<C extends Config<P>, P extends ConfigProperties> {
+    protected ConfigClass: Constructible<P, C>;
+    items: C[];
+    constructor(ConfigClass: Constructible<P, C>, items: P[]);
+    setConfig(config: C): void;
+    getConfig(name: string): C | undefined;
+    removeConfig(name: string): void;
+    toArray(): P[];
+}
+export {};

package/lib/makes/ConfigCollection.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCollection = void 0;
+class ConfigCollection {
+    constructor(ConfigClass, items) {
+        this.ConfigClass = ConfigClass;
+        this.items = items.map((props) => {
+            return new this.ConfigClass(props);
+        });
+    }
+    setConfig(config) {
+        let exists = false;
+        for (let i = 0; i < this.items.length; i++) {
+            if (this.items[i].name === config.name) {
+                exists = true;
+                this.items[i] = config;
+            }
+        }
+        if (!exists) {
+            this.items.push(config);
+        }
+    }
+    getConfig(name) {
+        return this.items.find((config) => {
+            return config.name === name;
+        });
+    }
+    removeConfig(name) {
+        const index = this.items.findIndex((storage) => {
+            return storage.name === name;
+        });
+        if (index === -1) {
+            return;
+        }
+        this.items = [
+            ...this.items.slice(0, index),
+            ...this.items.slice(index + 1)
+        ];
+    }
+    toArray() {
+        return this.items.map((item) => {
+            return item.toObject();
+        });
+    }
+}
+exports.ConfigCollection = ConfigCollection;

package/lib/makes/FileSystem.d.ts

@@ -1,5 +1,5 @@
-import FS, { RmOptions, Stats, WriteFileOptions } from "fs";
-type ReaddirOptions = FS.ObjectEncodingOptions & {
+import fs, { RmOptions, Stats, WriteFileOptions } from "fs";
+type ReaddirOptions = fs.ObjectEncodingOptions & {
     recursive?: boolean | undefined;
 };
 export declare class FileSystem {
@@ -9,12 +9,14 @@ export declare class FileSystem {
     basename(...parts: string[]): string;
     exists(...parts: string[]): boolean;
     stat(...parts: string[]): Stats;
-    mkdir(path: string, options?: FS.MakeDirectoryOptions): void;
-    readdir(...parts: string[]): Promise<unknown>;
+    mkdir(path?: string, options?: fs.MakeDirectoryOptions): void;
+    readdir(...parts: string[]): Promise<string[]>;
     readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
     readJSON(...paths: string[]): any;
-    writeFile(path: string, data: string | Buffer): Promise<void>;
-    writeJSON(path: string, data: any, options?: WriteFileOptions): Promise<void>;
+    writeFile(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions): Promise<void>;
+    writeJSON(path: string, data: any, options?: WriteFileOptions): void;
     rm(path: string, options?: RmOptions): Promise<void>;
+    createWriteStream(path: string): fs.WriteStream;
+    createReadStream(path: string): fs.ReadStream;
 }
 export {};

package/lib/makes/FileSystem.js

@@ -37,7 +37,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
 const fs_1 = __importDefault(require("fs"));
-const fs_2 = __importDefault(require("fs"));
 const Path = __importStar(require("path"));
 class FileSystem {
     constructor(source) {
@@ -51,21 +50,21 @@ class FileSystem {
     }
     exists(...parts) {
         const fullPath = this.path(...parts);
-        return fs_2.default.existsSync(fullPath);
+        return fs_1.default.existsSync(fullPath);
     }
     stat(...parts) {
         const fullPath = this.path(...parts);
-        return fs_2.default.statSync(fullPath);
+        return fs_1.default.statSync(fullPath);
     }
-    mkdir(path, options) {
+    mkdir(path = "", options) {
         const fullPath = this.path(path);
-        fs_2.default.mkdirSync(fullPath, options);
+        fs_1.default.mkdirSync(fullPath, options);
     }
     readdir(...parts) {
         return __awaiter(this, void 0, void 0, function* () {
             const fullPath = this.path(...parts);
             return new Promise((resolve, reject) => {
-                fs_2.default.readdir(fullPath, (err, files) => {
+                fs_1.default.readdir(fullPath, (err, files) => {
                     if (err) {
                         reject(err);
                         return;
@@ -79,7 +78,7 @@ class FileSystem {
         return __awaiter(this, arguments, void 0, function* (path = "", options) {
             const fullPath = this.path(path);
             return new Promise((resolve, reject) => {
-                fs_2.default.readdir(fullPath, options, (err, files) => {
+                fs_1.default.readdir(fullPath, options, (err, files) => {
                     if (err) {
                         reject(err);
                         return;
@@ -95,41 +94,31 @@ class FileSystem {
     }
     readJSON(...paths) {
         const filePath = this.path(...paths);
-        const res = fs_2.default.readFileSync(filePath);
+        const res = fs_1.default.readFileSync(filePath);
         return JSON.parse(res.toString());
     }
-    writeFile(path, data) {
+    writeFile(path, data, options) {
         const fullPath = this.path(path);
         return new Promise((resolve, reject) => {
-            fs_2.default.writeFile(fullPath, data, (err) => {
+            const callback = (err) => {
                 if (err) {
                     reject(err);
                     return;
                 }
                 resolve(undefined);
-            });
+            };
+            if (options) {
+                fs_1.default.writeFile(fullPath, data, options, callback);
+            }
+            else {
+                fs_1.default.writeFile(fullPath, data, callback);
+            }
         });
     }
     writeJSON(path, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fullPath = this.path(path);
-            const json = JSON.stringify(data, null, 4);
-            return new Promise((resolve, reject) => {
-                const callback = (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(undefined);
-                };
-                if (options) {
-                    fs_2.default.writeFile(fullPath, json, options, callback);
-                }
-                else {
-                    fs_2.default.writeFile(fullPath, json, callback);
-                }
-            });
-        });
+        const fullPath = this.path(path);
+        const json = JSON.stringify(data, null, 4);
+        fs_1.default.writeFileSync(fullPath, json, options);
     }
     rm(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -151,5 +140,11 @@ class FileSystem {
             });
         });
     }
+    createWriteStream(path) {
+        return fs_1.default.createWriteStream(this.path(path));
+    }
+    createReadStream(path) {
+        return fs_1.default.createReadStream(this.path(path));
+    }
 }
 exports.FileSystem = FileSystem;

package/lib/makes/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./AppConfig";
 export * from "./Config";
+export * from "./ConfigCollection";
 export * from "./Container";
 export * from "./FileSystem";
 export * from "./FS";

package/lib/makes/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AppConfig"), exports);
 __exportStar(require("./Config"), exports);
+__exportStar(require("./ConfigCollection"), exports);
 __exportStar(require("./Container"), exports);
 __exportStar(require("./FileSystem"), exports);
 __exportStar(require("./FS"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,6 +1,8 @@
 import { AppConfig } from "../makes";
 export declare abstract class AppConfigService {
     protected config?: AppConfig;
+    get version(): string;
+    isVersionGTE(version: string): boolean;
     abstract pwd(...parts: string[]): string;
     abstract setPWD(pwd: string): void;
     abstract dataPath(...args: string[]): string;

package/lib/services/AppConfigService.js

@@ -9,6 +9,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigService = void 0;
 const decorators_1 = require("../decorators");
 let AppConfigService = class AppConfigService {
+    get version() {
+        return "0.0.0";
+    }
+    isVersionGTE(version) {
+        const current = this.version.split(".").map(Number);
+        const compare = version.split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+            if (current[i] > compare[i]) {
+                return true;
+            }
+            else if (current[i] < compare[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
     getConfig() {
         if (!this.config) {
             this.config = this.loadConfig();

package/lib/services/DockerService.d.ts

@@ -27,7 +27,7 @@ export declare namespace DockerServiceParams {
     };
     type ImageList = {
         tag?: string;
-        reference?: string;
+        reference?: string[];
         labels?: {
             [key: string]: string;
         };
@@ -54,9 +54,10 @@ export declare abstract class DockerService {
     abstract buildImage(params: DockerServiceParams.BuildImage): Promise<any>;
     abstract imageExists(tag: string): Promise<boolean>;
     abstract imageLs(options?: DockerServiceParams.ImageList): Promise<ImageInfo[]>;
-    abstract imageRm(tag: string): Promise<void>;
+    abstract imageRm(tag: string, force?: boolean): Promise<void>;
     abstract pullImage(tag: string): Promise<void>;
     abstract attach(name: string | Container): Promise<NodeJS.ReadWriteStream>;
     abstract attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
     abstract exec(name: string, command?: string[], tty?: boolean): Promise<Duplex>;
+    abstract logs(containerOrName: string | Container): Promise<NodeJS.ReadableStream>;
 }

package/lib/services/PluginConfigService.d.ts

@@ -1,15 +1,27 @@
-import { WriteFileOptions, MakeDirectoryOptions, RmOptions } from "fs";
+import { WriteFileOptions, MakeDirectoryOptions, RmOptions, WriteStream, ReadStream } from "fs";
+import { FileSystem } from "../makes";
 export declare class PluginConfigService {
     protected readonly pluginDir: string;
     constructor(pluginDir: string);
+    get fs(): FileSystem;
+    /** @deprecated */
     dataPath(...parts: string[]): string;
-    mkdir(path: string, options?: MakeDirectoryOptions): Promise<void>;
+    /** @deprecated */
+    mkdir(path: string, options?: MakeDirectoryOptions): void;
+    /** @deprecated */
     writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
-    writeJSON(path: string, data: any, options?: WriteFileOptions): Promise<void>;
-    readJSON(path: string): Promise<any>;
+    /** @deprecated */
+    writeJSON(path: string, data: any, options?: WriteFileOptions): void;
+    /** @deprecated */
+    readJSON(path: string): any;
+    /** @deprecated */
     exists(path: string): boolean;
-    rm(path: string, options?: RmOptions): Promise<unknown>;
+    /** @deprecated */
+    rm(path: string, options?: RmOptions): Promise<void>;
+    /** @deprecated */
     readdir(path: string): Promise<string[]>;
-    createWriteSteam(path: string): import("fs").WriteStream;
-    createReadStream(path: string): import("fs").ReadStream;
+    /** @deprecated */
+    createWriteSteam(path: string): WriteStream;
+    /** @deprecated */
+    createReadStream(path: string): ReadStream;
 }

package/lib/services/PluginConfigService.js

@@ -1,33 +1,10 @@
 "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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -45,8 +22,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginConfigService = void 0;
-const Path = __importStar(require("path"));
-const fs_1 = require("fs");
 const makes_1 = require("../makes");
 const decorators_1 = require("../decorators");
 const env_1 = require("../env");
@@ -54,73 +29,61 @@ let PluginConfigService = class PluginConfigService {
     constructor(pluginDir) {
         this.pluginDir = pluginDir;
     }
-    dataPath(...parts) {
+    get fs() {
         if (!this.pluginDir) {
             throw new Error("Plugin dir missed");
         }
-        if (!(0, fs_1.existsSync)(this.pluginDir)) {
-            (0, fs_1.mkdirSync)(this.pluginDir, {
-                recursive: true
-            });
+        const fs = new makes_1.FileSystem(this.pluginDir);
+        if (!fs.exists()) {
+            fs.mkdir();
         }
-        return Path.join(this.pluginDir, ...parts);
+        return fs;
     }
+    /** @deprecated */
+    dataPath(...parts) {
+        return this.fs.path(...parts);
+    }
+    /** @deprecated */
     mkdir(path, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield makes_1.FS.mkdir(this.dataPath(path), options);
-        });
+        this.fs.mkdir(path, options);
     }
+    /** @deprecated */
     writeFile(path, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield makes_1.FS.writeFile(this.dataPath(path), data, options);
+            yield this.fs.writeFile(path, data, options);
         });
     }
+    /** @deprecated */
     writeJSON(path, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield makes_1.FS.writeJSON(this.dataPath(path), data, options);
-        });
+        this.fs.writeJSON(path, data, options);
     }
+    /** @deprecated */
     readJSON(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return makes_1.FS.readJSON(this.dataPath(path));
-        });
+        return this.fs.readJSON(path);
     }
+    /** @deprecated */
     exists(path) {
-        return (0, fs_1.existsSync)(this.dataPath(path));
+        return this.fs.exists(path);
     }
-    rm(path_1) {
-        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const fullPath = this.dataPath(path);
-            return new Promise((resolve, reject) => {
-                (0, fs_1.rm)(fullPath, options, (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(undefined);
-                });
-            });
+    /** @deprecated */
+    rm(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.fs.rm(path, options);
         });
     }
+    /** @deprecated */
     readdir(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fullPath = this.dataPath(path);
-            return new Promise((resolve, reject) => {
-                (0, fs_1.readdir)(fullPath, (err, files) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(files);
-                });
-            });
+            return this.fs.readdir(path);
         });
     }
+    /** @deprecated */
     createWriteSteam(path) {
-        return (0, fs_1.createWriteStream)(this.dataPath(path));
+        return this.fs.createWriteStream(path);
     }
+    /** @deprecated */
     createReadStream(path) {
-        return (0, fs_1.createReadStream)(this.dataPath(path));
+        return this.fs.createReadStream(path);
     }
 };
 exports.PluginConfigService = PluginConfigService;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.18",
+    "version": "1.0.19-dev.1",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",
@@ -25,7 +25,7 @@
         "test-watch": "jest --colors --watchAll --coverage"
     },
     "dependencies": {
-        "@kearisp/cli": "^2.0.5",
+        "@kearisp/cli": "^2.0.6",
         "fs": "^0.0.1-security",
         "path": "^0.12.7",
         "reflect-metadata": "^0.2.2"