@tsed/cli-core 7.0.0-alpha.9 → 7.0.0-beta.10

package/lib/esm/CliCore.js

@@ -1,16 +1,13 @@
 import "@tsed/logger-std";
 import { join, resolve } from "node:path";
-import { Type } from "@tsed/core";
-import { inject, injectable, InjectorService } from "@tsed/di";
+import { constant, inject, injector } from "@tsed/di";
 import { $asyncEmit } from "@tsed/hooks";
 import chalk from "chalk";
 import { Command } from "commander";
 import semver from "semver";
 import updateNotifier from "update-notifier";
 import { CliError } from "./domains/CliError.js";
-import { CliPackageJson } from "./services/CliPackageJson.js";
 import { CliService } from "./services/CliService.js";
-import { ProjectPackageJson } from "./services/ProjectPackageJson.js";
 import { createInjector } from "./utils/createInjector.js";
 import { loadPlugins } from "./utils/loadPlugins.js";
 import { resolveConfiguration } from "./utils/resolveConfiguration.js";
@@ -18,9 +15,21 @@ function isHelpManual(argv) {
     return argv.includes("-h") || argv.includes("--help");
 }
 export class CliCore {
-    constructor() {
-        this.injector = inject(InjectorService);
-        this.cliService = inject(CliService);
+    constructor(settings) {
+        createInjector(settings);
+    }
+    static checkPrecondition(settings) {
+        const { pkg } = settings;
+        this.checkPackage(pkg);
+        if (pkg?.engines?.node) {
+            this.checkNodeVersion(pkg.engines.node, pkg.name);
+        }
+    }
+    static checkPackage(pkg) {
+        if (!pkg) {
+            console.log(chalk.red(`settings.pkg is required. Require the package.json of your CLI when you bootstrap the CLI.`));
+            process.exit(1);
+        }
     }
     static checkNodeVersion(wanted, id) {
         if (!semver.satisfies(process.version, wanted)) {
@@ -35,35 +44,16 @@ export class CliCore {
         }
         return this;
     }
-    static async create(settings, module = CliCore) {
+    static async bootstrap(settings) {
+        if (settings.checkPrecondition) {
+            this.checkPrecondition(settings);
+        }
+        if (settings.updateNotifier) {
+            await this.updateNotifier(settings.pkg);
+        }
         settings = resolveConfiguration(settings);
-        const injector = this.createInjector(settings);
-        settings.plugins && (await loadPlugins());
-        await this.loadInjector(injector, module);
-        await $asyncEmit("$onReady");
-        return inject(CliCore);
-    }
-    static async bootstrap(settings, module = CliCore) {
-        const cli = await this.create(settings, module);
-        return cli.bootstrap();
-    }
-    static async loadInjector(injector, module = CliCore) {
-        await injector.emit("$beforeInit");
-        injector.addProvider(CliCore, {
-            useClass: module
-        });
-        await injector.load();
-        await injector.invoke(module);
-        await $asyncEmit("$afterInit");
-        injector.settings.set("loaded", true);
-    }
-    static async updateNotifier(pkg) {
-        updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
-        return this;
-    }
-    static createInjector(settings) {
         const argv = settings.argv || process.argv;
-        return createInjector({
+        return new CliCore({
             ...settings,
             name: settings.name || "tsed",
             argv,
@@ -73,7 +63,11 @@ export class CliCore {
                 scriptsDir: "scripts",
                 ...(settings.project || {})
             }
-        });
+        }).bootstrap();
+    }
+    static async updateNotifier(pkg) {
+        updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
+        return this;
     }
     static getProjectRoot(argv) {
         if (!isHelpManual(argv)) {
@@ -84,7 +78,14 @@ export class CliCore {
     }
     async bootstrap() {
         try {
-            await this.cliService.parseArgs(this.injector.settings.get("argv"));
+            const cliService = inject(CliService);
+            constant("plugins") && (await loadPlugins());
+            await $asyncEmit("$beforeInit");
+            await injector().load();
+            await $asyncEmit("$afterInit");
+            injector().settings.set("loaded", true);
+            await $asyncEmit("$onReady");
+            await cliService.parseArgs(constant("argv"));
         }
         catch (er) {
             throw new CliError({ origin: er, cli: this });
@@ -92,4 +93,3 @@ export class CliCore {
         return this;
     }
 }
-injectable(CliCore).imports([CliPackageJson, ProjectPackageJson, CliService]);

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/ProjectPreferences.js

@@ -4,4 +4,5 @@ export var PackageManager;
     PackageManager["YARN_BERRY"] = "yarn_berry";
     PackageManager["NPM"] = "npm";
     PackageManager["PNPM"] = "pnpm";
+    PackageManager["BUN"] = "bun";
 })(PackageManager || (PackageManager = {}));

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]);
+}
+injectable(PackageManagersModule).imports([YarnBerryManager, YarnManager, NpmManager, PNpmManager, BunManager]);

package/lib/esm/packageManagers/index.js

@@ -2,4 +2,5 @@ export * from "./PackageManagersModule.js";
 export * from "./supports/BaseManager.js";
 export * from "./supports/NpmManager.js";
 export * from "./supports/PNpmManager.js";
+export * from "./supports/YarnBerryManager.js";
 export * from "./supports/YarnManager.js";

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/packageManagers/supports/YarnBerryManager.js

@@ -29,7 +29,10 @@ let YarnBerryManager = class YarnBerryManager extends BaseManager {
             nodeLinker: "node-modules"
         });
         // then switch to berry
-        this.cliExeca.runSync(this.cmd, ["set", "version", "berry"]);
+        try {
+            this.cliExeca.runSync(this.cmd, ["set", "version", "berry"]);
+        }
+        catch (er) { }
     }
     add(deps, options) {
         return this.run("add", [...deps], options);

package/lib/esm/services/CliFs.js

@@ -51,7 +51,9 @@ export class CliFs extends RealFileSystemHost {
         return this.raw.ensureDirSync(path, options);
     }
     findUpFile(root, file) {
-        return [join(root, file), join(root, "..", file), join(root, "..", "..", file), join(root, "..", "..", "..", file)].find((path) => this.fileExistsSync(path));
+        return [join(root, file), join(root, "..", file), join(root, "..", "..", file), join(root, "..", "..", "..", file)].find((path) => {
+            return this.fileExistsSync(path) || this.raw.existsSync(path);
+        });
     }
     async importModule(mod, root = process.cwd()) {
         try {

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";
@@ -19,7 +19,6 @@ export class CliPlugins {
         this.name = constant("name", "");
         this.loadPlugins = loadPlugins;
         this.npmRegistryClient = inject(NpmRegistryClient);
-        this.cliHooks = inject(CliHooks);
         this.packageJson = inject(ProjectPackageJson);
         this.packageManagers = inject(PackageManagersModule);
     }
@@ -33,7 +32,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,45 @@ 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 schema = isArrowFn(inputSchema) ? inputSchema() : inputSchema;
+                const { isValid, errors, value } = validate(data, schema);
+                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 +174,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 +193,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 +215,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)}`);