@tsed/cli 6.6.2 → 7.0.0-alpha.1

package/lib/esm/commands/add/AddCmd.js

@@ -1,6 +1,5 @@
-import { __decorate } from "tslib";
-import { CliPlugins, Command, createSubTasks, inject, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
-let AddCmd = class AddCmd {
+import { CliPlugins, command, createSubTasks, inject, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
+export class AddCmd {
     constructor() {
         this.cliPlugins = inject(CliPlugins);
         this.packageJson = inject(ProjectPackageJson);
@@ -34,20 +33,21 @@ let AddCmd = class AddCmd {
             {
                 title: "Install plugins dependencies",
                 task: createSubTasks(() => this.cliPlugins.addPluginsDependencies(ctx), { ...ctx, concurrent: false })
+            },
+            {
+                title: "Transform files",
+                task: createSubTasks(() => this.cliPlugins.addPluginsDependencies(ctx), { ...ctx, concurrent: false })
             }
         ];
     }
-};
-AddCmd = __decorate([
-    Command({
-        name: "add",
-        description: "Add cli plugin to the current project",
-        args: {
-            name: {
-                description: "Npm package name of the cli plugin",
-                type: String
-            }
+}
+command(AddCmd, {
+    name: "add",
+    description: "Add cli plugin to the current project",
+    args: {
+        name: {
+            description: "Npm package name of the cli plugin",
+            type: String
         }
-    })
-], AddCmd);
-export { AddCmd };
+    }
+});

package/lib/esm/commands/generate/GenerateCmd.js

@@ -1,250 +1,101 @@
-var GenerateCmd_1;
-import { __decorate, __metadata } from "tslib";
-import { basename, dirname, join } from "node:path";
-import { Command, Inject, inject, ProjectPackageJson } from "@tsed/cli-core";
-import { normalizePath } from "@tsed/normalize-path";
-import { kebabCase, pascalCase } from "change-case";
-import { globbySync } from "globby";
-import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
-import { ClassNamePipe } from "../../pipes/ClassNamePipe.js";
-import { OutputFilePathPipe } from "../../pipes/OutputFilePathPipe.js";
-import { RoutePipe } from "../../pipes/RoutePipe.js";
-import { ProvidersInfoService } from "../../services/ProvidersInfoService.js";
-import { SrcRendererService } from "../../services/Renderer.js";
-import { fillImports } from "../../utils/fillImports.js";
-import { getFrameworksPrompt } from "../init/prompts/getFeaturesPrompt.js";
-import { PROVIDER_TYPES } from "./ProviderTypes.js";
-const DECORATOR_TYPES = [
-    { name: "Class decorator", value: "class" },
-    { name: "Ts.ED middleware and its decorator", value: "middleware" },
-    { name: "Ts.ED endpoint decorator", value: "endpoint" },
-    { name: "Ts.ED property decorator", value: "prop" },
-    { name: "Ts.ED parameter decorator", value: "param" },
-    { name: "Vanilla Method decorator", value: "method" },
-    { name: "Vanilla Property decorator", value: "property" },
-    { name: "Vanilla Parameter decorator", value: "parameter" },
-    { name: "Generic decorator", value: "generic" }
-];
+import { command, inject, ProjectPackageJson } from "@tsed/cli-core";
+import { pascalCase } from "change-case";
+import { CliProjectService } from "../../services/CliProjectService.js";
+import { CliTemplatesService } from "../../services/CliTemplatesService.js";
+import { mapDefaultTemplateOptions } from "../../services/mappers/mapDefaultTemplateOptions.js";
 const searchFactory = (list) => {
-    return (state, keyword) => {
+    return (_, keyword) => {
         if (keyword) {
-            return list.filter((item) => item.name.toLowerCase().includes(keyword.toLowerCase()));
+            return list.filter((item) => item.label.toLowerCase().includes(keyword.toLowerCase()));
         }
         return list;
     };
 };
-let GenerateCmd = GenerateCmd_1 = class GenerateCmd {
-    constructor(providersList) {
-        this.providersList = providersList;
-        this.srcRenderService = inject(SrcRendererService);
+export class GenerateCmd {
+    constructor() {
         this.projectPackageJson = inject(ProjectPackageJson);
-        PROVIDER_TYPES.forEach((info) => {
-            this.providersList.add({
-                ...info
-            }, GenerateCmd_1);
-        });
+        this.projectService = inject(CliProjectService);
+        this.templates = inject(CliTemplatesService);
     }
-    $prompt(initialOptions) {
-        const getName = (state) => initialOptions.name || pascalCase(state.name || initialOptions.name || state.type || initialOptions.type);
-        const proposedProviders = this.providersList.findProviders(initialOptions.type);
+    async $prompt(data) {
+        data.getName = (state) => data.name || pascalCase(state.name || data.name || state.type || data.type || "");
+        const templates = this.templates.find();
+        const templatesPrompts = await Promise.all(templates
+            .filter((template) => template.prompts)
+            .map((template) => {
+            return template.prompts(data);
+        }));
         return [
             {
                 type: "autocomplete",
                 name: "type",
                 message: "Which type of provider?",
-                default: initialOptions.type,
-                when: () => proposedProviders.length > 1,
-                source: searchFactory(proposedProviders)
+                default: data.type,
+                when: () => templates.length > 1,
+                source: searchFactory(this.templates.find(data.type))
             },
             {
                 type: "input",
                 name: "name",
                 message: "Which name?",
-                default: getName,
-                when: !initialOptions.name
-            },
-            {
-                ...getFrameworksPrompt(),
-                message: "Which platform?",
-                type: "list",
-                name: "platform",
-                when(state) {
-                    return ["server"].includes(state.type || initialOptions.type);
-                }
+                default: data.getName,
+                when: !data.name
             },
+            ...templatesPrompts.flat()
+        ];
+    }
+    $mapContext(ctx) {
+        return mapDefaultTemplateOptions(ctx);
+    }
+    $exec(ctx) {
+        const { symbolPath, type } = ctx;
+        return [
             {
-                type: "input",
-                name: "route",
-                message: "Which route?",
-                when(state) {
-                    return !!(["controller", "server"].includes(state.type || initialOptions.type) || initialOptions.route);
-                },
-                default: (state) => {
-                    return state.type === "server" ? "/rest" : this.routePipe.transform(getName(state));
+                title: `Generate ${ctx.type} file to '${symbolPath}.ts'`,
+                skip: !this.templates.get(type),
+                task: () => {
+                    this.projectService.createFromTemplate(type, ctx);
                 }
             },
             {
-                type: "list",
-                name: "directory",
-                message: "Which directory?",
-                when(state) {
-                    return ["controller"].includes(state.type || initialOptions.type) || initialOptions.directory;
-                },
-                choices: this.getDirectories("controllers")
-            },
-            {
-                type: "autocomplete",
-                name: "templateType",
-                message: (state) => `Which type of ${state.type || initialOptions.type}?`,
-                when(state) {
-                    return !!(["decorator"].includes(state.type || initialOptions.type) || initialOptions.templateType);
-                },
-                source: searchFactory(DECORATOR_TYPES)
-            },
-            {
-                type: "list",
-                name: "middlewarePosition",
-                message: () => `The middleware should be called:`,
-                choices: [
-                    { name: "Before the endpoint", value: "before" },
-                    { name: "After the endpoint", value: "after" }
-                ],
-                when(state) {
-                    return !!((["decorator"].includes(state.type || initialOptions.type) && ["middleware"].includes(state.templateType)) ||
-                        initialOptions.middlewarePosition);
+                title: "Transform generated files",
+                task: () => {
+                    return this.projectService.transformFiles(ctx);
                 }
             }
         ];
     }
-    $mapContext(ctx) {
-        const { name = "" } = ctx;
-        let { type = "" } = ctx;
-        type = type.toLowerCase();
-        if (ctx.name === "prisma" && ctx.name) {
-            type = "prisma.service";
-        }
-        const symbolName = this.classNamePipe.transform({ name, type, format: ProjectConvention.DEFAULT });
-        const symbolParamName = kebabCase(symbolName);
-        return fillImports({
-            ...ctx,
-            type,
-            route: ctx.route ? this.routePipe.transform(ctx.route) : "",
-            symbolName,
-            symbolParamName,
-            symbolPath: normalizePath(this.outputFilePathPipe.transform({
-                name,
-                type,
-                subDir: ctx.directory
-            })),
-            symbolPathBasename: normalizePath(this.classNamePipe.transform({ name, type })),
-            platformSymbol: ctx.platform && pascalCase(`Platform ${ctx.platform}`)
-        });
-    }
-    $exec(ctx) {
-        const { symbolPath } = ctx;
-        if (this.providersList.isMyProvider(ctx.type, GenerateCmd_1)) {
-            const type = [ctx.type, ctx.templateType].filter(Boolean).join(".");
-            let template = `generate/${type}.hbs`;
-            if (ctx.type === "server") {
-                template = `generate/server/${ctx.platform}/server.hbs`;
-            }
-            return [
-                {
-                    title: `Generate ${ctx.type} file to '${symbolPath}.ts'`,
-                    task: () => {
-                        if (ctx.type === "server") {
-                            return this.srcRenderService.render(template, ctx, {
-                                baseDir: "generate",
-                                basename: `${symbolPath}.ts`,
-                                replaces: [`server/${ctx.platform}`]
-                            });
-                        }
-                        return this.srcRenderService.render(template, ctx, {
-                            output: `${symbolPath}.ts`
-                        });
-                    }
-                },
-                {
-                    title: `Update bin/index`,
-                    skip() {
-                        return ctx.type !== "command";
-                    },
-                    task: () => {
-                        return this.srcRenderService.update("bin/index.ts", [
-                            {
-                                type: "import",
-                                content: `import {${ctx.symbolName}} from "./${basename(symbolPath)}.js";`
-                            },
-                            {
-                                type: "insert-after",
-                                pattern: /commands: \[/,
-                                content: `  ${ctx.symbolName}`
-                            }
-                        ]);
-                    }
-                }
-            ];
+}
+command(GenerateCmd, {
+    name: "generate",
+    alias: "g",
+    description: "Generate a new provider class",
+    args: {
+        type: {
+            description: "Type of the provider (Injectable, Controller, Pipe, etc...)",
+            type: String
+        },
+        name: {
+            description: "Name of the class",
+            type: String
         }
-        return [];
-    }
-    getDirectories(dir) {
-        const directories = globbySync("**/*", {
-            cwd: join(this.srcRenderService.rootDir, dir),
-            ignore: ["__*"]
-        });
-        const set = new Set(directories.map((dir) => {
-            return dirname(dir);
-        }));
-        set.delete(".");
-        return [...set];
-    }
-};
-__decorate([
-    Inject(),
-    __metadata("design:type", ClassNamePipe)
-], GenerateCmd.prototype, "classNamePipe", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", OutputFilePathPipe)
-], GenerateCmd.prototype, "outputFilePathPipe", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", RoutePipe)
-], GenerateCmd.prototype, "routePipe", void 0);
-GenerateCmd = GenerateCmd_1 = __decorate([
-    Command({
-        name: "generate",
-        alias: "g",
-        description: "Generate a new provider class",
-        args: {
-            type: {
-                description: "Type of the provider (Injectable, Controller, Pipe, etc...)",
-                type: String
-            },
-            name: {
-                description: "Name of the class",
-                type: String
-            }
+    },
+    options: {
+        "--route <route>": {
+            type: String,
+            description: "The route for the controller generated file"
         },
-        options: {
-            "--route <route>": {
-                type: String,
-                description: "The route for the controller generated file"
-            },
-            "-d, --directory <directory>": {
-                description: "Directory where the file must be generated",
-                type: String
-            },
-            "-t, --template-type <templateType>": {
-                description: "Directory where the file must be generated",
-                type: String
-            },
-            "-m, --middleware-position <templateType>": {
-                description: "Middleware position (before, after)",
-                type: String
-            }
+        "-d, --directory <directory>": {
+            description: "Directory where the file must be generated",
+            type: String
+        },
+        "-t, --template-type <templateType>": {
+            description: "Directory where the file must be generated",
+            type: String
+        },
+        "-m, --middleware-position <templateType>": {
+            description: "Middleware position (before, after)",
+            type: String
         }
-    }),
-    __metadata("design:paramtypes", [ProvidersInfoService])
-], GenerateCmd);
-export { GenerateCmd };
+    }
+});

package/lib/esm/commands/generate/mappers/mapGenerateContext.js

@@ -0,0 +1,29 @@
+import { inject, ProjectPackageJson } from "@tsed/cli-core";
+import { normalizePath } from "@tsed/normalize-path";
+import { ProjectConvention } from "../../../interfaces/ProjectConvention.js";
+import { OutputFilePathPipe } from "../../../pipes/OutputFilePathPipe.js";
+import { SymbolNamePipe } from "../../../pipes/SymbolNamePipe.js";
+export function mapGenerateContext(ctx) {
+    const classNamePipe = inject(SymbolNamePipe);
+    const outputFilePathPipe = inject(OutputFilePathPipe);
+    const projectPackageJson = inject(ProjectPackageJson);
+    const { name = "" } = ctx;
+    let { type = "" } = ctx;
+    type = type.toLowerCase();
+    if (ctx.name === "prisma" && ctx.name) {
+        type = "prisma.service";
+    }
+    const symbolName = classNamePipe.transform({ name, type, format: ProjectConvention.DEFAULT });
+    const symbolPath = normalizePath(outputFilePathPipe.transform({
+        name,
+        type,
+        subDir: ctx.directory
+    }));
+    return {
+        ...projectPackageJson.fillWithPreferences(ctx),
+        type,
+        symbolName,
+        symbolPath,
+        symbolPathBasename: normalizePath(classNamePipe.transform({ name, type }))
+    };
+}