@tsed/cli 6.6.3 → 7.0.0-alpha.2

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: "@tsedio/config-envs/envs"
+        });
+    }
+    if (data.config) {
+        if (data.configDotenv) {
+            project.addConfigSource("DotenvConfigSource", {
+                moduleSpecifier: "@tsedio/config-envs/dotenv"
+            });
+        }
+        else if (data.configEnvs) {
+            project.addConfigSource("EnvsConfigSource", {
+                moduleSpecifier: "@tsedio/config-envs/envs"
+            });
+        }
+        if (data.configJson) {
+            project.addConfigSource("JsonConfigSource", {
+                moduleSpecifier: "@tsedio/config-envs/json",
+                content: `withOptions(JsonConfigSource, {
+      path: "./config.json"
+    })`
+            });
+        }
+        if (data.configYaml) {
+            project.addConfigSource("YamlConfigSource", {
+                moduleSpecifier: "@tsedio/config-envs/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,96 @@
+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([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, ctx) {
+        const startTime = Date.now();
+        const obj = await this.templates.render(templateId, ctx);
+        taskOutput(`Template ${templateId} rendered in ${Date.now() - startTime}ms`);
+        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(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,68 @@
+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 (await this.fs.fileExists(fromPath)) {
+                const content = await inject(CliFs).readFile(fromPath);
+                return {
+                    templateId,
+                    content,
+                    outputPath: templateId.replace("{{srcDir}}", constant("project.srcDir", ""))
+                };
+            }
+        }
+    }
+}
+injectable(CliTemplatesService);

package/lib/esm/services/ProjectClient.js

@@ -0,0 +1,161 @@
+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;
+    }
+    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);
+        }
+    }
+}