@tsed/cli-core 7.0.0-beta.1 → 7.0.0-beta.11

package/lib/esm/services/ProjectPackageJson.js

@@ -45,12 +45,21 @@ export class ProjectPackageJson {
     get path() {
         return join(this.dir, "package.json");
     }
+    /**
+     * @deprecated
+     */
     get dir() {
-        return String(constant("project.rootDir"));
+        return this.cwd;
     }
+    /**
+     * @deprecated
+     * @param dir
+     */
     set dir(dir) {
-        configuration().set("project.rootDir", dir);
-        this.read();
+        this.setCWD(dir);
+    }
+    get cwd() {
+        return String(constant("project.rootDir", ""));
     }
     get name() {
         return this.raw.name;
@@ -83,6 +92,10 @@ export class ProjectPackageJson {
     get preferences() {
         return this.raw[constant("name")];
     }
+    setCWD(dir) {
+        configuration().set("project.rootDir", dir);
+        this.read();
+    }
     fillWithPreferences(ctx) {
         return {
             ...ctx,
@@ -222,7 +235,7 @@ export class ProjectPackageJson {
     refresh() {
         this.reinstall = false;
         this.rewrite = false;
-        const cwd = constant("project.rootDir");
+        const cwd = this.cwd;
         const pkgPath = join(String(cwd), "package.json");
         const pkg = this.fs.readJsonSync(pkgPath, { encoding: "utf8" });
         pkg.scripts = {

package/lib/esm/utils/createInjector.js

@@ -14,7 +14,7 @@ export function createInjector(settings = {}) {
     inj.settings.set({
         ...settings,
         project: {
-            root: process.cwd(),
+            // root: process.cwd(),
             srcDir: "src",
             ...(settings.project || {})
         }

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

@@ -1,4 +1,4 @@
-import { GlobalProviders, injector, logger } from "@tsed/di";
+import { injector, lazyInject, logger } from "@tsed/di";
 import chalk from "chalk";
 import figures from "figures";
 import { CliFs } from "../services/CliFs.js";
@@ -7,33 +7,20 @@ const all = (promises) => Promise.all(promises);
 export async function loadPlugins() {
     const $inj = injector();
     const name = $inj.settings.get("name");
-    const rootDir = $inj.settings.get("project.rootDir");
     const projectPackageJson = $inj.invoke(ProjectPackageJson);
     const fs = $inj.invoke(CliFs);
     const promises = Object.keys(projectPackageJson.allDependencies)
         .filter((mod) => mod.startsWith(`@${name}/cli-plugin`) || mod.includes(`${name}-cli-plugin`))
         .map(async (mod) => {
         try {
-            const { default: plugin } = await fs.importModule(mod, rootDir);
-            if (!$inj.has(plugin)) {
-                const provider = GlobalProviders.get(plugin)?.clone();
-                if (provider?.imports.length) {
-                    await all(provider.imports.map(async (token) => {
-                        $inj.add(token, GlobalProviders.get(token)?.clone());
-                        if ($inj.settings.get("loaded")) {
-                            await $inj.invoke(token);
-                        }
-                    }));
-                }
-                $inj.add(plugin, provider);
-                if ($inj.settings.get("loaded")) {
-                    await $inj.invoke(plugin);
-                }
+            if ($inj.settings.get("loaded")) {
+                logger().info("Try to load ", mod);
+                await lazyInject(() => fs.importModule(mod, projectPackageJson.cwd));
             }
             logger().info(chalk.green(figures.tick), mod, "module loaded");
         }
         catch (er) {
-            logger().warn(chalk.red(figures.cross), "Fail to load plugin", mod);
+            logger().warn(chalk.red(figures.cross), "Fail to load plugin", mod, er.message);
         }
     });
     await all(promises);

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

@@ -1,18 +1,11 @@
 import "@tsed/logger-std";
-import { Type } from "@tsed/core";
-import { InjectorService } from "@tsed/di";
-import { CliService } from "./services/CliService.js";
 export declare class CliCore {
-    readonly injector: InjectorService;
-    readonly cliService: CliService;
+    protected constructor(settings: Partial<TsED.Configuration>);
     static checkPrecondition(settings: any): void;
     static checkPackage(pkg: any): void;
     static checkNodeVersion(wanted: string, id: string): typeof CliCore;
-    static create<Cli extends CliCore = CliCore>(settings: Partial<TsED.Configuration>, module?: Type): Promise<Cli>;
-    static bootstrap(settings: Partial<TsED.Configuration>, module?: Type): Promise<CliCore>;
-    static loadInjector(injector: InjectorService, module?: Type): Promise<void>;
+    static bootstrap(settings: Partial<TsED.Configuration>): Promise<CliCore>;
     static updateNotifier(pkg: any): Promise<typeof CliCore>;
-    protected static createInjector(settings: Partial<TsED.Configuration>): InjectorService;
     protected static getProjectRoot(argv: string[]): string;
     bootstrap(): Promise<this>;
 }

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;
+    handler: (data: Input) => import("../interfaces/Tasks.js").Tasks | Promise<import("../interfaces/Tasks.js").Tasks> | any | Promise<any>;
+    prompt?(initialOptions: Partial<Input>): import("@tsed/cli-prompts").PromptQuestion[] | Promise<import("@tsed/cli-prompts").PromptQuestion[]>;
+    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/index.d.ts

@@ -1,5 +1,4 @@
 import "./utils/patchCommander.js";
-import Inquirer from "inquirer";
 export * from "./CliCore.js";
 export * from "./decorators/index.js";
 export * from "./fn/command.js";
@@ -7,8 +6,8 @@ export * from "./interfaces/index.js";
 export * from "./packageManagers/index.js";
 export * from "./services/index.js";
 export * from "./utils/index.js";
+export * from "@tsed/cli-prompts";
 export * from "@tsed/core";
 export * from "@tsed/di";
 export * from "@tsed/logger";
 export * from "@tsed/normalize-path";
-export { Inquirer };

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

@@ -9,4 +9,5 @@ export interface CommandData extends TsED.InitialCommandData {
     verbose?: boolean;
     bindLogger?: boolean;
     rawArgs?: string[];
+    [key: string]: any;
 }

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 { PromptQuestion } from "@tsed/cli-prompts";
 import { Type } from "@tsed/core";
+import type { TokenProvider } from "@tsed/di";
+import type { JsonSchema } from "@tsed/schema";
+import type { CommandProvider } 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> {
+    handler: (data: Input) => Tasks | Promise<Tasks> | any | Promise<any>;
+    prompt?(initialOptions: Partial<Input>): PromptQuestion[] | Promise<PromptQuestion[]>;
+    [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

@@ -1,35 +1,17 @@
-import "inquirer-autocomplete-prompt";
-import type { Answers, QuestionCollection } from "inquirer";
-import AutocompletePrompt from "inquirer-autocomplete-prompt";
+import type { PromptQuestion } from "@tsed/cli-prompts";
 import type { Tasks } from "./Tasks.js";
-declare module "inquirer" {
-    interface QuestionMap<T extends Answers = Answers> {
-        autocomplete: AutocompletePrompt.AutocompleteQuestionOptions<T>;
-    }
-}
-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.
+     * Hook to create the main prompt for the command. Refer to {@link PromptQuestion}
+     * for supported question attributes.
      * @param initialOptions
      */
-    $prompt?<T extends Answers = Answers>(initialOptions: Partial<Ctx>): QuestionOptions<T> | Promise<QuestionOptions<T>>;
+    $prompt?(initialOptions: Partial<Ctx>): PromptQuestion[] | Promise<PromptQuestion[]>;
     /**
      * Hook to map options
      * @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/ProjectPreferences.d.ts

@@ -2,7 +2,8 @@ export declare enum PackageManager {
     YARN = "yarn",
     YARN_BERRY = "yarn_berry",
     NPM = "npm",
-    PNPM = "pnpm"
+    PNPM = "pnpm",
+    BUN = "bun"
 }
 declare global {
     namespace TsED {

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

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

@@ -4,7 +4,6 @@ export declare class CliPlugins {
     name: string;
     readonly loadPlugins: typeof loadPlugins;
     private npmRegistryClient;
-    private cliHooks;
     private packageJson;
     private packageManagers;
     searchPlugins(keyword?: string, options?: any): Promise<any>;

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

@@ -1,3 +1,4 @@
+import { PromptRunner } from "@tsed/cli-prompts";
 import { DIContext } from "@tsed/di";
 import { Command } from "commander";
 import type { CommandData } from "../interfaces/CommandData.js";
@@ -13,6 +14,7 @@ export declare class CliService {
     protected hooks: CliHooks;
     protected projectPkg: ProjectPackageJson;
     protected packageManagers: PackageManagersModule;
+    protected promptRunner: PromptRunner;
     private commands;
     /**
      * Parse process.argv and runLifecycle action
@@ -26,20 +28,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 +44,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/services/ProjectPackageJson.d.ts

@@ -9,8 +9,16 @@ export declare class ProjectPackageJson {
     private raw;
     constructor();
     get path(): string;
+    /**
+     * @deprecated
+     */
     get dir(): string;
+    /**
+     * @deprecated
+     * @param dir
+     */
     set dir(dir: string);
+    get cwd(): string;
     get name(): string;
     set name(name: string);
     get version(): string;
@@ -28,6 +36,7 @@ export declare class ProjectPackageJson {
         [key: string]: string;
     };
     get preferences(): ProjectPreferences;
+    setCWD(dir: string): void;
     fillWithPreferences<T extends {}>(ctx: T): T & {
         packageManager: import("../interfaces/ProjectPreferences.js").PackageManager;
         runtime: any;

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

@@ -1 +1 @@
-export declare function resolveConfiguration(settings: any): any;
+export declare function resolveConfiguration(settings: Partial<TsED.Configuration>): Partial<TsED.Configuration>;

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;
+};