@tsed/cli 6.2.0-beta.1 → 6.2.0-beta.2

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

@@ -1,7 +1,7 @@
 var GenerateCmd_1;
 import { __decorate, __metadata } from "tslib";
 import { basename, dirname, join } from "node:path";
-import { Command, Inject, ProjectPackageJson, SrcRendererService } from "@tsed/cli-core";
+import { Command, Inject, inject, ProjectPackageJson } from "@tsed/cli-core";
 import { normalizePath } from "@tsed/normalize-path";
 import { kebabCase, pascalCase } from "change-case";
 import { globbySync } from "globby";
@@ -10,6 +10,7 @@ import { ClassNamePipe } from "../../pipes/ClassNamePipe.js";
 import { OutputFilePathPipe } from "../../pipes/OutputFilePathPipe.js";
 import { RoutePipe } from "../../pipes/RoutePipe.js";
 import { ProvidersInfoService } from "../../services/ProvidersInfoService.js";
+import { SrcRendererService } from "../../services/Renderer.js";
 import { fillImports } from "../../utils/fillImports.js";
 import { getFrameworksPrompt } from "../init/prompts/getFeaturesPrompt.js";
 import { PROVIDER_TYPES } from "./ProviderTypes.js";
@@ -35,6 +36,8 @@ const searchFactory = (list) => {
 let GenerateCmd = GenerateCmd_1 = class GenerateCmd {
     constructor(providersList) {
         this.providersList = providersList;
+        this.srcRenderService = inject(SrcRendererService);
+        this.projectPackageJson = inject(ProjectPackageJson);
         PROVIDER_TYPES.forEach((info) => {
             this.providersList.add({
                 ...info
@@ -208,14 +211,6 @@ __decorate([
     Inject(),
     __metadata("design:type", RoutePipe)
 ], GenerateCmd.prototype, "routePipe", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", SrcRendererService)
-], GenerateCmd.prototype, "srcRenderService", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], GenerateCmd.prototype, "projectPackageJson", void 0);
 GenerateCmd = GenerateCmd_1 = __decorate([
     Command({
         name: "generate",

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

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
 import { basename, join } from "node:path";
-import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, CliService, Command, Configuration, createSubTasks, createTasksRunner, inject, PackageManager, PackageManagersModule, ProjectPackageJson, RootRendererService } from "@tsed/cli-core";
+import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, CliService, Command, Configuration, createSubTasks, createTasksRunner, inject, PackageManager, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
 import { kebabCase, pascalCase } from "change-case";
 import { DEFAULT_TSED_TAGS } from "../../constants/index.js";
 import { ArchitectureConvention } from "../../interfaces/ArchitectureConvention.js";
@@ -11,6 +11,7 @@ import { InitPlatformsModule } from "../../platforms/InitPlatformsModule.js";
 import { RuntimesModule } from "../../runtimes/RuntimesModule.js";
 import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
 import { NodeRuntime } from "../../runtimes/supports/NodeRuntime.js";
+import { RootRendererService } from "../../services/Renderer.js";
 import { fillImports } from "../../utils/fillImports.js";
 import { FeaturesMap, FeatureType } from "./config/FeaturesPrompt.js";
 import { InitFileSchema } from "./config/InitFileSchema.js";

package/lib/esm/commands/run/RunCmd.js

@@ -1,6 +1,6 @@
 import { __decorate } from "tslib";
-import { CliFs, CliRunScript, Command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
-import { Inject } from "@tsed/di";
+import { CliFs, Command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
+import { CliRunScript } from "../../services/CliRunScript.js";
 let RunCmd = class RunCmd {
     constructor() {
         this.fs = inject(CliFs);
@@ -9,7 +9,7 @@ let RunCmd = class RunCmd {
     }
     async $exec(ctx) {
         const cmd = "node";
-        const args = ["--import", "@swc-node/register/register-esm"];
+        const args = ["--import", "@swc-node/register/esm-register"];
         const path = normalizePath("src/bin/index.ts");
         await this.runScript.run(cmd, [...args, path, ctx.command, ...ctx.rawArgs], {
             env: process.env

package/lib/esm/index.js

@@ -13,3 +13,4 @@ export * from "./interfaces/index.js";
 export * from "./pipes/index.js";
 export * from "./runtimes/index.js";
 export * from "./services/ProvidersInfoService.js";
+export * from "./services/Renderer.js";

package/lib/esm/services/CliRunScript.js

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { ProjectPackageJson } from "@tsed/cli-core";
+import { inject, Injectable } from "@tsed/di";
+let CliRunScript = class CliRunScript {
+    async run(cmd, args, options = {}) {
+        // @ts-ignore
+        const mod = await import("@npmcli/run-script");
+        return (mod.default || mod)({
+            event: "run",
+            ...options,
+            cmd: `${cmd} ${args.join(" ")}`,
+            path: options.cwd || inject(ProjectPackageJson).dir,
+            env: options.env || {},
+            stdio: options.stdio || "inherit",
+            banner: false
+        });
+    }
+};
+CliRunScript = __decorate([
+    Injectable()
+], CliRunScript);
+export { CliRunScript };

package/lib/esm/services/Renderer.js

@@ -0,0 +1,162 @@
+import { __decorate } from "tslib";
+import "../utils/hbs/index.js";
+import { basename, dirname, join, relative } from "node:path";
+import { CliFs } from "@tsed/cli-core";
+import { isString } from "@tsed/core";
+import { constant, inject, Injectable } from "@tsed/di";
+import { normalizePath } from "@tsed/normalize-path";
+import Consolidate from "consolidate";
+import fs from "fs-extra";
+import { globby } from "globby";
+import handlebars from "handlebars";
+import { Observable } from "rxjs";
+import { insertAfter } from "../utils/renderer/insertAfter.js";
+import { insertImport } from "../utils/renderer/insertImport.js";
+export class Renderer {
+    constructor() {
+        this.templateDir = constant("templateDir", "");
+        this.fs = inject(CliFs);
+        this.cache = new Set();
+    }
+    async loadPartials(cwd) {
+        if (this.cache.has(cwd)) {
+            return;
+        }
+        const files = await globby("**/_partials/*.hbs", {
+            cwd
+        });
+        files.forEach((filename) => {
+            let template = this.fs.readFileSync(join(cwd, filename), "utf8");
+            const name = basename(filename).replace(".hbs", "");
+            handlebars.registerPartial(name, template);
+        });
+        this.cache.add(cwd);
+    }
+    async render(path, data, options = {}) {
+        const { output, templateDir, rootDir } = this.mapOptions(path, options);
+        let content = "";
+        const file = normalizePath(join(templateDir, path));
+        options.baseDir && (await this.loadPartials(join(templateDir, options.baseDir)));
+        if (path.endsWith(".hbs")) {
+            content = await Consolidate.handlebars(file, data);
+        }
+        else {
+            content = await this.fs.readFile(file, { encoding: "utf8" });
+        }
+        return this.write(content, { output, rootDir });
+    }
+    renderAll(paths, data, options = {}) {
+        let count = 0;
+        const mapOptions = (opts) => {
+            if (isString(opts)) {
+                return { ...options, path: opts };
+            }
+            return {
+                ...options,
+                ...opts
+            };
+        };
+        return new Observable((observer) => {
+            observer.next(`[${count}/${paths.length}] Rendering files...`);
+            const promises = paths
+                .filter(Boolean)
+                .map(mapOptions)
+                .map(async ({ path, ...opts }) => {
+                await this.render(path, data, opts);
+                count++;
+                observer.next(`[${count}/${paths.length}] Rendering files...`);
+            });
+            Promise.all(promises)
+                .then(() => {
+                observer.next(`[${count}/${paths.length}] Rendering files...`);
+                observer.complete();
+            })
+                .catch((err) => {
+                observer.error(err);
+            });
+        });
+    }
+    async write(content, options) {
+        const { output, rootDir = this.rootDir } = options;
+        const outputFile = join(...[rootDir, output].filter(Boolean));
+        await this.fs.ensureDir(dirname(outputFile));
+        return this.fs.writeFile(outputFile, content, { encoding: "utf8" });
+    }
+    templateExists(path, options = {}) {
+        const { templateDir } = this.mapOptions(path, options);
+        return fs.existsSync(join(templateDir, path));
+    }
+    async scan(pattern, options = {}) {
+        const result = await globby(pattern.map((s) => normalizePath(s)), {
+            ...options,
+            objectMode: true,
+            cwd: this.rootDir
+        });
+        return result.map((entry) => entry.path);
+    }
+    relativeFrom(path) {
+        return relative(dirname(join(this.rootDir, path)), this.rootDir);
+    }
+    async update(path, actions) {
+        path = join(this.rootDir, path);
+        if (!this.fs.exists(path)) {
+            return;
+        }
+        const content = actions.reduce((fileContent, action) => {
+            switch (action.type) {
+                case "import":
+                    return insertImport(fileContent, action.content);
+                case "insert-after":
+                    return insertAfter(fileContent, action.content, action.pattern);
+                default:
+                    break;
+            }
+            return fileContent;
+        }, await this.fs.readFile(path, { encoding: "utf8" }));
+        return this.fs.writeFile(path, content, { encoding: "utf8" });
+    }
+    mapOptions(path, options) {
+        const { templateDir = this.templateDir, rootDir = this.rootDir } = options;
+        let { output = path } = options;
+        if (options.baseDir) {
+            output = normalizePath(join("/", relative(options.baseDir, path)));
+        }
+        if (options.basename) {
+            output = normalizePath(join(dirname(output), options.basename));
+        }
+        output = output.replace(/\.hbs$/, "");
+        if (options.replaces) {
+            options.replaces.filter(Boolean).forEach((replace) => {
+                output = output.replace(replace, "");
+            });
+        }
+        return { output, templateDir, rootDir };
+    }
+}
+let RootRendererService = class RootRendererService extends Renderer {
+    get rootDir() {
+        return constant("project.rootDir", "");
+    }
+};
+RootRendererService = __decorate([
+    Injectable()
+], RootRendererService);
+export { RootRendererService };
+let SrcRendererService = class SrcRendererService extends Renderer {
+    get rootDir() {
+        return join(...[constant("project.rootDir"), constant("project.srcDir")].filter(Boolean));
+    }
+};
+SrcRendererService = __decorate([
+    Injectable()
+], SrcRendererService);
+export { SrcRendererService };
+let ScriptsRendererService = class ScriptsRendererService extends Renderer {
+    get rootDir() {
+        return join(...[constant("project.rootDir"), constant("project.scriptsDir")].filter(Boolean));
+    }
+};
+ScriptsRendererService = __decorate([
+    Injectable()
+], ScriptsRendererService);
+export { ScriptsRendererService };