@intentius/chant-lexicon-aws 0.0.2

package/src/codegen/typecheck.test.ts

@@ -0,0 +1,50 @@
+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);
+  });
+
+  test("passes fixture-generated .d.ts", async () => {
+    const { loadSchemaFixtures } = await import("../testdata/load-fixtures");
+    const { generate } = await import("./generate");
+    const fixtures = loadSchemaFixtures();
+    const genResult = await generate({ schemaSource: fixtures });
+
+    const result = await typecheckDTS(genResult.typesDTS);
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      console.error("Diagnostics:", result.diagnostics);
+    }
+  });
+});

package/src/codegen/typecheck.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export from core — typecheck is lexicon-agnostic.
+ */
+export { typecheckDTS, type TypeCheckResult } from "@intentius/chant/codegen/typecheck";

package/src/codegen/versions.ts

@@ -0,0 +1,37 @@
+/**
+ * Pinned dependency versions for reproducible generation.
+ */
+
+export const PINNED_VERSIONS = {
+  cfnLint: "v1.32.4",
+} as const;
+
+/**
+ * Build the cfn-lint tarball URL for a given version tag.
+ */
+export function cfnLintTarballUrl(version?: string): string {
+  const tag = version ?? PINNED_VERSIONS.cfnLint;
+  return `https://github.com/aws-cloudformation/cfn-lint/archive/refs/tags/${tag}.tar.gz`;
+}
+
+/**
+ * Check for newer versions of pinned dependencies.
+ */
+export async function checkForUpdates(): Promise<{ cfnLint: { current: string; latest: string } }> {
+  const current = PINNED_VERSIONS.cfnLint;
+  let latest: string = current;
+
+  try {
+    const resp = await fetch("https://api.github.com/repos/aws-cloudformation/cfn-lint/releases/latest", {
+      headers: { Accept: "application/vnd.github.v3+json" },
+    });
+    if (resp.ok) {
+      const data = await resp.json() as { tag_name: string };
+      latest = data.tag_name;
+    }
+  } catch {
+    // Network failure — return current as latest
+  }
+
+  return { cfnLint: { current, latest } };
+}

package/src/coverage.ts

@@ -0,0 +1,14 @@
+/**
+ * Re-export from core — coverage analysis is lexicon-agnostic.
+ */
+export {
+  computeCoverage,
+  overallPct,
+  formatSummary,
+  formatVerbose,
+  checkThresholds,
+  type ResourceCoverage,
+  type CoverageReport,
+  type CoverageThresholds,
+  type ThresholdResult,
+} from "@intentius/chant/codegen/coverage";