@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-perf-cli-reduce-bundle-size-with-tsconfig-optimization-3556aaa4

package/dist/context/getEnvConfig.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvConfig = void 0;
+var utils_1 = require("../utils");
+var getEnvConfig = function (config, componentName, env) {
+  var _a, _b;
+  var defaultConfig = config.components[componentName];
+  if (!defaultConfig) {
+    throw new Error("unknown component " + componentName);
+  }
+  var envCustomizations = (_b = (_a = defaultConfig.env) === null || _a === void 0 ? void 0 : _a[env]) !== null && _b !== void 0 ? _b : {};
+  if (envCustomizations === false) {
+    throw new Error("env is disabled: " + env + ":" + componentName);
+  }
+  return (0, utils_1.mergeWithMergingArrays)(defaultConfig, envCustomizations);
+};
+exports.getEnvConfig = getEnvConfig;

package/dist/context/getEnvType.d.ts

@@ -0,0 +1,4 @@
+import type { EnvType } from "../types";
+export declare const getEnvType: (env: string, envConfig: {
+  type?: EnvType;
+}) => EnvType;

package/dist/context/getEnvType.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvType = void 0;
+var types_1 = require("../types");
+var getEnvType = function (env, envConfig) {
+  if (envConfig.type) return envConfig.type;
+  if ((0, types_1.isKnowEnvType)(env)) {
+    return env;
+  }
+  throw new Error("unknown env type: " + env);
+};
+exports.getEnvType = getEnvType;

package/dist/context/getEnvironment.d.ts

@@ -0,0 +1,3 @@
+import type { CreateComponentContextContext } from "..";
+import type { Environment } from "../types/context";
+export declare const getEnvironment: (ctx: CreateComponentContextContext) => Promise<Environment>;

package/dist/{pipeline/createChildPipeline.test.js → context/getEnvironment.js}

@@ -1,12 +1,21 @@
 "use strict";
 
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
 var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
       resolve(value);
     });
   }
-
   return new (P || (P = Promise))(function (resolve, reject) {
     function fulfilled(value) {
       try {
@@ -15,7 +24,6 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
         reject(e);
       }
     }
-
     function rejected(value) {
       try {
         step(generator["throw"](value));
@@ -23,29 +31,26 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
         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];
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
     },
-    trys: [],
-    ops: []
-  },
-      f,
-      y,
-      t,
-      g;
+    f,
+    y,
+    t,
+    g;
   return g = {
     next: verb(0),
     "throw": verb(1),
@@ -53,78 +58,59 @@ var __generator = this && this.__generator || function (thisArg, body) {
   }, 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 (_) 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]) {
         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];
@@ -132,7 +118,6 @@ var __generator = this && this.__generator || function (thisArg, body) {
     } finally {
       f = t = 0;
     }
-
     if (op[0] & 5) throw op[1];
     return {
       value: op[0] ? op[1] : void 0,
@@ -140,55 +125,34 @@ var __generator = this && this.__generator || function (thisArg, body) {
     };
   }
 };
-
-exports.__esModule = true;
-
-var createChildPipeline_1 = require("./createChildPipeline");
-
-describe("createChildPipeline", function () {
-  describe("node-app to kuberntes", function () {
-    var config = {
-      appName: "test",
-      customerName: "pan",
-      components: {
-        "my-app": {
-          dir: "myapp",
-          build: {
-            type: "node"
-          },
-          deploy: {
-            type: "kubernetes",
-            cluster: {
-              type: "gcloud",
-              name: "mega-cluster",
-              projectId: "super-google-project",
-              region: "ch-blabla"
-            }
-          }
-        }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvironment = void 0;
+var getEnvironmentContext_1 = require("./getEnvironmentContext");
+var getEnvironmentVariables_1 = require("./getEnvironmentVariables");
+var getEnvironment = function (ctx) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var env, variables, envContext, envType;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          env = ctx.env;
+          return [4 /*yield*/, (0, getEnvironmentVariables_1.getEnvironmentVariables)(ctx)];
+        case 1:
+          variables = _a.sent();
+          envContext = (0, getEnvironmentContext_1.getEnvironmentContext)(ctx);
+          envType = envContext.envType;
+          return [2 /*return*/, __assign({
+            envType: envType,
+            fullName: envContext.fullName,
+            slugPrefix: envContext.environmentSlugPrefix,
+            reviewSlug: envContext.reviewSlug,
+            slug: envContext.environmentSlug,
+            shortName: env
+          }, variables)];
       }
-    };
-    it("creates a pipeline for a single app on the main branch", function () {
-      return __awaiter(void 0, void 0, void 0, function () {
-        var _a, image, jobs;
-
-        return __generator(this, function (_b) {
-          switch (_b.label) {
-            case 0:
-              return [4
-              /*yield*/
-              , (0, createChildPipeline_1.createChildPipeline)("gitlab", "mainBranch", config)];
-
-            case 1:
-              _a = _b.sent(), image = _a.image, jobs = _a.jobs;
-              expect(image).toEqual("git.panter.ch:5001/catladder/catladder/base-pipeline:");
-              expect(Object.keys(jobs)).toEqual(["my-app audit", "my-app lint", "my-app test", "dev my-app app-build", "dev my-app docker-build", "dev my-app deploy-to-kubernetes", "dev my-app kubernetes-stop"]);
-              return [2
-              /*return*/
-              ];
-          }
-        });
-      });
     });
   });
-});
+};
+exports.getEnvironment = getEnvironment;

package/dist/context/getEnvironmentContext.d.ts

@@ -0,0 +1,8 @@
+import type { CreateComponentContextContext } from "..";
+import type { EnvironmentContext } from "../types/environmentContext";
+export declare const getEnvironmentContext: ({
+  env,
+  componentName,
+  config,
+  pipelineType
+}: CreateComponentContextContext) => EnvironmentContext;

package/dist/context/getEnvironmentContext.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvironmentContext = void 0;
+var BashExpression_1 = require("../bash/BashExpression");
+var getEnvConfig_1 = require("./getEnvConfig");
+var getEnvType_1 = require("./getEnvType");
+var getReviewSlug_1 = require("./getReviewSlug");
+var getEnvironmentSlugPrefix = function (env, reviewSlug) {
+  if (reviewSlug) {
+    return (0, BashExpression_1.joinBashExpressions)([env, reviewSlug], "-");
+  }
+  return env;
+};
+var getEnvironmentContext = function (_a) {
+  var env = _a.env,
+    componentName = _a.componentName,
+    config = _a.config,
+    pipelineType = _a.pipelineType;
+  var envConfigRaw = (0, getEnvConfig_1.getEnvConfig)(config, componentName, env);
+  var envType = (0, getEnvType_1.getEnvType)(env, envConfigRaw);
+  var reviewSlug = (0, getReviewSlug_1.getReviewSlug)(envConfigRaw, env, pipelineType);
+  var environmentSlugPrefix = getEnvironmentSlugPrefix(env, reviewSlug);
+  var environmentSlug = environmentSlugPrefix.concat("-".concat(componentName));
+  var fullName = (0, BashExpression_1.joinBashExpressions)([config.customerName, config.appName, environmentSlug], "-");
+  return {
+    envConfigRaw: envConfigRaw,
+    deployConfigRaw: envConfigRaw.deploy,
+    buildConfigRaw: envConfigRaw.build,
+    environmentSlugPrefix: environmentSlugPrefix,
+    environmentSlug: environmentSlug,
+    reviewSlug: reviewSlug,
+    pipelineType: pipelineType,
+    fullName: fullName,
+    envType: envType,
+    componentName: componentName,
+    env: env,
+    fullConfig: config
+  };
+};
+exports.getEnvironmentContext = getEnvironmentContext;

package/dist/context/getEnvironmentVariables.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentContext, EnvironmentEnvVarPart as EnvironmentVariables } from "../types";
+import type { CreateComponentContextContext } from "..";
+import type { StringOrBashExpression } from "../bash/BashExpression";
+import type { EnvironmentContext } from "../types/environmentContext";
+export type SecretEnvVar = {
+  key: string;
+  hidden?: boolean;
+};
+declare const getBasePredefinedVariables: (ctx: EnvironmentContext) => {
+  ENV_SHORT: string;
+  APP_DIR: string;
+  ENV_TYPE: "dev" | "review" | "stage" | "prod" | "local";
+};
+type BasePredefinedVariables = ReturnType<typeof getBasePredefinedVariables>;
+export type PredefinedVariables = BasePredefinedVariables & {
+  /**
+   * undefined in rails, Rails before 6.1 (mis)uses the `HOST` environment variable to specify the IP to bind to
+   */
+  HOST?: StringOrBashExpression;
+  ROOT_URL: StringOrBashExpression;
+  HOST_INTERNAL: StringOrBashExpression;
+  ROOT_URL_INTERNAL: StringOrBashExpression;
+};
+export declare const getEnvironmentVariables: (ctx: CreateComponentContextContext, alreadyVisited?: Record<string, Record<string, boolean>>) => Promise<EnvironmentVariables>;
+export declare const getSecretVarName: (env: string, componentName: string, key: string) => string;
+export declare const getSecretVarNameForContext: (context: ComponentContext, key: string) => string;
+export {};

package/dist/context/getEnvironmentVariables.js

@@ -0,0 +1,285 @@
+"use strict";
+
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __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.getSecretVarNameForContext = exports.getSecretVarName = exports.getEnvironmentVariables = void 0;
+var lodash_1 = require("lodash");
+var deploy_1 = require("../deploy");
+var BashExpression_1 = require("../bash/BashExpression");
+var types_1 = require("../build/types");
+var getBuildInfoVariables_1 = require("./getBuildInfoVariables");
+var getEnvironmentContext_1 = require("./getEnvironmentContext");
+var resolveReferences_1 = require("./resolveReferences");
+var transformJobOnlyVars_1 = require("./transformJobOnlyVars");
+var envVars_1 = require("./utils/envVars");
+var getBasePredefinedVariables = function (ctx) {
+  return __assign({
+    ENV_SHORT: ctx.env,
+    APP_DIR: ctx.envConfigRaw.dir,
+    ENV_TYPE: ctx.envType
+  }, ctx.envType !== "local" ? (0, getBuildInfoVariables_1.getBuildInfoVariables)(ctx) : {});
+};
+var getEnvironmentVariables = function (ctx_1) {
+  var args_1 = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    args_1[_i - 1] = arguments[_i];
+  }
+  return __awaiter(void 0, __spreadArray([ctx_1], __read(args_1), false), void 0, function (ctx, alreadyVisited) {
+    var environmentContext, config, env, componentName, envConfigRaw, deployConfigRaw, buildConfigRaw, envType, basePredefinedVariables, predefinedVariables, host, url, devLocalConfig, port, additionalEnvVars, HOST_INTERNAL, publicEnvVarsRaw, additionalSecretKeys, secretEnvVarKeys, secretEnvVars, legacyFromComponents, publicEnvVarsRawWithLegacyFromComponents, publicEnvVarsRawSanitized, envVarsRaw, envVars;
+    var _a, _b;
+    var _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    if (alreadyVisited === void 0) {
+      alreadyVisited = {};
+    }
+    return __generator(this, function (_m) {
+      switch (_m.label) {
+        case 0:
+          environmentContext = (0, getEnvironmentContext_1.getEnvironmentContext)(ctx);
+          config = ctx.config, env = ctx.env, componentName = ctx.componentName;
+          envConfigRaw = environmentContext.envConfigRaw, deployConfigRaw = environmentContext.deployConfigRaw, buildConfigRaw = environmentContext.buildConfigRaw, envType = environmentContext.envType;
+          basePredefinedVariables = getBasePredefinedVariables(environmentContext);
+          if (envType === "local") {
+            devLocalConfig = envConfigRaw;
+            port = (_c = devLocalConfig.port) !== null && _c !== void 0 ? _c : 3000;
+            host = "localhost:" + port.toString();
+            url = "http://" + host;
+            predefinedVariables = __assign(__assign(__assign(__assign({}, basePredefinedVariables), {
+              ENV_SHORT: "local",
+              ROOT_URL: url
+            }), (0, types_1.isStandaloneBuildConfig)(buildConfigRaw) && buildConfigRaw.type === "rails" ? {} : {
+              HOST: host
+            }), {
+              HOST_INTERNAL: host,
+              ROOT_URL_INTERNAL: "http://" + host,
+              PORT: port.toString()
+            });
+          } else {
+            additionalEnvVars = deployConfigRaw ? deploy_1.DEPLOY_TYPES[deployConfigRaw.type].getAdditionalEnvVars(environmentContext) : {};
+            HOST_INTERNAL = (_d = additionalEnvVars.HOST_INTERNAL) !== null && _d !== void 0 ? _d : "unknown-host.example.com";
+            host = (_e = envConfigRaw === null || envConfigRaw === void 0 ? void 0 : envConfigRaw.host) !== null && _e !== void 0 ? _e : HOST_INTERNAL;
+            url = (0, BashExpression_1.joinBashExpressions)(["https://", host]);
+            predefinedVariables = __assign(__assign(__assign(__assign({}, basePredefinedVariables), (0, types_1.isStandaloneBuildConfig)(buildConfigRaw) && buildConfigRaw.type === "rails" ? {} : {
+              HOST: host
+            }), {
+              ROOT_URL: url,
+              HOST_INTERNAL: HOST_INTERNAL,
+              /**@deprecated */
+              HOST_CANONICAL: HOST_INTERNAL,
+              ROOT_URL_INTERNAL: (0, BashExpression_1.joinBashExpressions)(["https://", HOST_INTERNAL])
+            }), additionalEnvVars);
+          }
+          publicEnvVarsRaw = (_g = (_f = envConfigRaw.vars) === null || _f === void 0 ? void 0 : _f.public) !== null && _g !== void 0 ? _g : {};
+          additionalSecretKeys = deployConfigRaw ? deploy_1.DEPLOY_TYPES[deployConfigRaw.type].additionalSecretKeys(environmentContext) : [];
+          secretEnvVarKeys = __spreadArray(__spreadArray([], __read((0, envVars_1.stringListToSecreteEnvVarList)((_j = (_h = envConfigRaw.vars) === null || _h === void 0 ? void 0 : _h.secret) !== null && _j !== void 0 ? _j : [])), false), __read(additionalSecretKeys), false);
+          secretEnvVars = (0, envVars_1.makeSecretEnvVarMapping)(env, componentName, secretEnvVarKeys);
+          legacyFromComponents = (_l = (_k = envConfigRaw.vars) === null || _k === void 0 ? void 0 : _k.fromComponents) !== null && _l !== void 0 ? _l : {};
+          publicEnvVarsRawWithLegacyFromComponents = (0, lodash_1.merge)({}, (0, resolveReferences_1.translateLegacyFromComponents)(legacyFromComponents), publicEnvVarsRaw);
+          publicEnvVarsRawSanitized = (0, envVars_1.stringifyValues)(publicEnvVarsRawWithLegacyFromComponents);
+          envVarsRaw = addIndexVar(__assign(__assign(__assign({}, predefinedVariables), secretEnvVars), publicEnvVarsRawSanitized));
+          return [4 /*yield*/, (0, resolveReferences_1.resolveReferences)(envVarsRaw, function (otherComponentName, alreadyVisited) {
+            return __awaiter(void 0, void 0, void 0, function () {
+              var otherEnvVars;
+              return __generator(this, function (_a) {
+                switch (_a.label) {
+                  case 0:
+                    return [4 /*yield*/, (0, exports.getEnvironmentVariables)(__assign(__assign({}, ctx), {
+                      componentName: otherComponentName
+                    }), alreadyVisited)];
+                  case 1:
+                    otherEnvVars = _a.sent().envVars;
+                    return [2 /*return*/, otherEnvVars];
+                }
+              });
+            });
+          }, alreadyVisited)];
+        case 1:
+          envVars = _m.sent();
+          _a = {
+            envVars: envVars,
+            secretEnvVarKeys: secretEnvVarKeys
+          };
+          _b = {};
+          return [4 /*yield*/, (0, transformJobOnlyVars_1.transformJobOnlyVars)(env, componentName, buildConfigRaw && (0, types_1.isStandaloneBuildConfig)(buildConfigRaw) && buildConfigRaw.jobVars || null)];
+        case 2:
+          _b.build = _m.sent();
+          return [4 /*yield*/, (0, transformJobOnlyVars_1.transformJobOnlyVars)(env, componentName, deployConfigRaw && deployConfigRaw.jobVars || null)];
+        case 3:
+          return [2 /*return*/, (_a.jobOnlyVars = (_b.deploy = _m.sent(), _b), _a.host = host, _a.url = url, _a)];
+      }
+    });
+  });
+};
+exports.getEnvironmentVariables = getEnvironmentVariables;
+var sanitizeForEnVar = function (s) {
+  return s.replace(/-/g, "_");
+};
+var getSecretVarName = function (env, componentName, key) {
+  return "CL_".concat(sanitizeForEnVar(env), "_").concat(sanitizeForEnVar(componentName), "_").concat(key);
+}; // remove dash from component name
+exports.getSecretVarName = getSecretVarName;
+var addIndexVar = function (vars) {
+  return __assign(__assign({}, vars), {
+    _ALL_ENV_VAR_KEYS: JSON.stringify(Object.keys(vars))
+  });
+};
+var getSecretVarNameForContext = function (context, key) {
+  return (0, exports.getSecretVarName)(context.env, context.name, key);
+};
+exports.getSecretVarNameForContext = getSecretVarNameForContext;

package/dist/context/getLabels.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentContext } from "../types";
+export declare const getLabels: (context: ComponentContext) => {
+  "customer-name": string | undefined;
+  "component-name": string | undefined;
+  "app-name": string | undefined;
+  "env-type": string | undefined;
+  "env-name": string | undefined;
+  "build-type": string | undefined;
+};