@wocker/core 1.0.21 → 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

@@ -30,6 +30,30 @@ class ApplicationContext {
     run(args) {
         return __awaiter(this, void 0, void 0, function* () {
             const cli = this.get(cli_1.Cli);
+            cli.command("").action(() => {
+                const module = this.container.getModule(this.module);
+                for (const [, container] of module.controllers) {
+                    if (!container.description) {
+                        continue;
+                    }
+                    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 container.commands) {
+                        if (!route.description) {
+                            continue;
+                        }
+                        for (const commandName of route.commandNames) {
+                            const space = " ".repeat(Math.max(0, spaceLength - commandName.length));
+                            console.info(`  ${commandName} ${space} ${route.description}`);
+                        }
+                    }
+                    console.info("");
+                }
+            });
             return cli.run(args);
         });
     }

package/lib/core/ControllerWrapper.d.ts

@@ -0,0 +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";
+export declare class ControllerWrapper<TInput = any> extends InstanceWrapper {
+    readonly type: Type<TInput>;
+    description?: string;
+    commands: Route[];
+    completions: Route[];
+    constructor(module: Module, type: Type<TInput>);
+    getRoutes(): Route[];
+    getCompletionCommands(name: string, command: string): Route[];
+    run(route: Route, input: CommandInput): any;
+}

package/lib/core/ControllerWrapper.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerWrapper = void 0;
+require("reflect-metadata");
+const InstanceWrapper_1 = require("./InstanceWrapper");
+const Route_1 = require("./Route");
+class ControllerWrapper extends InstanceWrapper_1.InstanceWrapper {
+    constructor(module, type) {
+        super(module, type);
+        this.commands = [];
+        this.completions = [];
+        if (!this.type) {
+            return;
+        }
+        this.description = Reflect.getMetadata("CONTROLLER_DESCRIPTION", this.type) || "";
+        for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
+            const route = new Route_1.Route(this.type, method);
+            if (route.isCommand) {
+                this.commands.push(route);
+            }
+            else if (route.isCompletion) {
+                this.completions.push(route);
+            }
+            else {
+                // TODO: Log
+            }
+        }
+    }
+    getRoutes() {
+        const routes = [];
+        if (!this.type) {
+            return [];
+        }
+        for (const method of Object.getOwnPropertyNames(this.type.prototype)) {
+            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/InstanceWrapper.d.ts

@@ -4,11 +4,11 @@ import { Provider } from "../types/Provider";
 import { Type } from "../types/Type";
 import { InjectionToken } from "../types/InjectionToken";
 export declare class InstanceWrapper<TInput = any> {
-    private readonly module;
-    private readonly provider;
+    protected readonly module: Module;
+    protected readonly provider: Provider<TInput>;
     protected _instance?: TInput | undefined;
     readonly token: InjectionToken<TInput>;
     readonly type?: Type<TInput>;
     constructor(module: Module, provider: Provider<TInput>, _instance?: TInput | undefined);
-    get instance(): TInput | undefined;
+    get instance(): TInput;
 }

package/lib/core/InstanceWrapper.js

@@ -22,7 +22,10 @@ class InstanceWrapper {
         this.type = this.provider;
     }
     get instance() {
-        if (!this._instance && this.type) {
+        if (!this._instance) {
+            if (!this.type) {
+                throw new Error("Type not defined");
+            }
             const types = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, this.type) || [];
             const selfTypes = Reflect.getMetadata(env_1.SELF_DECLARED_DEPS_METADATA, this.type) || [];
             if (selfTypes.length > 0) {

package/lib/core/Module.d.ts

@@ -2,11 +2,12 @@ import { Provider } from "../types/Provider";
 import { Type } from "../types/Type";
 import { Container } from "./Container";
 import { InstanceWrapper } from "./InstanceWrapper";
+import { ControllerWrapper } from "./ControllerWrapper";
 export declare class Module<TInput = any> {
     readonly container: Container;
-    type: TInput;
+    readonly type: TInput;
     imports: Map<any, InstanceWrapper>;
-    controllers: Map<any, InstanceWrapper>;
+    controllers: Map<any, ControllerWrapper>;
     providers: Map<any, InstanceWrapper>;
     exports: Set<any>;
     constructor(container: Container, type: TInput);

package/lib/core/Module.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = void 0;
 const InstanceWrapper_1 = require("./InstanceWrapper");
+const ControllerWrapper_1 = require("./ControllerWrapper");
 const env_1 = require("../env");
 class Module {
     constructor(container, type) {
@@ -40,17 +41,8 @@ class Module {
         this.providers.set(wrapper.token, wrapper);
     }
     addController(type) {
-        this.controllers.set(type, new InstanceWrapper_1.InstanceWrapper(this, 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;
-            }
-        }
+        const controllerWrapper = new ControllerWrapper_1.ControllerWrapper(this, type);
+        this.controllers.set(type, controllerWrapper);
     }
     addExport(type) {
         const token = typeof type !== "string"

package/lib/core/Route.d.ts

@@ -0,0 +1,23 @@
+import { ArgMeta } from "../types/ArgMeta";
+import { Type } from "../types/Type";
+export declare class Route {
+    readonly type: Type;
+    readonly method: string;
+    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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+const env_1 = require("../env");
+class Route {
+    constructor(type, method) {
+        this.type = type;
+        this.method = method;
+        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;
+        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] || ""
+                    }
+                };
+            }
+            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 })
+                };
+            }
+        }
+    }
+    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.d.ts

@@ -1,7 +1,7 @@
 import "reflect-metadata";
 import { Cli } from "@kearisp/cli";
 import { Container } from "./Container";
-import { InstanceWrapper } from "./InstanceWrapper";
+import { ControllerWrapper } from "./ControllerWrapper";
 import { Module } from "./Module";
 export declare class Scanner {
     readonly container: Container;
@@ -13,6 +13,6 @@ export declare class Scanner {
     protected scanImports(module: Module): void;
     protected scanExports(module: Module): void;
     protected scanRoutes(): void;
-    protected scanControllerRoutes(cli: Cli, controller: any, wrapper: InstanceWrapper): boolean;
+    protected scanControllerRoutes(cli: Cli, wrapper: ControllerWrapper): void;
     protected scanDynamicModules(): Promise<void>;
 }

package/lib/core/Scanner.js

@@ -85,115 +85,40 @@ class Scanner {
         }
         const cli = cliWrapper.instance;
         for (const [, module] of this.container.modules) {
-            for (const [type, controller] of module.controllers) {
+            for (const [, controller] of module.controllers) {
                 if (!controller.instance) {
                     continue;
                 }
-                this.scanControllerRoutes(cli, type, controller);
+                this.scanControllerRoutes(cli, controller);
             }
         }
     }
-    scanControllerRoutes(cli, controller, wrapper) {
-        const controllerCommandNames = [];
-        for (const name of Object.getOwnPropertyNames(controller.prototype)) {
-            const descriptor = Object.getOwnPropertyDescriptor(controller.prototype, name);
-            if (!descriptor) {
-                continue;
-            }
-            const commandNames = Reflect.getMetadata(env_1.COMMAND_METADATA, descriptor.value) || [];
-            if (commandNames.length === 0) {
-                continue;
-            }
-            const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, controller, name) || [];
-            const designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, controller.prototype, name) || [];
-            const description = Reflect.getMetadata(env_1.COMMAND_DESCRIPTION_METADATA, descriptor.value);
-            for (const commandName of commandNames) {
-                controllerCommandNames.push(commandName);
+    scanControllerRoutes(cli, wrapper) {
+        for (const route of wrapper.commands) {
+            for (const commandName of route.commandNames) {
                 const command = cli.command(commandName);
-                if (description) {
+                if (route.description) {
                     command.help({
-                        description
+                        description: route.description
                     });
                 }
-                argsMeta.forEach((argMeta) => {
-                    if (argMeta.type === "option") {
-                        command.option(argMeta.name, argMeta.params);
-                    }
-                });
                 command.action((input) => {
-                    const args = [];
-                    const params = Object.values(input.arguments());
-                    argsMeta.forEach((argMeta) => {
-                        switch (argMeta.type) {
-                            case "param":
-                                args[argMeta.index] = input.argument(argMeta.name);
-                                break;
-                            case "option":
-                                if (designTypes[argMeta.index] === Array) {
-                                    args[argMeta.index] = input.options(argMeta.name);
-                                }
-                                else {
-                                    args[argMeta.index] = input.option(argMeta.name);
-                                }
-                                break;
-                        }
-                    });
-                    return wrapper.instance[name](...args, ...params);
+                    return wrapper.run(route, input);
                 });
-            }
-        }
-        const controllerCompletions = [];
-        for (const method of Object.getOwnPropertyNames(controller.prototype)) {
-            const descriptor = Object.getOwnPropertyDescriptor(controller.prototype, method);
-            if (!descriptor) {
-                continue;
-            }
-            const completions = Reflect.getMetadata(env_1.COMPLETION_METADATA, descriptor.value) || [];
-            if (completions.length === 0) {
-                continue;
-            }
-            for (const completion of completions) {
-                controllerCompletions.push(Object.assign(Object.assign({}, completion), { method }));
-            }
-        }
-        controllerCompletions.sort((a, b) => {
-            return a.command < b.command ? -1 : 1;
-        });
-        for (const completion of controllerCompletions) {
-            const commandNames = completion.command
-                ? [completion.command]
-                : controllerCommandNames.filter((commandName) => {
-                    return !controllerCompletions.filter((c) => {
-                        return c.name === completion.name && typeof c.command !== "undefined";
-                    }).map((c) => {
-                        return c.method;
-                    }).includes(commandName);
-                });
-            const argsMeta = Reflect.getMetadata(env_1.ARGS_METADATA, controller, completion.method) || [];
-            const designTypes = Reflect.getMetadata(env_1.PARAMTYPES_METADATA, controller.prototype, completion.method) || [];
-            for (const commandName of commandNames) {
-                cli.command(commandName).completion(completion.name, (input) => {
-                    const args = [];
-                    argsMeta.forEach((argMeta) => {
-                        switch (argMeta.type) {
-                            case "param":
-                                args[argMeta.index] = input.argument(argMeta.name);
-                                break;
-                            case "option":
-                                if (designTypes[argMeta.index] === Array) {
-                                    args[argMeta.index] = input.options(argMeta.name);
-                                }
-                                else {
-                                    args[argMeta.index] = input.option(argMeta.name);
-                                }
-                                break;
+                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);
                     });
-                    return wrapper.instance[completion.method](...args);
-                });
+                }
             }
         }
-        return true;
     }
     scanDynamicModules() {
         return __awaiter(this, void 0, void 0, function* () {

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

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

package/lib/decorators/Controller.js

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

package/lib/decorators/Description.d.ts

@@ -1,2 +1,4 @@
 import "reflect-metadata";
-export declare const Description: (description: string) => MethodDecorator;
+type UniversalDecorator = ClassDecorator & MethodDecorator & PropertyDecorator & ParameterDecorator;
+export declare const Description: (description: string) => UniversalDecorator;
+export {};

package/lib/decorators/Description.js

@@ -4,8 +4,27 @@ exports.Description = void 0;
 require("reflect-metadata");
 const env_1 = require("../env");
 const Description = (description) => {
-    return (_target, _propertyKey, descriptor) => {
-        Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, descriptor.value);
+    return (target, propertyKey, descriptorOrIndex) => {
+        // Class
+        if (typeof target === "function" && typeof propertyKey === "undefined" && typeof descriptorOrIndex === "undefined") {
+            Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, target);
+            return;
+        }
+        if (typeof target !== "object" || !propertyKey) {
+            return;
+        }
+        // Property
+        if (typeof descriptorOrIndex === "undefined") {
+            Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, target, propertyKey);
+            return;
+        }
+        // Method
+        if (typeof descriptorOrIndex !== "number") {
+            Reflect.defineMetadata(env_1.COMMAND_DESCRIPTION_METADATA, description, descriptorOrIndex.value);
+            return;
+        }
+        // Parameter
+        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/index.d.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-export { Cli } from "@kearisp/cli";
+export { Cli, CommandNotFoundError } from "@kearisp/cli";
 export * from "./core";
 export * from "./decorators";
 export * from "./makes";

package/lib/index.js

@@ -14,10 +14,11 @@ 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.PLUGIN_DIR_KEY = exports.PLUGIN_NAME_METADATA = exports.MODULE_METADATA = exports.IS_MODULE_METADATA = exports.Cli = void 0;
+exports.PLUGIN_DIR_KEY = exports.PLUGIN_NAME_METADATA = exports.MODULE_METADATA = exports.IS_MODULE_METADATA = exports.CommandNotFoundError = exports.Cli = void 0;
 require("reflect-metadata");
 var cli_1 = require("@kearisp/cli");
 Object.defineProperty(exports, "Cli", { enumerable: true, get: function () { return cli_1.Cli; } });
+Object.defineProperty(exports, "CommandNotFoundError", { enumerable: true, get: function () { return cli_1.CommandNotFoundError; } });
 __exportStar(require("./core"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./makes"), exports);

package/lib/makes/AppConfig.d.ts

@@ -7,25 +7,31 @@ type ProjectData = {
     /** @deprecated */
     src?: string;
 };
+type PluginData = {
+    name: string;
+    env: "latest" | "beta";
+};
 type PresetData = {
     name: string;
     source: PresetType;
     path?: string;
 };
-export type AppConfigProperties = Omit<PickProperties<AppConfig>, "logLevel"> & {
+export type AppConfigProperties = Omit<PickProperties<AppConfig>, "logLevel" | "plugins"> & {
+    plugins?: (string | PluginData)[];
     logLevel?: AppConfig["logLevel"];
 };
 export declare abstract class AppConfig {
     debug?: boolean;
+    keystore?: string;
     logLevel: "off" | "info" | "warn" | "error";
-    plugins?: string[];
+    plugins: PluginData[];
     presets?: PresetData[];
     projects?: ProjectData[];
     meta?: EnvConfig;
     env?: EnvConfig;
     protected constructor(data: AppConfigProperties);
-    addPlugin(plugin: string): void;
-    removePlugin(removePlugin: string): void;
+    addPlugin(name: string, env?: PluginData["env"]): void;
+    removePlugin(name: string): void;
     getProject(id: string): ProjectData | undefined;
     addProject(id: string, name: string, path: string): void;
     removeProject(id: string): void;
@@ -42,5 +48,7 @@ export declare abstract class AppConfig {
     unsetEnv(name: string): void;
     abstract save(): Promise<void>;
     toJson(): AppConfigProperties;
+    toJsString(): string;
+    toString(): string;
 }
 export {};

package/lib/makes/AppConfig.js

@@ -1,29 +1,50 @@
 "use strict";
+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.AppConfig = void 0;
 const Preset_1 = require("./Preset");
 class AppConfig {
     constructor(data) {
         this.logLevel = "off";
-        Object.assign(this, data);
+        const { plugins = [] } = data, rest = __rest(data, ["plugins"]);
+        Object.assign(this, rest);
+        this.plugins = plugins.map((plugin) => {
+            if (typeof plugin === "string") {
+                return {
+                    name: plugin,
+                    env: "latest"
+                };
+            }
+            return plugin;
+        });
     }
-    addPlugin(plugin) {
-        if (!this.plugins) {
-            this.plugins = [];
-        }
-        if (this.plugins.includes(plugin)) {
+    addPlugin(name, env = "latest") {
+        const plugin = this.plugins.find((plugin) => plugin.name === name);
+        if (plugin) {
+            plugin.name = name;
+            plugin.env = env;
             return;
         }
-        this.plugins.push(plugin);
+        this.plugins.push({
+            name,
+            env
+        });
     }
-    removePlugin(removePlugin) {
-        if (!this.plugins) {
-            return;
-        }
-        this.plugins = this.plugins.filter((plugin) => plugin !== removePlugin);
+    removePlugin(name) {
         if (this.plugins.length === 0) {
-            delete this.plugins;
+            return;
         }
+        this.plugins = this.plugins.filter((plugin) => plugin.name !== name);
     }
     getProject(id) {
         if (!this.projects) {
@@ -151,7 +172,8 @@ class AppConfig {
         const json = {
             debug: this.debug,
             logLevel: this.logLevel,
-            plugins: this.plugins,
+            keystore: this.keystore,
+            plugins: this.plugins.length > 0 ? this.plugins : undefined,
             projects: this.projects,
             presets: this.presets,
             env: this.env,
@@ -164,5 +186,12 @@ class AppConfig {
             return res;
         }, {});
     }
+    toJsString() {
+        const json = JSON.stringify(this.toJson(), null, 4);
+        return `// Wocker config\nexports.config = ${json};`;
+    }
+    toString() {
+        return JSON.stringify(this.toJson(), null, 4);
+    }
 }
 exports.AppConfig = AppConfig;

package/lib/makes/FileSystem.d.ts

@@ -14,8 +14,9 @@ export declare class FileSystem {
     readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
     readFile(path: string): Buffer;
     readJSON(...paths: string[]): any;
-    writeFile(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions): Promise<void>;
+    writeFile(path: string, data: string | Buffer | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions): void;
     writeJSON(path: string, data: any, options?: WriteFileOptions): void;
+    appendFile(path: string, data: string | Uint8Array, options?: WriteFileOptions): void;
     rm(path: string, options?: RmOptions): void;
     createWriteStream(path: string, options?: BufferEncoding): fs.WriteStream;
     createReadStream(path: string, options?: BufferEncoding): fs.ReadStream;

package/lib/makes/FileSystem.js

@@ -114,30 +114,20 @@ class FileSystem {
     }
     writeFile(path, data, options) {
         const fullPath = this.path(path);
-        return new Promise((resolve, reject) => {
-            const callback = (err) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(undefined);
-            };
-            if (options) {
-                fs_1.default.writeFile(fullPath, data, options, callback);
-            }
-            else {
-                fs_1.default.writeFile(fullPath, data, callback);
-            }
-        });
+        fs_1.default.writeFileSync(fullPath, data, options);
     }
     writeJSON(path, data, options) {
         const fullPath = this.path(path);
         const json = JSON.stringify(data, null, 4);
         fs_1.default.writeFileSync(fullPath, json, options);
     }
+    appendFile(path, data, options) {
+        const fullPath = this.path(path);
+        fs_1.default.appendFileSync(fullPath, data, options);
+    }
     rm(path, options) {
         const fullPath = this.path(path);
-        fs_1.default.rmdirSync(fullPath, options);
+        fs_1.default.rmSync(fullPath, options);
     }
     createWriteStream(path, options) {
         return fs_1.default.createWriteStream(this.path(path), options);

package/lib/makes/KeystoreProvider.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class KeystoreProvider {
+    abstract get(key: string, defaultValue: string): Promise<string>;
+    abstract get(key: string, defaultValue?: string): Promise<string | undefined>;
+    abstract set(key: string, value: string): Promise<void>;
+    abstract delete(key: string): Promise<void>;
+}

package/lib/makes/KeystoreProvider.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeystoreProvider = void 0;
+class KeystoreProvider {
+}
+exports.KeystoreProvider = KeystoreProvider;

package/lib/makes/Preset.d.ts

@@ -1,16 +1,19 @@
 import { PickProperties } from "../types";
 type TextOption = {
-    type: "string" | "number" | "int";
+    type: "text" | "string" | "number" | "int" | "password";
     message?: string;
     default?: string | number;
 };
 type ConfirmOption = {
     type: "boolean";
     message?: string;
+    required?: boolean;
     default?: boolean;
 };
 type SelectOption = {
     type: "select";
+    required?: boolean;
+    multiple?: boolean;
     options: string[] | {
         label?: string;
         value: string;
@@ -20,7 +23,7 @@ type SelectOption = {
     message?: string;
     default?: string;
 };
-type AnyOption = TextOption | ConfirmOption | SelectOption;
+export type PresetVariableConfig = TextOption | ConfirmOption | SelectOption;
 export type PresetProperties = PickProperties<Preset>;
 export declare abstract class Preset {
     name: string;
@@ -30,10 +33,10 @@ export declare abstract class Preset {
     image?: string;
     dockerfile?: string;
     buildArgsOptions?: {
-        [name: string]: AnyOption;
+        [name: string]: PresetVariableConfig;
     };
     envOptions?: {
-        [name: string]: AnyOption;
+        [name: string]: PresetVariableConfig;
     };
     path?: string;
     volumes?: string[];

package/lib/makes/Project.d.ts

@@ -40,6 +40,9 @@ export declare abstract class Project {
     volumeUnmount(...volumes: string[]): void;
     addExtraHost(host: string, domain: string): void;
     removeExtraHost(host: string): void;
+    abstract getSecret(key: string, byDefault: string): Promise<string>;
+    abstract getSecret(key: string, byDefault?: string): Promise<string | undefined>;
+    abstract setSecret(key: string, value: string): Promise<void>;
     abstract save(): Promise<void>;
     toJSON(): ProjectProperties;
 }

package/lib/makes/index.d.ts

@@ -5,6 +5,7 @@ export * from "./FileSystem";
 export * from "./FileSystemManager";
 export * from "./FS";
 export * from "./FSManager";
+export * from "./KeystoreProvider";
 export * from "./Logger";
 export * from "./Preset";
 export * from "./Project";

package/lib/makes/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./FileSystem"), exports);
 __exportStar(require("./FileSystemManager"), exports);
 __exportStar(require("./FS"), exports);
 __exportStar(require("./FSManager"), exports);
+__exportStar(require("./KeystoreProvider"), exports);
 __exportStar(require("./Logger"), exports);
 __exportStar(require("./Preset"), exports);
 __exportStar(require("./Project"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,12 +1,14 @@
 import { AppConfig } from "../makes";
 export declare abstract class AppConfigService {
-    protected config?: AppConfig;
+    abstract get config(): AppConfig;
     get version(): string;
     isVersionGTE(version: string): boolean;
     abstract pwd(...parts: string[]): string;
     abstract setPWD(pwd: string): void;
     abstract dataPath(...args: string[]): string;
     abstract pluginsPath(...args: string[]): string;
+    /**
+     * @deprecated
+     */
     getConfig(): AppConfig;
-    protected abstract loadConfig(): AppConfig;
 }

package/lib/services/AppConfigService.js

@@ -25,10 +25,10 @@ let AppConfigService = class AppConfigService {
         }
         return true;
     }
+    /**
+     * @deprecated
+     */
     getConfig() {
-        if (!this.config) {
-            this.config = this.loadConfig();
-        }
         return this.config;
     }
 };

package/lib/services/KeystoreService.d.ts

@@ -0,0 +1,9 @@
+import { KeystoreProvider } from "../makes";
+export declare abstract class KeystoreService {
+    abstract hasProvider(name: string): boolean;
+    abstract provider(name?: string): KeystoreProvider;
+    abstract get(key: string, defaultValue: string): Promise<string>;
+    abstract get(key: string, defaultValue?: string): Promise<string | undefined>;
+    abstract set(key: string, value: string): Promise<void>;
+    abstract registerProvider(name: string, provider: KeystoreProvider): void;
+}

package/lib/services/KeystoreService.js

@@ -0,0 +1,16 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeystoreService = void 0;
+const decorators_1 = require("../decorators");
+let KeystoreService = class KeystoreService {
+};
+exports.KeystoreService = KeystoreService;
+exports.KeystoreService = KeystoreService = __decorate([
+    (0, decorators_1.Injectable)("KEYSTORE_SERVICE")
+], KeystoreService);

package/lib/services/ProjectService.d.ts

@@ -1,4 +1,3 @@
-import { Container } from "dockerode";
 import { Project } from "../makes/Project";
 type SearchParams = Partial<{
     id: string;
@@ -7,8 +6,7 @@ type SearchParams = Partial<{
 }>;
 export declare abstract class ProjectService {
     abstract cdProject(name: string): Promise<void>;
-    abstract get(): Promise<Project>;
-    abstract getContainer(): Promise<Container | null>;
+    abstract get(name?: string): Promise<Project>;
     abstract start(project: Project): Promise<void>;
     abstract stop(project: Project): Promise<void>;
     abstract save(project: Project): Promise<void>;

package/lib/services/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./AppConfigService";
 export * from "./AppEventsService";
 export * from "./DockerService";
+export * from "./KeystoreService";
 export * from "./LogService";
 export * from "./PluginConfigService";
 export * from "./PresetService";

package/lib/services/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AppConfigService"), exports);
 __exportStar(require("./AppEventsService"), exports);
 __exportStar(require("./DockerService"), exports);
+__exportStar(require("./KeystoreService"), exports);
 __exportStar(require("./LogService"), exports);
 __exportStar(require("./PluginConfigService"), exports);
 __exportStar(require("./PresetService"), exports);

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,11 +1,11 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.21",
+    "version": "1.0.22-beta.1",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Core of the Wocker",
     "license": "MIT",
-    "main": "lib/index.js",
-    "types": "lib/index.d.ts",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
     "keywords": [
         "wocker"
     ],
@@ -18,25 +18,27 @@
         "url": "https://github.com/kearisp/wocker-core/issues"
     },
     "scripts": {
-        "prepare": "npm run build",
+        "prepublishOnly": "npm run build",
         "build": "tsc --project tsconfig.build.json",
         "watch": "tsc -w --project tsconfig.build.json",
         "test": "jest --colors",
-        "test-watch": "jest --colors --watchAll --coverage"
+        "test-watch": "jest --colors --watchAll --coverage",
+        "make-coverage-badge": "make-coverage-badge"
     },
     "dependencies": {
-        "@kearisp/cli": "^2.0.7",
+        "@kearisp/cli": "^2.0.8",
         "fs": "^0.0.1-security",
         "path": "^0.12.7",
         "reflect-metadata": "^0.2.2"
     },
     "devDependencies": {
         "@types/dockerode": "^3.3.23",
-        "@types/jest": "^29.5.12",
-        "@types/node": "^20.11.7",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.15.3",
         "jest": "^29.7.0",
-        "ts-jest": "^29.2.4",
+        "make-coverage-badge": "^1.2.0",
+        "ts-jest": "^29.3.2",
         "ts-node": "^10.9.2",
-        "typescript": "^5.5.4"
+        "typescript": "^5.8.3"
     }
 }