@wocker/core 1.0.21-beta.3 → 1.0.22-beta.0

package/lib/core/ApplicationContext.js

@@ -30,6 +30,28 @@ 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) {
+                    const description = container.getDescription();
+                    if (!description) {
+                        continue;
+                    }
+                    console.info(`${description}:`);
+                    const routes = container.getRoutes();
+                    const spaceLength = routes.reduce((space, route) => {
+                        return Math.max(space, route.command.length + 2);
+                    }, 0);
+                    for (const route of routes) {
+                        if (!route.description) {
+                            continue;
+                        }
+                        const space = " ".repeat(Math.max(0, spaceLength - route.command.length));
+                        console.info(`  ${route.command} ${space} ${route.description}`);
+                    }
+                    console.info("");
+                }
+            });
             return cli.run(args);
         });
     }

package/lib/core/ControllerWrapper.d.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata";
+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>;
+    constructor(module: Module, type: Type<TInput>);
+    getDescription(): string | undefined;
+    getRoutes(): Route[];
+    getCompletions(): RouteCompletion[];
+}

package/lib/core/ControllerWrapper.js

@@ -0,0 +1,85 @@
+"use strict";
+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 = [];
+        if (!this.type) {
+            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) {
+                continue;
+            }
+            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);
+            }
+        }
+        return routes;
+    }
+    getCompletions() {
+        const routes = [], allCommandNames = [], allCompletions = [];
+        if (!this.type) {
+            return routes;
+        }
+        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);
+                routes.push(route);
+            }
+        }
+        return routes;
+    }
+}
+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,10 @@
+import { CommandInput } from "@kearisp/cli";
+export declare class Route {
+    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[];
+}

package/lib/core/Route.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+class Route {
+    constructor(method, command, argsMeta, designTypes, description) {
+        this.method = method;
+        this.command = command;
+        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);
+                    }
+                    break;
+            }
+        });
+        return args;
+    }
+}
+exports.Route = Route;

package/lib/core/RouteCompletion.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,11 @@
+"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;

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,36 @@ 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);
-                const command = cli.command(commandName);
-                if (description) {
-                    command.help({
-                        description
-                    });
-                }
-                argsMeta.forEach((argMeta) => {
-                    if (argMeta.type === "option") {
-                        command.option(argMeta.name, argMeta.params);
-                    }
+    scanControllerRoutes(cli, wrapper) {
+        for (const route of wrapper.getRoutes()) {
+            const command = cli.command(route.command);
+            if (route.description) {
+                command.help({
+                    description: route.description
                 });
-                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);
-                });
-            }
-        }
-        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 }));
             }
+            route.argsMeta.forEach((argMeta) => {
+                if (argMeta.type === "option") {
+                    command.option(argMeta.name, argMeta.params);
+                }
+            });
+            command.action((input) => {
+                return wrapper.instance[route.method](...route.getArgs(input));
+            });
         }
-        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;
-                        }
-                    });
-                    return wrapper.instance[completion.method](...args);
-                });
-            }
+        for (const completion of wrapper.getCompletions()) {
+            cli.command(completion.command).completion(completion.name, (input) => {
+                return wrapper.instance[completion.method](...completion.getArgs(input));
+            });
         }
-        return true;
     }
     scanDynamicModules() {
         return __awaiter(this, void 0, void 0, function* () {

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,33 @@ 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.COMMAND_DESCRIPTION_METADATA, [
+            {
+                index: descriptorOrIndex,
+                description
+            },
+            ...Reflect.getMetadata(env_1.COMMAND_DESCRIPTION_METADATA, target.constructor, propertyKey) || []
+        ], target.constructor, propertyKey);
     };
 };
 exports.Description = Description;

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/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@wocker/core",
-    "version": "1.0.21-beta.3",
+    "version": "1.0.22-beta.0",
     "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"
     }
 }