@tsed/cli 6.6.3 → 7.0.0-alpha.10

package/lib/esm/processors/transformBinFile.js

@@ -0,0 +1,47 @@
+import { dirname, join, relative } from "node:path";
+import { normalizePath } from "@tsed/normalize-path";
+import { SyntaxKind } from "ts-morph";
+export function transformBinFile(project, data) {
+    const binSourceFile = project.binSourceFile;
+    const options = project.findConfiguration("bin");
+    if (!binSourceFile || !options) {
+        return;
+    }
+    // list all commands in the bin/commands directory
+    const files = project.fs.globSync([normalizePath(project.rootDir, "src/bin/commands/*.ts")]);
+    const commands = files
+        .map((file) => {
+        const source = project.getSourceFile(file);
+        if (!source) {
+            return undefined;
+        }
+        const command = source?.getClasses().find((cls) => {
+            return cls.getDecorators().some((decorator) => {
+                return decorator.getName() === "Command" && decorator.getArguments().length > 0;
+            });
+        });
+        return command ? { command, file: source.getFilePath() } : undefined;
+    })
+        .filter((f) => f !== undefined)
+        .map(({ file, command }) => {
+        binSourceFile.addImportDeclaration({
+            moduleSpecifier: "./" + relative(dirname(binSourceFile.getFilePath()), file).replace(".ts", ".js"),
+            namedImports: [command.getName()]
+        });
+        return command.getName();
+    })
+        .sort();
+    const list = project.getPropertyAssignment(options, {
+        name: "commands",
+        kind: SyntaxKind.ArrayLiteralExpression,
+        initializer: "[]"
+    });
+    const existingElements = list.getElements();
+    commands
+        .filter((command) => {
+        return !existingElements.some((element) => element.getText() === command);
+    })
+        .forEach((command) => {
+        list.addElement(command);
+    });
+}

package/lib/esm/processors/transformConfigFile.js

@@ -0,0 +1,105 @@
+export function transformConfigFile(project, data) {
+    if (!data.config && data.commandName === "init") {
+        project.addConfigSource("EnvsConfigSource", {
+            moduleSpecifier: "@tsed/config/envs"
+        });
+    }
+    if (data.config) {
+        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
+    })`
+            });
+        }
+    }
+}

package/lib/esm/processors/transformIndexFile.js

@@ -0,0 +1,23 @@
+import { ts } from "@ts-morph/common";
+import { pascalCase } from "change-case";
+var SyntaxKind = ts.SyntaxKind;
+export function transformIndexFile(project, data) {
+    const sourceFile = project.indexSourceFile;
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "./" + project.serverName.replace(".ts", ".js"),
+        namedImports: ["Server"]
+    });
+    const platformName = "Platform" + pascalCase(data.platform);
+    sourceFile.addImportDeclaration({
+        moduleSpecifier: "@tsed/platform-" + data.platform.toLowerCase(),
+        namedImports: [platformName]
+    });
+    sourceFile.getImportDeclaration((declaration) => declaration.getModuleSpecifierValue() === "@tsed/platform-http")?.remove();
+    sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).map((identifier) => {
+        if (identifier.getText() === "PlatformBuilder") {
+            identifier.replaceWithText(identifier.getText().replace("PlatformBuilder", platformName));
+            return identifier.rename(platformName);
+        }
+        return identifier;
+    });
+}

package/lib/esm/processors/transformServerFile.js

@@ -0,0 +1,60 @@
+import { SyntaxKind } from "ts-morph";
+import { ArchitectureConvention } from "../interfaces/index.js";
+export function transformServerFile(project, data) {
+    const isFeature = data.architecture === ArchitectureConvention.FEATURE;
+    const sourceFile = project.serverSourceFile;
+    const options = project.findConfiguration("server");
+    if (!options) {
+        return;
+    }
+    if (data.commandName === "init") {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "@tsed/platform-" + data.platform.toLowerCase()
+        });
+    }
+    if (data.swagger) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "@tsed/swagger"
+        });
+        project.getPropertyAssignment(options, {
+            name: "swagger",
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: JSON.stringify([
+                {
+                    path: "/doc",
+                    specVersion: "3.1.0"
+                }
+            ], null, 2)
+        });
+    }
+    if (data.scalar) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "@tsed/scalar"
+        });
+        project.getPropertyAssignment(options, {
+            name: "scalar",
+            kind: SyntaxKind.ArrayLiteralExpression,
+            initializer: JSON.stringify([
+                {
+                    path: "/scalar/doc",
+                    specVersion: "3.1.0"
+                }
+            ], null, 2)
+        });
+    }
+    if (data.commandName === "init") {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "./config/index.js",
+            namedImports: [{ name: "config" }]
+        });
+        project.addNamespaceImport(sourceFile, isFeature ? "./rest/index.js" : "./controllers/rest/index.js", "rest");
+        project.addMountPath(data.route || "/rest", "...Object.values(rest)");
+        if (data.swagger || data.oidc) {
+            sourceFile.addImportDeclaration({
+                moduleSpecifier: isFeature ? "./pages/index.js" : "./controllers/pages/index.js",
+                namespaceImport: "pages"
+            });
+            project.addMountPath("/", "...Object.values(pages)");
+        }
+    }
+}

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,95 @@
+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 { taskOutput } from "../fn/taskOutput.js";
+import { PlatformsModule } from "../platforms/PlatformsModule.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";
+    }
+    create() {
+        taskOutput("Create typescript project");
+        const fs = inject(CliFs);
+        this.project = new ProjectClient({
+            rootDir: this.rootDir
+        });
+        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
+            });
+        });
+    }
+    get() {
+        if (!this.project) {
+            this.create();
+        }
+        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();
+            sourceFile.formatText({
+                indentSize: 2
+            });
+            return sourceFile.save();
+        }));
+    }
+    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
+            };
+        }
+    }
+    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(CliProjectService);

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,119 @@
+import { join } from "node:path";
+import { CliFs } from "@tsed/cli-core";
+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.renderedFiles = [];
+    }
+    #customTemplates;
+    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 = 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) {
+        return this.getAll().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 this.pushRenderResult({
+                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 (await this.fs.fileExists(fromPath)) {
+                const content = await inject(CliFs).readFile(fromPath);
+                return this.pushRenderResult({
+                    templateId,
+                    content,
+                    outputPath: templateId.replace("{{srcDir}}", constant("project.srcDir", ""))
+                });
+            }
+        }
+    }
+    pushRenderResult(renderedFile) {
+        this.renderedFiles.push(renderedFile);
+        return renderedFile;
+    }
+}
+injectable(CliTemplatesService);