@tdk-landscape/tdk-cli-core 1.3.44 → 1.3.48

package/cli/src/commands/__tests__/phases-model.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+
+/**
+ * Project → Phase → Stack → Resource (PPSR) model.
+ *
+ * project.json now organizes services by release phase:
+ *
+ *   project
+ *     └── phases
+ *           ├── pre_alpha.enabledStacks: ["proxy", "billing", "checkout-app"]
+ *           ├── alpha.enabledStacks: []
+ *           ├── beta.enabledStacks: []
+ *           └── out_of_scope.enabledStacks: []
+ *
+ * Each entry in enabledStacks[] is a stack name (e.g. "billing").
+ * A stack owns one or more resources/services (e.g. "checkout-app" has
+ * service.json with stack: "billing").
+ */
+describe("Project → Phase → Stack → Resource model", () => {
+  it("defines phases with enabledStacks (not legacy stacks/services)", () => {
+    const projectConfig = {
+      version: "1.0",
+      project: { name: "checkout-app", version: "1.0.0" },
+      phases: {
+        pre_alpha: {
+          name: "Pre-Alpha",
+          description: "Core infrastructure and MVP services",
+          enabledStacks: ["proxy", "database-management", "app", "billing", "checkout-app"],
+        },
+        alpha: {
+          name: "Alpha",
+          description: "Essential business services",
+          enabledStacks: [],
+        },
+        beta: {
+          name: "Beta",
+          description: "Extended features",
+          enabledStacks: [],
+        },
+        out_of_scope: {
+          name: "Out of Scope",
+          description: "Future releases",
+          enabledStacks: [],
+        },
+      },
+    };
+
+    expect(projectConfig).toHaveProperty("phases");
+    expect(projectConfig).not.toHaveProperty("stacks");
+    expect(projectConfig.phases.pre_alpha).toHaveProperty("enabledStacks");
+    expect(projectConfig.phases.pre_alpha).not.toHaveProperty("services");
+    expect(projectConfig.phases.pre_alpha.enabledStacks).toContain("billing");
+    expect(projectConfig.phases.pre_alpha.enabledStacks).toContain("checkout-app");
+  });
+
+  it("keeps the PSR stack concept separate from phases", () => {
+    const service = {
+      appName: "checkout-app",
+      appType: "frontend",
+      stack: "billing",
+      port: 3210,
+    };
+
+    const phase = {
+      name: "Pre-Alpha",
+      enabledStacks: ["billing", "checkout-app"],
+    };
+
+    // The service belongs to the "billing" stack, while the phase controls
+    // whether that stack is enabled for this project.
+    expect(service.stack).toBe("billing");
+    expect(phase.enabledStacks).toContain("billing");
+    expect(phase.enabledStacks).toContain("checkout-app");
+    expect(service.appName).toBe("checkout-app");
+  });
+
+  it("deduplicates enabledStacks per phase", () => {
+    const enabledStacks = Array.from(
+      new Set(["proxy", "billing", "checkout-app", "billing"]),
+    );
+
+    expect(enabledStacks).toEqual(["proxy", "billing", "checkout-app"]);
+    expect(enabledStacks.filter((s) => s === "billing")).toHaveLength(1);
+  });
+
+  it("maps legacy stacks/services to phases/enabledStacks", () => {
+    const legacy = {
+      stacks: {
+        pre_alpha: {
+          name: "Pre-Alpha",
+          description: "Core infrastructure and MVP services",
+          services: ["proxy", "billing"],
+        },
+        alpha: {
+          name: "Alpha",
+          description: "Essential business services",
+          services: [],
+        },
+        beta: {
+          name: "Beta",
+          description: "Extended features",
+          services: [],
+        },
+        out_of_scope: {
+          name: "Out of Scope",
+          description: "Future releases",
+          services: [],
+        },
+      },
+    };
+
+    const phases = {
+      pre_alpha: {
+        name: legacy.stacks.pre_alpha.name,
+        description: legacy.stacks.pre_alpha.description,
+        enabledStacks: legacy.stacks.pre_alpha.services,
+      },
+      alpha: {
+        name: legacy.stacks.alpha.name,
+        description: legacy.stacks.alpha.description,
+        enabledStacks: legacy.stacks.alpha.services,
+      },
+      beta: {
+        name: legacy.stacks.beta.name,
+        description: legacy.stacks.beta.description,
+        enabledStacks: legacy.stacks.beta.services,
+      },
+      out_of_scope: {
+        name: legacy.stacks.out_of_scope.name,
+        description: legacy.stacks.out_of_scope.description,
+        enabledStacks: legacy.stacks.out_of_scope.services,
+      },
+    };
+
+    expect(phases.pre_alpha.enabledStacks).toEqual(["proxy", "billing"]);
+    expect(phases).not.toHaveProperty("services");
+    expect(phases.pre_alpha).not.toHaveProperty("services");
+  });
+
+  it("generates spec.master PRE_ALPHA_RESOURCES from phases.pre_alpha.enabledStacks", () => {
+    const enabledStacks = ["proxy", "billing", "checkout-app"];
+    const resourceEntries = enabledStacks.map((stack) => `"${stack}": True`);
+    const specMaster = `PRE_ALPHA_RESOURCES = {\n${resourceEntries.join(",\n")}\n}`;
+
+    expect(specMaster).toContain('PRE_ALPHA_RESOURCES = {');
+    expect(specMaster).toContain('"billing": True');
+    expect(specMaster).toContain('"checkout-app": True');
+    expect(specMaster).not.toContain('"services"');
+  });
+
+  it("keeps focus lists derived from phases for CLI --focus", () => {
+    const preAlpha = ["proxy", "billing", "checkout-app"];
+    const alpha = ["api"];
+    const beta = ["worker"];
+    const focusPreAlpha = preAlpha;
+    const focusAlpha = [...preAlpha, ...alpha];
+    const focusBeta = [...preAlpha, ...alpha, ...beta];
+
+    expect(focusPreAlpha).toEqual(preAlpha);
+    expect(focusAlpha).toContain("checkout-app");
+    expect(focusBeta).toContain("checkout-app");
+  });
+});

package/cli/src/commands/__tests__/project-resource-features-e2e.test.ts

@@ -0,0 +1,207 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const repoRoot = resolve(__dirname, "../../../..");
+const cliBin = join(repoRoot, "cli", "bin", "tdk.js");
+
+function runTdk(args: string[], cwd: string, input?: string): string {
+  return execFileSync(process.execPath, [cliBin, ...args], {
+    cwd,
+    encoding: "utf-8",
+    input,
+    env: {
+      ...process.env,
+      TDK_EXTENSION_SOURCE: repoRoot,
+    },
+  });
+}
+
+function starlarkSection(content: string, name: string): string {
+  const start = content.indexOf(`${name} = {`);
+  expect(start).toBeGreaterThanOrEqual(0);
+  const end = content.indexOf("\n}", start);
+  expect(end).toBeGreaterThan(start);
+  return content.slice(start, end + 2);
+}
+
+describe("project and resource feature E2E", () => {
+  let projectRoot = "";
+
+  afterEach(() => {
+    if (projectRoot && projectRoot.startsWith(tmpdir())) {
+      rmSync(projectRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps Verdaccio as an explicit premium project feature", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-project-feature-"));
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const projectJsonPath = join(projectRoot, ".tdk", "project.json");
+    const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    expect(projectJson.phases.pre_alpha.enabledStacks).not.toContain("verdaccio");
+    expect(projectJson.optional_infra.verdaccio).toBe(false);
+
+    let spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(starlarkSection(spec, "PRE_ALPHA_RESOURCES")).not.toContain('"verdaccio": True');
+    expect(starlarkSection(spec, "OPTIONAL_INFRA_RESOURCES")).toContain('"verdaccio": False');
+
+    // Without TDK_LICENSE_KEY granting it, enabling verdaccio must be refused
+    // outright (config.ts:toggleInfraService) rather than silently accepted
+    // and then downgraded back to false by generateMasterConfigs.
+    expect(() => runTdk(["config", "enable-infra", "verdaccio"], projectRoot)).toThrow(
+      /Premium feature/,
+    );
+
+    const updatedProjectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    expect(updatedProjectJson.phases.pre_alpha.enabledStacks).not.toContain("verdaccio");
+    expect(updatedProjectJson.optional_infra.verdaccio).toBe(false);
+
+    spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(starlarkSection(spec, "PRE_ALPHA_RESOURCES")).not.toContain('"verdaccio": True');
+    expect(starlarkSection(spec, "OPTIONAL_INFRA_RESOURCES")).toContain('"verdaccio": False');
+  }, 10000);
+
+  it("warns instead of silently stripping stale Verdaccio state when no premium license grants it", () => {
+    // generateMasterConfigs() intentionally does not enforce the license
+    // gate itself (see the comment above hasVerdaccioLicense's call site in
+    // template-engine.ts): the real enforcement is that the free-tier
+    // verdaccio_loader.star in this public repo is a no-op stub, so hand-
+    // edited state here has no functional effect without the private
+    // premium overlay. It just warns so the user isn't left guessing.
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-stale-verdaccio-"));
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const projectJsonPath = join(projectRoot, ".tdk", "project.json");
+    const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    projectJson.phases.pre_alpha.enabledStacks.push("verdaccio");
+    projectJson.optional_infra.verdaccio = true;
+    writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2));
+
+    runTdk(["config", "regenerate"], projectRoot);
+
+    const updatedProjectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    expect(updatedProjectJson.phases.pre_alpha.enabledStacks).toContain("verdaccio");
+    expect(updatedProjectJson.optional_infra.verdaccio).toBe(true);
+
+    const spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(starlarkSection(spec, "PRE_ALPHA_RESOURCES")).toContain('"verdaccio": True');
+    expect(starlarkSection(spec, "OPTIONAL_INFRA_RESOURCES")).toContain('"verdaccio": True');
+  }, 10000);
+
+  it("copies Docker runtime assets and creates the root workspace manifest during project generation", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-project-runtime-assets-"));
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const rootPackageJson = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8"));
+    expect(rootPackageJson.private).toBe(true);
+    expect(rootPackageJson.workspaces).toEqual(["services/*/*"]);
+
+    for (const file of [
+      "install-deps.sh",
+      "bun-hoisted-symlink-fix.sh",
+      "prisma-bun-client-link-fix.sh",
+      "prisma-normalize-client.sh",
+    ]) {
+      expect(
+        existsSync(
+          join(projectRoot, "shared-platform-engineering", "docker-templates", file),
+        ),
+      ).toBe(true);
+    }
+  }, 10000);
+
+  it("vendors free env injection instead of Infisical credentials by default", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-project-env-injection-"));
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const envGenerator = readFileSync(
+      join(
+        projectRoot,
+        ".tdk",
+        ".tdk-out",
+        "tdk-cli-ext",
+        "engine",
+        "topologies",
+        "platform",
+        "docker",
+        "secrets",
+        "infisical.star",
+      ),
+      "utf-8",
+    );
+    expect(envGenerator).toContain("TDK_SECRET_PROVIDER");
+    expect(envGenerator).not.toContain("INFISICAL_CLIENT_SECRET");
+
+    const dockerfileGenerator = readFileSync(
+      join(
+        projectRoot,
+        ".tdk",
+        ".tdk-out",
+        "tdk-cli-ext",
+        "engine",
+        "topologies",
+        "platform",
+        "docker",
+        "dockerfile",
+        "dockerfile.star",
+      ),
+      "utf-8",
+    );
+    expect(dockerfileGenerator).toContain("use_infisical=False");
+  }, 10000);
+
+  it("writes default resource-level features into generated service.json files", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-resource-feature-"));
+    runTdk(["project", "--yes"], projectRoot);
+
+    runTdk(
+      [
+        "resource",
+        "api",
+        "--type",
+        "backend",
+        "--stack",
+        "alpha",
+        "--path",
+        "services/alpha/api",
+      ],
+      projectRoot,
+      "\n",
+    );
+    runTdk(
+      [
+        "resource",
+        "web",
+        "--type",
+        "frontend",
+        "--stack",
+        "alpha",
+        "--path",
+        "services/alpha/web",
+      ],
+      projectRoot,
+      "\n",
+    );
+
+    const backendService = JSON.parse(
+      readFileSync(join(projectRoot, "services", "alpha", "api", "service.json"), "utf-8"),
+    );
+    expect(backendService.featuresEnabled).toEqual(["prisma"]);
+
+    const frontendService = JSON.parse(
+      readFileSync(join(projectRoot, "services", "alpha", "web", "service.json"), "utf-8"),
+    );
+    expect(frontendService.featuresEnabled).toEqual(["api-client", "env-config", "api-index"]);
+  }, 10000);
+});

package/cli/src/commands/__tests__/project.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+
+const EXPECTED_TEMPLATES = [
+  "TILT_RESOURCE_DEFAULTS.star.hbs",
+  "TILT_TECH_STACK.star.hbs",
+  "Tiltfile.hbs",
+  "spec.master.hbs",
+] as const;
+
+const TEMPLATE_PATTERNS = {
+  "TILT_RESOURCE_DEFAULTS.star.hbs": [
+    "BASE_PORT_FRONTEND",
+    "BASE_PORT_BACKEND",
+    "HEALTH_CHECK_PATH",
+    "starlarkArray",
+  ],
+  "TILT_TECH_STACK.star.hbs": ["BUNDLER", "RUNTIME", "ORM", "assert_tech_stack"],
+  "Tiltfile.hbs": ["TDK CLI", ".tdk/.tdk-out", "spec.master"],
+} as const;
+
+describe("project command", () => {
+  it("should verify all expected templates exist", () => {
+    expect(EXPECTED_TEMPLATES).toHaveLength(4);
+    for (const template of EXPECTED_TEMPLATES) {
+      expect(EXPECTED_TEMPLATES).toContain(template);
+    }
+  });
+
+  it("should have templates with all required content patterns", () => {
+    for (const templateName of Object.keys(TEMPLATE_PATTERNS)) {
+      expect(EXPECTED_TEMPLATES).toContain(templateName);
+    }
+
+    for (const [, patterns] of Object.entries(TEMPLATE_PATTERNS)) {
+      for (const pattern of patterns) {
+        expect(patterns).toContain(pattern);
+      }
+    }
+  });
+});
+
+describe("project command templates", () => {
+  it("should have valid Handlebars template patterns", () => {
+    const handlebarsPatterns = ["{{", "}}"];
+
+    expect(handlebarsPatterns).toContain("{{");
+    expect(handlebarsPatterns).toContain("}}");
+  });
+
+  it("should have templates with required content patterns defined", () => {
+    for (const pattern of [
+      "BASE_PORT_FRONTEND",
+      "BASE_PORT_BACKEND",
+      "HEALTH_CHECK_PATH",
+      "starlarkArray",
+    ]) {
+      expect(TEMPLATE_PATTERNS["TILT_RESOURCE_DEFAULTS.star.hbs"]).toContain(pattern);
+    }
+
+    for (const pattern of ["BUNDLER", "RUNTIME", "ORM", "assert_tech_stack"]) {
+      expect(TEMPLATE_PATTERNS["TILT_TECH_STACK.star.hbs"]).toContain(pattern);
+    }
+
+    for (const pattern of ["TDK CLI", ".tdk/.tdk-out", "spec.master"]) {
+      expect(TEMPLATE_PATTERNS["Tiltfile.hbs"]).toContain(pattern);
+    }
+  });
+});

package/cli/src/commands/__tests__/resource.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it } from "vitest";
+import {
+  BASE_TEMPLATE,
+  createPackageJson,
+  createServiceJson,
+  DOCKERFILE_TEMPLATE,
+  getBackendIndexTemplate,
+  getWorkerIndexTemplate,
+  TSCONFIG_TEMPLATE,
+  TYPE_SPECIFIC,
+} from "../../commands/resource.js";
+import { CREATABLE_RESOURCE_TYPES, isCreatableResourceType } from "../../types/index.js";
+import { KEBAB_CASE_REGEX } from "../../utils/validation.js";
+
+describe("resource command", () => {
+  describe("resource name validation", () => {
+    it("should accept valid kebab-case names using KEBAB_CASE_REGEX", () => {
+      const validNames = ["my-service", "service123", "api-gateway", "a", "test-123-abc"];
+
+      for (const name of validNames) {
+        expect(KEBAB_CASE_REGEX.test(name)).toBe(true);
+      }
+    });
+
+    it("should reject invalid names using KEBAB_CASE_REGEX", () => {
+      const invalidNames = [
+        "MyService", // camelCase
+        "my_service", // underscore
+        "my service", // space
+        "service.name", // dot
+        "Service-Name", // uppercase
+        "", // empty
+      ];
+
+      for (const name of invalidNames) {
+        expect(KEBAB_CASE_REGEX.test(name)).toBe(false);
+      }
+    });
+  });
+
+  describe("service.json template", () => {
+    it("should create valid backend service.json using createServiceJson", () => {
+      const name = "test-backend";
+      const type = "backend";
+      const stack = "main";
+      const port = 3001;
+
+      const serviceJson = createServiceJson(name, type, stack, port);
+
+      expect(serviceJson).toHaveProperty("name", name);
+      expect(serviceJson).toHaveProperty("type", type);
+      expect(serviceJson).toHaveProperty("port", port);
+      expect(serviceJson).toHaveProperty("stack", stack);
+      expect(serviceJson).toHaveProperty("healthCheck", "/health");
+      expect(serviceJson).toHaveProperty("dependencies");
+      expect(serviceJson).toHaveProperty("build");
+      expect(serviceJson).toHaveProperty("dev");
+    });
+
+    it("should create valid frontend service.json using createServiceJson", () => {
+      const name = "test-frontend";
+      const type = "frontend";
+      const stack = "main";
+      const port = 3002;
+
+      const serviceJson = createServiceJson(name, type, stack, port);
+
+      expect(serviceJson).toHaveProperty("name", name);
+      expect(serviceJson).toHaveProperty("type", type);
+      expect(serviceJson).toHaveProperty("port", port);
+      expect(serviceJson.dev.watch).toContain("public/**/*");
+    });
+
+    it("should create valid worker service.json using createServiceJson", () => {
+      const name = "test-worker";
+      const type = "worker";
+      const stack = "main";
+      const port = 0;
+
+      const serviceJson = createServiceJson(name, type, stack, port);
+
+      expect(serviceJson).toHaveProperty("name", name);
+      expect(serviceJson).toHaveProperty("type", type);
+      expect(serviceJson.port).toBe(0); // Workers may not need ports
+      expect(serviceJson.dev.command).toBe("bun run worker");
+    });
+
+    it("should have correct TYPE_SPECIFIC extensions for each resource type", () => {
+      expect(TYPE_SPECIFIC.backend).toHaveProperty("healthCheck", "/health");
+      expect(TYPE_SPECIFIC.frontend.dev?.watch).toContain("public/**/*");
+      expect(TYPE_SPECIFIC.worker.dev?.command).toBe("bun run worker");
+    });
+
+    it("should have correct BASE_TEMPLATE structure", () => {
+      expect(BASE_TEMPLATE).toHaveProperty("port", 0);
+      expect(BASE_TEMPLATE).toHaveProperty("dependencies");
+      expect(BASE_TEMPLATE).toHaveProperty("build");
+      expect(BASE_TEMPLATE).toHaveProperty("dev");
+      expect(BASE_TEMPLATE.build).toHaveProperty("dockerfile", "Dockerfile");
+    });
+  });
+
+  describe("package.json template", () => {
+    it("should create backend package.json with Hono using createPackageJson", () => {
+      const name = "test-backend";
+      const type = "backend";
+
+      const packageJson = createPackageJson(name, type);
+
+      expect(packageJson.name).toBe(`@project/${name}`);
+      expect(packageJson).toHaveProperty("dependencies");
+      expect(packageJson.dependencies).toHaveProperty("hono");
+      expect(packageJson.dependencies).not.toHaveProperty("vite");
+      expect(packageJson.scripts.dev).toBe("bun run --watch src/index.ts");
+    });
+
+    it("should create frontend package.json with Vite using createPackageJson", () => {
+      const name = "test-frontend";
+      const type = "frontend";
+
+      const packageJson = createPackageJson(name, type);
+
+      expect(packageJson.name).toBe(`@project/${name}`);
+      expect(packageJson.dependencies).not.toHaveProperty("hono");
+      expect(packageJson.devDependencies).toHaveProperty("vite");
+      expect(packageJson.scripts.dev).toBe("vite");
+    });
+
+    it("should create worker package.json using createPackageJson", () => {
+      const name = "test-worker";
+      const type = "worker";
+
+      const packageJson = createPackageJson(name, type);
+
+      expect(packageJson.name).toBe(`@project/${name}`);
+      expect(packageJson.dependencies).toHaveProperty("hono");
+      expect(packageJson.scripts.build).toBe("tsc");
+    });
+  });
+
+  describe("tsconfig template", () => {
+    it("should have correct TSCONFIG_TEMPLATE structure", () => {
+      expect(TSCONFIG_TEMPLATE).toHaveProperty("compilerOptions");
+      expect(TSCONFIG_TEMPLATE.compilerOptions).toHaveProperty("target", "ES2022");
+      expect(TSCONFIG_TEMPLATE.compilerOptions).toHaveProperty("module", "ESNext");
+      expect(TSCONFIG_TEMPLATE.compilerOptions).toHaveProperty("strict", true);
+      expect(TSCONFIG_TEMPLATE).toHaveProperty("include");
+      expect(TSCONFIG_TEMPLATE.include).toContain("src/**/*");
+    });
+  });
+
+  describe("dockerfile template", () => {
+    it("should have correct DOCKERFILE_TEMPLATE content", () => {
+      expect(DOCKERFILE_TEMPLATE).toContain("FROM oven/bun:1.2");
+      expect(DOCKERFILE_TEMPLATE).toContain("WORKDIR /app");
+      expect(DOCKERFILE_TEMPLATE).toContain("HEALTHCHECK");
+      expect(DOCKERFILE_TEMPLATE).toContain("EXPOSE 3000");
+      expect(DOCKERFILE_TEMPLATE).toContain("bun install --frozen-lockfile");
+    });
+  });
+
+  describe("backend index.ts template", () => {
+    it("should have health check endpoints via getBackendIndexTemplate", () => {
+      const name = "test-service";
+      const indexContent = getBackendIndexTemplate(name);
+
+      expect(indexContent).toContain("app.get('/health'");
+      expect(indexContent).toContain("app.get('/health/live'");
+      expect(indexContent).toContain("app.get('/health/ready'");
+      expect(indexContent).toContain("async (c)");
+      expect(indexContent).toContain(`service: '${name}'`);
+    });
+
+    it("should have root endpoint with service info", () => {
+      const name = "test-service";
+      const indexContent = getBackendIndexTemplate(name);
+
+      expect(indexContent).toContain("app.get('/',");
+      expect(indexContent).toContain("endpoints:");
+    });
+  });
+
+  describe("worker index.ts template", () => {
+    it("should have worker configuration via getWorkerIndexTemplate", () => {
+      const name = "test-worker";
+      const workerContent = getWorkerIndexTemplate(name);
+
+      expect(workerContent).toContain("WORKER_POLL_INTERVAL");
+      expect(workerContent).toContain("WORKER_MAX_RETRIES");
+      expect(workerContent).toContain("WORKER_BATCH_SIZE");
+      expect(workerContent).toContain("interface Job");
+      expect(workerContent).toContain("async function main()");
+    });
+
+    it("should have graceful shutdown handling", () => {
+      const name = "test-worker";
+      const workerContent = getWorkerIndexTemplate(name);
+
+      expect(workerContent).toContain("process.on('SIGTERM'");
+      expect(workerContent).toContain("process.on('SIGINT'");
+      expect(workerContent).toContain("shutting down gracefully");
+    });
+  });
+
+  describe("resource type validation", () => {
+    it("should only accept valid resource types via isCreatableResourceType", () => {
+      const validTypes = ["backend", "frontend", "worker"];
+      const invalidTypes = ["api", "microservice", "service", "app", "library", "sdk"];
+
+      for (const type of validTypes) {
+        expect(isCreatableResourceType(type)).toBe(true);
+      }
+
+      for (const type of invalidTypes) {
+        expect(isCreatableResourceType(type)).toBe(false);
+      }
+    });
+
+    it("should have correct CREATABLE_RESOURCE_TYPES", () => {
+      expect(CREATABLE_RESOURCE_TYPES).toContain("backend");
+      expect(CREATABLE_RESOURCE_TYPES).toContain("frontend");
+      expect(CREATABLE_RESOURCE_TYPES).toContain("worker");
+      expect(CREATABLE_RESOURCE_TYPES).toHaveLength(3);
+    });
+  });
+});