feat(job): Support strategy (#45)

* chore: Implement matrixJSON

* chore: Implement strategyJSON

* chore: Export types

* chore: Install node@22

* feat(job): Support strategy

Author: koki-develop

lib/index.ts

@@ -1,10 +1,14 @@
 export * from "ghats/../.ghats/action.js";
 export * from "./package/concurrency";
 export * from "./package/defaults";
+export * from "./package/env";
+export * from "./package/environment";
 export * from "./package/expression";
 export * from "./package/job";
+export * from "./package/matrix";
 export * from "./package/on";
 export * from "./package/permissions";
 export * from "./package/shell";
 export * from "./package/step";
+export * from "./package/strategy";
 export * from "./package/workflow";

lib/internal/matrix.spec.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import type { Matrix } from "../package/matrix";
+import { matrixJSON } from "./matrix";
+
+describe("matrixJSON", () => {
+  test.each<[Matrix, ReturnType<typeof matrixJSON>]>([
+    ["${{ foo }}", "${{ foo }}"],
+    [
+      { foo: "${{ foo }}", bar: "${{ bar }}" },
+      { foo: "${{ foo }}", bar: "${{ bar }}" },
+    ],
+    [
+      { foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] },
+      { foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] },
+    ],
+
+    [{ include: "${{ foo }}" }, { include: "${{ foo }}" }],
+    [
+      { include: [{ foo: "${{ foo }}", bar: "${{ bar }}" }] },
+      { include: [{ foo: "${{ foo }}", bar: "${{ bar }}" }] },
+    ],
+    [
+      {
+        include: [{ foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] }],
+      },
+      {
+        include: [{ foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] }],
+      },
+    ],
+    [
+      {
+        exclude: [{ foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] }],
+      },
+      {
+        exclude: [{ foo: [1, 2, 3], bar: [4, "5", true, false, "${{ bar }}"] }],
+      },
+    ],
+  ])("matrixJSON(%j) -> %j", (matrix, expected) => {
+    expect(matrixJSON(matrix)).toEqual(expected);
+  });
+});

lib/internal/matrix.ts

@@ -0,0 +1,5 @@
+import type { Matrix } from "../package/matrix";
+
+export function matrixJSON(matrix: Matrix): Record<string, unknown> | string {
+  return matrix;
+}

lib/internal/strategy.spec.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import type { Strategy } from "../package/strategy";
+import { strategyJSON } from "./strategy";
+
+describe("strategyJSON", () => {
+  test.each<[Strategy, Record<string, unknown>]>([
+    [{ matrix: { foo: ["bar", "baz"] } }, { matrix: { foo: ["bar", "baz"] } }],
+    [
+      { matrix: { foo: ["bar", "baz"] }, failFast: true },
+      { matrix: { foo: ["bar", "baz"] }, "fail-fast": true },
+    ],
+    [
+      { matrix: { foo: ["bar", "baz"] }, maxParallel: 10 },
+      { matrix: { foo: ["bar", "baz"] }, "max-parallel": 10 },
+    ],
+    [
+      {
+        matrix: { foo: ["bar", "baz"] },
+        failFast: true,
+        maxParallel: 10,
+      },
+      {
+        matrix: { foo: ["bar", "baz"] },
+        "fail-fast": true,
+        "max-parallel": 10,
+      },
+    ],
+  ])("strategyJSON(%j) -> %j", (strategy, expected) => {
+    expect(strategyJSON(strategy)).toEqual(expected);
+  });
+});

lib/internal/strategy.ts

@@ -0,0 +1,12 @@
+import type { Strategy } from "../package/strategy";
+import { matrixJSON } from "./matrix";
+
+export function strategyJSON(strategy: Strategy): Record<string, unknown> {
+  return {
+    matrix: matrixJSON(strategy.matrix),
+    ...(strategy.failFast != null && { "fail-fast": strategy.failFast }),
+    ...(strategy.maxParallel != null && {
+      "max-parallel": strategy.maxParallel,
+    }),
+  };
+}

lib/package/job.spec.ts

@@ -141,6 +141,17 @@ describe("Job", () => {
         steps: [{ run: "echo 'Hello, world!'" }],
       },
     ],
+    [
+      new Job("with-strategy", {
+        runsOn: "ubuntu-latest",
+        strategy: { matrix: { foo: ["bar", "baz"] } },
+      }).run("echo 'Hello, world!'"),
+      {
+        "runs-on": "ubuntu-latest",
+        strategy: { matrix: { foo: ["bar", "baz"] } },
+        steps: [{ run: "echo 'Hello, world!'" }],
+      },
+    ],
     [
       new Job("with-continue-on-error", {
         runsOn: "ubuntu-latest",

lib/package/job.ts

@@ -4,13 +4,15 @@ import { envJSON } from "../internal/env";
 import { environmentJSON } from "../internal/environment";
 import { permissionsJSON } from "../internal/permissions";
 import { stepJSON } from "../internal/step";
+import { strategyJSON } from "../internal/strategy";
 import { type Concurrency } from "./concurrency";
 import type { Defaults } from "./defaults";
 import type { Env } from "./env";
 import type { Environment } from "./environment";
 import type { Expression } from "./expression";
 import { type Permissions } from "./permissions";
 import { type RunStep, type Step, type UsesStep } from "./step";
+import type { Strategy } from "./strategy";
 
 export type JobConfig = {
   runsOn: string;
@@ -23,7 +25,7 @@ export type JobConfig = {
   concurrency?: Concurrency;
   env?: Env;
   defaults?: Defaults;
-  // TODO: strategy
+  strategy?: Strategy;
   continueOnError?: boolean | Expression;
   // TODO: container
   // TODO: services
@@ -102,6 +104,10 @@ export class Job {
         defaults: defaultsJSON(this._config.defaults),
       }),
 
+      ...(this._config.strategy != null && {
+        strategy: strategyJSON(this._config.strategy),
+      }),
+
       ...(this._config.continueOnError != null && {
         "continue-on-error": this._config.continueOnError,
       }),

lib/package/matrix.ts

@@ -0,0 +1,18 @@
+import type { Expression } from "./expression";
+
+export type Matrix =
+  | Expression
+  | { [key: string]: Expression | Configuration[] }
+  | {
+      include?: Expression | { [key: string]: Expression | Configuration[] }[];
+      exclude?: Expression | { [key: string]: Expression | Configuration[] }[];
+    };
+
+type Configuration =
+  | string
+  | number
+  | boolean
+  | {
+      [key: string]: Configuration;
+    }
+  | Configuration[];

lib/package/strategy.ts

@@ -0,0 +1,7 @@
+import type { Matrix } from "./matrix";
+
+export type Strategy = {
+  matrix: Matrix;
+  failFast?: string | boolean;
+  maxParallel?: string | number;
+};

mise.toml

@@ -1,2 +1,3 @@
 [tools]
 bun = "1.2.8"
+node = "22.14.0"