@intentius/chant-lexicon-forgejo 0.80.0 → 0.82.0

package/dist/components/generate-op-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+HG;AAOH,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAmCjF;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,gBAAgB,CA4ClB"}
+{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+HG;AAOH,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAmCjF;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,gBAAgB,CA+ClB"}

package/dist/components/generate-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOjF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,uBAAuB,CAgBzB"}
+{"version":3,"file":"generate-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOjF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,uBAAuB,CAkBzB"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "07bace16712ce01b8d29bf2bff8bda5895d979e0a8f095ec3b352f0392795148",
+    "manifest.json": "bcfc082423806bcc5b376d996ee8d69f3267cdd27a3ccb749c548140c9673af1",
     "meta.json": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
     "types/index.d.ts": "66204549b2a864ab5489e3f02c1878e73ab4b3c9d938cfb480b66f71543a43de",
     "rules/delegate-to-github.ts": "1060cda40f4b73d6cca3ba3fa13b80b4886147d4034c88584c2d80c5510dbe5e",
@@ -9,5 +9,5 @@
     "rules/wfj011.ts": "fcb8bf6685d744af20ad804ce929488257995c74b9a3353b2eacae3768d1c83e",
     "skills/chant-forgejo.md": "a1a560429db736c187e0b34cf8dd9efc6ad771afefcbf6f802d160d3d5274257"
   },
-  "composite": "48d71cec688480cade4f5524f0513445c14d8b2d2bd69e22510f6415f23af2d9"
+  "composite": "4147188ccde8f5175e53c3880aa64fdcd6dba2d5ebebb8f93173b33945b986be"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "forgejo",
-  "version": "0.80.0",
+  "version": "0.82.0",
   "chantVersion": ">=0.1.0",
   "namespace": "Forgejo",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-forgejo",
-  "version": "0.80.0",
+  "version": "0.82.0",
   "description": "Forgejo / Codeberg / Gitea Actions lexicon for chant — a thin GitHub Actions dialect",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -54,8 +54,8 @@
   },
   "peerDependencies": {
     "zod": "^4.3.6",
-    "@intentius/chant": "^0.80.0",
-    "@intentius/chant-lexicon-github": "^0.80.0"
+    "@intentius/chant": "^0.82.0",
+    "@intentius/chant-lexicon-github": "^0.82.0"
   },
   "scripts": {
     "generate": "tsx src/codegen/generate-cli.ts",

package/src/components/generate-op-pipeline.test.ts

@@ -298,9 +298,14 @@ describe("generateForgejoOpPipeline: a dropped deployment environment (#2257)",
   const APPLY: ScheduledOpSpec = { name: "app-apply", trigger: { kind: "push", branches: ["main"] } };
   const GATED: ScheduledOpSpec = { ...APPLY, environment: { name: "production" } };
 
-  /** The document a spec with no `environment` emitted before the option existed. */
+  /**
+   * The document a spec with no `environment` emitted before the option
+   * existed. The `name:` line came later, from #2601, for every spec alike.
+   */
   const AUDIT_YAML_BEFORE_2257 =
     [
+      "name: actions-audit",
+      "",
       "on:",
       "  schedule:",
       "    - cron: '0 6 * * *'",
@@ -353,7 +358,16 @@ describe("generateForgejoOpPipeline: a dropped deployment environment (#2257)",
     ]).files;
     expect(files[0].yaml).toContain("# chant dropped `environment: production`");
     expect(files[1].yaml).not.toContain("# chant dropped");
-    expect(files[1].yaml.startsWith("on:")).toBe(true);
+    expect(files[1].yaml.startsWith("name: app-watch\n\non:")).toBe(true);
+  });
+
+  test("the dropped-environment header comes first, then the workflow's name (#2601)", () => {
+    const yaml = generateForgejoOpPipeline([GATED]).files[0].yaml;
+    const lines = yaml.split("\n");
+    const nameAt = lines.indexOf("name: app-apply");
+    expect(nameAt).toBeGreaterThan(0);
+    expect(lines.slice(0, nameAt - 1).every((line) => line.startsWith("# "))).toBe(true);
+    expect(lines[nameAt + 2]).toBe("on:");
   });
 
   test("refuses the same malformed environment github refuses, through the shared builder", () => {

package/src/components/generate-op-pipeline.ts

@@ -219,6 +219,9 @@ export function generateForgejoOpPipeline(
       const environment = ops[index].environment;
       const forgejoDoc: GithubOpPipelineDoc = {
         ...(environment ? { header: droppedEnvironmentHeader(environment.name) } : {}),
+        // Forgejo Actions reads `name:` as GitHub does (#2601), so the Op's
+        // name carries over and the Actions list shows it instead of the path.
+        ...(doc.name ? { name: doc.name } : {}),
         on: forgejoize(doc.on, dialectOptions),
         ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
         concurrency: forgejoize(doc.concurrency, dialectOptions),

package/src/components/generate-pipeline.member.test.ts

@@ -0,0 +1,32 @@
+/**
+ * A workspace member's pipeline on Forgejo (#2542): the github shape, with
+ * the member's path filter and working directory carried across the dialect.
+ */
+
+import { describe, test, expect } from "vitest";
+import { parseYAML } from "@intentius/chant/yaml";
+import type { DriverComponent } from "@intentius/chant/components/driver";
+import { generateForgejoPipeline } from "./generate-pipeline";
+import { generateForgejoOpPipeline } from "./generate-op-pipeline";
+
+const components: DriverComponent[] = [{ name: "api", dependsOn: [], deploy: [] }];
+
+describe("generateForgejoPipeline for a workspace member", () => {
+  test("working directory and name survive the dialect, and the triggers stay the plain pipeline's", () => {
+    const member = { name: "api", dir: "services/api", file: ".forgejo/workflows/chant-api-staging.yml" };
+    const doc = parseYAML(generateForgejoPipeline(components, { env: "staging", member }).yaml) as Record<string, unknown>;
+    expect(doc.name).toBe("chant-components-api-staging");
+    expect(Object.keys(doc.on as Record<string, unknown>)).toEqual(["workflow_dispatch"]);
+    expect(doc.defaults).toEqual({ run: { "working-directory": "services/api" } });
+  });
+
+  test("an Op's file and job carry the member", () => {
+    const result = generateForgejoOpPipeline([{ name: "plan", trigger: { kind: "pull_request" } }], {
+      member: { name: "api", dir: "services/api", fileDir: ".forgejo/workflows" },
+    });
+    expect(result.files[0].name).toBe("api-plan.yml");
+    const doc = parseYAML(result.files[0].yaml) as { on: Record<string, unknown>; jobs: Record<string, { defaults?: unknown }> };
+    expect(doc.on.pull_request).toEqual({ paths: ["services/api/**", ".forgejo/workflows/api-plan.yml"] });
+    expect(doc.jobs["plan"].defaults).toEqual({ run: { "working-directory": "services/api" } });
+  });
+});

package/src/components/generate-pipeline.test.ts

@@ -27,6 +27,7 @@ function pilotComponents(): DriverComponent[] {
 
 interface ParsedStep {
   name?: string;
+  id?: string;
   uses?: string;
   run?: string;
   with?: Record<string, unknown>;
@@ -35,6 +36,7 @@ interface ParsedJob {
   "runs-on"?: string;
   container?: string;
   needs?: string[];
+  outputs?: Record<string, string>;
   steps: ParsedStep[];
 }
 function parsedJobs(yaml: string): Record<string, ParsedJob> {
@@ -128,6 +130,23 @@ describe("generateForgejoPipeline: a promote job (#2575)", () => {
     const promote = jobs["promote-prod"];
     expect(promote.needs).toEqual(["api"]);
     expect(promote.steps.find((s) => s.name === "Download api build archive")?.with).toEqual({ name: "api-archive", path: "dist" });
-    expect(promote.steps.some((s) => s.run === "chant components promote --from staging --to prod")).toBe(true);
+    expect(promote.steps.some((s) => s.run === 'chant components promote --from staging --to prod --digest "api=${{ needs.api.outputs.digest }}"')).toBe(true);
+  });
+
+  test("the digest the api job recorded reaches the promote command through a job output (#2602)", () => {
+    const components: DriverComponent[] = [
+      {
+        name: "api",
+        deploy: [
+          { phase: "Build", steps: [{ kind: "docker-build", context: ".", into: "dist/api.tar" }] },
+          { phase: "Publish", steps: [{ kind: "publish-image", from: "archive:dist/api.tar" }] },
+        ],
+      },
+    ];
+    const jobs = parsedJobs(generateForgejoPipeline(components, { env: "staging", promoteTo: "prod" }).yaml);
+    expect(jobs["api"].outputs).toEqual({ digest: "${{ steps.digest.outputs.digest }}" });
+    expect(jobs["api"].steps.some((s) => s.run?.includes("--digest-file api.digest"))).toBe(true);
+    expect(jobs["api"].steps.find((s) => s.id === "digest")?.run).toBe('echo "digest=$(cut -d= -f2- api.digest)" >> "$GITHUB_OUTPUT"');
+    expect(jobs["promote-prod"].steps.some((s) => s.run?.includes('--digest "api=${{ needs.api.outputs.digest }}"'))).toBe(true);
   });
 });

package/src/components/generate-pipeline.ts

@@ -62,6 +62,8 @@ export function generateForgejoPipeline(
     environment: doc.environment,
     on: forgejoize(doc.on, dialectOptions),
     ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
+    // A workspace member's working directory (#2542) reads the same on Forgejo.
+    ...(doc.defaults ? { defaults: doc.defaults } : {}),
     jobsDoc: forgejoize(doc.jobsDoc, dialectOptions),
     stages: doc.stages,
     jobs: doc.jobs,