@catladder/pipeline 0.0.7 → 1.0.2

package/dist/config/configruedEnvs.test.js

@@ -0,0 +1,103 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _1 = require(".");
+
+describe("getAllEnvsByTrigger", function () {
+  var SIMPLE_CONFIG = {
+    appName: "my-app",
+    customerName: "pan",
+    components: {
+      app1: {
+        dir: "dir1",
+        build: {
+          type: "node"
+        },
+        deploy: {
+          type: "kubernetes"
+        }
+      },
+      app2: {
+        dir: "dir2",
+        build: {
+          type: "node"
+        },
+        deploy: {
+          type: "kubernetes"
+        },
+        env: {
+          dev2: {
+            type: "dev"
+          },
+          review2: {
+            type: "review"
+          },
+          stage2: {
+            type: "stage"
+          },
+          prod2: {
+            type: "prod"
+          }
+        }
+      },
+      app3: {
+        dir: "dir2",
+        build: {
+          type: "node"
+        },
+        deploy: {
+          type: "kubernetes"
+        },
+        env: {
+          dev: false,
+          review: false,
+          stage: false,
+          prod: false
+        }
+      }
+    }
+  };
+  describe("mainBranch", function () {
+    it("always includes dev if not disabled", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app1", "mainBranch");
+      expect(envs).toEqual(["dev"]);
+    });
+    it("returns additional dev environments", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app2", "mainBranch");
+      expect(envs).toEqual(["dev", "dev2"]);
+    });
+    it("does not include disabled envs", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app3", "mainBranch");
+      expect(envs).toEqual([]);
+    });
+  });
+  describe("mr", function () {
+    it("always includes review if not disabled", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app1", "mr");
+      expect(envs).toEqual(["review"]);
+    });
+    it("returns additional dev environments", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app2", "mr");
+      expect(envs).toEqual(["review", "review2"]);
+    });
+    it("does not include disabled envs", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app3", "mr");
+      expect(envs).toEqual([]);
+    });
+  });
+  describe("taggedRelease", function () {
+    it("always includes review if not disabled", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app1", "taggedRelease");
+      expect(envs).toEqual(["stage", "prod"]);
+    });
+    it("returns additional dev environments", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app2", "taggedRelease");
+      expect(envs).toEqual(["stage", "prod", "stage2", "prod2"]);
+    });
+    it("does not include disabled envs", function () {
+      var envs = (0, _1.getAllEnvsByTrigger)(SIMPLE_CONFIG, "app3", "taggedRelease");
+      expect(envs).toEqual([]);
+    });
+  });
+});

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./configruedEnvs";
+export * from "./readConfig";

package/dist/config/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function () {
+      return m[k];
+    }
+  });
+} : 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);
+};
+
+exports.__esModule = true;
+
+__exportStar(require("./configruedEnvs"), exports);
+
+__exportStar(require("./readConfig"), exports);

package/dist/config/readConfig.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "../types";
+export declare const readConfigSync: (directory?: string) => Config | null;

package/dist/config/readConfig.js

@@ -0,0 +1,47 @@
+"use strict";
+
+exports.__esModule = true;
+exports.readConfigSync = void 0;
+
+var fs_1 = require("fs");
+
+var ts_node_1 = require("ts-node");
+
+var js_yaml_1 = require("js-yaml"); // allows us to load ts files
+
+
+var fullPath = function (directory, ext) {
+  return directory + "/catladder." + ext;
+};
+
+var readConfigSync = function (directory) {
+  if (directory === void 0) {
+    directory = process.cwd();
+  }
+
+  (0, ts_node_1.register)({
+    cwd: directory,
+    transpileOnly: true,
+    compilerOptions: {
+      module: "commonjs"
+    }
+  });
+  var found = ["ts", "js", "yml", "yaml"].find(function (extension) {
+    return (0, fs_1.existsSync)(fullPath(directory, extension));
+  });
+
+  if (found) {
+    if (found === "ts" || found === "js") {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      return require(fullPath(directory, found))["default"];
+    } else {
+      return (0, js_yaml_1.load)((0, fs_1.readFileSync)(fullPath(directory, found), {
+        encoding: "utf-8"
+      }));
+    }
+  }
+
+  return null;
+};
+
+exports.readConfigSync = readConfigSync;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const PIPELINE_IMAGE_TAG: string;
+export declare const DOCKER_REGISTRY: string;

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+
+exports.__esModule = true;
+exports.DOCKER_REGISTRY = exports.PIPELINE_IMAGE_TAG = void 0;
+exports.PIPELINE_IMAGE_TAG = "v1-0-2-9d21e784" || "";
+exports.DOCKER_REGISTRY = "git.panter.ch:5001/catladder/catladder" || "";

package/dist/context/index.d.ts

@@ -0,0 +1,5 @@
+import { Config } from "../types/config";
+import { CommitInfo, Context, Environment, YarnInfo } from "../types/context";
+export declare const getSecretVarName: (env: string, componentName: string, key: string) => string;
+export declare const getEnvironment: (config: Config, componentName: string, env: string, commitInfo?: CommitInfo | undefined, skipReferences?: boolean) => Environment;
+export declare const createContext: (config: Config, componentName: string, env: string, commitInfo?: CommitInfo | undefined, yarnInfo?: YarnInfo | undefined) => Context;

package/dist/context/index.js

@@ -0,0 +1,211 @@
+"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 __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
+exports.__esModule = true;
+exports.createContext = exports.getEnvironment = exports.getSecretVarName = void 0;
+
+var lodash_1 = require("lodash");
+
+var slugify_1 = __importDefault(require("slugify"));
+
+var build_1 = require("../build");
+
+var deploy_1 = require("../deploy");
+
+var config_1 = require("../types/config");
+
+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 getEnvironment = function (config, componentName, env, commitInfo, skipReferences // to prevent infinit loop
+) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+
+  if (skipReferences === void 0) {
+    skipReferences = false;
+  }
+
+  var componentConfig = config.components[componentName];
+
+  if (!componentConfig) {
+    throw new Error("unknown component " + componentName);
+  }
+
+  var defaultConfig = componentConfig;
+  var envConfig = (_b = (_a = componentConfig.env) === null || _a === void 0 ? void 0 : _a[env]) !== null && _b !== void 0 ? _b : {};
+
+  if (envConfig === false) {
+    throw new Error("env is disabled: " + env);
+  }
+
+  var mergedConfig = (0, lodash_1.merge)({}, defaultConfig, envConfig); // env type: if its set manually, use that, otherwise use the known env types
+
+  var basePredefinedVariables = {
+    ENV_SHORT: env,
+    APP_DIR: componentConfig.dir
+  };
+  var envType = (_c = envConfig === null || envConfig === void 0 ? void 0 : envConfig.type) !== null && _c !== void 0 ? _c : (0, config_1.isKnowEnvType)(env) ? env : null;
+
+  if (!envType) {
+    throw new Error("Missing type in environment " + env + " in component " + componentName);
+  }
+
+  var environmentName = envType === "review" && commitInfo ? "".concat(env, "/").concat(commitInfo.refName, "/").concat(componentName) : "".concat(env, "/").concat(componentName);
+  var environmentSlug = envType === "review" && commitInfo ? "".concat(env, "-").concat(commitInfo.refSlug, "-").concat(componentName) : "".concat(env, "-").concat(componentName);
+  var predefinedVariables;
+  var hostname;
+  var url;
+
+  if (envType === "local") {
+    var devLocalConfig = mergedConfig;
+    var port = (_d = devLocalConfig.port) !== null && _d !== void 0 ? _d : 3000;
+    hostname = "localhost:" + port;
+    url = "http://" + hostname;
+    predefinedVariables = {
+      ROOT_URL: url,
+      PORT: port.toString()
+    };
+  } else {
+    var KUBE_NAMESPACE = "".concat(config.customerName, "-").concat(config.appName, "-").concat(env);
+    var RELEASE_NAME = "".concat(config.customerName, "-").concat(config.appName, "-").concat(environmentSlug);
+    var componentSlug = (0, slugify_1["default"])(componentName);
+    var envInUrl = envType === "review" && commitInfo ? "".concat(commitInfo.refSlug, ".").concat(env) : env;
+    var HOST_CANONICAL = "".concat(config.appName, "-").concat(componentSlug, ".").concat(envInUrl, ".").concat(config.customerName, ".panter.cloud");
+    hostname = (_e = mergedConfig === null || mergedConfig === void 0 ? void 0 : mergedConfig.hostname) !== null && _e !== void 0 ? _e : HOST_CANONICAL;
+    var url_1 = "https://".concat(hostname);
+    var KUBE_APP_NAME = envType === "review" && commitInfo ? "".concat(componentName, "-").concat(commitInfo.refSlug) : componentName;
+    predefinedVariables = __assign(__assign({}, basePredefinedVariables), {
+      HOST_CANONICAL: HOST_CANONICAL,
+      ROOT_URL: url_1,
+      KUBE_NAMESPACE: KUBE_NAMESPACE,
+      KUBE_APP_NAME: KUBE_APP_NAME,
+      RELEASE_NAME: RELEASE_NAME
+    });
+  }
+
+  var publicEnvVars = (_g = (_f = mergedConfig.vars) === null || _f === void 0 ? void 0 : _f.public) !== null && _g !== void 0 ? _g : {};
+  var secretEnvVarKeys = (_j = (_h = mergedConfig.vars) === null || _h === void 0 ? void 0 : _h.secret) !== null && _j !== void 0 ? _j : [];
+  var secretEnvVars = Object.fromEntries(secretEnvVarKeys.map(function (key) {
+    return [key, "$".concat((0, exports.getSecretVarName)(env, componentName, key))];
+  }));
+  var referencedRaw = (_l = (_k = mergedConfig.vars) === null || _k === void 0 ? void 0 : _k.fromComponents) !== null && _l !== void 0 ? _l : {};
+  var referenced = skipReferences ? {} : Object.entries(referencedRaw).reduce(function (acc, _a) {
+    var _b = __read(_a, 2),
+        otherApp = _b[0],
+        mapping = _b[1];
+
+    var envVars = (0, exports.getEnvironment)(config, otherApp, env, commitInfo, true // prevent infinit loop
+    ).envVars;
+    return __assign(__assign({}, acc), Object.fromEntries(Object.entries(mapping).map(function (_a) {
+      var _b = __read(_a, 2),
+          ourKey = _b[0],
+          otherKey = _b[1];
+
+      return [ourKey, envVars[otherKey]];
+    })));
+  }, {});
+
+  var envVars = __assign(__assign(__assign(__assign({}, predefinedVariables), secretEnvVars), referenced), publicEnvVars);
+
+  return {
+    envType: envType,
+    hostname: hostname,
+    fullName: environmentName,
+    slug: environmentSlug,
+    shortName: env,
+    url: predefinedVariables.ROOT_URL,
+    envVars: envVars,
+    secretEnvVarKeys: secretEnvVarKeys
+  };
+};
+
+exports.getEnvironment = getEnvironment;
+
+var createContext = function (config, componentName, env, commitInfo, yarnInfo) {
+  var _a, _b;
+
+  if (!/^[a-z0-9-]+$/.test(componentName)) {
+    throw new Error("componentName may only contain lower case letters, numbers and -");
+  }
+
+  var rawConfig = config.components[componentName];
+
+  if (!rawConfig) {
+    throw new Error("unknown component " + componentName);
+  } // envs can override the config
+
+
+  var envConfig = (_b = (_a = rawConfig.env) === null || _a === void 0 ? void 0 : _a[env]) !== null && _b !== void 0 ? _b : {};
+  var componentConfigWithoutDefaults = (0, lodash_1.merge)({}, rawConfig, envConfig); // fill in defaults of build and deploy
+
+  var defaults = componentConfigWithoutDefaults.deploy ? {
+    build: build_1.BUILD_TYPES[componentConfigWithoutDefaults.build.type].defaults(),
+    deploy: deploy_1.DEPLOY_TYPES[componentConfigWithoutDefaults.deploy.type].defaults()
+  } : {
+    build: {},
+    deploy: {}
+  };
+  var componentConfig = (0, lodash_1.merge)({}, defaults, componentConfigWithoutDefaults);
+  return {
+    fullConfig: config,
+    componentConfig: componentConfig,
+    componentName: componentName,
+    environment: (0, exports.getEnvironment)(config, componentName, env, commitInfo),
+    commitInfo: commitInfo,
+    yarnInfo: yarnInfo
+  };
+};
+
+exports.createContext = createContext;

package/dist/defaults/index.d.ts

@@ -0,0 +1,2 @@
+import { Retry } from "../types";
+export declare const BASE_RETRY: Retry;

package/dist/defaults/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.__esModule = true;
+exports.BASE_RETRY = void 0;
+exports.BASE_RETRY = {
+  max: 2,
+  when: ["runner_system_failure", "stuck_or_timeout_failure"]
+};

package/dist/deploy/base.d.ts

@@ -0,0 +1,9 @@
+import { GitlabJob, Context, GitlabJobDef } from "../types";
+export declare const DEPLOY_JOB_NAME = "\uD83D\uDE80 Deploy";
+export declare const STOP_JOB_NAME = "\uD83D\uDED1 Stop \u26A0\uFE0F";
+declare type JobWithoutScript = Omit<GitlabJob, "job"> & {
+  job: Omit<GitlabJobDef, "script">;
+};
+export declare const getBaseDeploymentJob: (context: Context) => JobWithoutScript;
+export declare const getBaseDeploymentStopJob: (context: Context) => JobWithoutScript;
+export {};

package/dist/deploy/base.js

@@ -0,0 +1,94 @@
+"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);
+};
+
+exports.__esModule = true;
+exports.getBaseDeploymentStopJob = exports.getBaseDeploymentJob = exports.STOP_JOB_NAME = exports.DEPLOY_JOB_NAME = void 0;
+exports.DEPLOY_JOB_NAME = "🚀 Deploy";
+exports.STOP_JOB_NAME = "🛑 Stop ⚠️";
+var DEPLOY_RUNNER_VARIABLES = {
+  KUBERNETES_CPU_REQUEST: "0.5",
+  KUBERNETES_CPU_LIMIT: "1",
+  KUBERNETES_MEMORY_REQUEST: "200Mi",
+  KUBERNETES_MEMORY_LIMIT: "500Mi"
+};
+
+var getBaseDeploymentJob = function (context) {
+  var environment = {
+    name: context.environment.fullName,
+    url: context.environment.url
+  };
+  var autoStop = context.environment.envType === "review" ? "2 weeks" : context.environment.envType === "dev" ? "3 weeks" : undefined;
+  return {
+    name: exports.DEPLOY_JOB_NAME,
+    envMode: "stagePerEnv",
+    // we don't want to deploy when there is a broken test
+    needsStages: [{
+      stage: "build",
+      artifacts: false
+    }, {
+      stage: "test",
+      artifacts: false
+    }],
+    job: {
+      rules: [context.environment.envType === "prod" ? {
+        when: "manual"
+      } : {
+        when: "on_success"
+      }],
+      stage: "deploy",
+      dependencies: [],
+      variables: __assign({}, DEPLOY_RUNNER_VARIABLES),
+      environment: __assign(__assign({}, environment), {
+        on_stop: exports.STOP_JOB_NAME,
+        auto_stop_in: autoStop
+      })
+    }
+  };
+};
+
+exports.getBaseDeploymentJob = getBaseDeploymentJob;
+
+var getBaseDeploymentStopJob = function (context) {
+  var environment = {
+    name: context.environment.fullName,
+    url: context.environment.url
+  };
+  return {
+    name: exports.STOP_JOB_NAME,
+    envMode: "stagePerEnv",
+    job: {
+      needs: [exports.DEPLOY_JOB_NAME],
+      rules: [{
+        "if": "$CI_COMMIT_BRANCH =~ /^[0-9]+\\.([0-9]+|x)\\.x$/",
+        when: "on_success",
+        allow_failure: true
+      }, {
+        when: "manual",
+        allow_failure: true
+      }],
+      variables: __assign(__assign({}, DEPLOY_RUNNER_VARIABLES), {
+        GIT_STRATEGY: "none"
+      }),
+      stage: "stop",
+      dependencies: [],
+      environment: __assign(__assign({}, environment), {
+        action: "stop"
+      })
+    }
+  };
+};
+
+exports.getBaseDeploymentStopJob = getBaseDeploymentStopJob;

package/dist/deploy/index.d.ts

@@ -0,0 +1,11 @@
+import { GitlabJobs } from "../types/gitlab-types";
+import { Context } from "../types/context";
+import { DeployConfig } from "./types";
+export declare type DeployTypes = { [type in DeployConfig["type"]]: {
+  jobs: (context: Context) => GitlabJobs;
+  defaults: () => Partial<Extract<DeployConfig, {
+    type: type;
+  }>>;
+} };
+export * from "./types";
+export declare const DEPLOY_TYPES: DeployTypes;

package/dist/deploy/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, {
+    enumerable: true,
+    get: function () {
+      return m[k];
+    }
+  });
+} : 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);
+};
+
+exports.__esModule = true;
+exports.DEPLOY_TYPES = void 0;
+
+var kubernetes_1 = require("./kubernetes");
+
+__exportStar(require("./types"), exports);
+
+exports.DEPLOY_TYPES = {
+  kubernetes: {
+    jobs: kubernetes_1.createKubernetesDeployJobs,
+    defaults: function () {
+      return {};
+    }
+  }
+};

package/dist/deploy/kubernetes/cloudsql.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../..";
+export declare const createCloudsqlBaseConfig: (context: Context) => {
+  cloudsql: {
+    proxyCredentials: string;
+  };
+};

package/dist/deploy/kubernetes/cloudsql.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createCloudsqlBaseConfig = void 0;
+
+var __1 = require("../..");
+
+var createCloudsqlBaseConfig = function (context) {
+  return {
+    cloudsql: {
+      proxyCredentials: "$".concat((0, __1.getSecretVarName)(context.environment.shortName, context.componentName, "cloudsqlProxyCredentials"))
+    }
+  };
+};
+
+exports.createCloudsqlBaseConfig = createCloudsqlBaseConfig;

package/dist/deploy/kubernetes/deployJob.d.ts

@@ -0,0 +1,3 @@
+import { GitlabJobs } from "../../types/gitlab-types";
+import { Context } from "../../types/context";
+export declare const createKubernetesDeployJobs: (context: Context) => GitlabJobs;