@tsed/cli 7.3.4 → 7.5.0-rc.1

package/lib/esm/commands/build/BuildCmd.js

@@ -0,0 +1,21 @@
+import { command, inject } from "@tsed/cli-core";
+import { taskLogger } from "@tsed/cli-tasks";
+import { CliRunScript } from "../../services/CliRunScript.js";
+export class BuildCmd {
+    constructor() {
+        this.runScript = inject(CliRunScript);
+    }
+    async $exec(ctx) {
+        const command = "vite build";
+        taskLogger().info(`Run ${[command, ...ctx.rawArgs].join(" ")}`);
+        await this.runScript.run(command, ctx.rawArgs, {
+            env: process.env
+        });
+    }
+}
+command({
+    token: BuildCmd,
+    name: "build",
+    description: "Build the project",
+    allowUnknownOption: true
+});

package/lib/esm/commands/dev/DevCmd.js

@@ -0,0 +1,118 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { command, normalizePath } from "@tsed/cli-core";
+import { taskLogger } from "@tsed/cli-tasks";
+export class DevCmd {
+    async $exec(ctx) {
+        await this.runViteDev(ctx.rawArgs);
+    }
+    parseWatchValue(args) {
+        const watchArg = args.find((arg) => arg === "--watch" || arg.startsWith("--watch="));
+        if (!watchArg) {
+            return true;
+        }
+        if (watchArg === "--watch") {
+            return true;
+        }
+        return watchArg !== "--watch=false";
+    }
+    async createViteDevServer() {
+        const { createServer } = await import("vite");
+        return createServer({
+            configFile: normalizePath("vite.config.ts"),
+            server: {
+                middlewareMode: true,
+                hmr: false,
+                ws: false
+            }
+        });
+    }
+    async runViteApp() {
+        const vite = await this.createViteDevServer();
+        const shutdown = async () => {
+            await vite.close();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await vite.ssrLoadModule(`/src/index.ts?t=${Date.now()}`);
+        await new Promise(() => { });
+    }
+    async runViteController(rawArgs) {
+        const watch = this.parseWatchValue(rawArgs);
+        const vite = await this.createViteDevServer();
+        let childProcess;
+        let restarting = false;
+        let queued = false;
+        const startChild = () => {
+            const [, scriptPath] = process.argv;
+            const args = scriptPath ? [scriptPath, "dev", ...rawArgs] : ["dev", ...rawArgs];
+            childProcess = spawn(process.execPath, args, {
+                env: {
+                    ...process.env,
+                    TSED_VITE_RUN_MODE: "app"
+                },
+                stdio: "inherit"
+            });
+        };
+        const stopChild = async () => {
+            if (!childProcess || childProcess.killed) {
+                return;
+            }
+            await new Promise((resolve) => {
+                childProcess.once("exit", resolve);
+                childProcess.kill("SIGTERM");
+            });
+        };
+        const restartChild = async (reason, file = "") => {
+            if (restarting) {
+                queued = true;
+                return;
+            }
+            restarting = true;
+            const suffix = file ? `: ${file}` : "";
+            taskLogger().info(`[tsed-dev] restart (${reason})${suffix}`);
+            await stopChild();
+            startChild();
+            restarting = false;
+            if (queued) {
+                queued = false;
+                await restartChild("queued");
+            }
+        };
+        if (watch) {
+            vite.watcher.on("all", async (event, file) => {
+                if (!file || file.includes("node_modules") || file.includes(".git") || file.includes("/dist/")) {
+                    return;
+                }
+                if (["add", "change", "unlink"].includes(event)) {
+                    await restartChild(event, file);
+                }
+            });
+        }
+        vite.watcher.once("ready", () => {
+            startChild();
+        });
+        const shutdown = async () => {
+            await stopChild();
+            await vite.close();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await new Promise(() => { });
+    }
+    async runViteDev(rawArgs) {
+        if (process.env.TSED_VITE_RUN_MODE === "app") {
+            await this.runViteApp();
+            return;
+        }
+        await this.runViteController(rawArgs);
+    }
+}
+command({
+    token: DevCmd,
+    name: "dev",
+    description: "Run the project in development mode",
+    allowUnknownOption: true
+});

package/lib/esm/commands/index.js

@@ -1,4 +1,6 @@
 import { AddCmd } from "./add/AddCmd.js";
+import { BuildCmd } from "./build/BuildCmd.js";
+import { DevCmd } from "./dev/DevCmd.js";
 import { GenerateCmd } from "./generate/GenerateCmd.js";
 import { InitCmd } from "./init/InitCmd.js";
 import { InitOptionsCommand } from "./init/InitOptionsCmd.js";
@@ -6,4 +8,4 @@ import { McpCommand } from "./mcp/McpCommand.js";
 import { RunCmd } from "./run/RunCmd.js";
 import { CreateTemplateCommand } from "./template/CreateTemplateCommand.js";
 import { UpdateCmd } from "./update/UpdateCmd.js";
-export default [AddCmd, InitCmd, InitOptionsCommand, GenerateCmd, UpdateCmd, RunCmd, CreateTemplateCommand, McpCommand];
+export default [AddCmd, InitCmd, InitOptionsCommand, GenerateCmd, UpdateCmd, RunCmd, DevCmd, BuildCmd, CreateTemplateCommand, McpCommand];

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

@@ -1,6 +1,6 @@
 import * as os from "node:os";
 import { basename, join } from "node:path";
-import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, inject, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
+import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, inject, PackageManager, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
 import { tasks } from "@tsed/cli-tasks";
 import { isString } from "@tsed/core";
 import { constant } from "@tsed/di";
@@ -14,6 +14,7 @@ import { PlatformsModule } from "../../platforms/PlatformsModule.js";
 import { RuntimesModule } from "../../runtimes/RuntimesModule.js";
 import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
 import { NodeRuntime } from "../../runtimes/supports/NodeRuntime.js";
+import { ViteRuntime } from "../../runtimes/supports/ViteRuntime.js";
 import { CliProjectService } from "../../services/CliProjectService.js";
 import { anonymizePaths } from "../../services/mappers/anonymizePaths.js";
 import { FeaturesMap, FeatureType } from "./config/FeaturesPrompt.js";
@@ -46,8 +47,16 @@ export class InitCmd {
         if (initialOptions.skipPrompt) {
             return [];
         }
-        const packageManagers = this.packageManagers.list();
-        const runtimes = this.runtimes.list();
+        const forceBunRuntime = this.isLaunchedWithBunx();
+        const packageManagers = forceBunRuntime ? this.filterOnlyBun(this.packageManagers.list()) : this.packageManagers.list();
+        const runtimes = forceBunRuntime ? this.filterOnlyBun(this.runtimes.list()) : this.runtimes.list();
+        const promptOptions = forceBunRuntime
+            ? {
+                ...initialOptions,
+                runtime: "bun",
+                packageManager: PackageManager.BUN
+            }
+            : initialOptions;
         return [
             {
                 type: "input",
@@ -59,12 +68,16 @@ export class InitCmd {
                     return kebabCase(input);
                 }
             },
-            ...getFeaturesPrompt(runtimes, packageManagers.filter((o) => o !== "bun"), initialOptions)
+            ...getFeaturesPrompt(runtimes, forceBunRuntime ? packageManagers : packageManagers.filter((o) => o !== "bun"), promptOptions)
         ];
     }
     $mapContext(ctx) {
         this.resolveRootDir(ctx);
         ctx = mapToContext(ctx);
+        if (this.isLaunchedWithBunx()) {
+            ctx.runtime = "bun";
+            ctx.packageManager = "bun";
+        }
         this.runtimes.init(ctx);
         this.runtimes.list().forEach((key) => {
             ctx[key] = ctx.runtime === key;
@@ -78,6 +91,16 @@ export class InitCmd {
             srcDir: constant("project.srcDir", "src")
         };
     }
+    isLaunchedWithBunx() {
+        return Boolean(globalThis.Bun);
+    }
+    filterOnlyBun(values) {
+        const filtered = values.filter((value) => value === "bun");
+        return filtered.length ? filtered : values;
+    }
+    async writeRcFiles(ctx) {
+        await Promise.all([render(".npmrc", ctx), render(".yarnrc", ctx)]);
+    }
     preExec(ctx) {
         this.fs.ensureDirSync(this.packageJson.cwd);
         ctx.projectName && (this.packageJson.name = ctx.projectName);
@@ -91,9 +114,7 @@ export class InitCmd {
             {
                 title: "Write RC files",
                 skip: () => !ctx.premium,
-                task: () => {
-                    return Promise.all([render(".npmrc", ctx), render(".yarnrc", ctx)]);
-                }
+                task: () => this.writeRcFiles(ctx)
             },
             {
                 title: "Initialize package.json",
@@ -123,7 +144,8 @@ export class InitCmd {
             ...ctx,
             node: runtime instanceof NodeRuntime,
             bun: runtime instanceof BunRuntime,
-            compiled: runtime instanceof NodeRuntime && runtime.isCompiled()
+            vite: runtime instanceof ViteRuntime,
+            compiled: runtime.isCompiled()
         };
         return [
             {

package/lib/esm/commands/init/config/FeaturesPrompt.js

@@ -329,6 +329,10 @@ export const FeaturesMap = {
     [FeatureType.LINT_STAGED]: {
         name: "Lint on commit"
     },
+    vite: {
+        name: "Node.js + Vite",
+        checked: false
+    },
     node: {
         name: "Node.js + SWC",
         checked: true
@@ -345,17 +349,17 @@ export const FeaturesMap = {
         name: "Bun.js",
         checked: false
     },
-    yarn: {
-        name: "Yarn",
-        checked: true
+    npm: {
+        name: "NPM",
+        checked: false
     },
     yarn_berry: {
         name: "Yarn Berry",
         checked: false
     },
-    npm: {
-        name: "NPM",
-        checked: false
+    yarn: {
+        name: "Yarn",
+        checked: true
     },
     pnpm: {
         name: "PNPM",
@@ -512,7 +516,7 @@ export const FeaturesPrompt = (availableRuntimes, availablePackageManagers) => [
         message: "Choose the package manager:",
         type: "list",
         name: "packageManager",
-        when: hasValue("runtime", ["node", "babel", "swc", "webpack"]),
+        when: hasValue("runtime", ["vite", "node", "babel", "swc", "webpack"]),
         choices: availablePackageManagers
     }
 ];

package/lib/esm/commands/init/config/InitSchema.js

@@ -274,6 +274,10 @@ export const InitSchema = () => {
             .enums(availableRuntimes)
             .prompt("Choose the runtime:")
             .choices([
+            {
+                label: "Node.js + Vite",
+                value: "vite"
+            },
             {
                 label: "Node.js + SWC",
                 value: "node"

package/lib/esm/commands/init/prompts/getFeaturesPrompt.js

@@ -2,9 +2,13 @@ import { cleanObject, isFunction } from "@tsed/core";
 import { FeaturesMap, FeaturesPrompt } from "../config/FeaturesPrompt.js";
 function mapChoices(item, options) {
     return item.choices.map((choice) => {
-        const { checked } = FeaturesMap[choice];
+        const config = FeaturesMap[choice];
+        if (!config) {
+            throw new Error(`Unknown init prompt choice "${choice}" for prompt "${item.name}"`);
+        }
+        const { checked } = config;
         return cleanObject({
-            ...FeaturesMap[choice],
+            ...config,
             value: choice,
             checked: isFunction(checked) ? checked(options) : checked
         });

package/lib/esm/commands/init/utils/hasFeature.js

@@ -3,8 +3,11 @@ export function hasValue(expression, value) {
     return (ctx) => [].concat(value).includes(getValue(expression, ctx));
 }
 export function hasFeature(feature) {
-    return (ctx) => !!ctx.features.find((item) => item === feature);
+    return (ctx) => !!ctx.features?.find((item) => item === feature);
 }
 export function hasValuePremium() {
-    return (ctx) => !!ctx.features.find((item) => item.endsWith(":premium"));
+    return (ctx) => Object.entries(ctx)
+        .filter(([key]) => key.startsWith("features"))
+        .flatMap(([, value]) => [].concat(value))
+        .some((item) => typeof item === "string" && item.endsWith(":premium"));
 }

package/lib/esm/commands/mcp/schema/ProjectPreferencesSchema.js

@@ -8,8 +8,8 @@ export const ProjectPreferenceSchema = s
     packageManager: s.string().enum(PackageManager).description("Used project manager to install dependencies"),
     runtime: s
         .string()
-        .enum("node", "babel", "swc", "webpack", "bun")
-        .description("The javascript runtime used to start application (node, node + webpack, node + swc, node + babel, bun)"),
+        .enum("vite", "node", "babel", "swc", "webpack", "bun")
+        .description("The javascript runtime used to start application (node, node + webpack, node + swc, node + babel, bun, vite)"),
     platform: s.string().enum(PlatformType).description("Node.js framework used to run server (Express, Koa, Fastify)")
 })
     .optional()

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

@@ -1,6 +1,5 @@
 import { CliFs, command, inject, normalizePath, ProjectPackageJson } from "@tsed/cli-core";
 import { taskLogger } from "@tsed/cli-tasks";
-import { logger } from "@tsed/di";
 import { CliRunScript } from "../../services/CliRunScript.js";
 export class RunCmd {
     constructor() {

package/lib/esm/runtimes/RuntimesModule.js

@@ -4,6 +4,7 @@ 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 { ViteRuntime } from "./supports/ViteRuntime.js";
 import { WebpackRuntime } from "./supports/WebpackRuntime.js";
 export class RuntimesModule {
     constructor() {
@@ -41,4 +42,4 @@ export class RuntimesModule {
         };
     }
 }
-injectable(RuntimesModule).imports([NodeRuntime, BabelRuntime, WebpackRuntime, BunRuntime]);
+injectable(RuntimesModule).imports([ViteRuntime, NodeRuntime, BabelRuntime, WebpackRuntime, , BunRuntime]);

package/lib/esm/runtimes/index.js

@@ -3,4 +3,5 @@ export * from "./supports/BabelRuntime.js";
 export * from "./supports/BaseRuntime.js";
 export * from "./supports/BunRuntime.js";
 export * from "./supports/NodeRuntime.js";
+export * from "./supports/ViteRuntime.js";
 export * from "./supports/WebpackRuntime.js";

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

@@ -0,0 +1,30 @@
+import { injectable } from "@tsed/di";
+import { BaseRuntime } from "./BaseRuntime.js";
+export class ViteRuntime extends BaseRuntime {
+    constructor() {
+        super(...arguments);
+        this.name = "vite";
+        this.cmd = "node";
+        this.order = -1;
+    }
+    files() {
+        return ["vite.config.ts"];
+    }
+    compile() {
+        return "tsed build";
+    }
+    startDev() {
+        return "tsed dev";
+    }
+    startProd(args) {
+        return `node ${args}`;
+    }
+    devDependencies() {
+        return {
+            "@tsed/cli": "{{cliVersion}}",
+            typescript: "latest",
+            vite: "latest"
+        };
+    }
+}
+injectable(ViteRuntime).type("runtime");