@intentius/chant-lexicon-gitlab 0.0.8 → 0.0.10

package/src/serializer.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect } from "bun:test";
 import { gitlabSerializer } from "./serializer";
 import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+import { createProperty, createResource } from "@intentius/chant/runtime";
 
 // ── Mock entities ──────────────────────────────────────────────────
 
@@ -258,6 +259,145 @@ describe("string quoting", () => {
   });
 });
 
+describe("runtime-style entities (non-enumerable props)", () => {
+  // Real generated entities use createResource/createProperty which define
+  // DECLARABLE_MARKER, entityType, kind, and props as non-enumerable.
+  // Object.entries() skips non-enumerable properties — the serializer must
+  // handle these correctly.
+
+  const RuntimeImage = createProperty("GitLab::CI::Image", "gitlab");
+  const RuntimeCache = createProperty("GitLab::CI::Cache", "gitlab");
+  const RuntimeArtifacts = createProperty("GitLab::CI::Artifacts", "gitlab");
+  const RuntimeRule = createProperty("GitLab::CI::Rule", "gitlab");
+  const RuntimeEnvironment = createProperty("GitLab::CI::Environment", "gitlab");
+  const RuntimeJob = createResource("GitLab::CI::Job", "gitlab", {});
+
+  test("serializes runtime-style property entities in jobs", () => {
+    const image = new RuntimeImage({ name: "node:20-alpine" });
+    const cache = new RuntimeCache({
+      key: "$CI_COMMIT_REF_SLUG",
+      paths: ["node_modules/"],
+      policy: "pull-push",
+    });
+    const artifacts = new RuntimeArtifacts({
+      paths: ["dist/"],
+      expire_in: "1 hour",
+    });
+    const job = new RuntimeJob({
+      stage: "build",
+      image,
+      cache,
+      script: ["npm ci", "npm run build"],
+      artifacts,
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("build", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+
+    // Image must expand to its properties, not {}
+    expect(output).toContain("image:");
+    expect(output).toContain("name: node:20-alpine");
+    expect(output).not.toContain("image: {}");
+
+    // Cache must expand
+    expect(output).toContain("cache:");
+    expect(output).toContain("paths:");
+    expect(output).toContain("- node_modules/");
+    expect(output).not.toContain("cache: {}");
+
+    // Artifacts must expand
+    expect(output).toContain("artifacts:");
+    expect(output).toContain("- dist/");
+    expect(output).not.toContain("artifacts: {}");
+  });
+
+  test("serializes runtime-style rules array", () => {
+    const rule1 = new RuntimeRule({ if: "$CI_MERGE_REQUEST_IID" });
+    const rule2 = new RuntimeRule({ if: "$CI_COMMIT_BRANCH" });
+    const job = new RuntimeJob({
+      stage: "test",
+      script: ["npm test"],
+      rules: [rule1, rule2],
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("test", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("rules:");
+    expect(output).toContain("if: '$CI_MERGE_REQUEST_IID'");
+    expect(output).toContain("if: '$CI_COMMIT_BRANCH'");
+  });
+
+  test("serializes runtime-style environment", () => {
+    const env = new RuntimeEnvironment({
+      name: "production",
+      url: "https://example.com",
+    });
+    const job = new RuntimeJob({
+      stage: "deploy",
+      script: ["deploy.sh"],
+      environment: env,
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("deploy", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("environment:");
+    expect(output).toContain("name: production");
+    expect(output).toContain("url: https://example.com");
+    expect(output).not.toContain("environment: {}");
+  });
+});
+
+describe("array-of-objects YAML formatting", () => {
+  test("serializes cache array with nested key object correctly", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("job", new MockJob({
+      stage: "build",
+      script: ["npm ci"],
+      cache: [
+        {
+          key: { files: ["package-lock.json"] },
+          paths: [".npm/"],
+          policy: "pull-push",
+        },
+      ],
+    }));
+
+    const output = gitlabSerializer.serialize(entities);
+    // The key object should be on a new line, properly indented
+    expect(output).toContain("cache:");
+    expect(output).toContain("- key:");
+    expect(output).toContain("files:");
+    expect(output).toContain("- package-lock.json");
+    expect(output).toContain("paths:");
+    expect(output).toContain("- .npm/");
+    expect(output).toContain("policy: pull-push");
+    // The key value should NOT be inlined as "key: files:"
+    expect(output).not.toMatch(/key: files:/);
+  });
+
+  test("serializes services array with nested objects", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("job", new MockJob({
+      stage: "build",
+      script: ["docker build ."],
+      services: [
+        { name: "docker:27-dind", alias: "docker" },
+      ],
+    }));
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("services:");
+    expect(output).toContain("- name: docker:27-dind");
+    expect(output).toContain("alias: docker");
+  });
+});
+
 describe("nested objects and arrays", () => {
   test("serializes nested objects", () => {
     const entities = new Map<string, Declarable>();

package/src/serializer.ts

@@ -20,7 +20,7 @@ import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
 function gitlabVisitor(entityNames: Map<Declarable, string>): SerializerVisitor {
   return {
     attrRef: (name, _attr) => name,
-    resourceRef: (name) => name,
+    resourceRef: (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(),
     propertyDeclarable: (entity, walk) => {
       if (!("props" in entity) || typeof entity.props !== "object" || entity.props === null) {
         return undefined;
@@ -37,11 +37,49 @@ function gitlabVisitor(entityNames: Map<Declarable, string>): SerializerVisitor
   };
 }
 
+/**
+ * Pre-process values to convert intrinsics to their YAML representation
+ * before the walker (which would call toJSON instead of toYAML).
+ *
+ * IMPORTANT: Must not touch Declarable objects — their identity markers
+ * (DECLARABLE_MARKER, entityType, kind, props) are non-enumerable and
+ * would be stripped by Object.entries(), producing empty `{}` output.
+ */
+function preprocessIntrinsics(value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+
+  if (typeof value === "object" && INTRINSIC_MARKER in value) {
+    if ("toYAML" in value && typeof value.toYAML === "function") {
+      return (value as { toYAML(): unknown }).toYAML();
+    }
+  }
+
+  // Leave Declarables untouched — the walker handles them
+  if (typeof value === "object" && value !== null && "entityType" in value) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(preprocessIntrinsics);
+  }
+
+  if (typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      result[k] = preprocessIntrinsics(v);
+    }
+    return result;
+  }
+
+  return value;
+}
+
 /**
  * Convert a value to YAML-compatible form using the walker.
  */
 function toYAMLValue(value: unknown, entityNames: Map<Declarable, string>): unknown {
-  return walkValue(value, entityNames, gitlabVisitor(entityNames));
+  const preprocessed = preprocessIntrinsics(value);
+  return walkValue(preprocessed, entityNames, gitlabVisitor(entityNames));
 }
 
 /**
@@ -98,10 +136,21 @@ function emitYAML(value: unknown, indent: number): string {
         const entries = Object.entries(item as Record<string, unknown>);
         if (entries.length > 0) {
           const [firstKey, firstVal] = entries[0];
-          lines.push(`${prefix}- ${firstKey}: ${emitYAML(firstVal, indent + 2).trimStart()}`);
+          const firstEmitted = emitYAML(firstVal, indent + 2);
+          if (firstEmitted.startsWith("\n")) {
+            // Multi-line value: put on next line, indented under the key
+            lines.push(`${prefix}- ${firstKey}:${firstEmitted}`);
+          } else {
+            lines.push(`${prefix}- ${firstKey}: ${firstEmitted}`);
+          }
           for (let i = 1; i < entries.length; i++) {
             const [key, val] = entries[i];
-            lines.push(`${prefix}  ${key}: ${emitYAML(val, indent + 2).trimStart()}`);
+            const emitted = emitYAML(val, indent + 2);
+            if (emitted.startsWith("\n")) {
+              lines.push(`${prefix}  ${key}:${emitted}`);
+            } else {
+              lines.push(`${prefix}  ${key}: ${emitted}`);
+            }
           }
         }
       } else {
@@ -112,7 +161,16 @@ function emitYAML(value: unknown, indent: number): string {
   }
 
   if (typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>);
+    const obj = value as Record<string, unknown>;
+
+    // Handle tagged values (intrinsics like !reference)
+    if ("tag" in obj && "value" in obj && typeof obj.tag === "string") {
+      if (obj.tag === "!reference" && Array.isArray(obj.value)) {
+        return `!reference [${(obj.value as string[]).join(", ")}]`;
+      }
+    }
+
+    const entries = Object.entries(obj);
     if (entries.length === 0) return "{}";
     const lines: string[] = [];
     for (const [key, val] of entries) {

package/src/validate.ts

@@ -16,6 +16,7 @@ const REQUIRED_NAMES = [
   "Artifacts", "Cache", "Image", "Service", "Rule", "Retry",
   "AllowFailure", "Parallel", "Include", "Release",
   "Environment", "Trigger", "AutoCancel",
+  "WorkflowRule", "Need", "Inherit",
 ];
 
 /**

package/src/variables.ts

@@ -8,10 +8,12 @@
 export const CI = {
   CommitBranch: "$CI_COMMIT_BRANCH",
   CommitRef: "$CI_COMMIT_REF_NAME",
+  CommitRefSlug: "$CI_COMMIT_REF_SLUG",
   CommitSha: "$CI_COMMIT_SHA",
   CommitTag: "$CI_COMMIT_TAG",
   DefaultBranch: "$CI_DEFAULT_BRANCH",
   Environment: "$CI_ENVIRONMENT_NAME",
+  EnvironmentSlug: "$CI_ENVIRONMENT_SLUG",
   JobId: "$CI_JOB_ID",
   JobName: "$CI_JOB_NAME",
   JobStage: "$CI_JOB_STAGE",
@@ -24,4 +26,6 @@ export const CI = {
   ProjectPath: "$CI_PROJECT_PATH",
   Registry: "$CI_REGISTRY",
   RegistryImage: "$CI_REGISTRY_IMAGE",
+  RegistryUser: "$CI_REGISTRY_USER",
+  RegistryPassword: "$CI_REGISTRY_PASSWORD",
 } as const;