@wocker/core 1.0.4 → 1.0.6

package/lib/makes/Factory.js

@@ -0,0 +1,201 @@
+"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.Factory = void 0;
+const cli_1 = require("@kearisp/cli");
+const Container_1 = require("./Container");
+const Module_1 = require("./Module");
+const env_1 = require("../env");
+class Factory {
+    constructor() {
+        this.routes = [];
+        this.container = new Container_1.Container();
+        this.cli = new cli_1.Cli();
+    }
+    scan(moduleType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.container.modules.has(moduleType)) {
+                return;
+            }
+            yield this.scanModules(moduleType);
+            yield this.scanDependencies();
+            yield this.scanDynamicModules();
+            yield this.scanRoutes();
+            yield this.init();
+        });
+    }
+    scanModules(moduleType, parent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.container.hasModule(moduleType)) {
+                return;
+            }
+            const module = new Module_1.Module(moduleType, parent);
+            this.container.addModule(moduleType, module);
+            const modules = Reflect.getMetadata(env_1.MODULE_METADATA.IMPORTS, moduleType) || [];
+            for (const subModuleType of modules) {
+                yield this.scanModules(subModuleType, module);
+            }
+            // const exports = Reflect.getMetadata(MODULE_METADATA.EXPORTS, moduleType) || [];
+            return module;
+        });
+    }
+    scanDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [, module] of this.container.modules) {
+                yield this.scanModuleDependencies(module);
+            }
+        });
+    }
+    scanModuleDependencies(module) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const providers = Reflect.getMetadata(env_1.MODULE_METADATA.PROVIDERS, module.type) || [];
+            module.addProvider(cli_1.Cli, this.cli);
+            providers.forEach((providerType) => {
+                module.addProvider(providerType);
+            });
+            const controllers = Reflect.getMetadata(env_1.MODULE_METADATA.CONTROLLERS, module.type) || [];
+            controllers.forEach((controller) => {
+                module.addController(controller);
+            });
+        });
+    }
+    scanDynamicModules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [moduleType, module] of this.container.modules) {
+                if (moduleType.prototype.load) {
+                    const { imports } = yield moduleType.prototype.load(this.container);
+                    for (const type of imports) {
+                        const isModule = Reflect.getMetadata("isModule", type);
+                        if (!isModule) {
+                            continue;
+                        }
+                        const subModule = yield this.scanModules(type, module);
+                        if (subModule) {
+                            yield this.scanModuleDependencies(subModule);
+                        }
+                    }
+                }
+            }
+        });
+    }
+    scanRoutes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [, module] of this.container.modules) {
+                for (const [type, controller] of module.controllers) {
+                    const controllerCommands = [];
+                    const controllerCompletions = [];
+                    for (const name of Object.getOwnPropertyNames(type.prototype)) {
+                        const descriptor = Object.getOwnPropertyDescriptor(type.prototype, name);
+                        if (!descriptor) {
+                            continue;
+                        }
+                        const commandName = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value);
+                        const completions = (Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || []).map((completion) => {
+                            return Object.assign(Object.assign({}, completion), { method: name });
+                        });
+                        if (completions.length > 0) {
+                            controllerCompletions.push(...completions);
+                        }
+                        if (commandName) {
+                            controllerCommands.push({
+                                command: commandName,
+                                controller,
+                                method: name,
+                                argsMeta: Reflect.getMetadata(env_1.ARGS_METADATA, type, name) || []
+                            });
+                            const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, type, name) || [];
+                            const command = this.cli.command(commandName);
+                            for (const argMeta of argsMeta) {
+                                if (argMeta.type === "option") {
+                                    command.option(argMeta.name, argMeta.params);
+                                }
+                            }
+                            // command.action((options, ...params) => {
+                            //     const args: any[] = [];
+                            //
+                            //     argsMeta.forEach((argMeta: any) => {
+                            //         if(argMeta.type === "option") {
+                            //             args[argMeta.index] = options[argMeta.name];
+                            //         }
+                            //     });
+                            //
+                            //     return controller.instance[name](...args, ...params);
+                            // });
+                        }
+                    }
+                    for (const controllerCommand of controllerCommands) {
+                        const { command: commandName, method, argsMeta } = controllerCommand;
+                        this.cli.command(commandName)
+                            .action((options, ...params) => {
+                            const args = [];
+                            argsMeta.forEach((argMeta) => {
+                                if (argMeta.type === "option") {
+                                    args[argMeta.index] = options[argMeta.name];
+                                }
+                            });
+                            return controller.instance[method](...args, ...params);
+                        });
+                    }
+                    for (const controllerCompletion of controllerCompletions) {
+                        const { name, command: commandName, method } = controllerCompletion;
+                        if (!commandName) {
+                            for (const route of controllerCommands) {
+                                const { command } = route;
+                                this.cli.command(command).completion(name, () => {
+                                    return controller.instance[method]();
+                                });
+                            }
+                        }
+                        else {
+                            this.cli.command(commandName).completion(name, () => {
+                                return controller.instance[method]();
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    }
+    log(...args) {
+        for (const [, module] of this.container.modules) {
+            module.providers.forEach((provider) => {
+                if (provider.instance.info) {
+                    provider.instance.info(...args);
+                }
+            });
+        }
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [, module] of this.container.modules) {
+                module.providers.forEach((provider) => {
+                    provider.instance;
+                });
+                module.controllers.forEach((controller) => {
+                    controller.instance;
+                });
+            }
+        });
+    }
+    run(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cli.run(args);
+        });
+    }
+    static create(module) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factory = new this();
+            yield factory.scan(module);
+            return factory;
+        });
+    }
+}
+exports.Factory = Factory;

package/lib/makes/InstanceWrapper.d.ts

@@ -0,0 +1,10 @@
+import { Module } from "./Module";
+export declare class InstanceWrapper {
+    private readonly module;
+    private readonly token;
+    private readonly provider;
+    private _instance?;
+    constructor(module: Module, token: any, provider: any, _instance?: any);
+    get instance(): any;
+    set instance(instance: any);
+}

package/lib/makes/InstanceWrapper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceWrapper = void 0;
+const env_1 = require("../env");
+class InstanceWrapper {
+    constructor(module, token, provider, _instance) {
+        this.module = module;
+        this.token = token;
+        this.provider = provider;
+        this._instance = _instance;
+    }
+    get instance() {
+        if (!this.provider) {
+            return null;
+        }
+        if (!this._instance) {
+            const types = [
+                ...Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.provider) || []
+            ];
+            const selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this.provider) || [];
+            if (selfTypes.length > 0) {
+                selfTypes.forEach(({ index, token }) => {
+                    types[index] = token;
+                });
+            }
+            const params = types.map((type) => {
+                const wrapper = this.module.getWrapper(type);
+                if (!wrapper) {
+                    return undefined;
+                }
+                return wrapper.instance;
+            });
+            this._instance = new this.provider(...params);
+        }
+        return this._instance;
+    }
+    set instance(instance) {
+        this._instance = instance;
+    }
+}
+exports.InstanceWrapper = InstanceWrapper;

package/lib/makes/Logger.d.ts

@@ -1,9 +1,8 @@
-import { DI } from "./DI";
-declare class Logger {
-    static install(di: DI): void;
+import { LogService } from "../services/LogService";
+export declare class Logger {
+    static install(ls: LogService): void;
     static log(...data: any[]): void;
     static info(...data: any[]): void;
-    static warning(...data: any[]): void;
+    static warn(...data: any[]): void;
     static error(...data: any[]): void;
 }
-export { Logger };

package/lib/makes/Logger.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const LogService_1 = require("../services/LogService");
-let _di;
+let loggerService;
 class Logger {
-    static install(di) {
-        _di = di;
+    static install(ls) {
+        loggerService = ls;
     }
     static log(...data) {
-        _di.resolveService(LogService_1.LogService).log(...data);
+        loggerService.log(...data);
     }
     static info(...data) {
-        _di.resolveService(LogService_1.LogService).info(...data);
+        loggerService.info(...data);
     }
-    static warning(...data) {
-        _di.resolveService(LogService_1.LogService).warning(...data);
+    static warn(...data) {
+        loggerService.warn(...data);
     }
     static error(...data) {
-        _di.resolveService(LogService_1.LogService).error(...data);
+        loggerService.error(...data);
     }
 }
 exports.Logger = Logger;

package/lib/makes/Module.d.ts

@@ -0,0 +1,17 @@
+import { Provider } from "../types/Provider";
+import { InstanceWrapper } from "./InstanceWrapper";
+export declare class Module {
+    type: any;
+    parent?: Module | undefined;
+    imports: Set<any>;
+    controllers: Map<any, InstanceWrapper>;
+    providers: Map<any, InstanceWrapper>;
+    exports: Map<any, any>;
+    constructor(type: any, parent?: Module | undefined);
+    get<T = any>(type: any): T;
+    getWrapper(type: any): InstanceWrapper | undefined;
+    addImport(module: any): void;
+    addProvider(provider: Provider, instance?: any): void;
+    addInjection(): void;
+    addController(type: any): void;
+}

package/lib/makes/Module.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const InstanceWrapper_1 = require("./InstanceWrapper");
+const env_1 = require("../env");
+class Module {
+    constructor(type, parent) {
+        this.type = type;
+        this.parent = parent;
+        this.imports = new Set();
+        this.controllers = new Map();
+        this.providers = new Map();
+        this.exports = new Map();
+    }
+    get(type) {
+        const wrapper = this.getWrapper(type);
+        if (!wrapper) {
+            throw new Error("Provider not found");
+        }
+        return wrapper.instance;
+    }
+    getWrapper(type) {
+        const token = typeof type !== "string"
+            ? Reflect.getMetadata(env_1.INJECT_TOKEN_METADATA, type) || type
+            : type;
+        const wrapper = this.providers.get(token);
+        if (!wrapper && this.parent) {
+            return this.parent.getWrapper(type);
+        }
+        return wrapper;
+    }
+    addImport(module) {
+        this.imports.add(module);
+    }
+    addProvider(provider, instance) {
+        if ("provide" in provider && "useValue" in provider) {
+            const wrapper = new InstanceWrapper_1.InstanceWrapper(this, provider.provide, provider.provide, provider.useValue);
+            this.providers.set(provider.provide, wrapper);
+            return;
+        }
+        const token = Reflect.getMetadata("INJECT_TOKEN", provider) || provider;
+        const wrapper = new InstanceWrapper_1.InstanceWrapper(this, token, provider, instance);
+        this.providers.set(token, wrapper);
+    }
+    addInjection() {
+        //
+    }
+    addController(type) {
+        this.controllers.set(type, new InstanceWrapper_1.InstanceWrapper(this, type, type));
+        for (const name of Object.getOwnPropertyNames(type.prototype)) {
+            const descriptor = Object.getOwnPropertyDescriptor(type.prototype, name);
+            if (!descriptor) {
+                continue;
+            }
+            const command = Reflect.getMetadata("command", descriptor.value);
+            if (!command) {
+                continue;
+            }
+            // console.log(">", name, command);
+        }
+    }
+}
+exports.Module = Module;

package/lib/makes/Plugin.d.ts

@@ -1,6 +1,4 @@
 import { Cli } from "@kearisp/cli";
-import { Controller } from "./Controller";
-declare class Plugin extends Controller {
+export declare class Plugin {
     install(cli: Cli): void;
 }
-export { Plugin };

package/lib/makes/Plugin.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
-const Controller_1 = require("./Controller");
-class Plugin extends Controller_1.Controller {
+class Plugin {
     install(cli) {
-        super.install(cli);
+        //
     }
 }
 exports.Plugin = Plugin;

package/lib/{models → makes}/Preset.d.ts

@@ -1,6 +1,6 @@
-import { DI } from "../makes/DI";
+import { DI } from "./DI";
 import { PresetServiceSearchOptions as SearchOptions } from "../services/PresetService";
-import { EnvConfig } from "../types/EnvConfig";
+import { EnvConfig } from "../types";
 type TextOption = {
     type: "string" | "number" | "int";
     message?: string;
@@ -40,7 +40,7 @@ declare class Preset {
     save(): Promise<void>;
     getImageName(buildArgs?: EnvConfig): string;
     static install(di: DI): void;
-    static search(options: SearchOptions): Promise<Preset[]>;
-    static searchOne(options: SearchOptions): Promise<Preset | null | undefined>;
+    static search(options: SearchOptions): Promise<any[]>;
+    static searchOne(options: SearchOptions): Promise<any>;
 }
 export { Preset };

package/lib/{models → makes}/Project.d.ts

@@ -1,12 +1,11 @@
-import "reflect-metadata";
-import { DI } from "../makes/DI";
-import { EnvConfig } from "../types/EnvConfig";
+import { PickProperties, EnvConfig } from "../types";
+import { DI } from "./DI";
 type SearchOptions = {
     id: string;
     name: string;
     path: string;
 };
-declare class Project {
+export declare class Project {
     id: string;
     name: string;
     type: string;
@@ -16,18 +15,23 @@ declare class Project {
     dockerfile?: string;
     scripts?: string[];
     buildArgs?: EnvConfig;
-    env: EnvConfig;
-    volumes?: string[];
+    env?: EnvConfig;
     ports?: string[];
-    static di?: DI;
-    constructor(data: any);
+    volumes?: string[];
+    metadata?: EnvConfig;
+    protected constructor(data: PickProperties<Project>);
+    get containerName(): string;
     hasEnv(name: string): boolean;
     getEnv(name: string, defaultValue?: string): string | undefined;
     setEnv(name: string, value: string | boolean): void;
     unsetEnv(name: string): void;
-    volumeMount(...volumes: string[]): void;
+    hasMeta(name: string): boolean;
+    getMeta<D = string | undefined>(name: string, defaultValue?: D): D;
+    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;
     save(): Promise<void>;
     static install(di: DI): void;
@@ -35,6 +39,6 @@ declare class Project {
     static search(params?: Partial<SearchOptions>): Promise<Project[]>;
     static searchOne(params: Partial<SearchOptions>): Promise<Project | null>;
 }
-export { Project };
 export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
 export declare const PROJECT_TYPE_IMAGE = "image";
+export {};

package/lib/{models → makes}/Project.js

@@ -10,11 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = exports.Project = void 0;
-require("reflect-metadata");
-const AppConfigService_1 = require("../services/AppConfigService");
-const ProjectService_1 = require("../services/ProjectService");
 const volumeParse_1 = require("../utils/volumeParse");
-let appConfig;
+const services_1 = require("../services");
 let projectService;
 class Project {
     constructor(data) {
@@ -23,13 +20,18 @@ class Project {
         this.type = data.type;
         this.path = data.path;
         this.preset = data.preset;
-        this.dockerfile = data.dockerfile;
         this.imageName = data.imageName;
+        this.dockerfile = data.dockerfile;
         this.scripts = data.scripts;
         this.buildArgs = data.buildArgs;
-        this.env = data.env || {};
+        this.env = data.env;
         this.ports = data.ports;
         this.volumes = data.volumes;
+        this.metadata = data.metadata;
+        Object.assign(this, data);
+    }
+    get containerName() {
+        return `${this.name}.workspace`;
     }
     hasEnv(name) {
         if (!this.env) {
@@ -38,18 +40,63 @@ class Project {
         return this.env.hasOwnProperty(name);
     }
     getEnv(name, defaultValue) {
-        const { [name]: value = defaultValue } = this.env;
+        const { [name]: value = defaultValue } = this.env || {};
         return value;
     }
     setEnv(name, value) {
-        this.env = Object.assign(Object.assign({}, this.env), { [name]: typeof value === "boolean"
-                ? (value ? "true" : "false")
-                : value });
+        if (!this.env) {
+            this.env = {};
+        }
+        this.env[name] = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
     }
     unsetEnv(name) {
+        if (!this.env) {
+            return;
+        }
         if (name in this.env) {
             delete this.env[name];
         }
+        if (Object.keys(this.env).length === 0) {
+            delete this.env;
+        }
+    }
+    hasMeta(name) {
+        return !!this.metadata && this.metadata.hasOwnProperty(name);
+    }
+    getMeta(name, defaultValue) {
+        const { [name]: value = defaultValue } = this.metadata || {};
+        return value;
+    }
+    setMeta(name, value) {
+        if (!this.metadata) {
+            this.metadata = {};
+        }
+        this.metadata[name] = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
+    }
+    unsetMeta(name) {
+        if (!this.metadata) {
+            return;
+        }
+        if (name in this.metadata) {
+            delete this.metadata[name];
+        }
+        if (Object.keys(this.metadata).length === 0) {
+            delete this.metadata;
+        }
+    }
+    getVolumeBySource(source) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
+        });
     }
     volumeMount(...volumes) {
         if (volumes.length === 0) {
@@ -65,16 +112,6 @@ class Project {
         ];
         this.volumeMount(...restVolumes);
     }
-    getVolumeBySource(source) {
-        return (this.volumes || []).find((volume) => {
-            return (0, volumeParse_1.volumeParse)(volume).source === source;
-        });
-    }
-    getVolumeByDestination(destination) {
-        return (this.volumes || []).find((volume) => {
-            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
-        });
-    }
     volumeUnmount(...volumes) {
         this.volumes = (this.volumes || []).filter((mounted) => {
             return !volumes.includes(mounted);
@@ -89,14 +126,13 @@ class Project {
         });
     }
     static install(di) {
-        appConfig = di.resolveService(AppConfigService_1.AppConfigService);
-        projectService = di.resolveService(ProjectService_1.ProjectService);
+        projectService = di.resolveService(services_1.ProjectService);
     }
     static fromObject(data) {
         return new Project(data);
     }
-    static search(params = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    static search() {
+        return __awaiter(this, arguments, void 0, function* (params = {}) {
             if (!projectService) {
                 throw new Error("Dependency is missing");
             }

package/lib/makes/Scanner.d.ts

@@ -0,0 +1,4 @@
+export declare class Scanner {
+    constructor();
+    scan(module: any): void;
+}

package/lib/makes/Scanner.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+class Scanner {
+    constructor() { }
+    scan(module) {
+    }
+}
+exports.Scanner = Scanner;

package/lib/makes/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./Container";
+export * from "./DI";
+export * from "./FS";
+export * from "./FSManager";
+export * from "./Logger";
+export * from "./Plugin";
+export * from "./Preset";
+export * from "./Project";
+export * from "./Factory";

package/lib/makes/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./Container"), exports);
+__exportStar(require("./DI"), exports);
+__exportStar(require("./FS"), exports);
+__exportStar(require("./FSManager"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./Plugin"), exports);
+__exportStar(require("./Preset"), exports);
+__exportStar(require("./Project"), exports);
+__exportStar(require("./Factory"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,4 +1,4 @@
-import { AppConfig } from "../types/AppConfig";
+import { AppConfig } from "../types";
 type TypeMap = {
     [type: string]: string;
 };