@wocker/core 1.1.0-beta.4 → 1.1.0-beta.6

package/lib/core/ApplicationContext.d.ts

@@ -8,4 +8,5 @@ export declare class ApplicationContext {
     constructor(module: Type, container: Container, options?: ApplicationOptions);
     get<TInput = any, TResult = TInput>(typeOrToken: InjectionToken<TInput>): TResult;
     run(args: string[]): Promise<string>;
+    protected process(args: string[]): Promise<string>;
 }

package/lib/core/ApplicationContext.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApplicationContext = void 0;
 const cli_1 = require("@kearisp/cli");
 const AsyncStorage_1 = require("./AsyncStorage");
+const EventService_1 = require("../services/EventService");
 const env_1 = require("../env");
 class ApplicationContext {
     constructor(module, container, options = {}) {
@@ -34,43 +35,53 @@ class ApplicationContext {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => {
                 AsyncStorage_1.AsyncStorage.run(this.container, () => {
-                    const cli = this.get(cli_1.Cli);
-                    cli.command("")
-                        .option("version", {
-                        type: "boolean",
-                        alias: "v"
-                    })
-                        .action((input) => {
-                        if (input.option("version")) {
-                            return env_1.WOCKER_VERSION;
+                    return resolve(this.process(args));
+                });
+            });
+        });
+    }
+    process(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cli = this.get(cli_1.Cli), eventService = this.get(EventService_1.EventService);
+            cli.command("")
+                .option("version", {
+                type: "boolean",
+                alias: "v"
+            })
+                .action((input) => {
+                if (input.option("version")) {
+                    return env_1.WOCKER_VERSION;
+                }
+                for (const [, module] of this.container.modules) {
+                    for (const [, container] of module.controllers) {
+                        if (!container.description) {
+                            continue;
                         }
-                        for (const [, module] of this.container.modules) {
-                            for (const [, container] of module.controllers) {
-                                if (!container.description) {
-                                    continue;
-                                }
-                                console.info(`${container.description}:`);
-                                const spaceLength = container.commands.reduce((space, route) => {
-                                    return route.commandNames.reduce((space, command) => {
-                                        return Math.max(space, command.length + 2);
-                                    }, space);
-                                }, 0);
-                                for (const route of container.commands) {
-                                    if (!route.description) {
-                                        continue;
-                                    }
-                                    for (const commandName of route.commandNames) {
-                                        const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
-                                        console.info(`  ${commandName} ${space} ${route.description}`);
-                                    }
-                                }
-                                console.info("");
+                        console.info(`${container.description}:`);
+                        const spaceLength = container.commands.reduce((space, route) => {
+                            return route.commandNames.reduce((space, command) => {
+                                return Math.max(space, command.length + 2);
+                            }, space);
+                        }, 0);
+                        for (const route of container.commands) {
+                            if (!route.description) {
+                                continue;
+                            }
+                            for (const commandName of route.commandNames) {
+                                const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
+                                console.info(`  ${commandName} ${space} ${route.description}`);
                             }
                         }
-                    });
-                    return resolve(cli.run(args));
-                });
+                        console.info("");
+                    }
+                }
             });
+            try {
+                return yield cli.run(args);
+            }
+            finally {
+                yield eventService.emit("finish");
+            }
         });
     }
 }

package/lib/core/CoreModule.js

@@ -5,21 +5,11 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreModule = void 0;
 const cli_1 = require("@kearisp/cli");
-const fs_1 = __importDefault(require("fs"));
 const decorators_1 = require("../decorators");
-const AppService_1 = require("../services/AppService");
-const AppConfigService_1 = require("../services/AppConfigService");
-const AppFileSystemService_1 = require("../services/AppFileSystemService");
-const ProcessService_1 = require("../services/ProcessService");
-const EventService_1 = require("../services/EventService");
-const LogService_1 = require("../services/LogService");
-const ProjectRepository_1 = require("../services/ProjectRepository");
+const services_1 = require("../services");
 const env_1 = require("../env");
 let CoreModule = class CoreModule {
 };
@@ -37,30 +27,26 @@ exports.CoreModule = CoreModule = __decorate([
                 provide: env_1.WOCKER_DATA_DIR_KEY,
                 useValue: env_1.WOCKER_DATA_DIR
             },
-            {
-                provide: env_1.FILE_SYSTEM_DRIVER_KEY,
-                useValue: fs_1.default
-            },
-            AppService_1.AppService,
-            AppConfigService_1.AppConfigService,
-            AppFileSystemService_1.AppFileSystemService,
-            ProjectRepository_1.ProjectRepository,
-            ProcessService_1.ProcessService,
-            EventService_1.EventService,
-            LogService_1.LogService
+            services_1.AppService,
+            services_1.AppConfigService,
+            services_1.AppFileSystemService,
+            services_1.ProjectRepository,
+            services_1.ProcessService,
+            services_1.EventService,
+            services_1.LogService
         ],
         exports: [
             cli_1.Cli,
             env_1.WOCKER_VERSION_KEY,
             env_1.WOCKER_DATA_DIR_KEY,
             env_1.FILE_SYSTEM_DRIVER_KEY,
-            AppService_1.AppService,
-            AppConfigService_1.AppConfigService,
-            AppFileSystemService_1.AppFileSystemService,
-            ProjectRepository_1.ProjectRepository,
-            ProcessService_1.ProcessService,
-            EventService_1.EventService,
-            LogService_1.LogService
+            services_1.AppService,
+            services_1.AppConfigService,
+            services_1.AppFileSystemService,
+            services_1.ProjectRepository,
+            services_1.ProcessService,
+            services_1.EventService,
+            services_1.LogService
         ]
     })
 ], CoreModule);

package/lib/core/Factory.d.ts

@@ -1,6 +1,5 @@
 import { ApplicationContext } from "./ApplicationContext";
-import { Type } from "../types";
-import { ApplicationOptions } from "../types/ApplicationOptions";
+import { ApplicationOptions, Type } from "../types";
 export declare class Factory {
     static create(module: Type, options?: ApplicationOptions): Promise<ApplicationContext>;
 }

package/lib/core/Factory.js

@@ -16,7 +16,7 @@ const Scanner_1 = require("./Scanner");
 class Factory {
     static create(module_1) {
         return __awaiter(this, arguments, void 0, function* (module, options = {}) {
-            const container = new Container_1.Container(), scanner = new Scanner_1.Scanner(container);
+            const container = new Container_1.Container(), scanner = new Scanner_1.Scanner(container, options);
             yield scanner.scan(module);
             return new ApplicationContext_1.ApplicationContext(module, container, options);
         });

package/lib/core/Route.js

@@ -11,7 +11,7 @@ class Route {
         this.commandNames = [];
         this.completions = [];
         const descriptor = Object.getOwnPropertyDescriptor(this.type.prototype, this.method);
-        if (!descriptor) {
+        if (!descriptor || !descriptor.value) {
             return;
         }
         this.description = Reflect.getMetadata(env_1.DESCRIPTION_METADATA, descriptor.value) || "";

package/lib/core/Scanner.d.ts

@@ -1,11 +1,11 @@
 import { Cli } from "@kearisp/cli";
-import { Type, DynamicModule, ProviderType } from "../types";
+import { Type, DynamicModule, ProviderType, ApplicationOptions } from "../types";
 import { Container } from "./Container";
 import { ControllerWrapper } from "./ControllerWrapper";
 import { ModuleWrapper } from "./ModuleWrapper";
 export declare class Scanner {
     readonly container: Container;
-    constructor(container?: Container);
+    constructor(container?: Container, options?: ApplicationOptions);
     scan(moduleDefinition: Type | DynamicModule): Promise<void>;
     protected getMetadata(moduleDefinition: Type | DynamicModule): DynamicModule;
     protected scanModule(moduleDefinition: Type | DynamicModule): ModuleWrapper;

package/lib/core/Scanner.js

@@ -8,21 +8,30 @@ 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.Scanner = void 0;
 const cli_1 = require("@kearisp/cli");
+const fs_1 = __importDefault(require("fs"));
 const Container_1 = require("./Container");
 const ModuleWrapper_1 = require("./ModuleWrapper");
 const CoreModule_1 = require("./CoreModule");
 const InstanceWrapper_1 = require("./InstanceWrapper");
 const env_1 = require("../env");
 class Scanner {
-    constructor(container) {
+    constructor(container, options = {}) {
+        const { fsDriver = fs_1.default } = options;
         this.container = container || new Container_1.Container();
         this.container.globalProviders.set("CORE_CONTAINER", new InstanceWrapper_1.InstanceWrapper(new ModuleWrapper_1.ModuleWrapper(this.container, null), {
             provide: "CORE_CONTAINER",
             useValue: this.container
         }));
+        this.container.globalProviders.set(env_1.FILE_SYSTEM_DRIVER_KEY, new InstanceWrapper_1.InstanceWrapper(new ModuleWrapper_1.ModuleWrapper(this.container, null), {
+            provide: env_1.FILE_SYSTEM_DRIVER_KEY,
+            useValue: fsDriver
+        }));
     }
     scan(moduleDefinition) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/makes/AppConfig.d.ts

@@ -13,6 +13,7 @@ export declare abstract class AppConfig {
     addPlugin(name: string, env?: PluginRef["env"]): void;
     removePlugin(name: string): void;
     getProject(name: string): ProjectRef | undefined;
+    getProjectByPath(path: string): ProjectRef | undefined;
     addProject(name: string, path: string): void;
     removeProject(name: string): void;
     registerPreset(name: string, source: PresetSource, path?: string): void;

package/lib/makes/AppConfig.js

@@ -61,6 +61,11 @@ class AppConfig {
             return projectData.name === name;
         });
     }
+    getProjectByPath(path) {
+        return this.projects.find((ref) => {
+            return ref.path === path;
+        });
+    }
     addProject(name, path) {
         let projectRef = this.getProject(name);
         if (!projectRef) {

package/lib/makes/JsonEditor.d.ts

@@ -1,16 +1,22 @@
 import { JSONPath, Node, ModificationOptions } from "jsonc-parser";
+type OrderMap = {
+    [key: string]: string[] | ((key: string, properties: string[]) => number);
+};
 export declare class JsonEditor<T extends object> {
     protected readonly original: string;
+    protected readonly orderMap: OrderMap;
     protected content: string;
     protected root: Node;
     state: T;
-    constructor(original: string);
+    constructor(original: string, orderMap?: OrderMap);
     protected createProxy(keys: JSONPath, options?: JsonEditor.CreateProxyOptions): any;
+    protected getInsertionIndex(path: JSONPath): ((properties: string[]) => number) | undefined;
     get(key: string | JSONPath): any;
     set(key: string | JSONPath, value: any, options?: ModificationOptions): void;
     unset(key: string | JSONPath): void;
     isDirty(): boolean;
     toString(): string;
+    static getNodeValue(node: Node): any;
 }
 export declare namespace JsonEditor {
     type CreateProxyOptions = {
@@ -18,3 +24,4 @@ export declare namespace JsonEditor {
         removeOnEmpty?: boolean;
     };
 }
+export {};

package/lib/makes/JsonEditor.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonEditor = void 0;
 const jsonc_parser_1 = require("jsonc-parser");
 class JsonEditor {
-    constructor(original) {
+    constructor(original, orderMap = {}) {
         this.original = original;
+        this.orderMap = orderMap;
         this.content = this.original;
         this.root = (0, jsonc_parser_1.parseTree)(this.content);
         this.state = this.createProxy([]);
@@ -21,12 +22,7 @@ class JsonEditor {
                     if (typeof target[property] === "function") {
                         return (...args) => {
                             const res = target[property](...args);
-                            this.set(keys, target, {
-                                formattingOptions: {
-                                    keepLines: false,
-                                    insertSpaces: true
-                                }
-                            });
+                            this.set(keys, target);
                             return res;
                         };
                     }
@@ -45,16 +41,11 @@ class JsonEditor {
                 if (Array.isArray(_)) {
                     property = parseInt(property);
                 }
-                this.set([...keys, property], value, {
-                    formattingOptions: {
-                        keepLines: false,
-                        insertSpaces: true
-                    }
-                });
+                this.set([...keys, property], value);
                 if (removeOnEmpty) {
                     const value = this.get(keys);
                     if (typeof value === "object" && Object.keys(value).length === 0) {
-                        this.set(keys, undefined);
+                        this.unset(keys);
                     }
                 }
                 return true;
@@ -66,33 +57,57 @@ class JsonEditor {
                 if (Array.isArray(_)) {
                     property = parseInt(property);
                 }
-                this.set([...keys, property], undefined);
+                this.unset([...keys, property]);
                 if (removeOnEmpty) {
                     const value = this.get(keys);
                     if (typeof value === "object" && Object.keys(value).length === 0) {
-                        this.set(keys, undefined);
+                        this.unset(keys);
                     }
                 }
                 return true;
             }
         });
     }
-    ;
+    getInsertionIndex(path) {
+        const key = path[path.length - 1], orderKey = path.slice(0, -1).join("."), ordered = this.orderMap[orderKey];
+        if (!ordered) {
+            return undefined;
+        }
+        return (properties) => {
+            if (typeof ordered === "function") {
+                return ordered(key, properties);
+            }
+            const keyIndex = ordered.indexOf(key);
+            if (keyIndex === -1) {
+                return properties.length;
+            }
+            let insertIndex = 0;
+            for (const property of properties) {
+                const propertyIndex = ordered.indexOf(property);
+                if (propertyIndex !== -1 && propertyIndex < keyIndex) {
+                    insertIndex++;
+                }
+            }
+            return insertIndex;
+        };
+    }
     get(key) {
         const path = typeof key === "string" ? key.split(".") : key;
         const node = (0, jsonc_parser_1.findNodeAtLocation)(this.root, path);
         if (!node) {
             return undefined;
         }
-        return (0, jsonc_parser_1.getNodeValue)(node);
+        return JsonEditor.getNodeValue(node);
     }
     set(key, value, options) {
         const path = typeof key === "string" ? key.split(".") : key;
         this.content = (0, jsonc_parser_1.applyEdits)(this.content, (0, jsonc_parser_1.modify)(this.content, path, value, options || {
             formattingOptions: {
                 insertSpaces: true,
-                keepLines: false
-            }
+                keepLines: false,
+                insertFinalNewline: true
+            },
+            getInsertionIndex: this.getInsertionIndex(path)
         }));
         this.root = (0, jsonc_parser_1.parseTree)(this.content);
     }
@@ -105,5 +120,31 @@ class JsonEditor {
     toString() {
         return this.content;
     }
+    static getNodeValue(node) {
+        var _a;
+        switch (node.type) {
+            case "array":
+                return (_a = node.children) === null || _a === void 0 ? void 0 : _a.map(jsonc_parser_1.getNodeValue);
+            case "object": {
+                const obj = Object.create({});
+                if (node.children) {
+                    for (let prop of node.children) {
+                        const [keyNode, valueNode] = prop.children || [];
+                        if (keyNode && valueNode) {
+                            obj[keyNode.value] = this.getNodeValue(valueNode);
+                        }
+                    }
+                }
+                return obj;
+            }
+            case "null":
+            case "string":
+            case "number":
+            case "boolean":
+                return node.value;
+            default:
+                return undefined;
+        }
+    }
 }
 exports.JsonEditor = JsonEditor;

package/lib/makes/PluginConfig.d.ts

@@ -0,0 +1,7 @@
+import { FileSystem } from "./FileSystem";
+export declare abstract class PluginConfig {
+    constructor(_data: any);
+    save(): void;
+    toObject(): any;
+    static make<C extends typeof PluginConfig>(fs: FileSystem, configPath?: string): InstanceType<C>;
+}

package/lib/makes/PluginConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginConfig = void 0;
+class PluginConfig {
+    constructor(_data) { }
+    save() {
+        throw new Error("Method not implemented");
+    }
+    toObject() {
+        throw new Error("Method not implemented");
+    }
+    static make(fs, configPath = "config.json") {
+        const data = fs.exists(configPath)
+            ? fs.readJSON(configPath)
+            : {};
+        return new class extends this {
+            constructor(data) {
+                super(data);
+            }
+            save() {
+                if (!fs.exists()) {
+                    fs.mkdir("", {
+                        recursive: true
+                    });
+                }
+                fs.writeJSON(configPath, this.toObject());
+            }
+        }(data);
+    }
+}
+exports.PluginConfig = PluginConfig;

package/lib/makes/Project.d.ts

@@ -1,20 +1,24 @@
 import { ProjectConfig } from "./ProjectConfig";
-import { EnvConfig, ProjectConfigScope, ProjectRef, ProjectType } from "../types";
+import { EnvConfig, ProjectConfigScope, ProjectRef, ProjectType, PresetMode } from "../types";
 export declare class Project {
     name: string;
     path: string;
-    readonly ref?: ProjectRef;
+    protected _ref?: ProjectRef;
     readonly configs: Record<ProjectConfigScope, ProjectConfig>;
     constructor(name: string, path: string);
+    get ref(): ProjectRef | undefined;
     get type(): ProjectType;
     set type(type: ProjectType);
     get containerName(): string;
     get scripts(): any;
     get preset(): string | undefined;
     set preset(preset: string | undefined);
-    get presetMode(): "project" | "global";
-    set presetMode(mode: "project" | "global");
+    get presetMode(): PresetMode;
+    set presetMode(mode: PresetMode);
+    get image(): string | undefined;
+    /** @deprecated */
     get imageName(): string | undefined;
+    /** @deprecated */
     set imageName(image: string | undefined);
     get dockerfile(): string | undefined;
     set dockerfile(dockerfile: string | undefined);
@@ -54,6 +58,9 @@ export declare class Project {
     get extraHosts(): any;
     addExtraHost(host: string, domain: string): void;
     removeExtraHost(host: string): void;
+    get metadata(): {
+        [x: string]: string;
+    };
     get services(): any;
     getSecret(key: string): Promise<string | undefined>;
     getSecret(key: string, byDefault: string): Promise<string>;

package/lib/makes/Project.js

@@ -20,12 +20,15 @@ class Project {
         this.name = name;
         this.path = path;
         const container = AsyncStorage_1.AsyncStorage.getContainer(), appService = container.get(AppService_1.AppService), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
-        this.ref = appService.getProject(this.name);
+        this._ref = appService.getProject(this.name);
         this.configs = {
-            [types_1.ProjectConfigScope.APP]: projectRepository.getConfig(this.name, types_1.ProjectConfigScope.APP),
-            [types_1.ProjectConfigScope.LOCAL]: projectRepository.getConfig(this.name, types_1.ProjectConfigScope.LOCAL)
+            [types_1.ProjectConfigScope.APP]: projectRepository.getConfig(types_1.ProjectConfigScope.APP, this.name, this.path),
+            [types_1.ProjectConfigScope.LOCAL]: projectRepository.getConfig(types_1.ProjectConfigScope.LOCAL, this.name, this.path)
         };
     }
+    get ref() {
+        return this._ref;
+    }
     get type() {
         return this.configs.app.type || this.configs.project.type;
     }
@@ -39,37 +42,42 @@ class Project {
         return Object.assign(Object.assign({}, this.configs.project.scripts), this.configs.app.scripts);
     }
     get preset() {
-        return this.configs.project.preset || this.configs.app.preset;
+        return this.configs.app.preset || this.configs.project.preset;
     }
     set preset(preset) {
         this.configs.app.preset = preset;
     }
     get presetMode() {
-        return this.configs.app.presetMode;
+        return this.configs.app.presetMode || this.configs.project.presetMode;
     }
     set presetMode(mode) {
         this.configs.app.presetMode = mode;
     }
+    get image() {
+        return this.configs.app.image || this.configs.project.image;
+    }
+    /** @deprecated */
     get imageName() {
         return this.configs.app.image || this.configs.project.image;
     }
+    /** @deprecated */
     set imageName(image) {
         this.configs.app.image = image;
     }
     get dockerfile() {
-        return this.configs.project.dockerfile || this.configs.app.dockerfile;
+        return this.configs.app.dockerfile || this.configs.project.dockerfile;
     }
     set dockerfile(dockerfile) {
         this.configs.app.dockerfile = dockerfile;
     }
     get composefile() {
-        return this.configs.project.composefile || this.configs.app.composefile;
+        return this.configs.app.composefile || this.configs.project.composefile;
     }
     set composefile(composefile) {
         this.configs.app.composefile = composefile;
     }
     get cmd() {
-        return this.configs.app.cmd;
+        return this.configs.app.cmd || this.configs.project.cmd;
     }
     get domains() {
         const host = this.getEnv("VIRTUAL_HOST");
@@ -200,6 +208,9 @@ class Project {
     removeExtraHost(host) {
         this.configs.app.removeExtraHost(host);
     }
+    get metadata() {
+        return Object.assign(Object.assign({}, this.configs.project.metadata), this.configs.app.metadata);
+    }
     get services() {
         return this.configs.app.services;
     }

package/lib/makes/ProjectConfig.d.ts

@@ -1,10 +1,9 @@
-import { FileSystem } from "./FileSystem";
-import { EnvConfig, ProjectType } from "../types";
 import { JsonEditor } from "./JsonEditor";
 import { ServiceConfig } from "./ServiceConfig";
+import { EnvConfig, ProjectType, ProjectConfigScope, PresetMode } from "../types";
 export declare class ProjectConfig extends JsonEditor<ProjectConfig.Data> {
-    readonly filename: string;
-    constructor(filename: string, content: string);
+    readonly _scope: ProjectConfigScope;
+    constructor(_scope: ProjectConfigScope, content: string);
     get type(): ProjectType | undefined;
     set type(type: ProjectType | undefined);
     get image(): string | undefined;
@@ -37,7 +36,7 @@ export declare class ProjectConfig extends JsonEditor<ProjectConfig.Data> {
     get ports(): string[];
     set ports(ports: string[]);
     setBuildArg(key: string, value: string, service?: string): void;
-    unsetBuildArg(name: string, service?: string): void;
+    unsetBuildArg(key: string, service?: string): void;
     getEnv(key: string): string | undefined;
     getEnv(key: string, byDefault: string): string;
     hasEnv(key: string): boolean;
@@ -51,7 +50,6 @@ export declare class ProjectConfig extends JsonEditor<ProjectConfig.Data> {
     removeExtraHost(host: string): void;
     addService(name: string, data: ServiceConfig.Data): void;
     service(name: string): any;
-    static make(fs: FileSystem, filename: string): ProjectConfig;
 }
 export declare namespace ProjectConfig {
     type Data = {
@@ -62,7 +60,7 @@ export declare namespace ProjectConfig {
         dockerfile?: string;
         composefile?: string;
         preset?: string;
-        presetMode?: "global" | "project";
+        presetMode?: PresetMode;
         scripts?: {
             [script: string]: string;
         };

package/lib/makes/ProjectConfig.js

@@ -4,9 +4,32 @@ exports.ProjectConfig = void 0;
 const volumeParse_1 = require("../utils/volumeParse");
 const JsonEditor_1 = require("./JsonEditor");
 class ProjectConfig extends JsonEditor_1.JsonEditor {
-    constructor(filename, content) {
-        super(content);
-        this.filename = filename;
+    constructor(_scope, content) {
+        super(content, {
+            "": [
+                // "version",
+                "type",
+                "image",
+                "dockerfile",
+                "composefile",
+                "preset",
+                "presetMode",
+                "scripts",
+                "cmd",
+                "buildArgs",
+                "env",
+                "metadata",
+                "volumes",
+                "ports",
+                "extraHosts",
+                "services"
+            ],
+            "env": [
+                "VIRTUAL_HOST",
+                "VIRTUAL_PORT"
+            ]
+        });
+        this._scope = _scope;
     }
     get type() {
         return this.state.type;
@@ -120,33 +143,17 @@ class ProjectConfig extends JsonEditor_1.JsonEditor {
     }
     setBuildArg(key, value, service) {
         if (service) {
-            // if(!this.services[service]) {
-            //     this.services[service] = {};
-            // }
-            //
-            // if(!this.services[service].buildArgs) {
-            //     this.services[service].buildArgs = {};
-            // }
-            //
-            // this.services[service].buildArgs[key] = value;
+            this.set(["services", service, "buildArgs", key], value);
             return;
         }
         this.buildArgs[key] = value;
     }
-    unsetBuildArg(name, service) {
+    unsetBuildArg(key, service) {
         if (service) {
-            // if(!this.services[service]) {
-            //     return;
-            // }
-            //
-            // if(this.services[service].buildArgs && name in this.services[service].buildArgs) {
-            //     delete this.services[service].buildArgs[name];
-            // }
+            this.unset(["services", service, "buildArgs", key]);
             return;
         }
-        if (name in this.buildArgs) {
-            delete this.buildArgs[name];
-        }
+        delete this.buildArgs[key];
     }
     getEnv(key, byDefault) {
         if (key in this.env) {
@@ -173,7 +180,9 @@ class ProjectConfig extends JsonEditor_1.JsonEditor {
             this.unset(["services", service, "env", key]);
             return;
         }
-        this.unset(["env", key]);
+        if (key in this.env) {
+            delete this.env[key];
+        }
     }
     getVolumeBySource(source) {
         return (this.state.volumes || []).find((volume) => {
@@ -232,12 +241,5 @@ class ProjectConfig extends JsonEditor_1.JsonEditor {
             removeOnEmpty: true
         });
     }
-    static make(fs, filename) {
-        let content = "{}";
-        if (fs.exists(filename)) {
-            content = fs.readFile(filename).toString();
-        }
-        return new ProjectConfig(filename, content);
-    }
 }
 exports.ProjectConfig = ProjectConfig;

package/lib/makes/index.d.ts

@@ -4,6 +4,7 @@ export * from "./ConfigCollection";
 export * from "./FileSystem";
 export * from "./FileSystemManager";
 export * from "./Logger";
+export * from "./PluginConfig";
 export * from "./Project";
 export * from "./Version";
 export * from "./VersionRange";

package/lib/makes/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./ConfigCollection"), exports);
 __exportStar(require("./FileSystem"), exports);
 __exportStar(require("./FileSystemManager"), exports);
 __exportStar(require("./Logger"), exports);
+__exportStar(require("./PluginConfig"), exports);
 __exportStar(require("./Project"), exports);
 __exportStar(require("./Version"), exports);
 __exportStar(require("./VersionRange"), exports);

package/lib/modules/plugin/services/PluginConfigService.d.ts

@@ -1,7 +1,7 @@
 import { WriteFileOptions, MakeDirectoryOptions, RmOptions, WriteStream, ReadStream } from "fs";
 import { FileSystemDriver } from "../../../types";
 import { AppConfigService } from "../../../services/AppConfigService";
-import { FileSystem } from "../../../makes";
+import { FileSystem, PluginConfig } from "../../../makes";
 export declare class PluginConfigService {
     protected readonly appConfigService: AppConfigService;
     protected readonly pluginDir: string;
@@ -9,6 +9,7 @@ export declare class PluginConfigService {
     protected _fs?: FileSystem;
     constructor(appConfigService: AppConfigService, pluginDir: string, driver: FileSystemDriver);
     get fs(): FileSystem;
+    getConfig<T extends typeof PluginConfig>(Config: T): InstanceType<T>;
     isVersionGTE(version: string): boolean;
     /** @deprecated */
     dataPath(...parts: string[]): string;

package/lib/modules/plugin/services/PluginConfigService.js

@@ -46,6 +46,9 @@ let PluginConfigService = class PluginConfigService {
         }
         return this._fs;
     }
+    getConfig(Config) {
+        return Config.make(this.fs);
+    }
     isVersionGTE(version) {
         if (!this.appConfigService.isVersionGTE) {
             return false;

package/lib/services/ProjectRepository.d.ts

@@ -8,7 +8,7 @@ export declare class ProjectRepository {
     protected readonly fs: AppFileSystemService;
     protected readonly driver: FileSystemDriver;
     constructor(appService: AppService, fs: AppFileSystemService, driver: FileSystemDriver);
-    getConfig(name: string, scope: ProjectConfigScope): ProjectConfig;
+    getConfig(scope: ProjectConfigScope, name: string, path?: string): ProjectConfig;
     getByName(name: string): Project;
     save(project: Project): void;
     search(params: ProjectRepository.SearchParams): Project[];

package/lib/services/ProjectRepository.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectRepository = void 0;
 const decorators_1 = require("../decorators");
 const makes_1 = require("../makes");
+// noinspection ES6PreferShortImport
 const Project_1 = require("../makes/Project");
 const ProjectConfig_1 = require("../makes/ProjectConfig");
 const AppService_1 = require("./AppService");
@@ -27,16 +28,29 @@ let ProjectRepository = class ProjectRepository {
         this.fs = fs;
         this.driver = driver;
     }
-    getConfig(name, scope) {
+    getConfig(scope, name, path) {
         const ref = this.appService.getProject(name);
-        if (!ref) {
-            throw new Error("");
-        }
         switch (scope) {
-            case types_1.ProjectConfigScope.APP:
-                return ProjectConfig_1.ProjectConfig.make(this.fs.cd(`projects/${ref.name}`), "config.json");
+            case types_1.ProjectConfigScope.APP: {
+                if (!ref) {
+                    return new ProjectConfig_1.ProjectConfig(scope, "{}");
+                }
+                const fs = this.fs.cd(`projects/${ref.name}`);
+                if (!fs.exists("config.json")) {
+                    return new ProjectConfig_1.ProjectConfig(scope, "{}");
+                }
+                return new ProjectConfig_1.ProjectConfig(scope, fs.readFile("config.json").toString());
+            }
             case types_1.ProjectConfigScope.LOCAL:
-                return ProjectConfig_1.ProjectConfig.make(new makes_1.FileSystem(ref.path, this.driver), "wocker.config.json");
+                path = path || (ref === null || ref === void 0 ? void 0 : ref.path);
+                if (!path) {
+                    return new ProjectConfig_1.ProjectConfig(scope, "{}");
+                }
+                const fs = new makes_1.FileSystem(path);
+                if (!fs.exists("wocker.config.json")) {
+                    return new ProjectConfig_1.ProjectConfig(scope, "{}");
+                }
+                return new ProjectConfig_1.ProjectConfig(scope, fs.readFile("wocker.config.json").toString());
         }
     }
     getByName(name) {

package/lib/types/ApplicationOptions.d.ts

@@ -1 +1,4 @@
-export type ApplicationOptions = {};
+import { FileSystemDriver } from "./FileSystemDriver";
+export type ApplicationOptions = {
+    fsDriver?: FileSystemDriver;
+};

package/lib/types/FileSystemDriver.d.ts

@@ -9,7 +9,7 @@ export interface FileSystemDriver {
     fstatSync(fd: number): FS.Stats;
     mkdirSync(path: string, options?: FS.MakeDirectoryOptions): void;
     readdir(path: string, options: any, callback: (err: NodeJS.ErrnoException | null, files: string[]) => void): void;
-    readdirSync(path: string, options?: any): (string | Buffer)[] | Dirent[] | Dirent<Buffer>[];
+    readdirSync(path: string, options?: any): (string | Buffer<ArrayBufferLike>)[] | Dirent[] | Dirent<Buffer>[];
     readFileSync(path: string): string | Buffer;
     writeFileSync(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: FS.WriteFileOptions): void;
     appendFileSync(path: FS.PathOrFileDescriptor, data: string | Uint8Array, options?: FS.WriteFileOptions): void;

package/lib/types/PresetMode.d.ts

@@ -0,0 +1,14 @@
+declare enum PresetModeEnum {
+    PROJECT = "project",
+    GLOBAL = "global"
+}
+export type PresetMode = PresetModeEnum;
+export declare const PresetMode: typeof PresetModeEnum & {
+    values: () => PresetModeEnum[];
+    options: () => {
+        label: string;
+        value: PresetModeEnum;
+    }[];
+    label: (mode: PresetModeEnum) => string;
+};
+export {};

package/lib/types/PresetMode.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetMode = void 0;
+var PresetModeEnum;
+(function (PresetModeEnum) {
+    PresetModeEnum["PROJECT"] = "project";
+    PresetModeEnum["GLOBAL"] = "global";
+})(PresetModeEnum || (PresetModeEnum = {}));
+exports.PresetMode = Object.assign({}, PresetModeEnum, {
+    values: () => {
+        return Object.values(PresetModeEnum);
+    },
+    options: () => {
+        return exports.PresetMode.values().map((mode) => {
+            return {
+                label: exports.PresetMode.label(mode),
+                value: mode
+            };
+        });
+    },
+    label: (mode) => {
+        switch (mode) {
+            case PresetModeEnum.PROJECT:
+                return "For project only";
+            case PresetModeEnum.GLOBAL:
+                return "Global usage";
+            default:
+                throw new Error(`Unsupported mode "${mode}"`);
+        }
+    }
+});

package/lib/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./ApplicationOptions";
 export * from "./DynamicModule";
 export * from "./EnvConfig";
 export * from "./FileSystemDriver";
@@ -10,6 +11,7 @@ export * from "./PluginMetadata";
 export * from "./ProjectConfigScope";
 export * from "./PluginRef";
 export * from "./PresetRef";
+export * from "./PresetMode";
 export * from "./PresetSource";
 export * from "./ProviderType";
 export * from "./ProjectRef";
@@ -21,8 +23,3 @@ export type {
  * @deprecated
  */
 ModuleMetadata as ModuleConfig } from "./ModuleMetadata";
-export type { 
-/**
- * @deprecated
- */
-PluginMetadata as PluginConfig } from "./PluginMetadata";

package/lib/types/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("./ApplicationOptions"), exports);
 __exportStar(require("./DynamicModule"), exports);
 __exportStar(require("./EnvConfig"), exports);
 __exportStar(require("./FileSystemDriver"), exports);
@@ -26,6 +27,7 @@ __exportStar(require("./PluginMetadata"), exports);
 __exportStar(require("./ProjectConfigScope"), exports);
 __exportStar(require("./PluginRef"), exports);
 __exportStar(require("./PresetRef"), exports);
+__exportStar(require("./PresetMode"), exports);
 __exportStar(require("./PresetSource"), exports);
 __exportStar(require("./ProviderType"), exports);
 __exportStar(require("./ProjectRef"), exports);

package/package.json

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