@typokit/cli 0.1.4

package/src/dev.test.ts

@@ -0,0 +1,285 @@
+// @typokit/cli — Dev Command Tests
+
+import { describe, it, expect } from "@rstest/core";
+import {
+  createDevState,
+  detectChangedFiles,
+  updateTrackedFiles,
+  buildDepGraph,
+  getAffectedOutputs,
+  isCacheValid,
+  updateCache,
+} from "./commands/dev.js";
+import { parseArgs } from "./index.js";
+
+// ─── createDevState ─────────────────────────────────────────
+
+describe("createDevState", () => {
+  it("creates initial state with defaults", () => {
+    const state = createDevState();
+    expect(state.running).toBe(false);
+    expect(state.stopWatcher).toBe(null);
+    expect(state.trackedFiles.size).toBe(0);
+    expect(state.depGraph.size).toBe(0);
+    expect(state.astCache.size).toBe(0);
+    expect(state.rebuildCount).toBe(0);
+    expect(state.lastRebuildMs).toBe(0);
+    expect(state.serverPid).toBe(null);
+  });
+});
+
+// ─── detectChangedFiles ─────────────────────────────────────
+
+describe("detectChangedFiles", () => {
+  it("detects added files", () => {
+    const state = createDevState();
+    const currentFiles = [
+      { path: "/src/a.ts", mtime: 1000 },
+      { path: "/src/b.ts", mtime: 2000 },
+    ];
+    const result = detectChangedFiles(state, currentFiles);
+    expect(result.added.length).toBe(2);
+    expect(result.changed.length).toBe(0);
+    expect(result.removed.length).toBe(0);
+  });
+
+  it("detects changed files by mtime", () => {
+    const state = createDevState();
+    state.trackedFiles.set("/src/a.ts", { path: "/src/a.ts", mtime: 1000 });
+    state.trackedFiles.set("/src/b.ts", { path: "/src/b.ts", mtime: 2000 });
+
+    const currentFiles = [
+      { path: "/src/a.ts", mtime: 1500 }, // changed
+      { path: "/src/b.ts", mtime: 2000 }, // unchanged
+    ];
+
+    const result = detectChangedFiles(state, currentFiles);
+    expect(result.changed.length).toBe(1);
+    expect(result.changed[0].path).toBe("/src/a.ts");
+    expect(result.added.length).toBe(0);
+    expect(result.removed.length).toBe(0);
+  });
+
+  it("detects removed files", () => {
+    const state = createDevState();
+    state.trackedFiles.set("/src/a.ts", { path: "/src/a.ts", mtime: 1000 });
+    state.trackedFiles.set("/src/b.ts", { path: "/src/b.ts", mtime: 2000 });
+
+    const currentFiles = [{ path: "/src/a.ts", mtime: 1000 }];
+
+    const result = detectChangedFiles(state, currentFiles);
+    expect(result.removed.length).toBe(1);
+    expect(result.removed[0]).toBe("/src/b.ts");
+  });
+
+  it("handles mixed changes", () => {
+    const state = createDevState();
+    state.trackedFiles.set("/src/a.ts", { path: "/src/a.ts", mtime: 1000 });
+    state.trackedFiles.set("/src/b.ts", { path: "/src/b.ts", mtime: 2000 });
+
+    const currentFiles = [
+      { path: "/src/a.ts", mtime: 1500 }, // changed
+      { path: "/src/c.ts", mtime: 3000 }, // added
+      // /src/b.ts removed
+    ];
+
+    const result = detectChangedFiles(state, currentFiles);
+    expect(result.changed.length).toBe(1);
+    expect(result.added.length).toBe(1);
+    expect(result.removed.length).toBe(1);
+  });
+});
+
+// ─── updateTrackedFiles ─────────────────────────────────────
+
+describe("updateTrackedFiles", () => {
+  it("replaces all tracked files", () => {
+    const state = createDevState();
+    state.trackedFiles.set("/old.ts", { path: "/old.ts", mtime: 100 });
+
+    updateTrackedFiles(state, [
+      { path: "/src/a.ts", mtime: 1000 },
+      { path: "/src/b.ts", mtime: 2000 },
+    ]);
+
+    expect(state.trackedFiles.size).toBe(2);
+    expect(state.trackedFiles.has("/old.ts")).toBe(false);
+    expect(state.trackedFiles.has("/src/a.ts")).toBe(true);
+    expect(state.trackedFiles.has("/src/b.ts")).toBe(true);
+  });
+});
+
+// ─── buildDepGraph ──────────────────────────────────────────
+
+describe("buildDepGraph", () => {
+  it("maps type files to validator and schema outputs", () => {
+    const graph = buildDepGraph(["/src/types.ts"], []);
+    const entry = graph.get("/src/types.ts");
+    expect(entry).toBeDefined();
+    expect(entry!.category).toBe("type");
+    expect(entry!.affectedOutputs).toContain("validators");
+    expect(entry!.affectedOutputs).toContain("schemas/openapi.json");
+  });
+
+  it("maps route files to router, schema, and test outputs", () => {
+    const graph = buildDepGraph([], ["/src/routes.ts"]);
+    const entry = graph.get("/src/routes.ts");
+    expect(entry).toBeDefined();
+    expect(entry!.category).toBe("route");
+    expect(entry!.affectedOutputs).toContain("routes/compiled-router.ts");
+    expect(entry!.affectedOutputs).toContain("schemas/openapi.json");
+    expect(entry!.affectedOutputs).toContain("tests/contract.test.ts");
+  });
+
+  it("handles both type and route files", () => {
+    const graph = buildDepGraph(["/src/types.ts"], ["/src/routes.ts"]);
+    expect(graph.size).toBe(2);
+  });
+});
+
+// ─── getAffectedOutputs ────────────────────────────────────
+
+describe("getAffectedOutputs", () => {
+  it("returns affected outputs for changed type file", () => {
+    const graph = buildDepGraph(["/src/types.ts"], ["/src/routes.ts"]);
+    const affected = getAffectedOutputs(graph, ["/src/types.ts"]);
+    expect(affected.has("validators")).toBe(true);
+    expect(affected.has("schemas/openapi.json")).toBe(true);
+  });
+
+  it("returns affected outputs for changed route file", () => {
+    const graph = buildDepGraph(["/src/types.ts"], ["/src/routes.ts"]);
+    const affected = getAffectedOutputs(graph, ["/src/routes.ts"]);
+    expect(affected.has("routes/compiled-router.ts")).toBe(true);
+    expect(affected.has("tests/contract.test.ts")).toBe(true);
+  });
+
+  it("merges outputs for multiple changed files", () => {
+    const graph = buildDepGraph(["/src/types.ts"], ["/src/routes.ts"]);
+    const affected = getAffectedOutputs(graph, [
+      "/src/types.ts",
+      "/src/routes.ts",
+    ]);
+    expect(affected.has("validators")).toBe(true);
+    expect(affected.has("routes/compiled-router.ts")).toBe(true);
+    expect(affected.has("schemas/openapi.json")).toBe(true);
+  });
+
+  it("returns empty set for unknown files", () => {
+    const graph = buildDepGraph(["/src/types.ts"], []);
+    const affected = getAffectedOutputs(graph, ["/src/unknown.ts"]);
+    expect(affected.size).toBe(0);
+  });
+});
+
+// ─── AST Cache ──────────────────────────────────────────────
+
+describe("isCacheValid", () => {
+  it("returns false for uncached file", () => {
+    const cache = new Map();
+    expect(isCacheValid(cache, "/src/a.ts", 1000)).toBe(false);
+  });
+
+  it("returns true when mtime matches", () => {
+    const cache = new Map();
+    updateCache(cache, "/src/a.ts", 1000);
+    expect(isCacheValid(cache, "/src/a.ts", 1000)).toBe(true);
+  });
+
+  it("returns false when mtime differs", () => {
+    const cache = new Map();
+    updateCache(cache, "/src/a.ts", 1000);
+    expect(isCacheValid(cache, "/src/a.ts", 2000)).toBe(false);
+  });
+});
+
+describe("updateCache", () => {
+  it("stores cache entry with mtime and hash", () => {
+    const cache = new Map();
+    updateCache(cache, "/src/a.ts", 1000);
+    const entry = cache.get("/src/a.ts");
+    expect(entry).toBeDefined();
+    expect(entry.mtime).toBe(1000);
+    expect(typeof entry.hash).toBe("string");
+    expect(entry.hash.length).toBeGreaterThan(0);
+  });
+
+  it("overwrites existing cache entry", () => {
+    const cache = new Map();
+    updateCache(cache, "/src/a.ts", 1000);
+    updateCache(cache, "/src/a.ts", 2000);
+    const entry = cache.get("/src/a.ts");
+    expect(entry.mtime).toBe(2000);
+  });
+});
+
+// ─── parseArgs: dev command ─────────────────────────────────
+
+describe("parseArgs dev command", () => {
+  it("parses dev command", () => {
+    const result = parseArgs(["node", "typokit", "dev"]);
+    expect(result.command).toBe("dev");
+  });
+
+  it("parses --debug-port flag", () => {
+    const result = parseArgs([
+      "node",
+      "typokit",
+      "dev",
+      "--debug-port",
+      "9900",
+    ]);
+    expect(result.command).toBe("dev");
+    expect(result.flags["debug-port"]).toBe("9900");
+  });
+
+  it("parses dev with --verbose", () => {
+    const result = parseArgs(["node", "typokit", "dev", "--verbose"]);
+    expect(result.command).toBe("dev");
+    expect(result.flags["verbose"]).toBe(true);
+  });
+
+  it("parses dev with multiple flags", () => {
+    const result = parseArgs([
+      "node",
+      "typokit",
+      "dev",
+      "--verbose",
+      "--debug-port",
+      "8080",
+      "--root",
+      "/my/project",
+    ]);
+    expect(result.command).toBe("dev");
+    expect(result.flags["verbose"]).toBe(true);
+    expect(result.flags["debug-port"]).toBe("8080");
+    expect(result.flags["root"]).toBe("/my/project");
+  });
+});
+
+// ─── DevServerState ─────────────────────────────────────────
+
+describe("DevServerState lifecycle", () => {
+  it("tracks rebuild count", () => {
+    const state = createDevState();
+    expect(state.rebuildCount).toBe(0);
+    state.rebuildCount++;
+    expect(state.rebuildCount).toBe(1);
+  });
+
+  it("tracks last rebuild duration", () => {
+    const state = createDevState();
+    expect(state.lastRebuildMs).toBe(0);
+    state.lastRebuildMs = 42;
+    expect(state.lastRebuildMs).toBe(42);
+  });
+
+  it("running flag controls watcher lifecycle", () => {
+    const state = createDevState();
+    expect(state.running).toBe(false);
+    state.running = true;
+    expect(state.running).toBe(true);
+    state.running = false;
+    expect(state.running).toBe(false);
+  });
+});

package/src/env.d.ts

@@ -0,0 +1,86 @@
+// Minimal type declarations for Node.js APIs used by @typokit/cli
+// Avoids adding @types/node as a dependency
+
+declare module "module" {
+  export function createRequire(url: string | URL): (id: string) => unknown;
+}
+
+declare module "path" {
+  export function join(...paths: string[]): string;
+  export function dirname(p: string): string;
+  export function resolve(...paths: string[]): string;
+  export function relative(from: string, to: string): string;
+  export function basename(p: string, ext?: string): string;
+  export function extname(p: string): string;
+  export function isAbsolute(p: string): boolean;
+}
+
+declare module "fs" {
+  export function existsSync(path: string): boolean;
+  export function mkdirSync(
+    path: string,
+    options?: { recursive?: boolean },
+  ): void;
+  export function readFileSync(path: string, encoding: string): string;
+  export function writeFileSync(
+    path: string,
+    data: string,
+    encoding?: string,
+  ): void;
+  export function readdirSync(
+    path: string,
+    options?: { recursive?: boolean; withFileTypes?: boolean },
+  ): string[];
+  export function statSync(path: string): {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    mtimeMs: number;
+  };
+  export function rmSync(
+    path: string,
+    options?: { recursive?: boolean; force?: boolean },
+  ): void;
+  export function watch(
+    path: string,
+    options: { recursive?: boolean },
+    listener: (event: string, filename: string | null) => void,
+  ): { close(): void };
+}
+
+declare module "child_process" {
+  interface SpawnSyncResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+  }
+  export function spawnSync(
+    command: string,
+    args: string[],
+    options?: { cwd?: string; encoding?: string; stdio?: string | string[] },
+  ): SpawnSyncResult;
+}
+
+declare module "url" {
+  export function pathToFileURL(path: string): URL;
+  export function fileURLToPath(url: string | URL): string;
+}
+
+interface ImportMeta {
+  url: string;
+}
+
+declare module "http" {
+  interface IncomingMessage {
+    statusCode?: number;
+    on(event: string, cb: (data?: unknown) => void): void;
+    setEncoding(enc: string): void;
+  }
+  interface ClientRequest {
+    on(event: string, cb: (err: Error) => void): void;
+  }
+  export function get(
+    url: string,
+    cb: (res: IncomingMessage) => void,
+  ): ClientRequest;
+}

package/src/generate.test.ts

@@ -0,0 +1,304 @@
+// @typokit/cli — Generate Command Tests
+
+import { describe, it, expect } from "@rstest/core";
+import { createLogger } from "./index.js";
+import type {
+  GenerateCommandOptions,
+  GenerateResult,
+} from "./commands/generate.js";
+
+// ─── executeGenerate dispatcher ─────────────────────────────
+
+describe("executeGenerate", () => {
+  it("returns error for unknown subcommand", async () => {
+    const { executeGenerate } = await import("./commands/generate.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeGenerate({
+      rootDir: "/nonexistent",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger,
+      subcommand: "nonexistent",
+      flags: {},
+      verbose: false,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain("Unknown generate subcommand");
+  });
+
+  it("dispatches to generate:db", async () => {
+    const { executeGenerate } = await import("./commands/generate.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeGenerate({
+      rootDir: "/nonexistent/empty",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger,
+      subcommand: "db",
+      flags: {},
+      verbose: false,
+    });
+
+    // With no type files, should succeed with no output
+    expect(result.success).toBe(true);
+    expect(result.filesWritten).toEqual([]);
+  });
+
+  it("dispatches to generate:client", async () => {
+    const { executeGenerate } = await import("./commands/generate.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeGenerate({
+      rootDir: "/nonexistent/empty",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger,
+      subcommand: "client",
+      flags: {},
+      verbose: false,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.filesWritten).toEqual([]);
+  });
+
+  it("dispatches to generate:openapi", async () => {
+    const { executeGenerate } = await import("./commands/generate.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeGenerate({
+      rootDir: "/nonexistent/empty",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger,
+      subcommand: "openapi",
+      flags: {},
+      verbose: false,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.filesWritten).toEqual([]);
+  });
+
+  it("dispatches to generate:tests", async () => {
+    const { executeGenerate } = await import("./commands/generate.js");
+    const logger = createLogger({ verbose: false });
+
+    const result = await executeGenerate({
+      rootDir: "/nonexistent/empty",
+      config: {
+        typeFiles: [],
+        routeFiles: [],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger,
+      subcommand: "tests",
+      flags: {},
+      verbose: false,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.filesWritten).toEqual([]);
+  });
+});
+
+// ─── generateClientCode ──────────────────────────────────────
+
+describe("generateClientCode", () => {
+  it("generates a valid TypeScript client module", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// compiled routes here");
+    expect(code).toContain("export interface ClientOptions");
+    expect(code).toContain("export interface RequestOptions");
+    expect(code).toContain("export function createClient");
+    expect(code).toContain("baseUrl");
+  });
+
+  it("includes auto-generated header comment", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// routes");
+    expect(code).toContain("Auto-generated by @typokit/cli");
+    expect(code).toContain("do not edit manually");
+  });
+
+  it("includes HTTP methods (get, post, put, patch, delete)", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// routes");
+    expect(code).toContain('"GET"');
+    expect(code).toContain('"POST"');
+    expect(code).toContain('"PUT"');
+    expect(code).toContain('"PATCH"');
+    expect(code).toContain('"DELETE"');
+  });
+
+  it("includes query string serialization", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// routes");
+    expect(code).toContain("encodeURIComponent");
+  });
+
+  it("includes param substitution", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// routes");
+    expect(code).toContain("params");
+    expect(code).toContain("replace");
+  });
+
+  it("includes compiled route reference", async () => {
+    const { generateClientCode } = await import("./commands/generate.js");
+
+    const code = generateClientCode("// my-compiled-routes");
+    expect(code).toContain("my-compiled-routes");
+  });
+});
+
+// ─── GenerateResult interface shape ──────────────────────────
+
+describe("GenerateResult", () => {
+  it("has expected shape", () => {
+    const result: GenerateResult = {
+      success: true,
+      filesWritten: ["/some/path/file.ts"],
+      duration: 42,
+      errors: [],
+    };
+    expect(result.success).toBe(true);
+    expect(result.filesWritten.length).toBe(1);
+    expect(result.duration).toBe(42);
+    expect(result.errors.length).toBe(0);
+  });
+
+  it("works with errors", () => {
+    const result: GenerateResult = {
+      success: false,
+      filesWritten: [],
+      duration: 10,
+      errors: ["Something went wrong"],
+    };
+    expect(result.success).toBe(false);
+    expect(result.errors[0]).toBe("Something went wrong");
+  });
+});
+
+// ─── GenerateCommandOptions interface shape ──────────────────
+
+describe("GenerateCommandOptions", () => {
+  it("accepts all required fields", () => {
+    const opts: GenerateCommandOptions = {
+      rootDir: "/my/project",
+      config: {
+        typeFiles: ["src/**/*.types.ts"],
+        routeFiles: ["src/**/*.routes.ts"],
+        outputDir: ".typokit",
+        distDir: "dist",
+        compiler: "tsc",
+        compilerArgs: [],
+      },
+      logger: createLogger({ verbose: false }),
+      subcommand: "openapi",
+      flags: { output: "./dist/openapi.json" },
+      verbose: false,
+    };
+    expect(opts.subcommand).toBe("openapi");
+    expect(opts.flags["output"]).toBe("./dist/openapi.json");
+  });
+});
+
+// ─── CLI integration: parseArgs for generate commands ────────
+
+describe("parseArgs with generate commands", () => {
+  it("parses generate:openapi command", async () => {
+    const { parseArgs } = await import("./index.js");
+    const result = parseArgs([
+      "node",
+      "typokit",
+      "generate:openapi",
+      "--output",
+      "./dist/api.json",
+    ]);
+    expect(result.command).toBe("generate:openapi");
+    expect(result.flags["output"]).toBe("./dist/api.json");
+  });
+
+  it("parses generate:db command", async () => {
+    const { parseArgs } = await import("./index.js");
+    const result = parseArgs(["node", "typokit", "generate:db", "--verbose"]);
+    expect(result.command).toBe("generate:db");
+    expect(result.flags["verbose"]).toBe(true);
+  });
+
+  it("parses generate:client command", async () => {
+    const { parseArgs } = await import("./index.js");
+    const result = parseArgs(["node", "typokit", "generate:client"]);
+    expect(result.command).toBe("generate:client");
+  });
+
+  it("parses generate:tests command", async () => {
+    const { parseArgs } = await import("./index.js");
+    const result = parseArgs([
+      "node",
+      "typokit",
+      "generate:tests",
+      "--root",
+      "/my/project",
+    ]);
+    expect(result.command).toBe("generate:tests");
+    expect(result.flags["root"]).toBe("/my/project");
+  });
+});
+
+// ─── resolveFilePatterns ─────────────────────────────────────
+
+describe("resolveGenerateFilePatterns", () => {
+  it("returns empty array for nonexistent dir patterns", async () => {
+    const { resolveGenerateFilePatterns } =
+      await import("./commands/generate.js");
+    const files = await resolveGenerateFilePatterns("/nonexistent/dir", [
+      "src/**/*.ts",
+    ]);
+    expect(files).toEqual([]);
+  });
+
+  it("returns empty for empty patterns", async () => {
+    const { resolveGenerateFilePatterns } =
+      await import("./commands/generate.js");
+    const files = await resolveGenerateFilePatterns("/nonexistent", []);
+    expect(files).toEqual([]);
+  });
+});