@wocker/core 1.0.14 → 1.0.16

package/lib/decorators/Description.js

@@ -4,8 +4,8 @@ exports.Description = void 0;
 require("reflect-metadata");
 const env_1 = require("../env");
 const Description = (description) => {
-    return (target, propertyKey, descriptor) => {
-        Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, descriptor);
+    return (_target, _propertyKey, descriptor) => {
+        Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, descriptor.value);
     };
 };
 exports.Description = Description;

package/lib/decorators/Option.d.ts

@@ -1,3 +1,4 @@
+import "reflect-metadata";
 import { Option as O } from "@kearisp/cli";
 type Params = Omit<O, "name">;
 export declare const Option: (name: string, params?: Partial<Params>) => ParameterDecorator;

package/lib/decorators/Option.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Option = void 0;
+require("reflect-metadata");
 const env_1 = require("../env");
 const Option = (name, params) => {
     return (target, key, index) => {

package/lib/makes/AppConfig.d.ts

@@ -0,0 +1,50 @@
+import { EnvConfig, PickProperties } from "../types";
+import { PresetType } from "./Preset";
+type ProjectData = {
+    id: string;
+    name?: string;
+    path?: string;
+    /** @deprecated */
+    src?: string;
+};
+type PresetData = {
+    name: string;
+    source: PresetType;
+    path?: string;
+};
+export type AppConfigProperties = Omit<PickProperties<AppConfig>, "logLevel"> & {
+    logLevel?: AppConfig["logLevel"];
+};
+export declare abstract class AppConfig {
+    debug?: boolean;
+    logLevel: "off" | "info" | "warn" | "error";
+    plugins?: string[];
+    presets?: PresetData[];
+    projects?: ProjectData[];
+    meta?: EnvConfig;
+    env?: EnvConfig;
+    protected constructor(data: AppConfigProperties);
+    addPlugin(plugin: string): void;
+    removePlugin(removePlugin: string): void;
+    getProject(id: string): ProjectData | undefined;
+    /**
+     * @deprecated
+     * @see Project.addProject
+     */
+    setProject(id: string, path: string): void;
+    addProject(id: string, name: string, path: string): void;
+    removeProject(id: string): void;
+    registerPreset(name: string, source: PresetType, path?: string): void;
+    unregisterPreset(name: string): void;
+    getMeta(name: string): string | undefined;
+    getMeta(name: string, defaultValue: string): string;
+    setMeta(name: string, value: string): void;
+    unsetMeta(name: string): void;
+    getEnv(name: string): string | undefined;
+    getEnv(name: string, defaultValue: string): string;
+    setEnv(name: string, value: string): void;
+    unsetEnv(name: string): void;
+    abstract save(): Promise<void>;
+    toJson(): AppConfigProperties;
+}
+export {};

package/lib/makes/AppConfig.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppConfig = void 0;
+const Preset_1 = require("./Preset");
+class AppConfig {
+    constructor(data) {
+        this.logLevel = "off";
+        Object.assign(this, data);
+    }
+    addPlugin(plugin) {
+        if (!this.plugins) {
+            this.plugins = [];
+        }
+        if (this.plugins.includes(plugin)) {
+            return;
+        }
+        this.plugins.push(plugin);
+    }
+    removePlugin(removePlugin) {
+        if (!this.plugins) {
+            return;
+        }
+        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
+        if (this.plugins.length === 0) {
+            delete this.plugins;
+        }
+    }
+    getProject(id) {
+        if (!this.projects) {
+            return;
+        }
+        return this.projects.find((projectData) => {
+            return projectData.id === id;
+        });
+    }
+    /* istanbul ignore next */
+    /**
+     * @deprecated
+     * @see Project.addProject
+     */
+    setProject(id, path) {
+        if (!this.projects) {
+            this.projects = [];
+        }
+        let projectData = this.projects.find((projectData) => {
+            return projectData.id === id;
+        });
+        if (!projectData) {
+            this.projects.push({
+                id,
+                path,
+                src: path
+            });
+            return;
+        }
+        projectData.name = id;
+        projectData.path = path;
+        projectData.src = path;
+    }
+    addProject(id, name, path) {
+        if (!this.projects) {
+            this.projects = [];
+        }
+        let projectData = this.projects.find((projectData) => {
+            return projectData.id === id;
+        });
+        if (!projectData) {
+            this.projects.push({
+                id,
+                name,
+                path,
+            });
+            return;
+        }
+        /* istanbul ignore next */
+        if (projectData.src) {
+            delete projectData.src;
+        }
+        projectData.name = name;
+        projectData.path = path;
+    }
+    removeProject(id) {
+        if (!this.projects) {
+            return;
+        }
+        this.projects = this.projects.filter((projectData) => {
+            return projectData.id !== id;
+        });
+        if (this.projects.length === 0) {
+            delete this.projects;
+        }
+    }
+    registerPreset(name, source, path) {
+        if (!this.presets) {
+            this.presets = [];
+        }
+        let presetData = this.presets.find((preset) => {
+            return preset.name === name;
+        });
+        if (!presetData) {
+            presetData = {
+                name,
+                source
+            };
+            this.presets.push(presetData);
+        }
+        presetData.source = source;
+        if (presetData.source === Preset_1.PRESET_SOURCE_EXTERNAL) {
+            presetData.path = path;
+        }
+        else if (presetData.path) {
+            delete presetData.path;
+        }
+    }
+    unregisterPreset(name) {
+        if (!this.presets) {
+            return;
+        }
+        this.presets = this.presets.filter((preset) => {
+            return preset.name !== name;
+        });
+        if (this.presets.length === 0) {
+            delete this.presets;
+        }
+    }
+    getMeta(name, defaultValue) {
+        if (!this.meta || !(name in this.meta)) {
+            return defaultValue;
+        }
+        return this.meta[name];
+    }
+    setMeta(name, value) {
+        if (!this.meta) {
+            this.meta = {};
+        }
+        this.meta[name] = value;
+    }
+    unsetMeta(name) {
+        if (!this.meta || !(name in this.meta)) {
+            return;
+        }
+        delete this.meta[name];
+        if (Object.keys(this.meta).length === 0) {
+            delete this.meta;
+        }
+    }
+    getEnv(name, defaultValue) {
+        if (!this.env || !(name in this.env)) {
+            return defaultValue;
+        }
+        return this.env[name];
+    }
+    setEnv(name, value) {
+        if (!this.env) {
+            this.env = {};
+        }
+        this.env[name] = value;
+    }
+    unsetEnv(name) {
+        if (!this.env || !(name in this.env)) {
+            return;
+        }
+        delete this.env[name];
+        if (Object.keys(this.env).length === 0) {
+            delete this.env;
+        }
+    }
+    toJson() {
+        const json = {
+            debug: this.debug,
+            logLevel: this.logLevel,
+            plugins: this.plugins,
+            projects: this.projects,
+            presets: this.presets,
+            env: this.env,
+            meta: this.meta
+        };
+        return Object.keys(json).reduce((res, key) => {
+            if (typeof json[key] !== "undefined") {
+                res[key] = json[key];
+            }
+            return res;
+        }, {});
+    }
+}
+exports.AppConfig = AppConfig;

package/lib/makes/Config.d.ts

@@ -1,36 +1,9 @@
-import { EnvConfig, PickProperties } from "../types";
-import { PresetType } from "./Preset";
-export type ConfigProperties = Omit<PickProperties<Config>, "logLevel"> & {
-    logLevel?: Config["logLevel"];
-};
-export declare abstract class Config {
-    debug?: boolean;
-    logLevel: "off" | "info" | "warn" | "error";
-    plugins: string[];
-    presets?: {
-        name: string;
-        source: PresetType;
-        path?: string;
-    }[];
-    projects: {
-        id: string;
-        name?: string;
-        src: string;
-    }[];
-    meta?: EnvConfig;
-    env?: EnvConfig;
+import { AppConfig, AppConfigProperties } from "./AppConfig";
+export type ConfigProperties = AppConfigProperties;
+/**
+ * @deprecated
+ * @see AppConfig
+ */
+export declare abstract class Config extends AppConfig {
     protected constructor(data: ConfigProperties);
-    addPlugin(plugin: string): void;
-    removePlugin(removePlugin: string): void;
-    setProject(id: string, path: string): void;
-    registerPreset(name: string, source: PresetType, path?: string): void;
-    unregisterPreset(name: string): void;
-    getMeta(name: string, defaultValue: string): string;
-    setMeta(name: string, value: string): void;
-    unsetMeta(name: string): void;
-    getEnv(name: string, defaultValue: string): string;
-    setEnv(name: string, value: string): void;
-    unsetEnv(name: string): void;
-    abstract save(): Promise<void>;
-    toJson(): ConfigProperties;
 }

package/lib/makes/Config.js

@@ -1,116 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = void 0;
-class Config {
+const AppConfig_1 = require("./AppConfig");
+/* istanbul ignore next */
+/**
+ * @deprecated
+ * @see AppConfig
+ */
+class Config extends AppConfig_1.AppConfig {
     constructor(data) {
-        this.logLevel = "off";
-        this.plugins = [];
-        this.presets = [];
-        this.projects = [];
-        Object.assign(this, data);
-    }
-    addPlugin(plugin) {
-        if (!this.plugins) {
-            this.plugins = [];
-        }
-        if (this.plugins.includes(plugin)) {
-            return;
-        }
-        this.plugins.push(plugin);
-    }
-    removePlugin(removePlugin) {
-        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
-    }
-    setProject(id, path) {
-        this.projects = [
-            ...this.projects.filter((project) => {
-                return project.id !== id && project.src !== path;
-            }),
-            {
-                id,
-                src: path
-            }
-        ];
-    }
-    registerPreset(name, source, path) {
-        if (!this.presets) {
-            this.presets = [];
-        }
-        const preset = this.presets.find((preset) => {
-            return preset.name === name;
-        });
-        if (!preset) {
-            this.presets.push({
-                name,
-                source,
-                path
-            });
-        }
-    }
-    unregisterPreset(name) {
-        if (!this.presets) {
-            return;
-        }
-        this.presets = this.presets.filter((preset) => {
-            return preset.name !== name;
-        });
-        if (this.presets.length === 0) {
-            delete this.presets;
-        }
-    }
-    getMeta(name, defaultValue) {
-        if (!this.meta || !(name in this.meta)) {
-            return defaultValue;
-        }
-        return this.meta[name];
-    }
-    setMeta(name, value) {
-        if (!this.meta) {
-            this.meta = {};
-        }
-        this.meta[name] = value;
-    }
-    unsetMeta(name) {
-        if (!this.meta || !(name in this.meta)) {
-            return;
-        }
-        delete this.meta[name];
-        if (Object.keys(this.meta).length === 0) {
-            delete this.meta;
-        }
-    }
-    getEnv(name, defaultValue) {
-        if (!this.env || !(name in this.env)) {
-            return defaultValue;
-        }
-        return this.env[name];
-    }
-    setEnv(name, value) {
-        if (!this.env) {
-            this.env = {};
-        }
-        this.env[name] = value;
-    }
-    unsetEnv(name) {
-        if (!this.env || !(name in this.env)) {
-            return;
-        }
-        delete this.env[name];
-        if (Object.keys(this.env).length === 0) {
-            delete this.env;
-        }
-    }
-    // noinspection JSUnusedGlobalSymbols
-    toJson() {
-        return {
-            debug: this.debug,
-            logLevel: this.logLevel,
-            plugins: this.plugins,
-            projects: this.projects,
-            presets: (this.presets || []).length > 0 ? this.presets : undefined,
-            env: this.env,
-            meta: this.meta
-        };
+        super(data);
     }
 }
 exports.Config = Config;

package/lib/makes/FileSystem.d.ts

@@ -1,15 +1,20 @@
-import * as fs from "fs";
-type ReaddirOptions = fs.ObjectEncodingOptions & {
+import FS, { RmOptions, Stats, WriteFileOptions } from "fs";
+type ReaddirOptions = FS.ObjectEncodingOptions & {
     recursive?: boolean | undefined;
 };
 export declare class FileSystem {
     protected readonly source: string;
     constructor(source: string);
     path(...parts: string[]): string;
+    basename(...parts: string[]): string;
     exists(...parts: string[]): boolean;
-    stat(...parts: string[]): fs.Stats;
-    mkdir(path: string, options?: fs.MakeDirectoryOptions): void;
+    stat(...parts: string[]): Stats;
+    mkdir(path: string, options?: FS.MakeDirectoryOptions): void;
     readdir(...parts: string[]): Promise<unknown>;
     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>;
+    rm(path: string, options?: RmOptions): Promise<void>;
 }
 export {};

package/lib/makes/FileSystem.js

@@ -31,9 +31,13 @@ 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.FileSystem = void 0;
-const fs = __importStar(require("fs"));
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = __importDefault(require("fs"));
 const Path = __importStar(require("path"));
 class FileSystem {
     constructor(source) {
@@ -42,23 +46,26 @@ class FileSystem {
     path(...parts) {
         return Path.join(this.source, ...parts);
     }
+    basename(...parts) {
+        return Path.basename(this.path(...parts));
+    }
     exists(...parts) {
         const fullPath = this.path(...parts);
-        return fs.existsSync(fullPath);
+        return fs_2.default.existsSync(fullPath);
     }
     stat(...parts) {
         const fullPath = this.path(...parts);
-        return fs.statSync(fullPath);
+        return fs_2.default.statSync(fullPath);
     }
     mkdir(path, options) {
         const fullPath = this.path(path);
-        fs.mkdirSync(fullPath, options);
+        fs_2.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.readdir(fullPath, (err, files) => {
+                fs_2.default.readdir(fullPath, (err, files) => {
                     if (err) {
                         reject(err);
                         return;
@@ -72,7 +79,7 @@ class FileSystem {
         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) => {
+                fs_2.default.readdir(fullPath, options, (err, files) => {
                     if (err) {
                         reject(err);
                         return;
@@ -86,5 +93,63 @@ class FileSystem {
             });
         });
     }
+    readJSON(...paths) {
+        const filePath = this.path(...paths);
+        const res = fs_2.default.readFileSync(filePath);
+        return JSON.parse(res.toString());
+    }
+    writeFile(path, data) {
+        const fullPath = this.path(path);
+        return new Promise((resolve, reject) => {
+            fs_2.default.writeFile(fullPath, data, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(undefined);
+            });
+        });
+    }
+    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);
+                }
+            });
+        });
+    }
+    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);
+                }
+            });
+        });
+    }
 }
 exports.FileSystem = FileSystem;

package/lib/makes/Preset.d.ts

@@ -26,6 +26,8 @@ export declare abstract class Preset {
     name: string;
     source?: PresetType;
     version: string;
+    type?: string;
+    image?: string;
     dockerfile?: string;
     buildArgsOptions?: {
         [name: string]: AnyOption;

package/lib/makes/Preset.js

@@ -4,9 +4,11 @@ exports.PRESET_SOURCE_GITHUB = exports.PRESET_SOURCE_EXTERNAL = exports.PRESET_S
 class Preset {
     constructor(data) {
         this.name = data.name;
+        this.version = data.version;
+        this.type = data.type;
         this.source = data.source;
         this.path = data.path;
-        this.version = data.version;
+        this.image = data.image;
         this.dockerfile = data.dockerfile;
         this.buildArgsOptions = data.buildArgsOptions;
         this.envOptions = data.envOptions;
@@ -17,8 +19,10 @@ class Preset {
     toJSON() {
         return {
             name: this.name,
-            source: this.source,
             version: this.version,
+            type: this.type,
+            source: this.source,
+            image: this.image,
             dockerfile: this.dockerfile,
             buildArgsOptions: this.buildArgsOptions,
             envOptions: this.envOptions,

package/lib/makes/Project.d.ts

@@ -1,4 +1,5 @@
 import { PickProperties, EnvConfig } from "../types";
+export type ProjectType = typeof PROJECT_TYPE_DOCKERFILE | typeof PROJECT_TYPE_IMAGE | typeof PROJECT_TYPE_PRESET;
 export type ProjectProperties = Omit<PickProperties<Project>, "containerName" | "domains">;
 export declare abstract class Project {
     id: string;

package/lib/makes/Project.js

@@ -155,9 +155,20 @@ class Project {
         this.volumeMount(...restVolumes);
     }
     volumeUnmount(...volumes) {
-        this.volumes = (this.volumes || []).filter((mounted) => {
-            return !volumes.includes(mounted);
+        if (!this.volumes || volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const v = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = this.volumes.filter((mounted) => {
+            const m = (0, volumeParse_1.volumeParse)(mounted);
+            return v.source !== m.source && v.destination !== m.destination;
         });
+        if (this.volumes.length === 0) {
+            delete this.volumes;
+            return;
+        }
+        this.volumeUnmount(...restVolumes);
     }
     toJSON() {
         return {

package/lib/makes/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./AppConfig";
 export * from "./Config";
 export * from "./Container";
 export * from "./FileSystem";

package/lib/makes/index.js

@@ -14,6 +14,7 @@ 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("./AppConfig"), exports);
 __exportStar(require("./Config"), exports);
 __exportStar(require("./Container"), exports);
 __exportStar(require("./FileSystem"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,16 +1,11 @@
-import { Config } from "../makes";
-type TypeMap = {
-    [type: string]: string;
-};
+import { AppConfig } from "../makes";
 declare abstract class AppConfigService {
-    protected config?: Config;
-    abstract dataPath(...args: string[]): string;
-    abstract pluginsPath(...args: string[]): string;
+    protected config?: AppConfig;
     abstract getPWD(): string;
     abstract setPWD(pwd: string): void;
-    abstract getProjectTypes(): TypeMap;
-    abstract registerProjectType(name: string, title?: string): void;
-    protected abstract loadConfig(): Promise<Config>;
-    getConfig(): Promise<Config>;
+    abstract dataPath(...args: string[]): string;
+    abstract pluginsPath(...args: string[]): string;
+    getConfig(): AppConfig;
+    protected abstract loadConfig(): AppConfig;
 }
 export { AppConfigService };

package/lib/services/AppConfigService.js

@@ -5,26 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __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.AppConfigService = void 0;
 const decorators_1 = require("../decorators");
 let AppConfigService = class AppConfigService {
     getConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config) {
-                this.config = yield this.loadConfig();
-            }
-            return this.config;
-        });
+        if (!this.config) {
+            this.config = this.loadConfig();
+        }
+        return this.config;
     }
 };
 exports.AppConfigService = AppConfigService;

package/lib/services/LogService.d.ts

@@ -1,4 +1,5 @@
 export declare abstract class LogService {
+    abstract debug(...data: any[]): void;
     abstract log(...data: any[]): void;
     abstract info(...data: any[]): void;
     abstract warn(...data: any[]): void;

package/lib/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./AppConfig";
 export * from "./EnvConfig";
 export * from "./PickProperties";
 export * from "./Volume";

package/lib/types/index.js

@@ -14,7 +14,6 @@ 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("./AppConfig"), exports);
 __exportStar(require("./EnvConfig"), exports);
 __exportStar(require("./PickProperties"), exports);
 __exportStar(require("./Volume"), exports);

package/package.json

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

package/lib/types/AppConfig.d.ts

@@ -1,12 +0,0 @@
-import { EnvConfig } from "./EnvConfig";
-export type AppConfig = {
-    debug?: boolean;
-    meta: EnvConfig;
-    env: EnvConfig;
-    plugins: string[];
-    projects: {
-        id: string;
-        name?: string;
-        src: string;
-    }[];
-};

package/lib/types/AppConfig.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });