@intentius/chant-lexicon-gitlab 0.46.0 → 0.50.0

package/src/lint/rules/rules.test.ts

@@ -88,6 +88,49 @@ describe("WGL002: missing-script", () => {
     const diags = missingScriptRule.check(ctx);
     expect(diags).toHaveLength(0);
   });
+
+  // chant #1544 — cross-lexicon rule bleed: a github/forgejo `Job` imported
+  // from its own lexicon package must not be judged by gitlab's `script`/
+  // `trigger`/`run` requirement.
+  test("does not flag a Job imported from the github lexicon", () => {
+    const ctx = createContext(
+      `import { Job } from "@intentius/chant-lexicon-github";\nconst j = new Job({ "runs-on": "ubuntu-latest", steps: [] });`,
+    );
+    const diags = missingScriptRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("does not flag a Job imported from the forgejo lexicon", () => {
+    const ctx = createContext(
+      `import { Job } from "@intentius/chant-lexicon-forgejo";\nconst j = new Job({ "runs-on": "ubuntu-latest", steps: [] });`,
+    );
+    const diags = missingScriptRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("still flags a Job imported from the gitlab lexicon", () => {
+    const ctx = createContext(
+      `import { Job } from "@intentius/chant-lexicon-gitlab";\nconst j = new Job({ stage: "test" });`,
+    );
+    const diags = missingScriptRule.check(ctx);
+    expect(diags).toHaveLength(1);
+  });
+
+  test("still flags a namespace-imported gl.Job() from the gitlab lexicon", () => {
+    const ctx = createContext(
+      `import * as gl from "@intentius/chant-lexicon-gitlab";\nconst j = new gl.Job({ stage: "build" });`,
+    );
+    const diags = missingScriptRule.check(ctx);
+    expect(diags).toHaveLength(1);
+  });
+
+  test("does not flag a namespace-imported Job from another lexicon", () => {
+    const ctx = createContext(
+      `import * as gh from "@intentius/chant-lexicon-github";\nconst j = new gh.Job({ "runs-on": "ubuntu-latest", steps: [] });`,
+    );
+    const diags = missingScriptRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
 });
 
 // ── WGL003: missing stage ───────────────────────────────────────────
@@ -107,6 +150,23 @@ describe("WGL003: missing-stage", () => {
     const diags = missingStageRule.check(ctx);
     expect(diags).toHaveLength(0);
   });
+
+  // chant #1544 — same cross-lexicon rule bleed as WGL002.
+  test("does not flag a Job imported from the github lexicon", () => {
+    const ctx = createContext(
+      `import { Job } from "@intentius/chant-lexicon-github";\nconst j = new Job({ "runs-on": "ubuntu-latest", steps: [] });`,
+    );
+    const diags = missingStageRule.check(ctx);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("still flags a Job imported from the gitlab lexicon", () => {
+    const ctx = createContext(
+      `import { Job } from "@intentius/chant-lexicon-gitlab";\nconst j = new Job({ script: ["test"] });`,
+    );
+    const diags = missingStageRule.check(ctx);
+    expect(diags).toHaveLength(1);
+  });
 });
 
 // ── WGL004: artifact no expiry ──────────────────────────────────────

package/src/op/builders.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Typed step-builder wrapper (chant #1288 Stage 2) — see
+ * `lexicons/k8s/src/op/builders.test.ts`'s module doc for what's asserted
+ * and why.
+ */
+
+import { describe, test, expect } from "vitest";
+import { gitlabPipeline as gitlabPipelineOld, stepOutput, type StepOutputRef } from "@intentius/chant/op";
+import { gitlabPipeline } from "./builders";
+
+describe("gitlab typed step builder (#1288 Stage 2)", () => {
+  test("gitlabPipeline: identical ActivityStep to core's original for a minimal call", () => {
+    expect(gitlabPipeline("alb-api")).toEqual(gitlabPipelineOld("alb-api"));
+  });
+
+  test("gitlabPipeline: identical ActivityStep with opts", () => {
+    const opts = { ref: "main", intervalMs: 15000, profile: "fastIdempotent" as const };
+    expect(gitlabPipeline("alb-api", opts)).toEqual(gitlabPipelineOld("alb-api", opts));
+  });
+
+  test("gitlabPipeline: accepts a StepOutputRef in a typed slot", () => {
+    const ref = stepOutput("resolve-ref", "sha");
+    const step = gitlabPipeline("alb-api", { ref });
+    expect(step.args?.ref).toBe(ref);
+  });
+
+  test("gitlabPipeline: .out is reachable when an id is given", () => {
+    const step = gitlabPipeline("alb-api", { id: "pipeline" });
+    const ref: StepOutputRef = step.out.name;
+    expect(ref.step).toBe("pipeline");
+  });
+});
+
+// ── Compile-time-only: authoring-time type errors (never executed) ──────────
+function _typeChecksOnly(): void {
+  // @ts-expect-error — "project" is not a key of GitlabPipelineArgs (the
+  // field is `name`, and it's positional here besides).
+  gitlabPipeline("alb-api", { project: "group/other" });
+
+  // @ts-expect-error — intervalMs must be a number.
+  gitlabPipeline("alb-api", { intervalMs: "15000" });
+}
+void _typeChecksOnly;

package/src/op/builders.ts

@@ -0,0 +1,39 @@
+/**
+ * Typed step-builder wrapper for this lexicon's `gitlabPipeline` activity
+ * (chant #1288 Stage 2 — "regenerate the step builders as fully typed
+ * wrappers"). Core cannot import a lexicon's `*Args` types (lexicons depend
+ * on core, not the other way around), so a fully typed `gitlabPipeline` has
+ * to live beside {@link GitlabPipelineArgs} — here, next to
+ * `./activities/gitlab.ts`. `opts`'s type below IS `GitlabPipelineArgs`
+ * itself (via `Omit`/`WithStepRefs`) — never a hand-restated mirror.
+ *
+ * `core`'s own `gitlabPipeline` (in `@intentius/chant/op`, re-exported from
+ * `@intentius/chant-lexicon-temporal`) is UNCHANGED and produces a
+ * byte-identical `ActivityStep` for the same inputs — purely additive, and
+ * deliberately not swapped into the temporal barrel (see
+ * `lexicons/k8s/src/op/builders.ts`'s module doc for why: that would make
+ * temporal depend on this package at runtime). An author who wants the typed
+ * surface imports it from here — `@intentius/chant-lexicon-gitlab`.
+ */
+
+import {
+  activity,
+  takeProfileAndId,
+  type ActivityStep,
+  type NamedActivityStep,
+  type WithStepRefs,
+} from "@intentius/chant/op";
+import type { GitlabPipelineArgs } from "./activities/gitlab";
+
+/**
+ * Trigger and wait for a GitLab CI pipeline to complete — the fully typed
+ * twin of core's `gitlabPipeline`. `opts` is {@link GitlabPipelineArgs}
+ * itself, minus the positional `name`. Defaults to the `longInfra` profile.
+ */
+export const gitlabPipeline = (
+  name: string,
+  opts?: WithStepRefs<Omit<GitlabPipelineArgs, "name">> & { profile?: ActivityStep["profile"]; id?: string },
+): NamedActivityStep => {
+  const { args, profile, id } = takeProfileAndId(opts as Record<string, unknown> | undefined);
+  return activity("gitlabPipeline", { name, ...args }, { profile: profile ?? "longInfra", ...(id ? { id } : {}) });
+};

package/src/plugin.test.ts

@@ -87,7 +87,7 @@ describe("gitlabPlugin", () => {
 
   test("returns post-synth checks", () => {
     const checks = gitlabPlugin.postSynthChecks!();
-    expect(checks).toHaveLength(39);
+    expect(checks).toHaveLength(41);
     const ids = checks.map((c) => c.id);
     expect(ids).toContain("WGL010");
     expect(ids).toContain("WGL011");

package/src/plugin.ts

@@ -23,12 +23,15 @@ import { gitlabHover } from "./lsp/hover";
 import { GitLabParser } from "./import/parser";
 import { GitLabGenerator } from "./import/generator";
 import { generateGitlabPipeline } from "./components/generate-pipeline";
+import { generateGitlabOpPipeline } from "./components/generate-op-pipeline";
 
 export const gitlabPlugin: LexiconPlugin = {
   name: "gitlab",
   auditCatalog: () => gitlabAuditCatalog,
   // Generate mode (#688): synthesize a .gitlab-ci.yml from the component graph.
   generateComponentPipeline: (components, options) => generateGitlabPipeline(components, options),
+  // Generate mode, Op counterpart (#927): scheduled Op → GitLab CI job.
+  generateOpPipeline: (ops, options) => generateGitlabOpPipeline(ops, options),
   // Self-upgrade: where the pinned GitLab schema version lives + its upstream (#685).
   upstreamPin: {
     file: "src/codegen/fetch.ts",