@wocker/core 1.0.22-beta.0 → 1.0.22-beta.1

package/README.md

@@ -2,6 +2,14 @@
 
 ###### Docker workspace for web projects
 
+[![npm version](https://img.shields.io/npm/v/@wocker/core.svg)](https://www.npmjs.com/package/@wocker/core)
+[![Publish](https://github.com/kearisp/wocker-core/actions/workflows/publish-latest.yml/badge.svg?event=release)](https://github.com/kearisp/wocker-core/actions/workflows/publish-latest.yml)
+[![License](https://img.shields.io/npm/l/@wocker/core)](https://github.com/kearisp/wocker-core/blob/main/LICENSE)
+
+[![npm total downloads](https://img.shields.io/npm/dt/@wocker/core.svg)](https://www.npmjs.com/package/@wocker/core)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/@wocker/core)](https://bundlephobia.com/package/@wocker/core)
+![Coverage](https://gist.githubusercontent.com/kearisp/f17f46c6332ea3bb043f27b0bddefa9f/raw/coverage-wocker-core-latest.svg)
+
 ## Installation
 
 **Note:** It is recommended to install Wocker globally to ensure accessibility from any directory in your terminal.

package/lib/core/ApplicationContext.js

@@ -33,21 +33,23 @@ class ApplicationContext {
             cli.command("").action(() => {
                 const module = this.container.getModule(this.module);
                 for (const [, container] of module.controllers) {
-                    const description = container.getDescription();
-                    if (!description) {
+                    if (!container.description) {
                         continue;
                     }
-                    console.info(`${description}:`);
-                    const routes = container.getRoutes();
-                    const spaceLength = routes.reduce((space, route) => {
-                        return Math.max(space, route.command.length + 2);
+                    console.info(`${container.description}:`);
+                    const spaceLength = container.commands.reduce((space, route) => {
+                        return route.commandNames.reduce((space, command) => {
+                            return Math.max(space, command.length + 2);
+                        }, space);
                     }, 0);
-                    for (const route of routes) {
+                    for (const route of container.commands) {
                         if (!route.description) {
                             continue;
                         }
-                        const space = " ".repeat(Math.max(0, spaceLength - route.command.length));
-                        console.info(`  ${route.command} ${space} ${route.description}`);
+                        for (const commandName of route.commandNames) {
+                            const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
+                            console.info(`  ${commandName} ${space} ${route.description}`);
+                        }
                     }
                     console.info("");
                 }

package/lib/core/ControllerWrapper.d.ts

@@ -1,13 +1,16 @@
 import "reflect-metadata";
+import { CommandInput } from "@kearisp/cli";
 import { InstanceWrapper } from "./InstanceWrapper";
 import { Module } from "./Module";
 import { Type } from "../types/Type";
 import { Route } from "./Route";
-import { RouteCompletion } from "./RouteCompletion";
 export declare class ControllerWrapper<TInput = any> extends InstanceWrapper {
     readonly type: Type<TInput>;
+    description?: string;
+    commands: Route[];
+    completions: Route[];
     constructor(module: Module, type: Type<TInput>);
-    getDescription(): string | undefined;
     getRoutes(): Route[];
-    getCompletions(): RouteCompletion[];
+    getCompletionCommands(name: string, command: string): Route[];
+    run(route: Route, input: CommandInput): any;
 }

package/lib/core/ControllerWrapper.js

@@ -2,84 +2,76 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerWrapper = void 0;
 require("reflect-metadata");
-const env_1 = require("../env");
 const InstanceWrapper_1 = require("./InstanceWrapper");
 const Route_1 = require("./Route");
-const RouteCompletion_1 = require("./RouteCompletion");
 class ControllerWrapper extends InstanceWrapper_1.InstanceWrapper {
     constructor(module, type) {
         super(module, type);
-    }
-    getDescription() {
-        return Reflect.getMetadata("CONTROLLER_DESCRIPTION", this.type);
-        // || this.type.prototype.constructor.name;
-    }
-    getRoutes() {
-        const routes = [];
+        this.commands = [];
+        this.completions = [];
         if (!this.type) {
-            return [];
+            return;
         }
+        this.description = Reflect.getMetadata("CONTROLLER_DESCRIPTION", this.type) || "";
         for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
-            const descriptor = Object.getOwnPropertyDescriptor(this.type.prototype, method);
-            if (!descriptor) {
-                continue;
+            const route = new Route_1.Route(this.type, method);
+            if (route.isCommand) {
+                this.commands.push(route);
             }
-            const commandNames = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value) || [];
-            if (commandNames.length === 0) {
-                continue;
+            else if (route.isCompletion) {
+                this.completions.push(route);
             }
-            const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, this.type, method) || [];
-            const designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type.prototype, method) || [];
-            const description = Reflect.getMetadata(env_1.COMMAND_DESCRIPTION_METADATA, descriptor.value);
-            for (const commandName of commandNames) {
-                const route = new Route_1.Route(method, commandName, argsMeta, designTypes, description);
-                routes.push(route);
+            else {
+                // TODO: Log
             }
         }
-        return routes;
     }
-    getCompletions() {
-        const routes = [], allCommandNames = [], allCompletions = [];
+    getRoutes() {
+        const routes = [];
         if (!this.type) {
-            return routes;
+            return [];
         }
         for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
-            const descriptor = Object.getOwnPropertyDescriptor(this.type.prototype, method);
-            if (!descriptor) {
-                continue;
-            }
-            const commandNames = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value) || [];
-            if (commandNames.length > 0) {
-                allCommandNames.push(...commandNames);
-            }
-            const completionsData = Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [];
-            if (completionsData.length > 0) {
-                for (const completionData of completionsData) {
-                    allCompletions.push(Object.assign(Object.assign({}, completionData), { method }));
-                }
-            }
-        }
-        allCompletions.sort((a, b) => {
-            return a.command < b.command ? -1 : 1;
-        });
-        for (const data of allCompletions) {
-            const commandNames = data.command
-                ? [data.command]
-                : allCommandNames.filter((commandName) => {
-                    return !allCompletions.filter((c) => {
-                        return c.name === data.name && typeof c.command !== "undefined";
-                    }).map((c) => {
-                        return c.method;
-                    }).includes(commandName);
-                });
-            const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, this.type, data.method) || [];
-            const designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type.prototype, data.method) || [];
-            for (const commandName of commandNames) {
-                const route = new RouteCompletion_1.RouteCompletion(data.method, data.name, commandName, argsMeta, designTypes);
+            const route = new Route_1.Route(this.type, method);
+            if (route.isCommand || route.isCompletion) {
                 routes.push(route);
             }
         }
         return routes;
     }
+    getCompletionCommands(name, command) {
+        const completions = this.completions.filter((route) => {
+            return route.completions.filter((completion) => {
+                return completion.name === name && completion.command === command;
+            }).length > 0;
+        });
+        if (completions.length > 0) {
+            return completions;
+        }
+        return this.completions.filter((route) => {
+            return route.completions.filter((completion) => {
+                return completion.name === name && !completion.command;
+            });
+        });
+    }
+    run(route, input) {
+        const args = [];
+        route.args.forEach((arg, index) => {
+            switch (arg.type) {
+                case "param":
+                    args[index] = input.argument(arg.name);
+                    break;
+                case "option":
+                    if (route.designTypes[index] === Array) {
+                        args[index] = input.options(arg.name);
+                    }
+                    else {
+                        args[index] = input.option(arg.name);
+                    }
+                    break;
+            }
+        });
+        return this.instance[route.method](...args);
+    }
 }
 exports.ControllerWrapper = ControllerWrapper;

package/lib/core/Route.d.ts

@@ -1,10 +1,23 @@
-import { CommandInput } from "@kearisp/cli";
+import { ArgMeta } from "../types/ArgMeta";
+import { Type } from "../types/Type";
 export declare class Route {
+    readonly type: Type;
     readonly method: string;
-    readonly command: string;
-    readonly argsMeta: any[];
-    readonly designTypes: any[];
-    readonly description?: string | undefined;
-    constructor(method: string, command: string, argsMeta: any[], designTypes: any[], description?: string | undefined);
-    getArgs(input: CommandInput): any[];
+    description?: string;
+    args: {
+        type: "param" | "option";
+        name: string;
+        params: any;
+    }[];
+    argsMeta: ArgMeta[];
+    designTypes: any[];
+    commandNames: string[];
+    completions: {
+        name: string;
+        command?: string;
+    }[];
+    constructor(type: Type, method: string);
+    get isCommand(): boolean;
+    get isCompletion(): boolean;
+    getArgType(index: number): string | undefined;
 }

package/lib/core/Route.js

@@ -1,32 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Route = void 0;
+const env_1 = require("../env");
 class Route {
-    constructor(method, command, argsMeta, designTypes, description) {
+    constructor(type, method) {
+        this.type = type;
         this.method = method;
-        this.command = command;
+        this.args = [];
+        this.argsMeta = [];
+        this.designTypes = [];
+        this.commandNames = [];
+        this.completions = [];
+        const descriptor = Object.getOwnPropertyDescriptor(this.type.prototype, this.method);
+        if (!descriptor) {
+            return;
+        }
+        this.description = Reflect.getMetadata(env_1.COMMAND_DESCRIPTION_METADATA, descriptor.value) || "";
+        this.commandNames = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value) || [];
+        this.completions = Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [];
+        const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, this.type, this.method) || [], argsAliases = Reflect.getMetadata(env_1.ALIAS_METADATA, this.type, this.method) || {}, argsDescription = Reflect.getMetadata(env_1.ARGS_DESCRIPTION_METADATA, this.type, method) || {}, designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type.prototype, this.method) || [];
         this.argsMeta = argsMeta;
         this.designTypes = designTypes;
-        this.description = description;
-    }
-    getArgs(input) {
-        const args = [];
-        this.argsMeta.forEach((argMeta) => {
-            switch (argMeta.type) {
-                case "param":
-                    args[argMeta.index] = input.argument(argMeta.name);
-                    break;
-                case "option":
-                    if (this.designTypes[argMeta.index] === Array) {
-                        args[argMeta.index] = input.options(argMeta.name);
-                    }
-                    else {
-                        args[argMeta.index] = input.option(argMeta.name);
+        for (let i = 0; i < argsMeta.length; i++) {
+            const argMeta = argsMeta[i];
+            if (argMeta.type === "param") {
+                this.args[argMeta.index] = {
+                    type: argMeta.type,
+                    name: argMeta.name,
+                    params: {
+                        description: argsDescription[argMeta.index] || ""
                     }
-                    break;
+                };
+            }
+            if (argMeta.type === "option") {
+                const { type, alias, description } = argMeta.params || {};
+                this.args[argMeta.index] = {
+                    type: argMeta.type,
+                    name: argMeta.name,
+                    params: Object.assign(Object.assign({}, argMeta.params), { type: this.getArgType(argMeta.index) || type, alias: argsAliases[argMeta.index] || alias, description: argsDescription[argMeta.index] || description })
+                };
             }
-        });
-        return args;
+        }
+    }
+    get isCommand() {
+        return this.commandNames.length > 0;
+    }
+    get isCompletion() {
+        return this.completions.length > 0;
+    }
+    getArgType(index) {
+        switch (this.designTypes[index]) {
+            case String:
+                return "string";
+            case Boolean:
+                return "boolean";
+            case Number:
+                return "number";
+            default:
+                return undefined;
+        }
     }
 }
 exports.Route = Route;

package/lib/core/Scanner.js

@@ -94,26 +94,30 @@ class Scanner {
         }
     }
     scanControllerRoutes(cli, wrapper) {
-        for (const route of wrapper.getRoutes()) {
-            const command = cli.command(route.command);
-            if (route.description) {
-                command.help({
-                    description: route.description
+        for (const route of wrapper.commands) {
+            for (const commandName of route.commandNames) {
+                const command = cli.command(commandName);
+                if (route.description) {
+                    command.help({
+                        description: route.description
+                    });
+                }
+                command.action((input) => {
+                    return wrapper.run(route, input);
                 });
-            }
-            route.argsMeta.forEach((argMeta) => {
-                if (argMeta.type === "option") {
-                    command.option(argMeta.name, argMeta.params);
+                for (const arg of route.args) {
+                    if (arg.type === "option") {
+                        command.option(arg.name, arg.params);
+                    }
+                    command.completion(arg.name, (input) => {
+                        const [completion] = wrapper.getCompletionCommands(arg.name, commandName);
+                        if (!completion) {
+                            return [];
+                        }
+                        return wrapper.run(completion, input);
+                    });
                 }
-            });
-            command.action((input) => {
-                return wrapper.instance[route.method](...route.getArgs(input));
-            });
-        }
-        for (const completion of wrapper.getCompletions()) {
-            cli.command(completion.command).completion(completion.name, (input) => {
-                return wrapper.instance[completion.method](...completion.getArgs(input));
-            });
+            }
         }
     }
     scanDynamicModules() {

package/lib/decorators/Completion.js

@@ -6,11 +6,11 @@ const env_1 = require("../env");
 const Completion = (name, command) => {
     return (_target, _propertyKey, descriptor) => {
         Reflect.defineMetadata(env_1.COMPLETION_METADATA, [
-            ...Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [],
             {
                 name,
                 command
-            }
+            },
+            ...Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || []
         ], descriptor.value);
     };
 };

package/lib/decorators/Description.js

@@ -24,13 +24,7 @@ const Description = (description) => {
             return;
         }
         // Parameter
-        Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, [
-            {
-                index: descriptorOrIndex,
-                description
-            },
-            ...Reflect.getMetadata(env_1.COMMAND_DESCRIPTION_METADATA, target.constructor, propertyKey) || []
-        ], target.constructor, propertyKey);
+        Reflect.defineMetadata(env_1.ARGS_DESCRIPTION_METADATA, Object.assign(Object.assign({}, Reflect.getMetadata(env_1.ARGS_DESCRIPTION_METADATA, target.constructor, propertyKey) || {}), { [descriptorOrIndex]: description }), target.constructor, propertyKey);
     };
 };
 exports.Description = Description;

package/lib/decorators/Option.d.ts

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

package/lib/decorators/Option.js

@@ -9,13 +9,13 @@ const Option = (name, params) => {
             return;
         }
         Reflect.defineMetadata(env_1.ARGS_METADATA, [
-            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, key) || [],
             {
                 type: "option",
                 name,
-                params,
+                params: typeof params === "string" ? { alias: params } : params,
                 index
-            }
+            },
+            ...Reflect.getMetadata(env_1.ARGS_METADATA, target.constructor, key) || []
         ], target.constructor, key);
     };
 };

package/lib/env.d.ts

@@ -6,6 +6,8 @@ export declare const COMMAND_METADATA = "command";
 export declare const COMMAND_DESCRIPTION_METADATA = "__COMMAND_DESCRIPTION__";
 export declare const COMPLETION_METADATA = "completion";
 export declare const ARGS_METADATA = "__ARGS__";
+export declare const ALIAS_METADATA = "__ALIAS_METADATA__";
+export declare const ARGS_DESCRIPTION_METADATA = "__ARGS_DESCRIPTION__";
 export declare const OPTION_META = "__OPTION_META__";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";

package/lib/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULE_METADATA = exports.PLUGIN_NAME_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_DESCRIPTION_METADATA = exports.COMMAND_METADATA = exports.ARGS_META = exports.INJECTABLE_WATERMARK = exports.IS_MODULE_METADATA = exports.IS_GLOBAL_METADATA = void 0;
+exports.MODULE_METADATA = exports.PLUGIN_NAME_METADATA = exports.PLUGIN_DIR_KEY = exports.INJECT_TOKEN_METADATA = exports.SELF_DECLARED_DEPS_METADATA = exports.PARAMTYPES_METADATA = exports.OPTION_META = exports.ARGS_DESCRIPTION_METADATA = exports.ALIAS_METADATA = exports.ARGS_METADATA = exports.COMPLETION_METADATA = exports.COMMAND_DESCRIPTION_METADATA = exports.COMMAND_METADATA = exports.ARGS_META = exports.INJECTABLE_WATERMARK = exports.IS_MODULE_METADATA = exports.IS_GLOBAL_METADATA = void 0;
 exports.IS_GLOBAL_METADATA = "IS_GLOBAL";
 exports.IS_MODULE_METADATA = "isModule";
 exports.INJECTABLE_WATERMARK = "__injectable__";
@@ -9,6 +9,8 @@ exports.COMMAND_METADATA = "command";
 exports.COMMAND_DESCRIPTION_METADATA = "__COMMAND_DESCRIPTION__";
 exports.COMPLETION_METADATA = "completion";
 exports.ARGS_METADATA = "__ARGS__";
+exports.ALIAS_METADATA = "__ALIAS_METADATA__";
+exports.ARGS_DESCRIPTION_METADATA = "__ARGS_DESCRIPTION__";
 exports.OPTION_META = "__OPTION_META__";
 exports.PARAMTYPES_METADATA = "design:paramtypes";
 exports.SELF_DECLARED_DEPS_METADATA = "self:paramtypes";

package/lib/types/ArgMeta.d.ts

@@ -0,0 +1,6 @@
+export type ArgMeta = {
+    index: number;
+    type: "param" | "option";
+    name: string;
+    params: any;
+};

package/lib/types/ArgMeta.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.22-beta.0",
+    "version": "1.0.22-beta.1",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",

package/lib/core/RouteCompletion.d.ts

@@ -1,5 +0,0 @@
-import { Route } from "./Route";
-export declare class RouteCompletion extends Route {
-    readonly name: string;
-    constructor(method: string, name: string, command: string, argsMeta: any[], designTypes: any[]);
-}

package/lib/core/RouteCompletion.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteCompletion = void 0;
-const Route_1 = require("./Route");
-class RouteCompletion extends Route_1.Route {
-    constructor(method, name, command, argsMeta, designTypes) {
-        super(method, command, argsMeta, designTypes);
-        this.name = name;
-    }
-}
-exports.RouteCompletion = RouteCompletion;