@tsed/cli 6.6.2 → 7.0.0-alpha.1

package/lib/esm/commands/init/InitCmd.js

@@ -1,35 +1,35 @@
-import { __decorate } from "tslib";
 import { basename, join } from "node:path";
-import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, CliService, Command, Configuration, createSubTasks, createTasksRunner, inject, PackageManager, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
-import { kebabCase, pascalCase } from "change-case";
-import { DEFAULT_TSED_TAGS } from "../../constants/index.js";
+import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, createSubTasks, createTasksRunner, inject, PackageManager, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { constant } from "@tsed/di";
+import { $asyncAlter } from "@tsed/hooks";
+import { kebabCase } from "change-case";
+import { DEFAULT_TSED_TAGS, TEMPLATE_DIR } from "../../constants/index.js";
+import { exec } from "../../fn/exec.js";
+import { render } from "../../fn/render.js";
 import { ArchitectureConvention } from "../../interfaces/ArchitectureConvention.js";
 import { PlatformType } from "../../interfaces/index.js";
 import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
-import { OutputFilePathPipe } from "../../pipes/OutputFilePathPipe.js";
-import { InitPlatformsModule } from "../../platforms/InitPlatformsModule.js";
+import { PlatformsModule } from "../../platforms/PlatformsModule.js";
 import { RuntimesModule } from "../../runtimes/RuntimesModule.js";
 import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
 import { NodeRuntime } from "../../runtimes/supports/NodeRuntime.js";
-import { RootRendererService } from "../../services/Renderer.js";
-import { fillImports } from "../../utils/fillImports.js";
+import { CliProjectService } from "../../services/CliProjectService.js";
 import { FeaturesMap, FeatureType } from "./config/FeaturesPrompt.js";
 import { InitFileSchema } from "./config/InitFileSchema.js";
 import { mapToContext } from "./mappers/mapToContext.js";
 import { getFeaturesPrompt } from "./prompts/getFeaturesPrompt.js";
-let InitCmd = class InitCmd {
+export class InitCmd {
     constructor() {
         this.configuration = inject(Configuration);
         this.cliPlugins = inject(CliPlugins);
         this.packageJson = inject(ProjectPackageJson);
         this.packageManagers = inject(PackageManagersModule);
         this.runtimes = inject(RuntimesModule);
-        this.platforms = inject(InitPlatformsModule);
+        this.platforms = inject(PlatformsModule);
         this.cliPackageJson = cliPackageJson();
-        this.cliService = inject(CliService);
         this.cliLoadFile = inject(CliLoadFile);
-        this.rootRenderer = inject(RootRendererService);
-        this.outputFilePathPipe = inject(OutputFilePathPipe);
+        this.project = inject(CliProjectService);
         this.execa = inject(CliExeca);
         this.fs = inject(CliFs);
     }
@@ -101,29 +101,28 @@ let InitCmd = class InitCmd {
         this.packageManagers.list().forEach((key) => {
             ctx[key] = ctx.packageManager === key;
         });
-        return fillImports({
+        return {
             ...ctx,
-            entryServer: ctx.convention !== ProjectConvention.ANGULAR ? "Server" : "server",
             cliVersion: ctx.cliVersion || this.cliPackageJson.version,
-            srcDir: this.configuration.project?.srcDir,
-            platformSymbol: ctx.platform && pascalCase(`Platform ${ctx.platform}`)
-        });
+            srcDir: constant("project.srcDir", "src")
+        };
     }
     async $beforeExec(ctx) {
         this.fs.ensureDirSync(this.packageJson.dir);
-        this.packageJson.name = ctx.projectName;
+        ctx.projectName && (this.packageJson.name = ctx.projectName);
         ctx.packageManager && this.packageJson.setPreference("packageManager", ctx.packageManager);
         ctx.runtime && this.packageJson.setPreference("runtime", ctx.runtime);
         ctx.architecture && this.packageJson.setPreference("architecture", ctx.architecture);
         ctx.convention && this.packageJson.setPreference("convention", ctx.convention);
+        ctx.platform && this.packageJson.setPreference("platform", ctx.convention);
         ctx.GH_TOKEN && this.packageJson.setGhToken(ctx.GH_TOKEN);
         await createTasksRunner([
             {
                 title: "Write RC files",
                 skip: () => !ctx.GH_TOKEN,
-                task: () => this.rootRenderer.renderAll(["/init/.npmrc.hbs", "/init/.yarnrc.hbs"], ctx, {
-                    baseDir: "/init"
-                })
+                task: () => {
+                    return Promise.all([render(".npmrc", ctx), render(".yarnrc", ctx)]);
+                }
             },
             {
                 title: "Initialize package.json",
@@ -151,39 +150,54 @@ let InitCmd = class InitCmd {
     }
     async $exec(ctx) {
         this.checkPrecondition(ctx);
-        const subTasks = [
-            ...(await this.cliService.getTasks("generate", {
-                ...ctx,
-                type: "server",
-                name: "Server",
-                route: "/rest"
-            })),
-            ...(await this.cliService.getTasks("generate", {
-                type: "controller",
-                route: "hello-world",
-                name: "HelloWorld",
-                directory: "rest"
-            })),
-            ...(ctx.commands
-                ? await this.cliService.getTasks("generate", {
-                    type: "command",
-                    route: "hello",
-                    name: "hello"
-                })
-                : [])
-        ];
+        const runtime = this.runtimes.get();
+        ctx = {
+            ...ctx,
+            node: runtime instanceof NodeRuntime,
+            bun: runtime instanceof BunRuntime,
+            compiled: runtime instanceof NodeRuntime && runtime.isCompiled()
+        };
         return [
             {
-                title: "Generate project files",
-                task: createSubTasks([
-                    {
-                        title: "Root files",
-                        task: () => {
-                            return this.generateFiles(ctx);
-                        }
-                    },
-                    ...subTasks
-                ], { ...ctx, concurrent: false })
+                title: "Render base files",
+                task: async () => {
+                    return this.renderFiles(ctx);
+                }
+            },
+            {
+                title: "Alter package json",
+                task: async () => {
+                    return $asyncAlter("$alterPackageJson", this.packageJson, [ctx]);
+                }
+            },
+            {
+                title: "Generate additional project files",
+                task: createSubTasks(async () => {
+                    const subTasks = [
+                        ...(await exec("generate", {
+                            ...ctx,
+                            type: "controller",
+                            route: "rest",
+                            name: "HelloWorld",
+                            directory: "rest"
+                        })),
+                        ...(ctx.commands
+                            ? await exec("generate", {
+                                ...ctx,
+                                type: "command",
+                                route: "hello",
+                                name: "hello"
+                            })
+                            : [])
+                    ];
+                    return $asyncAlter("$alterInitSubTasks", subTasks, [ctx]);
+                }, { ...ctx, concurrent: false })
+            },
+            {
+                title: "transform generated files to the project configuration",
+                task: async () => {
+                    return this.project.transformFiles(ctx);
+                }
             }
         ];
     }
@@ -262,7 +276,7 @@ let InitCmd = class InitCmd {
         }, ctx);
     }
     addFeatures(ctx) {
-        ctx.features.forEach((value) => {
+        ctx.features?.forEach((value) => {
             const feature = FeaturesMap[value.toLowerCase()];
             if (feature) {
                 if (feature.dependencies) {
@@ -273,128 +287,132 @@ let InitCmd = class InitCmd {
                 }
             }
         });
-        if (ctx.features.find((value) => value === FeatureType.GRAPHQL)) {
+        if (ctx.features?.find((value) => value === FeatureType.GRAPHQL)) {
             this.packageJson.addDependencies({
                 [`apollo-server-${ctx.platform}`]: "2.25.2"
             }, ctx);
         }
     }
-    generateFiles(ctx) {
-        const indexCtrlBaseName = basename(`${this.outputFilePathPipe.transform({
-            name: "Index",
-            type: "controller",
-            format: ctx.convention
-        })}.ts`);
-        const runtime = this.runtimes.get();
-        const packageManager = this.packageManagers.get();
-        ctx = {
-            ...ctx,
-            node: runtime instanceof NodeRuntime,
-            bun: runtime instanceof BunRuntime,
-            compiled: runtime instanceof NodeRuntime && runtime.isCompiled()
-        };
+    async baseFiles(ctx) {
+        const packageManager = inject(PackageManagersModule).get();
         const pm2 = ctx.bun ? "bun" : ctx.compiled ? "node-compiled" : "node-loader";
-        return this.rootRenderer.renderAll([
-            ...runtime.files(),
-            "/init/.dockerignore.hbs",
-            "/init/.gitignore.hbs",
-            "/init/.barrels.json.hbs",
-            {
-                path: `/init/pm2/${pm2}/processes.config.cjs.hbs`,
-                output: `processes.config.cjs`,
-                replaces: [`pm2/${pm2}`]
-            },
-            "/init/docker-compose.yml.hbs",
-            {
-                path: `/init/docker/${packageManager.name}/Dockerfile.hbs`,
-                output: `Dockerfile`,
-                replaces: [`docker/${packageManager.name}`]
-            },
-            "/init/README.md.hbs",
-            "/init/tsconfig.json.hbs",
-            "/init/tsconfig.base.json.hbs",
-            "/init/tsconfig.node.json.hbs",
-            ctx.testing && "/init/tsconfig.spec.json.hbs",
-            "/init/src/index.ts.hbs",
-            "/init/src/config/envs/index.ts.hbs",
-            "/init/src/config/logger/index.ts.hbs",
-            "/init/src/config/index.ts.hbs",
-            ctx.commands && "/init/src/bin/index.ts.hbs",
-            ctx.swagger && "/init/views/swagger.ejs.hbs",
-            ctx.swagger && {
-                path: "/init/src/controllers/pages/IndexController.ts.hbs",
-                basename: indexCtrlBaseName,
-                replaces: [ctx.architecture === ArchitectureConvention.FEATURE ? "controllers" : null]
-            }
-        ].filter(Boolean), ctx, {
-            baseDir: "/init"
+        const runtimes = inject(RuntimesModule);
+        const runtime = runtimes.get();
+        // files with higher priority
+        const promises = [
+            "tsconfig.base.json",
+            "tsconfig.config.json",
+            "tsconfig.spec.json",
+            "tsconfig.node.json",
+            "docker-compose.yml",
+            `dockerfile.${packageManager.name}`,
+            ".dockerignore",
+            ".gitignore",
+            "server",
+            "config",
+            "index",
+            "index.config.util",
+            "index.logger",
+            "index.controller",
+            "barrels",
+            "readme",
+            `pm2.${pm2}`,
+            ctx.swagger && "/views/swagger.ejs",
+            ...runtime.files()
+        ].map((id) => {
+            return id && render(id, ctx);
         });
+        await Promise.all(promises);
     }
-};
-InitCmd = __decorate([
-    Command({
-        name: "init",
-        description: "Init a new Ts.ED project",
-        args: {
-            root: {
-                type: String,
-                defaultValue: ".",
-                description: "Root directory to initialize the Ts.ED project"
+    async renderFiles(ctx) {
+        // base files
+        await this.baseFiles(ctx);
+        const files = await $asyncAlter("$alterRenderFiles", [], [ctx]);
+        const promises = files.map((option) => {
+            if (!option) {
+                return;
             }
-        },
-        options: {
-            "-n, --project-name <projectName>": {
-                type: String,
-                defaultValue: "",
-                description: "Set the project name. By default, the project is the same as the name directory."
-            },
-            "-a, --arch <architecture>": {
-                type: String,
-                defaultValue: ArchitectureConvention.DEFAULT,
-                description: `Set the default architecture convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
-            },
-            "-c, --convention <convention>": {
-                type: String,
-                defaultValue: ProjectConvention.DEFAULT,
-                description: `Set the default project convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
-            },
-            "-p, --platform <platform>": {
-                type: String,
-                defaultValue: PlatformType.EXPRESS,
-                description: "Set the default platform for Ts.ED (express, koa or fastify)"
-            },
-            "--features <features...>": {
-                type: Array,
-                itemType: String,
-                defaultValue: [],
-                description: "List of the Ts.ED features."
-            },
-            "--runtime <runtime>": {
-                itemType: String,
-                defaultValue: "node",
-                description: "The default runtime used to run the project"
-            },
-            "-m, --package-manager <packageManager>": {
-                itemType: String,
-                defaultValue: PackageManager.YARN,
-                description: "The default package manager to install the project"
-            },
-            "-t, --tsed-version <version>": {
-                type: String,
-                defaultValue: DEFAULT_TSED_TAGS,
-                description: "Use a specific version of Ts.ED (format: 5.x.x)."
-            },
-            "-f, --file <path>": {
-                type: String,
-                description: "Location of a file in which the features are defined."
-            },
-            "-s, --skip-prompt": {
-                type: Boolean,
-                defaultValue: false,
-                description: "Skip the prompt."
+            if (isString(option)) {
+                const [id, name] = option.split(":");
+                return render(id, {
+                    ...ctx,
+                    from: TEMPLATE_DIR,
+                    name: name || id
+                });
             }
+            else {
+                if ("id" in option) {
+                    return render(option.id, {
+                        ...ctx,
+                        ...option
+                    });
+                }
+            }
+        });
+        await Promise.all(promises);
+    }
+}
+command(InitCmd, {
+    name: "init",
+    description: "Init a new Ts.ED project",
+    args: {
+        root: {
+            type: String,
+            defaultValue: ".",
+            description: "Root directory to initialize the Ts.ED project"
+        }
+    },
+    options: {
+        "-n, --project-name <projectName>": {
+            type: String,
+            defaultValue: "",
+            description: "Set the project name. By default, the project is the same as the name directory."
+        },
+        "-a, --arch <architecture>": {
+            type: String,
+            defaultValue: ArchitectureConvention.DEFAULT,
+            description: `Set the default architecture convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
+        },
+        "-c, --convention <convention>": {
+            type: String,
+            defaultValue: ProjectConvention.DEFAULT,
+            description: `Set the default project convention (${ArchitectureConvention.DEFAULT} or ${ArchitectureConvention.FEATURE})`
         },
-        disableReadUpPkg: true
-    })
-], InitCmd);
-export { InitCmd };
+        "-p, --platform <platform>": {
+            type: String,
+            defaultValue: PlatformType.EXPRESS,
+            description: "Set the default platform for Ts.ED (express, koa or fastify)"
+        },
+        "--features <features...>": {
+            type: Array,
+            itemType: String,
+            defaultValue: [],
+            description: "List of the Ts.ED features."
+        },
+        "--runtime <runtime>": {
+            itemType: String,
+            defaultValue: "node",
+            description: "The default runtime used to run the project"
+        },
+        "-m, --package-manager <packageManager>": {
+            itemType: String,
+            defaultValue: PackageManager.YARN,
+            description: "The default package manager to install the project"
+        },
+        "-t, --tsed-version <version>": {
+            type: String,
+            defaultValue: DEFAULT_TSED_TAGS,
+            description: "Use a specific version of Ts.ED (format: 5.x.x)."
+        },
+        "-f, --file <path>": {
+            type: String,
+            description: "Location of a file in which the features are defined."
+        },
+        "-s, --skip-prompt": {
+            type: Boolean,
+            defaultValue: false,
+            description: "Skip the prompt."
+        }
+    },
+    disableReadUpPkg: true
+});

package/lib/esm/commands/init/config/FeaturesPrompt.js

@@ -7,9 +7,19 @@ export var FeatureType;
     FeatureType["SOCKETIO"] = "socketio";
     FeatureType["OIDC"] = "oidc";
     FeatureType["PASSPORTJS"] = "passportjs";
+    FeatureType["CONFIG"] = "config";
     FeatureType["COMMANDS"] = "commands";
     FeatureType["DB"] = "db";
     FeatureType["DOC"] = "doc";
+    // CONFIG
+    FeatureType["CONFIG_ENVS"] = "config:envs";
+    FeatureType["CONFIG_DOTENV"] = "config:dotenv";
+    FeatureType["CONFIG_JSON"] = "config:json";
+    FeatureType["CONFIG_YAML"] = "config:yaml";
+    FeatureType["CONFIG_IOREDIS"] = "config:ioredis";
+    FeatureType["CONFIG_MONGO"] = "config:mongo";
+    FeatureType["CONFIG_VAULT"] = "config:vault";
+    FeatureType["CONFIG_POSTGRES"] = "config:postgres";
     // DOC
     FeatureType["SWAGGER"] = "swagger";
     FeatureType["SCALAR"] = "scalar";
@@ -32,7 +42,7 @@ export var FeatureType;
     FeatureType["TYPEORM_SQLJS"] = "typeorm:sqljs";
     FeatureType["TYPEORM_REACTNATIVE"] = "typeorm:reactnative";
     FeatureType["TYPEORM_EXPO"] = "typeorm:expo";
-    // TESTING
+    // TESTING & LINTER
     FeatureType["TESTING"] = "testing";
     FeatureType["JEST"] = "jest";
     FeatureType["VITEST"] = "vitest";
@@ -137,6 +147,53 @@ export const FeaturesMap = {
         name: "Feature",
         checked: false
     },
+    /// CONFIGURATION SOURCES
+    [FeatureType.CONFIG]: {
+        name: "Configuration sources",
+        dependencies: {
+            "@tsed/config": "{{tsedVersion}}"
+        }
+    },
+    [FeatureType.CONFIG_ENVS]: {
+        name: "Envs"
+    },
+    [FeatureType.CONFIG_DOTENV]: {
+        name: "Dotenv"
+    },
+    [FeatureType.CONFIG_JSON]: {
+        name: "JSON"
+    },
+    [FeatureType.CONFIG_YAML]: {
+        name: "YAML"
+    },
+    [FeatureType.CONFIG_IOREDIS]: {
+        name: "IORedis (Premium)",
+        dependencies: {
+            ioredis: "latest",
+            "@tsedio/config-ioredis": "{{tsedVersion}}"
+        }
+    },
+    [FeatureType.CONFIG_MONGO]: {
+        name: "MongoDB (Premium)",
+        dependencies: {
+            mongodb: "latest",
+            "@tsedio/config-mongo": "{{tsedVersion}}"
+        }
+    },
+    [FeatureType.CONFIG_VAULT]: {
+        name: "Vault (Premium)",
+        dependencies: {
+            "@tsedio/config-vault": "{{tsedVersion}}"
+        }
+    },
+    [FeatureType.CONFIG_POSTGRES]: {
+        name: "Postgres (Premium)",
+        dependencies: {
+            pg: "latest",
+            "@tsedio/config-postgres": "{{tsedVersion}}"
+        }
+    },
+    /// TYPEORM
     [FeatureType.TYPEORM_MYSQL]: {
         name: "MySQL",
         dependencies: {
@@ -225,6 +282,7 @@ export const FeaturesMap = {
             typeorm: "latest"
         }
     },
+    /// TESTING
     [FeatureType.VITEST]: {
         name: "Vitest",
         devDependencies: {
@@ -237,6 +295,7 @@ export const FeaturesMap = {
             "@tsed/cli-plugin-jest": "{{cliVersion}}"
         }
     },
+    // LINTER
     [FeatureType.ESLINT]: {
         name: "EsLint",
         checked: true,
@@ -308,6 +367,7 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
         name: "features",
         message: "Check the features needed for your project",
         choices: [
+            FeatureType.CONFIG,
             FeatureType.GRAPHQL,
             FeatureType.DB,
             FeatureType.PASSPORTJS,
@@ -317,6 +377,22 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
             FeatureType.TESTING,
             FeatureType.LINTER,
             FeatureType.COMMANDS
+        ].sort((a, b) => a.localeCompare(b))
+    },
+    {
+        type: "checkbox",
+        message: "Choose configuration sources",
+        name: "featuresConfig",
+        when: hasFeature(FeatureType.CONFIG),
+        choices: [
+            FeatureType.CONFIG_ENVS,
+            FeatureType.CONFIG_DOTENV,
+            FeatureType.CONFIG_JSON,
+            FeatureType.CONFIG_YAML,
+            FeatureType.CONFIG_IOREDIS,
+            FeatureType.CONFIG_MONGO,
+            FeatureType.CONFIG_VAULT,
+            FeatureType.CONFIG_POSTGRES
         ]
     },
     {
@@ -359,8 +435,8 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
     //   type: "password",
     //   name: "GH_TOKEN",
     //   message:
-    //     "Enter GH_TOKEN to use the premium @tsedio/prisma package or leave blank (see https://tsed.dev/tutorials/prisma-client.html)",
-    //   when: hasValue("featuresDB.type", "prisma")
+    //     "Enter GH_TOKEN to use the premium @tsedio package or leave blank (see https://tsed.dev/plugins/premium/install-premium-plugins.html)"
+    //   // when: hasValue("featuresDB.type", "prisma")
     // },
     {
         message: "Choose unit framework",

package/lib/esm/commands/init/mappers/mapToContext.js

@@ -3,9 +3,10 @@ import { mapUniqFeatures } from "./mapUniqFeatures.js";
 export function mapToContext(options) {
     options = mapUniqFeatures(options);
     options.features.forEach((feature) => {
-        feature.split(":").forEach((type) => {
-            options[camelCase(type)] = true;
-        });
+        const [base, type] = feature.split(":");
+        options[camelCase(base)] = true;
+        type && (options[camelCase(type)] = true);
+        feature && (options[camelCase(feature)] = true);
     });
     return options;
 }

package/lib/esm/commands/run/RunCmd.js

@@ -1,7 +1,6 @@
-import { __decorate } from "tslib";
-import { CliFs, Command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
+import { CliFs, command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
 import { CliRunScript } from "../../services/CliRunScript.js";
-let RunCmd = class RunCmd {
+export class RunCmd {
     constructor() {
         this.fs = inject(CliFs);
         this.projectPackageJson = inject(ProjectPackageJson);
@@ -16,26 +15,23 @@ let RunCmd = class RunCmd {
         });
         return [];
     }
-};
-RunCmd = __decorate([
-    Command({
-        name: "run",
-        description: "Run a project level command",
-        args: {
-            command: {
-                description: "The project command",
-                type: String,
-                required: true
-            }
-        },
-        options: {
-            "-p, --production": {
-                type: Boolean,
-                defaultValue: false,
-                description: "Set production profile to NODE_ENV"
-            }
-        },
-        allowUnknownOption: true
-    })
-], RunCmd);
-export { RunCmd };
+}
+command(RunCmd, {
+    name: "run",
+    description: "Run a project level command",
+    args: {
+        command: {
+            description: "The project command",
+            type: String,
+            required: true
+        }
+    },
+    options: {
+        "-p, --production": {
+            type: Boolean,
+            defaultValue: false,
+            description: "Set production profile to NODE_ENV"
+        }
+    },
+    allowUnknownOption: true
+});