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

package/lib/core/Container.js

@@ -55,8 +55,8 @@ let Container = class Container {
         if (wrapper) {
             wrapper.replace(provider);
         }
-        this.modules.forEach((moduleRef) => {
-            moduleRef.replace(token, provider);
+        this.modules.forEach((moduleWrapper) => {
+            moduleWrapper.replace(token, provider);
         });
     }
 };

package/lib/core/CoreModule.js

@@ -19,6 +19,7 @@ const AppFileSystemService_1 = require("../services/AppFileSystemService");
 const ProcessService_1 = require("../services/ProcessService");
 const EventService_1 = require("../services/EventService");
 const LogService_1 = require("../services/LogService");
+const ProjectRepository_1 = require("../services/ProjectRepository");
 const env_1 = require("../env");
 let CoreModule = class CoreModule {
 };
@@ -43,6 +44,7 @@ exports.CoreModule = CoreModule = __decorate([
             AppService_1.AppService,
             AppConfigService_1.AppConfigService,
             AppFileSystemService_1.AppFileSystemService,
+            ProjectRepository_1.ProjectRepository,
             ProcessService_1.ProcessService,
             EventService_1.EventService,
             LogService_1.LogService
@@ -55,6 +57,7 @@ exports.CoreModule = CoreModule = __decorate([
             AppService_1.AppService,
             AppConfigService_1.AppConfigService,
             AppFileSystemService_1.AppFileSystemService,
+            ProjectRepository_1.ProjectRepository,
             ProcessService_1.ProcessService,
             EventService_1.EventService,
             LogService_1.LogService

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/makes/JsonEditor.d.ts

@@ -0,0 +1,19 @@
+import { JSONPath, Node, ModificationOptions } from "jsonc-parser";
+export declare class JsonEditor<T extends object> {
+    protected readonly original: string;
+    protected content: string;
+    protected root: Node;
+    state: T;
+    constructor(original: string);
+    protected createProxy(keys: JSONPath, options?: JsonEditor.CreateProxyOptions): any;
+    get(key: string | JSONPath): any;
+    set(key: string | JSONPath, value: any, options?: ModificationOptions): void;
+    isDirty(): boolean;
+    toString(): string;
+}
+export declare namespace JsonEditor {
+    type CreateProxyOptions = {
+        isArray?: boolean;
+        removeOnEmpty?: boolean;
+    };
+}

package/lib/makes/JsonEditor.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonEditor = void 0;
+const jsonc_parser_1 = require("jsonc-parser");
+class JsonEditor {
+    constructor(original) {
+        this.original = original;
+        this.content = this.original;
+        this.root = (0, jsonc_parser_1.parseTree)(this.content);
+        this.state = this.createProxy([]);
+    }
+    createProxy(keys, options = {}) {
+        const { isArray, removeOnEmpty } = options;
+        let target = this.get(keys);
+        if (!target) {
+            target = isArray ? [] : {};
+        }
+        return new Proxy(target, {
+            get: (target, property) => {
+                if (target && target.__proto__ && property in target.__proto__) {
+                    if (typeof target[property] === "function") {
+                        return (...args) => {
+                            const res = target[property](...args);
+                            this.set(keys, target, {
+                                formattingOptions: {
+                                    keepLines: false,
+                                    insertSpaces: true
+                                }
+                            });
+                            return res;
+                        };
+                    }
+                    return target[property];
+                }
+                if (Array.isArray(target)) {
+                    property = parseInt(property);
+                }
+                const value = this.get([...keys, property]);
+                if (value !== null && typeof value === "object") {
+                    return this.createProxy([...keys, property]);
+                }
+                return value;
+            },
+            set: (_, property, value) => {
+                if (Array.isArray(_)) {
+                    property = parseInt(property);
+                }
+                this.set([...keys, property], value, {
+                    formattingOptions: {
+                        keepLines: false,
+                        insertSpaces: true
+                    }
+                });
+                if (removeOnEmpty) {
+                    const value = this.get(keys);
+                    if (typeof value === "object" && Object.keys(value).length === 0) {
+                        this.set(keys, undefined);
+                    }
+                }
+                return true;
+            },
+            has: (target, property) => {
+                return property in target;
+            },
+            deleteProperty: (_, property) => {
+                if (Array.isArray(_)) {
+                    property = parseInt(property);
+                }
+                this.set([...keys, property], undefined);
+                if (removeOnEmpty) {
+                    const value = this.get(keys);
+                    if (typeof value === "object" && Object.keys(value).length === 0) {
+                        this.set(keys, undefined);
+                    }
+                }
+                return true;
+            }
+        });
+    }
+    ;
+    get(key) {
+        const path = typeof key === "string" ? key.split(".") : key;
+        const node = (0, jsonc_parser_1.findNodeAtLocation)(this.root, path);
+        if (!node) {
+            return undefined;
+        }
+        return (0, jsonc_parser_1.getNodeValue)(node);
+    }
+    set(key, value, options = {}) {
+        const path = typeof key === "string" ? key.split(".") : key;
+        this.content = (0, jsonc_parser_1.applyEdits)(this.content, (0, jsonc_parser_1.modify)(this.content, path, value, options));
+        this.root = (0, jsonc_parser_1.parseTree)(this.content);
+    }
+    isDirty() {
+        return this.content !== this.original;
+    }
+    toString() {
+        return this.content;
+    }
+}
+exports.JsonEditor = JsonEditor;

package/lib/makes/Project.d.ts

@@ -0,0 +1,63 @@
+import { ProjectConfig } from "./ProjectConfig";
+import { EnvConfig, ProjectConfigScope, ProjectRef, ProjectType } from "../types";
+export declare class Project {
+    name: string;
+    path: string;
+    readonly ref?: ProjectRef;
+    readonly configs: Record<ProjectConfigScope, ProjectConfig>;
+    constructor(name: string, path: string);
+    get type(): ProjectType;
+    set type(type: ProjectType);
+    get containerName(): string;
+    get scripts(): any;
+    get preset(): string | undefined;
+    set preset(preset: string | undefined);
+    get presetMode(): "project" | "global";
+    set presetMode(mode: "project" | "global");
+    get 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(key: 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(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(): any;
+    addExtraHost(host: string, domain: string): void;
+    removeExtraHost(host: string): void;
+    get services(): any;
+    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;
+}

package/lib/makes/Project.js

@@ -0,0 +1,229 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const AsyncStorage_1 = require("../core/AsyncStorage");
+const AppService_1 = require("../services/AppService");
+const ProjectRepository_1 = require("../services/ProjectRepository");
+const volumeParse_1 = require("../utils/volumeParse");
+const types_1 = require("../types");
+class Project {
+    constructor(name, path) {
+        this.name = name;
+        this.path = path;
+        const container = AsyncStorage_1.AsyncStorage.getContainer(), appService = container.get(AppService_1.AppService), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
+        this.ref = appService.getProject(this.name);
+        this.configs = {
+            [types_1.ProjectConfigScope.APP]: projectRepository.getConfig(this.name, types_1.ProjectConfigScope.APP),
+            [types_1.ProjectConfigScope.LOCAL]: projectRepository.getConfig(this.name, types_1.ProjectConfigScope.LOCAL)
+        };
+    }
+    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.project.preset || 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) {
+            return [];
+        }
+        return host.split(",");
+    }
+    hasDomain(domain) {
+        return this.domains.includes(domain);
+    }
+    addDomain(addDomain) {
+        let domains = [
+            ...this.domains.filter((domain) => {
+                return domain !== addDomain;
+            }),
+            addDomain
+        ];
+        this.setEnv("VIRTUAL_HOST", domains.join(","));
+    }
+    removeDomain(removeDomain) {
+        if (!this.hasDomain(removeDomain)) {
+            return;
+        }
+        let domains = this.domains.filter((domain) => {
+            return domain !== removeDomain;
+        });
+        this.setEnv("VIRTUAL_HOST", domains.join(","));
+    }
+    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.configs.app.ports = [
+            ...this.configs.app.ports.filter((link) => {
+                return link !== `${hostPort}:${containerPort}`;
+            }),
+            `${hostPort}:${containerPort}`
+        ];
+    }
+    unlinkPort(hostPort, containerPort) {
+        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(key, value, service) {
+        this.configs.app.setBuildArg(key, value, service);
+    }
+    unsetBuildArg(name, service) {
+        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) {
+        return this.configs.app.hasEnv(name) || this.configs.project.hasEnv(name);
+    }
+    getEnv(key, byDefault) {
+        return this.configs.app.env[key] || this.configs.project.env[key] || byDefault;
+    }
+    setEnv(key, value, service) {
+        this.configs.app.setEnv(key, value, service);
+    }
+    unsetEnv(key, service) {
+        this.configs.app.unsetEnv(key, service);
+    }
+    hasMeta(key) {
+        return this.configs.app.metadata.hasOwnProperty(key) || this.configs.project.metadata.hasOwnProperty(key);
+    }
+    getMeta(key, byDefault) {
+        return this.configs.app.metadata[key] || this.configs.project.metadata[key] || byDefault;
+    }
+    setMeta(name, value) {
+        this.configs.app.metadata[name] = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
+    }
+    unsetMeta(name) {
+        if (name in this.configs.app.metadata) {
+            delete this.configs.app.metadata[name];
+        }
+    }
+    getVolumeBySource(source) {
+        return this.configs.project.getVolumeBySource(source) || this.configs.app.getVolumeBySource(source);
+    }
+    getVolumeByDestination(destination) {
+        return this.configs.project.getVolumeByDestination(destination) || this.configs.app.getVolumeByDestination(destination);
+    }
+    volumeMount(...volumes) {
+        this.configs.app.volumeMount(...volumes);
+    }
+    volumeUnmount(...volumes) {
+        this.configs.app.volumeUnmount(...volumes);
+    }
+    get extraHosts() {
+        return Object.assign(Object.assign({}, this.configs.project.extraHosts), this.configs.app.extraHosts);
+    }
+    ;
+    addExtraHost(host, domain) {
+        this.configs.app.addExtraHost(host, domain);
+    }
+    removeExtraHost(host) {
+        this.configs.app.removeExtraHost(host);
+    }
+    get services() {
+        return this.configs.app.services;
+    }
+    getSecret(key, byDefault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const container = AsyncStorage_1.AsyncStorage.getContainer(), keystoreService = container.get("KEYSTORE_SERVICE");
+            return keystoreService.get(`p:${this.name}:${key}`, byDefault);
+        });
+    }
+    setSecret(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const container = AsyncStorage_1.AsyncStorage.getContainer(), keystoreService = container.get("KEYSTORE_SERVICE");
+            return keystoreService.set(`p:${this.name}:${key}`, value);
+        });
+    }
+    unsetSecret(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const container = AsyncStorage_1.AsyncStorage.getContainer(), keystoreService = container.get("KEYSTORE_SERVICE");
+            return keystoreService.delete(`p:${this.name}:${key}`);
+        });
+    }
+    save() {
+        const container = AsyncStorage_1.AsyncStorage.getContainer(), projectRepository = container.get(ProjectRepository_1.ProjectRepository);
+        projectRepository.save(this);
+    }
+}
+exports.Project = Project;

package/lib/makes/ProjectConfig.d.ts

@@ -0,0 +1,85 @@
+import { FileSystem } from "./FileSystem";
+import { EnvConfig, ProjectType } from "../types";
+import { JsonEditor } from "./JsonEditor";
+import { ServiceConfig } from "./ServiceConfig";
+export declare class ProjectConfig extends JsonEditor<ProjectConfig.Data> {
+    constructor(content: string);
+    get type(): ProjectType | undefined;
+    set type(type: ProjectType | undefined);
+    get buildArgs(): EnvConfig;
+    set buildArgs(buildArgs: EnvConfig);
+    get env(): EnvConfig;
+    set env(env: EnvConfig | undefined);
+    get metadata(): EnvConfig;
+    set metadata(metadata: EnvConfig);
+    get preset(): string | undefined;
+    set preset(preset: string | undefined);
+    get presetMode(): "project" | "global" | undefined;
+    set presetMode(presetMode: "project" | "global" | undefined);
+    get image(): string | undefined;
+    set image(image: string | undefined);
+    get imageName(): string | undefined;
+    set imageName(image: string | undefined);
+    get composefile(): string | undefined;
+    set composefile(composefile: string | undefined);
+    get dockerfile(): string | undefined;
+    set dockerfile(dockerfile: string | undefined);
+    get cmd(): string[] | undefined;
+    set cmd(cmd: string[] | undefined);
+    get scripts(): any;
+    get services(): any;
+    get extraHosts(): any;
+    set extraHosts(extraHosts: any);
+    get volumes(): string[];
+    set volumes(volumes: string[]);
+    get ports(): string[];
+    set ports(ports: string[]);
+    setBuildArg(key: string, value: string, service?: string): void;
+    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;
+    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;
+    addService(name: string, data: ServiceConfig.Data): void;
+    service(name: string): any;
+    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, ProjectConfig.Service>;
+    };
+    type Service = {
+        type?: "compose" | "plugin";
+        containerName?: string;
+        buildArgs?: EnvConfig;
+        env?: EnvConfig;
+        ports?: string[];
+        volumes?: string[];
+    };
+}