@catladder/pipeline 0.0.0-refactore-catenv-command-validates-argument-78d05852 → 0.0.0-reference-database-url-1befbbee

package/dist/types/jobs.d.ts

@@ -1,12 +1,23 @@
-import type { Artifacts, GitlabEnvironment, GitlabJobCache, GitlabRule, GitlabJobImage, GitlabJobDef } from "./gitlab-types";
+import type { UnspecifiedEnvVars } from "..";
+import type { Artifacts, GitlabEnvironment, GitlabJobCache, GitlabJobDef, GitlabJobImage, GitlabRule } from "./gitlab-types";
+export type CatladderJobCache = GitlabJobCache;
 export declare const BASE_STAGES: readonly ["setup", "test", "build", "deploy", "verify", "rollback", "stop"];
-export declare type BaseStage = typeof BASE_STAGES[number];
-export declare type CatladderJobNeed = string | {
+export type BaseStage = (typeof BASE_STAGES)[number];
+export type CatladderJobNeed = string | {
   job: string;
   artifacts: boolean;
   componentName?: string;
+} | {
+  job: string;
+  artifacts: boolean;
+  workspaceName: string;
+};
+export type CatladderJobEnvironmentConfig = {
+  action?: GitlabEnvironment["action"];
+  on_stop?: GitlabEnvironment["on_stop"];
+  auto_stop_in?: string;
 };
-export declare type CatladderJob<S = BaseStage> = {
+export type CatladderJob<S = BaseStage> = {
   /**
    * the name of the job (without any env or app prefix and suffix)
    */
@@ -32,6 +43,7 @@ export declare type CatladderJob<S = BaseStage> = {
   needsStages?: {
     stage: S;
     artifacts?: boolean;
+    workspaceName?: string;
   }[];
   /**
    * does this require another job (from the same component)?
@@ -40,18 +52,10 @@ export declare 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
    */
-  cache?: GitlabJobCache | GitlabJobCache[];
+  cache?: CatladderJobCache | CatladderJobCache[];
   /**
    * job artifacts, we also use gitlab shape here
    */
@@ -67,12 +71,23 @@ export declare type CatladderJob<S = BaseStage> = {
   /**
    * variables to pass
    */
-  variables: GitlabJobDef["variables"];
+  variables: UnspecifiedEnvVars | undefined;
+  /**
+   * additional vars only for the runner.
+   * Also if you use services: that require env vars, you need to set them here.
+   *
+   */
+  runnerVariables?: Record<string, string>;
   /**
    * whether failures are allowed
    */
   allow_failure?: boolean;
-  environment?: GitlabEnvironment;
+  /**
+   * gitlab environment config, subject to change
+   */
+  environment?: CatladderJobEnvironmentConfig;
+  /** */
+  when?: GitlabRule["when"];
   rules?: GitlabRule[];
   /**
    * How many instances of a job should be run in parallel.

package/dist/types/jobs.js

@@ -1,5 +1,7 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.BASE_STAGES = void 0;
 exports.BASE_STAGES = ["setup", "test", "build", "deploy", "verify", "rollback", "stop"];

package/dist/types/pipeline.d.ts

@@ -1,4 +1,4 @@
 import type { GitlabJobDef, GitlabPipeline } from "./gitlab-types";
-export declare type PipelineType = "gitlab";
-export declare type PipelineJob<T extends PipelineType> = T extends "gitlab" ? GitlabJobDef : never;
-export declare type Pipeline<T extends PipelineType> = T extends "gitlab" ? GitlabPipeline : never;
+export type PipelineType = "gitlab";
+export type PipelineJob<T extends PipelineType> = T extends "gitlab" ? GitlabJobDef : never;
+export type Pipeline<T extends PipelineType> = T extends "gitlab" ? GitlabPipeline : never;

package/dist/types/pipeline.js

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

package/dist/types/utils.d.ts

@@ -1 +1 @@
-export declare type PartialDeep<T> = T extends any[] ? T : T extends Record<string, any> ? { [P in keyof T]?: PartialDeep<T[P]> } : T;
+export type PartialDeep<T> = T extends any[] ? T : T extends Record<string, any> ? { [P in keyof T]?: PartialDeep<T[P]> } : T;

package/dist/types/utils.js

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

package/dist/utils/gitlab.js

@@ -31,8 +31,11 @@ var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
   }
   return to.concat(ar || Array.prototype.slice.call(from));
 };
-exports.__esModule = true;
+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);
@@ -46,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/index.d.ts

@@ -1,3 +1,4 @@
 export declare function notNil<TValue>(value: TValue | null | undefined): value is TValue;
-export declare const ensureArray: <T>(s: T | T[] | undefined) => T[] | null;
+export declare const ensureArrayOrNull: <T>(s: undefined | T | T[]) => T[] | null;
+export declare const ensureArray: <T>(s: undefined | T | T[]) => T[];
 export declare const mergeWithMergingArrays: <A, B>(obj1: A, obj2: B) => A & B;

package/dist/utils/index.js

@@ -31,16 +31,23 @@ var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
   }
   return to.concat(ar || Array.prototype.slice.call(from));
 };
-exports.__esModule = true;
-exports.mergeWithMergingArrays = exports.ensureArray = exports.notNil = void 0;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeWithMergingArrays = exports.ensureArray = exports.ensureArrayOrNull = exports.notNil = void 0;
 var lodash_1 = require("lodash");
 function notNil(value) {
   return value !== null && value !== undefined;
 }
 exports.notNil = notNil;
-var ensureArray = function (s) {
+var ensureArrayOrNull = function (s) {
   return (0, lodash_1.isNil)(s) ? null : Array.isArray(s) ? s : [s];
 };
+exports.ensureArrayOrNull = ensureArrayOrNull;
+var ensureArray = function (s) {
+  var _a;
+  return (_a = (0, exports.ensureArrayOrNull)(s)) !== null && _a !== void 0 ? _a : [];
+};
 exports.ensureArray = ensureArray;
 // see https://github.com/lodash/lodash/issues/5384
 var mergeWithMergingArrays = function (obj1, obj2) {

package/dist/utils/jsonParse.d.ts

@@ -0,0 +1 @@
+export declare const jsonParseOrThrow: (str: string) => any;

package/dist/utils/jsonParse.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonParseOrThrow = void 0;
+var jsonParseOrThrow = function (str) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    throw new Error("could not parse json: ".concat(str));
+  }
+};
+exports.jsonParseOrThrow = jsonParseOrThrow;

package/dist/utils/removeUndefined.d.ts

@@ -0,0 +1 @@
+export declare const removeUndefined: <T extends object>(obj: T) => T;

package/dist/utils/removeUndefined.js

@@ -0,0 +1,36 @@
+"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.removeUndefined = void 0;
+var removeUndefined = function (obj) {
+  return Object.fromEntries(Object.entries(obj).filter(function (_a) {
+    var _b = __read(_a, 2),
+      value = _b[1];
+    return value !== undefined;
+  }));
+};
+exports.removeUndefined = removeUndefined;

package/dist/utils/writeFiles.d.ts

@@ -0,0 +1,11 @@
+import { stringify } from "yaml";
+export declare const getAutoGeneratedHeader: (commentChar: string) => string;
+export declare const writeGeneratedFile: (path: string, content: string, {
+  commentChar
+}: {
+  commentChar: string;
+}) => Promise<void>;
+type StringifyOptions = Exclude<Parameters<typeof stringify>[2], null | undefined | string | number>;
+export declare const yamlStringifyOptions: StringifyOptions;
+export declare const writeYamlfile: (path: string, data: any) => Promise<void>;
+export {};

package/dist/{pipeline/commitInfo/getBuildId.js → utils/writeFiles.js}

@@ -55,7 +55,7 @@ var __generator = this && this.__generator || function (thisArg, body) {
   }
   function step(op) {
     if (f) throw new TypeError("Generator is already executing.");
-    while (_) try {
+    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]) {
@@ -115,41 +115,58 @@ var __generator = this && this.__generator || function (thisArg, body) {
     };
   }
 };
-exports.__esModule = true;
-exports.getCurrentVersionString = exports.getBuildId = void 0;
-var child_process_promise_1 = require("child-process-promise");
-var getBuildId = function () {
-  return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-      switch (_a.label) {
+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 getAutoGeneratedHeader = function (commentChar) {
+  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");
+};
+exports.getAutoGeneratedHeader = getAutoGeneratedHeader;
+var writeGeneratedFile = function (path_1, content_1, _a) {
+  return __awaiter(void 0, [path_1, content_1, _a], void 0, function (path, content, _b) {
+    var commentChar = _b.commentChar;
+    return __generator(this, function (_c) {
+      switch (_c.label) {
         case 0:
-          return [4 /*yield*/, (0, child_process_promise_1.exec)("git describe --tags || git rev-parse HEAD").then(function (s) {
-            return s.stdout.trim();
+          return [4 /*yield*/, (0, promises_1.writeFile)(path,
+          // need to spread out the jobs, forgot why
+          [(0, exports.getAutoGeneratedHeader)(commentChar), content].join("\n"), {
+            encoding: "utf-8"
           })];
         case 1:
-          return [2 /*return*/, _a.sent()];
+          _c.sent();
+          return [2 /*return*/];
       }
     });
   });
 };
-exports.getBuildId = getBuildId;
-// thx chat gpt
-/**
- * returns the last tagged version string Major.minor.patch
- * returns 0.0.0 if there is no tag
- */
-var getCurrentVersionString = function () {
+exports.writeGeneratedFile = writeGeneratedFile;
+exports.yamlStringifyOptions = {
+  // prevents colapsing long command statements into multiple lines
+  lineWidth: 0,
+  // represent multi line commands as single line json strings
+  doubleQuotedAsJSON: true,
+  // Better readability when bash commands most often use double quotes
+  singleQuote: true
+};
+var writeYamlfile = function (path, data) {
   return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
       switch (_a.label) {
         case 0:
-          return [4 /*yield*/, (0, child_process_promise_1.exec)('latest_tag=$(git describe --tags --abbrev=0 2>/dev/null); if [ -z "$latest_tag" ]; then echo "0.0.0"; else echo "${latest_tag#v}"; fi | cut -d "." -f 1-3').then(function (s) {
-            return s.stdout.trim();
+          return [4 /*yield*/, (0, exports.writeGeneratedFile)(path, (0, yaml_1.stringify)(data, exports.yamlStringifyOptions), {
+            commentChar: "#"
           })];
         case 1:
-          return [2 /*return*/, _a.sent()];
+          _a.sent();
+          return [2 /*return*/];
       }
     });
   });
 };
-exports.getCurrentVersionString = getCurrentVersionString;
+exports.writeYamlfile = writeYamlfile;

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.d.ts

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