@wocker/core 1.0.9 → 1.0.10

package/lib/decorators/Module.js

@@ -5,8 +5,10 @@ const env_1 = require("../env");
 const Module = (config) => {
     const { [env_1.PLUGIN_NAME_METADATA]: name, [env_1.MODULE_METADATA.CONTROLLERS]: controllers = [], [env_1.MODULE_METADATA.PROVIDERS]: providers = [], [env_1.MODULE_METADATA.IMPORTS]: imports = [], [env_1.MODULE_METADATA.EXPORTS]: exports = [] } = config;
     return (target) => {
+        if (name) {
+            Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
+        }
         Reflect.defineMetadata("isModule", true, target);
-        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
         Reflect.defineMetadata(env_1.MODULE_METADATA.IMPORTS, imports, target);
         Reflect.defineMetadata(env_1.MODULE_METADATA.CONTROLLERS, controllers, target);
         Reflect.defineMetadata(env_1.MODULE_METADATA.PROVIDERS, providers, target);

package/lib/decorators/Plugin.js

@@ -18,7 +18,7 @@ const Plugin = (config) => {
     const { name } = config, rest = __rest(config, ["name"]);
     return (target) => {
         Reflect.defineMetadata("isPlugin", true, target);
-        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, true, target);
+        Reflect.defineMetadata(env_1.PLUGIN_NAME_METADATA, name, target);
         (0, Module_1.Module)(rest)(target);
     };
 };

package/lib/makes/Config.d.ts

@@ -13,7 +13,7 @@ export declare abstract class Config {
     env?: EnvConfig;
     protected constructor(data: ConfigProperties);
     addPlugin(plugin: string): void;
-    removePlugin(plugin: string): void;
+    removePlugin(removePlugin: string): void;
     setProject(id: string, path: string): void;
     getMeta(name: string, defaultValue: string): string;
     setMeta(name: string, value: string): void;

package/lib/makes/Config.js

@@ -9,10 +9,16 @@ class Config {
         Object.assign(this, data);
     }
     addPlugin(plugin) {
+        if (!this.plugins) {
+            this.plugins = [];
+        }
+        if (this.plugins.includes(plugin)) {
+            return;
+        }
         this.plugins.push(plugin);
     }
-    removePlugin(plugin) {
-        this.plugins = this.plugins.filter((plugin) => plugin !== plugin);
+    removePlugin(removePlugin) {
+        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
     }
     setProject(id, path) {
         this.projects = [

package/lib/makes/FS.d.ts

@@ -8,12 +8,13 @@ type ReadFileOptions = Abortable & {
     encoding?: BufferEncoding;
     flag?: string;
 };
-declare class FS {
+export declare class FS {
     static mkdir(path: PathLike, options?: MakeDirectoryOptions): Promise<unknown>;
     static readFile(filePath: PathOrFileDescriptor, options?: ReadFileOptions): Promise<string | Buffer>;
     static writeFile(filePath: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<unknown>;
     static readJSON(...paths: string[]): Promise<any>;
     static writeJSON(filePath: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<void>;
+    static readdir(path: PathLike): Promise<string[]>;
     static rm(path: PathLike, options?: RmOptions): Promise<void>;
 }
-export { FS };
+export {};

package/lib/makes/FS.js

@@ -31,15 +31,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FS = void 0;
-const fs_1 = require("fs");
+const fs_1 = __importDefault(require("fs"));
 const Path = __importStar(require("path"));
 class FS {
     static mkdir(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                (0, fs_1.mkdir)(path, options, (err) => {
+                fs_1.default.mkdir(path, options, (err) => {
                     if (err) {
                         reject(err);
                         return;
@@ -52,7 +55,7 @@ class FS {
     static readFile(filePath, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                (0, fs_1.readFile)(filePath, options, (err, res) => {
+                fs_1.default.readFile(filePath, options, (err, res) => {
                     if (err) {
                         reject(err);
                         return;
@@ -73,10 +76,10 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.writeFile)(filePath, data, options, callback);
+                    fs_1.default.writeFile(filePath, data, options, callback);
                 }
                 else {
-                    (0, fs_1.writeFile)(filePath, data, callback);
+                    fs_1.default.writeFile(filePath, data, callback);
                 }
             });
         });
@@ -85,7 +88,7 @@ class FS {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield new Promise((resolve, reject) => {
                 const filePath = Path.join(...paths);
-                (0, fs_1.readFile)(filePath, (err, data) => {
+                fs_1.default.readFile(filePath, (err, data) => {
                     if (err) {
                         reject(err);
                         return;
@@ -108,14 +111,28 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.writeFile)(filePath, json, options, callback);
+                    fs_1.default.writeFile(filePath, json, options, callback);
                 }
                 else {
-                    (0, fs_1.writeFile)(filePath, json, callback);
+                    fs_1.default.writeFile(filePath, json, callback);
                 }
             });
         });
     }
+    static readdir(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fs_1.default.readdir(path, (err, files) => {
+                    if (!err) {
+                        resolve(files);
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        });
+    }
     static rm(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
@@ -127,10 +144,10 @@ class FS {
                     resolve(undefined);
                 };
                 if (options) {
-                    (0, fs_1.rm)(path, options, callback);
+                    fs_1.default.rm(path, options, callback);
                 }
                 else {
-                    (0, fs_1.rm)(path, callback);
+                    fs_1.default.rm(path, callback);
                 }
             });
         });

package/lib/makes/FSManager.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import fs, { createReadStream, MakeDirectoryOptions, RmOptions } from "fs";
-declare class FSManager {
-    protected source: string;
-    protected destination: string;
+import { FileSystem } from "./FileSystem";
+export declare class FSManager {
+    readonly source: FileSystem;
+    readonly destination: FileSystem;
     constructor(source: string, destination: string);
     path(...parts: string[]): string;
     mkdir(path: string, options?: MakeDirectoryOptions): Promise<unknown>;
@@ -15,4 +16,3 @@ declare class FSManager {
     createWriteStream(...parts: string[]): fs.WriteStream;
     createReadStream(path: string, options?: Parameters<typeof createReadStream>[1]): fs.ReadStream;
 }
-export { FSManager };

package/lib/makes/FSManager.js

@@ -34,18 +34,18 @@ 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 Path = __importStar(require("path"));
+const FileSystem_1 = require("./FileSystem");
 class FSManager {
     constructor(source, destination) {
-        this.source = source;
-        this.destination = destination;
+        this.source = new FileSystem_1.FileSystem(source);
+        this.destination = new FileSystem_1.FileSystem(destination);
     }
     path(...parts) {
-        return Path.join(this.destination, ...parts);
+        return this.destination.path(...parts);
     }
     mkdir(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const fullPath = Path.join(this.destination, path);
+            const fullPath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.mkdir)(fullPath, options, (err) => {
                     if (err) {
@@ -59,7 +59,7 @@ class FSManager {
     }
     readdir(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filePath = Path.join(this.destination, path);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.readdir)(filePath, (err, files) => {
                     if (err) {
@@ -72,16 +72,16 @@ class FSManager {
         });
     }
     exists(path) {
-        const fullPath = Path.join(this.destination, path);
+        const fullPath = this.path(path);
         return (0, fs_1.existsSync)(fullPath);
     }
     copy(path) {
-        const destination = Path.join(this.destination, path);
+        const destination = this.path(path);
         if ((0, fs_1.existsSync)(destination)) {
             return Promise.resolve();
         }
         return new Promise((resolve, reject) => {
-            (0, fs_1.copyFile)(Path.join(this.source, path), destination, (err) => {
+            (0, fs_1.copyFile)(this.source.path(path), destination, (err) => {
                 if (err) {
                     reject(err);
                     return;
@@ -92,7 +92,7 @@ class FSManager {
     }
     readJSON(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filePath = Path.join(this.destination, ...path);
+            const filePath = this.path(path);
             const res = yield new Promise((resolve, reject) => {
                 (0, fs_1.readFile)(filePath, (err, data) => {
                     if (err) {
@@ -108,7 +108,7 @@ class FSManager {
     writeJSON(path, data) {
         return __awaiter(this, void 0, void 0, function* () {
             const json = JSON.stringify(data, null, 4);
-            const filePath = Path.join(this.destination, path);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.writeFile)(filePath, json, (err) => {
                     if (err) {
@@ -122,7 +122,7 @@ class FSManager {
     }
     rm(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, options = {}) {
-            const filePath = Path.join(this.destination, path);
+            const filePath = this.path(path);
             return new Promise((resolve, reject) => {
                 fs_1.default.rm(filePath, options, (err) => {
                     if (err) {
@@ -135,11 +135,11 @@ class FSManager {
         });
     }
     createWriteStream(...parts) {
-        const filePath = Path.join(this.destination, ...parts);
+        const filePath = this.path(...parts);
         return (0, fs_1.createWriteStream)(filePath);
     }
     createReadStream(path, options) {
-        const filePath = Path.join(this.destination, path);
+        const filePath = this.path(path);
         return (0, fs_1.createReadStream)(filePath, options);
     }
 }

package/lib/makes/FileSystem.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import * as fs from "fs";
+type ReaddirOptions = fs.ObjectEncodingOptions & {
+    recursive?: boolean | undefined;
+};
+export declare class FileSystem {
+    protected readonly source: string;
+    constructor(source: string);
+    path(...parts: string[]): string;
+    exists(...parts: string[]): boolean;
+    stat(...parts: string[]): fs.Stats;
+    mkdir(path: string, options?: fs.MakeDirectoryOptions): void;
+    readdir(...parts: string[]): Promise<unknown>;
+    readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
+}
+export {};

package/lib/makes/FileSystem.js

@@ -0,0 +1,90 @@
+"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 (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 __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.FileSystem = void 0;
+const fs = __importStar(require("fs"));
+const Path = __importStar(require("path"));
+class FileSystem {
+    constructor(source) {
+        this.source = source;
+    }
+    path(...parts) {
+        return Path.join(this.source, ...parts);
+    }
+    exists(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.existsSync(fullPath);
+    }
+    stat(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.statSync(fullPath);
+    }
+    mkdir(path, options) {
+        const fullPath = this.path(path);
+        fs.mkdirSync(fullPath, options);
+    }
+    readdir(...parts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullPath = this.path(...parts);
+            return new Promise((resolve, reject) => {
+                fs.readdir(fullPath, (err, files) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(files);
+                });
+            });
+        });
+    }
+    readdirFiles() {
+        return __awaiter(this, arguments, void 0, function* (path = "", options) {
+            const fullPath = this.path(path);
+            return new Promise((resolve, reject) => {
+                fs.readdir(fullPath, options, (err, files) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    files = files.filter((path) => {
+                        const stat = this.stat(path);
+                        return stat.isFile();
+                    });
+                    resolve(files);
+                });
+            });
+        });
+    }
+}
+exports.FileSystem = FileSystem;

package/lib/makes/Project.d.ts

@@ -1,4 +1,5 @@
 import { PickProperties, EnvConfig } from "../types";
+type ProjectProperties = Omit<PickProperties<Project>, "containerName">;
 export declare abstract class Project {
     id: string;
     name: string;
@@ -13,7 +14,7 @@ export declare abstract class Project {
     ports?: string[];
     volumes?: string[];
     metadata?: EnvConfig;
-    protected constructor(data: PickProperties<Project>);
+    protected constructor(data: ProjectProperties);
     get containerName(): string;
     hasEnv(name: string): boolean;
     getEnv(name: string, defaultValue?: string): string | undefined;
@@ -28,6 +29,8 @@ export declare abstract class Project {
     volumeMount(...volumes: string[]): void;
     volumeUnmount(...volumes: string[]): void;
     abstract save(): Promise<void>;
+    toJSON(): ProjectProperties;
 }
 export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
 export declare const PROJECT_TYPE_IMAGE = "image";
+export {};

package/lib/makes/Project.js

@@ -106,6 +106,23 @@ class Project {
             return !volumes.includes(mounted);
         });
     }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            path: this.path,
+            preset: this.preset,
+            imageName: this.imageName,
+            dockerfile: this.dockerfile,
+            scripts: this.scripts,
+            buildArgs: this.buildArgs,
+            env: this.env,
+            ports: this.ports,
+            volumes: this.volumes,
+            metadata: this.metadata
+        };
+    }
 }
 exports.Project = Project;
 exports.PROJECT_TYPE_DOCKERFILE = "dockerfile";

package/lib/makes/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./Config";
 export * from "./Container";
 export * from "./DI";
+export * from "./FileSystem";
 export * from "./FS";
 export * from "./FSManager";
 export * from "./Logger";

package/lib/makes/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Config"), exports);
 __exportStar(require("./Container"), exports);
 __exportStar(require("./DI"), exports);
+__exportStar(require("./FileSystem"), exports);
 __exportStar(require("./FS"), exports);
 __exportStar(require("./FSManager"), exports);
 __exportStar(require("./Logger"), exports);

package/package.json

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