@intentius/chant 0.0.1

package/src/codegen/typecheck.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "bun:test";
+import { typecheckDTS } from "./typecheck";
+
+describe("typecheckDTS", () => {
+  test("passes valid .d.ts", async () => {
+    const content = `
+      export declare class Bucket {
+        readonly type: string;
+        readonly bucketName?: string;
+      }
+    `;
+    const result = await typecheckDTS(content);
+    expect(result.ok).toBe(true);
+    expect(result.diagnostics).toHaveLength(0);
+  });
+
+  test("fails on undefined type reference", async () => {
+    const content = `
+      export declare class Broken {
+        readonly value: UndefinedType;
+      }
+    `;
+    const result = await typecheckDTS(content);
+    expect(result.ok).toBe(false);
+    expect(result.diagnostics.length).toBeGreaterThan(0);
+  });
+
+  test("fails on syntax error", async () => {
+    const content = `
+      export declare class {
+        this is not valid typescript
+      }
+    `;
+    const result = await typecheckDTS(content);
+    expect(result.ok).toBe(false);
+  });
+});

package/src/codegen/typecheck.ts

@@ -0,0 +1,74 @@
+/**
+ * Type-check generated .d.ts files by spawning tsc.
+ */
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+export interface TypeCheckResult {
+  ok: boolean;
+  diagnostics: string[];
+  fileCount: number;
+}
+
+/**
+ * Type-check a .d.ts content string by writing to a temp file and running tsc.
+ */
+export async function typecheckDTS(content: string): Promise<TypeCheckResult> {
+  // Create temp directory
+  const dir = join(tmpdir(), `chant-typecheck-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+
+  try {
+    // Write the .d.ts file
+    const dtsPath = join(dir, "index.d.ts");
+    writeFileSync(dtsPath, content);
+
+    // Write a minimal tsconfig
+    const tsconfig = {
+      compilerOptions: {
+        strict: true,
+        noEmit: true,
+        skipLibCheck: false,
+        target: "ES2022",
+        module: "ES2022",
+        moduleResolution: "bundler",
+      },
+      include: ["index.d.ts"],
+    };
+    writeFileSync(join(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+
+    // Run tsc
+    const proc = Bun.spawn(["bunx", "tsc", "--noEmit", "--project", "tsconfig.json"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+
+    // Parse diagnostics from stdout (tsc writes errors to stdout)
+    const output = stdout + stderr;
+    const diagnostics = output
+      .split("\n")
+      .filter((line) => line.trim().length > 0)
+      .filter((line) => /error TS\d+/.test(line) || /:\d+:\d+/.test(line));
+
+    return {
+      ok: exitCode === 0,
+      diagnostics,
+      fileCount: 1,
+    };
+  } finally {
+    // Cleanup
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // Best effort cleanup
+    }
+  }
+}

package/src/codegen/validate.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { validateLexiconArtifacts } from "./validate";
+
+function makeTempDir(): string {
+  const dir = join(tmpdir(), `chant-validate-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("validateLexiconArtifacts", () => {
+  test("fails when lexicon JSON is missing", async () => {
+    const dir = makeTempDir();
+    const genDir = join(dir, "src", "generated");
+    mkdirSync(genDir, { recursive: true });
+
+    const result = await validateLexiconArtifacts({
+      lexiconJsonFilename: "lexicon-test.json",
+      requiredNames: ["Resource"],
+      basePath: dir,
+    });
+
+    expect(result.success).toBe(false);
+    const jsonCheck = result.checks.find((c) => c.name === "lexicon-json-exists");
+    expect(jsonCheck?.ok).toBe(false);
+    expect(jsonCheck?.error).toContain("lexicon-test.json not found");
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("passes with valid artifacts and required names", async () => {
+    const dir = makeTempDir();
+    const genDir = join(dir, "src", "generated");
+    mkdirSync(genDir, { recursive: true });
+
+    const lexiconData = {
+      Resource: {
+        resourceType: "Test::Storage::Bucket",
+        kind: "resource",
+        lexicon: "test",
+        attrs: { arn: "Arn" },
+        createOnly: ["/properties/Name"],
+        propertyConstraints: { Name: { minLength: 1 } },
+        constraints: [{ name: "c1", type: "required_or" }],
+      },
+    };
+    writeFileSync(join(genDir, "lexicon-test.json"), JSON.stringify(lexiconData));
+    writeFileSync(join(genDir, "index.d.ts"), "export declare class Resource { readonly type: string; }");
+
+    const result = await validateLexiconArtifacts({
+      lexiconJsonFilename: "lexicon-test.json",
+      requiredNames: ["Resource"],
+      basePath: dir,
+      coverageThresholds: { minPropertyPct: 1 },
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.checks.every((c) => c.ok)).toBe(true);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("detects missing required names", async () => {
+    const dir = makeTempDir();
+    const genDir = join(dir, "src", "generated");
+    mkdirSync(genDir, { recursive: true });
+
+    writeFileSync(join(genDir, "lexicon-test.json"), JSON.stringify({ Foo: { resourceType: "T", kind: "resource", lexicon: "t" } }));
+    writeFileSync(join(genDir, "index.d.ts"), "export {};");
+
+    const result = await validateLexiconArtifacts({
+      lexiconJsonFilename: "lexicon-test.json",
+      requiredNames: ["Bar", "Baz"],
+      basePath: dir,
+    });
+
+    const namesCheck = result.checks.find((c) => c.name === "required-names");
+    expect(namesCheck?.ok).toBe(false);
+    expect(namesCheck?.error).toContain("Bar");
+    expect(namesCheck?.error).toContain("Baz");
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+});

package/src/codegen/validate.ts

@@ -0,0 +1,143 @@
+/**
+ * Generic validation framework for lexicon artifacts.
+ *
+ * Provides configurable validation checks that any lexicon can use
+ * by passing lexicon-specific configuration.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { computeCoverage, checkThresholds, type CoverageThresholds } from "./coverage";
+
+export interface ValidateCheck {
+  name: string;
+  ok: boolean;
+  error?: string;
+}
+
+export interface ValidateResult {
+  success: boolean;
+  checks: ValidateCheck[];
+}
+
+export interface LexiconValidationConfig {
+  /** Filename of the lexicon JSON (e.g. "lexicon-mydom.json") */
+  lexiconJsonFilename: string;
+  /** Required backward-compatible export names to check in lexicon JSON */
+  requiredNames: string[];
+  /** Base path of the lexicon package */
+  basePath: string;
+  /** Path to the generated directory (defaults to basePath/src/generated) */
+  generatedDir?: string;
+  /** Coverage thresholds (optional) */
+  coverageThresholds?: CoverageThresholds;
+}
+
+/**
+ * Validate generated lexicon artifacts using the provided configuration.
+ */
+export async function validateLexiconArtifacts(config: LexiconValidationConfig): Promise<ValidateResult> {
+  const generatedDir = config.generatedDir ?? join(config.basePath, "src", "generated");
+  const checks: ValidateCheck[] = [];
+
+  // Check 1: lexicon JSON exists and parses
+  const lexiconPath = join(generatedDir, config.lexiconJsonFilename);
+  let lexiconData: Record<string, unknown> | null = null;
+
+  if (!existsSync(lexiconPath)) {
+    checks.push({ name: "lexicon-json-exists", ok: false, error: `${config.lexiconJsonFilename} not found` });
+  } else {
+    try {
+      const raw = readFileSync(lexiconPath, "utf-8");
+      lexiconData = JSON.parse(raw);
+      checks.push({ name: "lexicon-json-exists", ok: true });
+    } catch (err) {
+      checks.push({
+        name: "lexicon-json-exists",
+        ok: false,
+        error: `Failed to parse ${config.lexiconJsonFilename}: ${err instanceof Error ? err.message : String(err)}`,
+      });
+    }
+  }
+
+  // Check 2: index.d.ts exists
+  const dtsPath = join(generatedDir, "index.d.ts");
+  if (!existsSync(dtsPath)) {
+    checks.push({ name: "types-exist", ok: false, error: "index.d.ts not found" });
+  } else {
+    checks.push({ name: "types-exist", ok: true });
+  }
+
+  // Check 3: Required backward-compatible names present in lexicon JSON
+  if (lexiconData && config.requiredNames.length > 0) {
+    const missing = config.requiredNames.filter((name) => !(name in lexiconData!));
+    if (missing.length > 0) {
+      checks.push({
+        name: "required-names",
+        ok: false,
+        error: `Missing required names: ${missing.join(", ")}`,
+      });
+    } else {
+      checks.push({ name: "required-names", ok: true });
+    }
+  } else if (!lexiconData && config.requiredNames.length > 0) {
+    checks.push({
+      name: "required-names",
+      ok: false,
+      error: "Skipped — lexicon JSON not available",
+    });
+  }
+
+  // Check 4: Coverage thresholds (only if lexicon JSON was loaded)
+  if (lexiconData && config.coverageThresholds) {
+    try {
+      const raw = readFileSync(lexiconPath, "utf-8");
+      const report = computeCoverage(raw);
+      const result = checkThresholds(report, config.coverageThresholds);
+      if (result.ok) {
+        checks.push({ name: "coverage-thresholds", ok: true });
+      } else {
+        checks.push({
+          name: "coverage-thresholds",
+          ok: false,
+          error: result.violations.join("; "),
+        });
+      }
+    } catch (err) {
+      checks.push({
+        name: "coverage-thresholds",
+        ok: false,
+        error: `Coverage check failed: ${err instanceof Error ? err.message : String(err)}`,
+      });
+    }
+  }
+
+  // Check 5: Type-check generated .d.ts
+  if (existsSync(dtsPath)) {
+    try {
+      const { typecheckDTS } = await import("./typecheck");
+      const dtsContent = readFileSync(dtsPath, "utf-8");
+      const tcResult = await typecheckDTS(dtsContent);
+      if (tcResult.ok) {
+        checks.push({ name: "types-compile", ok: true });
+      } else {
+        checks.push({
+          name: "types-compile",
+          ok: false,
+          error: `TypeScript errors: ${tcResult.diagnostics.slice(0, 5).join("; ")}`,
+        });
+      }
+    } catch (err) {
+      checks.push({
+        name: "types-compile",
+        ok: false,
+        error: `Type-check failed: ${err instanceof Error ? err.message : String(err)}`,
+      });
+    }
+  }
+
+  return {
+    success: checks.every((c) => c.ok),
+    checks,
+  };
+}