@catladder/pipeline 1.170.1 → 2.0.1

package/dist/types/context.d.ts

@@ -2,10 +2,11 @@ import type { StringOrBashExpression } from "../bash/BashExpression";
 import type { BuildConfigFromWorkspace, BuildConfigStandalone, WorkspaceBuildConfig } from "../build";
 import type { PredefinedVariables, SecretEnvVar } from "../context";
 import type { DeployConfig } from "../deploy";
+import type { VariableValue } from "../variables/VariableValue";
 import type { ComponentConfig, Config, EnvType, PipelineTrigger } from "./config";
 import type { BaseStage, CatladderJob } from "./jobs";
 import type { PipelineType } from "./pipeline";
-export type UnspecifiedEnvVars = Record<string, StringOrBashExpression | undefined | null>;
+export type UnspecifiedEnvVars = Record<string, VariableValue | undefined | null>;
 export type EnvironmentEnvVars<V extends UnspecifiedEnvVars = UnspecifiedEnvVars> = {
   envVars: V & UnspecifiedEnvVars;
   secretEnvVarKeys: SecretEnvVar[];
@@ -28,10 +29,6 @@ export type Environment = {
    * the full name of the app. We use this as RELEASE_NAME in kubernetes and the service name in google cloud run
    */
   fullName: StringOrBashExpression;
-  /**
-   * @deprecated this is the same as context.env, use that instead
-   */
-  shortName: string;
   /**
    * the environment slug without component name.
    */
@@ -120,10 +117,6 @@ export type ComponentContext<BC extends BuildContextComponent = BuildContextComp
    * the name of the component
    */
   name: string;
-  /**
-   * @deprecated use name instead
-   */
-  componentName: string;
   /**
    * the merged component config.
    *

package/dist/types/gitlab-types.d.ts

@@ -23,4 +23,5 @@ export interface GitlabPipeline extends Pick<JobTemplate, "variables"> {
   };
   stages: string[];
   jobs: Record<string, GitlabJobDef>;
+  before_script?: string[];
 }

package/dist/types/jobs.d.ts

@@ -52,14 +52,6 @@ export type CatladderJob<S = BaseStage> = {
    *
    */
   needs?: Array<CatladderJobNeed>;
-  /**
-   * @deprecated set `componentName` to `needs` if you want to wait for a job from another component
-   */
-  needsOtherComponent?: Array<{
-    componentName: string;
-    job: string;
-    artifacts: boolean;
-  }>;
   /**
    * cache config, we use here the same shape as gitlab itself
    */

package/dist/utils/gitlab.js

@@ -35,6 +35,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.collapseableSection = exports.repeatOnFailure = exports.sanitizeForBashVariable = exports.allowFailureInScripts = void 0;
+var globalScriptFunctions_1 = require("../globalScriptFunctions");
 var allowFailureInScripts = function (script) {
   return __spreadArray(__spreadArray(["set +e"], __read(script), false), ["set -e" // reenable
   ], false);
@@ -48,9 +49,11 @@ var repeatOnFailure = function (command, options) {
   return "\n    until ".concat(command, "\n    do\n      echo \"Trying again.\"\n      sleep ").concat(options.pauseInSeconds, "\n    done\n  ");
 };
 exports.repeatOnFailure = repeatOnFailure;
+var start = (0, globalScriptFunctions_1.registerGlobalScriptFunction)("collapseable_section_start", "local section_title=\"${1}\"\n  local section_description=\"${2:-$section_title}\"\n  echo -e \"section_start:`date +%s`:${section_title}[collapsed=true]\\r\\e[0K${section_description}\"\n");
+var end = (0, globalScriptFunctions_1.registerGlobalScriptFunction)("collapseable_section_end", "local section_title=\"${1}\"\n  echo -e \"section_end:`date +%s`:${section_title}\\r\\e[0K\"\n");
 var collapseableSection = function (name, header) {
   return function (commands) {
-    return __spreadArray(__spreadArray(["echo -e \"\\e[0Ksection_start:$(date +%s):".concat(name, "[collapsed=true]\\r\\e[0K").concat(header, "\"")], __read(commands), false), ["echo -e \"\\e[0Ksection_end:$(date +%s):".concat(name, "\\r\\e[0K\"")], false);
+    return __spreadArray(__spreadArray([start.invoke("\"".concat(name, "\""), "\"".concat(header, "\""))], __read(commands), false), [end.invoke("\"".concat(name, "\""))], false);
   };
 };
 exports.collapseableSection = collapseableSection;

package/dist/utils/writeFiles.js

@@ -115,20 +115,14 @@ var __generator = this && this.__generator || function (thisArg, body) {
     };
   }
 };
-var __importDefault = this && this.__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : {
-    "default": mod
-  };
-};
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.writeYamlfile = exports.yamlStringifyOptions = exports.writeGeneratedFile = exports.getAutoGeneratedHeader = void 0;
 var promises_1 = require("fs/promises");
 var yaml_1 = require("yaml");
-var packageInfos_1 = __importDefault(require("../packageInfos"));
 var getAutoGeneratedHeader = function (commentChar) {
-  return ["-------------------------------------------------", "\uD83D\uDC31 \uD83D\uDD28 This file is generated by catladder v".concat(packageInfos_1.default.version), "\uD83D\uDEA8 Do not edit this file manually \uD83D\uDEA8", "-------------------------------------------------"].map(function (line) {
+  return ["-------------------------------------------------", "\uD83D\uDC31 \uD83D\uDD28 This file is generated by catladder", "\uD83D\uDEA8 Do not edit this file manually \uD83D\uDEA8", "-------------------------------------------------"].map(function (line) {
     return "".concat(commentChar, " ").concat(line);
   }).join("\n").concat("\n");
 };

package/dist/variables/VariableValue.d.ts

@@ -0,0 +1,3 @@
+import type { BashExpression } from "../bash/BashExpression";
+import type { VariableValueContainingReferences } from "./VariableValueContainingReferences";
+export type VariableValue = VariableValueContainingReferences | BashExpression | string;

package/dist/variables/VariableValue.js

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

package/dist/variables/VariableValueContainingReferences.d.ts

@@ -0,0 +1,24 @@
+import { BashExpression } from "../bash/BashExpression";
+import type { EscapeOptions } from "../bash/bashEscape";
+export declare class UnresolvableReference {
+  reference: VariableReference;
+  constructor(reference: VariableReference);
+  toString(): string;
+}
+export declare class VariableReference {
+  componentName: string;
+  variableName: string;
+  constructor(componentName: string, variableName: string);
+  toString(): string;
+}
+type VariableValuePart = string | BashExpression | VariableReference | UnresolvableReference;
+type MaybeArray<T> = T | T[];
+export declare class VariableValueContainingReferences {
+  parts: VariableValuePart[];
+  constructor(parts: MaybeArray<VariableValuePart | VariableValueContainingReferences>);
+  toString(options?: EscapeOptions): string;
+}
+export declare const createVariableValueContainingReferencesFromString: (value: string, options: {
+  componentName: string;
+}) => VariableValueContainingReferences;
+export {};

package/dist/variables/VariableValueContainingReferences.js

@@ -0,0 +1,97 @@
+"use strict";
+
+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;
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createVariableValueContainingReferencesFromString = exports.VariableValueContainingReferences = exports.VariableReference = exports.UnresolvableReference = void 0;
+var BashExpression_1 = require("../bash/BashExpression");
+var bashEscape_1 = require("../bash/bashEscape");
+var UnresolvableReference = /** @class */function () {
+  function UnresolvableReference(reference) {
+    this.reference = reference;
+  }
+  UnresolvableReference.prototype.toString = function () {
+    return "Unresolvable reference: ".concat(this.reference.toString());
+  };
+  return UnresolvableReference;
+}();
+exports.UnresolvableReference = UnresolvableReference;
+var VariableReference = /** @class */function () {
+  function VariableReference(componentName, variableName) {
+    this.componentName = componentName;
+    this.variableName = variableName;
+  }
+  VariableReference.prototype.toString = function () {
+    return "${".concat(this.componentName, ":").concat(this.variableName, "}");
+  };
+  return VariableReference;
+}();
+exports.VariableReference = VariableReference;
+var VariableValueContainingReferences = /** @class */function () {
+  function VariableValueContainingReferences(parts) {
+    this.parts = (Array.isArray(parts) ? parts : [parts]).flatMap(function (part) {
+      return part instanceof VariableValueContainingReferences ? part.parts : part === "" ? [] : [part];
+    });
+  }
+  VariableValueContainingReferences.prototype.toString = function (options) {
+    if (options === void 0) {
+      options = {
+        quotes: false
+      };
+    }
+    return this.parts.map(function (part) {
+      if (typeof part === "string") {
+        return (0, bashEscape_1.escapeString)(part, options);
+      } else if (part instanceof BashExpression_1.BashExpression) {
+        return (0, bashEscape_1.escapeBashExpression)(part, options);
+      } else {
+        return part.toString();
+      }
+    }).join("");
+  };
+  return VariableValueContainingReferences;
+}();
+exports.VariableValueContainingReferences = VariableValueContainingReferences;
+// regex to resolve references in catladder variables
+// those expressions have the pattern ${componentName:variableName}
+var REGEX = /\$\{(([^:}]+):)?([^}]+)}/gm;
+var createVariableValueContainingReferencesFromString = function (value, options) {
+  var parts = [];
+  var match;
+  var lastIndex = 0;
+  while ((match = REGEX.exec(value)) !== null) {
+    var _a = __read(match, 4),
+      fullMatch = _a[0],
+      _1 = _a[1],
+      otherComponentName = _a[2],
+      variableName = _a[3];
+    parts.push(value.slice(lastIndex, match.index));
+    parts.push(new VariableReference(otherComponentName || options.componentName, variableName));
+    lastIndex = REGEX.lastIndex;
+  }
+  parts.push(value.slice(lastIndex));
+  return new VariableValueContainingReferences(parts);
+};
+exports.createVariableValueContainingReferencesFromString = createVariableValueContainingReferencesFromString;

package/dist/variables/__tests__/resolveAllReferences.test.js

@@ -0,0 +1,219 @@
+"use strict";
+
+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
+    };
+  }
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+var resolveAllReferences_1 = require("../resolveAllReferences");
+describe("replaceAllReferences", function () {
+  it("should replace all references recursivly", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars, result;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the 2nd component has ${component2:variable1} and self reference ${variable2}", {
+                componentName: "component1"
+              }),
+              myOtherVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the third component has ${component3:variable1}, isn't that cool?", {
+                componentName: "component1"
+              }),
+              myThirdVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("value from component3: ${component3:variable3}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2 /*return*/, {
+                    variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am variable1 from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable2: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("foo from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable3: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                      componentName: componentName
+                    })
+                  }];
+                });
+              });
+            };
+            return [4 /*yield*/, (0, resolveAllReferences_1.resolveAllReferences)(values, getEnvVars)];
+          case 1:
+            result = _a.sent();
+            expect(result).toEqual({
+              myVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the 2nd component has ", "i am variable1 from component2", " and self reference ", "foo from component1"]),
+              myOtherVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the third component has ", "i am variable1 from component3", ", isn't that cool?"]),
+              myThirdVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["value from component3: ", "i am referencing ", "i am variable1 from component1"])
+            });
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+
+  it("detects infinte loop", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component2:variable1}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  if (componentName === "component2") {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component3:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  } else if (componentName === "component3") {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  } else {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component2:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  }
+                  return [2 /*return*/];
+                });
+              });
+            };
+            // expect to throw an error
+            return [4 /*yield*/, expect((0, resolveAllReferences_1.resolveAllReferences)(values, getEnvVars)).rejects.toThrow("Infinite loop detected in these variables: myVar (last reference: ${component1:variable1})")];
+          case 1:
+            // expect to throw an error
+            _a.sent();
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+});

package/dist/variables/__tests__/resolveAllReferencesOnce.test.d.ts

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

package/dist/variables/__tests__/resolveAllReferencesOnce.test.js

@@ -0,0 +1,171 @@
+"use strict";
+
+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
+    };
+  }
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+var resolveAllReferencesOnce_1 = require("../resolveAllReferencesOnce");
+describe("resolveAllReferencesOnce", function () {
+  it("should replace all references", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars, result;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the 2nd component has ${component2:variable1} and self reference ${variable2}", {
+                componentName: "component1"
+              }),
+              myOtherVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the third component has ${component3:variable1}, isn't that cool?", {
+                componentName: "component1"
+              }),
+              myThirdVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("value from component3: ${component3:variable3}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2 /*return*/, {
+                    variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am variable1 from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable2: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("foo from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable3: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                      componentName: componentName
+                    })
+                  }];
+                });
+              });
+            };
+            return [4 /*yield*/, (0, resolveAllReferencesOnce_1.resolveAllReferencesOnce)(values, getEnvVars)];
+          case 1:
+            result = _a.sent();
+            expect(result).toEqual({
+              myVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the 2nd component has ", "i am variable1 from component2", " and self reference ", "foo from component1"]),
+              myOtherVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the third component has ", "i am variable1 from component3", ", isn't that cool?"]),
+              myThirdVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["value from component3: ", "i am referencing ", new VariableValueContainingReferences_1.VariableReference("component1", "variable1")])
+            });
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+});

package/dist/variables/__tests__/resolveReferencesOnce.test.d.ts

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