@tsed/cli 7.4.0 → 7.5.0-rc.2

package/lib/esm/bin/boot.js

@@ -0,0 +1,42 @@
+import { register } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+const EXT = process.env.CLI_MODE === "ts" ? "ts" : "js";
+register(pathToFileURL(join(import.meta.dirname, `../loaders/alias.hook.${EXT}`)), {
+    parentURL: import.meta.dirname,
+    data: {
+        "@tsed/core": import.meta.resolve("@tsed/core"),
+        "@tsed/di": import.meta.resolve("@tsed/di"),
+        "@tsed/schema": import.meta.resolve("@tsed/schema"),
+        "@tsed/cli-core": import.meta.resolve("@tsed/cli-core"),
+        "@tsed/cli": import.meta.resolve("@tsed/cli")
+    },
+    transferList: []
+});
+const { tools, commands, resources, CliCore, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
+CliCore.bootstrap({
+    name: "tsed",
+    pkg: PKG,
+    templateDir: TEMPLATE_DIR,
+    plugins: true,
+    updateNotifier: true,
+    checkPrecondition: true,
+    commands,
+    tools,
+    resources,
+    defaultProjectPreferences() {
+        return {
+            convention: ProjectConvention.DEFAULT,
+            architecture: ArchitectureConvention.DEFAULT
+        };
+    },
+    project: {
+        reinstallAfterRun: true
+    },
+    logger: {
+        level: "info"
+    }
+}).catch((error) => {
+    console.error(error);
+    process.exit(-1);
+});

package/lib/esm/bin/tsed-build.js

@@ -0,0 +1,23 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+function runNode(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            env: process.env,
+            stdio: "inherit"
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`vite build exited with code ${code}`));
+        });
+    });
+}
+export async function build(rawArgs = process.argv.slice(2)) {
+    const viteBin = fileURLToPath(import.meta.resolve("vite/bin/vite.js"));
+    await runNode(process.execPath, [viteBin, "build", ...rawArgs]);
+}

package/lib/esm/bin/tsed-dev.js

@@ -0,0 +1,130 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "@tsed/cli-core";
+import { logger } from "@tsed/di";
+const RUN_MODE = "TSED_VITE_RUN_MODE";
+function parseWatchValue(args) {
+    if (args.includes("--no-watch")) {
+        return false;
+    }
+    const watchIndex = args.findIndex((arg) => arg === "--watch" || arg.startsWith("--watch="));
+    if (watchIndex === -1) {
+        return true;
+    }
+    const watchArg = args[watchIndex];
+    if (watchArg === "--watch") {
+        const nextValue = args[watchIndex + 1];
+        if (!nextValue || nextValue.startsWith("-")) {
+            return true;
+        }
+        return nextValue !== "false";
+    }
+    if (watchArg === "--watch=false") {
+        return false;
+    }
+    if (watchArg === "--watch=true") {
+        return true;
+    }
+    return true;
+}
+function assertViteProject() {
+    const configFile = normalizePath("vite.config.ts");
+    if (!existsSync(configFile)) {
+        throw new Error("tsed dev is only available for ViteRuntime projects. Missing vite.config.ts in the current directory.");
+    }
+}
+async function createViteDevServer() {
+    // @ts-ignore
+    const { createServer } = await import("vite");
+    return createServer({
+        configFile: normalizePath("vite.config.ts"),
+        server: {
+            middlewareMode: true,
+            hmr: false,
+            ws: false
+        }
+    });
+}
+async function runViteApp() {
+    const vite = await createViteDevServer();
+    const shutdown = async () => {
+        await vite.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await vite.ssrLoadModule("/src/index.ts");
+    await new Promise(() => { });
+}
+async function runViteController(rawArgs) {
+    const runnerFile = fileURLToPath(import.meta.url);
+    const watch = parseWatchValue(rawArgs);
+    const vite = await createViteDevServer();
+    let childProcess;
+    let restarting = false;
+    let queued = false;
+    const startChild = () => {
+        childProcess = spawn(process.execPath, [runnerFile, ...rawArgs], {
+            env: {
+                ...process.env,
+                [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}` : "";
+        logger().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(() => { });
+}
+export async function dev(rawArgs = process.argv.slice(2)) {
+    if (process.env[RUN_MODE] === "app") {
+        await runViteApp();
+        return;
+    }
+    await runViteController(rawArgs);
+}

package/lib/esm/bin/tsed.js

@@ -1,44 +1,32 @@
 #!/usr/bin/env node
-import "./ts-mode.js";
-import { register } from "node:module";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
 const EXT = process.env.CLI_MODE === "ts" ? "ts" : "js";
-register(pathToFileURL(join(import.meta.dirname, `../loaders/alias.hook.${EXT}`)), {
-    parentURL: import.meta.dirname,
-    data: {
-        "@tsed/core": import.meta.resolve("@tsed/core"),
-        "@tsed/di": import.meta.resolve("@tsed/di"),
-        "@tsed/schema": import.meta.resolve("@tsed/schema"),
-        "@tsed/cli-core": import.meta.resolve("@tsed/cli-core"),
-        "@tsed/cli": import.meta.resolve("@tsed/cli")
-    },
-    transferList: []
-});
-const { tools, commands, resources, CliCore, PKG, TEMPLATE_DIR, ArchitectureConvention, ProjectConvention } = await import("../index.js");
-CliCore.bootstrap({
-    name: "tsed",
-    pkg: PKG,
-    templateDir: TEMPLATE_DIR,
-    plugins: true,
-    updateNotifier: true,
-    checkPrecondition: true,
-    commands,
-    tools,
-    resources,
-    defaultProjectPreferences() {
-        return {
-            convention: ProjectConvention.DEFAULT,
-            architecture: ArchitectureConvention.DEFAULT
-        };
-    },
-    project: {
-        reinstallAfterRun: true
-    },
-    logger: {
-        level: "info"
-    }
-}).catch((error) => {
-    console.error(error);
-    process.exit(-1);
-});
+const [, , commandName, ...rawArgs] = process.argv;
+switch (commandName) {
+    case "dev":
+        try {
+            const { dev } = await import("./tsed-dev.js");
+            await dev(rawArgs);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+        break;
+    case "build":
+        try {
+            const { build } = await import("./tsed-build.js");
+            await build(rawArgs);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+        break;
+    default:
+        await import("./ts-mode.js");
+        await import(`./boot.${EXT}`);
+        break;
+}
+export {};

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

@@ -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";
@@ -143,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/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");