@wocker/core 1.1.0-beta.1 → 1.1.0-beta.2

package/lib/makes/AppConfig.d.ts

@@ -1,27 +1,15 @@
-import { EnvConfig, PackageManagerType, PluginRef, PresetRef, ProjectRef, ProjectOldRef, PresetSource } from "../types";
 import { FileSystem } from "./FileSystem";
-export type AppConfigProperties = {
-    debug?: boolean;
-    pm?: PackageManagerType;
-    keystore?: string;
-    logLevel?: "off" | "info" | "warn" | "error";
-    plugins?: PluginRef[];
-    presets?: PresetRef[];
-    projects?: ProjectOldRef[];
-    meta?: EnvConfig;
-    env?: EnvConfig;
-};
+import { EnvConfig, PackageManagerType, PluginRef, PresetRef, ProjectRef, ProjectOldRef, PresetSource } from "../types";
 export declare abstract class AppConfig {
     debug?: boolean;
     pm?: PackageManagerType;
     keystore?: string;
-    logLevel: "off" | "info" | "warn" | "error";
     plugins: PluginRef[];
     presets: PresetRef[];
     projects: ProjectRef[];
     meta?: EnvConfig;
     env?: EnvConfig;
-    constructor(data: AppConfigProperties);
+    constructor(data: AppConfig.Data);
     addPlugin(name: string, env?: PluginRef["env"]): void;
     removePlugin(name: string): void;
     getProject(name: string): ProjectRef | undefined;
@@ -39,7 +27,19 @@ export declare abstract class AppConfig {
     setEnv(name: string, value: string): void;
     unsetEnv(name: string): void;
     abstract save(): void;
-    toObject(): AppConfigProperties;
+    toObject(): AppConfig.Data;
     toJsString(): string;
     static make(fs: FileSystem): AppConfig;
 }
+export declare namespace AppConfig {
+    type Data = {
+        debug?: boolean;
+        pm?: PackageManagerType;
+        keystore?: string;
+        plugins?: PluginRef[];
+        presets?: PresetRef[];
+        projects?: ProjectOldRef[];
+        meta?: EnvConfig;
+        env?: EnvConfig;
+    };
+}

package/lib/makes/AppConfig.js

@@ -15,7 +15,6 @@ exports.AppConfig = void 0;
 const types_1 = require("../types");
 class AppConfig {
     constructor(data) {
-        this.logLevel = "off";
         const { plugins = [], presets = [], projects = [] } = data, rest = __rest(data, ["plugins", "presets", "projects"]);
         Object.assign(this, rest);
         this.plugins = plugins.map((plugin) => {
@@ -167,7 +166,6 @@ class AppConfig {
         return {
             debug: this.debug,
             pm: this.pm,
-            logLevel: this.logLevel,
             keystore: this.keystore,
             plugins: this.plugins.length > 0 ? this.plugins : undefined,
             presets: this.presets.length > 0 ? this.presets : undefined,

package/lib/modules/project/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./makes/Project";
+export * from "./makes/ProjectConfig";
 export * from "./repositories/ProjectRepository";
 export * from "./services/ProjectService";
 export { ServiceProperties } from "./types";

package/lib/modules/project/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./makes/Project"), exports);
+__exportStar(require("./makes/ProjectConfig"), exports);
 __exportStar(require("./repositories/ProjectRepository"), exports);
 __exportStar(require("./services/ProjectService"), exports);

package/lib/modules/project/makes/Project.d.ts

@@ -1,59 +1,68 @@
 import { EnvConfig, ProjectType } from "../../../types";
-import { ServiceProperties, ProjectV1 } from "../types";
+import { ProjectConfigScope } from "../types";
+import { ProjectConfig } from "./ProjectConfig";
 export declare class Project {
-    /** @deprecated */
-    id?: string;
     name: string;
-    type: ProjectType;
     path: string;
-    cmd?: string[];
-    imageName?: string;
-    dockerfile?: string;
-    composefile?: string;
-    preset?: string;
-    presetMode?: "global" | "project";
-    scripts?: {
-        [script: string]: string;
-    };
-    services: {
-        [name: string]: ServiceProperties;
-    };
-    buildArgs: EnvConfig;
-    env: EnvConfig;
-    metadata: EnvConfig;
-    ports: string[];
-    extraHosts: EnvConfig;
-    volumes: string[];
-    constructor(data: ProjectV1);
+    protected configs: Record<ProjectConfigScope, ProjectConfig>;
+    constructor(name: string, path: string);
+    protected getConfig(scope: ProjectConfigScope): ProjectConfig;
+    get type(): ProjectType;
+    set type(type: ProjectType);
     get containerName(): string;
+    get scripts(): {
+        [x: string]: string;
+    };
+    get preset(): string | undefined;
+    set preset(preset: string | undefined);
+    get presetMode(): "project" | "global";
+    set presetMode(mode: "project" | "global");
+    get imageName(): string | undefined;
+    set imageName(image: string | undefined);
+    get dockerfile(): string | undefined;
+    set dockerfile(dockerfile: string | undefined);
+    get composefile(): string | undefined;
+    set composefile(composefile: string | undefined);
+    get cmd(): string[] | undefined;
     get domains(): string[];
     hasDomain(domain: string): boolean;
     addDomain(addDomain: string): void;
     removeDomain(removeDomain: string): void;
     clearDomains(): void;
+    get volumes(): string[];
+    get ports(): string[];
+    set ports(ports: string[]);
     linkPort(hostPort: number, containerPort: number): void;
     unlinkPort(hostPort: number, containerPort: number): void;
+    get buildArgs(): EnvConfig;
+    set buildArgs(buildArgs: EnvConfig);
     setBuildArg(name: string, value: string, service?: string): void;
     unsetBuildArg(name: string, service?: string): void;
+    get env(): EnvConfig;
+    set env(env: EnvConfig);
     hasEnv(name: string): boolean;
     getEnv(key: string): string | undefined;
     getEnv(key: string, byDefault: string): string;
-    setEnv(name: string, value: string | boolean, service?: string): void;
-    unsetEnv(name: string, service?: string): void;
-    hasMeta(name: string): boolean;
-    getMeta<D = string | undefined>(name: string, defaultValue?: D): D;
+    setEnv(key: string, value: string | boolean, service?: string): void;
+    unsetEnv(key: string, service?: string): void;
+    hasMeta(key: string): boolean;
+    getMeta(key: string): string | undefined;
+    getMeta(key: string, byDefault: string): string;
     setMeta(name: string, value: string | boolean): void;
     unsetMeta(name: string): void;
     getVolumeBySource(source: string): string | undefined;
     getVolumeByDestination(destination: string): string | undefined;
     volumeMount(...volumes: string[]): void;
     volumeUnmount(...volumes: string[]): void;
+    get extraHosts(): {
+        [x: string]: string;
+    };
     addExtraHost(host: string, domain: string): void;
     removeExtraHost(host: string): void;
+    get services(): Record<string, import("../types").ServiceProperties>;
     getSecret(key: string): Promise<string | undefined>;
     getSecret(key: string, byDefault: string): Promise<string>;
     setSecret(key: string, value: string): Promise<void>;
     unsetSecret(key: string): Promise<void>;
     save(): void;
-    toObject(): ProjectV1;
 }

package/lib/modules/project/makes/Project.js

@@ -8,38 +8,71 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Project = void 0;
 const AsyncStorage_1 = require("../../../core/AsyncStorage");
+const AppService_1 = require("../../../services/AppService");
 const volumeParse_1 = require("../../../utils/volumeParse");
 const ProjectRepository_1 = require("../repositories/ProjectRepository");
+const types_1 = require("../types");
 class Project {
-    constructor(data) {
-        const { name, services = {}, buildArgs = {}, env = {}, metadata = {}, ports = [], extraHosts = {}, volumes = [] } = data, rest = __rest(data, ["name", "services", "buildArgs", "env", "metadata", "ports", "extraHosts", "volumes"]);
-        this.id = this.name = name;
-        this.services = services;
-        this.buildArgs = buildArgs;
-        this.env = env;
-        this.metadata = metadata;
-        this.ports = ports;
-        this.extraHosts = extraHosts;
-        this.volumes = volumes;
-        Object.assign(this, rest);
+    constructor(name, path) {
+        this.name = name;
+        this.path = path;
+        this.configs = {
+            [types_1.ProjectConfigScope.APP]: this.getConfig(types_1.ProjectConfigScope.APP),
+            [types_1.ProjectConfigScope.LOCAL]: this.getConfig(types_1.ProjectConfigScope.LOCAL)
+        };
+    }
+    getConfig(scope) {
+        const container = AsyncStorage_1.AsyncStorage.getContainer(), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
+        return projectRepository.getConfig(this.name, scope);
+    }
+    get type() {
+        return this.configs.app.type || this.configs.project.type;
+    }
+    set type(type) {
+        this.configs.app.type = type;
     }
     get containerName() {
         return `${this.name}.workspace`;
     }
+    get scripts() {
+        return Object.assign(Object.assign({}, this.configs.project.scripts), this.configs.app.scripts);
+    }
+    get preset() {
+        return this.configs.app.preset;
+    }
+    set preset(preset) {
+        this.configs.app.preset = preset;
+    }
+    get presetMode() {
+        return this.configs.app.presetMode;
+    }
+    set presetMode(mode) {
+        this.configs.app.presetMode = mode;
+    }
+    get imageName() {
+        return this.configs.app.image;
+    }
+    set imageName(image) {
+        this.configs.app.image = image;
+    }
+    get dockerfile() {
+        return this.configs.project.dockerfile || this.configs.app.dockerfile;
+    }
+    set dockerfile(dockerfile) {
+        this.configs.app.dockerfile = dockerfile;
+    }
+    get composefile() {
+        return this.configs.project.composefile || this.configs.app.composefile;
+    }
+    set composefile(composefile) {
+        this.configs.app.composefile = composefile;
+    }
+    get cmd() {
+        return this.configs.app.cmd;
+    }
     get domains() {
         const host = this.getEnv("VIRTUAL_HOST");
         if (!host) {
@@ -71,169 +104,116 @@ class Project {
     clearDomains() {
         this.unsetEnv("VIRTUAL_HOST");
     }
+    get volumes() {
+        return [
+            ...this.configs.project.volumes.filter((volume) => {
+                return !this.configs.app.getVolumeByDestination((0, volumeParse_1.volumeParse)(volume).destination);
+            }),
+            ...this.configs.app.volumes
+        ];
+    }
+    get ports() {
+        return [
+            ...this.configs.project.ports,
+            ...this.configs.app.ports
+        ];
+    }
+    set ports(ports) {
+        this.configs.app.ports = ports;
+    }
     linkPort(hostPort, containerPort) {
-        this.ports = [
-            ...this.ports.filter((link) => {
+        this.configs.app.ports = [
+            ...this.configs.app.ports.filter((link) => {
                 return link !== `${hostPort}:${containerPort}`;
             }),
             `${hostPort}:${containerPort}`
         ];
     }
     unlinkPort(hostPort, containerPort) {
-        if (!this.ports) {
-            return;
-        }
-        this.ports = this.ports.filter((link) => {
+        this.configs.app.ports = this.configs.app.ports.filter((link) => {
             return link !== `${hostPort}:${containerPort}`;
         });
     }
+    get buildArgs() {
+        return Object.assign(Object.assign({}, this.configs.project.buildArgs), this.configs.app.buildArgs);
+    }
+    set buildArgs(buildArgs) {
+        this.configs.app.buildArgs = buildArgs;
+    }
     setBuildArg(name, value, service) {
         if (service) {
-            if (!this.services[service]) {
+            if (!this.configs.app.services[service]) {
                 throw new Error(`Service "${service}" not found`);
             }
-            if (!this.services[service].buildArgs) {
-                this.services[service].buildArgs = {};
+            if (!this.configs.app.services[service].buildArgs) {
+                this.configs.app.services[service].buildArgs = {};
             }
-            this.services[service].buildArgs[name] = value;
+            this.configs.app.services[service].buildArgs[name] = value;
             return;
         }
-        this.buildArgs[name] = value;
+        this.configs.app.buildArgs[name] = value;
     }
     unsetBuildArg(name, service) {
-        if (service) {
-            if (!this.services[service]) {
-                throw new Error(`Service "${service}" not found`);
-            }
-            if (this.services[service].buildArgs && name in this.services[service].buildArgs) {
-                delete this.services[service].buildArgs[name];
-                if (Object.keys(this.services[service].buildArgs).length === 0) {
-                    delete this.services[service].buildArgs;
-                }
-            }
-            return;
-        }
-        if (name in this.buildArgs) {
-            delete this.buildArgs[name];
-        }
+        this.configs.app.unsetBuildArg(name, service);
+    }
+    get env() {
+        return Object.assign(Object.assign({}, this.configs.project.env), this.configs.app.env);
+    }
+    set env(env) {
+        this.configs.app.env = env;
     }
     hasEnv(name) {
-        if (!this.env) {
-            return false;
-        }
-        return this.env.hasOwnProperty(name);
+        return this.configs.app.hasEnv(name) || this.configs.project.hasEnv(name);
     }
-    getEnv(name, defaultValue) {
-        const { [name]: value = defaultValue } = this.env || {};
-        return value;
+    getEnv(key, byDefault) {
+        return this.configs.app.env[key] || this.configs.project.env[key] || byDefault;
     }
-    setEnv(name, value, service) {
-        if (!this.env) {
-            this.env = {};
-        }
-        if (service) {
-            if (!this.services[service]) {
-                throw new Error(`Service "${service}" not found`);
-            }
-            if (!this.services[service].env) {
-                this.services[service].env = {};
-            }
-            this.services[service].env[name] = typeof value === "boolean"
-                ? (value ? "true" : "false")
-                : value;
-            return;
-        }
-        this.env[name] = typeof value === "boolean"
-            ? (value ? "true" : "false")
-            : value;
+    setEnv(key, value, service) {
+        this.configs.app.setEnv(key, value, service);
     }
-    unsetEnv(name, service) {
-        if (service) {
-            if (!this.services[service]) {
-                throw new Error(`Service "${service}" not found`);
-            }
-            if (this.services[service].env && name in this.services[service].env) {
-                delete this.services[service].env[name];
-                if (Object.keys(this.services[service].env).length === 0) {
-                    delete this.services[service].env;
-                }
-            }
-            return;
-        }
-        if (name in this.env) {
-            delete this.env[name];
-        }
+    unsetEnv(key, service) {
+        this.configs.app.unsetEnv(key, service);
     }
-    hasMeta(name) {
-        return !!this.metadata && this.metadata.hasOwnProperty(name);
+    hasMeta(key) {
+        return this.configs.app.metadata.hasOwnProperty(key) || this.configs.project.metadata.hasOwnProperty(key);
     }
-    getMeta(name, defaultValue) {
-        const { [name]: value = defaultValue } = this.metadata || {};
-        return value;
+    getMeta(key, byDefault) {
+        return this.configs.app.metadata[key] || this.configs.project.metadata[key] || byDefault;
     }
     setMeta(name, value) {
-        if (!this.metadata) {
-            this.metadata = {};
-        }
-        this.metadata[name] = typeof value === "boolean"
+        this.configs.app.metadata[name] = typeof value === "boolean"
             ? (value ? "true" : "false")
             : value;
     }
     unsetMeta(name) {
-        if (name in this.metadata) {
-            delete this.metadata[name];
+        if (name in this.configs.app.metadata) {
+            delete this.configs.app.metadata[name];
         }
     }
     getVolumeBySource(source) {
-        return (this.volumes || []).find((volume) => {
-            return (0, volumeParse_1.volumeParse)(volume).source === source;
-        });
+        return this.configs.project.getVolumeBySource(source) || this.configs.app.getVolumeBySource(source);
     }
     getVolumeByDestination(destination) {
-        return (this.volumes || []).find((volume) => {
-            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
-        });
+        return this.configs.project.getVolumeByDestination(destination) || this.configs.app.getVolumeByDestination(destination);
     }
     volumeMount(...volumes) {
-        if (volumes.length === 0) {
-            return;
-        }
-        const [volume, ...restVolumes] = volumes;
-        const { destination } = (0, volumeParse_1.volumeParse)(volume);
-        this.volumes = [
-            ...(this.volumes || []).filter((v) => {
-                return v !== this.getVolumeByDestination(destination);
-            }),
-            volume
-        ];
-        this.volumeMount(...restVolumes);
+        this.configs.app.volumeMount(...volumes);
     }
     volumeUnmount(...volumes) {
-        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) {
-            return;
-        }
-        this.volumeUnmount(...restVolumes);
+        this.configs.app.volumeUnmount(...volumes);
+    }
+    get extraHosts() {
+        return Object.assign(Object.assign({}, this.configs.project.extraHosts), this.configs.app.extraHosts);
     }
+    ;
     addExtraHost(host, domain) {
-        if (!this.extraHosts) {
-            this.extraHosts = {};
-        }
-        this.extraHosts[host] = domain;
+        this.configs.app.addExtraHost(host, domain);
     }
     removeExtraHost(host) {
-        if (!this.extraHosts || !this.extraHosts[host]) {
-            return;
-        }
-        delete this.extraHosts[host];
+        this.configs.app.removeExtraHost(host);
+    }
+    get services() {
+        return this.configs.app.services;
     }
     getSecret(key, byDefault) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -254,29 +234,13 @@ class Project {
         });
     }
     save() {
-        const container = AsyncStorage_1.AsyncStorage.getContainer(), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
-        projectRepository.save(this);
-    }
-    toObject() {
-        return {
-            name: this.name,
-            type: this.type,
-            path: this.path,
-            imageName: this.imageName,
-            dockerfile: this.dockerfile,
-            composefile: this.composefile,
-            preset: this.preset,
-            presetMode: this.presetMode,
-            cmd: this.cmd,
-            scripts: this.scripts,
-            services: Object.keys(this.services).length > 0 ? this.services : undefined,
-            buildArgs: Object.keys(this.buildArgs).length > 0 ? this.buildArgs : undefined,
-            env: Object.keys(this.env).length > 0 ? this.env : undefined,
-            metadata: Object.keys(this.metadata).length > 0 ? this.metadata : undefined,
-            ports: this.ports.length > 0 ? this.ports : undefined,
-            extraHosts: Object.keys(this.extraHosts).length ? this.extraHosts : undefined,
-            volumes: this.volumes.length > 0 ? this.volumes : undefined,
-        };
+        const container = AsyncStorage_1.AsyncStorage.getContainer(), appService = container.get(AppService_1.AppService), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
+        appService.addProject(this.name, this.path);
+        this.configs.app.save();
+        // const container = AsyncStorage.getContainer(),
+        //       projectRepository = container.get(ProjectRepository);
+        //
+        // projectRepository.save(this);
     }
 }
 exports.Project = Project;

package/lib/modules/project/makes/ProjectConfig.d.ts

@@ -0,0 +1,61 @@
+import { FileSystem } from "../../../makes";
+import { EnvConfig, ProjectType } from "../../../types";
+import { ServiceProperties } from "../types";
+export declare abstract class ProjectConfig {
+    type?: ProjectType;
+    image?: string;
+    dockerfile?: string;
+    composefile?: string;
+    preset?: string;
+    presetMode?: "global" | "project";
+    scripts: {
+        [script: string]: string;
+    };
+    cmd?: string[];
+    buildArgs: EnvConfig;
+    env: EnvConfig;
+    metadata: EnvConfig;
+    ports: string[];
+    volumes: string[];
+    extraHosts: EnvConfig;
+    services: Record<string, ServiceProperties>;
+    constructor(data: ProjectConfig.Data);
+    unsetBuildArg(name: string, service?: string): void;
+    getEnv(key: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
+    hasEnv(key: string): boolean;
+    setEnv(key: string, value: string | boolean, service?: string): void;
+    unsetEnv(key: string, service?: string): void;
+    abstract save(): void;
+    getVolumeBySource(source: string): string | undefined;
+    getVolumeByDestination(destination: string): string | undefined;
+    volumeMount(...volumes: string[]): void;
+    volumeUnmount(...volumes: string[]): void;
+    addExtraHost(host: string, domain: string): void;
+    removeExtraHost(host: string): void;
+    toObject(): ProjectConfig.Data;
+    static make(fs: FileSystem, filename: string): ProjectConfig;
+}
+export declare namespace ProjectConfig {
+    type Data = {
+        type?: ProjectType;
+        image?: string;
+        /** @deprecated */
+        imageName?: string;
+        dockerfile?: string;
+        composefile?: string;
+        preset?: string;
+        presetMode?: "global" | "project";
+        scripts?: {
+            [script: string]: string;
+        };
+        cmd?: string[];
+        buildArgs?: EnvConfig;
+        env?: EnvConfig;
+        metadata?: EnvConfig;
+        volumes?: string[];
+        ports?: string[];
+        extraHosts?: EnvConfig;
+        services?: Record<string, ServiceProperties>;
+    };
+}

package/lib/modules/project/makes/ProjectConfig.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectConfig = void 0;
+const volumeParse_1 = require("../../../utils/volumeParse");
+class ProjectConfig {
+    constructor(data) {
+        const { type, imageName, image = imageName, dockerfile, composefile, preset, presetMode, scripts = {}, cmd, buildArgs = {}, env = {}, metadata = {}, volumes = [], ports = [], extraHosts = {}, services = {} } = data;
+        this.type = type;
+        this.image = image;
+        this.dockerfile = dockerfile;
+        this.composefile = composefile;
+        this.preset = preset;
+        this.presetMode = presetMode;
+        this.scripts = scripts;
+        this.cmd = cmd;
+        this.buildArgs = buildArgs;
+        this.env = env;
+        this.metadata = metadata;
+        this.volumes = volumes;
+        this.ports = ports;
+        this.extraHosts = extraHosts;
+        this.services = services;
+    }
+    unsetBuildArg(name, 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];
+            }
+            return;
+        }
+        if (name in this.buildArgs) {
+            delete this.buildArgs[name];
+        }
+    }
+    getEnv(key, byDefault) {
+        if (key in this.env) {
+            return this.env[key];
+        }
+        return byDefault;
+    }
+    hasEnv(key) {
+        return this.env.hasOwnProperty(key);
+    }
+    setEnv(key, value, service) {
+        const sValue = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
+        if (service) {
+            if (!this.services[service]) {
+                return;
+            }
+            if (!this.services[service].env) {
+                this.services[service].env = {};
+            }
+            this.services[service].env[key] = sValue;
+            return;
+        }
+        this.env[key] = sValue;
+    }
+    unsetEnv(key, service) {
+        if (service) {
+            if (!this.services[service]) {
+                throw new Error(`Service "${service}" not found`);
+            }
+            if (this.services[service].env && key in this.services[service].env) {
+                delete this.services[service].env[key];
+                if (Object.keys(this.services[service].env).length === 0) {
+                    delete this.services[service].env;
+                }
+            }
+            return;
+        }
+        if (key in this.env) {
+            delete this.env[key];
+        }
+    }
+    getVolumeBySource(source) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
+        });
+    }
+    volumeMount(...volumes) {
+        if (volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const { destination } = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = [
+            ...(this.volumes || []).filter((v) => {
+                return v !== this.getVolumeByDestination(destination);
+            }),
+            volume
+        ];
+        this.volumeMount(...restVolumes);
+    }
+    volumeUnmount(...volumes) {
+        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) {
+            return;
+        }
+        this.volumeUnmount(...restVolumes);
+    }
+    addExtraHost(host, domain) {
+        this.extraHosts[host] = domain;
+    }
+    removeExtraHost(host) {
+        if (host in this.extraHosts) {
+            delete this.extraHosts[host];
+        }
+    }
+    toObject() {
+        return {
+            type: this.type,
+            image: this.image,
+            dockerfile: this.dockerfile,
+            composefile: this.composefile,
+            preset: this.preset,
+            presetMode: this.presetMode,
+            scripts: Object.keys(this.scripts).length > 0 ? this.scripts : undefined,
+            cmd: this.cmd,
+            buildArgs: Object.keys(this.buildArgs).length > 0 ? this.buildArgs : undefined,
+            env: Object.keys(this.env).length > 0 ? this.env : undefined,
+            metadata: Object.keys(this.metadata).length > 0 ? this.metadata : undefined,
+            volumes: this.volumes.length > 0 ? this.volumes : undefined,
+            ports: this.ports.length > 0 ? this.ports : undefined,
+        };
+    }
+    static make(fs, filename) {
+        let data = {};
+        if (fs.exists(filename)) {
+            data = fs.readJSON(filename);
+        }
+        return new class extends ProjectConfig {
+            constructor(data) {
+                super(data);
+            }
+            save() {
+                if (!fs.exists()) {
+                    fs.mkdir("", {
+                        recursive: true
+                    });
+                }
+                fs.writeJSON(filename, this.toObject());
+            }
+        }(data);
+    }
+}
+exports.ProjectConfig = ProjectConfig;

package/lib/modules/project/makes/ServiceConfig.d.ts

@@ -0,0 +1,2 @@
+export declare class ServiceConfig {
+}

package/lib/modules/project/makes/ServiceConfig.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceConfig = void 0;
+class ServiceConfig {
+}
+exports.ServiceConfig = ServiceConfig;

package/lib/modules/project/repositories/ProjectRepository.d.ts

@@ -1,9 +1,18 @@
 import { Project } from "../makes/Project";
-export declare abstract class ProjectRepository {
-    abstract getByName(name: string): Project;
-    abstract save(project: Project): void;
-    abstract search(params: ProjectRepository.SearchParams): Project[];
-    abstract searchOne(params: ProjectRepository.SearchParams): Project;
+import { ProjectConfig } from "../makes/ProjectConfig";
+import { AppFileSystemService, AppService } from "../../../services";
+import { FileSystemDriver } from "../../../types";
+import { ProjectConfigScope } from "../types";
+export declare class ProjectRepository {
+    protected readonly appService: AppService;
+    protected readonly fs: AppFileSystemService;
+    protected readonly driver: FileSystemDriver;
+    constructor(appService: AppService, fs: AppFileSystemService, driver: FileSystemDriver);
+    getConfig(name: string, scope: ProjectConfigScope): ProjectConfig;
+    getByName(name: string): Project;
+    save(project: Project): void;
+    search(params: ProjectRepository.SearchParams): Project[];
+    searchOne(params: ProjectRepository.SearchParams): Project | null;
 }
 export declare namespace ProjectRepository {
     type SearchParams = Partial<{

package/lib/modules/project/repositories/ProjectRepository.js

@@ -5,12 +5,72 @@ 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 __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.ProjectRepository = void 0;
 const decorators_1 = require("../../../decorators");
+const Project_1 = require("../makes/Project");
+const ProjectConfig_1 = require("../makes/ProjectConfig");
+const FileSystem_1 = require("../../../makes/FileSystem");
+const services_1 = require("../../../services");
+const env_1 = require("../../../env");
+const types_1 = require("../types");
 let ProjectRepository = class ProjectRepository {
+    constructor(appService, fs, driver) {
+        this.appService = appService;
+        this.fs = fs;
+        this.driver = driver;
+    }
+    getConfig(name, scope) {
+        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.ProjectConfigScopeEnum.LOCAL:
+                return ProjectConfig_1.ProjectConfig.make(new FileSystem_1.FileSystem(ref.path, this.driver), "wocker.config.json");
+        }
+    }
+    getByName(name) {
+        const ref = this.appService.getProject(name);
+        if (!ref) {
+            throw new Error(`Project "${name}" not found`);
+        }
+        return new Project_1.Project(ref.name, ref.path);
+    }
+    save(project) {
+        project.save();
+    }
+    search(params) {
+        const { name, path } = params, projects = [];
+        for (const ref of this.appService.projects) {
+            if (name && ref.name !== name) {
+                continue;
+            }
+            if (path && ref.path !== path) {
+                continue;
+            }
+            const project = this.getByName(ref.name);
+            projects.push(project);
+        }
+        return projects;
+    }
+    searchOne(params) {
+        const [project] = this.search(params);
+        return project || null;
+    }
 };
 exports.ProjectRepository = ProjectRepository;
 exports.ProjectRepository = ProjectRepository = __decorate([
-    (0, decorators_1.Injectable)("PROJECT_REPOSITORY")
+    (0, decorators_1.Injectable)("PROJECT_REPOSITORY"),
+    __param(2, (0, decorators_1.Inject)(env_1.FILE_SYSTEM_DRIVER_KEY)),
+    __metadata("design:paramtypes", [services_1.AppService,
+        services_1.AppFileSystemService, Object])
 ], ProjectRepository);

package/lib/modules/project/types/ProjectConfigScope.d.ts

@@ -0,0 +1,9 @@
+import { ProjectRef } from "../../../types";
+export declare enum ProjectConfigScopeEnum {
+    APP = "app",
+    LOCAL = "project"
+}
+export type ProjectConfigScope = ProjectConfigScopeEnum;
+export declare const ProjectConfigScope: typeof ProjectConfigScopeEnum & {
+    fileName(scope: ProjectConfigScopeEnum, projectRef: ProjectRef): string;
+};

package/lib/modules/project/types/ProjectConfigScope.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectConfigScope = exports.ProjectConfigScopeEnum = void 0;
+var ProjectConfigScopeEnum;
+(function (ProjectConfigScopeEnum) {
+    ProjectConfigScopeEnum["APP"] = "app";
+    ProjectConfigScopeEnum["LOCAL"] = "project";
+})(ProjectConfigScopeEnum || (exports.ProjectConfigScopeEnum = ProjectConfigScopeEnum = {}));
+exports.ProjectConfigScope = Object.assign({}, ProjectConfigScopeEnum, {
+    fileName(scope, projectRef) {
+        switch (scope) {
+            case ProjectConfigScopeEnum.APP:
+                return `projects/${projectRef.name}/config.json`;
+            case ProjectConfigScopeEnum.LOCAL:
+                return `wocker.config.json`;
+            default:
+                throw new Error(`Unknown config scope: ${scope}`);
+        }
+    }
+});

package/lib/modules/project/types/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./ProjectConfigScope";
 export * from "./ProjectV1";
 export * from "./ServiceProperties";

package/lib/modules/project/types/index.js

@@ -14,5 +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("./ProjectConfigScope"), exports);
 __exportStar(require("./ProjectV1"), exports);
 __exportStar(require("./ServiceProperties"), exports);

package/lib/services/AppFileSystemService.js

@@ -23,7 +23,7 @@ let AppFileSystemService = class AppFileSystemService extends FileSystem_1.FileS
 };
 exports.AppFileSystemService = AppFileSystemService;
 exports.AppFileSystemService = AppFileSystemService = __decorate([
-    (0, decorators_1.Injectable)(),
+    (0, decorators_1.Injectable)("APP_FILE_SYSTEM_SERVICE"),
     __param(0, (0, decorators_1.Inject)(env_1.WOCKER_DATA_DIR_KEY)),
     __param(1, (0, decorators_1.Inject)(env_1.FILE_SYSTEM_DRIVER_KEY)),
     __metadata("design:paramtypes", [String, Object])

package/lib/services/AppService.d.ts

@@ -1,17 +1,19 @@
 import { AppConfig } from "../makes/AppConfig";
 import { AppFileSystemService } from "./AppFileSystemService";
 import { ProcessService } from "./ProcessService";
+import { LogService } from "./LogService";
 import { ProjectRef, PluginRef, PresetRef, PresetSource } from "../types";
 type TypeMap = {
     [type: string]: string;
 };
 export declare class AppService {
     readonly version: string;
-    protected readonly processService: ProcessService;
     readonly fs: AppFileSystemService;
+    protected readonly processService: ProcessService;
+    protected readonly logService: LogService;
     protected _config?: AppConfig;
     protected readonly mapTypes: TypeMap;
-    constructor(version: string, processService: ProcessService, fs: AppFileSystemService);
+    constructor(version: string, fs: AppFileSystemService, processService: ProcessService, logService: LogService);
     get config(): AppConfig;
     get debug(): boolean;
     set debug(debug: boolean);
@@ -21,6 +23,7 @@ export declare class AppService {
     isVersionGT(version: string): boolean;
     isVersionGTE(version: string): boolean;
     getProjectTypes(): TypeMap;
+    getProject(name: string): ProjectRef | undefined;
     addProject(name: string, path: string): void;
     removeProject(name: string): void;
     addPlugin(name: string, env?: PluginRef["env"]): void;

package/lib/services/AppService.js

@@ -18,13 +18,15 @@ const Version_1 = require("../makes/Version");
 const AppConfig_1 = require("../makes/AppConfig");
 const AppFileSystemService_1 = require("./AppFileSystemService");
 const ProcessService_1 = require("./ProcessService");
+const LogService_1 = require("./LogService");
 const types_1 = require("../types");
 const env_1 = require("../env");
 let AppService = class AppService {
-    constructor(version, processService, fs) {
+    constructor(version, fs, processService, logService) {
         this.version = version;
-        this.processService = processService;
         this.fs = fs;
+        this.processService = processService;
+        this.logService = logService;
         this.mapTypes = {
             [types_1.ProjectType.IMAGE]: "Image",
             [types_1.ProjectType.PRESET]: "Preset",
@@ -64,6 +66,9 @@ let AppService = class AppService {
         }
         return this.mapTypes;
     }
+    getProject(name) {
+        return this.config.getProject(name);
+    }
     addProject(name, path) {
         this.config.addProject(name, path);
         this.config.save();
@@ -128,6 +133,7 @@ exports.AppService = AppService;
 exports.AppService = AppService = __decorate([
     (0, decorators_1.Injectable)("APP_SERVICE"),
     __param(0, (0, decorators_1.Inject)(env_1.WOCKER_VERSION_KEY)),
-    __metadata("design:paramtypes", [String, ProcessService_1.ProcessService,
-        AppFileSystemService_1.AppFileSystemService])
+    __metadata("design:paramtypes", [String, AppFileSystemService_1.AppFileSystemService,
+        ProcessService_1.ProcessService,
+        LogService_1.LogService])
 ], AppService);

package/lib/services/LogService.d.ts

@@ -1,11 +1,13 @@
-import { AppService } from "./AppService";
+import { ProcessService } from "./ProcessService";
 import { AppFileSystemService } from "./AppFileSystemService";
+import { LogLevel } from "../types";
 export declare class LogService {
-    protected readonly appService: AppService;
+    protected readonly processService: ProcessService;
     protected readonly fs: AppFileSystemService;
-    constructor(appService: AppService, fs: AppFileSystemService);
+    constructor(processService: ProcessService, fs: AppFileSystemService);
+    get logLevel(): LogLevel;
     protected get logName(): string;
-    protected _log(type: string, ...data: any[]): void;
+    protected _log(type: LogLevel, ...data: any[]): void;
     debug(...data: any[]): void;
     log(...data: any[]): void;
     info(...data: any[]): void;

package/lib/services/LogService.js

@@ -12,18 +12,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogService = void 0;
 const format_1 = require("date-fns/format");
 const decorators_1 = require("../decorators");
-const AppService_1 = require("./AppService");
+const ProcessService_1 = require("./ProcessService");
 const AppFileSystemService_1 = require("./AppFileSystemService");
+const types_1 = require("../types");
 let LogService = class LogService {
-    constructor(appService, fs) {
-        this.appService = appService;
+    constructor(processService, fs) {
+        this.processService = processService;
         this.fs = fs;
     }
+    get logLevel() {
+        const level = this.processService.getEnv("WS_LOG_LEVEL", types_1.LogLevel.WARNING);
+        if (types_1.LogLevel.values().includes(level)) {
+            return level;
+        }
+        return types_1.LogLevel.WARNING;
+    }
     get logName() {
         return "ws.log";
     }
     _log(type, ...data) {
-        if (type === "debug" && !this.appService.debug) {
+        if (!types_1.LogLevel.isGTE(this.logLevel, type)) {
             return;
         }
         const time = (0, format_1.format)(new Date(), "yyyy-MM-dd HH:mm:ss");
@@ -36,19 +44,19 @@ let LogService = class LogService {
         this.fs.appendFile(this.logName, `[${time}] ${type}: ${logData}\n`);
     }
     debug(...data) {
-        this._log("debug", ...data);
+        this._log(types_1.LogLevel.DEBUG, ...data);
     }
     log(...data) {
-        this._log("log", ...data);
+        this._log(types_1.LogLevel.LOG, ...data);
     }
     info(...data) {
-        this._log("info", ...data);
+        this._log(types_1.LogLevel.INFO, ...data);
     }
     warn(...data) {
-        this._log("warn", ...data);
+        this._log(types_1.LogLevel.WARNING, ...data);
     }
     error(...data) {
-        this._log("error", ...data);
+        this._log(types_1.LogLevel.ERROR, ...data);
     }
     clear() {
         this.fs.writeFile(this.logName, "");
@@ -57,6 +65,6 @@ let LogService = class LogService {
 exports.LogService = LogService;
 exports.LogService = LogService = __decorate([
     (0, decorators_1.Injectable)("LOG_SERVICE"),
-    __metadata("design:paramtypes", [AppService_1.AppService,
+    __metadata("design:paramtypes", [ProcessService_1.ProcessService,
         AppFileSystemService_1.AppFileSystemService])
 ], LogService);

package/lib/services/ProcessService.d.ts

@@ -8,7 +8,7 @@ export declare class ProcessService {
     cd(path: string): void;
     chdir(path: string): void;
     write(chunk: string | Buffer): boolean;
-    getEnv(key: string, byDefault?: string): string | undefined;
+    getEnv(key: string): string | undefined;
     getEnv(key: string, byDefault: string): string;
     setEnv(key: string, value: string): void;
 }

package/lib/types/LogLevel.d.ts

@@ -0,0 +1,13 @@
+declare enum LogLevelEnum {
+    DEBUG = "debug",
+    LOG = "log",
+    INFO = "info",
+    WARNING = "warn",
+    ERROR = "error"
+}
+export type LogLevel = LogLevelEnum;
+export declare const LogLevel: typeof LogLevelEnum & {
+    values(): LogLevelEnum[];
+    isGTE(a: LogLevelEnum, b: LogLevelEnum): boolean;
+};
+export {};

package/lib/types/LogLevel.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevelEnum;
+(function (LogLevelEnum) {
+    LogLevelEnum["DEBUG"] = "debug";
+    LogLevelEnum["LOG"] = "log";
+    LogLevelEnum["INFO"] = "info";
+    LogLevelEnum["WARNING"] = "warn";
+    LogLevelEnum["ERROR"] = "error";
+})(LogLevelEnum || (LogLevelEnum = {}));
+exports.LogLevel = Object.assign({}, LogLevelEnum, {
+    values() {
+        return Object.values(LogLevelEnum);
+    },
+    isGTE(a, b) {
+        const values = exports.LogLevel.values();
+        return values.indexOf(a) <= values.indexOf(b);
+    }
+});

package/lib/types/index.d.ts

@@ -2,6 +2,7 @@ export * from "./DynamicModule";
 export * from "./EnvConfig";
 export * from "./FileSystemDriver";
 export * from "./InjectionToken";
+export * from "./LogLevel";
 export * from "./ModuleMetadata";
 export * from "./PackageManagerType";
 export * from "./PickProperties";

package/lib/types/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./DynamicModule"), exports);
 __exportStar(require("./EnvConfig"), exports);
 __exportStar(require("./FileSystemDriver"), exports);
 __exportStar(require("./InjectionToken"), exports);
+__exportStar(require("./LogLevel"), exports);
 __exportStar(require("./ModuleMetadata"), exports);
 __exportStar(require("./PackageManagerType"), exports);
 __exportStar(require("./PickProperties"), exports);

package/package.json

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