@catladder/pipeline 0.0.0-next-95928577 → 0.0.0-next-e7541a00

package/dist/backends/gitlab/GitlabBackend.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "../../types";
+import type { PipelineBackend, PipelineFile } from "../types";
+export declare class GitlabBackend implements PipelineBackend {
+  readonly type: "gitlab";
+  readonly generatedFolder: string;
+  createFiles(config: Config): Promise<PipelineFile[]>;
+  /**
+   * the complete pipeline as one object (all includes merged into one),
+   * mainly for testing purposes
+   */
+  createCompletePipeline(config: Config): Promise<Record<string, unknown>>;
+  private createIncludes;
+  private createPipeline;
+}

package/dist/backends/gitlab/GitlabBackend.js

@@ -0,0 +1,393 @@
+"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 __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;
+};
+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));
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GitlabBackend = void 0;
+var rules_1 = require("../../rules");
+var config_1 = require("../../types/config");
+var createAllJobs_1 = require("../../pipeline/createAllJobs");
+var createGitlabJobs_1 = require("./createGitlabJobs");
+var createGitlabPipeline_1 = require("./createGitlabPipeline");
+var gitlabReleaseJobs_1 = require("./gitlabReleaseJobs");
+var getPipelineStages_1 = require("./getPipelineStages");
+var sortGitLabJobDefProps_1 = require("./sortGitLabJobDefProps");
+var CATLADDER_GENERATED_FOLDER = ".catladder-generated";
+var GITLAB_GENERATED_FOLDER = CATLADDER_GENERATED_FOLDER + "/gitlab";
+var GitlabBackend = /** @class */function () {
+  function GitlabBackend() {
+    this.type = "gitlab";
+    this.generatedFolder = GITLAB_GENERATED_FOLDER;
+  }
+  GitlabBackend.prototype.createFiles = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var includes, mainFile;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, this.createIncludes(config)];
+          case 1:
+            includes = _a.sent();
+            mainFile = {
+              path: ".gitlab-ci.yml",
+              content: {
+                include: includes.map(function (i) {
+                  return i.path;
+                })
+              }
+            };
+            return [2 /*return*/, __spreadArray([mainFile], __read(includes), false)];
+        }
+      });
+    });
+  };
+  /**
+   * the complete pipeline as one object (all includes merged into one),
+   * mainly for testing purposes
+   */
+  GitlabBackend.prototype.createCompletePipeline = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var includes;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, this.createIncludes(config)];
+          case 1:
+            includes = _a.sent();
+            return [2 /*return*/, includes.reduce(function (acc, _a) {
+              var content = _a.content;
+              return __assign(__assign({}, acc), content);
+            }, {})];
+        }
+      });
+    });
+  };
+  GitlabBackend.prototype.createIncludes = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, jobs, image, stages, variables, workflow, pipelineRest, groups, componentIncludes, mainInclude;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4 /*yield*/, this.createPipeline(config)];
+          case 1:
+            _a = _b.sent(), jobs = _a.jobs, image = _a.image, stages = _a.stages, variables = _a.variables, workflow = _a.workflow, pipelineRest = __rest(_a, ["jobs", "image", "stages", "variables", "workflow"]);
+            groups = Object.entries(jobs).reduce(function (acc, _a) {
+              var _b = __read(_a, 2),
+                jobName = _b[0],
+                _c = _b[1],
+                gitlabJob = _c.gitlabJob,
+                context = _c.context;
+              var group = !context ? "global-jobs" : (context === null || context === void 0 ? void 0 : context.type) + "/" + context.name;
+              if (!acc[group]) {
+                acc[group] = {};
+              }
+              acc[group][jobName] = (0, sortGitLabJobDefProps_1.sortGitLabJobDefProps)(gitlabJob); // also sort properties for more consistent diffing
+              return acc;
+            }, {});
+            componentIncludes = Object.entries(groups).map(function (_a) {
+              var _b = __read(_a, 2),
+                group = _b[0],
+                jobs = _b[1];
+              return {
+                path: GITLAB_GENERATED_FOLDER + "/" + group + ".yaml",
+                content: jobs
+              };
+            });
+            mainInclude = {
+              path: GITLAB_GENERATED_FOLDER + "/main.yaml",
+              content: __assign({
+                image: image,
+                stages: stages,
+                variables: variables,
+                workflow: workflow
+              }, pipelineRest)
+            };
+            return [2 /*return*/, __spreadArray([mainInclude], __read(componentIncludes), false)];
+        }
+      });
+    });
+  };
+  GitlabBackend.prototype.createPipeline = function (config) {
+    return __awaiter(this, void 0, void 0, function () {
+      var stages, allJobsPerTrigger, allWorkspaceJobs, allComponentJobs, allGlobalJobs, allJobs;
+      var _this = this;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            stages = (0, getPipelineStages_1.getPipelineStages)(config);
+            return [4 /*yield*/, Promise.all(config_1.ALL_PIPELINE_TRIGGERS.map(function (trigger) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                  switch (_b.label) {
+                    case 0:
+                      _a = createGitlabJobs_1.createGitlabJobs;
+                      return [4 /*yield*/, (0, createAllJobs_1.createAllJobs)({
+                        config: config,
+                        trigger: trigger,
+                        pipelineType: this.type
+                      })];
+                    case 1:
+                      return [4 /*yield*/, _a.apply(void 0, [_b.sent(), getGitlabRulesForTrigger(trigger)])];
+                    case 2:
+                      return [2 /*return*/, _b.sent()];
+                  }
+                });
+              });
+            })).then(function (j) {
+              return j.flat();
+            })];
+          case 1:
+            allJobsPerTrigger = _a.sent();
+            allWorkspaceJobs = allJobsPerTrigger.filter(function (j) {
+              var _a;
+              return ((_a = j.context) === null || _a === void 0 ? void 0 : _a.type) === "workspace";
+            }) // sort by componentName in the same order as they appear in the config
+            // this is purely for better readability in git diffs when you add new components
+            .sort(function (a, b) {
+              var _a;
+              var workspaceNames = Object.keys((_a = config.builds) !== null && _a !== void 0 ? _a : {});
+              var aIndex = workspaceNames.findIndex(function (c) {
+                return c === a.context.name;
+              });
+              var bIndex = workspaceNames.findIndex(function (c) {
+                return c === b.context.name;
+              });
+              return aIndex - bIndex;
+            });
+            allComponentJobs = allJobsPerTrigger.filter(function (j) {
+              var _a;
+              return ((_a = j.context) === null || _a === void 0 ? void 0 : _a.type) === "component";
+            })
+            // sort by componentName in the same order as they appear in the config
+            // this is purely for better readability in git diffs when you add new components
+            .sort(function (a, b) {
+              var componentNames = Object.keys(config.components);
+              var aIndex = componentNames.findIndex(function (c) {
+                return c === a.context.name;
+              });
+              var bIndex = componentNames.findIndex(function (c) {
+                return c === b.context.name;
+              });
+              return aIndex - bIndex;
+            });
+            allGlobalJobs = allJobsPerTrigger.filter(function (j) {
+              var _a;
+              return ((_a = j.context) === null || _a === void 0 ? void 0 : _a.type) === "agent";
+            });
+            allJobs = __spreadArray(__spreadArray(__spreadArray([], __read(allWorkspaceJobs), false), __read(allComponentJobs), false), __read(allGlobalJobs), false).reduce(function (acc, _a) {
+              var _b, _c;
+              var gitlabJob = _a.gitlabJob,
+                name = _a.name,
+                context = _a.context;
+              // merge jobs, if a job is already there, merge the rules
+              // this is currently needed because of envMode: "none", which creates the same job for all triggers, so it can appear multiple times
+              // NOTICE: envNode none has been removed and this may no longer be needed
+              if (acc[name]) {
+                acc[name].gitlabJob.rules = __spreadArray(__spreadArray([], __read((_b = acc[name].gitlabJob.rules) !== null && _b !== void 0 ? _b : []), false), __read((_c = gitlabJob.rules) !== null && _c !== void 0 ? _c : []), false);
+              } else {
+                acc[name] = {
+                  context: context,
+                  gitlabJob: gitlabJob
+                };
+              }
+              return acc;
+            }, {});
+            return [2 /*return*/, (0, createGitlabPipeline_1.createGitlabPipelineWithDefaults)({
+              stages: __spreadArray(__spreadArray([], __read(stages), false), ["release"], false),
+              jobs: __assign(__assign({}, allJobs), Object.fromEntries(Object.entries((0, gitlabReleaseJobs_1.getGitlabReleaseJobs)(config)).map(function (_a) {
+                var _b = __read(_a, 2),
+                  name = _b[0],
+                  gitlabJob = _b[1];
+                return [name, {
+                  gitlabJob: gitlabJob,
+                  context: null
+                }];
+              }))),
+              variables: config.runnerVariables
+            })];
+        }
+      });
+    });
+  };
+  return GitlabBackend;
+}();
+exports.GitlabBackend = GitlabBackend;
+function getGitlabRulesForTrigger(trigger) {
+  // mainBranch: on push to main branch except it's a release commit
+  // mr: on merge request
+  // taggedRelease: on tag
+  switch (trigger) {
+    case "mainBranch":
+      return [rules_1.RULE_NEVER_ON_AGENT_TRIGGER, rules_1.RULE_IS_MAIN_BRANCH_AND_NOT_RELEASE_COMMIT];
+    case "mr":
+      return [rules_1.RULE_NEVER_ON_AGENT_TRIGGER, rules_1.RULE_IS_MERGE_REQUEST];
+    case "taggedRelease":
+      return [rules_1.RULE_NEVER_ON_AGENT_TRIGGER, rules_1.RULE_IS_TAGGED_RELEASE];
+  }
+  throw new Error("".concat(trigger, " is not supported"));
+}

package/dist/backends/gitlab/cache.d.ts

@@ -0,0 +1,9 @@
+import type { AgentContext, Context, GitlabJobCache } from "../../types";
+export declare const getCacheKeyWithFallbackForMR: (baseKey: string, context: Context) => {
+  key: string;
+  fallback_keys: string[];
+} | {
+  key: string;
+  fallback_keys?: undefined;
+};
+export declare const addCacheFallback: (cache: GitlabJobCache | GitlabJobCache[], context: Context | AgentContext) => GitlabJobCache | GitlabJobCache[];

package/dist/backends/gitlab/cache.js

@@ -0,0 +1,47 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addCacheFallback = exports.getCacheKeyWithFallbackForMR = void 0;
+var getCacheKeyWithFallbackForMR = function (baseKey, context) {
+  // if its a branch, create a key with the branch name with fallback to the base key
+  if (context.trigger === "mr") {
+    return {
+      key: baseKey + "-mr$CI_MERGE_REQUEST_IID",
+      fallback_keys: [baseKey]
+    };
+  }
+  return {
+    key: baseKey
+  };
+};
+exports.getCacheKeyWithFallbackForMR = getCacheKeyWithFallbackForMR;
+var addCacheFallback = function (cache, context) {
+  if (context.type !== "agent" && context.trigger === "mr") {
+    if (Array.isArray(cache)) {
+      return cache.map(function (c) {
+        return addCacheFallbackToSingleCacheForMR(c, context);
+      });
+    }
+    return addCacheFallbackToSingleCacheForMR(cache, context);
+  }
+  return cache;
+};
+exports.addCacheFallback = addCacheFallback;
+var addCacheFallbackToSingleCacheForMR = function (cache, context) {
+  if (typeof cache.key === "string") {
+    return __assign(__assign({}, cache), (0, exports.getCacheKeyWithFallbackForMR)(cache.key, context));
+  }
+  return cache; // as is
+};

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

@@ -0,0 +1,6 @@
+import type { CiVariableName } from "../../bash/ciVariables";
+/**
+ * how gitlab names the predefined CI variables,
+ * see https://docs.gitlab.com/ee/ci/variables/predefined_variables.html
+ */
+export declare const GITLAB_CI_VARIABLES: Record<CiVariableName, string>;

package/dist/backends/gitlab/ciVariables.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GITLAB_CI_VARIABLES = void 0;
+/**
+ * how gitlab names the predefined CI variables,
+ * see https://docs.gitlab.com/ee/ci/variables/predefined_variables.html
+ */
+exports.GITLAB_CI_VARIABLES = {
+  commitSha: "CI_COMMIT_SHA",
+  jobToken: "CI_JOB_TOKEN",
+  jobImage: "CI_JOB_IMAGE",
+  registry: "CI_REGISTRY",
+  registryImage: "CI_REGISTRY_IMAGE"
+};

package/dist/backends/gitlab/createGitlabJobs.d.ts

@@ -0,0 +1,13 @@
+import type { AgentContext, Context, GitlabJobDef, GitlabRule } from "../../types";
+import type { CatladderJob } from "../../types/jobs";
+import type { AllCatladderJobs } from "../../pipeline/createAllJobs";
+export type GitlabJobWithContext = {
+  gitlabJob: GitlabJobDef;
+  context: Context | AgentContext | null;
+};
+export type AllGitlabJobs = (GitlabJobWithContext & {
+  name: string;
+})[];
+export declare const GITLAB_ENVIRONMENT_URL_VARIABLE = "CL_GITLAB_ENVIRONMENT_URL";
+export declare const makeGitlabJob: (context: Context | AgentContext, job: CatladderJob<string>, allJobs: AllCatladderJobs, baseRules?: GitlabRule[]) => [fullName: string, job: GitlabJobDef];
+export declare const createGitlabJobs: (allJobs: AllCatladderJobs, baseRules?: GitlabRule[]) => Promise<AllGitlabJobs>;