@wocker/core 1.0.32-beta.3 → 1.1.0-beta.0

package/lib/env.d.ts

@@ -1,4 +1,4 @@
-export declare const WOCKER_VERSION = "1.0.32";
+export declare const WOCKER_VERSION = "1.1.0";
 export declare const WOCKER_VERSION_KEY = "__WOCKER_VERSION__";
 export declare const WOCKER_DATA_DIR: string;
 export declare const WOCKER_DATA_DIR_KEY = "__WOCKER_DATA_DIR__";

package/lib/env.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODULE_METADATA = exports.PLUGIN_NAME_METADATA = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.ALIAS_METADATA = exports.ARGS_OLD_METADATA = exports.ARGS_METADATA = exports.LISTENER_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.DESCRIPTION_METADATA = exports.INJECTABLE_WATERMARK = exports.IS_MODULE_METADATA = exports.IS_GLOBAL_METADATA = exports.IS_CONTROLLER_METADATA = exports.PLUGIN_DIR_KEY = exports.FILE_SYSTEM_DRIVER_KEY = exports.WOCKER_DATA_DIR_KEY = exports.WOCKER_DATA_DIR = exports.WOCKER_VERSION_KEY = exports.WOCKER_VERSION = void 0;
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-exports.WOCKER_VERSION = "1.0.32";
+exports.WOCKER_VERSION = "1.1.0";
 exports.WOCKER_VERSION_KEY = "__WOCKER_VERSION__";
 exports.WOCKER_DATA_DIR = process.env.WS_DIR || path_1.default.join(os_1.default.homedir(), ".workspace");
 exports.WOCKER_DATA_DIR_KEY = "__WOCKER_DATA_DIR__";

package/lib/makes/AppConfig.d.ts

@@ -1,4 +1,5 @@
 import { EnvConfig, PackageManagerType, PluginRef, PresetRef, ProjectRef, ProjectOldRef, PresetSource } from "../types";
+import { FileSystem } from "./FileSystem";
 export type AppConfigProperties = {
     debug?: boolean;
     pm?: PackageManagerType;
@@ -10,7 +11,7 @@ export type AppConfigProperties = {
     meta?: EnvConfig;
     env?: EnvConfig;
 };
-export declare class AppConfig {
+export declare abstract class AppConfig {
     debug?: boolean;
     pm?: PackageManagerType;
     keystore?: string;
@@ -33,10 +34,41 @@ export declare class AppConfig {
     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;
+    getEnv(key: string, byDefault?: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
     setEnv(name: string, value: string): void;
     unsetEnv(name: string): void;
+    abstract save(): void;
     toObject(): AppConfigProperties;
     toJsString(): string;
+    static make(fs: FileSystem): {
+        save(): void;
+        debug?: boolean;
+        pm?: PackageManagerType;
+        keystore?: string;
+        logLevel: "off" | "info" | "warn" | "error";
+        plugins: PluginRef[];
+        presets: PresetRef[];
+        projects: ProjectRef[];
+        meta?: EnvConfig;
+        env?: EnvConfig;
+        addPlugin(name: string, env?: PluginRef["env"]): void;
+        removePlugin(name: string): void;
+        getProject(name: string): ProjectRef | undefined;
+        addProject(name: string, path: string): void;
+        removeProject(name: string): void;
+        registerPreset(name: string, source: PresetSource, path?: string): void;
+        unregisterPreset(name: string): void;
+        hasMeta(name: string): boolean;
+        getMeta(name: string, defaultValue?: string): string | undefined;
+        getMeta(name: string, defaultValue: string): string;
+        setMeta(name: string, value: string): void;
+        unsetMeta(name: string): void;
+        getEnv(key: string, byDefault?: string): string | undefined;
+        getEnv(key: string, byDefault: string): string;
+        setEnv(name: string, value: string): void;
+        unsetEnv(name: string): void;
+        toObject(): AppConfigProperties;
+        toJsString(): string;
+    };
 }

package/lib/makes/AppConfig.js

@@ -142,11 +142,11 @@ class AppConfig {
             delete this.meta;
         }
     }
-    getEnv(name, defaultValue) {
-        if (!this.env || !(name in this.env)) {
-            return defaultValue;
+    getEnv(key, byDefault) {
+        if (!this.env || !(key in this.env)) {
+            return byDefault;
         }
-        return this.env[name];
+        return this.env[key];
     }
     setEnv(name, value) {
         if (!this.env) {
@@ -180,5 +180,52 @@ class AppConfig {
         const json = JSON.stringify(this.toObject(), null, 4);
         return `// Wocker config\nexports.config = ${json};`;
     }
+    static make(fs) {
+        let data = {};
+        if (fs.exists("wocker.config.js")) {
+            try {
+                const { config } = require(fs.path("wocker.config.js"));
+                data = config;
+            }
+            catch (err) {
+                // TODO: Log somehow
+                let json = fs.readJSON("wocker.config.json");
+                if (typeof json === "string") {
+                    json = JSON.parse(json);
+                }
+                data = json;
+            }
+        }
+        else if (fs.exists("wocker.config.json")) {
+            data = fs.readJSON("wocker.config.json");
+        }
+        else if (fs.exists("wocker.json")) {
+            let json = fs.readJSON("wocker.json");
+            if (typeof json === "string") {
+                json = JSON.parse(json);
+            }
+            data = json;
+        }
+        else if (fs.exists("data.json")) {
+            data = fs.readJSON("data.json");
+        }
+        return new class extends AppConfig {
+            save() {
+                if (!fs.exists()) {
+                    fs.mkdir("", {
+                        recursive: true
+                    });
+                }
+                fs.writeFile("wocker.config.js", this.toJsString());
+                fs.writeJSON("wocker.config.json", this.toObject()); // Backup file
+                if (fs.exists("data.json")) {
+                    fs.rm("data.json");
+                }
+                if (fs.exists("wocker.json")) {
+                    fs.rm("wocker.json");
+                }
+            }
+        }(data);
+    }
 }
 exports.AppConfig = AppConfig;

package/lib/makes/Logger.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const core_1 = require("../core");
-const services_1 = require("../services");
+// noinspection ES6PreferShortImport
+const LogService_1 = require("../services/LogService");
 class Logger {
     static getLogService() {
         var _a;
@@ -10,7 +11,7 @@ class Logger {
         if (!container) {
             return;
         }
-        return (_a = container.getProvider(services_1.LogService)) === null || _a === void 0 ? void 0 : _a.instance;
+        return (_a = container.getProvider(LogService_1.LogService)) === null || _a === void 0 ? void 0 : _a.instance;
     }
     static log(...data) {
         var _a;

package/lib/makes/Version.d.ts

@@ -0,0 +1,22 @@
+type VersionData = {
+    major: number;
+    minor: number;
+    patch: number;
+    tag?: string;
+    build?: number;
+};
+export declare class Version {
+    static readonly REGEXP: RegExp;
+    protected static cache: Map<string, Version>;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly tag?: string;
+    readonly build?: number;
+    constructor(data: VersionData);
+    parts(): number[];
+    compare(version: string | Version): number;
+    static valid(version: string): boolean;
+    static parse(version: string): Version;
+}
+export {};

package/lib/makes/Version.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+class Version {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    parts() {
+        var _a;
+        return [
+            this.major,
+            this.minor,
+            this.patch,
+            (_a = this.build) !== null && _a !== void 0 ? _a : 0
+        ];
+    }
+    compare(version) {
+        var _a, _b;
+        if (typeof version === "string") {
+            version = Version.parse(version);
+        }
+        const a = this.parts(), b = version.parts();
+        for (let i = 0; i < Math.max(a.length, b.length); i++) {
+            if (i === 3) {
+                if (this.tag && !version.tag)
+                    return -1;
+                else if (!this.tag && version.tag)
+                    return 1;
+                else if (this.tag !== version.tag)
+                    return this.tag < version.tag ? -1 : 1;
+            }
+            const diff = ((_a = a[i]) !== null && _a !== void 0 ? _a : 0) - ((_b = b[i]) !== null && _b !== void 0 ? _b : 0);
+            if (diff !== 0) {
+                return diff > 0 ? 1 : -1;
+            }
+        }
+        return 0;
+    }
+    static valid(version) {
+        return Version.REGEXP.test(version);
+    }
+    static parse(version) {
+        if (!Version.cache.has(version)) {
+            if (!Version.REGEXP.test(version)) {
+                throw new RangeError("Invalid version format");
+            }
+            const [, major, minor, patch, tag, build] = Version.REGEXP.exec(version) || [];
+            Version.cache.set(version, new Version({
+                major: parseInt(major),
+                minor: parseInt(minor),
+                patch: parseInt(patch),
+                tag,
+                build: build ? parseInt(build) : undefined
+            }));
+        }
+        return Version.cache.get(version);
+    }
+}
+exports.Version = Version;
+Version.REGEXP = /^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)(?:\.(\d+))?)?/;
+Version.cache = new Map();

package/lib/makes/VersionRange.d.ts

@@ -0,0 +1,6 @@
+import { VersionRule } from "./VersionRule";
+export declare class VersionRange {
+    protected rules: VersionRule[][];
+    constructor(rules: VersionRule[][]);
+    static parse(range: string): VersionRange;
+}

package/lib/makes/VersionRange.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionRange = void 0;
+const VersionRule_1 = require("./VersionRule");
+class VersionRange {
+    constructor(rules) {
+        this.rules = rules;
+    }
+    static parse(range) {
+        const rules = range.split("||").map((range) => {
+            return range.split(" ").map((rule) => {
+                return VersionRule_1.VersionRule.parse(rule);
+            });
+        });
+        return new VersionRange(rules);
+    }
+}
+exports.VersionRange = VersionRange;

package/lib/makes/VersionRule.d.ts

@@ -0,0 +1,24 @@
+import { Version } from "./Version";
+type VersionRuleData = {
+    prefix?: string;
+    major?: number;
+    minor?: number;
+    patch?: number;
+    tag?: string;
+    build?: number;
+};
+export declare class VersionRule {
+    static readonly REGEXP: RegExp;
+    protected static map: Map<string, VersionRule>;
+    readonly prefix?: string;
+    readonly major?: number;
+    readonly minor?: number;
+    readonly patch?: number;
+    readonly tag?: string;
+    readonly build?: number;
+    constructor(data: VersionRuleData);
+    get version(): Version;
+    match(version: string | Version, withTag?: boolean): boolean;
+    static parse(rule: string): VersionRule;
+}
+export {};

package/lib/makes/VersionRule.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionRule = void 0;
+const Version_1 = require("./Version");
+class VersionRule {
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    get version() {
+        var _a, _b, _c;
+        return new Version_1.Version({
+            major: (_a = this.major) !== null && _a !== void 0 ? _a : 0,
+            minor: (_b = this.minor) !== null && _b !== void 0 ? _b : 0,
+            patch: (_c = this.patch) !== null && _c !== void 0 ? _c : 0,
+            tag: this.tag,
+            build: this.build
+        });
+    }
+    match(version, withTag) {
+        if (typeof version === "string") {
+            version = Version_1.Version.parse(version);
+        }
+        if ((!withTag || this.tag) && this.tag !== version.tag) {
+            return false;
+        }
+        const cmp = version.compare(this.version);
+        switch (this.prefix) {
+            case ">":
+                return cmp > 0;
+            case ">=":
+                return cmp >= 0;
+            case "<":
+                return cmp < 0;
+            case "<=":
+                return cmp <= 0;
+            case "^":
+                return (this.major === version.major &&
+                    cmp >= 0);
+            case "~":
+                return (this.major === version.major &&
+                    this.minor === version.minor &&
+                    cmp >= 0);
+            default:
+                return ((this.major === undefined || this.major === version.major) &&
+                    (this.minor === undefined || this.minor === version.minor) &&
+                    (this.patch === undefined || this.patch === version.patch));
+        }
+    }
+    static parse(rule) {
+        if (!VersionRule.map.has(rule)) {
+            if (!VersionRule.REGEXP.test(rule)) {
+                throw new Error("Invalid version rule");
+            }
+            const [, prefix, major, minor, patch, tag, build, onlyTag] = VersionRule.REGEXP.exec(rule) || [];
+            VersionRule.map.set(rule, new VersionRule({
+                prefix,
+                major: major && major !== "x" && major !== "*" ? parseInt(major) : undefined,
+                minor: minor && minor !== "x" ? parseInt(minor) : undefined,
+                patch: patch && patch !== "x" ? parseInt(patch) : undefined,
+                tag: tag || onlyTag,
+                build: build && build !== "x" ? parseInt(build) : undefined
+            }));
+        }
+        return VersionRule.map.get(rule);
+    }
+}
+exports.VersionRule = VersionRule;
+VersionRule.REGEXP = /^(?:(\^|~|<=|>=|<|>)?(x|\d+)(?:\.(\*|x|\d+))?(?:\.(x|\d+))?(?:-([a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*)(?:\.(\d+))?)?|([a-zA-Z0-9]+(?:-[a-zAZ0-9]+)*))$/;
+VersionRule.map = new Map();

package/lib/makes/index.d.ts

@@ -4,3 +4,6 @@ export * from "./ConfigCollection";
 export * from "./FileSystem";
 export * from "./FileSystemManager";
 export * from "./Logger";
+export * from "./Version";
+export * from "./VersionRange";
+export * from "./VersionRule";

package/lib/makes/index.js

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

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

@@ -1,4 +1,4 @@
 export * from "./makes/Project";
 export * from "./repositories/ProjectRepository";
 export * from "./services/ProjectService";
-export { PROJECT_TYPE_IMAGE, PROJECT_TYPE_DOCKERFILE, PROJECT_TYPE_COMPOSE, PROJECT_TYPE_PRESET, ProjectType, ServiceProperties } from "./types";
+export { ServiceProperties } from "./types";

package/lib/modules/project/index.js

@@ -14,12 +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 });
-exports.PROJECT_TYPE_PRESET = exports.PROJECT_TYPE_COMPOSE = exports.PROJECT_TYPE_DOCKERFILE = exports.PROJECT_TYPE_IMAGE = void 0;
 __exportStar(require("./makes/Project"), exports);
 __exportStar(require("./repositories/ProjectRepository"), exports);
 __exportStar(require("./services/ProjectService"), exports);
-var types_1 = require("./types");
-Object.defineProperty(exports, "PROJECT_TYPE_IMAGE", { enumerable: true, get: function () { return types_1.PROJECT_TYPE_IMAGE; } });
-Object.defineProperty(exports, "PROJECT_TYPE_DOCKERFILE", { enumerable: true, get: function () { return types_1.PROJECT_TYPE_DOCKERFILE; } });
-Object.defineProperty(exports, "PROJECT_TYPE_COMPOSE", { enumerable: true, get: function () { return types_1.PROJECT_TYPE_COMPOSE; } });
-Object.defineProperty(exports, "PROJECT_TYPE_PRESET", { enumerable: true, get: function () { return types_1.PROJECT_TYPE_PRESET; } });

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

@@ -1,5 +1,5 @@
-import { EnvConfig } from "../../../types";
-import { ServiceProperties, ProjectType, ProjectV1 } from "../types";
+import { EnvConfig, ProjectType } from "../../../types";
+import { ServiceProperties, ProjectV1 } from "../types";
 export declare class Project {
     /** @deprecated */
     id?: string;

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

@@ -1,5 +1,4 @@
-import { EnvConfig } from "../../../types";
-import { ProjectType } from "./ProjectType";
+import { EnvConfig, ProjectType } from "../../../types";
 import { ServiceProperties } from "./ServiceProperties";
 export type ProjectV1 = {
     name: string;

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

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

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

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

package/lib/services/AppConfigService.d.ts

@@ -1,29 +1,43 @@
 import { AppConfig } from "../makes/AppConfig";
-import { PresetSource, PresetRef, ProjectRef, PluginRef } from "../types";
+import { ProjectRef, PluginRef, PresetRef, PresetSource } from "../types";
+import { AppService } from "./AppService";
 import { AppFileSystemService } from "./AppFileSystemService";
 import { ProcessService } from "./ProcessService";
-type TypeMap = {
-    [type: string]: string;
-};
+/**
+ * @deprecated
+ */
 export declare class AppConfigService {
-    readonly version: string;
-    protected readonly processService: ProcessService;
+    protected readonly appService: AppService;
     readonly fs: AppFileSystemService;
-    protected _pwd: string;
-    protected _config?: AppConfig;
-    protected readonly mapTypes: TypeMap;
-    constructor(version: string, processService: ProcessService, fs: AppFileSystemService);
-    get experimentalFeatures(): string[];
+    protected readonly processService: ProcessService;
+    constructor(appService: AppService, fs: AppFileSystemService, processService: ProcessService);
+    get config(): AppConfig;
     get debug(): boolean;
     set debug(debug: boolean);
-    get config(): AppConfig;
-    get presets(): PresetRef[];
+    get experimentalFeatures(): string[];
     get projects(): ProjectRef[];
     get plugins(): PluginRef[];
-    /**
-     * @deprecated
-     */
+    get presets(): PresetRef[];
+    getConfig(): AppConfig;
+    getProjectTypes(): {
+        [type: string]: string;
+    };
+    addProject(name: string, path: string): void;
+    removeProject(name: string): void;
+    addPlugin(name: string, env?: PluginRef["env"]): void;
+    removePlugin(name: string): void;
+    registerPreset(name: string, source: PresetSource, path?: string): void;
+    unregisterPreset(name: string): void;
+    getEnv(key: string, byDefault?: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
+    setEnv(key: string, value: string): void;
+    unsetEnv(key: string): void;
+    getMeta(key: string, byDefault?: string): string | undefined;
+    getMeta(key: string, byDefault: string): string;
+    setMeta(key: string, value: string): void;
+    unsetMeta(key: string): void;
     isVersionGTE(version: string): boolean;
+    isExperimentalEnabled(key: string): boolean;
     /**
      * @deprecated
      */
@@ -32,28 +46,6 @@ export declare class AppConfigService {
      * @deprecated
      */
     setPWD(pwd: string): void;
-    /**
-     * @deprecated
-     */
     dataPath(...args: string[]): string;
-    /**
-     * @deprecated
-     */
-    getConfig(): AppConfig;
-    addProject(name: string, path: string): void;
-    removeProject(name: string): void;
-    registerPreset(name: string, source: PresetSource, path?: string): void;
-    unregisterPreset(name: string): void;
-    addPlugin(name: string, env?: PluginRef["env"]): void;
-    removePlugin(name: string): void;
-    setEnv(name: string, value: string): void;
-    unsetEnv(name: string): void;
-    getMeta(name: string, byDefault?: string): string | undefined;
-    getMeta(name: string, byDefault: string): string;
-    setMeta(name: string, value: string): void;
-    unsetMeta(name: string): void;
-    isExperimentalEnabled(key: string): boolean;
-    getProjectTypes(): TypeMap;
     save(): void;
 }
-export {};

package/lib/services/AppConfigService.js

@@ -8,9 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,193 +15,110 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigService = void 0;
 const path_1 = __importDefault(require("path"));
 const decorators_1 = require("../decorators");
-const project_1 = require("../modules/project");
-const AppConfig_1 = require("../makes/AppConfig");
+const AppService_1 = require("./AppService");
 const AppFileSystemService_1 = require("./AppFileSystemService");
 const ProcessService_1 = require("./ProcessService");
-const env_1 = require("../env");
+/**
+ * @deprecated
+ */
 let AppConfigService = class AppConfigService {
-    constructor(version, processService, fs) {
-        this.version = version;
-        this.processService = processService;
+    constructor(appService, fs, processService) {
+        this.appService = appService;
         this.fs = fs;
-        this.mapTypes = {
-            [project_1.PROJECT_TYPE_IMAGE]: "Image",
-            [project_1.PROJECT_TYPE_PRESET]: "Preset",
-            [project_1.PROJECT_TYPE_DOCKERFILE]: "Dockerfile"
-        };
-        this._pwd = (process.cwd() || process.env.PWD);
+        this.processService = processService;
     }
-    get experimentalFeatures() {
-        return [
-            "projectComposeType",
-            "buildKit",
-            "dns"
-        ];
+    get config() {
+        return this.appService.config;
     }
     get debug() {
-        return this.config.debug || false;
+        return this.appService.debug;
     }
     set debug(debug) {
-        this.config.debug = debug;
-    }
-    get config() {
-        if (!this._config) {
-            let data = {};
-            if (this.fs.exists("wocker.config.js")) {
-                try {
-                    const { config } = require(this.fs.path("wocker.config.js"));
-                    data = config;
-                }
-                catch (err) {
-                    // TODO: Log somehow
-                    // this.logService.error(err);
-                    if (this.fs.exists("wocker.config.json")) {
-                        let json = this.fs.readJSON("wocker.config.json");
-                        if (typeof json === "string") {
-                            json = JSON.parse(json);
-                        }
-                        data = json;
-                    }
-                }
-            }
-            else if (this.fs.exists("wocker.config.json")) {
-                data = this.fs.readJSON("wocker.config.json");
-            }
-            else if (this.fs.exists("wocker.json")) {
-                let json = this.fs.readJSON("wocker.json");
-                if (typeof json === "string") {
-                    json = JSON.parse(json);
-                }
-                data = json;
-            }
-            else if (this.fs.exists("data.json")) {
-                data = this.fs.readJSON("data.json");
-            }
-            else if (!this.fs.exists()) {
-                this.fs.mkdir("", {
-                    recursive: true
-                });
-            }
-            this._config = new AppConfig_1.AppConfig(data);
-        }
-        return this._config;
+        this.appService.debug = debug;
     }
-    get presets() {
-        return this.config.presets;
+    get experimentalFeatures() {
+        return this.appService.experimentalFeatures;
     }
     get projects() {
-        return this.config.projects;
+        return this.appService.projects;
     }
     get plugins() {
-        return this.config.plugins;
+        return this.appService.plugins;
     }
-    /**
-     * @deprecated
-     */
-    isVersionGTE(version) {
-        const current = this.version.split(".").map(Number);
-        const compare = version.split(".").map(Number);
-        for (let i = 0; i < 3; i++) {
-            if (current[i] > compare[i]) {
-                return true;
-            }
-            else if (current[i] < compare[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * @deprecated
-     */
-    pwd(...parts) {
-        return this.processService.pwd(path_1.default.join(...parts));
-    }
-    /**
-     * @deprecated
-     */
-    setPWD(pwd) {
-        this.processService.chdir(pwd);
-    }
-    /**
-     * @deprecated
-     */
-    dataPath(...args) {
-        return this.fs.path(...args);
+    get presets() {
+        return this.appService.presets;
     }
-    /**
-     * @deprecated
-     */
     getConfig() {
         return this.config;
     }
+    getProjectTypes() {
+        return this.appService.getProjectTypes();
+    }
     addProject(name, path) {
-        this.config.addProject(name, path);
+        this.appService.addProject(name, path);
     }
     removeProject(name) {
-        this.config.removeProject(name);
-        this.save();
+        this.appService.removeProject(name);
+    }
+    addPlugin(name, env) {
+        this.appService.addPlugin(name, env);
+    }
+    removePlugin(name) {
+        this.appService.removePlugin(name);
     }
     registerPreset(name, source, path) {
-        this.config.registerPreset(name, source, path);
-        this.save();
+        this.appService.registerPreset(name, source, path);
     }
     unregisterPreset(name) {
-        this.config.unregisterPreset(name);
-        this.save();
+        this.appService.unregisterPreset(name);
     }
-    addPlugin(name, env) {
-        this.config.addPlugin(name, env);
+    getEnv(key, byDefault) {
+        return this.appService.getEnv(key, byDefault);
     }
-    removePlugin(name) {
-        this.config.removePlugin(name);
+    setEnv(key, value) {
+        this.appService.setEnv(key, value);
     }
-    setEnv(name, value) {
-        this.config.setEnv(name, value);
+    unsetEnv(key) {
+        this.appService.unsetEnv(key);
     }
-    unsetEnv(name) {
-        this.config.unsetEnv(name);
+    getMeta(key, byDefault) {
+        return this.appService.getMeta(key, byDefault);
     }
-    getMeta(name, byDefault) {
-        return this.config.getMeta(name, byDefault);
+    setMeta(key, value) {
+        this.appService.setMeta(key, value);
     }
-    setMeta(name, value) {
-        this.config.setMeta(name, value);
+    unsetMeta(key) {
+        this.appService.unsetMeta(key);
     }
-    unsetMeta(name) {
-        this.config.unsetMeta(name);
+    isVersionGTE(version) {
+        return this.appService.isVersionGTE(version);
     }
     isExperimentalEnabled(key) {
-        return this.config.getMeta(`experimental.${key}`) === "enabled";
+        return this.appService.isExperimentalEnabled(key);
     }
-    getProjectTypes() {
-        if (this.isExperimentalEnabled("projectComposeType")) {
-            return Object.assign(Object.assign({}, this.mapTypes), { [project_1.PROJECT_TYPE_COMPOSE]: "Docker compose" });
-        }
-        return this.mapTypes;
+    /**
+     * @deprecated
+     */
+    pwd(...parts) {
+        return this.processService.pwd(path_1.default.join(...parts));
+    }
+    /**
+     * @deprecated
+     */
+    setPWD(pwd) {
+        this.processService.chdir(pwd);
+    }
+    dataPath(...args) {
+        return this.appService.fs.path(path_1.default.join(...args));
     }
     save() {
-        const fs = this.fs;
-        if (!fs.exists()) {
-            fs.mkdir("", {
-                recursive: true
-            });
-        }
-        fs.writeFile("wocker.config.js", this.config.toJsString());
-        fs.writeJSON("wocker.config.json", this.config.toObject()); // Backup file
-        if (fs.exists("data.json")) {
-            fs.rm("data.json");
-        }
-        if (fs.exists("wocker.json")) {
-            fs.rm("wocker.json");
-        }
+        this.config.save();
     }
 };
 exports.AppConfigService = AppConfigService;
 exports.AppConfigService = AppConfigService = __decorate([
     (0, decorators_1.Injectable)("APP_CONFIG"),
-    __param(0, (0, decorators_1.Inject)(env_1.WOCKER_VERSION_KEY)),
-    __metadata("design:paramtypes", [String, ProcessService_1.ProcessService,
-        AppFileSystemService_1.AppFileSystemService])
+    __metadata("design:paramtypes", [AppService_1.AppService,
+        AppFileSystemService_1.AppFileSystemService,
+        ProcessService_1.ProcessService])
 ], AppConfigService);

package/lib/services/AppFileSystemService.d.ts

@@ -1,4 +1,4 @@
-import { FileSystemDriver } from "../types/FileSystemDriver";
+import { FileSystemDriver } from "../types";
 import { FileSystem } from "../makes/FileSystem";
 export declare class AppFileSystemService extends FileSystem {
     constructor(dataDir: string, fsDriver: FileSystemDriver);

package/lib/services/AppService.d.ts

@@ -1,20 +1,42 @@
-import { AppConfigService } from "./AppConfigService";
+import { AppConfig } from "../makes/AppConfig";
 import { AppFileSystemService } from "./AppFileSystemService";
-import { ProjectRef } from "../types";
+import { ProcessService } from "./ProcessService";
+import { ProjectRef, PluginRef, PresetRef, PresetSource } from "../types";
 type TypeMap = {
     [type: string]: string;
 };
 export declare class AppService {
     readonly version: string;
-    protected readonly appConfigService: AppConfigService;
-    protected readonly fs: AppFileSystemService;
-    constructor(version: string, appConfigService: AppConfigService, fs: AppFileSystemService);
+    protected readonly processService: ProcessService;
+    readonly fs: AppFileSystemService;
+    protected _config?: AppConfig;
+    protected readonly mapTypes: TypeMap;
+    constructor(version: string, processService: ProcessService, fs: AppFileSystemService);
+    get config(): AppConfig;
+    get debug(): boolean;
+    set debug(debug: boolean);
     get projects(): ProjectRef[];
+    get plugins(): PluginRef[];
+    get presets(): PresetRef[];
+    isVersionGT(version: string): boolean;
     isVersionGTE(version: string): boolean;
-    get experimentalFeatures(): string[];
     getProjectTypes(): TypeMap;
     addProject(name: string, path: string): void;
-    getMeta(name: string, byDefault?: string): string | undefined;
-    getMeta(name: string, byDefault: string): string;
+    removeProject(name: string): void;
+    addPlugin(name: string, env?: PluginRef["env"]): void;
+    removePlugin(name: string): void;
+    registerPreset(name: string, source: PresetSource, path?: string): void;
+    unregisterPreset(name: string): void;
+    getEnv(key: string, byDefault?: string): string | undefined;
+    getEnv(key: string, byDefault: string): string;
+    setEnv(key: string, value: string): void;
+    unsetEnv(key: string): void;
+    getMeta(key: string, byDefault?: string): string | undefined;
+    getMeta(key: string, byDefault: string): string;
+    setMeta(key: string, value: string): void;
+    unsetMeta(key: string): void;
+    get experimentalFeatures(): string[];
+    isExperimentalEnabled(key: string): boolean;
+    save(): void;
 }
 export {};

package/lib/services/AppService.js

@@ -14,49 +14,120 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppService = void 0;
 const decorators_1 = require("../decorators");
-const AppConfigService_1 = require("./AppConfigService");
+const Version_1 = require("../makes/Version");
+const AppConfig_1 = require("../makes/AppConfig");
 const AppFileSystemService_1 = require("./AppFileSystemService");
+const ProcessService_1 = require("./ProcessService");
+const types_1 = require("../types");
 const env_1 = require("../env");
 let AppService = class AppService {
-    constructor(version, appConfigService, fs) {
+    constructor(version, processService, fs) {
         this.version = version;
-        this.appConfigService = appConfigService;
+        this.processService = processService;
         this.fs = fs;
+        this.mapTypes = {
+            [types_1.ProjectType.IMAGE]: "Image",
+            [types_1.ProjectType.PRESET]: "Preset",
+            [types_1.ProjectType.DOCKERFILE]: "Dockerfile"
+        };
+    }
+    get config() {
+        if (!this._config) {
+            this._config = AppConfig_1.AppConfig.make(this.fs);
+        }
+        return this._config;
+    }
+    get debug() {
+        return this.config.debug || false;
+    }
+    set debug(debug) {
+        this.config.debug = debug;
     }
     get projects() {
-        return this.appConfigService.projects;
+        return this.config.projects;
     }
-    isVersionGTE(version) {
-        const current = this.version.split(".").map(Number);
-        const compare = version.split(".").map(Number);
-        for (let i = 0; i < 3; i++) {
-            if (current[i] > compare[i]) {
-                return true;
-            }
-            else if (current[i] < compare[i]) {
-                return false;
-            }
-        }
-        return true;
+    get plugins() {
+        return this.config.plugins;
     }
-    get experimentalFeatures() {
-        return this.appConfigService.experimentalFeatures;
+    get presets() {
+        return this.config.presets;
+    }
+    isVersionGT(version) {
+        return Version_1.Version.parse(this.version).compare(version) > 0;
+    }
+    isVersionGTE(version) {
+        return Version_1.Version.parse(this.version).compare(version) >= 0;
     }
     getProjectTypes() {
-        return this.appConfigService.getProjectTypes();
+        if (this.isExperimentalEnabled("projectComposeType")) {
+            return Object.assign(Object.assign({}, this.mapTypes), { [types_1.ProjectType.COMPOSE]: "Docker compose" });
+        }
+        return this.mapTypes;
     }
     addProject(name, path) {
-        this.appConfigService.addProject(name, path);
-        this.appConfigService.save();
+        this.config.addProject(name, path);
+        this.config.save();
+    }
+    removeProject(name) {
+        this.config.removeProject(name);
+        this.config.save();
+    }
+    addPlugin(name, env) {
+        this.config.addPlugin(name, env);
+        this.config.save();
+    }
+    removePlugin(name) {
+        this.config.removePlugin(name);
+        this.config.save();
+    }
+    registerPreset(name, source, path) {
+        this.config.registerPreset(name, source, path);
+        this.config.save();
+    }
+    unregisterPreset(name) {
+        this.config.unregisterPreset(name);
+        this.config.save();
+    }
+    getEnv(key, byDefault) {
+        return this.config.getEnv(key, byDefault);
+    }
+    setEnv(key, value) {
+        this.config.setEnv(key, value);
+        this.config.save();
+    }
+    unsetEnv(key) {
+        this.config.unsetEnv(key);
+        this.config.save();
+    }
+    getMeta(key, byDefault) {
+        return this.config.getMeta(key, byDefault);
+    }
+    setMeta(key, value) {
+        this.config.setMeta(key, value);
+        this.config.save();
+    }
+    unsetMeta(key) {
+        this.config.unsetMeta(key);
+        this.config.save();
+    }
+    get experimentalFeatures() {
+        return [
+            "projectComposeType",
+            "buildKit",
+            "dns"
+        ];
+    }
+    isExperimentalEnabled(key) {
+        return this.config.getMeta(`experimental.${key}`) === "enabled";
     }
-    getMeta(name, byDefault) {
-        return this.appConfigService.getMeta(name, byDefault);
+    save() {
+        this.config.save();
     }
 };
 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, AppConfigService_1.AppConfigService,
+    __metadata("design:paramtypes", [String, ProcessService_1.ProcessService,
         AppFileSystemService_1.AppFileSystemService])
 ], AppService);

package/lib/services/LogService.d.ts

@@ -1,9 +1,9 @@
-import { AppConfigService } from "./AppConfigService";
+import { AppService } from "./AppService";
 import { AppFileSystemService } from "./AppFileSystemService";
 export declare class LogService {
-    protected readonly appConfigService: AppConfigService;
+    protected readonly appService: AppService;
     protected readonly fs: AppFileSystemService;
-    constructor(appConfigService: AppConfigService, fs: AppFileSystemService);
+    constructor(appService: AppService, fs: AppFileSystemService);
     protected get logName(): string;
     protected _log(type: string, ...data: any[]): void;
     debug(...data: any[]): void;

package/lib/services/LogService.js

@@ -12,18 +12,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogService = void 0;
 const format_1 = require("date-fns/format");
 const decorators_1 = require("../decorators");
-const AppConfigService_1 = require("./AppConfigService");
+const AppService_1 = require("./AppService");
 const AppFileSystemService_1 = require("./AppFileSystemService");
 let LogService = class LogService {
-    constructor(appConfigService, fs) {
-        this.appConfigService = appConfigService;
+    constructor(appService, fs) {
+        this.appService = appService;
         this.fs = fs;
     }
     get logName() {
         return "ws.log";
     }
     _log(type, ...data) {
-        if (type === "debug" && !this.appConfigService.config.debug) {
+        if (type === "debug" && !this.appService.debug) {
             return;
         }
         const time = (0, format_1.format)(new Date(), "yyyy-MM-dd HH:mm:ss");
@@ -57,6 +57,6 @@ let LogService = class LogService {
 exports.LogService = LogService;
 exports.LogService = LogService = __decorate([
     (0, decorators_1.Injectable)("LOG_SERVICE"),
-    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+    __metadata("design:paramtypes", [AppService_1.AppService,
         AppFileSystemService_1.AppFileSystemService])
 ], LogService);

package/lib/types/ProjectType.d.ts

@@ -0,0 +1,19 @@
+declare enum ProjectTypeEnum {
+    DOCKERFILE = "dockerfile",
+    IMAGE = "image",
+    COMPOSE = "compose",
+    PRESET = "preset"
+}
+/** @deprecated */
+export declare const PROJECT_TYPE_DOCKERFILE = ProjectTypeEnum.DOCKERFILE;
+/** @deprecated */
+export declare const PROJECT_TYPE_IMAGE = ProjectTypeEnum.IMAGE;
+/** @deprecated */
+export declare const PROJECT_TYPE_PRESET = ProjectTypeEnum.PRESET;
+/** @deprecated */
+export declare const PROJECT_TYPE_COMPOSE = ProjectTypeEnum.COMPOSE;
+export type ProjectType = ProjectTypeEnum;
+export declare const ProjectType: typeof ProjectTypeEnum & {
+    values(): ProjectTypeEnum[];
+};
+export {};

package/lib/types/ProjectType.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectType = exports.PROJECT_TYPE_COMPOSE = exports.PROJECT_TYPE_PRESET = exports.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = void 0;
+var ProjectTypeEnum;
+(function (ProjectTypeEnum) {
+    ProjectTypeEnum["DOCKERFILE"] = "dockerfile";
+    ProjectTypeEnum["IMAGE"] = "image";
+    ProjectTypeEnum["COMPOSE"] = "compose";
+    ProjectTypeEnum["PRESET"] = "preset";
+})(ProjectTypeEnum || (ProjectTypeEnum = {}));
+/** @deprecated */
+exports.PROJECT_TYPE_DOCKERFILE = ProjectTypeEnum.DOCKERFILE;
+/** @deprecated */
+exports.PROJECT_TYPE_IMAGE = ProjectTypeEnum.IMAGE;
+/** @deprecated */
+exports.PROJECT_TYPE_PRESET = ProjectTypeEnum.PRESET;
+/** @deprecated */
+exports.PROJECT_TYPE_COMPOSE = ProjectTypeEnum.COMPOSE;
+exports.ProjectType = Object.assign({}, ProjectTypeEnum, {
+    values() {
+        return Object.values(ProjectTypeEnum);
+    }
+});

package/lib/types/index.d.ts

@@ -11,6 +11,7 @@ export * from "./PresetRef";
 export * from "./PresetSource";
 export * from "./ProviderType";
 export * from "./ProjectRef";
+export * from "./ProjectType";
 export * from "./Type";
 export * from "./Volume";
 export type { 

package/lib/types/index.js

@@ -27,5 +27,6 @@ __exportStar(require("./PresetRef"), exports);
 __exportStar(require("./PresetSource"), exports);
 __exportStar(require("./ProviderType"), exports);
 __exportStar(require("./ProjectRef"), exports);
+__exportStar(require("./ProjectType"), exports);
 __exportStar(require("./Type"), exports);
 __exportStar(require("./Volume"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wocker/core",
     "type": "commonjs",
-    "version": "1.0.32-beta.3",
+    "version": "1.1.0-beta.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",
@@ -39,6 +39,7 @@
         "@types/dockerode": "^3.3.23",
         "@types/jest": "^30.0.0",
         "@types/node": "^24.5.2",
+        "@wocker/testing": "^1.0.7",
         "jest": "^30.1.3",
         "make-coverage-badge": "^1.2.0",
         "memfs": "^4.17.1",

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

@@ -1,5 +0,0 @@
-export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
-export declare const PROJECT_TYPE_IMAGE = "image";
-export declare const PROJECT_TYPE_PRESET = "preset";
-export declare const PROJECT_TYPE_COMPOSE = "compose";
-export type ProjectType = typeof PROJECT_TYPE_DOCKERFILE | typeof PROJECT_TYPE_IMAGE | typeof PROJECT_TYPE_PRESET | typeof PROJECT_TYPE_COMPOSE;

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECT_TYPE_COMPOSE = exports.PROJECT_TYPE_PRESET = exports.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = void 0;
-exports.PROJECT_TYPE_DOCKERFILE = "dockerfile";
-exports.PROJECT_TYPE_IMAGE = "image";
-exports.PROJECT_TYPE_PRESET = "preset";
-exports.PROJECT_TYPE_COMPOSE = "compose";