@catladder/pipeline 0.0.0-node16-03dc096a → 0.0.0-perf-cli-reduce-bundle-size-with-tsconfig-optimization-c14723ff

package/README.md

@@ -0,0 +1,3 @@
+## @catladder/pipeline 🐱 🔧
+
+See [@catladder/cli](https://www.npmjs.com/package/@catladder/cli).

package/bin/catladder-gitlab-dev.js

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+
+require("../dist/catladder-gitlab.js");

package/bin/catladder-gitlab.js

@@ -1,3 +1,3 @@
 #! /usr/bin/env node
 
-require("../dist/catladder-gitlab.js");
+require("../dist/bundles/catladder-gitlab/index.js");

package/dist/bash/BashExpression.d.ts

@@ -0,0 +1,40 @@
+/**
+ * this class represents a string that can be evaluated in bash scripts.
+ *
+ * you can do basic transforms like lowercase, but that does not return you a lowercase string, but instead an experssion represeting a lowercase string
+ */
+export declare class BashExpression {
+  private value;
+  constructor(value: string | BashExpression);
+  toJSON(): string;
+  toString(): string;
+  /**
+   *
+   * @returns a bash expression to lowercase the string
+   */
+  toLowerCase(): BashExpression;
+  /**
+   * concats a value to this one and returns a new BashExpression
+   * @param value
+   * @returns
+   */
+  concat(...values: Array<string | BashExpression>): BashExpression;
+  transformWithCommand(command: string): BashExpression;
+}
+export type StringOrBashExpression = string | BashExpression;
+export declare const getBashVariable: (name: string) => BashExpression;
+/**
+ * joins bash expressions together with a joiner
+ * returns a bash expression if any of the parts is a bash expression
+ * returns a string otherwise
+ *
+ * @param parts
+ * @param joiner
+ * @returns
+ */
+export declare const joinBashExpressions: (parts: Array<StringOrBashExpression>, joiner?: string) => StringOrBashExpression;
+/**
+ * escapes a string or bash expression for bash
+ * it mainly escapes double quotes
+ */
+export declare const bashEscape: (value: StringOrBashExpression | any) => any;

package/dist/bash/BashExpression.js

@@ -0,0 +1,124 @@
+"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;
+};
+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.bashEscape = exports.joinBashExpressions = exports.getBashVariable = exports.BashExpression = void 0;
+/**
+ * this class represents a string that can be evaluated in bash scripts.
+ *
+ * you can do basic transforms like lowercase, but that does not return you a lowercase string, but instead an experssion represeting a lowercase string
+ */
+var BashExpression = /** @class */function () {
+  function BashExpression(value) {
+    this.value = value;
+  }
+  BashExpression.prototype.toJSON = function () {
+    return this.toString();
+  };
+  BashExpression.prototype.toString = function () {
+    return this.value.toString();
+  };
+  /**
+   *
+   * @returns a bash expression to lowercase the string
+   */
+  BashExpression.prototype.toLowerCase = function () {
+    return this.transformWithCommand("awk '{print tolower($0)}'");
+  };
+  /**
+   * concats a value to this one and returns a new BashExpression
+   * @param value
+   * @returns
+   */
+  BashExpression.prototype.concat = function () {
+    var _a;
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      values[_i] = arguments[_i];
+    }
+    return new BashExpression((_a = this.toString()).concat.apply(_a, __spreadArray([], __read(values.map(function (v) {
+      return v.toString();
+    })), false)));
+  };
+  BashExpression.prototype.transformWithCommand = function (command) {
+    return new BashExpression(
+    // see https://stackoverflow.com/a/2264537
+    "$(printf %s \"".concat(this.toString(), "\" | ").concat(command, ")"));
+  };
+  return BashExpression;
+}();
+exports.BashExpression = BashExpression;
+var getBashVariable = function (name) {
+  return new BashExpression("$".concat(name));
+};
+exports.getBashVariable = getBashVariable;
+/**
+ * joins bash expressions together with a joiner
+ * returns a bash expression if any of the parts is a bash expression
+ * returns a string otherwise
+ *
+ * @param parts
+ * @param joiner
+ * @returns
+ */
+var joinBashExpressions = function (parts, joiner) {
+  if (joiner === void 0) {
+    joiner = "";
+  }
+  var anyIsBashExpression = parts.some(function (p) {
+    return p instanceof BashExpression;
+  });
+  if (anyIsBashExpression) {
+    return new BashExpression(parts.map(function (p) {
+      return p instanceof BashExpression ? p.toString() : p;
+    }).join(joiner));
+  } else {
+    return parts.join(joiner);
+  }
+};
+exports.joinBashExpressions = joinBashExpressions;
+/**
+ * escapes a string or bash expression for bash
+ * it mainly escapes double quotes
+ */
+var bashEscape = function (value) {
+  if (value instanceof BashExpression) {
+    return value.toString(); // no need to escape bash expressions, as we want them to evaluate
+  }
+  // we wrap it in double quotes, so we need to escape them
+  if (typeof value === "string") return value.replace(/"/g, '\\"');
+  return value;
+};
+exports.bashEscape = bashEscape;

package/dist/bash/bashExpressionPerPipelineType.d.ts

@@ -0,0 +1,6 @@
+import type { PipelineType } from "../types/pipeline";
+import type { BashExpression } from "./BashExpression";
+export type BashExpressionPerPipelineType = { [type in PipelineType]?: BashExpression | string } & {
+  default: BashExpression | string;
+};
+export declare const getBashExpressionPerPipelineType: (definition: BashExpressionPerPipelineType, pipelineType?: PipelineType) => string | BashExpression;

package/dist/bash/bashExpressionPerPipelineType.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBashExpressionPerPipelineType = void 0;
+var getBashExpressionPerPipelineType = function (definition, pipelineType) {
+  if (!pipelineType) return definition.default;
+  return definition[pipelineType] || definition.default;
+};
+exports.getBashExpressionPerPipelineType = getBashExpressionPerPipelineType;

package/dist/bash/bashYaml.d.ts

@@ -0,0 +1,10 @@
+/***
+ * creates a yaml string that can be used in bash scripts
+ * it handles BashExpressions correctly so that they can be evaluated in bash
+ */
+export declare const yamlBashString: (value: any) => string;
+/**
+ * creates a bash script that writes a yaml string to a file
+ * @param value the yaml value to write, it supports BashExpressions
+ */
+export declare const writeBashYamlToFileScript: (value: any, filename: string) => string[];

package/dist/bash/bashYaml.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeBashYamlToFileScript = exports.yamlBashString = void 0;
+var yaml_1 = require("yaml");
+var BashExpression_1 = require("./BashExpression");
+var bashExpressionType = {
+  tag: "",
+  resolve: function (str) {
+    // not really needed,but let's make typescript happy
+    return new BashExpression_1.BashExpression(str);
+  },
+  stringify: function (node, ctx) {
+    // we create a BLOCK_LITERAL
+    // but because bash will interpret the value, it may resolve to a multiline string
+    // so we need to indent every line using sed
+    return "|-\n" + node.value.transformWithCommand("sed 's/^/".concat(ctx.indent, "/'"));
+  },
+  identify: function (v) {
+    return v instanceof BashExpression_1.BashExpression;
+  }
+};
+/***
+ * creates a yaml string that can be used in bash scripts
+ * it handles BashExpressions correctly so that they can be evaluated in bash
+ */
+var yamlBashString = function (value) {
+  return (0, yaml_1.stringify)(value, {
+    defaultStringType: "BLOCK_LITERAL",
+    defaultKeyType: "PLAIN",
+    customTags: [bashExpressionType],
+    aliasDuplicateObjects: false,
+    lineWidth: 0
+  });
+};
+exports.yamlBashString = yamlBashString;
+/**
+ * creates a bash script that writes a yaml string to a file
+ * @param value the yaml value to write, it supports BashExpressions
+ */
+var writeBashYamlToFileScript = function (value, filename) {
+  return ["cat > ".concat(filename, " <<EOF\n").concat((0, exports.yamlBashString)(value), "\nEOF\n")];
+};
+exports.writeBashYamlToFileScript = writeBashYamlToFileScript;

package/dist/bash/getInjectVarsScript.d.ts

@@ -0,0 +1,2 @@
+import type { UnspecifiedEnvVars } from "../types";
+export declare const getInjectVarsScript: (vars?: UnspecifiedEnvVars) => string[];

package/dist/bash/getInjectVarsScript.js

@@ -0,0 +1,45 @@
+"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.getInjectVarsScript = void 0;
+var lodash_1 = require("lodash");
+var BashExpression_1 = require("./BashExpression");
+var getInjectVarsScript = function (vars) {
+  if (!vars) return [];
+  // filter out null and undefined values
+  return Object.entries(vars).filter(function (_a) {
+    var _b = __read(_a, 2),
+      value = _b[1];
+    return !(0, lodash_1.isNil)(value);
+  }).map(function (_a) {
+    var _b = __read(_a, 2),
+      key = _b[0],
+      value = _b[1];
+    return "export ".concat(key, "=\"").concat(value ? (0, BashExpression_1.bashEscape)(value) : "", "\"");
+  });
+};
+exports.getInjectVarsScript = getInjectVarsScript;

package/dist/bash/replaceAsync.d.ts

@@ -0,0 +1,2 @@
+import { BashExpression } from "./BashExpression";
+export default function replaceAsync(string: string | BashExpression, searchValue: any, replacer: (substring: string, ...args: any[]) => Promise<string | BashExpression>): Promise<string | BashExpression>;

package/dist/bash/replaceAsync.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 BashExpression_1 = require("./BashExpression");
+// from https://github.com/dsblv/string-replace-async/blob/main/index.js
+// and adjusted a bit
+function replaceAsync(string, searchValue, replacer) {
+  return __awaiter(this, void 0, void 0, function () {
+    var wasBashExpression, values_1, resolvedValues_1, containsBashExpression, result, error_1;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          wasBashExpression = string instanceof BashExpression_1.BashExpression;
+          _a.label = 1;
+        case 1:
+          _a.trys.push([1, 3,, 4]);
+          values_1 = [];
+          String.prototype.replace.call(string.toString(), searchValue, function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            // eslint-disable-next-line prefer-spread
+            var result = replacer.apply(undefined, args);
+            values_1.push(result);
+            return "";
+          });
+          return [4 /*yield*/, Promise.all(values_1)];
+        case 2:
+          resolvedValues_1 = _a.sent();
+          containsBashExpression = resolvedValues_1.some(function (value) {
+            return value instanceof BashExpression_1.BashExpression;
+          });
+          result = String.prototype.replace.call(string.toString(), searchValue, function () {
+            var _a, _b;
+            return (_b = (_a = resolvedValues_1.shift()) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "";
+          });
+          if (wasBashExpression || containsBashExpression) {
+            return [2 /*return*/, new BashExpression_1.BashExpression(result)];
+          } else {
+            return [2 /*return*/, result];
+          }
+          return [3 /*break*/, 4];
+        case 3:
+          error_1 = _a.sent();
+          return [2 /*return*/, Promise.reject(error_1)];
+        case 4:
+          return [2 /*return*/];
+      }
+    });
+  });
+}
+
+exports.default = replaceAsync;

package/dist/build/artifacts/createBuildJobArtifact.d.ts

@@ -0,0 +1,3 @@
+import { type Context } from "../../types";
+import type { CatladderJob } from "../../types/jobs";
+export declare const createBuildJobArtifacts: (context: Context) => CatladderJob["artifacts"];

package/dist/build/artifacts/createBuildJobArtifact.js

@@ -0,0 +1,97 @@
+"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 __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.createBuildJobArtifacts = void 0;
+var path_1 = require("path");
+var types_1 = require("../../types");
+var lodash_1 = require("lodash");
+var writeDotEnv_1 = require("../base/writeDotEnv");
+var createBuildJobArtifacts = function (context) {
+  var _a, _b;
+  var paths = context.type === "workspace" ? context.components.flatMap(function (c) {
+    return getArtifactsPathForComponent(c);
+  }) : getArtifactsPathForComponent(context, ["__build_info.json"]);
+  // esxclude .env files if generated
+  var exclude = context.type === "workspace" ? context.components.flatMap(function (c) {
+    return getDotEnvPathsForComponent(c);
+  }) : getDotEnvPathsForComponent(context);
+  return __assign(__assign({
+    paths: (0, lodash_1.uniq)(paths).sort(function (a, b) {
+      return a.localeCompare(b);
+    })
+  }, exclude.length > 0 ? {
+    exclude: exclude
+  } : {}), {
+    expire_in: "1 day",
+    when: "always",
+    reports:
+    // TODO: support for junit reports in other builds
+    context.type === "component" && (0, types_1.componentContextIsStandaloneBuild)(context) ? {
+      junit: (_b = (_a = context.build.config.artifactsReports) === null || _a === void 0 ? void 0 : _a.junit) === null || _b === void 0 ? void 0 : _b.map(function (p) {
+        return (0, path_1.join)(context.build.dir, p);
+      })
+    } : {}
+  });
+};
+exports.createBuildJobArtifacts = createBuildJobArtifacts;
+var getArtifactsPathForComponent = function (c, additionalPaths) {
+  var _a, _b;
+  return (_b = __spreadArray(__spreadArray([], __read((_a = c.build.config.artifactsPaths) !== null && _a !== void 0 ? _a : []), false), __read(additionalPaths !== null && additionalPaths !== void 0 ? additionalPaths : []), false)) === null || _b === void 0 ? void 0 : _b.flatMap(function (artifact) {
+    return c.build
+    // in theory, we only need "direct",
+    // but in some cases project may have packages in the workspace that create build artifacts, which aren't components
+    // this highly depends on the build tool. To be safe, we get all
+    .getComponentDirs("all").flatMap(function (cDir) {
+      return (0, path_1.join)(cDir, artifact);
+    });
+  });
+};
+var getDotEnvPathsForComponent = function (c) {
+  if ((0, writeDotEnv_1.componentContextNeedsBuildTimeDotEnv)(c)) {
+    return [(0, path_1.join)(c.build.dir, ".env")];
+  }
+  return [];
+};

package/dist/build/base/__tests__/createArtifactsConfig.test.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var createArtifactsConfig_1 = require("../createArtifactsConfig");
+describe("createArtifactsConfig", function () {
+  it("returns undefined if no artifacts or artifactsReports", function () {
+    expect((0, createArtifactsConfig_1.createArtifactsConfig)(".")).toBeUndefined();
+  });
+  it("returns artifacts if no artifactsReports", function () {
+    expect((0, createArtifactsConfig_1.createArtifactsConfig)(".", undefined, {
+      paths: ["testpath"],
+      reports: {
+        coverage_report: {
+          coverage_format: "cobertura",
+          path: "some"
+        },
+        terraform: "something"
+      }
+    })).toMatchSnapshot();
+  });
+  it("returns junit parts of artifactsReports", function () {
+    expect((0, createArtifactsConfig_1.createArtifactsConfig)(".", {
+      junit: ["report.xml"]
+    })).toMatchSnapshot();
+  });
+  it("merges junit files if both given", function () {
+    var _a, _b;
+    var result = (0, createArtifactsConfig_1.createArtifactsConfig)(".", {
+      junit: ["partial-report.xml"]
+    }, {
+      paths: ["testpath"],
+      reports: {
+        junit: "full-report.xml",
+        terraform: "something"
+      }
+    });
+    expect(result).toMatchSnapshot();
+    expect((_b = (_a = result === null || result === void 0 ? void 0 : result.artifacts) === null || _a === void 0 ? void 0 : _a.reports) === null || _b === void 0 ? void 0 : _b.junit).toHaveLength(2);
+  });
+});

package/dist/build/base/constants.d.ts

@@ -1,7 +1,6 @@
 export declare const APP_BUILD_JOB_NAME = "\uD83D\uDD28 app";
 export declare const RUNNER_BUILD_RESOURCE_VARIABLES: {
   KUBERNETES_CPU_REQUEST: string;
-  KUBERNETES_CPU_LIMIT: string;
   KUBERNETES_MEMORY_REQUEST: string;
   KUBERNETES_MEMORY_LIMIT: string;
 };

package/dist/build/base/constants.js

@@ -1,11 +1,12 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.RUNNER_BUILD_RESOURCE_VARIABLES = exports.APP_BUILD_JOB_NAME = void 0;
 exports.APP_BUILD_JOB_NAME = "🔨 app";
 exports.RUNNER_BUILD_RESOURCE_VARIABLES = {
-  KUBERNETES_CPU_REQUEST: "0.5",
-  KUBERNETES_CPU_LIMIT: "2",
+  KUBERNETES_CPU_REQUEST: "0.45",
   KUBERNETES_MEMORY_REQUEST: "1Gi",
   KUBERNETES_MEMORY_LIMIT: "4Gi"
 };

package/dist/build/base/createAppBuildJob.d.ts

@@ -0,0 +1,9 @@
+import type { BuildContextStandalone, ComponentContext, WorkspaceContext } from "../..";
+import type { CatladderJob } from "../../types/jobs";
+export type AppBuildJobDefinition = Partial<Omit<CatladderJob, "artifacts">>;
+export declare const createAppBuildJob: (context: ComponentContext<BuildContextStandalone> | WorkspaceContext, {
+  script,
+  variables,
+  runnerVariables,
+  ...def
+}: AppBuildJobDefinition) => CatladderJob;