@intentius/chant-lexicon-gitlab 0.0.1

package/src/import/generator.test.ts

@@ -0,0 +1,151 @@
+import { describe, test, expect } from "bun:test";
+import { GitLabGenerator } from "./generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
+
+const generator = new GitLabGenerator();
+
+describe("GitLabGenerator", () => {
+  test("generates import statement", () => {
+    const ir: TemplateIR = {
+      resources: [
+        { logicalId: "testJob", type: "GitLab::CI::Job", properties: { script: ["test"] } },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe("main.ts");
+    expect(files[0].content).toContain('from "@intentius/chant-lexicon-gitlab"');
+    expect(files[0].content).toContain("Job");
+  });
+
+  test("generates Job constructor", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "buildJob",
+          type: "GitLab::CI::Job",
+          properties: {
+            stage: "build",
+            script: ["npm run build"],
+          },
+        },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    const content = files[0].content;
+    expect(content).toContain("export const buildJob = new Job(");
+    expect(content).toContain('stage: "build"');
+    expect(content).toContain('script: ["npm run build"]');
+  });
+
+  test("generates Default constructor", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "defaults",
+          type: "GitLab::CI::Default",
+          properties: { interruptible: true },
+        },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("export const defaults = new Default(");
+    expect(files[0].content).toContain("interruptible: true");
+  });
+
+  test("generates Workflow constructor", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "workflow",
+          type: "GitLab::CI::Workflow",
+          properties: { name: "CI Pipeline" },
+        },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("export const workflow = new Workflow(");
+    expect(files[0].content).toContain('"CI Pipeline"');
+  });
+
+  test("wraps nested property types in constructors", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "testJob",
+          type: "GitLab::CI::Job",
+          properties: {
+            script: ["test"],
+            artifacts: { paths: ["dist/"], expireIn: "1 week" },
+            cache: { key: "node", paths: ["node_modules/"] },
+          },
+        },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    const content = files[0].content;
+    expect(content).toContain("new Artifacts(");
+    expect(content).toContain("new Cache(");
+    expect(content).toContain("Artifacts");
+    expect(content).toContain("Cache");
+  });
+
+  test("wraps rules in Rule constructors", () => {
+    const ir: TemplateIR = {
+      resources: [
+        {
+          logicalId: "testJob",
+          type: "GitLab::CI::Job",
+          properties: {
+            script: ["test"],
+            rules: [{ if: "$CI_COMMIT_BRANCH", when: "always" }],
+          },
+        },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    const content = files[0].content;
+    expect(content).toContain("new Rule(");
+    expect(content).toContain("Rule");
+  });
+
+  test("generates multiple resources", () => {
+    const ir: TemplateIR = {
+      resources: [
+        { logicalId: "buildJob", type: "GitLab::CI::Job", properties: { stage: "build", script: ["build"] } },
+        { logicalId: "testJob", type: "GitLab::CI::Job", properties: { stage: "test", script: ["test"] } },
+      ],
+      parameters: [],
+    };
+
+    const files = generator.generate(ir);
+    const content = files[0].content;
+    expect(content).toContain("export const buildJob");
+    expect(content).toContain("export const testJob");
+  });
+
+  test("includes stages comment from metadata", () => {
+    const ir: TemplateIR = {
+      resources: [
+        { logicalId: "testJob", type: "GitLab::CI::Job", properties: { script: ["test"] } },
+      ],
+      parameters: [],
+      metadata: { stages: ["build", "test", "deploy"] },
+    };
+
+    const files = generator.generate(ir);
+    expect(files[0].content).toContain("Pipeline stages: build, test, deploy");
+  });
+});

package/src/import/generator.ts

@@ -0,0 +1,173 @@
+/**
+ * TypeScript code generator for GitLab CI import.
+ *
+ * Converts a TemplateIR (from parsed .gitlab-ci.yml) into TypeScript
+ * source code using the @intentius/chant-lexicon-gitlab constructors.
+ */
+
+import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
+import type { TemplateIR, ResourceIR } from "@intentius/chant/import/parser";
+
+/**
+ * Map GitLab CI entity types to their constructor names.
+ */
+const TYPE_TO_CLASS: Record<string, string> = {
+  "GitLab::CI::Job": "Job",
+  "GitLab::CI::Default": "Default",
+  "GitLab::CI::Workflow": "Workflow",
+};
+
+/**
+ * Properties that reference known property entities.
+ */
+const PROPERTY_CONSTRUCTORS: Record<string, string> = {
+  artifacts: "Artifacts",
+  cache: "Cache",
+  image: "Image",
+  retry: "Retry",
+  allowFailure: "AllowFailure",
+  parallel: "Parallel",
+  environment: "Environment",
+  trigger: "Trigger",
+  autoCancel: "AutoCancel",
+};
+
+/**
+ * Generate TypeScript source code from a GitLab CI IR.
+ */
+export class GitLabGenerator implements TypeScriptGenerator {
+  generate(ir: TemplateIR): GeneratedFile[] {
+    const lines: string[] = [];
+
+    // Collect which constructors are needed
+    const usedConstructors = new Set<string>();
+    for (const resource of ir.resources) {
+      const cls = TYPE_TO_CLASS[resource.type];
+      if (cls) usedConstructors.add(cls);
+
+      // Check properties for nested constructors
+      this.collectNestedConstructors(resource.properties, usedConstructors);
+    }
+
+    // Import statement
+    const imports = [...usedConstructors].sort().join(", ");
+    lines.push(`import { ${imports} } from "@intentius/chant-lexicon-gitlab";`);
+    lines.push("");
+
+    // Emit stages if present in metadata
+    if (ir.metadata?.stages && Array.isArray(ir.metadata.stages)) {
+      lines.push(`// Pipeline stages: ${(ir.metadata.stages as string[]).join(", ")}`);
+      lines.push("");
+    }
+
+    // Emit includes as comments
+    if (ir.metadata?.include) {
+      lines.push("// Imported includes (not converted):");
+      const includes = Array.isArray(ir.metadata.include) ? ir.metadata.include : [ir.metadata.include];
+      for (const inc of includes) {
+        if (typeof inc === "string") {
+          lines.push(`//   - ${inc}`);
+        } else if (typeof inc === "object" && inc !== null) {
+          lines.push(`//   - ${JSON.stringify(inc)}`);
+        }
+      }
+      lines.push("");
+    }
+
+    // Emit resources
+    for (const resource of ir.resources) {
+      const cls = TYPE_TO_CLASS[resource.type];
+      if (!cls) continue;
+
+      const varName = resource.logicalId;
+      const propsStr = this.emitProps(resource.properties, 1);
+
+      lines.push(`export const ${varName} = new ${cls}(${propsStr});`);
+      lines.push("");
+    }
+
+    return [{ path: "main.ts", content: lines.join("\n") }];
+  }
+
+  private collectNestedConstructors(props: Record<string, unknown>, used: Set<string>): void {
+    for (const [key, value] of Object.entries(props)) {
+      const constructor = PROPERTY_CONSTRUCTORS[key];
+      if (constructor && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        used.add(constructor);
+      }
+      if (key === "rules" && Array.isArray(value)) {
+        used.add("Rule");
+      }
+    }
+  }
+
+  private emitProps(props: Record<string, unknown>, depth: number): string {
+    const indent = "  ".repeat(depth);
+    const innerIndent = "  ".repeat(depth + 1);
+    const entries: string[] = [];
+
+    for (const [key, value] of Object.entries(props)) {
+      if (value === undefined || value === null) continue;
+      const emitted = this.emitValue(key, value, depth + 1);
+      entries.push(`${innerIndent}${key}: ${emitted},`);
+    }
+
+    if (entries.length === 0) return "{}";
+    return `{\n${entries.join("\n")}\n${indent}}`;
+  }
+
+  private emitValue(key: string, value: unknown, depth: number): string {
+    if (value === null || value === undefined) return "undefined";
+
+    // Check if this key maps to a property constructor
+    const constructor = PROPERTY_CONSTRUCTORS[key];
+    if (constructor && typeof value === "object" && !Array.isArray(value)) {
+      const propsStr = this.emitProps(value as Record<string, unknown>, depth);
+      return `new ${constructor}(${propsStr})`;
+    }
+
+    // Rules array — wrap each item in Rule constructor
+    if (key === "rules" && Array.isArray(value)) {
+      const items = value.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          const propsStr = this.emitProps(item as Record<string, unknown>, depth + 1);
+          return `new Rule(${propsStr})`;
+        }
+        return JSON.stringify(item);
+      });
+      const indent = "  ".repeat(depth);
+      const innerIndent = "  ".repeat(depth + 1);
+      return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+    }
+
+    return this.emitLiteral(value, depth);
+  }
+
+  private emitLiteral(value: unknown, depth: number): string {
+    if (value === null || value === undefined) return "undefined";
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "[]";
+      const items = value.map((item) => this.emitLiteral(item, depth + 1));
+      // Short arrays on one line
+      const oneLine = `[${items.join(", ")}]`;
+      if (oneLine.length < 80) return oneLine;
+      const indent = "  ".repeat(depth);
+      const innerIndent = "  ".repeat(depth + 1);
+      return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+    }
+
+    if (typeof value === "object") {
+      const entries = Object.entries(value as Record<string, unknown>);
+      if (entries.length === 0) return "{}";
+      const indent = "  ".repeat(depth);
+      const innerIndent = "  ".repeat(depth + 1);
+      const items = entries.map(([k, v]) => `${innerIndent}${k}: ${this.emitLiteral(v, depth + 1)},`);
+      return `{\n${items.join("\n")}\n${indent}}`;
+    }
+
+    return String(value);
+  }
+}

package/src/import/parser.test.ts

@@ -0,0 +1,160 @@
+import { describe, test, expect } from "bun:test";
+import { GitLabParser } from "./parser";
+
+const parser = new GitLabParser();
+
+describe("GitLabParser", () => {
+  test("parses simple pipeline with one job", () => {
+    const yaml = `
+stages:
+  - test
+
+test-job:
+  stage: test
+  script:
+    - npm test
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources).toHaveLength(1);
+    expect(ir.resources[0].type).toBe("GitLab::CI::Job");
+    expect(ir.resources[0].properties.stage).toBe("test");
+    expect(ir.resources[0].properties.script).toEqual(["npm test"]);
+  });
+
+  test("parses multiple jobs", () => {
+    const yaml = `
+stages:
+  - build
+  - test
+
+build-job:
+  stage: build
+  script:
+    - make build
+
+test-job:
+  stage: test
+  script:
+    - make test
+`;
+    const ir = parser.parse(yaml);
+    const jobs = ir.resources.filter((r) => r.type === "GitLab::CI::Job");
+    expect(jobs).toHaveLength(2);
+  });
+
+  test("parses default settings", () => {
+    const yaml = `
+default:
+  interruptible: true
+  timeout: 30 minutes
+`;
+    const ir = parser.parse(yaml);
+    const defaults = ir.resources.find((r) => r.type === "GitLab::CI::Default");
+    expect(defaults).toBeDefined();
+    expect(defaults!.properties.interruptible).toBe(true);
+  });
+
+  test("parses workflow", () => {
+    const yaml = `
+workflow:
+  name: My Pipeline
+`;
+    const ir = parser.parse(yaml);
+    const workflow = ir.resources.find((r) => r.type === "GitLab::CI::Workflow");
+    expect(workflow).toBeDefined();
+    expect(workflow!.properties.name).toBe("My Pipeline");
+  });
+
+  test("converts snake_case keys to camelCase", () => {
+    const yaml = `
+test-job:
+  stage: test
+  before_script:
+    - echo setup
+  after_script:
+    - echo done
+  script:
+    - npm test
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources[0].properties.beforeScript).toEqual(["echo setup"]);
+    expect(ir.resources[0].properties.afterScript).toEqual(["echo done"]);
+  });
+
+  test("converts kebab-case job names to camelCase", () => {
+    const yaml = `
+my-test-job:
+  stage: test
+  script:
+    - test
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources[0].logicalId).toBe("myTestJob");
+  });
+
+  test("preserves original name in metadata", () => {
+    const yaml = `
+deploy-prod:
+  stage: deploy
+  script:
+    - deploy.sh
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.resources[0].metadata?.originalName).toBe("deploy-prod");
+  });
+
+  test("records stages in metadata", () => {
+    const yaml = `
+stages:
+  - build
+  - test
+  - deploy
+
+test-job:
+  stage: test
+  script:
+    - npm test
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.metadata?.stages).toEqual(["build", "test", "deploy"]);
+  });
+
+  test("skips reserved keys as jobs", () => {
+    const yaml = `
+stages:
+  - test
+variables:
+  NODE_ENV: production
+include:
+  - local: shared.yml
+
+test-job:
+  stage: test
+  script:
+    - npm test
+`;
+    const ir = parser.parse(yaml);
+    // Only the job should be in resources (not stages, variables, include)
+    const jobs = ir.resources.filter((r) => r.type === "GitLab::CI::Job");
+    expect(jobs).toHaveLength(1);
+  });
+
+  test("handles JSON input", () => {
+    const json = JSON.stringify({
+      stages: ["test"],
+      "test-job": { stage: "test", script: ["npm test"] },
+    });
+    const ir = parser.parse(json);
+    expect(ir.resources).toHaveLength(1);
+  });
+
+  test("returns empty parameters (GitLab CI has no parameters)", () => {
+    const yaml = `
+test-job:
+  script:
+    - test
+`;
+    const ir = parser.parse(yaml);
+    expect(ir.parameters).toEqual([]);
+  });
+});