@wocker/core 1.0.5 → 1.0.6

package/lib/decorators/Command.d.ts

@@ -0,0 +1 @@
+export declare const Command: (command: string) => MethodDecorator;

package/lib/decorators/Command.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const env_1 = require("../env");
+const Command = (command) => {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(env_1.COMMAND_METADATA, command, descriptor.value);
+    };
+};
+exports.Command = Command;

package/lib/decorators/Completion.d.ts

@@ -0,0 +1 @@
+export declare const Completion: (name: string, command?: string) => MethodDecorator;

package/lib/decorators/Completion.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Completion = void 0;
+const Completion = (name, command) => {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata("completion", [
+            ...Reflect.getMetadata("completion", descriptor.value) || [],
+            {
+                name,
+                command
+            }
+        ], descriptor.value);
+    };
+};
+exports.Completion = Completion;

package/lib/decorators/Controller.d.ts

@@ -0,0 +1,5 @@
+type Params = {
+    command?: string;
+};
+export declare const Controller: (params?: Params) => ClassDecorator;
+export {};

package/lib/decorators/Controller.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const Controller = (params) => {
+    const { command } = params || {};
+    return (target) => {
+        if (!command) {
+            return;
+        }
+        Reflect.defineMetadata("IS_CONTROLLER", true, target);
+        // TODO:
+    };
+};
+exports.Controller = Controller;

package/lib/decorators/Inject.d.ts

@@ -1 +1 @@
-export declare const Inject: () => (target: any) => void;
+export declare const Inject: <T = any>(token?: T) => ParameterDecorator;

package/lib/decorators/Inject.js

@@ -1,8 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Inject = void 0;
-const Inject = () => {
-    return (target) => {
+const env_1 = require("../env");
+const Inject = (token) => {
+    return (target, propertyKey, parameterIndex) => {
+        Reflect.defineMetadata(env_1.SELF_DECLARED_DEPS_METADATA, [
+            ...Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, target) || [],
+            {
+                token: token,
+                index: parameterIndex
+            }
+        ], target);
     };
 };
 exports.Inject = Inject;

package/lib/decorators/Injectable.d.ts

@@ -1,4 +1 @@
-import { DI } from "../makes/DI";
-export declare const Injectable: () => <T extends new (...rest: any[]) => {}>(Target: T) => {
-    new (di: DI): {};
-} & T;
+export declare const Injectable: (token?: string) => ClassDecorator;

package/lib/decorators/Injectable.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injectable = void 0;
-const Injectable = () => {
-    return (Target) => {
-        // @ts-ignore
-        return class extends Target {
-            constructor(di) {
-                const types = Reflect.getMetadata("design:paramtypes", Target);
-                const params = types.map((type) => {
-                    return (di).resolveService(type);
-                });
-                super(...params);
-            }
-        };
+const env_1 = require("../env");
+const Injectable = (token) => {
+    return (target) => {
+        Reflect.defineMetadata(env_1.INJECTABLE_WATERMARK, true, target);
+        if (token) {
+            Reflect.defineMetadata(env_1.INJECT_TOKEN_METADATA, token, target);
+        }
     };
 };
 exports.Injectable = Injectable;

package/lib/decorators/Module.d.ts

@@ -0,0 +1,15 @@
+import { MODULE_METADATA } from "../env";
+import { Provider } from "../types/Provider";
+import { Type } from "../types/Type";
+type Config = {
+    [MODULE_METADATA.NAME]?: string;
+    [MODULE_METADATA.CONTROLLERS]?: any[];
+    [MODULE_METADATA.PROVIDERS]?: Provider[];
+    [MODULE_METADATA.IMPORTS]?: any[];
+    [MODULE_METADATA.EXPORTS]?: any[];
+};
+export type DynamicModule = {
+    providers?: any[];
+};
+export declare const Module: (config: Config) => <T extends Type>(Target: T) => void;
+export {};

package/lib/decorators/Module.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const env_1 = require("../env");
+const Module = (config) => {
+    const { [env_1.MODULE_METADATA.NAME]: name, [env_1.MODULE_METADATA.CONTROLLERS]: controllers = [], [env_1.MODULE_METADATA.PROVIDERS]: providers = [], [env_1.MODULE_METADATA.IMPORTS]: imports = [], [env_1.MODULE_METADATA.EXPORTS]: exports = [] } = config;
+    return (Target) => {
+        Reflect.defineMetadata("isModule", true, Target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.NAME, name, Target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.IMPORTS, imports, Target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.CONTROLLERS, controllers, Target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.PROVIDERS, providers, Target);
+        Reflect.defineMetadata(env_1.MODULE_METADATA.EXPORTS, exports, Target);
+    };
+};
+exports.Module = Module;

package/lib/decorators/Option.d.ts

@@ -0,0 +1,4 @@
+import { Option as O } from "@kearisp/cli";
+type Params = Omit<O, "name">;
+export declare const Option: (name: string, params?: Partial<Params>) => ParameterDecorator;
+export {};

package/lib/decorators/Option.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Option = void 0;
+const env_1 = require("../env");
+const Option = (name, params) => {
+    return (target, key, index) => {
+        if (!key) {
+            return;
+        }
+        Reflect.defineMetadata(env_1.ARGS_METADATA, [
+            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, key) || [],
+            {
+                type: "option",
+                name,
+                params,
+                index
+            }
+        ], target.constructor, key);
+    };
+};
+exports.Option = Option;

package/lib/decorators/Param.d.ts

@@ -0,0 +1 @@
+export declare const Param: (name: string) => MethodDecorator;

package/lib/decorators/Param.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Param = void 0;
+const Param = (name) => {
+    return (target, propertyKey, descriptor) => {
+    };
+};
+exports.Param = Param;

package/lib/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Command";
+export * from "./Completion";
+export * from "./Controller";
+export * from "./Inject";
+export * from "./Injectable";
+export * from "./Module";
+export * from "./Option";

package/lib/decorators/index.js

@@ -0,0 +1,23 @@
+"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("./Command"), exports);
+__exportStar(require("./Completion"), exports);
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Inject"), exports);
+__exportStar(require("./Injectable"), exports);
+__exportStar(require("./Module"), exports);
+__exportStar(require("./Option"), exports);

package/lib/env.d.ts

@@ -0,0 +1,18 @@
+export declare const IS_MODULE = "IS_MODULE";
+export declare const INJECTABLE_WATERMARK = "__injectable__";
+export declare const ARGS_META = "__ARGS__";
+export declare const COMMAND_METADATA = "command";
+export declare const COMPLETION_METADATA = "completion";
+export declare const ARGS_METADATA = "__ARGS__";
+export declare const OPTION_META = "__OPTION_META__";
+export declare const PARAMTYPES_METADATA = "design:paramtypes";
+export declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+export declare const INJECT_TOKEN_METADATA = "INJECT_TOKEN";
+export declare const PLUGIN_DIR_KEY = "PLUGIN_DIR";
+export declare enum MODULE_METADATA {
+    NAME = "name",
+    IMPORTS = "imports",
+    EXPORTS = "exports",
+    CONTROLLERS = "controllers",
+    PROVIDERS = "providers"
+}

package/lib/env.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_METADATA = exports.ARGS_META = exports.INJECTABLE_WATERMARK = exports.IS_MODULE = void 0;
+exports.IS_MODULE = "IS_MODULE";
+exports.INJECTABLE_WATERMARK = "__injectable__";
+exports.ARGS_META = "__ARGS__";
+exports.COMMAND_METADATA = "command";
+exports.COMPLETION_METADATA = "completion";
+exports.ARGS_METADATA = "__ARGS__";
+exports.OPTION_META = "__OPTION_META__";
+exports.PARAMTYPES_METADATA = "design:paramtypes";
+exports.SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+exports.INJECT_TOKEN_METADATA = "INJECT_TOKEN";
+exports.PLUGIN_DIR_KEY = "PLUGIN_DIR";
+var MODULE_METADATA;
+(function (MODULE_METADATA) {
+    MODULE_METADATA["NAME"] = "name";
+    MODULE_METADATA["IMPORTS"] = "imports";
+    MODULE_METADATA["EXPORTS"] = "exports";
+    MODULE_METADATA["CONTROLLERS"] = "controllers";
+    MODULE_METADATA["PROVIDERS"] = "providers";
+})(MODULE_METADATA || (exports.MODULE_METADATA = MODULE_METADATA = {}));

package/lib/index.d.ts

@@ -1,19 +1,6 @@
 export { Cli } from "@kearisp/cli";
-export * from "./decorators/Inject";
-export * from "./decorators/Injectable";
-export * from "./makes/Controller";
-export * from "./makes/DI";
-export * from "./makes/FS";
-export * from "./makes/FSManager";
-export * from "./makes/Logger";
-export * from "./makes/Plugin";
-export * from "./models/Preset";
-export * from "./models/Project";
-export * from "./services/AppConfigService";
-export * from "./services/AppEventsService";
-export * from "./services/DockerService";
-export * from "./services/LogService";
-export * from "./services/PresetService";
-export * from "./services/ProjectService";
-export * from "./types/AppConfig";
-export * from "./types/EnvConfig";
+export * from "./decorators";
+export * from "./makes";
+export * from "./services";
+export * from "./types";
+export { MODULE_METADATA, PLUGIN_DIR_KEY } from "./env";

package/lib/index.js

@@ -14,24 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cli = void 0;
+exports.PLUGIN_DIR_KEY = exports.MODULE_METADATA = exports.Cli = void 0;
 var cli_1 = require("@kearisp/cli");
 Object.defineProperty(exports, "Cli", { enumerable: true, get: function () { return cli_1.Cli; } });
-__exportStar(require("./decorators/Inject"), exports);
-__exportStar(require("./decorators/Injectable"), exports);
-__exportStar(require("./makes/Controller"), exports);
-__exportStar(require("./makes/DI"), exports);
-__exportStar(require("./makes/FS"), exports);
-__exportStar(require("./makes/FSManager"), exports);
-__exportStar(require("./makes/Logger"), exports);
-__exportStar(require("./makes/Plugin"), exports);
-__exportStar(require("./models/Preset"), exports);
-__exportStar(require("./models/Project"), exports);
-__exportStar(require("./services/AppConfigService"), exports);
-__exportStar(require("./services/AppEventsService"), exports);
-__exportStar(require("./services/DockerService"), exports);
-__exportStar(require("./services/LogService"), exports);
-__exportStar(require("./services/PresetService"), exports);
-__exportStar(require("./services/ProjectService"), exports);
-__exportStar(require("./types/AppConfig"), exports);
-__exportStar(require("./types/EnvConfig"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./makes"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+var env_1 = require("./env");
+Object.defineProperty(exports, "MODULE_METADATA", { enumerable: true, get: function () { return env_1.MODULE_METADATA; } });
+Object.defineProperty(exports, "PLUGIN_DIR_KEY", { enumerable: true, get: function () { return env_1.PLUGIN_DIR_KEY; } });

package/lib/makes/Container.d.ts

@@ -0,0 +1,8 @@
+import { Module } from "./Module";
+export declare class Container {
+    modules: Map<any, Module>;
+    hasModule(type: any): boolean;
+    getModule(type: any): Module | undefined;
+    addModule(type: any, module: Module): void;
+    addController(moduleType: any, type: any): void;
+}

package/lib/makes/Container.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+class Container {
+    constructor() {
+        this.modules = new Map();
+    }
+    hasModule(type) {
+        return this.modules.has(type);
+    }
+    getModule(type) {
+        return this.modules.get(type);
+    }
+    addModule(type, module) {
+        this.modules.set(type, module);
+    }
+    addController(moduleType, type) {
+        const module = this.getModule(moduleType);
+        if (!module) {
+            return;
+        }
+        module.addController(type);
+    }
+}
+exports.Container = Container;

package/lib/makes/FSManager.js

@@ -43,8 +43,8 @@ class FSManager {
     path(...parts) {
         return Path.join(this.destination, ...parts);
     }
-    mkdir(path, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    mkdir(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
             const fullPath = Path.join(this.destination, path);
             return new Promise((resolve, reject) => {
                 (0, fs_1.mkdir)(fullPath, options, (err) => {
@@ -120,8 +120,8 @@ class FSManager {
             });
         });
     }
-    rm(path, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    rm(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
             const filePath = Path.join(this.destination, path);
             return new Promise((resolve, reject) => {
                 fs_1.default.rm(filePath, options, (err) => {

package/lib/makes/Factory.d.ts

@@ -0,0 +1,17 @@
+import { Module } from "./Module";
+export declare class Factory {
+    private readonly cli;
+    private readonly container;
+    private routes;
+    private constructor();
+    scan(moduleType: any): Promise<void>;
+    scanModules(moduleType: any, parent?: Module): Promise<Module | undefined>;
+    scanDependencies(): Promise<void>;
+    scanModuleDependencies(module: Module): Promise<void>;
+    scanDynamicModules(): Promise<void>;
+    scanRoutes(): Promise<void>;
+    log(...args: any[]): void;
+    init(): Promise<void>;
+    run(args: string[]): Promise<any>;
+    static create(module: any): Promise<Factory>;
+}

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);
+}