@tdk-landscape/tdk-cli-core 1.3.89 → 1.3.90

package/cli/dist/backend-frameworks/nestjs.js

@@ -0,0 +1,56 @@
+export function getNestIndexTemplate(name) {
+    return `import 'reflect-metadata';
+import { Controller, Get, Module } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+@Controller()
+class AppController {
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  @Get('health')
+  health() {
+    return { status: 'ok', service: '${name}' };
+  }
+
+  @Get('health/live')
+  live() {
+    return { status: 'alive', timestamp: Date.now() };
+  }
+
+  @Get()
+  root() {
+    return { service: '${name}', version: '1.0.0', endpoints: ['/health', '/health/live'] };
+  }
+}
+
+@Module({ controllers: [AppController] })
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { logger: ['error', 'warn', 'log'] });
+  const port = Number(process.env.PORT || 3000);
+
+  // Bind beyond loopback: Traefik reaches the container over the Docker network.
+  await app.listen(port, '0.0.0.0');
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+}
+
+bootstrap();
+`;
+}
+export const nestBackendProvider = {
+    id: "nestjs",
+    label: "Bun + NestJS",
+    dependencies: {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "reflect-metadata": "^0.2.2",
+        rxjs: "^7.8.1",
+    },
+    devDependencies: {},
+    // Nest's decorators need these; the engine's generated Docker tsconfig already sets them.
+    compilerOptions: { experimentalDecorators: true, emitDecoratorMetadata: true },
+    createIndex: getNestIndexTemplate,
+};
+//# sourceMappingURL=nestjs.js.map

package/cli/dist/backend-frameworks/registry.js

@@ -3,6 +3,7 @@ import { TdkError } from "../utils/errors.js";
 import { elysiaBackendProvider } from "./elysia.js";
 import { expressBackendProvider } from "./express.js";
 import { fastifyBackendProvider } from "./fastify.js";
+import { nestBackendProvider } from "./nestjs.js";
 /** Hono is the historical default; omitting --framework keeps the exact historical output. */
 export const DEFAULT_BACKEND_FRAMEWORK = "hono";
 export const honoBackendProvider = {
@@ -17,6 +18,7 @@ export const BACKEND_FRAMEWORKS = {
     express: expressBackendProvider,
     elysia: elysiaBackendProvider,
     fastify: fastifyBackendProvider,
+    nestjs: nestBackendProvider,
 };
 export function getBackendFramework(frameworkId) {
     const id = (frameworkId ?? DEFAULT_BACKEND_FRAMEWORK).trim().toLowerCase();

package/cli/dist/backend-languages/registry.js

@@ -2,11 +2,13 @@ import { TdkError } from "../utils/errors.js";
 import { bunBackendProvider } from "./bun.js";
 import { goBackendProvider } from "./go.js";
 import { pythonBackendProvider } from "./python.js";
+import { rustBackendProvider } from "./rust.js";
 export const DEFAULT_BACKEND_LANGUAGE = "bun";
 export const BACKEND_LANGUAGES = {
     bun: bunBackendProvider,
     python: pythonBackendProvider,
     go: goBackendProvider,
+    rust: rustBackendProvider,
 };
 export function getBackendLanguage(languageId) {
     const id = (languageId ?? DEFAULT_BACKEND_LANGUAGE).trim().toLowerCase();

package/cli/dist/backend-languages/rust.js

@@ -0,0 +1,83 @@
+/**
+ * Rust is compiled into the image and has no reload process, so the dev command is only what a developer
+ * would run by hand. Tilt rebuilds the image when a watched file changes (the engine returns no live-update rules).
+ */
+export const RUST_DEV_COMMAND = "cargo run";
+export const rustBackendProvider = {
+    id: "rust",
+    label: "Rust (axum)",
+    devCommand: RUST_DEV_COMMAND,
+    watch: ["src/**/*.rs", "Cargo.toml", "Cargo.lock"],
+    installHint: "cargo build   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "Cargo.toml",
+                content: `[package]
+name = "${name}"
+version = "0.1.0"
+edition = "2021"
+
+# The image copies the release binary by this fixed name.
+[[bin]]
+name = "app"
+path = "src/main.rs"
+
+[dependencies]
+axum = "0.8"
+serde_json = "1"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
+`,
+                description: "Generating Cargo.toml",
+                emoji: "📦",
+            },
+            {
+                filename: "src/main.rs",
+                content: `use axum::{routing::get, Json, Router};
+use serde_json::{json, Value};
+
+fn app() -> Router {
+    Router::new()
+        .route("/", get(root))
+        // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+        .route("/health", get(health))
+}
+
+async fn root() -> Json<Value> {
+    Json(json!({ "service": "${name}", "version": "1.0.0", "endpoints": ["/health"] }))
+}
+
+async fn health() -> Json<Value> {
+    Json(json!({ "status": "ok", "service": "${name}" }))
+}
+
+#[tokio::main]
+async fn main() {
+    let port = std::env::var("PORT").unwrap_or_else(|_| "3000".to_string());
+
+    // 0.0.0.0 listens on every interface, which Traefik needs inside the container network.
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{port}"))
+        .await
+        .expect("failed to bind the port");
+    println!("${name} listening on 0.0.0.0:{port}");
+    axum::serve(listener, app()).await.expect("server error");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn health_reports_ok() {
+        let Json(body) = health().await;
+        assert_eq!(body["status"], "ok");
+    }
+}
+`,
+                description: "Generating backend source and smoke test",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=rust.js.map

package/cli/dist/commands/resource.js

@@ -154,11 +154,13 @@ export function createPackageJson(name, type, frameworkId) {
 }
 export function createResourceTsconfig(resourceType, frameworkId) {
     const framework = resolveFrontendFramework(resourceType, frameworkId);
+    const backendFramework = resolveBackendFramework(resourceType, frameworkId);
     return {
         ...TSCONFIG_TEMPLATE,
         compilerOptions: {
             ...TSCONFIG_TEMPLATE.compilerOptions,
             ...(framework?.compilerOptions ?? {}),
+            ...(backendFramework?.compilerOptions ?? {}),
         },
     };
 }
@@ -295,8 +297,8 @@ export const resourceCommand = new Command("resource")
     .description("Create a new resource (service) from scratch, or register an existing one")
     .argument("[name]", "Resource name (kebab-case)")
     .option("-t, --type <type>", "Resource type: backend, frontend, worker, bring-your-own, sdk", "backend")
-    .option("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik, vanilla; backend hono (default), express, elysia, fastify")
-    .option("--language <id>", "Backend language: bun (default), python, go")
+    .option("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik, vanilla; backend hono (default), express, elysia, fastify, nestjs")
+    .option("--language <id>", "Backend language: bun (default), python, go, rust")
     .option("-s, --stack <stack>", "Stack to assign resource to", "default")
     .option("-p, --path <path>", "Custom path for resource directory")
     .option("--resource-path <path>", "Alias for --path (for backward compatibility)")
@@ -620,7 +622,7 @@ This file contains the resource configuration for TDK.
             {
                 type: "json",
                 filename: "tsconfig.json",
-                content: createResourceTsconfig(resourceType, frontendFramework?.id),
+                content: createResourceTsconfig(resourceType, frontendFramework?.id ?? backendFramework?.id),
                 description: "Generating tsconfig.json",
                 emoji: "⚙️",
             },

package/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tdk-cli-internal",
   "private": true,
-  "version": "1.3.89",
+  "version": "1.3.90",
   "description": "TDK CLI — start services on your laptop.",
   "keywords": [
     "tdk",

package/engine/schemas/service-schema.json

@@ -238,7 +238,8 @@
         "hono",
         "express",
         "elysia",
-        "fastify"
+        "fastify",
+        "nestjs"
       ],
       "pattern": "^[a-z][a-z0-9-]*$",
       "type": "string"
@@ -248,7 +249,8 @@
       "examples": [
         "bun",
         "python",
-        "go"
+        "go",
+        "rust"
       ],
       "pattern": "^[a-z][a-z0-9-]*$",
       "type": "string"

package/engine/topologies/platform/docker/dockerfile/language_dockerfile.star

@@ -8,12 +8,13 @@
 BASE_PORT_BACKEND = 4000
 
 # Languages whose runtime files are owned by the provider (no Vite/tsconfig/Bun config).
-PROVIDER_OWNED_LANGUAGES = ["python", "go"]
+PROVIDER_OWNED_LANGUAGES = ["python", "go", "rust"]
 
 # Files a provider-owned language must scaffold; checked before generating anything.
 LANGUAGE_REQUIRED_FILES = {
     "python": ["pyproject.toml", "src/main.py"],
     "go": ["go.mod", "main.go"],
+    "rust": ["Cargo.toml", "src/main.rs"],
 }
 
 _CURL = """RUN apt-get update && apt-get install -y --no-install-recommends curl \\
@@ -73,9 +74,37 @@ EXPOSE {port}
 CMD ["app"]
 """
 
+_RUST = """# Generated by TDK for a Rust backend. Do not edit; change service.json instead.
+# BuildKit cache mounts keep the registry and the target directory between builds, so a rebuild after a
+# source change recompiles only the crate itself, not every dependency.
+FROM rust:1-slim-bookworm AS build
+
+WORKDIR /app/{res_path}
+
+COPY {res_path}/ ./
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    --mount=type=cache,target=/app/{res_path}/target \\
+    cargo build --release && mkdir -p /out && cp target/release/app /out/app
+
+FROM build AS test
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    --mount=type=cache,target=/app/{res_path}/target \\
+    cargo test
+
+FROM debian:bookworm-slim AS production
+
+{curl}
+COPY --from=build /out/app /usr/local/bin/app
+
+{healthcheck}
+EXPOSE {port}
+
+CMD ["app"]
+"""
+
 def generate_language_dockerfile(res_path, language, port = BASE_PORT_BACKEND):
     """Dockerfile text for a provider-owned backend language, or fail for an unknown one."""
-    template = {"python": _PYTHON, "go": _GO}.get(language)
+    template = {"python": _PYTHON, "go": _GO, "rust": _RUST}.get(language)
     if template == None:
         fail("No Dockerfile generator for backend language '{}'".format(language))
     return template.format(

package/engine/topologies/tilt/generators/validators.star

@@ -559,6 +559,7 @@ def generate_resource_health_check(resource_name, resource_path, manifest, check
     backend_files = {
         "python": ["pyproject.toml", "src/main.py"],
         "go": ["go.mod", "main.go"],
+        "rust": ["Cargo.toml", "src/main.rs"],
     }.get(manifest.get("language", "bun"), ["package.json", "prisma/schema.prisma"])
     required_files = {
         "backend": backend_files,
@@ -575,7 +576,7 @@ fi
 '''.format(req_file, req_file))
     
     # Check 2: Package.json is valid JSON (Python and Go backends have no package.json)
-    if manifest.get("language", "bun") not in ["python", "go"]:
+    if manifest.get("language", "bun") not in ["python", "go", "rust"]:
         health_checks.append('''
 if ! cat package.json | head -1 > /dev/null 2>&1; then
     echo "❌ package.json is not valid"

package/engine/topologies/tilt/resources/orchestrator/apply_compose_resource_registration.star

@@ -220,12 +220,12 @@ def _build_live_update_rules(res_path, full_res_path, syncs, project_root='', la
 
     Python backends reload their own process after a sync (uvicorn --reload), so they have
     no Bun install step. A changed pyproject.toml is not synced, so Tilt rebuilds the image instead.
-    Go backends have no live update at all (see the early return).
+    Go and Rust backends have no live update at all (see the early return).
     """
-    # Go is compiled into the image and has no reload process, so syncing sources would leave the old
-    # binary running. Return before any sync() step is built (Tilt rejects sync steps that are created
+    # Go and Rust are compiled into the image and have no reload process, so syncing sources would leave the
+    # old binary running. Return before any sync() step is built (Tilt rejects sync steps that are created
     # but never used): no live-update rules means Tilt rebuilds the image when a watched file changes.
-    if language == 'go':
+    if language in ['go', 'rust']:
         return []
 
     live_update_rules = []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tdk-landscape/tdk-cli-core",
-  "version": "1.3.89",
+  "version": "1.3.90",
   "description": "TDK CLI — start services on your laptop.",
   "homepage": "https://tdk-landscape.github.io/tdk-website",
   "repository": {