@intentius/chant-lexicon-gitlab 0.0.6 → 0.0.9

package/src/composites/python-pipeline.ts

@@ -0,0 +1,75 @@
+import { Composite } from "@intentius/chant";
+import { Job, Default, Image, Cache, Artifacts } from "../generated";
+import { CI } from "../variables";
+
+export interface PythonPipelineProps {
+  /** Python version. Default: "3.12" */
+  pythonVersion?: string;
+  /** Test command. Default: "pytest --junitxml=report.xml --cov" */
+  testCommand?: string;
+  /** Lint command. Set to null to omit lint job. Default: "ruff check ." */
+  lintCommand?: string | null;
+  /** Requirements file. Default: "requirements.txt" */
+  requirementsFile?: string;
+  /** Use poetry instead of pip. Default: false */
+  usePoetry?: boolean;
+}
+
+export const PythonPipeline = Composite<PythonPipelineProps>((props) => {
+  const {
+    pythonVersion = "3.12",
+    testCommand = "pytest --junitxml=report.xml --cov",
+    lintCommand = "ruff check .",
+    requirementsFile = "requirements.txt",
+    usePoetry = false,
+  } = props;
+
+  const pythonImage = new Image({ name: `python:${pythonVersion}-slim` });
+
+  const cache = new Cache({
+    key: { files: [usePoetry ? "poetry.lock" : requirementsFile] },
+    paths: [".pip-cache/", ".venv/"],
+    policy: "pull-push",
+  });
+
+  const installSteps = usePoetry
+    ? ["pip install poetry", "poetry config virtualenvs.in-project true", "poetry install"]
+    : [
+        "python -m venv .venv",
+        "source .venv/bin/activate",
+        `pip install -r ${requirementsFile}`,
+      ];
+
+  const activateStep = usePoetry ? "source .venv/bin/activate" : "source .venv/bin/activate";
+
+  const defaults = new Default({
+    image: pythonImage,
+    cache: [cache],
+    before_script: [...installSteps],
+  });
+
+  const test = new Job({
+    stage: "test",
+    variables: { PIP_CACHE_DIR: `${CI.ProjectDir}/.pip-cache` },
+    script: [activateStep, testCommand],
+    artifacts: new Artifacts({
+      reports: { junit: "report.xml" },
+      when: "always",
+    }),
+  });
+
+  const lint =
+    lintCommand !== null
+      ? new Job({
+          stage: "test",
+          variables: { PIP_CACHE_DIR: `${CI.ProjectDir}/.pip-cache` },
+          script: [activateStep, lintCommand],
+        })
+      : undefined;
+
+  if (lint) {
+    return { defaults, test, lint };
+  }
+
+  return { defaults, test } as any;
+}, "PythonPipeline");

package/src/composites/review-app.ts

@@ -0,0 +1,63 @@
+import { Composite } from "@intentius/chant";
+import { Job, Image, Environment, Rule } from "../generated";
+import { CI } from "../variables";
+
+export interface ReviewAppProps {
+  /** Base name for the jobs (e.g. "review" → review-deploy, review-stop in YAML). */
+  name: string;
+  /** Deploy script command(s). */
+  deployScript: string | string[];
+  /** Stop script command(s). Default: echo "Stopping review app..." */
+  stopScript?: string | string[];
+  /** Environment URL pattern. Default: "https://$CI_ENVIRONMENT_SLUG.example.com" */
+  urlPattern?: string;
+  /** Auto-stop timer. Default: "1 week" */
+  autoStopIn?: string;
+  /** Override image for both jobs. */
+  image?: InstanceType<typeof Image>;
+  /** Job stage. Default: "deploy" */
+  stage?: string;
+}
+
+export const ReviewApp = Composite<ReviewAppProps>((props) => {
+  const {
+    name,
+    deployScript,
+    stopScript = 'echo "Stopping review app..."',
+    urlPattern = `https://${CI.EnvironmentSlug}.example.com`,
+    autoStopIn = "1 week",
+    image,
+    stage = "deploy",
+  } = props;
+
+  const stopJobName = `${name}-stop`;
+
+  const deployScriptArr = Array.isArray(deployScript) ? deployScript : [deployScript];
+  const stopScriptArr = Array.isArray(stopScript) ? stopScript : [stopScript];
+
+  const deploy = new Job({
+    stage,
+    ...(image ? { image } : {}),
+    environment: new Environment({
+      name: `review/${CI.CommitRefSlug}`,
+      url: urlPattern,
+      auto_stop_in: autoStopIn,
+      on_stop: stopJobName,
+    }),
+    rules: [new Rule({ if: CI.MergeRequestIid })],
+    script: deployScriptArr,
+  });
+
+  const stop = new Job({
+    stage,
+    ...(image ? { image } : {}),
+    environment: new Environment({
+      name: `review/${CI.CommitRefSlug}`,
+      action: "stop",
+    }),
+    rules: [new Rule({ if: CI.MergeRequestIid, when: "manual" })],
+    script: stopScriptArr,
+  });
+
+  return { deploy, stop };
+}, "ReviewApp");

package/src/generated/index.d.ts

@@ -4,7 +4,7 @@
 
 export declare class AllowFailure {
   constructor(props: {
-    exit_codes: number;
+    exit_codes: number | number[];
   });
 }
 
@@ -48,7 +48,7 @@ export declare class Default {
     before_script?: string | string[];
     cache?: Cache | Cache[];
     hooks?: Record<string, unknown>;
-    id_tokens?: Record<string, unknown>;
+    id_tokens?: Record<string, { aud: string | string[] }>;
     identity?: "google_cloud";
     image?: Image;
     interruptible?: boolean;
@@ -85,19 +85,34 @@ export declare class Image {
     docker?: Record<string, unknown>;
     /** Command or script that should be executed as the container's entrypoint. It will be translated to Docker's --entrypoint option while creating the container. The syntax is similar to Dockerfile's ENTRYPOINT directive, where each shell token is a separate string in the array. */
     entrypoint?: any[];
-    pull_policy?: "always" | "never" | "if-not-present" | "always" | "never" | "if-not-present"[];
+    pull_policy?: "always" | "never" | "if-not-present" | ("always" | "never" | "if-not-present")[];
   });
 }
 
 export declare class Include {
   constructor(props: {
-    file: string | string[];
-    /** Path to the project, e.g. `group/project`, or `group/sub-group/project` [Learn more](https://docs.gitlab.com/ee/ci/yaml/index.html#includefile). */
-    project: string;
+    /** Local path to component directory or full path to external component directory. */
+    component?: string;
+    file?: string | string[];
     inputs?: Record<string, unknown>;
+    /** Relative path from local repository root (`/`) to the `yaml`/`yml` file template. The file must be on the same branch, and does not work across git submodules. */
+    local?: string;
+    /** Path to the project, e.g. `group/project`, or `group/sub-group/project` [Learn more](https://docs.gitlab.com/ee/ci/yaml/index.html#includefile). */
+    project?: string;
     /** Branch/Tag/Commit-hash for the target project. */
     ref?: string;
+    /** URL to a `yaml`/`yml` template file using HTTP/HTTPS. */
+    remote?: string;
     rules?: any[];
+    /** Use a `.gitlab-ci.yml` template as a base, e.g. `Nodejs.gitlab-ci.yml`. */
+    template?: string;
+  });
+}
+
+export declare class Inherit {
+  constructor(props: {
+    default?: boolean | ("after_script" | "artifacts" | "before_script" | "cache" | "image" | "interruptible" | "retry" | "services" | "tags" | "timeout")[];
+    variables?: boolean | string[];
   });
 }
 
@@ -113,20 +128,20 @@ export declare class Job {
     /** Specify a list of job names from earlier stages from which artifacts should be loaded. By default, all previous artifacts are passed. Use an empty array to skip downloading artifacts. */
     dependencies?: string[];
     /** Used to associate environment metadata with a deploy. Environment can have a name and URL attached to it, and will be displayed under /environments under the project. */
-    environment?: string | Record<string, any>;
+    environment?: Environment | string;
     /** Job will run *except* for when these filtering options match. */
     except?: any;
     /** The name of one or more jobs to inherit configuration from. */
     extends?: string | string[];
     hooks?: Record<string, unknown>;
-    id_tokens?: Record<string, unknown>;
+    id_tokens?: Record<string, { aud: string | string[] }>;
     identity?: "google_cloud";
     image?: Image;
-    inherit?: Record<string, unknown>;
+    inherit?: Inherit;
     interruptible?: boolean;
     manual_confirmation?: string;
     /** The list of jobs in previous stages whose sole completion is needed to start the current job. */
-    needs?: string | Record<string, any> | any[][];
+    needs?: Need[];
     /** Job will run *only* when these filtering options match. */
     only?: any;
     pages?: Record<string, any> | boolean;
@@ -134,7 +149,7 @@ export declare class Job {
     /** A path to a directory that contains the files to be published with Pages */
     publish?: string;
     /** Indicates that the job creates a Release. */
-    release?: Record<string, unknown>;
+    release?: Release;
     /** Limit job concurrency. Can be used to ensure that the Runner will not run certain jobs simultaneously. */
     resource_group?: string;
     retry?: Retry | number;
@@ -148,12 +163,24 @@ export declare class Job {
     start_in?: string;
     tags?: any[];
     timeout?: string;
-    trigger?: Record<string, any> | string;
+    trigger?: Trigger | string;
     variables?: Record<string, unknown>;
     when?: "on_success" | "on_failure" | "always" | "never" | "manual" | "delayed";
   });
 }
 
+export declare class Need {
+  constructor(props: {
+    job: string;
+    artifacts?: boolean;
+    optional?: boolean;
+    parallel?: any;
+    pipeline?: string;
+    project?: string;
+    ref?: string;
+  });
+}
+
 export declare class Parallel {
   constructor(props: {
     /** Defines different variables for jobs that are running in parallel. */
@@ -211,19 +238,20 @@ export declare class Service {
     command?: string[];
     docker?: Record<string, unknown>;
     entrypoint?: string[];
-    pull_policy?: "always" | "never" | "if-not-present" | "always" | "never" | "if-not-present"[];
+    pull_policy?: "always" | "never" | "if-not-present" | ("always" | "never" | "if-not-present")[];
     variables?: Record<string, unknown>;
   });
 }
 
 export declare class Trigger {
   constructor(props: {
-    /** Path to the project, e.g. `group/project`, or `group/sub-group/project`. */
-    project: string;
     /** The branch name that a downstream pipeline will use */
     branch?: string;
     /** Specify what to forward to the downstream pipeline. */
     forward?: Record<string, unknown>;
+    include?: string | Record<string, any>[];
+    /** Path to the project, e.g. `group/project`, or `group/sub-group/project`. */
+    project?: string;
     /** You can mirror the pipeline status from the triggered pipeline to the source bridge job by using strategy: depend */
     strategy?: "depend";
   });
@@ -233,7 +261,18 @@ export declare class Workflow {
   constructor(props: {
     auto_cancel?: AutoCancel;
     name?: string;
-    rules?: Record<string, any> | string[][];
+    rules?: WorkflowRule[];
+  });
+}
+
+export declare class WorkflowRule {
+  constructor(props: {
+    auto_cancel?: AutoCancel;
+    changes?: any;
+    exists?: any;
+    if?: string;
+    variables?: Record<string, unknown>;
+    when?: "always" | "never";
   });
 }
 

package/src/generated/index.ts

@@ -12,12 +12,15 @@ export const Cache = createProperty("GitLab::CI::Cache", "gitlab");
 export const Environment = createProperty("GitLab::CI::Environment", "gitlab");
 export const Image = createProperty("GitLab::CI::Image", "gitlab");
 export const Include = createProperty("GitLab::CI::Include", "gitlab");
+export const Inherit = createProperty("GitLab::CI::Inherit", "gitlab");
+export const Need = createProperty("GitLab::CI::Need", "gitlab");
 export const Parallel = createProperty("GitLab::CI::Parallel", "gitlab");
 export const Release = createProperty("GitLab::CI::Release", "gitlab");
 export const Retry = createProperty("GitLab::CI::Retry", "gitlab");
 export const Rule = createProperty("GitLab::CI::Rule", "gitlab");
 export const Service = createProperty("GitLab::CI::Service", "gitlab");
 export const Trigger = createProperty("GitLab::CI::Trigger", "gitlab");
+export const WorkflowRule = createProperty("GitLab::CI::WorkflowRule", "gitlab");
 
 // Re-exports for convenience
 export { reference } from "../intrinsics";

package/src/generated/lexicon-gitlab.json

@@ -7,17 +7,77 @@
   "Artifacts": {
     "resourceType": "GitLab::CI::Artifacts",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "untracked": {
+        "default": false
+      },
+      "when": {
+        "default": "on_success",
+        "enum": [
+          "on_success",
+          "on_failure",
+          "always"
+        ]
+      },
+      "access": {
+        "default": "all",
+        "enum": [
+          "none",
+          "developer",
+          "all"
+        ]
+      },
+      "expire_in": {
+        "default": "30 days"
+      }
+    }
   },
   "AutoCancel": {
     "resourceType": "GitLab::CI::AutoCancel",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "on_job_failure": {
+        "default": "none",
+        "enum": [
+          "none",
+          "all"
+        ]
+      },
+      "on_new_commit": {
+        "enum": [
+          "conservative",
+          "interruptible",
+          "none"
+        ]
+      }
+    }
   },
   "Cache": {
     "resourceType": "GitLab::CI::Cache",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "policy": {
+        "pattern": "pull-push|pull|push|\\$\\w{1,255}",
+        "default": "pull-push"
+      },
+      "unprotect": {
+        "default": false
+      },
+      "untracked": {
+        "default": false
+      },
+      "when": {
+        "default": "on_success",
+        "enum": [
+          "on_success",
+          "on_failure",
+          "always"
+        ]
+      }
+    }
   },
   "Default": {
     "resourceType": "GitLab::CI::Default",
@@ -27,21 +87,93 @@
   "Environment": {
     "resourceType": "GitLab::CI::Environment",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "name": {
+        "minLength": 1
+      },
+      "url": {
+        "pattern": "^(https?://.+|\\$[A-Za-z]+)",
+        "format": "uri"
+      },
+      "action": {
+        "default": "start",
+        "enum": [
+          "start",
+          "prepare",
+          "stop",
+          "verify",
+          "access"
+        ]
+      },
+      "deployment_tier": {
+        "enum": [
+          "production",
+          "staging",
+          "testing",
+          "development",
+          "other"
+        ]
+      }
+    }
   },
   "Image": {
     "resourceType": "GitLab::CI::Image",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "name": {
+        "minLength": 1
+      },
+      "pull_policy": {
+        "default": "always"
+      }
+    }
   },
   "Include": {
     "resourceType": "GitLab::CI::Include",
     "kind": "property",
+    "lexicon": "gitlab",
+    "constraints": {
+      "project": {
+        "pattern": "(?:\\S/\\S|\\$\\S+)"
+      },
+      "local": {
+        "pattern": "\\.ya?ml$",
+        "format": "uri-reference"
+      },
+      "template": {
+        "pattern": "\\.ya?ml$",
+        "format": "uri-reference"
+      },
+      "component": {
+        "format": "uri-reference"
+      },
+      "remote": {
+        "pattern": "^https?://.+\\.ya?ml$",
+        "format": "uri-reference"
+      }
+    }
+  },
+  "Inherit": {
+    "resourceType": "GitLab::CI::Inherit",
+    "kind": "property",
     "lexicon": "gitlab"
   },
   "Job": {
     "resourceType": "GitLab::CI::Job",
     "kind": "resource",
+    "lexicon": "gitlab",
+    "constraints": {
+      "coverage": {
+        "pattern": "^/.+/$",
+        "format": "regex"
+      }
+    }
+  },
+  "Need": {
+    "resourceType": "GitLab::CI::Need",
+    "kind": "property",
     "lexicon": "gitlab"
   },
   "Parallel": {
@@ -52,7 +184,19 @@
   "Release": {
     "resourceType": "GitLab::CI::Release",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "tag_name": {
+        "minLength": 1
+      },
+      "description": {
+        "minLength": 1
+      },
+      "released_at": {
+        "pattern": "^(?:[1-9]\\d{3}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[1-9]\\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)-02-29)T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:Z|[+-][01]\\d:[0-5]\\d)$",
+        "format": "date-time"
+      }
+    }
   },
   "Retry": {
     "resourceType": "GitLab::CI::Retry",
@@ -67,16 +211,50 @@
   "Service": {
     "resourceType": "GitLab::CI::Service",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "name": {
+        "minLength": 1
+      },
+      "pull_policy": {
+        "default": "always"
+      },
+      "alias": {
+        "minLength": 1
+      }
+    }
   },
   "Trigger": {
     "resourceType": "GitLab::CI::Trigger",
     "kind": "property",
-    "lexicon": "gitlab"
+    "lexicon": "gitlab",
+    "constraints": {
+      "project": {
+        "pattern": "(?:\\S/\\S|\\$\\S+)"
+      },
+      "strategy": {
+        "enum": [
+          "depend"
+        ]
+      }
+    }
   },
   "Workflow": {
     "resourceType": "GitLab::CI::Workflow",
     "kind": "resource",
     "lexicon": "gitlab"
+  },
+  "WorkflowRule": {
+    "resourceType": "GitLab::CI::WorkflowRule",
+    "kind": "property",
+    "lexicon": "gitlab",
+    "constraints": {
+      "when": {
+        "enum": [
+          "always",
+          "never"
+        ]
+      }
+    }
   }
 }

package/src/import/generator.ts

@@ -25,11 +25,12 @@ const PROPERTY_CONSTRUCTORS: Record<string, string> = {
   cache: "Cache",
   image: "Image",
   retry: "Retry",
-  allowFailure: "AllowFailure",
+  allow_failure: "AllowFailure",
   parallel: "Parallel",
   environment: "Environment",
   trigger: "Trigger",
-  autoCancel: "AutoCancel",
+  auto_cancel: "AutoCancel",
+  inherit: "Inherit",
 };
 
 /**

package/src/import/parser.test.ts

@@ -65,7 +65,7 @@ workflow:
     expect(workflow!.properties.name).toBe("My Pipeline");
   });
 
-  test("converts snake_case keys to camelCase", () => {
+  test("preserves spec-native snake_case property keys", () => {
     const yaml = `
 test-job:
   stage: test
@@ -77,8 +77,8 @@ test-job:
     - 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"]);
+    expect(ir.resources[0].properties.before_script).toEqual(["echo setup"]);
+    expect(ir.resources[0].properties.after_script).toEqual(["echo done"]);
   });
 
   test("converts kebab-case job names to camelCase", () => {

package/src/import/parser.ts

@@ -10,6 +10,14 @@ import type { TemplateParser, TemplateIR, ResourceIR } from "@intentius/chant/im
 /**
  * Reserved top-level keys in .gitlab-ci.yml that are NOT job definitions.
  */
+/**
+ * Convert snake_case to camelCase — used only for TS variable names (logicalId),
+ * NOT for spec property names.
+ */
+function snakeToCamelCase(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
 const RESERVED_KEYS = new Set([
   "stages",
   "variables",
@@ -24,28 +32,6 @@ const RESERVED_KEYS = new Set([
   "pages",
 ]);
 
-/**
- * Map snake_case GitLab CI keys to camelCase for Chant properties.
- */
-function toCamelCase(name: string): string {
-  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/**
- * Recursively convert snake_case keys in an object to camelCase.
- */
-function camelCaseKeys(value: unknown): unknown {
-  if (value === null || value === undefined) return value;
-  if (Array.isArray(value)) return value.map(camelCaseKeys);
-  if (typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-      result[toCamelCase(key)] = camelCaseKeys(val);
-    }
-    return result;
-  }
-  return value;
-}
 
 /**
  * Parse a YAML document into a plain object.
@@ -227,7 +213,7 @@ export class GitLabParser implements TemplateParser {
       resources.push({
         logicalId: "defaults",
         type: "GitLab::CI::Default",
-        properties: camelCaseKeys(doc.default) as Record<string, unknown>,
+        properties: doc.default as Record<string, unknown>,
       });
     }
 
@@ -236,7 +222,7 @@ export class GitLabParser implements TemplateParser {
       resources.push({
         logicalId: "workflow",
         type: "GitLab::CI::Workflow",
-        properties: camelCaseKeys(doc.workflow) as Record<string, unknown>,
+        properties: doc.workflow as Record<string, unknown>,
       });
     }
 
@@ -256,9 +242,9 @@ export class GitLabParser implements TemplateParser {
         obj.needs !== undefined
       ) {
         resources.push({
-          logicalId: toCamelCase(key.replace(/-/g, "_")),
+          logicalId: snakeToCamelCase(key.replace(/-/g, "_")),
           type: "GitLab::CI::Job",
-          properties: camelCaseKeys(obj) as Record<string, unknown>,
+          properties: obj as Record<string, unknown>,
           metadata: {
             originalName: key,
             stage: typeof obj.stage === "string" ? obj.stage : undefined,

package/src/index.ts

@@ -14,6 +14,10 @@ export { CI } from "./variables";
 // After running `chant generate`, this re-exports all CI entity classes
 export * from "./generated/index";
 
+// Composites
+export { DockerBuild, NodePipeline, BunPipeline, PnpmPipeline, PythonPipeline, ReviewApp } from "./composites/index";
+export type { DockerBuildProps, NodePipelineProps, PythonPipelineProps, ReviewAppProps } from "./composites/index";
+
 // Spec utilities (for tooling)
 export { fetchCISchema, fetchSchemas, GITLAB_SCHEMA_VERSION } from "./codegen/fetch";
 export { parseCISchema, gitlabShortName, gitlabServiceName } from "./codegen/parse";