@catladder/pipeline 0.0.0-next-e7541a00 → 0.0.0-next-4e7c6848

package/dist/backends/github/GithubBackend.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from "../../types";
+import type { GithubWorkflow } from "../../types/github-types";
+import type { PipelineBackend, PipelineFile } from "../types";
+export declare class GithubBackend implements PipelineBackend {
+  readonly type: "github";
+  cleanup(): Promise<void>;
+  createFiles(config: Config): Promise<PipelineFile[]>;
+  /**
+   * all workflows keyed by file name, mainly for testing purposes
+   */
+  createWorkflows(config: Config): Promise<Record<string, GithubWorkflow>>;
+}

package/dist/backends/github/GithubBackend.js

@@ -0,0 +1,435 @@
+"use strict";
+
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+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());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = this && this.__values || function (o) {
+  var s = typeof Symbol === "function" && Symbol.iterator,
+    m = s && o[s],
+    i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function () {
+      if (o && i >= o.length) o = void 0;
+      return {
+        value: o && o[i++],
+        done: !o
+      };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GithubBackend = void 0;
+var promises_1 = require("fs/promises");
+var path_1 = require("path");
+var createAllJobs_1 = require("../../pipeline/createAllJobs");
+var config_1 = require("../../types/config");
+var ciVariables_1 = require("./ciVariables");
+var createGithubJobs_1 = require("./createGithubJobs");
+var githubReleaseJobs_1 = require("./githubReleaseJobs");
+var WORKFLOWS_FOLDER = ".github/workflows";
+/**
+ * generated workflow files are prefixed so that cleanup never touches
+ * user-maintained workflows in the same folder
+ */
+var GENERATED_FILE_PREFIX = "catladder-";
+var TRIGGER_WORKFLOWS = {
+  mr: {
+    name: "catladder review",
+    on: {
+      pull_request: {
+        types: ["opened", "synchronize", "reopened"]
+      }
+    },
+    concurrency: {
+      group: "catladder-review-${{ github.event.number }}",
+      "cancel-in-progress": true
+    }
+  },
+  mainBranch: {
+    name: "catladder main",
+    // TODO: make the default branch configurable
+    on: {
+      push: {
+        branches: ["main"]
+      }
+    }
+  },
+  taggedRelease: {
+    name: "catladder release",
+    on: {
+      push: {
+        tags: ["v*"]
+      }
+    }
+  }
+};
+var GithubBackend = /** @class */function () {
+  function GithubBackend() {
+    this.type = "github";
+  }
+  GithubBackend.prototype.cleanup = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var entries;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, (0, promises_1.readdir)(WORKFLOWS_FOLDER).catch(function () {
+              return [];
+            })];
+          case 1:
+            entries = _a.sent();
+            return [4 /*yield*/, Promise.all(entries.filter(function (file) {
+              return file.startsWith(GENERATED_FILE_PREFIX);
+            }).map(function (file) {
+              return (0, promises_1.unlink)((0, path_1.join)(WORKFLOWS_FOLDER, file));
+            }))];
+          case 2:
+            _a.sent();
+            return [2 /*return*/];
+        }
+      });
+    });
+  };
+  GithubBackend.prototype.createFiles = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var workflows;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, this.createWorkflows(config)];
+          case 1:
+            workflows = _a.sent();
+            return [2 /*return*/, Object.entries(workflows).map(function (_a) {
+              var _b = __read(_a, 2),
+                fileName = _b[0],
+                workflow = _b[1];
+              return {
+                path: (0, path_1.join)(WORKFLOWS_FOLDER, fileName),
+                content: workflow
+              };
+            })];
+        }
+      });
+    });
+  };
+  /**
+   * all workflows keyed by file name, mainly for testing purposes
+   */
+  GithubBackend.prototype.createWorkflows = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var workflows, reviewStopJobs, manualJobs, _loop_1, this_1, ALL_PIPELINE_TRIGGERS_1, ALL_PIPELINE_TRIGGERS_1_1, trigger, e_1_1;
+      var e_1, _a;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            workflows = {};
+            reviewStopJobs = {};
+            manualJobs = {};
+            _loop_1 = function (trigger) {
+              var allJobs, uploadProviderIds, jobs, releaseJobs;
+              return __generator(this, function (_c) {
+                switch (_c.label) {
+                  case 0:
+                    return [4 /*yield*/, (0, createAllJobs_1.createAllJobs)({
+                      config: config,
+                      trigger: trigger,
+                      pipelineType: this_1.type
+                    })];
+                  case 1:
+                    allJobs = _c.sent();
+                    uploadProviderIds = (0, createGithubJobs_1.getUploadProviderIds)(allJobs);
+                    jobs = {};
+                    // NOTE: agent jobs are gitlab-only and skipped on github
+                    __spreadArray(__spreadArray([], __read(allJobs.workspaces), false), __read(allJobs.components), false).forEach(function (_a) {
+                      var context = _a.context,
+                        contextJobs = _a.jobs;
+                      return contextJobs.forEach(function (job) {
+                        var _a = __read((0, createGithubJobs_1.makeGithubJob)(context, job, allJobs, uploadProviderIds), 2),
+                          id = _a[0],
+                          githubJob = _a[1];
+                        if (isReviewStopJob(context, job)) {
+                          reviewStopJobs[id] = githubJob;
+                        } else if (isManualTaskJob(job)) {
+                          manualJobs[id] = githubJob;
+                        } else {
+                          jobs[id] = githubJob;
+                        }
+                      });
+                    });
+                    if (trigger === "mainBranch") {
+                      releaseJobs = (0, githubReleaseJobs_1.getGithubReleaseJobs)(config, Object.keys(jobs));
+                      Object.assign(jobs, releaseJobs.main);
+                      Object.assign(manualJobs, releaseJobs.manual);
+                    }
+                    if (Object.keys(jobs).length > 0) {
+                      workflows["".concat(GENERATED_FILE_PREFIX).concat(workflowFileName(trigger))] = __assign(__assign({}, TRIGGER_WORKFLOWS[trigger]), {
+                        env: ciVariables_1.GITHUB_INJECTED_WORKFLOW_ENV,
+                        jobs: jobs
+                      });
+                    }
+                    return [2 /*return*/];
+                }
+              });
+            };
+            this_1 = this;
+            _b.label = 1;
+          case 1:
+            _b.trys.push([1, 6, 7, 8]);
+            ALL_PIPELINE_TRIGGERS_1 = __values(config_1.ALL_PIPELINE_TRIGGERS), ALL_PIPELINE_TRIGGERS_1_1 = ALL_PIPELINE_TRIGGERS_1.next();
+            _b.label = 2;
+          case 2:
+            if (!!ALL_PIPELINE_TRIGGERS_1_1.done) return [3 /*break*/, 5];
+            trigger = ALL_PIPELINE_TRIGGERS_1_1.value;
+            return [5 /*yield**/, _loop_1(trigger)];
+          case 3:
+            _b.sent();
+            _b.label = 4;
+          case 4:
+            ALL_PIPELINE_TRIGGERS_1_1 = ALL_PIPELINE_TRIGGERS_1.next();
+            return [3 /*break*/, 2];
+          case 5:
+            return [3 /*break*/, 8];
+          case 6:
+            e_1_1 = _b.sent();
+            e_1 = {
+              error: e_1_1
+            };
+            return [3 /*break*/, 8];
+          case 7:
+            try {
+              if (ALL_PIPELINE_TRIGGERS_1_1 && !ALL_PIPELINE_TRIGGERS_1_1.done && (_a = ALL_PIPELINE_TRIGGERS_1.return)) _a.call(ALL_PIPELINE_TRIGGERS_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+            return [7 /*endfinally*/];
+          case 8:
+            if (Object.keys(reviewStopJobs).length > 0) {
+              workflows["".concat(GENERATED_FILE_PREFIX, "review-stop.yml")] = {
+                name: "catladder review stop",
+                on: {
+                  pull_request: {
+                    types: ["closed"]
+                  }
+                },
+                env: ciVariables_1.GITHUB_INJECTED_WORKFLOW_ENV,
+                jobs: reviewStopJobs
+              };
+            }
+            if (Object.keys(manualJobs).length > 0) {
+              workflows["".concat(GENERATED_FILE_PREFIX, "manual.yml")] = {
+                name: "catladder manual tasks",
+                on: {
+                  workflow_dispatch: {
+                    inputs: {
+                      job: {
+                        description: "the task to run",
+                        required: true,
+                        type: "choice",
+                        options: Object.keys(manualJobs)
+                      }
+                    }
+                  }
+                },
+                env: ciVariables_1.GITHUB_INJECTED_WORKFLOW_ENV,
+                jobs: Object.fromEntries(Object.entries(manualJobs).map(function (_a) {
+                  var _b = __read(_a, 2),
+                    id = _b[0],
+                    job = _b[1];
+                  return [id, __assign(__assign({}, job), {
+                    if: "${{ inputs.job == '".concat(id, "' }}")
+                  })];
+                }))
+              };
+            }
+            return [2 /*return*/, workflows];
+        }
+      });
+    });
+  };
+  return GithubBackend;
+}();
+exports.GithubBackend = GithubBackend;
+var workflowFileName = function (trigger) {
+  switch (trigger) {
+    case "mr":
+      return "review.yml";
+    case "mainBranch":
+      return "main.yml";
+    case "taggedRelease":
+      return "release.yml";
+  }
+  throw new Error("".concat(trigger, " is not supported"));
+};
+/**
+ * stop jobs of review environments run in their own workflow when the
+ * pull request is closed (the counterpart of gitlab's on_stop wiring)
+ */
+var isReviewStopJob = function (context, job) {
+  var _a;
+  return ((_a = job.environment) === null || _a === void 0 ? void 0 : _a.action) === "stop" && context.type === "component" && context.environment.envType === "review";
+};
+/**
+ * stop/rollback jobs of non-review environments have no automatic
+ * trigger; they are collected in a workflow_dispatch workflow
+ * (gitlab runs them as manual jobs inside the pipeline)
+ */
+var isManualTaskJob = function (job) {
+  return job.stage === "stop" || job.stage === "rollback";
+};

package/dist/backends/github/ciVariables.d.ts

@@ -0,0 +1,14 @@
+import type { CiVariableName } from "../../bash/ciVariables";
+/**
+ * how the github backend names the predefined CI variables.
+ *
+ * GITHUB_* variables are provided by github actions natively; the CL_*
+ * variables are injected by the {@link GithubBackend} itself (workflow or
+ * job level), because github has no direct counterpart.
+ */
+export declare const GITHUB_CI_VARIABLES: Record<CiVariableName, string>;
+/**
+ * the workflow-level env the backend injects to provide the CL_*
+ * variables referenced by {@link GITHUB_CI_VARIABLES}
+ */
+export declare const GITHUB_INJECTED_WORKFLOW_ENV: Record<string, string>;

package/dist/backends/github/ciVariables.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GITHUB_INJECTED_WORKFLOW_ENV = exports.GITHUB_CI_VARIABLES = void 0;
+/**
+ * how the github backend names the predefined CI variables.
+ *
+ * GITHUB_* variables are provided by github actions natively; the CL_*
+ * variables are injected by the {@link GithubBackend} itself (workflow or
+ * job level), because github has no direct counterpart.
+ */
+exports.GITHUB_CI_VARIABLES = {
+  commitSha: "GITHUB_SHA",
+  jobToken: "CL_JOB_TOKEN",
+  jobImage: "CL_JOB_IMAGE",
+  registry: "CL_REGISTRY",
+  registryImage: "CL_REGISTRY_IMAGE"
+};
+/**
+ * the workflow-level env the backend injects to provide the CL_*
+ * variables referenced by {@link GITHUB_CI_VARIABLES}
+ */
+exports.GITHUB_INJECTED_WORKFLOW_ENV = {
+  CL_JOB_TOKEN: "${{ github.token }}",
+  CL_REGISTRY: "ghcr.io",
+  CL_REGISTRY_IMAGE: "ghcr.io/${{ github.repository }}",
+  // empty outside of pull request events
+  CL_PR_NUMBER: "${{ github.event.number }}"
+};

package/dist/backends/github/createGithubJobs.d.ts

@@ -0,0 +1,17 @@
+import type { AllCatladderJobs } from "../../pipeline/createAllJobs";
+import type { Context } from "../../types";
+import type { GithubJob } from "../../types/github-types";
+import type { CatladderJob } from "../../types/jobs";
+export declare const githubJobId: (context: Context, jobName: string) => string;
+type ResolvedNeed = {
+  id: string;
+  artifacts: boolean;
+};
+export declare const resolveGithubNeeds: (context: Context, job: CatladderJob, allJobs: AllCatladderJobs) => ResolvedNeed[];
+export declare const makeGithubJob: (context: Context, job: CatladderJob, allJobs: AllCatladderJobs, uploadProviderIds: Set<string>) => [id: string, githubJob: GithubJob];
+/**
+ * the ids of all jobs whose artifacts are consumed by other jobs
+ * (they need an upload step)
+ */
+export declare const getUploadProviderIds: (allJobs: AllCatladderJobs) => Set<string>;
+export {};