@tsed/cli 6.6.2 → 7.0.0-alpha.1

package/lib/esm/runtimes/RuntimesModule.js

@@ -1,17 +1,14 @@
-import { __decorate, __metadata, __param } from "tslib";
-import { PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
-import { Inject, inject, Module } from "@tsed/di";
+import { ProjectPackageJson } from "@tsed/cli-core";
+import { inject, injectable, injectMany } from "@tsed/di";
 import { BabelRuntime } from "./supports/BabelRuntime.js";
 import { BaseRuntime } from "./supports/BaseRuntime.js";
 import { BunRuntime } from "./supports/BunRuntime.js";
 import { NodeRuntime } from "./supports/NodeRuntime.js";
 import { WebpackRuntime } from "./supports/WebpackRuntime.js";
-let RuntimesModule = class RuntimesModule {
-    constructor(runtimes) {
-        this.runtimes = runtimes;
+export class RuntimesModule {
+    constructor() {
         this.projectPackageJson = inject(ProjectPackageJson);
-        this.packagesManager = inject(PackageManagersModule);
-        this.runtimes = runtimes.filter((manager) => manager.has());
+        this.runtimes = injectMany("runtime").filter((manager) => manager.has());
     }
     init(ctx) {
         ctx.runtime = ctx.runtime || this.get().name;
@@ -43,12 +40,5 @@ let RuntimesModule = class RuntimesModule {
             "start:prod": `cross-env NODE_ENV=production ${runtime.startProd("dist/index.js")}`
         };
     }
-};
-RuntimesModule = __decorate([
-    Module({
-        imports: [NodeRuntime, BabelRuntime, WebpackRuntime, BunRuntime]
-    }),
-    __param(0, Inject("runtime")),
-    __metadata("design:paramtypes", [Array])
-], RuntimesModule);
-export { RuntimesModule };
+}
+injectable(RuntimesModule).imports([NodeRuntime, BabelRuntime, WebpackRuntime, BunRuntime]);

package/lib/esm/runtimes/supports/BabelRuntime.js

@@ -1,8 +1,7 @@
-import { __decorate } from "tslib";
 import { dirname } from "node:path";
-import { Injectable } from "@tsed/di";
+import { injectable } from "@tsed/di";
 import { NodeRuntime } from "./NodeRuntime.js";
-let BabelRuntime = class BabelRuntime extends NodeRuntime {
+export class BabelRuntime extends NodeRuntime {
     constructor() {
         super(...arguments);
         this.name = "babel";
@@ -12,7 +11,7 @@ let BabelRuntime = class BabelRuntime extends NodeRuntime {
         return false;
     }
     files() {
-        return ["/init/.babelrc.hbs"];
+        return [".babelrc"];
     }
     startDev(main) {
         return `babel-watch --extensions .ts ${main}`;
@@ -38,10 +37,5 @@ let BabelRuntime = class BabelRuntime extends NodeRuntime {
             typescript: "latest"
         };
     }
-};
-BabelRuntime = __decorate([
-    Injectable({
-        type: "runtime"
-    })
-], BabelRuntime);
-export { BabelRuntime };
+}
+injectable(BabelRuntime).type("runtime");

package/lib/esm/runtimes/supports/BunRuntime.js

@@ -1,7 +1,6 @@
-import { __decorate } from "tslib";
-import { Injectable } from "@tsed/di";
+import { injectable } from "@tsed/di";
 import { BaseRuntime } from "./BaseRuntime.js";
-let BunRuntime = class BunRuntime extends BaseRuntime {
+export class BunRuntime extends BaseRuntime {
     constructor() {
         super(...arguments);
         this.name = "bun";
@@ -22,10 +21,5 @@ let BunRuntime = class BunRuntime extends BaseRuntime {
             typescript: "latest"
         };
     }
-};
-BunRuntime = __decorate([
-    Injectable({
-        type: "runtime"
-    })
-], BunRuntime);
-export { BunRuntime };
+}
+injectable(BunRuntime).type("runtime");

package/lib/esm/runtimes/supports/NodeRuntime.js

@@ -9,7 +9,7 @@ let NodeRuntime = class NodeRuntime extends BaseRuntime {
         this.order = 0;
     }
     files() {
-        return ["/init/.swcrc.hbs", "/init/nodemon.json.hbs"];
+        return [".swcrc", "nodemon.json"];
     }
     startDev(main) {
         return `nodemon ${main}`;

package/lib/esm/runtimes/supports/WebpackRuntime.js

@@ -12,7 +12,7 @@ let WebpackRuntime = class WebpackRuntime extends BabelRuntime {
         return true;
     }
     files() {
-        return [...super.files(), "/init/webpack.config.js.hbs"];
+        return [...super.files(), "webpack.config.js"];
     }
     compile(src, out) {
         return "tsc && cross-env NODE_ENV=production webpack";

package/lib/esm/services/CliProjectService.js

@@ -0,0 +1,91 @@
+import { dirname, join, relative } from "node:path";
+import { CliFs, inject } from "@tsed/cli-core";
+import { constant, injectable } from "@tsed/di";
+import { $asyncAlter } from "@tsed/hooks";
+import { normalizePath } from "@tsed/normalize-path";
+import { globbySync } from "globby";
+import { PlatformsModule } from "../platforms/PlatformsModule.js";
+import { InitExpressPlatform } from "../platforms/supports/InitExpressPlatform.js";
+import { InitFastifyPlatform } from "../platforms/supports/InitFastifyPlatform.js";
+import { InitKoaPlatform } from "../platforms/supports/InitKoaPlatform.js";
+import { transformBinFile } from "../processors/transformBinFile.js";
+import { transformConfigFile } from "../processors/transformConfigFile.js";
+import { transformIndexFile } from "../processors/transformIndexFile.js";
+import { transformServerFile } from "../processors/transformServerFile.js";
+import { ProjectClient } from "../services/ProjectClient.js";
+import { CliTemplatesService } from "./CliTemplatesService.js";
+export class CliProjectService {
+    constructor() {
+        this.templates = inject(CliTemplatesService);
+        this.rootDir = constant("project.rootDir", process.cwd());
+    }
+    get srcDir() {
+        return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
+    }
+    getRelativePath(path) {
+        return normalizePath(relative(dirname(join(this.srcDir, path)), this.rootDir));
+    }
+    getServerFileName() {
+        return this.get().getSource("Server.ts") ? "Server" : "server";
+    }
+    get() {
+        if (this.project) {
+            return this.project;
+        }
+        const fs = inject(CliFs);
+        this.project = new ProjectClient({
+            // tsConfigFilePath: join(this.rootDir, "tsconfig.json"),
+            rootDir: this.rootDir
+        });
+        const files = fs.globSync([join(constant("project.rootDir", process.cwd()), "**/*.ts")]);
+        files.forEach((file) => {
+            this.project.createSourceFile(file, fs.readFileSync(file, "utf8"), {
+                overwrite: true
+            });
+        });
+        return this.project;
+    }
+    async transformFiles(data) {
+        const project = this.get();
+        if (data.commandName === "init") {
+            transformIndexFile(project, data);
+        }
+        transformServerFile(project, data);
+        transformConfigFile(project, data);
+        transformBinFile(project, data);
+        if (data.platform) {
+            const platform = inject(PlatformsModule).get(data.platform);
+            platform.alterProjectFiles(project, data);
+        }
+        await $asyncAlter(`$alterProjectFiles`, project, [data]);
+        await Promise.all(project.getSourceFiles().map((sourceFile) => {
+            sourceFile.organizeImports();
+            return sourceFile.save();
+        }));
+    }
+    async createFromTemplate(templateId, ctx) {
+        const obj = await this.templates.render(templateId, ctx);
+        const project = this.get();
+        if (obj) {
+            const sourceFile = await project.createSource(obj.outputPath, obj.content, {
+                overwrite: true
+            });
+            return {
+                ...obj,
+                source: sourceFile
+            };
+        }
+    }
+    getDirectories(dir) {
+        const directories = globbySync("**/*", {
+            cwd: join(this.srcDir, dir),
+            ignore: ["__*"]
+        });
+        const set = new Set(directories.map((dir) => {
+            return dirname(dir);
+        }));
+        set.delete(".");
+        return [...set];
+    }
+}
+injectable(PlatformsModule).imports([InitExpressPlatform, InitKoaPlatform, InitFastifyPlatform]);

package/lib/esm/services/CliRunScript.js

@@ -1,7 +1,6 @@
-import { __decorate } from "tslib";
 import { ProjectPackageJson } from "@tsed/cli-core";
-import { inject, Injectable } from "@tsed/di";
-let CliRunScript = class CliRunScript {
+import { inject, injectable } from "@tsed/di";
+export class CliRunScript {
     async run(cmd, args, options = {}) {
         // @ts-ignore
         const mod = await import("@npmcli/run-script");
@@ -15,8 +14,5 @@ let CliRunScript = class CliRunScript {
             banner: false
         });
     }
-};
-CliRunScript = __decorate([
-    Injectable()
-], CliRunScript);
-export { CliRunScript };
+}
+injectable(CliRunScript);

package/lib/esm/services/CliTemplatesService.js

@@ -0,0 +1,67 @@
+import { join } from "node:path";
+import { CliFs } from "@tsed/cli-core";
+import { constant, inject, injectable, injectMany } from "@tsed/di";
+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);
+    }
+    get srcDir() {
+        return join(...[this.rootDir, constant("project.srcDir")].filter(Boolean));
+    }
+    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;
+    }
+    get(id) {
+        const templates = injectMany("CLI_TEMPLATES");
+        return templates.find((template) => template.id === id);
+    }
+    async render(templateId, data) {
+        const template = this.get(templateId);
+        if (template) {
+            const opts = mapDefaultTemplateOptions({
+                ...data,
+                type: templateId
+            });
+            const render = await template.render(opts.symbolName, opts);
+            if (render === undefined) {
+                return;
+            }
+            if (typeof render === "object") {
+                return render;
+            }
+            const filePath = opts.symbolPath ||
+                template.fileName?.replace("{{symbolName}}", opts.symbolName)?.replace("{{srcDir}}", this.srcDir) ||
+                opts.symbolName;
+            const outputPath = `${filePath}${template.ext ? "." + template.ext : ""}`;
+            return {
+                templateId,
+                content: render,
+                outputPath,
+                name: opts.name,
+                symbolName: opts.symbolName,
+                symbolPath: opts.symbolPath,
+                symbolPathBasename: opts.symbolPathBasename
+            };
+        }
+        else {
+            const from = data.from || TEMPLATE_DIR;
+            const fromPath = join(from, templateId.replace("{{srcDir}}", "src"));
+            if (this.fs.fileExistsSync(fromPath)) {
+                return {
+                    templateId,
+                    content: await inject(CliFs).readFile(fromPath),
+                    outputPath: templateId.replace("{{srcDir}}", constant("project.srcDir", ""))
+                };
+            }
+        }
+    }
+}
+injectable(CliTemplatesService);

package/lib/esm/services/ProjectClient.js

@@ -0,0 +1,139 @@
+import { join } from "node:path";
+import { CliDockerComposeYaml, CliFs, ProjectPackageJson } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { constant, inject } from "@tsed/di";
+import { ObjectLiteralExpression, Project, SyntaxKind } from "ts-morph";
+import { OutputFilePathPipe } from "../pipes/OutputFilePathPipe.js";
+export class ProjectClient extends Project {
+    constructor({ rootDir, ...options }) {
+        super({
+            fileSystem: inject(CliFs),
+            ...options
+        });
+        this.pkg = inject(ProjectPackageJson);
+        this.fs = inject(CliFs);
+        this.dockerCompose = inject(CliDockerComposeYaml);
+        this.rootDir = rootDir;
+    }
+    get srcDir() {
+        return constant("project.srcDir", "/src");
+    }
+    get serverSourceFile() {
+        return this.getSource(join(this.srcDir, this.serverName));
+    }
+    get configSourceFile() {
+        return this.getSource(join(this.srcDir, `config/config.ts`));
+    }
+    get indexSourceFile() {
+        return this.getSource(join(this.srcDir, "index.ts"));
+    }
+    get binSourceFile() {
+        return this.getSource(join(this.srcDir, "bin/index.ts"));
+    }
+    get serverName() {
+        return inject(OutputFilePathPipe).getServerName();
+    }
+    getSource(path) {
+        const resolved = join(this.rootDir, path.replace("{{srcDir}}", this.srcDir));
+        return this.getSourceFile(resolved);
+    }
+    async createSource(path, sourceFileText, options) {
+        path = join(this.rootDir, path);
+        if (path.endsWith(".ts") || path.endsWith(".mts")) {
+            const source = this.createSourceFile(path, sourceFileText, options);
+            source.organizeImports();
+            await source.save();
+            return source;
+        }
+        await this.fs.writeFile(path, sourceFileText, { encoding: "utf-8" });
+    }
+    findClassDecorator(sourceFile, name) {
+        return sourceFile
+            .getClasses()
+            .flatMap((cls) => cls.getDecorators())
+            .find((decorator) => decorator.getName() === name);
+    }
+    addMountPath(path, specifier) {
+        if (!this.serverSourceFile) {
+            return;
+        }
+        const options = this.findConfigurationDecorationOptions();
+        if (!options) {
+            return;
+        }
+        let mount = this.getPropertyAssignment(options, {
+            name: "mount",
+            kind: SyntaxKind.ObjectLiteralExpression,
+            initializer: "{}"
+        });
+        const escape = '"' + ((path || "").startsWith("/") ? path : "/" + path) + '"';
+        const property = this.getPropertyAssignment(mount, {
+            name: escape,
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: "[]"
+        });
+        if (isString(specifier)) {
+            property.addElement(specifier);
+        }
+        options.formatText({
+            indentSize: 2
+        });
+    }
+    addNamespaceImport(sourceFile, moduleSpecifier, name) {
+        return sourceFile
+            .addImportDeclaration({
+            moduleSpecifier,
+            namespaceImport: name
+        })
+            .getNamespaceImport();
+    }
+    findConfiguration(kind) {
+        switch (kind) {
+            case "server":
+                return this.findConfigurationDecorationOptions();
+            case "config":
+                return this.findConfigConfiguration();
+            case "bin":
+                return this.findBinConfiguration();
+            default:
+                throw new Error(`Unknown configuration kind: ${kind}`);
+        }
+    }
+    getPropertyAssignment(input, { name, initializer, kind }) {
+        const assigment = input.getProperty(name)?.getChildAtIndex(2).asKind(kind);
+        if (!initializer) {
+            return assigment;
+        }
+        return (assigment ||
+            input
+                .addPropertyAssignment({
+                name,
+                initializer
+            })
+                .getInitializerIfKindOrThrow(kind));
+    }
+    findConfigurationDecorationOptions() {
+        if (!this.serverSourceFile) {
+            return;
+        }
+        return this.findClassDecorator(this.serverSourceFile, "Configuration")?.getArguments().at(0);
+    }
+    findConfigConfiguration() {
+        const sourceFile = this.configSourceFile;
+        if (!sourceFile) {
+            return;
+        }
+        return sourceFile.getVariableDeclaration("config")?.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+    findBinConfiguration() {
+        if (!this.binSourceFile) {
+            return;
+        }
+        for (const child of this.binSourceFile.getStatements()) {
+            if (child.getKind() === SyntaxKind.ExpressionStatement && child.getText().includes("CliCore.bootstrap")) {
+                return child.getFirstDescendantByKind(SyntaxKind.ObjectLiteralExpression);
+            }
+        }
+        return undefined;
+    }
+}

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

@@ -0,0 +1,30 @@
+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 mapDefaultTemplateOptions(opts) {
+    const classNamePipe = inject(SymbolNamePipe);
+    const outputFilePathPipe = inject(OutputFilePathPipe);
+    const projectPackageJson = inject(ProjectPackageJson);
+    const { name = "" } = opts;
+    let { type = "" } = opts;
+    type = type.toLowerCase();
+    if (opts.name === "prisma" && opts.name) {
+        type = "prisma.service";
+    }
+    const symbolName = opts.symbolName || classNamePipe.transform({ name, type, format: ProjectConvention.DEFAULT });
+    const symbolPath = opts.symbolPath ||
+        normalizePath(outputFilePathPipe.transform({
+            name,
+            type,
+            subDir: opts.directory
+        }));
+    return {
+        ...projectPackageJson.fillWithPreferences(opts),
+        type,
+        symbolName,
+        symbolPath,
+        symbolPathBasename: opts.symbolPathBasename || normalizePath(classNamePipe.transform({ name, type }))
+    };
+}

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

@@ -0,0 +1,38 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { camelCase, pascalCase } from "change-case";
+export default defineTemplate({
+    id: "async.factory",
+    label: "Async Factory",
+    fileName: "{{symbolName}}.factory?",
+    outputDir: "{{srcDir}}/services",
+    render(symbolName) {
+        const camelName = camelCase(symbolName);
+        const optName = pascalCase(symbolName + "Options");
+        return `import {injectable} from "@tsed/di";
+
+interface ${optName} {
+  
+}
+    
+declare global {
+  namespace TsED {
+    interface Configuration extends Record<string, any> {
+      ${camelName}: Options;
+    }
+  }
+}    
+
+export const ${symbolName} = injectable(Symbol.for("${symbolName}"))
+  .factory(async () => {
+    const myConstant = constant<${optName}>("${camelName}");
+    
+    // do something async
+    await Promise.resolve();
+    
+    return {};
+  })
+  .token();
+  
+export type {{symbolName}} = typeof ${symbolName};`;
+    }
+});

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

@@ -0,0 +1,22 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { $alter } from "@tsed/hooks";
+export default defineTemplate({
+    id: "barrels",
+    label: "Barrels",
+    description: "Create barrels files (index.ts) to simplify imports.",
+    fileName: ".barrels",
+    ext: "json",
+    outputDir: ".",
+    preserveCase: true,
+    prompts() {
+        return [];
+    },
+    render(_, data) {
+        const barrels = $alter("$alterBarrels", {
+            directory: ["./src/controllers/rest", data.swagger || (data.oidc && "./src/controllers/pages")].filter(Boolean),
+            exclude: ["**/__mock__", "**/__mocks__", "**/*.spec.ts"],
+            delete: true
+        });
+        return JSON.stringify(barrels, null, 2);
+    }
+});

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

@@ -0,0 +1,56 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+import { kebabCase } from "change-case";
+export default defineTemplate({
+    id: "command",
+    label: "Command",
+    fileName: "{{symbolName}}.command",
+    outputDir: "{{srcDir}}/bin/commands",
+    render(symbolName) {
+        const symbolParamName = kebabCase(symbolName);
+        return `import {Command, CommandProvider, QuestionOptions} from "@tsed/cli-core";
+
+export interface ${symbolName}Context {
+}
+
+@Command({
+  name: "${symbolParamName}",
+  description: "Command description",
+  args: {
+  },
+  options: {
+  },
+  allowUnknownOption: false
+})
+export class ${symbolName} implements CommandProvider {
+  /**
+   *  Ask questions with Inquirer. Return an empty array or don't implement the method to skip this step
+   */
+  async $prompt(initialOptions: Partial<${symbolName}Context>): Promise<QuestionOptions> {
+    return [];
+  }
+
+  /**
+   * This method is called after the $prompt to create / map inputs to a proper context for the next step
+   */
+  $mapContext(ctx: Partial<${symbolName}Context>): ${symbolName}Context {
+    return {
+      ...ctx
+      // map something, based on ctx
+    };
+  }
+  /**
+   *  This step run your tasks with Listr module
+   */
+  async $exec(ctx: ${symbolName}Context): Promise<any> {
+    return [
+      {
+        title: "Do something",
+        task: () => {
+          console.log('HELLO')
+        }
+      }
+    ];
+  }
+}`;
+    }
+});

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

@@ -0,0 +1,27 @@
+import { defineTemplate } from "../utils/defineTemplate.js";
+export default defineTemplate({
+    id: "config",
+    label: "Config",
+    description: "Create a new config file",
+    outputDir: "{{srcDir}}/config",
+    fileName: "config",
+    hidden: true,
+    preserveCase: true,
+    render() {
+        return `import {readFileSync} from "node:fs";
+import loggerConfig from "./logger/index.js";
+
+const pkg = JSON.parse(readFileSync("./package.json", {encoding: "utf8"}));
+/**
+ * This is the shared configuration for the application
+ */
+export const config: Partial<TsED.Configuration> = {
+  version: pkg.version,
+  ajv: {
+    returnsCoercedValues: true
+  },
+  logger: loggerConfig
+};
+`;
+    }
+});

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

@@ -0,0 +1,45 @@
+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);
+            },
+            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));
+            }
+        }
+    ],
+    render(symbolName, data) {
+        const route = inject(RoutePipe).transform(data.route);
+        return `import {Controller} from "@tsed/di";
+import {Get} from "@tsed/schema";
+
+@Controller("${route}")
+export class ${symbolName} {
+  @Get("/")
+  get() {
+    return "hello";
+  }
+}`;
+    }
+});