@factorialco/gat 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# GitHub Actions Template Generator (aka GAT)
+
+TODO

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 cli = new commander_1.Command();
+cli.version("0.0.1").description("TODO");
+cli
+    .command("build")
+    .description("TODO")
+    .action(async () => {
+    const folder = path_1.default.join(process.cwd(), ".github", "templates");
+    if (!fs_1.default.existsSync(path_1.default.join(folder, "..", "workflows"))) {
+        fs_1.default.mkdirSync(path_1.default.join(folder, "..", "workflows"));
+    }
+    for await (const templateFile of fs_1.default.readdirSync(folder)) {
+        if (!templateFile.match(/^shared$/)) {
+            const { stdout } = await execPromise(`npx ts-node ${path_1.default.join(folder, templateFile)}`);
+            fs_1.default.writeFileSync(path_1.default.join(folder, "..", "workflows", templateFile.replace(".ts", ".yml")), stdout);
+        }
+    }
+    process.exit(0);
+});
+cli.parse(process.argv);

package/dist/event.d.ts

@@ -0,0 +1,15 @@
+export declare type EventName = "push" | "pull_request";
+export declare type EventOptions<T extends EventName> = T extends "push" ? PushEventOptions : T extends "pull_request" ? PullRequestEventOptions : never;
+interface PushEventOptions {
+    branches?: string[];
+    paths?: string[];
+}
+interface PullRequestEventOptions {
+    types?: Array<"opened" | "reopened" | "synchronize">;
+    paths?: string[];
+}
+export interface Event {
+    name: EventName;
+    options?: EventOptions<EventName>;
+}
+export {};

package/dist/event.js

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"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,108 @@
+declare type Step = RunStep | {
+    [Name in ActionName]: UseStep<Name>;
+}[ActionName];
+interface BaseStep {
+    id?: string;
+    name?: string;
+    env?: Record<string, string>;
+    ifExpression?: string;
+    workingDirectory?: string;
+}
+export interface RunStep extends BaseStep {
+    run: string;
+}
+declare type ActionName = "actions/checkout@v3" | "actions/setup-node@v3" | "actions/upload-artifact@v3" | "actions/download-artifact@v3" | "ruby/setup-ruby@v1" | "dorny/paths-filter@v2" | "tespkg/actions-cache@v1" | "prewk/s3-cp-action@v2" | "chromaui/action@v1" | "rtCamp/action-slack-notify@v2" | "factorialco/delta-action@v3.0.0" | "factorialco/test-summary-action@v1.2.0";
+export interface UseStep<T extends ActionName> extends BaseStep {
+    uses: T;
+    with?: StepOptions<T>;
+}
+declare type StepOptions<T extends ActionName> = T extends "actions/checkout@v3" ? {
+    ref?: string;
+    "fetch-depth"?: number;
+} : T extends "actions/setup-node@v3" ? {
+    "node-version": string;
+} : T extends "actions/upload-artifact@v3" ? {
+    name: string;
+    path: string;
+} : T extends "ruby/setup-ruby@v1" ? {
+    "ruby-version": string;
+    "cache-version"?: number;
+    "bundler-cache"?: boolean;
+    "working-directory"?: string;
+} : T extends "dorny/paths-filter@v2" ? {
+    filters: string;
+} : T extends "tespkg/actions-cache@v1" ? {
+    endpoint: string;
+    region: string;
+    bucket: string;
+    accessKey: string;
+    secretKey: string;
+    insecure: string;
+    "use-fallback": boolean;
+    path: string;
+    key: string;
+    "restore-keys": string;
+} : T extends "prewk/s3-cp-action@v2" ? {
+    source: string;
+    dest: string;
+    aws_s3_endpoint: string;
+    aws_region: string;
+    aws_access_key_id: string;
+    aws_secret_access_key: string;
+} : T extends "chromaui/action@v1" ? {
+    workingDir: string;
+    token: string;
+    projectToken: string;
+    exitZeroOnChanges?: boolean;
+    autoAcceptChanges?: boolean;
+} : T extends "factorialco/delta-action@v3.0.0" ? {
+    engine: "eslint" | "semgrep" | "rubocop";
+    main: string;
+    branch: string;
+    head_ref: string;
+    forkpoint: string;
+    monorepo_prefix: "frontend" | "backend";
+} : T extends "factorialco/test-summary-action@v1.2.0" ? {
+    engine: "jest" | "rspec";
+    reportFile: string;
+    sha: string;
+} : never;
+declare type Runner = "standard" | "beefy" | "large" | "release" | "standard-aws" | "beefy-aws" | "large-aws" | "release-aws";
+export interface ConcurrencyGroup {
+    groupSuffix: string;
+    cancelPrevious: boolean;
+}
+export interface Matrix {
+    elements: Array<{
+        id: string;
+        options: any[];
+    }>;
+    extra?: Array<Record<string, any>>;
+}
+export interface Service {
+    image: string;
+    credentials?: {
+        username: string;
+        password: string;
+    };
+    env?: Record<string, string>;
+    ports: string[];
+    options?: string;
+}
+export interface JobOptions<JobNames = never> {
+    ifExpression?: string;
+    runsOn?: Runner;
+    timeout?: number;
+    dependsOn?: Array<JobNames>;
+    services?: Record<string, Service>;
+    env?: Record<string, string>;
+    concurrency?: ConcurrencyGroup;
+    matrix?: Matrix;
+    steps: Step[];
+    outputs?: Record<string, string>;
+}
+export interface Job<JobNames> {
+    name: string;
+    options: JobOptions<JobNames>;
+}
+export {};

package/dist/job.js

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

package/dist/workflow.d.ts

@@ -0,0 +1,24 @@
+import { Job, JobOptions } from "./job";
+import type { Event, EventName, EventOptions } from "./event";
+interface DefaultOptions {
+    workingDirectory: string;
+}
+interface EnvVar {
+    name: string;
+    value: string;
+}
+export declare class Workflow<JobNames = never> {
+    name: string;
+    events: Event[];
+    jobs: Array<Job<JobNames>>;
+    defaultOptions: DefaultOptions | null;
+    env: EnvVar[];
+    constructor(name: string);
+    on<T extends EventName>(name: T, options?: EventOptions<T>): this;
+    addDefaults(options: DefaultOptions): this;
+    addJob<JobName extends string>(name: JobName, options: JobOptions<JobNames>): Workflow<JobNames | JobName>;
+    addMergeGatekeeperJob(dependsOn: Array<JobNames>): this;
+    setEnv(name: string, value: any): this;
+    compile(): string;
+}
+export {};

package/dist/workflow.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflow = void 0;
+const yaml_1 = require("yaml");
+const kebabCase_1 = __importDefault(require("lodash/kebabCase"));
+class Workflow {
+    constructor(name) {
+        this.name = name;
+        this.events = [];
+        this.jobs = [];
+        this.defaultOptions = null;
+        this.env = [];
+    }
+    on(name, options) {
+        this.events = [...this.events, { name, options }];
+        return this;
+    }
+    addDefaults(options) {
+        this.defaultOptions = options;
+        return this;
+    }
+    addJob(name, options) {
+        this.jobs = [...this.jobs, { name, options }];
+        return this;
+    }
+    addMergeGatekeeperJob(dependsOn) {
+        this.jobs = [
+            ...this.jobs,
+            {
+                name: "merge_gatekeeper",
+                options: {
+                    ifExpression: "${{ always() }}",
+                    dependsOn,
+                    steps: [
+                        {
+                            workingDirectory: "${{ github.workspace }}",
+                            run: dependsOn
+                                .map((jobName) => `\${{ needs.${jobName}.result == 'success' || needs.${jobName}.result == 'skipped' }}`)
+                                .join(" && "),
+                        },
+                    ],
+                },
+            },
+        ];
+        return this;
+    }
+    setEnv(name, value) {
+        this.env = [...this.env, { name, value }];
+        return this;
+    }
+    compile() {
+        const result = {
+            name: this.name,
+            on: Object.fromEntries(this.events.map(({ name, options }) => [name, options ? options : null])),
+            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(this.jobs.map(({ name, options: { ifExpression, runsOn, matrix, steps, dependsOn, services, timeout, concurrency, outputs, }, }) => [
+                name,
+                {
+                    if: ifExpression,
+                    "runs-on": ["self-hosted", `${runsOn ?? "standard-aws"}-runner`],
+                    "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: {
+                                ...Object.fromEntries(matrix.elements.map(({ id, options }) => [id, options])),
+                                include: matrix.extra,
+                            },
+                        }
+                        : undefined,
+                    steps: steps.map(({ id, name, ifExpression, workingDirectory, ...options }) => ({
+                        id,
+                        name,
+                        if: ifExpression,
+                        "working-directory": workingDirectory,
+                        ...options,
+                    })),
+                    outputs,
+                },
+            ])),
+        };
+        const compiled = `# Template automatically generated by gat\n# DO NOT CHANGE THIS FILE MANUALLY\n\n${(0, yaml_1.stringify)(result, {
+            singleQuote: true,
+            aliasDuplicateObjects: false,
+            lineWidth: 150,
+        })}`;
+        console.log(compiled);
+        return compiled;
+    }
+}
+exports.Workflow = Workflow;

package/dist/workflow.spec.d.ts

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

package/dist/workflow.spec.js

@@ -0,0 +1,155 @@
+"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", () => {
+        const workflow = new workflow_1.Workflow("Simple");
+        workflow
+            .on("pull_request", { types: ["opened"] })
+            .addJob("job1", {
+            runsOn: "standard",
+            steps: [{ name: "Do something", run: "exit 0" }],
+        })
+            .addJob("job2", {
+            runsOn: "standard",
+            steps: [{ name: "Do something else", run: "exit 0" }],
+            dependsOn: ["job1"],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows multiple events", () => {
+        const workflow = new workflow_1.Workflow("Multiple events");
+        workflow
+            .on("push", { branches: ["main"] })
+            .on("pull_request", { types: ["opened"] })
+            .addJob("job1", {
+            runsOn: "standard",
+            steps: [{ name: "Do something", run: "exit 0" }],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows declaring default options", () => {
+        const workflow = new workflow_1.Workflow("Default options");
+        workflow
+            .on("push", { branches: ["main"] })
+            .addDefaults({
+            workingDirectory: "frontend",
+        })
+            .addJob("job1", {
+            runsOn: "standard",
+            steps: [{ name: "Do something", run: "exit 0" }],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows declaring environment variables", () => {
+        const workflow = new workflow_1.Workflow("With Environment variables");
+        workflow
+            .on("push")
+            .setEnv("NODE_VERSION", "16")
+            .setEnv("ENABLED", true)
+            .addJob("job1", {
+            runsOn: "standard",
+            steps: [
+                {
+                    name: "Do something",
+                    run: "echo ${{ env.NODE_VERSION }} && echo ${{ env.ENABLED }}",
+                },
+            ],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows uses steps", () => {
+        const workflow = new workflow_1.Workflow("Uses steps");
+        workflow
+            .on("push")
+            .setEnv("NODE_VERSION", "16")
+            .setEnv("ENABLED", true)
+            .addJob("job1", {
+            runsOn: "standard",
+            steps: [
+                {
+                    uses: "actions/checkout@v3",
+                    with: {
+                        ref: "main",
+                    },
+                },
+            ],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows using a concurrency group", () => {
+        const workflow = new workflow_1.Workflow("Concurrency group");
+        workflow.on("push").addJob("job1", {
+            runsOn: "standard",
+            concurrency: {
+                groupSuffix: "foo",
+                cancelPrevious: true,
+            },
+            steps: [
+                {
+                    run: "echo 0",
+                },
+            ],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows using outputs", () => {
+        const workflow = new workflow_1.Workflow("Using outputs");
+        workflow.on("push").addJob("job1", {
+            runsOn: "standard",
+            steps: [
+                {
+                    id: "random-number",
+                    run: 'echo "::set-output name=random-number::$RANDOM"',
+                },
+            ],
+            outputs: {
+                "random-number": "${{ steps.random-number.outputs.random-number }}",
+            },
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows conditional jobs", () => {
+        const workflow = new workflow_1.Workflow("Conditional job");
+        workflow.on("push").addJob("job1", {
+            ifExpression: "${{ github.ref != 'refs/heads/main' }}",
+            steps: [
+                {
+                    run: "exit 0",
+                },
+            ],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+    (0, vitest_1.it)("allows a job matrix", () => {
+        const workflow = new workflow_1.Workflow("Conditional job");
+        workflow.on("push").addJob("job1", {
+            matrix: {
+                elements: [
+                    {
+                        id: "food",
+                        options: ["🍕", "🍔"],
+                    },
+                    {
+                        id: "topping",
+                        options: ["🍍"],
+                    },
+                ],
+                extra: [
+                    {
+                        food: "🍕",
+                        topping: "🍍",
+                        tasty: true,
+                    },
+                ],
+            },
+            steps: [
+                {
+                    run: "echo ${{ matrix.food }} with ${{ matrix.topping }}",
+                },
+            ],
+        });
+        (0, vitest_1.expect)(workflow.compile()).toMatchSnapshot();
+    });
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@factorialco/gat",
+  "version": "0.0.1",
+  "description": "TODO",
+  "bin": {
+    "gat": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "prepublishOnly": "vitest run",
+    "test": "vitest",
+    "coverage": "vitest run --coverage"
+  },
+  "author": "David Morcillo <david.morcillo@factorial.co>",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/lodash": "^4.14.184",
+    "commander": "^9.4.0",
+    "typescript": "^4.7.4",
+    "vitest": "^0.18.1"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "yaml": "^2.1.1"
+  },
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/factorialco/gat.git"
+  },
+  "bugs": {
+    "url": "https://github.com/factorialco/gat/issues"
+  },
+  "homepage": "https://github.com/factorialco/gat#readme"
+}