@intentius/chant-lexicon-gitlab 0.0.3 → 0.0.6

package/src/validate.test.ts

@@ -6,38 +6,29 @@ import { fileURLToPath } from "url";
 const basePath = dirname(dirname(fileURLToPath(import.meta.url)));
 
 describe("validate", () => {
-  test("passes validation for current generated artifacts", async () => {
+  test("runs validation checks on current generated artifacts", async () => {
     const result = await validate({ basePath });
-    expect(result.success).toBe(true);
     expect(result.checks.length).toBeGreaterThan(0);
   });
 
-  test("checks all expected entities are present", async () => {
+  test("checks lexicon JSON exists and parses", async () => {
     const result = await validate({ basePath });
-    const checkNames = result.checks.map((c) => c.name);
-    expect(checkNames).toContain("resource Job present");
-    expect(checkNames).toContain("resource Default present");
-    expect(checkNames).toContain("resource Workflow present");
-    expect(checkNames).toContain("property Artifacts present");
-    expect(checkNames).toContain("property Cache present");
-    expect(checkNames).toContain("property Image present");
+    const jsonCheck = result.checks.find((c) => c.name === "lexicon-json-exists");
+    expect(jsonCheck).toBeDefined();
+    expect(jsonCheck?.ok).toBe(true);
   });
 
-  test("checks file existence", async () => {
+  test("checks types exist", async () => {
     const result = await validate({ basePath });
-    const fileChecks = result.checks.filter((c) => c.name.endsWith("exists"));
-    expect(fileChecks.length).toBeGreaterThan(0);
-    for (const check of fileChecks) {
-      expect(check.ok).toBe(true);
-    }
+    const typesCheck = result.checks.find((c) => c.name === "types-exist");
+    expect(typesCheck).toBeDefined();
+    expect(typesCheck?.ok).toBe(true);
   });
 
-  test("checks index.d.ts class declarations", async () => {
+  test("checks required names are present", async () => {
     const result = await validate({ basePath });
-    const dtsChecks = result.checks.filter((c) => c.name.startsWith("index.d.ts declares"));
-    expect(dtsChecks.length).toBeGreaterThan(0);
-    for (const check of dtsChecks) {
-      expect(check.ok).toBe(true);
-    }
+    const requiredCheck = result.checks.find((c) => c.name === "required-names");
+    expect(requiredCheck).toBeDefined();
+    expect(requiredCheck?.ok).toBe(true);
   });
 });

package/src/validate.ts

@@ -1,125 +1,34 @@
 /**
- * Semantic validation for GitLab CI lexicon artifacts.
+ * Validate generated lexicon-gitlab artifacts.
  *
- * Checks that generated files exist, contain expected entities,
- * and pass basic structural validation.
+ * Thin wrapper around the core validation framework
+ * with GitLab-specific configuration.
  */
 
-import { existsSync, readFileSync } from "fs";
-import { join, dirname } from "path";
+import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { validateLexiconArtifacts, type ValidateResult } from "@intentius/chant/codegen/validate";
 
-export interface ValidateCheck {
-  name: string;
-  ok: boolean;
-  error?: string;
-}
-
-export interface ValidateResult {
-  success: boolean;
-  checks: ValidateCheck[];
-}
+export type { ValidateCheck, ValidateResult } from "@intentius/chant/codegen/validate";
 
-const EXPECTED_RESOURCES = ["Job", "Default", "Workflow"];
-const EXPECTED_PROPERTIES = [
-  "Artifacts", "Cache", "Image", "Rule", "Retry",
+const REQUIRED_NAMES = [
+  "Job", "Default", "Workflow",
+  "Artifacts", "Cache", "Image", "Service", "Rule", "Retry",
   "AllowFailure", "Parallel", "Include", "Release",
   "Environment", "Trigger", "AutoCancel",
 ];
 
 /**
- * Validate lexicon artifacts.
+ * Validate the generated lexicon-gitlab artifacts.
+ *
+ * @param opts.basePath - Override the package directory (defaults to lexicon-gitlab package root)
  */
 export async function validate(opts?: { basePath?: string }): Promise<ValidateResult> {
   const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
-  const generatedDir = join(basePath, "src", "generated");
-  const checks: ValidateCheck[] = [];
-
-  // Check files exist
-  for (const file of ["lexicon-gitlab.json", "index.d.ts", "index.ts", "runtime.ts"]) {
-    const path = join(generatedDir, file);
-    checks.push({
-      name: `${file} exists`,
-      ok: existsSync(path),
-      error: existsSync(path) ? undefined : `File not found: ${path}`,
-    });
-  }
-
-  // Validate lexicon JSON structure
-  const lexiconPath = join(generatedDir, "lexicon-gitlab.json");
-  if (existsSync(lexiconPath)) {
-    try {
-      const content = readFileSync(lexiconPath, "utf-8");
-      const registry = JSON.parse(content);
-      const entries = Object.keys(registry);
-
-      // Check expected count
-      const expectedCount = EXPECTED_RESOURCES.length + EXPECTED_PROPERTIES.length;
-      checks.push({
-        name: `lexicon-gitlab.json has ${expectedCount} entries`,
-        ok: entries.length === expectedCount,
-        error: entries.length !== expectedCount
-          ? `Expected ${expectedCount} entries, found ${entries.length}`
-          : undefined,
-      });
-
-      // Check resource entities present
-      for (const name of EXPECTED_RESOURCES) {
-        const entry = registry[name];
-        const ok = entry !== undefined && entry.kind === "resource";
-        checks.push({
-          name: `resource ${name} present`,
-          ok,
-          error: ok ? undefined : `Missing or invalid resource entry: ${name}`,
-        });
-      }
-
-      // Check property entities present
-      for (const name of EXPECTED_PROPERTIES) {
-        const entry = registry[name];
-        const ok = entry !== undefined && entry.kind === "property";
-        checks.push({
-          name: `property ${name} present`,
-          ok,
-          error: ok ? undefined : `Missing or invalid property entry: ${name}`,
-        });
-      }
-
-      // Check all entries have required fields
-      for (const [name, entry] of Object.entries(registry)) {
-        const e = entry as Record<string, unknown>;
-        const hasRequired = e.resourceType && e.kind && e.lexicon === "gitlab";
-        checks.push({
-          name: `${name} has required fields`,
-          ok: !!hasRequired,
-          error: hasRequired ? undefined : `Entry ${name} missing required fields`,
-        });
-      }
-    } catch (err) {
-      checks.push({
-        name: "lexicon-gitlab.json is valid JSON",
-        ok: false,
-        error: `Parse error: ${err}`,
-      });
-    }
-  }
-
-  // Validate index.d.ts has class declarations
-  const dtsPath = join(generatedDir, "index.d.ts");
-  if (existsSync(dtsPath)) {
-    const dts = readFileSync(dtsPath, "utf-8");
-    for (const name of [...EXPECTED_RESOURCES, ...EXPECTED_PROPERTIES]) {
-      const has = dts.includes(`export declare class ${name}`);
-      checks.push({
-        name: `index.d.ts declares ${name}`,
-        ok: has,
-        error: has ? undefined : `Missing class declaration: ${name}`,
-      });
-    }
-  }
 
-  return {
-    success: checks.every((c) => c.ok),
-    checks,
-  };
+  return validateLexiconArtifacts({
+    lexiconJsonFilename: "lexicon-gitlab.json",
+    requiredNames: REQUIRED_NAMES,
+    basePath,
+  });
 }