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

package/cli/src/utils/__tests__/paths.test.ts

@@ -0,0 +1,180 @@
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { findProjectRoot } from "../paths.js";
+
+describe("findProjectRoot", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "tdk-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should find project root when .tdk/project.json exists", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    const root = findProjectRoot(tmpDir);
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should find project root from a nested subdirectory", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+    const subDir = join(tmpDir, "services", "product", "my-service", "backend");
+    mkdirSync(subDir, { recursive: true });
+
+    const root = findProjectRoot(subDir);
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should return null when no .tdk/project.json exists", () => {
+    mkdirSync(join(tmpDir, "services"), { recursive: true });
+
+    const root = findProjectRoot(tmpDir);
+    expect(root).toBeNull();
+  });
+
+  it("should return null when .tdk directory exists but no project.json inside", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+
+    const root = findProjectRoot(tmpDir);
+    expect(root).toBeNull();
+  });
+
+  it("should return null from empty directory", () => {
+    const root = findProjectRoot(tmpDir);
+    expect(root).toBeNull();
+  });
+
+  it("should stop at filesystem root and not loop infinitely", () => {
+    const root = findProjectRoot("/");
+    expect(root).toBeNull();
+  });
+
+  it("should handle very deep paths correctly", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    const deepDir = join(tmpDir, "a", "b", "c", "d", "e", "f", "g");
+    mkdirSync(deepDir, { recursive: true });
+
+    const root = findProjectRoot(deepDir);
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should handle paths with symlinks (resolve to real path)", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+    const realDir = join(tmpDir, "real");
+    mkdirSync(realDir, { recursive: true });
+    const linkDir = join(tmpDir, "link");
+
+    try {
+      symlinkSync(realDir, linkDir);
+      const root = findProjectRoot(linkDir);
+      expect(root).toBe(tmpDir);
+    } catch {
+      // Symlinks might not be available on some platforms, skip
+    }
+  });
+
+  it("should not confuse .tdk directory outside project root", () => {
+    const outerDir = mkdtempSync(join(tmpdir(), "tdk-outer-"));
+    try {
+      mkdirSync(join(outerDir, ".tdk"), { recursive: true });
+      writeFileSync(join(outerDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+      const root = findProjectRoot(tmpDir);
+      expect(root).toBeNull();
+    } finally {
+      rmSync(outerDir, { recursive: true, force: true });
+    }
+  });
+
+  it("should return resolved path (no trailing separators or dot segments)", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    const root = findProjectRoot(join(tmpDir, ".", "services", ".."));
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should find project root with trailing slash in startDir", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    const root = findProjectRoot(`${tmpDir}/`);
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should handle startDir being a non-existent path (resolves to cwd parent)", () => {
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    // A non-existent path - resolve will still produce something based on cwd
+    const root = findProjectRoot(resolve(tmpDir, "nonexistent", "dir"));
+
+    // Since we have .tdk/project.json in tmpDir and the resolved path
+    // starts with tmpDir, walking up should find it
+    // resolve(tmpDir, 'nonexistent', 'dir') = tmpDir + '/nonexistent/dir'
+    // Walking up from there: tmpDir + '/nonexistent/dir' -> tmpDir + '/nonexistent' -> tmpDir
+    // tmpDir has .tdk/project.json so it should be found
+    expect(root).toBe(tmpDir);
+  });
+
+  it("should work when .tdk is a symlink to another directory", () => {
+    const realTdkDir = join(tmpDir, "real-tdk");
+    mkdirSync(realTdkDir, { recursive: true });
+    writeFileSync(join(realTdkDir, "project.json"), JSON.stringify({ version: "2" }));
+    mkdirSync(join(tmpDir, "services"), { recursive: true });
+
+    try {
+      symlinkSync(realTdkDir, join(tmpDir, ".tdk"));
+      const root = findProjectRoot(tmpDir);
+      expect(root).toBe(tmpDir);
+    } catch {
+      // Symlinks might fail on some platforms
+    }
+  });
+
+  it("should find project root even when there are multiple .tdk directories in the path", () => {
+    // Create a .tdk/project.json in a parent and child
+    mkdirSync(join(tmpDir, ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+    mkdirSync(join(tmpDir, "subdir", ".tdk"), { recursive: true });
+    writeFileSync(join(tmpDir, "subdir", ".tdk", "project.json"), JSON.stringify({ version: "2" }));
+
+    // Starting from the child, it should find the child first
+    const root = findProjectRoot(join(tmpDir, "subdir"));
+    expect(root).toBe(join(tmpDir, "subdir"));
+  });
+});
+
+describe("getPackageVersion", () => {
+  it("should return a non-empty string version", async () => {
+    const { getPackageVersion } = await import("../paths.js");
+    const version = getPackageVersion();
+    expect(version).toBeTypeOf("string");
+    expect(version.length).toBeGreaterThan(0);
+  });
+
+  it("should return version matching semver pattern", async () => {
+    const { getPackageVersion } = await import("../paths.js");
+    const version = getPackageVersion();
+    expect(version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+
+  it("should return cached value on repeated calls", async () => {
+    const { getPackageVersion } = await import("../paths.js");
+    const v1 = getPackageVersion();
+    const v2 = getPackageVersion();
+    expect(v1).toBe(v2);
+  });
+});

package/cli/src/utils/__tests__/port-assignment.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import type { DiscoveredResource } from "../../types/index.js";
+import { assignPort, getUsedPorts } from "../port-assignment.js";
+
+describe("getUsedPorts", () => {
+  it("should return empty set for no resources", () => {
+    const usedPorts = getUsedPorts([]);
+    expect(usedPorts.size).toBe(0);
+  });
+
+  it("should collect ports from resources", () => {
+    const resources: DiscoveredResource[] = [
+      {
+        name: "svc-a",
+        port: 3000,
+        path: "/tmp",
+        configPath: "/tmp/a/service.json",
+        config: { appName: "svc-a", appType: "backend" },
+      },
+      {
+        name: "svc-b",
+        port: 4000,
+        path: "/tmp",
+        configPath: "/tmp/b/service.json",
+        config: { appName: "svc-b", appType: "frontend" },
+      },
+    ];
+
+    const usedPorts = getUsedPorts(resources);
+    expect(usedPorts.has(3000)).toBe(true);
+    expect(usedPorts.has(4000)).toBe(true);
+    expect(usedPorts.size).toBe(2);
+  });
+
+  it("should skip resources without ports", () => {
+    const resources: DiscoveredResource[] = [
+      { name: "svc-a", port: undefined, path: "/tmp", configPath: "/tmp/a/service.json" },
+      { name: "svc-b", port: 0, path: "/tmp", configPath: "/tmp/b/service.json" },
+    ];
+
+    const usedPorts = getUsedPorts(resources);
+    expect(usedPorts.size).toBe(0);
+  });
+});
+
+describe("assignPort", () => {
+  it("should assign base port when no resources exist", () => {
+    const port = assignPort("backend", []);
+    expect(port).toBe(4000);
+  });
+
+  it("should assign next available port", () => {
+    const existing: DiscoveredResource[] = [
+      {
+        name: "svc-a",
+        port: 4000,
+        path: "/tmp",
+        configPath: "/tmp/a/service.json",
+        config: { appName: "svc-a", appType: "backend" },
+      },
+    ];
+
+    const port = assignPort("backend", existing);
+    expect(port).toBe(4001);
+  });
+
+  it("should assign frontend port from frontend range", () => {
+    const port = assignPort("frontend", []);
+    expect(port).toBe(3000);
+  });
+
+  it("should assign worker port from worker range", () => {
+    const port = assignPort("worker", []);
+    expect(port).toBe(6000);
+  });
+
+  it("should skip used ports", () => {
+    const existing: DiscoveredResource[] = [
+      {
+        name: "front-a",
+        port: 3000,
+        path: "/tmp",
+        configPath: "/tmp/a/service.json",
+        config: { appName: "front-a", appType: "frontend" },
+      },
+      {
+        name: "front-b",
+        port: 3001,
+        path: "/tmp",
+        configPath: "/tmp/b/service.json",
+        config: { appName: "front-b", appType: "frontend" },
+      },
+      {
+        name: "front-c",
+        port: 3002,
+        path: "/tmp",
+        configPath: "/tmp/c/service.json",
+        config: { appName: "front-c", appType: "frontend" },
+      },
+    ];
+
+    const port = assignPort("frontend", existing);
+    expect(port).toBe(3003);
+  });
+
+  it("should throw when no ports available in range", () => {
+    // Fill all frontend ports (3000-3999)
+    const existing: DiscoveredResource[] = [];
+    for (let i = 3000; i <= 3999; i++) {
+      existing.push({
+        name: `svc-${i}`,
+        port: i,
+        path: "/tmp",
+        configPath: `/tmp/svc-${i}/service.json`,
+        config: { appName: `svc-${i}`, appType: "frontend" },
+      });
+    }
+
+    expect(() => assignPort("frontend", existing)).toThrow("No available ports");
+  });
+});

package/cli/src/utils/__tests__/service-urls.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DiscoveredResource } from "../../types/index.js";
+import {
+  appendHealthPath,
+  buildHealthTargets,
+  pingHealthTarget,
+  resolveServicePath,
+  resolveSubdomainBases,
+} from "../service-urls.js";
+
+function resource(
+  name: string,
+  appType: string,
+  config: Record<string, unknown> = {},
+): DiscoveredResource {
+  return {
+    name,
+    path: `/tmp/${name}`,
+    configPath: `/tmp/${name}/service.json`,
+    config: { appName: name, appType, ...config } as DiscoveredResource["config"],
+  };
+}
+
+describe("appendHealthPath", () => {
+  it("appends /health", () => {
+    expect(appendHealthPath("/menu")).toBe("/menu/health");
+  });
+
+  it("collapses trailing slashes", () => {
+    expect(appendHealthPath("/menu///")).toBe("/menu/health");
+  });
+});
+
+describe("resolveSubdomainBases", () => {
+  const original = process.env.TDK_SERVICE_BASE_URL;
+
+  afterEach(() => {
+    if (original === undefined) {
+      delete process.env.TDK_SERVICE_BASE_URL;
+    } else {
+      process.env.TDK_SERVICE_BASE_URL = original;
+    }
+  });
+
+  it("splits a bare domain into app/api subdomains", () => {
+    process.env.TDK_SERVICE_BASE_URL = "http://demo.localhost";
+    expect(resolveSubdomainBases()).toEqual({
+      appBase: "http://app.demo.localhost",
+      apiBase: "http://api.demo.localhost",
+    });
+  });
+
+  it("does not add subdomains to plain localhost", () => {
+    process.env.TDK_SERVICE_BASE_URL = "http://localhost:8080";
+    expect(resolveSubdomainBases()).toEqual({
+      appBase: "http://localhost:8080",
+      apiBase: "http://localhost:8080",
+    });
+  });
+});
+
+describe("resolveServicePath", () => {
+  it("strips the -api suffix for backends", () => {
+    expect(resolveServicePath(resource("menu-api", "backend"))).toBe("/api/menu");
+  });
+
+  it("prefers an explicit apiPath", () => {
+    expect(resolveServicePath(resource("menu-api", "backend", { apiPath: "/api/v2/menu" }))).toBe(
+      "/api/v2/menu",
+    );
+  });
+
+  it("prefers an explicit basePath for frontends", () => {
+    expect(resolveServicePath(resource("floor-app", "frontend", { basePath: "/floor" }))).toBe(
+      "/floor",
+    );
+  });
+
+  it("falls back to the service name for frontends", () => {
+    expect(resolveServicePath(resource("floor-app", "frontend"))).toBe("/floor-app");
+  });
+});
+
+describe("buildHealthTargets", () => {
+  const original = process.env.TDK_SERVICE_BASE_URL;
+
+  beforeEach(() => {
+    process.env.TDK_SERVICE_BASE_URL = "http://demo.localhost";
+  });
+
+  afterEach(() => {
+    if (original === undefined) {
+      delete process.env.TDK_SERVICE_BASE_URL;
+    } else {
+      process.env.TDK_SERVICE_BASE_URL = original;
+    }
+  });
+
+  it("routes frontends to app.* and backends to api.*", () => {
+    const targets = buildHealthTargets([
+      resource("floor-app", "frontend"),
+      resource("menu-api", "backend"),
+    ]);
+
+    expect(targets).toEqual([
+      { name: "floor-app", appType: "frontend", url: "http://app.demo.localhost/floor-app/health" },
+      { name: "menu-api", appType: "backend", url: "http://api.demo.localhost/api/menu/health" },
+    ]);
+  });
+
+  it("skips services that have no Traefik route", () => {
+    const targets = buildHealthTargets([
+      resource("kitchen-worker", "worker"),
+      resource("shared-lib", "library"),
+      resource("client-sdk", "sdk"),
+      resource("db-migrator", "migrator"),
+      resource("menu-api", "backend"),
+    ]);
+
+    expect(targets.map((t) => t.name)).toEqual(["menu-api"]);
+  });
+});
+
+describe("pingHealthTarget", () => {
+  const target = { name: "menu-api", appType: "backend" as const, url: "http://api/health" };
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("reports ok for a 2xx response", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => new Response("{}", { status: 200 })),
+    );
+    await expect(pingHealthTarget(target, 100)).resolves.toMatchObject({ ok: true, status: 200 });
+  });
+
+  it("reports the status code for a non-2xx response", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => new Response("nope", { status: 404 })),
+    );
+    await expect(pingHealthTarget(target, 100)).resolves.toMatchObject({ ok: false, status: 404 });
+  });
+
+  it("captures the reason when the request never completes", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        throw new Error("connect ECONNREFUSED");
+      }),
+    );
+    const probe = await pingHealthTarget(target, 100);
+    expect(probe.ok).toBe(false);
+    expect(probe.status).toBeUndefined();
+    expect(probe.error).toContain("ECONNREFUSED");
+  });
+
+  it("reports a timeout as a timeout", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => {
+        const err = new Error("timed out");
+        err.name = "TimeoutError";
+        throw err;
+      }),
+    );
+    await expect(pingHealthTarget(target, 100)).resolves.toMatchObject({
+      ok: false,
+      error: "no response within 100ms",
+    });
+  });
+});