@tsed/cli-core 7.0.0-beta.2 → 7.0.0-beta.4

package/lib/esm/CliCore.js

@@ -58,7 +58,7 @@ export class CliCore {
             name: settings.name || "tsed",
             argv,
             project: {
-                // rootDir: this.getProjectRoot(argv),
+                rootDir: this.getProjectRoot(argv),
                 srcDir: "src",
                 scriptsDir: "scripts",
                 ...(settings.project || {})

package/lib/esm/decorators/command.js

@@ -1,6 +1,6 @@
 import { command } from "../fn/command.js";
 export function Command(options) {
     return (token) => {
-        command(token, options);
+        command({ ...options, token });
     };
 }

package/lib/esm/decorators/index.js

@@ -1,5 +1 @@
 export * from "./command.js";
-export * from "./onAdd.js";
-export * from "./onExec.js";
-export * from "./onPostInstall.js";
-export * from "./onPrompt.js";

package/lib/esm/fn/command.js

@@ -1,5 +1,33 @@
 import { injectable } from "@tsed/di";
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
-export function command(token, options) {
-    return injectable(token).type("command").set(CommandStoreKeys.COMMAND, options);
+import { JsonSchema } from "@tsed/schema";
+JsonSchema.add("prompt", function prompt(label) {
+    this.customKey("x-label", label);
+    return this;
+})
+    .add("when", function when(fn) {
+    this.customKey("x-when", fn);
+    return this;
+})
+    .add("opt", function opt(v) {
+    this.customKey("x-opt", v);
+    return this;
+})
+    .add("choices", function choices(choices) {
+    this.customKey("x-choices", choices);
+    return this;
+});
+export function command(options) {
+    if (!options.token) {
+        return injectable(Symbol.for(`COMMAND_${options.name}`))
+            .type("command")
+            .set("command", options)
+            .factory(() => {
+            return {
+                ...options,
+                $prompt: options.prompt,
+                $exec: options.handler
+            };
+        });
+    }
+    return injectable(options.token).type("command").set("command", options);
 }

package/lib/esm/interfaces/index.js

@@ -2,7 +2,7 @@ import { Type } from "@tsed/core";
 export * from "./CliDefaultOptions.js";
 export * from "./CommandData.js";
 export * from "./CommandMetadata.js";
-export * from "./CommandParameters.js";
+export * from "./CommandOptions.js";
 export * from "./CommandProvider.js";
 export * from "./PackageJson.js";
 export * from "./ProjectPreferences.js";

package/lib/esm/packageManagers/PackageManagersModule.js

@@ -1,5 +1,4 @@
-import { __decorate, __metadata, __param } from "tslib";
-import { Inject, injectable } from "@tsed/di";
+import { Inject, inject, injectable, injectMany } from "@tsed/di";
 import { EMPTY, throwError } from "rxjs";
 import { catchError } from "rxjs/operators";
 import { ProjectPackageJson } from "../services/ProjectPackageJson.js";
@@ -18,17 +17,19 @@ function mapPackagesWithInvalidVersion(deps) {
         .filter(([, version]) => !isValidVersion(version))
         .map(toString);
 }
-let PackageManagersModule = class PackageManagersModule {
-    constructor(packageManagers) {
-        this.packageManagers = packageManagers;
-        this.packageManagers = packageManagers.filter((manager) => manager.has());
+export class PackageManagersModule {
+    constructor() {
+        this.projectPackageJson = inject(ProjectPackageJson);
+        this.packageManagers = injectMany("package:manager").filter((manager) => {
+            return manager.has();
+        });
     }
     init(options = {}) {
         const packageManager = this.get(options.packageManager);
         options.packageManager = packageManager.name;
         options = {
             ...options,
-            cwd: this.projectPackageJson.dir,
+            cwd: this.projectPackageJson.cwd,
             env: {
                 ...process.env,
                 GH_TOKEN: this.projectPackageJson.GH_TOKEN
@@ -45,7 +46,7 @@ let PackageManagersModule = class PackageManagersModule {
         const deps = mapPackagesWithInvalidVersion(this.projectPackageJson.dependencies);
         options = {
             ...options,
-            cwd: this.projectPackageJson.dir,
+            cwd: this.projectPackageJson.cwd,
             env: {
                 ...process.env,
                 GH_TOKEN: this.projectPackageJson.GH_TOKEN
@@ -116,14 +117,5 @@ let PackageManagersModule = class PackageManagersModule {
         });
         return this.get().runScript(scriptName, options).pipe(errorPipe());
     }
-};
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], PackageManagersModule.prototype, "projectPackageJson", void 0);
-PackageManagersModule = __decorate([
-    __param(0, Inject("package:manager")),
-    __metadata("design:paramtypes", [Array])
-], PackageManagersModule);
-export { PackageManagersModule };
+}
 injectable(PackageManagersModule).imports([YarnManager, YarnBerryManager, NpmManager, PNpmManager, BunManager]);

package/lib/esm/packageManagers/supports/BaseManager.js

@@ -1,10 +1,10 @@
-import { __decorate, __metadata } from "tslib";
-import { Inject } from "@tsed/di";
+import { inject } from "@tsed/di";
 import { Observable } from "rxjs";
 import { CliExeca } from "../../services/CliExeca.js";
 export class BaseManager {
     constructor() {
         this.verboseOpt = "--verbose";
+        this.cliExeca = inject(CliExeca);
     }
     has() {
         try {
@@ -23,7 +23,3 @@ export class BaseManager {
         return this.cliExeca.run(this.cmd, [cmd, options.verbose && this.verboseOpt, ...args].filter(Boolean), options);
     }
 }
-__decorate([
-    Inject(CliExeca),
-    __metadata("design:type", CliExeca)
-], BaseManager.prototype, "cliExeca", void 0);

package/lib/esm/services/CliHttpClient.js

@@ -41,10 +41,11 @@ export class CliHttpClient extends CliHttpLogClient {
         return this.mapResponse(result, options);
     }
     getRequestParameters(method, endpoint, options) {
+        const url = (this.host || "") + endpoint.replace(this.host || "", "");
         options = {
             method,
-            url: (this.host || "") + endpoint.replace(this.host || "", ""),
             ...options,
+            url,
             params: options.params || options.qs,
             data: options.data,
             headers: {
@@ -53,7 +54,7 @@ export class CliHttpClient extends CliHttpLogClient {
                 ...(options.headers || {})
             }
         };
-        this.configureProxy(endpoint, options);
+        this.configureProxy(url, options);
         return options;
     }
     configureProxy(endpoint, options) {

package/lib/esm/services/CliHttpLogClient.js

@@ -11,7 +11,7 @@ let CliHttpLogClient = class CliHttpLogClient {
         this.callee = options.callee || "http";
     }
     onSuccess(options) {
-        return this.logger.debug({
+        this.logger.debug({
             ...this.formatLog(options),
             status: "OK"
         });

package/lib/esm/services/CliLoadFile.js

@@ -1,21 +1,12 @@
 import { extname } from "node:path";
 import { inject, injectable } from "@tsed/di";
-import { default as Ajv } from "ajv";
+import { validate } from "../utils/validate.js";
 import { CliFs } from "./CliFs.js";
 import { CliYaml } from "./CliYaml.js";
 export class CliLoadFile {
-    // @ts-ignore
-    #ajv;
     constructor() {
         this.cliYaml = inject(CliYaml);
         this.cliFs = inject(CliFs);
-        const options = {
-            verbose: false,
-            coerceTypes: true,
-            strict: false
-        };
-        // @ts-ignore
-        this.#ajv = new Ajv(options);
     }
     /**
      * Load a configuration file from yaml, json
@@ -33,18 +24,14 @@ export class CliLoadFile {
             throw new Error("Unsupported format file");
         }
         if (schema) {
-            const validate = this.#ajv.compile(schema);
-            const isValid = validate(config);
+            const { isValid, errors, value } = validate(config, schema);
             if (!isValid) {
-                const [error] = validate.errors;
-                throw new Error([
-                    `${error.instancePath.replace(/\//gi, ".")} `,
-                    error.message,
-                    error.params?.allowedValues && `. Allowed values: ${error.params?.allowedValues}`
-                ]
+                const [error] = errors;
+                throw new Error([`${error.path.replace(/\//gi, ".")} `, error.message, error.expected && `. Allowed values: ${error.expected}`]
                     .filter(Boolean)
                     .join(""));
             }
+            return value;
         }
         return config;
     }

package/lib/esm/services/CliPlugins.js

@@ -1,6 +1,6 @@
 import { constant, inject, injectable } from "@tsed/di";
+import { $asyncEmit } from "@tsed/hooks";
 import chalk from "chalk";
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
 import { PackageManagersModule } from "../packageManagers/PackageManagersModule.js";
 import { createSubTasks } from "../utils/createTasksRunner.js";
 import { loadPlugins } from "../utils/loadPlugins.js";
@@ -33,7 +33,7 @@ export class CliPlugins {
             return {
                 title: `Run plugin '${chalk.cyan(plugin)}'`,
                 task: () => {
-                    return this.cliHooks.emit(CommandStoreKeys.ADD, plugin, ctx);
+                    return $asyncEmit("$onAddPlugin", [plugin, ctx]);
                 }
             };
         });

package/lib/esm/services/CliService.js

@@ -1,4 +1,4 @@
-import { classOf } from "@tsed/core";
+import { classOf, isArrowFn } from "@tsed/core";
 import { configuration, constant, context, destroyInjector, DIContext, getContext, inject, injectable, injector, logger, Provider, runInContext } from "@tsed/di";
 import { $asyncAlter, $asyncEmit } from "@tsed/hooks";
 import { pascalCase } from "change-case";
@@ -6,11 +6,10 @@ import { Argument, Command } from "commander";
 import Inquirer from "inquirer";
 import inquirer_autocomplete_prompt from "inquirer-autocomplete-prompt";
 import { v4 } from "uuid";
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
 import { PackageManagersModule } from "../packageManagers/index.js";
 import { createSubTasks, createTasksRunner } from "../utils/createTasksRunner.js";
 import { getCommandMetadata } from "../utils/getCommandMetadata.js";
-import { mapCommanderOptions } from "../utils/index.js";
+import { mapCommanderOptions, validate } from "../utils/index.js";
 import { mapCommanderArgs } from "../utils/mapCommanderArgs.js";
 import { parseOption } from "../utils/parseOption.js";
 import { CliHooks } from "./CliHooks.js";
@@ -44,78 +43,57 @@ export class CliService {
      */
     runLifecycle(cmdName, data = {}, $ctx) {
         return runInContext($ctx, async () => {
-            await $asyncEmit("$loadPackageJson");
-            data = await this.beforePrompt(cmdName, data);
-            $ctx.set("data", data);
-            data = await this.prompt(cmdName, data);
-            await this.dispatch(cmdName, data, $ctx);
-        });
-    }
-    async dispatch(cmdName, data, $ctx) {
-        try {
             $ctx.set("dispatchCmd", cmdName);
-            $ctx.set("data", data);
-            await this.exec(cmdName, data, $ctx);
-        }
-        catch (er) {
-            await $asyncEmit("$onFinish", er);
+            await $asyncEmit("$loadPackageJson");
+            data = await this.prompt(cmdName, data, $ctx);
+            try {
+                await this.exec(cmdName, data, $ctx);
+            }
+            catch (er) {
+                await $asyncEmit("$onFinish", [data, er]);
+                await destroyInjector();
+                throw er;
+            }
+            await $asyncEmit("$onFinish", [data]);
             await destroyInjector();
-            throw er;
-        }
-        await $asyncEmit("$onFinish");
-        await destroyInjector();
+        });
     }
     async exec(cmdName, data, $ctx) {
-        const initialTasks = await this.getTasks(cmdName, data);
-        if (initialTasks.length) {
-            const tasks = [
-                ...initialTasks,
-                {
+        const tasks = await this.getTasks(cmdName, data);
+        $ctx.set("data", data);
+        if (tasks.length) {
+            if (this.reinstallAfterRun && (this.projectPkg.rewrite || this.projectPkg.reinstall)) {
+                tasks.push({
                     title: "Install dependencies",
-                    enabled: () => this.reinstallAfterRun && (this.projectPkg.rewrite || this.projectPkg.reinstall),
                     task: createSubTasks(() => this.packageManagers.install(data), { ...data, concurrent: false })
-                },
-                ...(await this.getPostInstallTasks(cmdName, data))
-            ];
-            return createTasksRunner(tasks, this.mapData(cmdName, data, $ctx));
-        }
-    }
-    /**
-     * Run prompt for a given command
-     * @param cmdName
-     * @param data Initial data
-     */
-    async beforePrompt(cmdName, data = {}) {
-        const provider = this.commands.get(cmdName);
-        const instance = inject(provider.useClass);
-        const verbose = data.verbose;
-        if (instance.$beforePrompt) {
-            data = await instance.$beforePrompt(JSON.parse(JSON.stringify(data)));
-            data.verbose = verbose;
+                }, ...(await this.getPostInstallTasks(cmdName, data)));
+            }
+            data = this.mapData(cmdName, data, $ctx);
+            $ctx.set("data", data);
+            return createTasksRunner(tasks, data);
         }
-        return data;
     }
     /**
      * Run prompt for a given command
      * @param cmdName
-     * @param ctx Initial data
+     * @param data
+     * @param $ctx
      */
-    async prompt(cmdName, ctx = {}) {
+    async prompt(cmdName, data = {}, $ctx) {
         const provider = this.commands.get(cmdName);
-        const instance = inject(provider.useClass);
+        const instance = inject(provider.token);
+        $ctx.set("data", data);
         if (instance.$prompt) {
-            const questions = [
-                ...(await instance.$prompt(ctx)),
-                ...(await this.hooks.emit(CommandStoreKeys.PROMPT_HOOKS, cmdName, ctx))
-            ];
+            const questions = [...(await instance.$prompt(data))];
             if (questions.length) {
-                ctx = {
-                    ...ctx,
+                data = {
+                    ...data,
                     ...(await Inquirer.prompt(questions))
                 };
             }
         }
-        return ctx;
+        $ctx.set("data", data);
+        return data;
     }
     /**
      * Run lifecycle
@@ -127,14 +105,10 @@ export class CliService {
         const provider = this.commands.get(cmdName);
         const instance = inject(provider.token);
         data = this.mapData(cmdName, data, $ctx);
-        if (instance.$beforeExec) {
-            await instance.$beforeExec(data);
-        }
-        return [
-            ...(await instance.$exec(data)),
-            ...(await this.hooks.emit(CommandStoreKeys.EXEC_HOOKS, cmdName, data)),
-            ...(await $asyncAlter(`$alter${pascalCase(cmdName)}Tasks`, [], [data]))
-        ].map((opts) => {
+        const tasks = [];
+        tasks.push(...((await instance.$exec(data)) || []));
+        tasks.push(...(await $asyncAlter(`$alter${pascalCase(cmdName)}Tasks`, [], [data])));
+        return tasks.map((opts) => {
             return {
                 ...opts,
                 task: async (arg, task) => {
@@ -148,32 +122,44 @@ export class CliService {
     }
     async getPostInstallTasks(cmdName, data) {
         const provider = this.commands.get(cmdName);
-        const instance = inject(provider.useClass);
+        const instance = inject(provider.token);
         data = this.mapData(cmdName, data, getContext());
         return [
             ...(instance.$postInstall ? await instance.$postInstall(data) : []),
-            ...(await this.hooks.emit(CommandStoreKeys.POST_INSTALL_HOOKS, cmdName, data)),
             ...(await $asyncAlter(`$alter${pascalCase(cmdName)}PostInstallTasks`, [], [data])),
             ...(instance.$afterPostInstall ? await instance.$afterPostInstall(data) : [])
         ];
     }
     createCommand(metadata) {
-        const { args, name, options, description, alias, allowUnknownOption } = metadata;
+        const { name, description, alias, inputSchema } = metadata;
         if (this.commands.has(name)) {
             return this.commands.get(name).command;
         }
-        let cmd = this.program.command(name);
+        const { args, options, allowUnknownOption } = metadata.getOptions();
         const onAction = (commandName) => {
             const [, ...rawArgs] = cmd.args;
             const mappedArgs = mapCommanderArgs(args, this.program.args.filter((arg) => commandName === arg));
             const allOpts = mapCommanderOptions(commandName, this.program.commands);
-            const data = {
+            let data = {
                 ...allOpts,
                 verbose: !!this.program.opts().verbose,
                 ...mappedArgs,
                 ...cmd.opts(),
                 rawArgs
             };
+            if (inputSchema) {
+                const { isValid, errors, value } = validate(data, isArrowFn(inputSchema) ? inputSchema() : inputSchema);
+                if (isValid) {
+                    data = value;
+                }
+                else {
+                    logger().error({
+                        event: "VALIDATION_ERROR",
+                        errors
+                    });
+                    throw new Error("Validation error");
+                }
+            }
             const $ctx = new DIContext({
                 id: v4(),
                 injector: injector(),
@@ -187,6 +173,7 @@ export class CliService {
             configuration().set("command.metadata", metadata);
             return this.runLifecycle(name, data, $ctx);
         };
+        let cmd = this.program.command(name);
         if (alias) {
             cmd = cmd.alias(alias);
         }
@@ -205,7 +192,7 @@ export class CliService {
     }
     mapData(cmdName, data, $ctx) {
         const provider = this.commands.get(cmdName);
-        const instance = inject(provider.useClass);
+        const instance = inject(provider.token);
         const verbose = data.verbose;
         data.commandName ||= cmdName;
         if (instance.$mapContext) {
@@ -227,7 +214,7 @@ export class CliService {
      * @param provider
      */
     build(provider) {
-        const metadata = getCommandMetadata(provider.useClass);
+        const metadata = getCommandMetadata(provider.token);
         if (metadata.name) {
             if (this.commands.has(metadata.name)) {
                 throw Error(`The ${metadata.name} command is already registered. Change your command name used by the class ${classOf(provider.useClass)}`);

package/lib/esm/services/ProjectPackageJson.js

@@ -59,7 +59,7 @@ export class ProjectPackageJson {
         this.setCWD(dir);
     }
     get cwd() {
-        return String(constant("project.rootDir"));
+        return String(constant("project.rootDir", ""));
     }
     get name() {
         return this.raw.name;

package/lib/esm/utils/getCommandMetadata.js

@@ -1,17 +1,44 @@
-import { Store } from "@tsed/core";
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
+import { isArrowFn, Store } from "@tsed/core";
 export function getCommandMetadata(token) {
-    const { name, alias, args = {}, allowUnknownOption, description, options = {}, enableFeatures, disableReadUpPkg, bindLogger = true, ...opts } = Store.from(token)?.get(CommandStoreKeys.COMMAND);
+    const { name, alias, args = {}, description, options = {}, enableFeatures, disableReadUpPkg, inputSchema, bindLogger = true, ...opts } = Store.from(token)?.get("command");
     return {
         name,
+        inputSchema,
         alias,
-        args,
         description,
-        options,
-        allowUnknownOption: !!allowUnknownOption,
         enableFeatures: enableFeatures || [],
         disableReadUpPkg: !!disableReadUpPkg,
         bindLogger,
-        ...opts
+        ...opts,
+        getOptions() {
+            if (inputSchema) {
+                const schema = isArrowFn(inputSchema) ? inputSchema() : inputSchema;
+                Object.entries(schema.get("properties") || {})?.forEach(([propertyKey, propertySchema]) => {
+                    const base = {
+                        type: propertySchema.getTarget(),
+                        itemType: propertySchema.isCollection ? propertySchema.get("items").getTarget() : undefined,
+                        description: propertySchema.get("description") || "",
+                        defaultValue: propertySchema.get("default"),
+                        required: schema.isRequired(propertyKey)
+                    };
+                    const opt = propertySchema.get("x-opt");
+                    if (opt) {
+                        options[opt] = {
+                            ...base,
+                            customParser: schema.get("custom-parser")
+                        };
+                    }
+                    else {
+                        args[propertyKey] = base;
+                    }
+                });
+                opts.allowUnknownOption = !!schema.get("additionalProperties");
+            }
+            return {
+                args,
+                options,
+                allowUnknownOption: !!opts.allowUnknownOption
+            };
+        }
     };
 }

package/lib/esm/utils/index.js

@@ -8,3 +8,4 @@ export * from "./mapCommanderArgs.js";
 export * from "./mapCommanderOptions.js";
 export * from "./parseOption.js";
 export * from "./resolveConfiguration.js";
+export * from "./validate.js";

package/lib/esm/utils/validate.js

@@ -0,0 +1,23 @@
+import { Ajv } from "ajv";
+const ajv = new Ajv({
+    verbose: false,
+    coerceTypes: true,
+    strict: false,
+    allErrors: true
+});
+export function validate(value, schema) {
+    const validate = ajv.compile(schema.toJSON());
+    const result = validate(value);
+    if (!result) {
+        const errors = (validate.errors || []).map((e) => ({
+            path: e.instancePath || e.schemaPath,
+            message: e.message,
+            expected: (e.params && e.params.type) || undefined
+        }));
+        return {
+            isValid: false,
+            errors: errors
+        };
+    }
+    return { isValid: true, value: value };
+}

package/lib/types/decorators/command.d.ts

@@ -1,2 +1,2 @@
-import type { CommandParameters } from "../interfaces/CommandParameters.js";
-export declare function Command(options: CommandParameters): ClassDecorator;
+import type { BaseCommandOptions } from "../interfaces/CommandOptions.js";
+export declare function Command<Input = any>(options: BaseCommandOptions<Input>): ClassDecorator;

package/lib/types/decorators/index.d.ts

@@ -1,5 +1 @@
 export * from "./command.js";
-export * from "./onAdd.js";
-export * from "./onExec.js";
-export * from "./onPostInstall.js";
-export * from "./onPrompt.js";

package/lib/types/fn/command.d.ts

@@ -1,3 +1,58 @@
-import { injectable, type TokenProvider } from "@tsed/di";
-import type { CommandParameters } from "../interfaces/CommandParameters.js";
-export declare function command(token: TokenProvider, options: CommandParameters): ReturnType<typeof injectable>;
+import type { Type } from "@tsed/core";
+import { type FactoryTokenProvider } from "@tsed/di";
+import { JsonSchema } from "@tsed/schema";
+import type { CommandOptions } from "../interfaces/CommandOptions.js";
+import type { CommandProvider } from "../interfaces/index.js";
+type SchemaChoice = {
+    label: string;
+    value: string;
+    checked?: ((ctx: any) => boolean) | boolean;
+    items?: SchemaChoice[];
+};
+declare module "@tsed/schema" {
+    interface JsonSchema {
+        prompt(label: string): this;
+        opt(value: string): this;
+        when(fn: (ctx: any) => boolean): this;
+        choices(value: SchemaChoice[]): this;
+    }
+}
+export declare function command<Input>(options: CommandOptions<Input>): TsED.ProviderBuilder<FactoryTokenProvider<{
+    $prompt: any;
+    $exec: any;
+    token: import("@tsed/di").TokenProvider<CommandProvider>;
+    name: string;
+    alias?: string;
+    description: string;
+    args?: {
+        [key: string]: import("../interfaces/CommandOptions.js").CommandArg;
+    };
+    inputSchema?: JsonSchema<Input> | (() => JsonSchema<Input>) | undefined;
+    options?: {
+        [key: string]: import("../interfaces/CommandOptions.js").CommandOpts;
+    };
+    allowUnknownOption?: boolean;
+    enableFeatures?: string[];
+    disableReadUpPkg?: boolean;
+    bindLogger?: boolean;
+} | {
+    $prompt: any;
+    $exec: any;
+    prompt?<T extends import("inquirer").Answers = import("inquirer").Answers>(initialOptions: Partial<Input>): import("../interfaces/CommandProvider.js").QuestionOptions<T> | Promise<import("../interfaces/CommandProvider.js").QuestionOptions<T>>;
+    handler: (data: Input) => import("../interfaces/Tasks.js").Tasks | Promise<import("../interfaces/Tasks.js").Tasks> | any | Promise<any>;
+    name: string;
+    alias?: string;
+    description: string;
+    args?: {
+        [key: string]: import("../interfaces/CommandOptions.js").CommandArg;
+    };
+    inputSchema?: JsonSchema<Input> | (() => JsonSchema<Input>) | undefined;
+    options?: {
+        [key: string]: import("../interfaces/CommandOptions.js").CommandOpts;
+    };
+    allowUnknownOption?: boolean;
+    enableFeatures?: string[];
+    disableReadUpPkg?: boolean;
+    bindLogger?: boolean;
+}>> | TsED.ClassProviderBuilder<Type<CommandProvider<Input>>>;
+export {};

package/lib/types/interfaces/CommandMetadata.d.ts

@@ -1,19 +1,21 @@
-import type { CommandArg, CommandOptions, CommandParameters } from "./CommandParameters.js";
-export interface CommandMetadata extends CommandParameters {
-    /**
-     * CommandProvider arguments
-     */
-    args: {
-        [key: string]: CommandArg;
-    };
-    /**
-     * CommandProvider options
-     */
-    options: {
-        [key: string]: CommandOptions;
-    };
-    allowUnknownOption?: boolean;
+import type { BaseCommandOptions, CommandArg, CommandOpts } from "./CommandOptions.js";
+export interface CommandMetadata extends Omit<BaseCommandOptions<any>, "args" | "options" | "allowUnknownOption"> {
     enableFeatures: string[];
     disableReadUpPkg: boolean;
     bindLogger: boolean;
+    getOptions(): {
+        /**
+         * CommandProvider arguments
+         */
+        args: {
+            [key: string]: CommandArg;
+        };
+        /**
+         * CommandProvider options
+         */
+        options: {
+            [key: string]: CommandOpts;
+        };
+        allowUnknownOption?: boolean;
+    };
 }

package/lib/types/interfaces/{CommandParameters.d.ts → CommandOptions.d.ts}

@@ -1,4 +1,9 @@
 import { Type } from "@tsed/core";
+import type { TokenProvider } from "@tsed/di";
+import type { JsonSchema } from "@tsed/schema";
+import type { Answers } from "inquirer";
+import type { CommandProvider, QuestionOptions } from "./CommandProvider.js";
+import type { Tasks } from "./Tasks.js";
 export interface CommandArg {
     /**
      * Description of the argument
@@ -21,7 +26,7 @@ export interface CommandArg {
      */
     required?: boolean;
 }
-export interface CommandOptions {
+export interface CommandOpts {
     /**
      * Description of the commander.option()
      */
@@ -48,7 +53,7 @@ export interface CommandOptions {
      */
     customParser?: (value: any) => any;
 }
-export interface CommandParameters {
+export interface BaseCommandOptions<Input> {
     /**
      * name commands
      */
@@ -64,14 +69,26 @@ export interface CommandParameters {
     args?: {
         [key: string]: CommandArg;
     };
+    inputSchema?: JsonSchema<Input> | (() => JsonSchema<Input>);
     /**
      * CommandProvider options
      */
     options?: {
-        [key: string]: CommandOptions;
+        [key: string]: CommandOpts;
     };
     allowUnknownOption?: boolean;
     enableFeatures?: string[];
     disableReadUpPkg?: boolean;
+    bindLogger?: boolean;
+}
+interface FunctionalCommandOptions<Input> extends BaseCommandOptions<Input> {
+    prompt?<T extends Answers = Answers>(initialOptions: Partial<Input>): QuestionOptions<T> | Promise<QuestionOptions<T>>;
+    handler: (data: Input) => Tasks | Promise<Tasks> | any | Promise<any>;
+    [key: string]: any;
+}
+export interface ClassCommandOptions<Input> extends BaseCommandOptions<Input> {
+    token: TokenProvider<CommandProvider>;
     [key: string]: any;
 }
+export type CommandOptions<Input> = ClassCommandOptions<Input> | FunctionalCommandOptions<Input>;
+export {};

package/lib/types/interfaces/CommandProvider.d.ts

@@ -9,11 +9,6 @@ declare module "inquirer" {
 }
 export type QuestionOptions<T extends Answers = Answers> = QuestionCollection<T>;
 export interface CommandProvider<Ctx = any> {
-    /**
-     * Run a function before the main prompt. Useful for pre-loading data from the file system
-     * @param initialOptions
-     */
-    $beforePrompt?(initialOptions: Partial<Ctx>): Partial<Ctx>;
     /**
      * Hook to create the main prompt for the command
      * See https://github.com/enquirer/enquirer for more detail on question configuration.
@@ -25,11 +20,6 @@ export interface CommandProvider<Ctx = any> {
      * @param ctx
      */
     $mapContext?(ctx: Partial<Ctx>): Ctx;
-    /**
-     * Run something before the exec hook
-     * @param ctx
-     */
-    $beforeExec?(ctx: Ctx): Promise<any>;
     /**
      * Run a command
      * @param ctx

package/lib/types/interfaces/index.d.ts

@@ -1,10 +1,10 @@
-import { Type } from "@tsed/core";
+import type { TokenProvider } from "@tsed/di";
 import type { CommandProvider } from "./CommandProvider.js";
 import type { PackageJson } from "./PackageJson.js";
 export * from "./CliDefaultOptions.js";
 export * from "./CommandData.js";
 export * from "./CommandMetadata.js";
-export * from "./CommandParameters.js";
+export * from "./CommandOptions.js";
 export * from "./CommandProvider.js";
 export * from "./PackageJson.js";
 export * from "./ProjectPreferences.js";
@@ -15,7 +15,7 @@ declare global {
             /**
              * Load given commands
              */
-            commands: Type<CommandProvider>[];
+            commands: TokenProvider<CommandProvider>[];
             /**
              * Init Cli with defined argv
              */

package/lib/types/packageManagers/PackageManagersModule.d.ts

@@ -5,9 +5,8 @@ export interface InstallOptions {
     [key: string]: any;
 }
 export declare class PackageManagersModule {
-    protected packageManagers: BaseManager[];
     protected projectPackageJson: ProjectPackageJson;
-    constructor(packageManagers: BaseManager[]);
+    protected packageManagers: BaseManager[];
     init(options?: InstallOptions): Promise<void>;
     install(options?: InstallOptions): ({
         title: string;

package/lib/types/services/CliHttpLogClient.d.ts

@@ -6,7 +6,7 @@ export declare class CliHttpLogClient {
     callee: string;
     protected logger: Logger;
     constructor(options?: Partial<BaseLogClientOptions>);
-    protected onSuccess(options: Record<string, unknown>): Logger;
+    protected onSuccess(options: Record<string, unknown>): void;
     protected onError(error: any, options: any): void;
     protected logToCurl(options: any): string;
     protected getStatusCodeFromError(error: any): any;

package/lib/types/services/CliLoadFile.d.ts

@@ -1,13 +1,11 @@
-import { type Schema } from "ajv";
+import type { JsonSchema } from "@tsed/schema";
 import { CliFs } from "./CliFs.js";
 import { CliYaml } from "./CliYaml.js";
 export declare class CliLoadFile {
-    #private;
     protected cliYaml: CliYaml;
     protected cliFs: CliFs;
-    constructor();
     /**
      * Load a configuration file from yaml, json
      */
-    loadFile<Model = any>(path: string, schema?: Schema): Promise<Model>;
+    loadFile<Model = any>(path: string, schema?: JsonSchema<Model>): Promise<Model>;
 }

package/lib/types/services/CliService.d.ts

@@ -26,20 +26,14 @@ export declare class CliService {
      * @param $ctx
      */
     runLifecycle(cmdName: string, data: CommandData | undefined, $ctx: DIContext): Promise<Promise<void>>;
-    dispatch(cmdName: string, data: CommandData, $ctx: DIContext): Promise<void>;
     exec(cmdName: string, data: any, $ctx: DIContext): Promise<any>;
     /**
      * Run prompt for a given command
      * @param cmdName
-     * @param data Initial data
-     */
-    beforePrompt(cmdName: string, data?: CommandData): Promise<CommandData>;
-    /**
-     * Run prompt for a given command
-     * @param cmdName
-     * @param ctx Initial data
+     * @param data
+     * @param $ctx
      */
-    prompt(cmdName: string, ctx?: CommandData): Promise<CommandData>;
+    prompt(cmdName: string, data: CommandData | undefined, $ctx: DIContext): Promise<CommandData>;
     /**
      * Run lifecycle
      * @param cmdName
@@ -48,7 +42,7 @@ export declare class CliService {
     getTasks(cmdName: string, data: any): Promise<Task[]>;
     getPostInstallTasks(cmdName: string, data: any): Promise<any[]>;
     createCommand(metadata: CommandMetadata): any;
-    private load;
+    load(): void;
     private mapData;
     /**
      * Build command and sub-commands

package/lib/types/utils/index.d.ts

@@ -8,3 +8,4 @@ export * from "./mapCommanderArgs.js";
 export * from "./mapCommanderOptions.js";
 export * from "./parseOption.js";
 export * from "./resolveConfiguration.js";
+export * from "./validate.js";

package/lib/types/utils/mapCommanderArgs.d.ts

@@ -1,4 +1,4 @@
-import type { CommandArg } from "../interfaces/CommandParameters.js";
+import type { CommandArg } from "../interfaces/CommandOptions.js";
 export declare function mapCommanderArgs(args: {
     [arg: string]: CommandArg;
 }, commandArgs: any[]): any;

package/lib/types/utils/validate.d.ts

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "@tsed/schema";
+export declare function validate<Value>(value: unknown, schema: JsonSchema<Value>): {
+    isValid: boolean;
+    errors: {
+        path: string;
+        message: string | undefined;
+        expected: any;
+    }[];
+    value?: undefined;
+} | {
+    isValid: boolean;
+    value: Value;
+    errors?: undefined;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-core",
   "description": "Build your CLI with TypeScript and Decorators",
-  "version": "7.0.0-beta.2",
+  "version": "7.0.0-beta.4",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -65,7 +65,7 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/typescript": "7.0.0-beta.2",
+    "@tsed/typescript": "7.0.0-beta.4",
     "@types/commander": "2.12.2",
     "@types/figures": "3.0.1",
     "@types/fs-extra": "^11.0.4",

package/lib/esm/decorators/on.js

@@ -1,8 +0,0 @@
-import { StoreMerge } from "@tsed/core";
-export function On(hookName, name) {
-    return (target, propertyKey) => {
-        StoreMerge(hookName, {
-            [name]: [propertyKey]
-        })(target);
-    };
-}

package/lib/esm/decorators/onAdd.js

@@ -1,5 +0,0 @@
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
-import { On } from "./on.js";
-export function OnAdd(cliPlugin) {
-    return On(CommandStoreKeys.ADD, cliPlugin);
-}

package/lib/esm/decorators/onExec.js

@@ -1,5 +0,0 @@
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
-import { On } from "./on.js";
-export function OnExec(cmdName) {
-    return On(CommandStoreKeys.EXEC_HOOKS, cmdName);
-}

package/lib/esm/decorators/onPostInstall.js

@@ -1,5 +0,0 @@
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
-import { On } from "./on.js";
-export function OnPostInstall(cmdName) {
-    return On(CommandStoreKeys.POST_INSTALL_HOOKS, cmdName);
-}

package/lib/esm/decorators/onPrompt.js

@@ -1,5 +0,0 @@
-import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
-import { On } from "./on.js";
-export function OnPrompt(cmdName) {
-    return On(CommandStoreKeys.PROMPT_HOOKS, cmdName);
-}

package/lib/esm/domains/CommandStoreKeys.js

@@ -1,8 +0,0 @@
-export var CommandStoreKeys;
-(function (CommandStoreKeys) {
-    CommandStoreKeys["COMMAND"] = "command";
-    CommandStoreKeys["ADD"] = "$onAdd";
-    CommandStoreKeys["EXEC_HOOKS"] = "$onExec";
-    CommandStoreKeys["POST_INSTALL_HOOKS"] = "$onPostInstall";
-    CommandStoreKeys["PROMPT_HOOKS"] = "$onPrompt";
-})(CommandStoreKeys || (CommandStoreKeys = {}));

package/lib/types/decorators/on.d.ts

@@ -1 +0,0 @@
-export declare function On(hookName: string, name: string): MethodDecorator;

package/lib/types/decorators/onAdd.d.ts

@@ -1 +0,0 @@
-export declare function OnAdd(cliPlugin: string): MethodDecorator;

package/lib/types/decorators/onExec.d.ts

@@ -1 +0,0 @@
-export declare function OnExec(cmdName: string): MethodDecorator;

package/lib/types/decorators/onPostInstall.d.ts

@@ -1 +0,0 @@
-export declare function OnPostInstall(cmdName: string): MethodDecorator;

package/lib/types/decorators/onPrompt.d.ts

@@ -1 +0,0 @@
-export declare function OnPrompt(cmdName: string): MethodDecorator;

package/lib/types/domains/CommandStoreKeys.d.ts

@@ -1,7 +0,0 @@
-export declare enum CommandStoreKeys {
-    COMMAND = "command",
-    ADD = "$onAdd",
-    EXEC_HOOKS = "$onExec",
-    POST_INSTALL_HOOKS = "$onPostInstall",
-    PROMPT_HOOKS = "$onPrompt"
-}