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

package/lib/makes/ProjectConfig.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectConfig = void 0;
+const volumeParse_1 = require("../utils/volumeParse");
+const JsonEditor_1 = require("./JsonEditor");
+class ProjectConfig extends JsonEditor_1.JsonEditor {
+    // public editor: JsonEditor<ProjectConfig.Data>;
+    // protected state: ProjectConfig.Data;
+    // public type?: ProjectType;
+    // public image?: string;
+    // public dockerfile?: string;
+    // public composefile?: string;
+    // public preset?: string;
+    // public presetMode?: "global" | "project";
+    // public scripts: {
+    //     [script: string]: string;
+    // };
+    // public cmd?: string[];
+    // public metadata: EnvConfig;
+    // public ports: string[];
+    // public volumes: string[];
+    // public extraHosts: EnvConfig;
+    // public services: Record<string, ProjectConfig.Service>;
+    constructor(content) {
+        super(content);
+        // this.editor = new JsonEditor<ProjectConfig.Data>(content);
+        // const {
+        //     type,
+        //     imageName,
+        //     image = imageName,
+        //     dockerfile,
+        //     composefile,
+        //     preset,
+        //     presetMode,
+        //     scripts = {},
+        //     cmd,
+        //     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.metadata = metadata;
+        // this.volumes = volumes;
+        // this.ports = ports;
+        // this.extraHosts = extraHosts;
+        // this.services = services;
+    }
+    get type() {
+        return this.state.type;
+    }
+    set type(type) {
+        this.state.type = type;
+    }
+    get buildArgs() {
+        return this.createProxy(["buildArgs"], {
+            removeOnEmpty: true
+        });
+    }
+    set buildArgs(buildArgs) {
+        this.state.buildArgs = Object.assign({}, buildArgs);
+    }
+    get env() {
+        return this.createProxy(["env"], {
+            removeOnEmpty: true
+        });
+    }
+    set env(env) {
+        this.state.env = env ? Object.assign({}, env) : env;
+    }
+    get metadata() {
+        return this.createProxy(["metadata"], {
+            removeOnEmpty: true
+        });
+    }
+    set metadata(metadata) {
+        this.state.metadata = Object.assign({}, metadata);
+    }
+    get preset() {
+        return this.state.preset;
+    }
+    set preset(preset) {
+        this.state.preset = preset;
+    }
+    get presetMode() {
+        return this.state.presetMode;
+    }
+    set presetMode(presetMode) {
+        this.state.presetMode = presetMode;
+    }
+    get image() {
+        return this.state.image;
+    }
+    set image(image) {
+        this.state.image = image;
+    }
+    get imageName() {
+        return this.state.imageName;
+    }
+    set imageName(image) {
+        this.state.imageName = image;
+    }
+    get composefile() {
+        return this.state.composefile;
+    }
+    set composefile(composefile) {
+        this.state.composefile = composefile;
+    }
+    get dockerfile() {
+        return this.state.dockerfile;
+    }
+    set dockerfile(dockerfile) {
+        this.state.dockerfile = dockerfile;
+    }
+    get cmd() {
+        return this.state.cmd;
+    }
+    set cmd(cmd) {
+        this.state.cmd = cmd;
+    }
+    get scripts() {
+        return {};
+    }
+    get services() {
+        return {};
+    }
+    get extraHosts() {
+        return this.createProxy(["extraHosts"]);
+    }
+    set extraHosts(extraHosts) {
+        this.state.extraHosts = Object.assign({}, extraHosts);
+    }
+    get volumes() {
+        return this.createProxy(["volumes"], {
+            removeOnEmpty: true,
+            isArray: true
+        });
+    }
+    set volumes(volumes) {
+        this.state.volumes = volumes;
+    }
+    get ports() {
+        return this.createProxy(["ports"], {
+            isArray: true,
+            removeOnEmpty: true
+        });
+    }
+    set ports(ports) {
+        this.state.ports = [...ports];
+    }
+    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;
+            return;
+        }
+        this.buildArgs[key] = value;
+    }
+    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);
+        return key in this.env;
+    }
+    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.state.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.state.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.state.volumes = [
+            ...(this.state.volumes || []).filter((v) => {
+                return v !== this.getVolumeByDestination(destination);
+            }),
+            volume
+        ];
+        this.volumeMount(...restVolumes);
+    }
+    volumeUnmount(...volumes) {
+        if (!this.state.volumes || volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const v = (0, volumeParse_1.volumeParse)(volume);
+        this.state.volumes = this.state.volumes.filter((mounted) => {
+            const m = (0, volumeParse_1.volumeParse)(mounted);
+            return v.source !== m.source && v.destination !== m.destination;
+        });
+        if (this.state.volumes.length === 0) {
+            return;
+        }
+        this.volumeUnmount(...restVolumes);
+    }
+    addExtraHost(host, domain) {
+        if (!this.state.extraHosts) {
+            this.state.extraHosts = {};
+        }
+        this.state.extraHosts[host] = domain;
+    }
+    removeExtraHost(host) {
+        if (this.state.extraHosts && host in this.state.extraHosts) {
+            delete this.state.extraHosts[host];
+        }
+    }
+    addService(name, data) {
+    }
+    service(name) {
+        return this.createProxy(["services", name], {
+            removeOnEmpty: true
+        });
+    }
+    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,
+        // };
+        return this.state;
+    }
+    static make(fs, filename) {
+        let content = "{}";
+        if (fs.exists(filename)) {
+            content = fs.readFile(filename).toString();
+        }
+        return new class extends ProjectConfig {
+            save() {
+                // if(!fs.exists()) {
+                //     fs.mkdir("", {
+                //         recursive: true
+                //     });
+                // }
+                //
+                // fs.writeJSON(filename, this.toObject());
+            }
+        }(content);
+    }
+}
+exports.ProjectConfig = ProjectConfig;

package/lib/makes/ServiceConfig.d.ts

@@ -0,0 +1,23 @@
+import { EnvConfig } from "../types";
+export declare class ServiceConfig {
+    protected readonly original: ServiceConfig.Data;
+    protected readonly state: ServiceConfig.Data;
+    constructor(original: ServiceConfig.Data);
+    get buildArgs(): EnvConfig;
+    set buildArgs(buildArgs: EnvConfig);
+    get env(): EnvConfig;
+    set env(env: EnvConfig);
+    isDirty(): boolean;
+    toObject(): ServiceConfig.Data;
+}
+export declare namespace ServiceConfig {
+    type Data = {
+        type?: "compose" | "plugin";
+        image?: string;
+        containerName?: string;
+        buildArgs?: EnvConfig;
+        env?: EnvConfig;
+        ports?: string[];
+        volumes?: string[];
+    };
+}

package/lib/makes/ServiceConfig.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceConfig = void 0;
+class ServiceConfig {
+    constructor(original) {
+        this.original = original;
+        this.state = JSON.parse(JSON.stringify(this.original));
+    }
+    get buildArgs() {
+        if (!this.state.buildArgs) {
+            this.state.buildArgs = {};
+        }
+        return this.state.buildArgs;
+    }
+    set buildArgs(buildArgs) {
+        this.state.buildArgs = Object.assign({}, buildArgs);
+    }
+    get env() {
+        if (!this.state.env) {
+            this.state.env = {};
+        }
+        return this.state.env;
+    }
+    set env(env) {
+        this.state.env = Object.assign({}, env);
+    }
+    isDirty() {
+        return JSON.stringify(this.toObject()) !== JSON.stringify(this.original);
+    }
+    toObject() {
+        const { type, image, containerName, buildArgs, env, volumes, ports } = this.state;
+        const object = {};
+        if (type) {
+            object.type = type;
+        }
+        if (image) {
+            object.image = image;
+        }
+        if (containerName) {
+            object.containerName = containerName;
+        }
+        if (buildArgs && Object.keys(buildArgs).length > 0) {
+            object.buildArgs = Object.assign({}, buildArgs);
+        }
+        if (env && Object.keys(env).length > 0) {
+            object.env = Object.assign({}, env);
+        }
+        if (volumes && volumes.length > 0) {
+            object.volumes = [...volumes];
+        }
+        if (ports && ports.length > 0) {
+            object.ports = [...ports];
+        }
+        return object;
+    }
+}
+exports.ServiceConfig = ServiceConfig;

package/lib/makes/index.d.ts

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

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("./Project"), exports);
 __exportStar(require("./Version"), exports);
 __exportStar(require("./VersionRange"), exports);
 __exportStar(require("./VersionRule"), exports);

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

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

package/lib/modules/project/index.js

@@ -14,6 +14,4 @@ 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("./makes/Project"), exports);
-__exportStar(require("./repositories/ProjectRepository"), exports);
 __exportStar(require("./services/ProjectService"), exports);

package/lib/modules/project/services/ProjectService.d.ts

@@ -1,5 +1,5 @@
-import { Project } from "../makes/Project";
-import { ProjectRepository } from "../repositories/ProjectRepository";
+import { Project } from "../../../makes/Project";
+import { ProjectRepository } from "../../../services/ProjectRepository";
 export declare abstract class ProjectService {
     abstract get(name?: string): Project;
     abstract save(project: Project): void;

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/services/ProjectRepository.d.ts

@@ -0,0 +1,22 @@
+import { Project } from "../makes/Project";
+import { ProjectConfig } from "../makes/ProjectConfig";
+import { AppService } from "./AppService";
+import { AppFileSystemService } from "./AppFileSystemService";
+import { FileSystemDriver, 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<{
+        name: string;
+        path: string;
+    }>;
+}