@tsed/cli 7.0.0-alpha.1 → 7.0.0-alpha.10

package/lib/esm/bin/tsed.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "@swc-node/register/esm-register";
 import { register } from "node:module";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -14,8 +15,28 @@ register(pathToFileURL(join(import.meta.dirname, `../loaders/alias.hook.${EXT}`)
     },
     transferList: []
 });
-const { Cli } = await import("../Cli.js");
-Cli.bootstrap({}).catch((error) => {
+const { commands, CliCore, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
+CliCore.bootstrap({
+    name: "tsed",
+    pkg: PKG,
+    templateDir: TEMPLATE_DIR,
+    plugins: true,
+    updateNotifier: true,
+    checkPrecondition: true,
+    commands,
+    defaultProjectPreferences() {
+        return {
+            convention: ProjectConvention.DEFAULT,
+            architecture: ArchitectureConvention.DEFAULT
+        };
+    },
+    project: {
+        reinstallAfterRun: true
+    },
+    logger: {
+        level: "info"
+    }
+}).catch((error) => {
     console.error(error);
     process.exit(-1);
 });

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

@@ -1,14 +1,15 @@
 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 { addContextMethods } from "../../services/mappers/addContextMethods.js";
 import { mapDefaultTemplateOptions } from "../../services/mappers/mapDefaultTemplateOptions.js";
 const searchFactory = (list) => {
+    const items = list.map((item) => ({ name: item.label, value: item.id }));
     return (_, keyword) => {
         if (keyword) {
-            return list.filter((item) => item.label.toLowerCase().includes(keyword.toLowerCase()));
+            return items.filter((item) => item.name.toLowerCase().includes(keyword.toLowerCase()));
         }
-        return list;
+        return items;
     };
 };
 export class GenerateCmd {
@@ -18,7 +19,7 @@ export class GenerateCmd {
         this.templates = inject(CliTemplatesService);
     }
     async $prompt(data) {
-        data.getName = (state) => data.name || pascalCase(state.name || data.name || state.type || data.type || "");
+        data = addContextMethods(data);
         const templates = this.templates.find();
         const templatesPrompts = await Promise.all(templates
             .filter((template) => template.prompts)
@@ -29,7 +30,7 @@ export class GenerateCmd {
             {
                 type: "autocomplete",
                 name: "type",
-                message: "Which type of provider?",
+                message: "Which template you want to use?",
                 default: data.type,
                 when: () => templates.length > 1,
                 source: searchFactory(this.templates.find(data.type))
@@ -53,15 +54,11 @@ export class GenerateCmd {
             {
                 title: `Generate ${ctx.type} file to '${symbolPath}.ts'`,
                 skip: !this.templates.get(type),
-                task: () => {
-                    this.projectService.createFromTemplate(type, ctx);
-                }
+                task: () => this.projectService.createFromTemplate(type, ctx)
             },
             {
                 title: "Transform generated files",
-                task: () => {
-                    return this.projectService.transformFiles(ctx);
-                }
+                task: () => this.projectService.transformFiles(ctx)
             }
         ];
     }

package/lib/esm/commands/index.js

@@ -2,5 +2,6 @@ import { AddCmd } from "./add/AddCmd.js";
 import { GenerateCmd } from "./generate/GenerateCmd.js";
 import { InitCmd } from "./init/InitCmd.js";
 import { RunCmd } from "./run/RunCmd.js";
+import { CreateTemplateCommand } from "./template/CreateTemplateCommand.js";
 import { UpdateCmd } from "./update/UpdateCmd.js";
-export default [AddCmd, InitCmd, GenerateCmd, UpdateCmd, RunCmd];
+export default [AddCmd, InitCmd, GenerateCmd, UpdateCmd, RunCmd, CreateTemplateCommand];

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

@@ -7,6 +7,7 @@ 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 { taskOutput } from "../../fn/taskOutput.js";
 import { ArchitectureConvention } from "../../interfaces/ArchitectureConvention.js";
 import { PlatformType } from "../../interfaces/index.js";
 import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
@@ -119,7 +120,7 @@ export class InitCmd {
         await createTasksRunner([
             {
                 title: "Write RC files",
-                skip: () => !ctx.GH_TOKEN,
+                skip: () => !ctx.premium,
                 task: () => {
                     return Promise.all([render(".npmrc", ctx), render(".yarnrc", ctx)]);
                 }
@@ -160,13 +161,11 @@ export class InitCmd {
         return [
             {
                 title: "Render base files",
-                task: async () => {
-                    return this.renderFiles(ctx);
-                }
+                task: () => this.renderFiles(ctx)
             },
             {
                 title: "Alter package json",
-                task: async () => {
+                task: () => {
                     return $asyncAlter("$alterPackageJson", this.packageJson, [ctx]);
                 }
             },
@@ -175,7 +174,7 @@ export class InitCmd {
                 task: createSubTasks(async () => {
                     const subTasks = [
                         ...(await exec("generate", {
-                            ...ctx,
+                            //...ctx,
                             type: "controller",
                             route: "rest",
                             name: "HelloWorld",
@@ -183,7 +182,7 @@ export class InitCmd {
                         })),
                         ...(ctx.commands
                             ? await exec("generate", {
-                                ...ctx,
+                                //...ctx,
                                 type: "command",
                                 route: "hello",
                                 name: "hello"
@@ -241,6 +240,7 @@ export class InitCmd {
             "@tsed/core": ctx.tsedVersion,
             "@tsed/di": ctx.tsedVersion,
             "@tsed/ajv": ctx.tsedVersion,
+            "@tsed/config": ctx.tsedVersion,
             "@tsed/exceptions": ctx.tsedVersion,
             "@tsed/schema": ctx.tsedVersion,
             "@tsed/json-mapper": ctx.tsedVersion,
@@ -255,13 +255,11 @@ export class InitCmd {
             "@tsed/platform-views": ctx.tsedVersion,
             "@tsed/platform-multer": ctx.tsedVersion,
             "@tsed/logger": "latest",
+            "@tsed/logger-std": "latest",
             "@tsed/engines": "latest",
             "@tsed/barrels": "latest",
             ajv: "latest",
             "cross-env": "latest",
-            dotenv: "latest",
-            "dotenv-expand": "latest",
-            "dotenv-flow": "latest",
             ...this.runtimes.get().dependencies(),
             ...this.platforms.get(ctx.platform).dependencies(ctx)
         });
@@ -301,7 +299,7 @@ export class InitCmd {
         // files with higher priority
         const promises = [
             "tsconfig.base.json",
-            "tsconfig.config.json",
+            "tsconfig.json",
             "tsconfig.spec.json",
             "tsconfig.node.json",
             "docker-compose.yml",
@@ -314,6 +312,7 @@ export class InitCmd {
             "index.config.util",
             "index.logger",
             "index.controller",
+            ctx.commands && "index.command",
             "barrels",
             "readme",
             `pm2.${pm2}`,
@@ -326,8 +325,11 @@ export class InitCmd {
     }
     async renderFiles(ctx) {
         // base files
+        let startTime = Date.now();
         await this.baseFiles(ctx);
+        taskOutput(`Base files rendered (${Date.now() - startTime}ms)`);
         const files = await $asyncAlter("$alterRenderFiles", [], [ctx]);
+        startTime = Date.now();
         const promises = files.map((option) => {
             if (!option) {
                 return;
@@ -350,6 +352,7 @@ export class InitCmd {
             }
         });
         await Promise.all(promises);
+        taskOutput(`Plugins files rendered (${Date.now() - startTime}ms)`);
     }
 }
 command(InitCmd, {

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

@@ -1,5 +1,5 @@
 import { ArchitectureConvention, PlatformType, ProjectConvention } from "../../../interfaces/index.js";
-import { hasFeature, hasValue } from "../utils/hasFeature.js";
+import { hasFeature, hasValue, hasValuePremium } from "../utils/hasFeature.js";
 import { isPlatform } from "../utils/isPlatform.js";
 export var FeatureType;
 (function (FeatureType) {
@@ -16,10 +16,11 @@ export var FeatureType;
     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";
+    FeatureType["CONFIG_AWS_SECRETS"] = "config:aws_secrets:premium";
+    FeatureType["CONFIG_IOREDIS"] = "config:ioredis:premium";
+    FeatureType["CONFIG_MONGO"] = "config:mongo:premium";
+    FeatureType["CONFIG_VAULT"] = "config:vault:premium";
+    FeatureType["CONFIG_POSTGRES"] = "config:postgres:premium";
     // DOC
     FeatureType["SWAGGER"] = "swagger";
     FeatureType["SCALAR"] = "scalar";
@@ -158,39 +159,59 @@ export const FeaturesMap = {
         name: "Envs"
     },
     [FeatureType.CONFIG_DOTENV]: {
-        name: "Dotenv"
+        name: "Dotenv",
+        dependencies: {
+            dotenv: "latest",
+            "dotenv-expand": "latest",
+            "dotenv-flow": "latest"
+        }
     },
     [FeatureType.CONFIG_JSON]: {
         name: "JSON"
     },
     [FeatureType.CONFIG_YAML]: {
-        name: "YAML"
+        name: "YAML",
+        dependencies: {
+            "js-yaml": "latest"
+        }
+    },
+    [FeatureType.CONFIG_AWS_SECRETS]: {
+        name: "AWS Secrets Manager (Premium)",
+        dependencies: {
+            "@tsedio/config-source-aws-secrets": "latest",
+            "@aws-sdk/client-secrets-manager": "latest"
+        }
     },
     [FeatureType.CONFIG_IOREDIS]: {
         name: "IORedis (Premium)",
         dependencies: {
-            ioredis: "latest",
-            "@tsedio/config-ioredis": "{{tsedVersion}}"
+            "@tsedio/config-ioredis": "{{tsedVersion}}",
+            "@tsed/ioredis": "{{tsedVersion}}",
+            ioredis: "latest"
+        },
+        devDependencies: {
+            "@tsedio/testcontainers-redis": "latest"
         }
     },
     [FeatureType.CONFIG_MONGO]: {
         name: "MongoDB (Premium)",
         dependencies: {
             mongodb: "latest",
-            "@tsedio/config-mongo": "{{tsedVersion}}"
+            "@tsedio/config-mongo": "latest"
         }
     },
     [FeatureType.CONFIG_VAULT]: {
         name: "Vault (Premium)",
         dependencies: {
-            "@tsedio/config-vault": "{{tsedVersion}}"
+            "@tsedio/config-vault": "latest",
+            "node-vault": "latest"
         }
     },
     [FeatureType.CONFIG_POSTGRES]: {
         name: "Postgres (Premium)",
         dependencies: {
             pg: "latest",
-            "@tsedio/config-postgres": "{{tsedVersion}}"
+            "@tsedio/config-postgres": "latest"
         }
     },
     /// TYPEORM
@@ -389,6 +410,7 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
             FeatureType.CONFIG_DOTENV,
             FeatureType.CONFIG_JSON,
             FeatureType.CONFIG_YAML,
+            FeatureType.CONFIG_AWS_SECRETS,
             FeatureType.CONFIG_IOREDIS,
             FeatureType.CONFIG_MONGO,
             FeatureType.CONFIG_VAULT,
@@ -431,13 +453,12 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
         ],
         when: hasValue("featuresDB", FeatureType.TYPEORM)
     },
-    // {
-    //   type: "password",
-    //   name: "GH_TOKEN",
-    //   message:
-    //     "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")
-    // },
+    {
+        type: "password",
+        name: "GH_TOKEN",
+        message: "Enter GH_TOKEN to use the premium @tsedio package or leave blank (see https://tsed.dev/plugins/premium/install-premium-plugins.html)",
+        when: hasValuePremium()
+    },
     {
         message: "Choose unit framework",
         type: "list",

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

@@ -4,6 +4,10 @@ export function mapToContext(options) {
     options = mapUniqFeatures(options);
     options.features.forEach((feature) => {
         const [base, type] = feature.split(":");
+        if (feature?.endsWith(":premium")) {
+            feature = feature.replace(":premium", "");
+            options.premium = true;
+        }
         options[camelCase(base)] = true;
         type && (options[camelCase(type)] = true);
         feature && (options[camelCase(feature)] = true);

package/lib/esm/commands/init/prompts/getFeaturesPrompt.js

@@ -18,15 +18,3 @@ export function getFeaturesPrompt(runtimes, availablePackageManagers, options) {
         });
     });
 }
-export function getFrameworksPrompt() {
-    return {
-        ...FrameworksPrompt,
-        choices: FrameworksPrompt.choices.map((choice, index) => {
-            return cleanObject({
-                ...FeaturesMap[choice],
-                checked: index === 0,
-                value: choice
-            });
-        })
-    };
-}

package/lib/esm/commands/init/utils/hasFeature.js

@@ -5,3 +5,6 @@ export function hasValue(expression, value) {
 export function hasFeature(feature) {
     return (ctx) => !!ctx.features.find((item) => item === feature);
 }
+export function hasValuePremium() {
+    return (ctx) => !!ctx.features.find((item) => item.endsWith(":premium"));
+}

package/lib/esm/commands/template/CreateTemplateCommand.js

@@ -0,0 +1,101 @@
+import { command, inject, ProjectPackageJson } from "@tsed/cli-core";
+import { snakeCase } from "change-case";
+import { PKG } from "../../constants/index.js";
+import { render } from "../../fn/render.js";
+import { CliTemplatesService } from "../../services/CliTemplatesService.js";
+const searchFactory = (list) => {
+    const items = list.map((item) => ({ name: item.label, value: item.id }));
+    return (_, keyword) => {
+        if (keyword) {
+            return items.filter((item) => item.name.toLowerCase().includes(keyword.toLowerCase()));
+        }
+        return items;
+    };
+};
+export class CreateTemplateCommand {
+    constructor() {
+        this.projectPackageJson = inject(ProjectPackageJson);
+        this.templates = inject(CliTemplatesService);
+    }
+    async $prompt(data) {
+        return [
+            {
+                type: "list",
+                name: "from",
+                message: "Create a template from existing one?",
+                default: "new",
+                when: !data.from,
+                choices: [
+                    { name: "No, create a new template", value: "new" },
+                    { name: "Yes, from existing template", value: "existing" }
+                ]
+            },
+            {
+                type: "autocomplete",
+                name: "templateId",
+                message: "Select the template to use as base",
+                default: data.from,
+                when: (ctx) => {
+                    return ctx.from === "existing";
+                },
+                source: searchFactory(this.templates.find())
+            },
+            {
+                type: "confirm",
+                name: "override",
+                message: "Would you like to override the selected Ts.ED default template?",
+                when: (ctx) => ctx.from !== "new",
+                default: !!data.override
+            },
+            {
+                type: "input",
+                name: "name",
+                message: "Which name?",
+                default: data.name,
+                when: !data.name
+            }
+        ];
+    }
+    $mapContext(ctx) {
+        const symbolName = snakeCase(ctx.name).replace(/_/g, "-");
+        return {
+            ...ctx,
+            symbolPath: `./.templates/${symbolName}.template`,
+            symbolPathBasename: ".",
+            symbolName: symbolName,
+            templateId: ctx.orverride ? ctx.templateId : symbolName,
+            template: ctx.templateId && this.templates.get(ctx.templateId)
+        };
+    }
+    $exec(ctx) {
+        this.projectPackageJson.addDevDependencies({ "@tsed/cli": PKG.version });
+        return [
+            {
+                title: "Generate " + ctx.from === "new" ? `new template ${ctx.templateId}` : `template ${ctx.templateId} from ${ctx.from}`,
+                task: async () => {
+                    await render("new-template", ctx);
+                }
+            }
+        ];
+    }
+}
+command(CreateTemplateCommand, {
+    name: "template",
+    description: "Create a custom template that can be selected in tsed generate command",
+    args: {
+        name: {
+            description: "Name of the class",
+            type: String
+        }
+    },
+    options: {
+        "--from <from>": {
+            type: String,
+            description: "Select the template to use as base"
+        },
+        "--override": {
+            type: Boolean,
+            description: "Override the existing selected template"
+        }
+    }
+});

package/lib/esm/fn/taskOutput.js

@@ -0,0 +1,7 @@
+import { context } from "@tsed/di";
+export function taskOutput(output) {
+    const task = context().get("currentTask");
+    if (task) {
+        task.output = output;
+    }
+}

package/lib/esm/index.js

@@ -1,7 +1,8 @@
+import "@tsed/logger-std";
 import "./templates/index.js";
-export * from "./Cli.js";
 export * from "./commands/add/AddCmd.js";
 export * from "./commands/generate/GenerateCmd.js";
+export { default as commands } from "./commands/index.js";
 export * from "./commands/init/config/FeaturesPrompt.js";
 export * from "./commands/init/config/FeaturesPrompt.js";
 export * from "./commands/init/InitCmd.js";
@@ -17,3 +18,4 @@ export * from "./services/CliProjectService.js";
 export * from "./services/CliTemplatesService.js";
 export * from "./services/ProjectClient.js";
 export * from "./utils/defineTemplate.js";
+export { CliCore } from "@tsed/cli-core";

package/lib/esm/processors/transformConfigFile.js

@@ -1,26 +1,105 @@
-import { SyntaxKind } from "ts-morph";
 export function transformConfigFile(project, data) {
-    const sourceFile = project.configSourceFile;
-    const options = project.findConfiguration("config");
-    if (!options) {
-        return;
+    if (!data.config && data.commandName === "init") {
+        project.addConfigSource("EnvsConfigSource", {
+            moduleSpecifier: "@tsed/config/envs"
+        });
     }
     if (data.config) {
-        // const extendsConfig = project.getPropertyAssignment(options, {
-        //   name: "extends",
-        //   kind: SyntaxKind.ObjectLiteralExpression,
-        //   initializer: "[]"
-        // });
-        //
-        // if (data.configEnvs) {
-        //   sourceFile.addImportDeclaration({
-        //     moduleSpecifier: "@tsed/config/envs",
-        //     namedImports: [{name: "EnvsConfigSource"}]
-        //   });
-        // }
+        if (data.configDotenv) {
+            project.addConfigSource("DotenvConfigSource", {
+                moduleSpecifier: "@tsed/config/dotenv"
+            });
+        }
+        else if (data.configEnvs) {
+            project.addConfigSource("EnvsConfigSource", {
+                moduleSpecifier: "@tsed/config/envs"
+            });
+        }
+        if (data.configJson) {
+            project.addConfigSource("JsonConfigSource", {
+                moduleSpecifier: "@tsed/config/json",
+                content: `withOptions(JsonConfigSource, {
+      path: "./config.json"
+    })`
+            });
+        }
+        if (data.configYaml) {
+            project.addConfigSource("YamlConfigSource", {
+                moduleSpecifier: "@tsed/config/yaml",
+                content: `withOptions(YamlConfigSource, {
+      path: "./config.yaml"
+    })`
+            });
+        }
+        if (data.configAwsSecrets) {
+            project.addConfigSource("AwsSecretsConfigSource", {
+                moduleSpecifier: "@tsedio/config-source-aws-secrets",
+                content: `withOptions(AwsSecretsConfigSource, {
+              name: "aws",
+      path: "/my-app/config", // Path prefix in Secrets Manager
+      region: "us-east-1", // AWS region
+      watch: true // Enable secrets watching
+      // validationSchema: object({}) // Optional: add a validation schema
+      // maxConcurrency: 10
+      })`
+            });
+        }
+        if (data.configVault) {
+            project.addConfigSource("VaultConfigSource", {
+                moduleSpecifier: "@tsedio/config-vault",
+                content: `    withOptions(VaultConfigSource, {
+      name: "vault",
+      endpoint: "http://localhost:8200", // Vault server URL
+      token: "your-vault-token", // Your Vault token
+      secretPath: "secret/data/myapp", // Path to your secret (KV v2 or v1, see below)
+      refreshInterval: 10000 // ⏱️ Polling interval in ms (default: 10s)
+      // Additional node-vault options
+
+      // validationSchema: object({}) // Optional: add a validation schema
+    })`
+            });
+        }
+        if (data.configIoredis) {
+            project.addConfigSource("IoredisConfigSource", {
+                moduleSpecifier: "@tsedio/config-ioredis",
+                content: `withOptions(IoredisConfigSource, {
+      name: "redis",
+      prefixKey: "my-config", // Optional: All config keys will be prefixed
+      url: "redis://localhost:6379" // Or use any Redis/Cluster options
+      // validationSchema: object({}) // Optional: add a validation schema
+    })`
+            });
+        }
+        if (data.configMongo) {
+            project.addConfigSource("MongoConfigSource", {
+                moduleSpecifier: "@tsedio/config-mongo",
+                content: `withOptions(MongoConfigSource, {
+      name: "mongo",
+      url: "mongodb://localhost:27017", // MongoDB connection URL
+      database: "my_database", // Database name
+      collection: "config" // Collection used for config storage
+
+      // Additional MongoDB client options can be provided here
+
+      // ConfigSource options
+      // validationSchema: object({}) // Optional: add a validation schema
+    })`
+            });
+        }
+        if (data.configPostgres) {
+            project.addConfigSource("PostgresConfigSource", {
+                moduleSpecifier: "@tsedio/config-postgres",
+                content: `withOptions(PostgresConfigSource, {
+      name: "postgres",
+      connectionString: "postgresql://postgres:postgres@localhost:5432/my_database", // PostgreSQL connection string
+      table: "config" // Table used for config storage
+
+      // Additional PostgresSQL client options can be provided here
+
+      // ConfigSource options
+      // validationSchema: object({}) // Optional: add a validation schema
+    })`
+            });
+        }
     }
-    sourceFile.organizeImports();
-    sourceFile.formatText({
-        indentSize: 2
-    });
 }

package/lib/esm/processors/transformIndexFile.js

@@ -12,7 +12,6 @@ export function transformIndexFile(project, data) {
         moduleSpecifier: "@tsed/platform-" + data.platform.toLowerCase(),
         namedImports: [platformName]
     });
-    // replace PlatformBuilder with Platform<PlatformType>
     sourceFile.getImportDeclaration((declaration) => declaration.getModuleSpecifierValue() === "@tsed/platform-http")?.remove();
     sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).map((identifier) => {
         if (identifier.getText() === "PlatformBuilder") {
@@ -21,8 +20,4 @@ export function transformIndexFile(project, data) {
         }
         return identifier;
     });
-    sourceFile.organizeImports();
-    sourceFile.formatText({
-        indentSize: 2
-    });
 }

package/lib/esm/processors/transformServerFile.js

@@ -57,8 +57,4 @@ export function transformServerFile(project, data) {
             project.addMountPath("/", "...Object.values(pages)");
         }
     }
-    sourceFile.organizeImports();
-    sourceFile.formatText({
-        indentSize: 2
-    });
 }