@tsed/cli 7.0.0-alpha.3 → 7.0.0-alpha.5

package/lib/esm/Cli.js

@@ -1,4 +1,5 @@
 import "@tsed/logger-std";
+import "./templates/index.js";
 import { CliCore } from "@tsed/cli-core";
 import chalk from "chalk";
 import commands from "./commands/index.js";

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";

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))

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

@@ -120,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)]);
                 }

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,11 +16,11 @@ export var FeatureType;
     FeatureType["CONFIG_DOTENV"] = "config:dotenv";
     FeatureType["CONFIG_JSON"] = "config:json";
     FeatureType["CONFIG_YAML"] = "config:yaml";
-    FeatureType["CONFIG_AWS_SECRETS"] = "config:aws_secrets";
-    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";
@@ -453,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,99 @@
+import { command, inject, ProjectPackageJson } from "@tsed/cli-core";
+import { snakeCase } from "change-case";
+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) {
+        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/services/CliProjectService.js

@@ -32,7 +32,7 @@ export class CliProjectService {
         this.project = new ProjectClient({
             rootDir: this.rootDir
         });
-        const files = fs.globSync([join(constant("project.rootDir", process.cwd()), "**/*.ts")]);
+        const files = fs.globSync(["!**/node_modules/**", join(constant("project.rootDir", process.cwd()), "**/*.ts")]);
         files.forEach((file) => {
             this.project.createSourceFile(file, fs.readFileSync(file, "utf8"), {
                 overwrite: true
@@ -66,15 +66,14 @@ export class CliProjectService {
             return sourceFile.save();
         }));
     }
-    async createFromTemplate(templateId, ctx) {
-        const startTime = Date.now();
-        const obj = await this.templates.render(templateId, ctx);
-        taskOutput(`Template ${templateId} rendered in ${Date.now() - startTime}ms`);
+    async createFromTemplate(templateId, data) {
+        const obj = await this.templates.render(templateId, data);
         const project = this.get();
         if (obj) {
             const sourceFile = await project.createSource(obj.outputPath, obj.content, {
                 overwrite: true
             });
+            sourceFile && this.templates.get(templateId)?.hooks?.$afterCreateSourceFile?.(sourceFile, data);
             return {
                 ...obj,
                 source: sourceFile

package/lib/esm/services/CliTemplatesService.js

@@ -1,27 +1,75 @@
 import { join } from "node:path";
 import { CliFs } from "@tsed/cli-core";
-import { constant, inject, injectable, injectMany } from "@tsed/di";
+import { constant, inject, injectable, injectMany, logger } from "@tsed/di";
+import { globby } from "globby";
 import { TEMPLATE_DIR } from "../constants/index.js";
 import { mapDefaultTemplateOptions } from "./mappers/mapDefaultTemplateOptions.js";
 export class CliTemplatesService {
     constructor() {
         this.rootDir = constant("project.rootDir", process.cwd());
         this.fs = inject(CliFs);
+        this.#templates = new Map();
     }
+    #customTemplates;
+    #templates;
     get srcDir() {
         return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
     }
+    get templatesDir() {
+        return join(this.rootDir, ".templates");
+    }
+    $onInit() {
+        return this.loadTemplates();
+    }
+    async loadTemplates() {
+        if (!this.#customTemplates?.length) {
+            const files = await globby("**/*.ts", {
+                cwd: this.templatesDir
+            });
+            const promises = files.map(async (file) => {
+                try {
+                    const files = join(this.templatesDir, file);
+                    const { default: token } = await import(files.replace(".ts", ".js"));
+                    if (token) {
+                        return inject(token);
+                    }
+                }
+                catch (er) {
+                    logger().warn("Unable to load custom template %s: %s", file, er.message);
+                }
+            });
+            let customs = await Promise.all(promises);
+            this.#customTemplates = customs.map((template) => {
+                return {
+                    ...template,
+                    label: template.label + " (custom)"
+                };
+            });
+        }
+    }
+    getAll() {
+        const templates = injectMany("CLI_TEMPLATES");
+        const map = (this.#customTemplates || []).concat(templates).reduce((acc, template) => {
+            if (acc.has(template.id)) {
+                return acc;
+            }
+            return acc.set(template.id, template);
+        }, new Map());
+        return [...map.values()];
+    }
     find(id) {
-        const templates = injectMany("CLI_TEMPLATES").filter((template) => !template.hidden);
-        id = id?.toLowerCase();
-        const foundTemplates = templates.filter((template) => {
-            return template.label.toLowerCase().includes(id) || template.id.includes(id);
-        });
-        return foundTemplates.length ? foundTemplates : templates;
+        const templates = this.getAll().filter((template) => !template.hidden);
+        if (id) {
+            id = id?.toLowerCase();
+            const foundTemplates = templates.filter((template) => {
+                return template.label.toLowerCase().includes(id) || template.id.includes(id);
+            });
+            return foundTemplates.length ? foundTemplates : templates;
+        }
+        return templates;
     }
     get(id) {
-        const templates = injectMany("CLI_TEMPLATES");
-        return templates.find((template) => template.id === id);
+        return this.getAll().find((template) => template.id === id);
     }
     async render(templateId, data) {
         const template = this.get(templateId);

package/lib/esm/services/ProjectClient.js

@@ -113,6 +113,28 @@ export class ProjectClient extends Project {
             })
                 .getInitializerIfKindOrThrow(kind));
     }
+    addConfigSource(name, { content = name, moduleSpecifier }) {
+        const sourceFile = this.configSourceFile;
+        const options = this.findConfiguration("config");
+        if (!options) {
+            return;
+        }
+        const extendsConfig = this.getPropertyAssignment(options, {
+            name: "extends",
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: "[]"
+        });
+        const has = extendsConfig.getElements().some((expression) => {
+            return expression.getText().includes(name);
+        });
+        if (!has) {
+            sourceFile.addImportDeclaration({
+                moduleSpecifier,
+                namedImports: [{ name: name }]
+            });
+            extendsConfig.addElement("\n" + content);
+        }
+    }
     findConfigurationDecorationOptions() {
         if (!this.serverSourceFile) {
             return;
@@ -137,26 +159,4 @@ export class ProjectClient extends Project {
         }
         return undefined;
     }
-    addConfigSource(name, { content = name, moduleSpecifier }) {
-        const sourceFile = this.configSourceFile;
-        const options = this.findConfiguration("config");
-        if (!options) {
-            return;
-        }
-        const extendsConfig = this.getPropertyAssignment(options, {
-            name: "extends",
-            kind: SyntaxKind.ArrayLiteralExpression,
-            initializer: "[]"
-        });
-        const has = extendsConfig.getElements().some((expression) => {
-            return expression.getText().includes(name);
-        });
-        if (!has) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier,
-                namedImports: [{ name: name }]
-            });
-            extendsConfig.addElement("\n" + content);
-        }
-    }
 }

package/lib/esm/services/mappers/addContextMethods.js

@@ -0,0 +1,17 @@
+import { inject } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { pascalCase } from "change-case";
+import { RoutePipe } from "../../pipes/RoutePipe.js";
+import { CliProjectService } from "../CliProjectService.js";
+export function addContextMethods(context) {
+    const getName = (state) => context.name || pascalCase(state.name || context.name || state.type || context.type || "");
+    return {
+        getName,
+        getRoute: (state) => {
+            return inject(RoutePipe).transform(isString(state) ? state : getName(state));
+        },
+        getDirectories: (dir) => {
+            return inject(CliProjectService).getDirectories(dir);
+        }
+    };
+}

package/lib/esm/services/mappers/mapDefaultTemplateOptions.js

@@ -1,8 +1,13 @@
 import { inject, ProjectPackageJson } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
 import { normalizePath } from "@tsed/normalize-path";
+import { pascalCase } from "change-case";
 import { ProjectConvention } from "../../interfaces/ProjectConvention.js";
 import { OutputFilePathPipe } from "../../pipes/OutputFilePathPipe.js";
+import { RoutePipe } from "../../pipes/RoutePipe.js";
 import { SymbolNamePipe } from "../../pipes/SymbolNamePipe.js";
+import { CliProjectService } from "../CliProjectService.js";
+import { addContextMethods } from "./addContextMethods.js";
 export function mapDefaultTemplateOptions(opts) {
     const classNamePipe = inject(SymbolNamePipe);
     const outputFilePathPipe = inject(OutputFilePathPipe);
@@ -25,6 +30,7 @@ export function mapDefaultTemplateOptions(opts) {
         type,
         symbolName,
         symbolPath,
-        symbolPathBasename: opts.symbolPathBasename || normalizePath(classNamePipe.transform({ name, type }))
+        symbolPathBasename: opts.symbolPathBasename || normalizePath(classNamePipe.transform({ name, type })),
+        ...addContextMethods(opts)
     };
 }

package/lib/esm/templates/barrels.template.js

@@ -7,13 +7,14 @@ export default defineTemplate({
     fileName: ".barrels",
     ext: "json",
     outputDir: ".",
+    hidden: true,
     preserveCase: true,
     prompts() {
         return [];
     },
-    render(_, data) {
+    render(_, context) {
         const barrels = $alter("$alterBarrels", {
-            directory: ["./src/controllers/rest", data.swagger || (data.oidc && "./src/controllers/pages")].filter(Boolean),
+            directory: ["./src/controllers/rest", (context.swagger || context.oidc) && "./src/controllers/pages"].filter(Boolean),
             exclude: ["**/__mock__", "**/__mocks__", "**/*.spec.ts"],
             delete: true
         });

package/lib/esm/templates/controller.template.js

@@ -1,36 +1,35 @@
 import { defineTemplate } from "../utils/defineTemplate.js";
-import { RoutePipe } from "../pipes/index.js";
-import { CliProjectService } from "../services/CliProjectService.js";
-import { inject } from "@tsed/di";
 export default defineTemplate({
     id: "controller",
     label: "Controller",
     fileName: "{{symbolName}}.controller",
     outputDir: "{{srcDir}}/controllers",
-    prompts: (data) => [
-        {
-            type: "list",
-            name: "directory",
-            message: "Which directory?",
-            when(state) {
-                return !!(["controller"].includes(state.type || data.type) || data.directory);
+    prompts(context) {
+        return [
+            {
+                type: "list",
+                name: "directory",
+                message: "Which directory?",
+                when(state) {
+                    return !!(["controller"].includes(state.type || context.type) || context.directory);
+                },
+                choices: context.getDirectories("controllers")
             },
-            choices: inject(CliProjectService).getDirectories("controllers")
-        },
-        {
-            type: "input",
-            name: "route",
-            message: "Which route?",
-            when(state) {
-                return !!(["controller"].includes(state.type || data.type) || data.route);
-            },
-            default: (state) => {
-                return inject(RoutePipe).transform(data.getName(state));
+            {
+                type: "input",
+                name: "route",
+                message: "Which route?",
+                when(state) {
+                    return !!(["controller"].includes(state.type || context.type) || context.route);
+                },
+                default: (state) => {
+                    return context.getRoute(state);
+                }
             }
-        }
-    ],
-    render(symbolName, data) {
-        const route = inject(RoutePipe).transform(data.route);
+        ];
+    },
+    render(symbolName, context) {
+        const route = context.getRoute(context.route);
         return `import {Controller} from "@tsed/di";
 import {Get} from "@tsed/schema";
 

package/lib/esm/templates/decorator.template.js

@@ -4,30 +4,32 @@ export default defineTemplate({
     label: "Decorator",
     fileName: "{{symbolName}}",
     outputDir: "{{srcDir}}/decorators",
-    prompts: (data) => [
-        {
-            type: "list",
-            name: "templateType",
-            message: "What kind of decorator do you want to create?",
-            when(state) {
-                return !!(["decorator"].includes(state.type || data.type) || data.templateType);
-            },
-            choices: [
-                { name: "Class Decorator", value: "class" },
-                { name: "Generic Decorator (class, property)", value: "generic" },
-                { name: "Method Decorator", value: "method" },
-                { name: "Parameter Decorator", value: "param" },
-                { name: "Property Decorator", value: "property" },
-                { name: "Property Decorator (with @Property)", value: "prop" },
-                { name: "Parameters Decorator", value: "parameters" },
-                { name: "Endpoint Decorator", value: "endpoint" },
-                { name: "Middleware Decorator", value: "middleware" }
-            ],
-            default: "class"
-        }
-    ],
-    render(symbolName, data) {
-        const type = data.templateType || "class";
+    prompts(context) {
+        return [
+            {
+                type: "list",
+                name: "templateType",
+                message: "What kind of decorator do you want to create?",
+                when(state) {
+                    return !!(["decorator"].includes(state.type || context.type) || context.templateType);
+                },
+                choices: [
+                    { name: "Class Decorator", value: "class" },
+                    { name: "Generic Decorator (class, property)", value: "generic" },
+                    { name: "Method Decorator", value: "method" },
+                    { name: "Parameter Decorator", value: "param" },
+                    { name: "Property Decorator", value: "property" },
+                    { name: "Property Decorator (with @Property)", value: "prop" },
+                    { name: "Parameters Decorator", value: "parameters" },
+                    { name: "Endpoint Decorator", value: "endpoint" },
+                    { name: "Middleware Decorator", value: "middleware" }
+                ],
+                default: "class"
+            }
+        ];
+    },
+    render(symbolName, context) {
+        const type = context.templateType || "class";
         switch (type) {
             case "class":
                 return `

package/lib/esm/templates/docker-compose.template.js

@@ -7,7 +7,7 @@ export default defineTemplate({
     outputDir: ".",
     ext: "yml",
     preserveCase: true,
-    render(_, data) {
+    render(_, context) {
         return `services:
   server:
     build:
@@ -17,7 +17,7 @@ export default defineTemplate({
         - http_proxy
         - https_proxy
         - no_proxy
-    image: ${data.projectName}/server:latest
+    image: ${context.projectName}/server:latest
     ports:
       - "8081:8081"
 `;