@factorialco/gat 2.5.0 → 3.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -1,32 +1,28 @@
 #!/usr/bin/env node
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-import fs from "fs";
-import path from "path";
-import { exec } from "child_process";
-import { Command } from "commander";
-import { promisify } from "util";
-const execPromise = promisify(exec);
-const folder = path.join(process.cwd(), ".github", "templates");
-const cli = new Command();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const util_1 = require("util");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+const folder = path_1.default.join(process.cwd(), ".github", "templates");
+const cli = new commander_1.Command();
 cli
     .version("2.0.0")
     .description("Write your GitHub Actions workflows using TypeScript");
 cli
     .command("build")
     .description("Transpile all Gat templates into GitHub Actions workflows.")
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
-    if (!fs.existsSync(path.join(folder, "..", "workflows"))) {
-        fs.mkdirSync(path.join(folder, "..", "workflows"));
+    .action(async () => {
+    if (!fs_1.default.existsSync(path_1.default.join(folder, "..", "workflows"))) {
+        fs_1.default.mkdirSync(path_1.default.join(folder, "..", "workflows"));
     }
-    yield execPromise(`npx tsx ${path.join(folder, "index.ts")}`);
+    await execPromise(`npx tsx ${path_1.default.join(folder, "index.ts")}`);
     process.exit(0);
-}));
+});
 cli.parse(process.argv);

package/dist/event.d.ts

@@ -0,0 +1,40 @@
+export type EventName = "push" | "pull_request" | "pull_request_review" | "workflow_run" | "workflow_dispatch" | "schedule" | "pull_request_target" | "repository_dispatch";
+export type EventOptions<T extends EventName> = T extends "push" ? PushEventOptions : T extends "pull_request" ? PullRequestEventOptions : T extends "pull_request_review" ? PullRequestReviewEventOptions : T extends "workflow_run" ? WorkflowRunEventOptions : T extends "workflow_dispatch" ? WorkflowDispatchEventOptions : T extends "schedule" ? ScheduleEventOptions : T extends "repository_dispatch" ? RepositoryDispatchEventOptions : never;
+interface PushEventOptions {
+    branches?: string[];
+    paths?: string[];
+}
+interface PullRequestEventOptions {
+    branches?: string[];
+    paths?: string[];
+    types?: Array<"opened" | "closed" | "reopened" | "synchronize" | "labeled" | "unlabeled">;
+}
+interface PullRequestReviewEventOptions {
+    types?: Array<"submitted">;
+}
+interface WorkflowRunEventOptions {
+    workflows?: string[];
+    types?: Array<"completed">;
+    branches?: string[];
+}
+interface WorkflowDispatchInput {
+    description: string;
+    required?: boolean;
+    type?: "choice" | "boolean" | "string";
+    options?: string[];
+    default?: string | boolean;
+}
+interface WorkflowDispatchEventOptions {
+    inputs?: Record<string, WorkflowDispatchInput>;
+}
+type ScheduleEventOptions = Array<{
+    cron: string;
+}>;
+interface RepositoryDispatchEventOptions {
+    types: string[];
+}
+export interface Event {
+    name: EventName;
+    options?: EventOptions<EventName>;
+}
+export {};

package/dist/event.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Workflow } from "./workflow";
+import { type ConcurrencyGroup, type JobOptions, type Matrix, type Service } from "./job";
+import { type RunStep, type UseStep, type BaseStep } from "./step";
+export { Workflow, RunStep, UseStep, BaseStep, ConcurrencyGroup, JobOptions, Matrix, Service, };

package/dist/index.js

@@ -1,2 +1,5 @@
-import { Workflow } from "./workflow";
-export { Workflow, };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+const workflow_1 = require("./workflow");
+Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return workflow_1.Workflow; } });

package/dist/job.d.ts

@@ -0,0 +1,42 @@
+export interface ConcurrencyGroup {
+    groupSuffix: string;
+    cancelPrevious: boolean;
+}
+export interface Matrix {
+    elements: Array<{
+        id: string;
+        options: Array<string | number | boolean>;
+    }>;
+    extra?: Array<Record<string, string | number | boolean>>;
+}
+export interface Service {
+    image: string;
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    env?: Record<string, string>;
+    ports: string[];
+    options?: string;
+    volumes?: string[];
+}
+export interface JobOptions<Step, RunnerDefinition, Name> {
+    prettyName?: string;
+    permissions?: object;
+    ifExpression?: string;
+    runsOn?: RunnerDefinition;
+    timeout?: number;
+    dependsOn?: Array<Name>;
+    services?: Record<string, Service>;
+    env?: Record<string, string>;
+    concurrency?: ConcurrencyGroup;
+    matrix?: Matrix | string;
+    steps: Step[];
+    outputs?: Record<string, string>;
+    workingDirectory?: string;
+}
+export type StringWithNoSpaces<T> = T extends `${string} ${string}` ? never : T extends ` ${string}` ? never : T extends `${string} ` ? never : T;
+export interface Job<Step, RunnerDefinition, Name> {
+    name: string;
+    options: JobOptions<Step, RunnerDefinition, Name>;
+}

package/dist/job.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/step.d.ts

@@ -0,0 +1,18 @@
+export interface BaseStep {
+    id?: string;
+    name?: string;
+    env?: Record<string, string>;
+    ifExpression?: string;
+    workingDirectory?: string;
+    continueOnError?: boolean;
+    timeout?: number;
+}
+export type Step = RunStep | UseStep;
+export interface RunStep extends BaseStep {
+    run: string;
+}
+export interface UseStep extends BaseStep {
+    uses: string;
+    with?: Record<string, string | number | boolean>;
+}
+export declare const isUseStep: (step: Step) => step is UseStep;

package/dist/step.js

@@ -1,3 +1,7 @@
-export const isUseStep = (step) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUseStep = void 0;
+const isUseStep = (step) => {
     return step.uses !== undefined;
 };
+exports.isUseStep = isUseStep;

package/dist/workflow.d.ts

@@ -0,0 +1,31 @@
+import { ConcurrencyGroup, Job, JobOptions, StringWithNoSpaces } from "./job";
+import type { Event, EventName, EventOptions } from "./event";
+import { type Step } from "./step";
+interface DefaultOptions {
+    workingDirectory: string;
+}
+interface EnvVar {
+    name: string;
+    value: string;
+}
+export type RunnerDefinition = string | {
+    group: string;
+    labels?: string[];
+} | ["self-hosted", string];
+export declare class Workflow<JobStep extends Step = Step, Runner extends RunnerDefinition = RunnerDefinition, JobName = never> {
+    name: string;
+    events: Event[];
+    jobs: Array<Job<JobStep, Runner, JobName>>;
+    defaultOptions: DefaultOptions | null;
+    env: EnvVar[];
+    concurrencyGroup?: ConcurrencyGroup;
+    constructor(name: string);
+    on<T extends EventName>(name: T, options?: EventOptions<T>): this;
+    addDefaults(options: DefaultOptions): this;
+    addJob<T extends string>(name: StringWithNoSpaces<T>, options: JobOptions<JobStep, Runner, JobName>): Workflow<JobStep, Runner, JobName | T>;
+    setEnv(name: string, value: string): this;
+    setConcurrencyGroup(concurrencyGroup: ConcurrencyGroup): this;
+    defaultRunner(): string;
+    compile(filepath?: string): Promise<string | void>;
+}
+export {};

package/dist/workflow.js

@@ -1,35 +1,20 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { dump } from "js-yaml";
-import kebabCase from "lodash/kebabCase";
-import fs from "fs";
-import path from "path";
-import { promisify } from "util";
-import axios from "axios";
-import { isUseStep } from "./step";
-const writeFilePromise = promisify(fs.writeFile);
-const DEFAULT_RUNNERS = ["ubuntu-22.04"];
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+const js_yaml_1 = require("js-yaml");
+const kebabCase_1 = __importDefault(require("lodash/kebabCase"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const axios_1 = __importDefault(require("axios"));
+const step_1 = require("./step");
+const writeFilePromise = (0, util_1.promisify)(fs_1.default.writeFile);
 const chainAttackCache = {};
-const supplyChainAttack = (step, enabled = false) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!isUseStep(step))
+const supplyChainAttack = async (step, enabled = false) => {
+    if (!(0, step_1.isUseStep)(step))
         return;
     if (!enabled)
         return step.uses;
@@ -42,7 +27,7 @@ const supplyChainAttack = (step, enabled = false) => __awaiter(void 0, void 0, v
     if (!match)
         return uses;
     const { repository, version } = match.groups;
-    const response = yield axios.get(`https://api.github.com/repos/${repository}/tags`);
+    const response = await axios_1.default.get(`https://api.github.com/repos/${repository}/tags`);
     const tags = response.data;
     const tag = tags.find((tag) => tag.name === version);
     if (!tag)
@@ -50,8 +35,8 @@ const supplyChainAttack = (step, enabled = false) => __awaiter(void 0, void 0, v
     const result = `${repository}@${tag.commit.sha}`;
     chainAttackCache[uses] = result;
     return result;
-});
-export class Workflow {
+};
+class Workflow {
     constructor(name) {
         this.name = name;
         this.events = [];
@@ -82,89 +67,92 @@ export class Workflow {
     defaultRunner() {
         return "ubuntu-22.04";
     }
-    assignRunner(runsOn) {
-        const runnerName = runsOn !== null && runsOn !== void 0 ? runsOn : this.defaultRunner();
-        const isSelfHosted = !DEFAULT_RUNNERS.includes(runnerName);
-        return isSelfHosted ? ["self-hosted", runnerName] : runnerName;
-    }
-    compile(filepath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = {
-                name: this.name,
-                on: Object.fromEntries(this.events.map(({ name, options }) => [
-                    name,
-                    options ? options : null,
-                ])),
-                concurrency: this.concurrencyGroup
-                    ? {
-                        group: this.concurrencyGroup.groupSuffix,
-                        "cancel-in-progress": this.concurrencyGroup.cancelPrevious,
-                    }
-                    : undefined,
-                defaults: this.defaultOptions
-                    ? {
-                        run: {
-                            "working-directory": this.defaultOptions.workingDirectory,
-                        },
-                    }
-                    : undefined,
-                env: this.env.length > 0
-                    ? Object.fromEntries(this.env.map(({ name, value }) => [name, value]))
-                    : undefined,
-                jobs: Object.fromEntries(yield Promise.all(this.jobs.map(({ name, options: { prettyName, permissions, ifExpression, runsOn, matrix, env, steps, dependsOn, services, timeout, concurrency, outputs, workingDirectory, }, }) => __awaiter(this, void 0, void 0, function* () {
-                    return [
-                        name,
-                        {
-                            name: prettyName,
-                            permissions,
+    async compile(filepath) {
+        const result = {
+            name: this.name,
+            on: Object.fromEntries(this.events.map(({ name, options }) => [
+                name,
+                options ? options : null,
+            ])),
+            concurrency: this.concurrencyGroup
+                ? {
+                    group: this.concurrencyGroup.groupSuffix,
+                    "cancel-in-progress": this.concurrencyGroup.cancelPrevious,
+                }
+                : undefined,
+            defaults: this.defaultOptions
+                ? {
+                    run: {
+                        "working-directory": this.defaultOptions.workingDirectory,
+                    },
+                }
+                : undefined,
+            env: this.env.length > 0
+                ? Object.fromEntries(this.env.map(({ name, value }) => [name, value]))
+                : undefined,
+            jobs: Object.fromEntries(await Promise.all(this.jobs.map(async ({ name, options: { prettyName, permissions, ifExpression, runsOn, matrix, env, steps, dependsOn, services, timeout, concurrency, outputs, workingDirectory, }, }) => [
+                name,
+                {
+                    name: prettyName,
+                    permissions,
+                    if: ifExpression,
+                    "runs-on": runsOn ?? this.defaultRunner(),
+                    "timeout-minutes": timeout ?? 15,
+                    needs: dependsOn,
+                    services,
+                    concurrency: concurrency
+                        ? {
+                            group: `${(0, kebabCase_1.default)(this.name)}-${name}-${concurrency.groupSuffix}`,
+                            "cancel-in-progress": concurrency.cancelPrevious,
+                        }
+                        : undefined,
+                    strategy: matrix
+                        ? {
+                            "fail-fast": false,
+                            matrix: typeof matrix === "string"
+                                ? matrix
+                                : {
+                                    ...Object.fromEntries(matrix.elements.map(({ id, options }) => [
+                                        id,
+                                        options,
+                                    ])),
+                                    include: matrix.extra,
+                                },
+                        }
+                        : undefined,
+                    env,
+                    defaults: workingDirectory
+                        ? {
+                            run: {
+                                "working-directory": workingDirectory,
+                            },
+                        }
+                        : undefined,
+                    steps: await Promise.all(steps.map(async (step) => {
+                        const { id, name, ifExpression, workingDirectory, continueOnError, timeout, ...options } = step;
+                        return {
+                            id,
+                            name,
                             if: ifExpression,
-                            "runs-on": this.assignRunner(runsOn),
-                            "timeout-minutes": timeout !== null && timeout !== void 0 ? timeout : 15,
-                            needs: dependsOn,
-                            services,
-                            concurrency: concurrency
-                                ? {
-                                    group: `${kebabCase(this.name)}-${name}-${concurrency.groupSuffix}`,
-                                    "cancel-in-progress": concurrency.cancelPrevious,
-                                }
-                                : undefined,
-                            strategy: matrix
-                                ? {
-                                    "fail-fast": false,
-                                    matrix: typeof matrix === "string"
-                                        ? matrix
-                                        : Object.assign(Object.assign({}, Object.fromEntries(matrix.elements.map(({ id, options }) => [
-                                            id,
-                                            options,
-                                        ]))), { include: matrix.extra }),
-                                }
-                                : undefined,
-                            env,
-                            defaults: workingDirectory
-                                ? {
-                                    run: {
-                                        "working-directory": workingDirectory,
-                                    },
-                                }
-                                : undefined,
-                            steps: yield Promise.all(steps.map((step) => __awaiter(this, void 0, void 0, function* () {
-                                const { id, name, ifExpression, workingDirectory, continueOnError, timeout } = step, options = __rest(step, ["id", "name", "ifExpression", "workingDirectory", "continueOnError", "timeout"]);
-                                return Object.assign(Object.assign({ id,
-                                    name, if: ifExpression, "continue-on-error": continueOnError, "working-directory": workingDirectory, "timeout-minutes": timeout }, options), { uses: yield supplyChainAttack(step) });
-                            }))),
-                            outputs,
-                        },
-                    ];
-                })))),
-            };
-            const compiled = `# Workflow automatically generated by gat\n# DO NOT CHANGE THIS FILE MANUALLY\n\n${dump(result, {
-                noRefs: true,
-                lineWidth: 200,
-                noCompatMode: true,
-            })}`;
-            if (!filepath)
-                return compiled;
-            return writeFilePromise(path.join(process.cwd(), ".github", "workflows", filepath), compiled);
-        });
+                            "continue-on-error": continueOnError,
+                            "working-directory": workingDirectory,
+                            "timeout-minutes": timeout,
+                            ...options,
+                            uses: await supplyChainAttack(step),
+                        };
+                    })),
+                    outputs,
+                },
+            ]))),
+        };
+        const compiled = `# Workflow automatically generated by gat\n# DO NOT CHANGE THIS FILE MANUALLY\n\n${(0, js_yaml_1.dump)(result, {
+            noRefs: true,
+            lineWidth: 200,
+            noCompatMode: true,
+        })}`;
+        if (!filepath)
+            return compiled;
+        return writeFilePromise(path_1.default.join(process.cwd(), ".github", "workflows", filepath), compiled);
     }
 }
+exports.Workflow = Workflow;

package/dist/workflow.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow.spec.js

@@ -1,17 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { describe, it, expect } from "vitest";
-import { Workflow } from "./workflow";
-describe("Workflow", () => {
-    it("generates a simple workflow", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Simple");
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const workflow_1 = require("./workflow");
+(0, vitest_1.describe)("Workflow", () => {
+    (0, vitest_1.it)("generates a simple workflow", async () => {
+        const workflow = new workflow_1.Workflow("Simple");
         workflow
             .on("pull_request", { types: ["opened"] })
             .addJob("job1", {
@@ -21,20 +14,20 @@ describe("Workflow", () => {
             steps: [{ name: "Do something else", run: "exit 0" }],
             dependsOn: ["job1"],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows multiple events", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Multiple events");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows multiple events", async () => {
+        const workflow = new workflow_1.Workflow("Multiple events");
         workflow
             .on("push", { branches: ["main"] })
             .on("pull_request", { types: ["opened"] })
             .addJob("job1", {
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows declaring default options", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Default options");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows declaring default options", async () => {
+        const workflow = new workflow_1.Workflow("Default options");
         workflow
             .on("push", { branches: ["main"] })
             .addDefaults({
@@ -43,10 +36,10 @@ describe("Workflow", () => {
             .addJob("job1", {
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows declaring environment variables", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("With Environment variables");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows declaring environment variables", async () => {
+        const workflow = new workflow_1.Workflow("With Environment variables");
         workflow
             .on("push")
             .setEnv("NODE_VERSION", "16")
@@ -59,10 +52,10 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows using a concurrency group", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Concurrency group");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows using a concurrency group", async () => {
+        const workflow = new workflow_1.Workflow("Concurrency group");
         workflow.on("push").addJob("job1", {
             concurrency: {
                 groupSuffix: "foo",
@@ -74,10 +67,10 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows using outputs", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Using outputs");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows using outputs", async () => {
+        const workflow = new workflow_1.Workflow("Using outputs");
         workflow.on("push").addJob("job1", {
             steps: [
                 {
@@ -89,10 +82,10 @@ describe("Workflow", () => {
                 "random-number": "${{ steps.random-number.outputs.random-number }}",
             },
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows conditional jobs", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Conditional job");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows conditional jobs", async () => {
+        const workflow = new workflow_1.Workflow("Conditional job");
         workflow.on("push").addJob("job1", {
             ifExpression: "${{ github.ref != 'refs/heads/main' }}",
             steps: [
@@ -101,10 +94,10 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows a job matrix", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Conditional job");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows a job matrix", async () => {
+        const workflow = new workflow_1.Workflow("Conditional job");
         workflow.on("push").addJob("job1", {
             matrix: {
                 elements: [
@@ -131,10 +124,10 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows uses steps", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Uses steps");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows uses steps", async () => {
+        const workflow = new workflow_1.Workflow("Uses steps");
         workflow
             .on("push")
             .setEnv("NODE_VERSION", "16")
@@ -149,12 +142,12 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows custom types in a workflow", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("With custom types");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows custom types in a workflow", async () => {
+        const workflow = new workflow_1.Workflow("With custom types");
         workflow.on("push").addJob("job1", {
-            runsOn: "standard-runner",
+            runsOn: ["self-hosted", "standard-runner"],
             steps: [
                 {
                     run: "echo 'Do something'",
@@ -167,10 +160,10 @@ describe("Workflow", () => {
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("support workflow dispatch event", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Workflow dispatch");
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("support workflow dispatch event", async () => {
+        const workflow = new workflow_1.Workflow("Workflow dispatch");
         workflow
             .on("workflow_dispatch", {
             inputs: {
@@ -188,27 +181,27 @@ describe("Workflow", () => {
             .addJob("job1", {
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("supports schedule event", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Schedule")
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("supports schedule event", async () => {
+        const workflow = new workflow_1.Workflow("Schedule")
             .on("schedule", [{ cron: "0 4 * * 1-5" }])
             .addJob("job1", {
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("supports a pretty name for the job", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Job with pretty name")
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("supports a pretty name for the job", async () => {
+        const workflow = new workflow_1.Workflow("Job with pretty name")
             .on("push")
             .addJob("job1", {
             prettyName: "My pretty name",
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows permissions into jobs", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Job with permissions")
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows permissions into jobs", async () => {
+        const workflow = new workflow_1.Workflow("Job with permissions")
             .on("push")
             .addJob("job1", {
             permissions: {
@@ -217,10 +210,10 @@ describe("Workflow", () => {
             },
             steps: [{ name: "Do something", run: "exit 0" }],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows multiline strings", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Multiline strings")
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows multiline strings", async () => {
+        const workflow = new workflow_1.Workflow("Multiline strings")
             .on("push")
             .addJob("job1", {
             steps: [
@@ -231,10 +224,10 @@ exit 0`,
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
-    it("allows concurrency groups at workflow level", () => __awaiter(void 0, void 0, void 0, function* () {
-        const workflow = new Workflow("Concurrency at workflow level")
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows concurrency groups at workflow level", async () => {
+        const workflow = new workflow_1.Workflow("Concurrency at workflow level")
             .on("push")
             .setConcurrencyGroup({
             groupSuffix: "${{ github.workflow }}-${{ github.ref }}",
@@ -248,6 +241,6 @@ exit 0`,
                 },
             ],
         });
-        expect(yield workflow.compile()).toMatchSnapshot();
-    }));
+        (0, vitest_1.expect)(await workflow.compile()).toMatchSnapshot();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorialco/gat",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Write your GitHub Actions workflows using TypeScript",
   "bin": {
     "gat": "dist/cli.js"
@@ -11,16 +11,6 @@
     "dist/**/*"
   ],
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "prepare": "npm run build",
-    "prepublishOnly": "vitest run",
-    "test": "vitest",
-    "coverage": "vitest run --coverage",
-    "lint": "eslint src/**/*.ts",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  },
   "author": "David Morcillo <david.morcillo@factorial.co>",
   "license": "ISC",
   "devDependencies": {
@@ -49,5 +39,13 @@
   "bugs": {
     "url": "https://github.com/factorialco/gat/issues"
   },
-  "homepage": "https://github.com/factorialco/gat#readme"
-}
+  "homepage": "https://github.com/factorialco/gat#readme",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  }
+}