@catladder/pipeline 0.0.0-more-collapse-deeb54d7 → 0.0.0-multiple-gitlab-includes-1a40efc0

package/README.md

@@ -0,0 +1,17 @@
+## @catladder/pipeline 🐱 🔧
+
+Panter workflow for cloud CI/CD and DevOps.
+
+**It just works™**
+
+## Getting started
+
+[See the documentation][docs-getting-started].
+
+[docs-getting-started]: https://catladder.git.panter.biz/catladder/docs/getting_started "Getting started"
+
+## Contribution
+
+[See contribution guide][docs-contribute].
+
+[docs-contribute]: https://catladder.git.panter.biz/catladder/docs/contribute "Contribution guide"

package/dist/bash/BashExpression.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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;
+  replace(searchValue: any, replacer: (substring: string, ...args: any[]) => string): BashExpression;
+  /**
+   *
+   * @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;

package/dist/bash/BashExpression.js

@@ -0,0 +1,114 @@
+"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.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();
+  };
+  BashExpression.prototype.replace = function (searchValue, replacer) {
+    return new BashExpression(this.value.toString().replace(searchValue, replacer));
+  };
+  /**
+   *
+   * @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;

package/dist/bash/bashEscape.d.ts

@@ -0,0 +1,34 @@
+import type { VariableValue } from "../variables/VariableValue";
+import { BashExpression } from "./BashExpression";
+export type QuotesEscapeMode = "single" | "double";
+export type EscapeOptions = {
+  quotes?: QuotesEscapeMode | false;
+};
+/**
+ * escapes a string or bash expression for bash
+ * it either can escape single or double quotes (double is default)
+ */
+export declare const bashEscape: (value: VariableValue | any, options?: EscapeOptions) => string | BashExpression | null | undefined;
+export declare const escapeString: (value: string | null | undefined, {
+  quotes
+}?: EscapeOptions) => string | null | undefined;
+export declare const escapeBashExpression: (value: BashExpression, options: EscapeOptions) => BashExpression;
+export declare const escapeDoubleQuotes: (value: string | null | undefined) => string | undefined;
+export declare const escapeSingleQuotes: (value: string | null | undefined) => string | undefined;
+/**
+ *
+ * escape env vars for .env files.
+ * unfortunatly, the format has many limitations. In order to be very forgiving, we need to do some magic here:
+ *
+ * - when the value contains no newlines, we are fine
+ * - if the value contains newlines, we need to wrap it in quotes. And thats where the problem begins:
+ * - you can't escape quotes. this is a limitation of dotenv and node
+ * - you can have inner quotes, but they break in node.js (not in dotenv though), see https://github.com/nodejs/node/issues/54134
+ * - so we need to quote cleverly
+ * - to make things worse, we need to check whether we have a simple stirng or a bash expression, that needs to be evalulated first...
+ *
+ *  what an absolute nightmare.
+ *
+ * - other languages are currently only partially supported, since most .env implementations are slightly different
+ */
+export declare const escapeForDotEnv: (value: VariableValue | undefined | null) => string;

package/dist/bash/bashEscape.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeForDotEnv = exports.escapeSingleQuotes = exports.escapeDoubleQuotes = exports.escapeBashExpression = exports.escapeString = exports.bashEscape = void 0;
+var globalScriptFunctions_1 = require("../globalScriptFunctions");
+var VariableValueContainingReferences_1 = require("../variables/VariableValueContainingReferences");
+var BashExpression_1 = require("./BashExpression");
+/**
+ * escapes a string or bash expression for bash
+ * it either can escape single or double quotes (double is default)
+ */
+var bashEscape = function (value, options) {
+  if (options === void 0) {
+    options = {
+      quotes: "double"
+    };
+  }
+  if (value instanceof BashExpression_1.BashExpression) {
+    // no need to escape
+    return (0, exports.escapeBashExpression)(value, options);
+  }
+  if (value instanceof VariableValueContainingReferences_1.VariableValueContainingReferences) {
+    return value.toString(options);
+  }
+  return (0, exports.escapeString)(value, options);
+};
+exports.bashEscape = bashEscape;
+var escapeString = function (value, _a) {
+  var _b = _a === void 0 ? {
+      quotes: "double"
+    } : _a,
+    quotes = _b.quotes;
+  var quoteEscaped = quotes ? quotes === "single" ? (0, exports.escapeSingleQuotes)(value) : (0, exports.escapeDoubleQuotes)(value) : value;
+  return quoteEscaped;
+};
+exports.escapeString = escapeString;
+var escapeBashExpression = function (value, options) {
+  // no need to escape, we just return the string
+  return value;
+};
+exports.escapeBashExpression = escapeBashExpression;
+var escapeDoubleQuotes = function (value) {
+  return value === null || value === void 0 ? void 0 : value.toString().replace(/"/g, '\\"');
+};
+exports.escapeDoubleQuotes = escapeDoubleQuotes;
+var escapeSingleQuotes = function (value) {
+  return value === null || value === void 0 ? void 0 : value.toString().replace(/'/g, "\\'");
+};
+exports.escapeSingleQuotes = escapeSingleQuotes;
+/**
+ *
+ * escape env vars for .env files.
+ * unfortunatly, the format has many limitations. In order to be very forgiving, we need to do some magic here:
+ *
+ * - when the value contains no newlines, we are fine
+ * - if the value contains newlines, we need to wrap it in quotes. And thats where the problem begins:
+ * - you can't escape quotes. this is a limitation of dotenv and node
+ * - you can have inner quotes, but they break in node.js (not in dotenv though), see https://github.com/nodejs/node/issues/54134
+ * - so we need to quote cleverly
+ * - to make things worse, we need to check whether we have a simple stirng or a bash expression, that needs to be evalulated first...
+ *
+ *  what an absolute nightmare.
+ *
+ * - other languages are currently only partially supported, since most .env implementations are slightly different
+ */
+var escapeForDotEnv = function (value) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    // if string contains newlines, we need to wrap it in quotes
+    // we additionaly escape newlines, that give best compatibility
+    if (value.includes("\n")) {
+      var newlinesReplaces = value.replace(/\n/g, "\\n");
+      // default to ", but if this is not possible, we try to use ' or `
+      var quote = value.includes("\"") ? value.includes("'") ? value.includes("`") ?
+      // If all quote types are present, default to double quotes. This works in dotenv, but not in node.js because of the bug mentioned abouve
+      '"' : "`" : "'" : '"';
+      // if we found a quote, we can wrap the string in it
+      return "".concat(quote).concat(newlinesReplaces).concat(quote);
+    } else {
+      // otherwise we can return as is
+      return value;
+    }
+  } else if (value instanceof BashExpression_1.BashExpression) {
+    return escapeBashExpressionForDotEnv(value);
+  } else if (value instanceof VariableValueContainingReferences_1.VariableValueContainingReferences) {
+    // instead of doing it part-wise, we just do it all at once
+    var containsAnyBashExpression = value.parts.some(function (part) {
+      return part instanceof BashExpression_1.BashExpression;
+    });
+    if (!containsAnyBashExpression) {
+      return (0, exports.escapeForDotEnv)(value.toString({
+        quotes: "double"
+      }));
+    } else {
+      var result = escapeBashExpressionForDotEnv(new BashExpression_1.BashExpression(value.toString({
+        quotes: "double"
+      })));
+      return result;
+    }
+  } else {
+    return value;
+  }
+};
+exports.escapeForDotEnv = escapeForDotEnv;
+// basically the same thing as above for bash
+// thx chatgpt for this
+var escapeForDotEnvScript = (0, globalScriptFunctions_1.registerGlobalScriptFunction)("escapeForDotEnv", "\n input=\"${1:-$(cat)}\"\n input=\"${input//$'\\n'/\\\\n}\"\n  if [[ \"$input\" == *\\\\n* ]]; then\n    if [[ \"$input\" == *\\\"* && \"$input\" == *\\'* && \"$input\" == *\\`* ]]; then\n      printf \"\\\"%s\\\"\\n\" \"$input\" ".concat( /* fallback to double quotes */"", "\n    elif [[ \"$input\" == *\\\"* && \"$input\" == *\\'* ]]; then\n      printf \"`%s`\\n\" \"$input\"\n    elif [[ \"$input\" == *\\\"* ]]; then\n      printf \"'%s'\\n\" \"$input\"\n    else\n      printf \"\\\"%s\\\"\\n\" \"$input\"\n    fi\n  else\n    printf \"%s\\n\" \"$input\"\n  fi\n  "));
+var escapeBashExpressionForDotEnv = function (value) {
+  return value.transformWithCommand(escapeForDotEnvScript.name).toString();
+};

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,69 @@
+"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 VariableValueContainingReferences_1 = require("../variables/VariableValueContainingReferences");
+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" + ctx.indent + indentNewlinesInBashExpression(node.value, ctx.indent);
+  },
+  identify: function (v) {
+    return v instanceof BashExpression_1.BashExpression;
+  }
+};
+var indentNewlinesInBashExpression = function (expression, indent) {
+  return expression.transformWithCommand("sed '1!s/^/".concat(indent, "/'"));
+};
+var variableContainingReferences = {
+  tag: "",
+  resolve: function (str) {
+    // not really needed,but let's make typescript happy
+    return new VariableValueContainingReferences_1.VariableValueContainingReferences(str);
+  },
+  stringify: function (node, ctx) {
+    var value = node.value;
+    var stringified = value.parts.map(function (part) {
+      return part instanceof BashExpression_1.BashExpression ? indentNewlinesInBashExpression(part, ctx.indent) :
+      // indent every new line
+      part.toString().replace(/\n/g, "\n".concat(ctx.indent));
+    }).join("");
+    return "|-\n" + ctx.indent + stringified;
+  },
+  identify: function (v) {
+    return v instanceof VariableValueContainingReferences_1.VariableValueContainingReferences;
+  }
+};
+/***
+ * 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, variableContainingReferences],
+    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,47 @@
+"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 bashEscape_1 = require("./bashEscape");
+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, bashEscape_1.bashEscape)(value, {
+      quotes: "double"
+    }) : "", "\"");
+  });
+};
+exports.getInjectVarsScript = getInjectVarsScript;

package/dist/bash/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bashEscape";
+export * from "./BashExpression";

package/dist/bash/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function () {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __exportStar = this && this.__exportStar || function (m, exports) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+__exportStar(require("./bashEscape"), exports);
+__exportStar(require("./BashExpression"), exports);

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

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 var createArtifactsConfig_1 = require("../createArtifactsConfig");
 describe("createArtifactsConfig", function () {
   it("returns undefined if no artifacts or artifactsReports", function () {

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

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