@wocker/core 1.0.21-beta.1 → 1.0.21-beta.3

package/lib/makes/AppConfig.d.ts

@@ -31,6 +31,7 @@ export declare abstract class AppConfig {
     removeProject(id: string): void;
     registerPreset(name: string, source: PresetType, path?: string): void;
     unregisterPreset(name: string): void;
+    hasMeta(name: string): boolean;
     getMeta(name: string): string | undefined;
     getMeta(name: string, defaultValue: string): string;
     setMeta(name: string, value: string): void;

package/lib/makes/AppConfig.js

@@ -99,6 +99,12 @@ class AppConfig {
             delete this.presets;
         }
     }
+    hasMeta(name) {
+        if (!this.meta) {
+            return false;
+        }
+        return name in this.meta;
+    }
     getMeta(name, defaultValue) {
         if (!this.meta || !(name in this.meta)) {
             return defaultValue;

package/lib/makes/FS.d.ts

@@ -4,6 +4,9 @@ type ReadFileOptions = Abortable & {
     encoding?: BufferEncoding;
     flag?: string;
 };
+/**
+ * @deprecated
+ */
 export declare class FS {
     static mkdir(path: PathLike, options?: MakeDirectoryOptions): Promise<unknown>;
     static readFile(filePath: PathOrFileDescriptor, options?: ReadFileOptions): Promise<string | Buffer>;

package/lib/makes/FS.js

@@ -48,6 +48,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
 const fs_1 = __importDefault(require("fs"));
 const Path = __importStar(require("path"));
+/**
+ * @deprecated
+ */
 class FS {
     static mkdir(path, options) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/makes/FSManager.d.ts

@@ -1,14 +1,11 @@
-import fs, { createReadStream, MakeDirectoryOptions, RmOptions } from "fs";
-import { FileSystem } from "./FileSystem";
-export declare class FSManager {
-    readonly source: FileSystem;
-    readonly destination: FileSystem;
-    constructor(source: string, destination: string);
+import fs, { createReadStream, RmOptions } from "fs";
+import { FileSystemManager } from "./FileSystemManager";
+/**
+ * @deprecated
+ */
+export declare class FSManager extends FileSystemManager {
     path(...parts: string[]): string;
-    mkdir(path: string, options?: MakeDirectoryOptions): Promise<unknown>;
     readdir(path: string): Promise<string[]>;
-    exists(path: string): boolean;
-    copy(path: string): Promise<void>;
     readJSON(path: string): Promise<any>;
     writeJSON(path: string, data: any): Promise<void>;
     rm(path: string, options?: RmOptions): Promise<unknown>;

package/lib/makes/FSManager.js

@@ -44,29 +44,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FSManager = void 0;
 const fs_1 = __importStar(require("fs"));
-const FileSystem_1 = require("./FileSystem");
-class FSManager {
-    constructor(source, destination) {
-        this.source = new FileSystem_1.FileSystem(source);
-        this.destination = new FileSystem_1.FileSystem(destination);
-    }
+const FileSystemManager_1 = require("./FileSystemManager");
+/**
+ * @deprecated
+ */
+class FSManager extends FileSystemManager_1.FileSystemManager {
     path(...parts) {
         return this.destination.path(...parts);
     }
-    mkdir(path_1) {
-        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const fullPath = this.path(path);
-            return new Promise((resolve, reject) => {
-                (0, fs_1.mkdir)(fullPath, options, (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(undefined);
-                });
-            });
-        });
-    }
     readdir(path) {
         return __awaiter(this, void 0, void 0, function* () {
             const filePath = this.path(path);
@@ -81,25 +66,6 @@ class FSManager {
             });
         });
     }
-    exists(path) {
-        const fullPath = this.path(path);
-        return (0, fs_1.existsSync)(fullPath);
-    }
-    copy(path) {
-        const destination = this.path(path);
-        if ((0, fs_1.existsSync)(destination)) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve, reject) => {
-            (0, fs_1.copyFile)(this.source.path(path), destination, (err) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(undefined);
-            });
-        });
-    }
     readJSON(path) {
         return __awaiter(this, void 0, void 0, function* () {
             const filePath = this.path(path);

package/lib/makes/FileSystem.d.ts

@@ -1,4 +1,4 @@
-import fs, { RmOptions, Stats, WriteFileOptions } from "fs";
+import fs, { RmOptions, Stats, WriteFileOptions, MakeDirectoryOptions } from "fs";
 type ReaddirOptions = fs.ObjectEncodingOptions & {
     recursive?: boolean | undefined;
 };
@@ -9,13 +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;
+    mkdir(path?: string, options?: MakeDirectoryOptions): void;
     readdir(...parts: string[]): Promise<string[]>;
     readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
+    readFile(path: string): Buffer;
     readJSON(...paths: string[]): any;
     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>;
+    rm(path: string, options?: RmOptions): void;
     createWriteStream(path: string, options?: BufferEncoding): fs.WriteStream;
     createReadStream(path: string, options?: BufferEncoding): fs.ReadStream;
 }

package/lib/makes/FileSystem.js

@@ -103,6 +103,10 @@ class FileSystem {
             });
         });
     }
+    readFile(path) {
+        const filePath = this.path(path);
+        return fs_1.default.readFileSync(filePath);
+    }
     readJSON(...paths) {
         const filePath = this.path(...paths);
         const res = fs_1.default.readFileSync(filePath);
@@ -132,24 +136,8 @@ class FileSystem {
         fs_1.default.writeFileSync(fullPath, json, options);
     }
     rm(path, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fullPath = this.path(path);
-            return new Promise((resolve, reject) => {
-                const callback = (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(undefined);
-                };
-                if (options) {
-                    fs_1.default.rm(fullPath, options, callback);
-                }
-                else {
-                    fs_1.default.rm(fullPath, callback);
-                }
-            });
-        });
+        const fullPath = this.path(path);
+        fs_1.default.rmdirSync(fullPath, options);
     }
     createWriteStream(path, options) {
         return fs_1.default.createWriteStream(this.path(path), options);

package/lib/makes/FileSystemManager.d.ts

@@ -0,0 +1,10 @@
+import { MakeDirectoryOptions, CopySyncOptions } from "fs";
+import { FileSystem } from "./FileSystem";
+export declare class FileSystemManager {
+    readonly source: FileSystem;
+    readonly destination: FileSystem;
+    constructor(source: string, destination: string);
+    exists(...parts: string[]): boolean;
+    mkdir(path: string, options?: MakeDirectoryOptions): void;
+    copy(path: string, options?: CopySyncOptions): void;
+}

package/lib/makes/FileSystemManager.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const FileSystem_1 = require("./FileSystem");
+class FileSystemManager {
+    constructor(source, destination) {
+        this.source = new FileSystem_1.FileSystem(source);
+        this.destination = new FileSystem_1.FileSystem(destination);
+    }
+    exists(...parts) {
+        return this.destination.exists(...parts);
+    }
+    mkdir(path, options) {
+        this.destination.mkdir(path, options);
+    }
+    copy(path, options) {
+        fs_1.default.cpSync(this.source.path(path), this.destination.path(path), options);
+    }
+}
+exports.FileSystemManager = FileSystemManager;

package/lib/makes/index.d.ts

@@ -2,6 +2,7 @@ export * from "./AppConfig";
 export * from "./Config";
 export * from "./ConfigCollection";
 export * from "./FileSystem";
+export * from "./FileSystemManager";
 export * from "./FS";
 export * from "./FSManager";
 export * from "./Logger";

package/lib/makes/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./AppConfig"), exports);
 __exportStar(require("./Config"), exports);
 __exportStar(require("./ConfigCollection"), exports);
 __exportStar(require("./FileSystem"), exports);
+__exportStar(require("./FileSystemManager"), exports);
 __exportStar(require("./FS"), exports);
 __exportStar(require("./FSManager"), exports);
 __exportStar(require("./Logger"), exports);

package/lib/services/DockerService.d.ts

@@ -9,6 +9,8 @@ export declare namespace DockerServiceParams {
         entrypoint?: string | string[];
         projectId?: string;
         tty?: boolean;
+        memory?: number;
+        memorySwap?: number;
         ulimits?: {
             [key: string]: {
                 hard?: number;
@@ -64,7 +66,7 @@ export declare abstract class DockerService {
     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 attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
     abstract exec(name: string, command?: DockerServiceParams.Exec | string[], tty?: boolean): Promise<Duplex>;
     abstract logs(containerOrName: string | Container): Promise<NodeJS.ReadableStream>;
 }

package/lib/services/PluginConfigService.d.ts

@@ -1,10 +1,13 @@
 import { WriteFileOptions, MakeDirectoryOptions, RmOptions, WriteStream, ReadStream } from "fs";
+import { AppConfigService } from "./AppConfigService";
 import { FileSystem } from "../makes";
 export declare class PluginConfigService {
+    protected readonly appConfigService: AppConfigService;
     protected readonly pluginDir: string;
     protected _fs?: FileSystem;
-    constructor(pluginDir: string);
+    constructor(appConfigService: AppConfigService, pluginDir: string);
     get fs(): FileSystem;
+    isVersionGTE(version: string): boolean;
     /** @deprecated */
     dataPath(...parts: string[]): string;
     /** @deprecated */

package/lib/services/PluginConfigService.js

@@ -22,11 +22,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginConfigService = void 0;
+const AppConfigService_1 = require("./AppConfigService");
 const makes_1 = require("../makes");
 const decorators_1 = require("../decorators");
 const env_1 = require("../env");
 let PluginConfigService = class PluginConfigService {
-    constructor(pluginDir) {
+    constructor(appConfigService, pluginDir) {
+        this.appConfigService = appConfigService;
         this.pluginDir = pluginDir;
     }
     get fs() {
@@ -41,6 +43,12 @@ let PluginConfigService = class PluginConfigService {
         }
         return this._fs;
     }
+    isVersionGTE(version) {
+        if (!this.appConfigService.isVersionGTE) {
+            return false;
+        }
+        return this.appConfigService.isVersionGTE(version);
+    }
     /** @deprecated */
     dataPath(...parts) {
         return this.fs.path(...parts);
@@ -91,6 +99,6 @@ let PluginConfigService = class PluginConfigService {
 exports.PluginConfigService = PluginConfigService;
 exports.PluginConfigService = PluginConfigService = __decorate([
     (0, decorators_1.Injectable)(),
-    __param(0, (0, decorators_1.Inject)(env_1.PLUGIN_DIR_KEY)),
-    __metadata("design:paramtypes", [String])
+    __param(1, (0, decorators_1.Inject)(env_1.PLUGIN_DIR_KEY)),
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService, String])
 ], PluginConfigService);

package/lib/services/PluginFileSystem.d.ts

@@ -0,0 +1,4 @@
+import { FileSystem } from "../makes";
+export declare class PluginFileSystem extends FileSystem {
+    constructor(pluginDir: string);
+}

package/lib/services/PluginFileSystem.js

@@ -0,0 +1,29 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginFileSystem = void 0;
+const decorators_1 = require("../decorators");
+const env_1 = require("../env");
+const makes_1 = require("../makes");
+let PluginFileSystem = class PluginFileSystem extends makes_1.FileSystem {
+    constructor(pluginDir) {
+        super(pluginDir);
+    }
+};
+exports.PluginFileSystem = PluginFileSystem;
+exports.PluginFileSystem = PluginFileSystem = __decorate([
+    (0, decorators_1.Injectable)(),
+    __param(0, (0, decorators_1.Inject)(env_1.PLUGIN_DIR_KEY)),
+    __metadata("design:paramtypes", [String])
+], PluginFileSystem);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.21-beta.1",
+    "version": "1.0.21-beta.3",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",