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

package/lib/core/ApplicationContext.d.ts

@@ -1,9 +1,11 @@
-import { Type, InjectionToken } from "../types";
 import { Container } from "./Container";
+import { Type, InjectionToken } from "../types";
+import { ApplicationOptions } from "../types/ApplicationOptions";
 export declare class ApplicationContext {
     protected readonly module: Type;
     protected readonly container: Container;
-    constructor(module: Type, container: Container);
+    protected readonly options: ApplicationOptions;
+    constructor(module: Type, container: Container, options?: ApplicationOptions);
     get<TInput = any, TResult = TInput>(typeOrToken: InjectionToken<TInput>): TResult;
     run(args: string[]): Promise<string>;
 }

package/lib/core/ApplicationContext.js

@@ -14,9 +14,10 @@ const cli_1 = require("@kearisp/cli");
 const AsyncStorage_1 = require("./AsyncStorage");
 const env_1 = require("../env");
 class ApplicationContext {
-    constructor(module, container) {
+    constructor(module, container, options = {}) {
         this.module = module;
         this.container = container;
+        this.options = options;
     }
     get(typeOrToken) {
         const module = this.container.getModule(this.module);

package/lib/core/Factory.d.ts

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

package/lib/core/Factory.js

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

package/lib/core/Scanner.js

@@ -14,8 +14,8 @@ const cli_1 = require("@kearisp/cli");
 const Container_1 = require("./Container");
 const ModuleWrapper_1 = require("./ModuleWrapper");
 const CoreModule_1 = require("./CoreModule");
-const env_1 = require("../env");
 const InstanceWrapper_1 = require("./InstanceWrapper");
+const env_1 = require("../env");
 class Scanner {
     constructor(container) {
         this.container = container || new Container_1.Container();

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,36 +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): {
-        save(): void;
+    static make(fs: FileSystem): AppConfig;
+}
+export declare namespace AppConfig {
+    type Data = {
         debug?: boolean;
         pm?: PackageManagerType;
         keystore?: string;
-        logLevel: "off" | "info" | "warn" | "error";
-        plugins: PluginRef[];
-        presets: PresetRef[];
-        projects: ProjectRef[];
+        plugins?: PluginRef[];
+        presets?: PresetRef[];
+        projects?: ProjectOldRef[];
         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

@@ -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;