@catladder/pipeline 0.0.4 → 0.0.8

package/dist/scripts/createSamplePipeline.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/dist/scripts/createSamplePipeline.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var fs_1 = require("fs");
+var createPipeline_1 = require("./magic/createPipeline");
+var sample_config_1 = __importDefault(require("./magic/sample-config"));
+createPipeline_1.createPipeline("taggedRelease", sample_config_1["default"]).then(function (mainPipeline) {
+    fs_1.writeFileSync("__pipeline.yml", JSON.stringify(mainPipeline, null, 2), {
+        encoding: "utf-8"
+    });
+});

package/dist/scripts/magic/build/docker.d.ts

@@ -0,0 +1,2 @@
+import { GitlabJobDef, Context } from "../types";
+export declare const createDockerBuildJob: (context: Context, { script }: Pick<GitlabJobDef, "script">) => GitlabJobDef;

package/dist/scripts/magic/build/docker.js

@@ -0,0 +1,68 @@
+"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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.createDockerBuildJob = void 0;
+var createDockerBuildJob = function (context, _a) {
+    var script = _a.script;
+    var base = {
+        stage: "build",
+        image: "git.panter.ch:5001/catladder/gitlab-ci/docker-build:$PIPELINE_IMAGE_TAG",
+        interruptible: true,
+        services: [
+            {
+                name: "docker:20-dind",
+                command: ["--tls=false"]
+            },
+        ],
+        variables: {
+            APP_DIR: context.componentConfig.dir,
+            DOCKER_HOST: "tcp://0.0.0.0:2375",
+            DOCKER_TLS_CERTDIR: "",
+            DOCKER_DIR: ".",
+            IMAGE_TAG: "$CI_COMMIT_SHA",
+            DOCKER_DRIVER: "overlay2",
+            IMAGE_NAME: "$CI_REGISTRY_IMAGE/" + context.componentName,
+            CACHE_IMAGE: "$CI_REGISTRY_IMAGE/" + context.componentName + "/cache:cache"
+        }
+    };
+    return __assign(__assign({}, base), { script: __spreadArray(__spreadArray([], __read(script)), [
+            "docker login --username gitlab-ci-token --password $CI_JOB_TOKEN $CI_REGISTRY",
+            "docker pull $CACHE_IMAGE || true",
+            "docker build --network host --cache-from $CACHE_IMAGE --tag $IMAGE_NAME:$IMAGE_TAG -f $APP_DIR/Dockerfile .",
+            "docker push $IMAGE_NAME:$IMAGE_TAG",
+            "docker tag $IMAGE_NAME:$IMAGE_TAG $CACHE_IMAGE",
+            "docker push $CACHE_IMAGE",
+        ]) });
+};
+exports.createDockerBuildJob = createDockerBuildJob;

package/dist/scripts/magic/build/index.d.ts

@@ -0,0 +1,9 @@
+import { GitlabJobs } from "../types/gitlab-types";
+import { Context } from "../types/context";
+import { BuildConfig } from "./types";
+export declare const buildJobCreators: {
+    [type in BuildConfig["type"]]: (context: Context) => GitlabJobs;
+};
+export declare const getBuildDefaults: {
+    [type in BuildConfig["type"]]: () => Partial<BuildConfig>;
+};

package/dist/scripts/magic/build/index.js

@@ -0,0 +1,12 @@
+"use strict";
+exports.__esModule = true;
+exports.getBuildDefaults = exports.buildJobCreators = void 0;
+var node_1 = require("./node");
+exports.buildJobCreators = {
+    node: node_1.createNodeJobs,
+    "node-static": node_1.createNodeJobs
+};
+exports.getBuildDefaults = {
+    node: node_1.getNodeDefaults,
+    "node-static": node_1.getNodeStaticDefaults
+};

package/dist/scripts/magic/build/node.d.ts

@@ -0,0 +1,6 @@
+import { GitlabJobs } from "../types/gitlab-types";
+import { Context } from "../types/context";
+import { BuildConfigNode, BuildConfigNodeStatic } from "./types";
+export declare const createNodeJobs: (context: Context) => GitlabJobs;
+export declare const getNodeDefaults: () => Partial<BuildConfigNode>;
+export declare const getNodeStaticDefaults: () => Partial<BuildConfigNodeStatic>;

package/dist/scripts/magic/build/node.js

@@ -0,0 +1,150 @@
+"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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.getNodeStaticDefaults = exports.getNodeDefaults = exports.createNodeJobs = void 0;
+var docker_1 = require("./docker");
+var types_1 = require("./types");
+var baseRetry = {
+    max: 2,
+    when: ["runner_system_failure", "stuck_or_timeout_failure"]
+};
+var getYarnInstall = function (context) { return [
+    "cd " + context.componentConfig.dir,
+    "if [ -f ./.nvmrc ]; then source /root/.nvm/nvm.sh && nvm install <<< .nvmrc; fi",
+    "yarn install --frozen-lockfile",
+]; };
+var getNodeCache = function (context) { return [
+    {
+        key: "node-modules",
+        policy: "pull-push",
+        paths: ["node_modules", "**/node_modules/"]
+    },
+]; };
+var getNextCache = function (context) { return [
+    {
+        key: "next-cache",
+        policy: "pull-push",
+        paths: [context.componentConfig.dir + "/.next/cache/"]
+    },
+]; };
+var createNodeTestJobs = function (context) {
+    var base = {
+        variables: {
+            APP_PATH: context.componentConfig.dir
+        },
+        cache: getNodeCache(context),
+        stage: "test",
+        interruptible: true,
+        needs: [],
+        retry: baseRetry
+    };
+    var yarnInstall = getYarnInstall(context);
+    return [
+        {
+            name: "audit",
+            perEnv: false,
+            job: __assign(__assign({}, base), { script: __spreadArray(__spreadArray([], __read(yarnInstall)), ["yarn audit"]), allow_failure: true })
+        },
+        {
+            name: "lint",
+            perEnv: false,
+            job: __assign(__assign({}, base), { script: __spreadArray(__spreadArray([], __read(yarnInstall)), ["yarn lint"]) })
+        },
+        {
+            name: "test",
+            perEnv: false,
+            job: __assign(__assign({}, base), { script: __spreadArray(__spreadArray([], __read(yarnInstall)), ["yarn test"]) })
+        },
+    ];
+};
+var createNodeBuildJobs = function (context) {
+    var buildConfig = context.componentConfig.build;
+    if (!types_1.isOfType(buildConfig, "node") && !types_1.isOfType(buildConfig, "node-static")) {
+        // should not happen
+        throw new Error("deploy config is not kubernetes");
+    }
+    var buildInfo = [
+        ". getCommitInfo",
+        "echo '{\"id\":\"'$BUILD_ID'\",\"commit\":\"'$BUILD_COMMIT'\",\"tag\":\"'$BUILD_TAG'\",\"time\":\"'$BUILD_TIME'\"}' > " + context.componentConfig.dir + "/__build_info.json",
+    ];
+    var yarnInstall = getYarnInstall(context);
+    return [
+        {
+            name: "app-build",
+            job: {
+                needs: [],
+                cache: __spreadArray(__spreadArray([], __read(getNodeCache(context))), __read(getNextCache(context))),
+                variables: context.environment.variables,
+                retry: baseRetry,
+                interruptible: true,
+                stage: "build",
+                script: __spreadArray(__spreadArray(__spreadArray([], __read(buildInfo)), __read(yarnInstall)), [buildConfig.buildCommand]),
+                artifacts: {
+                    paths: [
+                        context.componentConfig.dir + "/__build_info.json",
+                        context.componentConfig.dir + "/dist",
+                        context.componentConfig.dir + "/.next",
+                    ]
+                }
+            }
+        },
+        {
+            name: "docker-build",
+            job: __assign(__assign({}, docker_1.createDockerBuildJob(context, {
+                script: [
+                    buildConfig.type === "node-static"
+                        ? "ensureNginxDockerfile"
+                        : "ensureNodeDockerfile",
+                ]
+            })), { needs: ["app-build"] })
+        },
+    ];
+};
+var createNodeJobs = function (context) {
+    return __spreadArray(__spreadArray([], __read(createNodeTestJobs(context))), __read(createNodeBuildJobs(context)));
+};
+exports.createNodeJobs = createNodeJobs;
+var getNodeDefaults = function () {
+    return {
+        startCommand: "yarn start",
+        buildCommand: "yarn build"
+    };
+};
+exports.getNodeDefaults = getNodeDefaults;
+var getNodeStaticDefaults = function () {
+    return {
+        buildCommand: "yarn build"
+    };
+};
+exports.getNodeStaticDefaults = getNodeStaticDefaults;

package/dist/scripts/magic/build/types.d.ts

@@ -0,0 +1,18 @@
+export declare type BuildConfigBase = {
+    startCommand?: string;
+};
+export declare type BuildConfigNode = {
+    type: "node";
+    buildCommand?: string;
+} & BuildConfigBase;
+export declare type BuildConfigNodeStatic = {
+    type: "node-static";
+    buildCommand?: string;
+    startCommand?: never;
+};
+export declare type BuildConfig = BuildConfigNode | BuildConfigNodeStatic;
+export declare const isOfType: <T extends "node" | "node-static">(t: BuildConfig, type: T) => t is Extract<BuildConfigNode, {
+    type: T;
+}> | Extract<BuildConfigNodeStatic, {
+    type: T;
+}>;

package/dist/scripts/magic/build/types.js

@@ -0,0 +1,7 @@
+"use strict";
+exports.__esModule = true;
+exports.isOfType = void 0;
+var isOfType = function (t, type) {
+    return t.type === type;
+};
+exports.isOfType = isOfType;

package/dist/scripts/magic/context/index.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "../types/config";
+import { Context } from "../types/context";
+export declare const createContext: (componentName: string, config: Config, env: string) => Context;

package/dist/scripts/magic/context/index.js

@@ -0,0 +1,122 @@
+"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 = void 0;
+var lodash_1 = require("lodash");
+var slugify_1 = __importDefault(require("slugify"));
+var build_1 = require("../build");
+var deploy_1 = require("../deploy");
+var getEnvironment = function (config, componentName, env, commitInfo) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    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 : {};
+    var mergedConfig = lodash_1.merge({}, defaultConfig, envConfig);
+    var publicEnvVars = (_d = (_c = mergedConfig.vars) === null || _c === void 0 ? void 0 : _c.public) !== null && _d !== void 0 ? _d : {};
+    var secretEnvVarsRaw = (_f = (_e = mergedConfig.vars) === null || _e === void 0 ? void 0 : _e.secret) !== null && _f !== void 0 ? _f : {}; // TODO, map to gl secrets?
+    var secretEnvVars = {}; // TODO
+    var referencedRaw = (_h = (_g = mergedConfig.vars) === null || _g === void 0 ? void 0 : _g.fromComponents) !== null && _h !== void 0 ? _h : {};
+    var referenced = Object.entries(referencedRaw).reduce(function (acc, _a) {
+        var _b = __read(_a, 2), otherApp = _b[0], mapping = _b[1];
+        // TODO: prevent infinit looop
+        var variables = getEnvironment(config, otherApp, env, commitInfo).variables;
+        return Object.fromEntries(Object.entries(mapping).map(function (_a) {
+            var _b = __read(_a, 2), ourKey = _b[0], otherKey = _b[1];
+            return [
+                ourKey,
+                variables[otherKey],
+            ];
+        }));
+    }, {});
+    var envType = (_l = (_k = (_j = componentConfig.env) === null || _j === void 0 ? void 0 : _j[env]) === null || _k === void 0 ? void 0 : _k.type) !== null && _l !== void 0 ? _l : env;
+    var environmentName = envType === "review"
+        ? env + "/" + componentName + "/" + commitInfo.refName
+        : env + "/" + componentName;
+    var KUBE_APP_NAME = envType === "review"
+        ? componentName + "-" + commitInfo.refSlug
+        : componentName;
+    var KUBE_NAMESPACE = config.customerName + "-" + config.appName + "-" + env;
+    var APP_SLUG = slugify_1["default"](KUBE_APP_NAME);
+    var HOST_CANONICAL = config.appName + "-" + APP_SLUG + "." + config.customerName + ".panter.cloud";
+    var hostname = (_m = mergedConfig.hostname) !== null && _m !== void 0 ? _m : HOST_CANONICAL;
+    var url = "https://" + hostname;
+    var predefinedVariables = {
+        HOST_CANONICAL: HOST_CANONICAL,
+        ROOT_URL: url,
+        KUBE_NAMESPACE: KUBE_NAMESPACE,
+        KUBE_APP_NAME: KUBE_APP_NAME,
+        ENV_SHORT: env,
+        APP_DIR: componentConfig.dir
+    };
+    var variables = __assign(__assign(__assign(__assign({}, predefinedVariables), publicEnvVars), secretEnvVars), referenced);
+    return {
+        hostname: hostname,
+        fullName: environmentName,
+        shortName: env,
+        url: url,
+        variables: variables
+    };
+};
+var createContext = function (componentName, config, env) {
+    var _a, _b, _c, _d;
+    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 = lodash_1.merge({}, rawConfig, envConfig);
+    // fill in defaults of build and deploy
+    var defaults = {
+        build: build_1.getBuildDefaults[componentConfigWithoutDefaults.build.type](),
+        deploy: deploy_1.getDeployDefaults[componentConfigWithoutDefaults.deploy.type]()
+    };
+    var componentConfig = lodash_1.merge({}, defaults, componentConfigWithoutDefaults);
+    var commit = {
+        refName: (_c = process.env.CI_COMMIT_REF_NAME) !== null && _c !== void 0 ? _c : "unknown",
+        refSlug: (_d = process.env.CI_COMMIT_REF_SLUG) !== null && _d !== void 0 ? _d : "unknown"
+    };
+    return {
+        fullConfig: config,
+        componentConfig: componentConfig,
+        componentName: componentName,
+        environment: getEnvironment(config, componentName, env, commit),
+        commit: commit
+    };
+};
+exports.createContext = createContext;

package/dist/scripts/magic/createChildPipeline/index.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "../types/config";
+import { GitlabJobDef } from "../types/gitlab-types";
+export declare const createJobs: (envs: string[], config: Config, componentName: string) => Record<string, GitlabJobDef>;

package/dist/scripts/magic/createChildPipeline/index.js

@@ -0,0 +1,68 @@
+"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) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.createJobs = void 0;
+var build_1 = require("../build");
+var context_1 = require("../context");
+var deploy_1 = require("../deploy");
+var createRawJobs = function (context) {
+    var buildJobs = build_1.buildJobCreators[context.componentConfig.build.type](context);
+    var deployJobs = deploy_1.deployJobCreators[context.componentConfig.deploy.type](context);
+    return __spreadArray(__spreadArray([], __read(buildJobs)), __read(deployJobs));
+};
+var getFullJobName = function (name, componentName, env) {
+    if (env) {
+        return env + " " + componentName + " " + name;
+    }
+    return componentName + " " + name;
+};
+var replaceReferences = function (def, componentName, env) {
+    var _a, _b;
+    return __assign(__assign({}, def), { needs: (_a = def.needs) === null || _a === void 0 ? void 0 : _a.map(function (n) { return getFullJobName(n, componentName, env); }), dependencies: (_b = def.dependencies) === null || _b === void 0 ? void 0 : _b.map(function (n) {
+            return getFullJobName(n, componentName, env);
+        }) });
+};
+var createJobs = function (envs, config, componentName) {
+    return envs.reduce(function (acc, env) {
+        var context = context_1.createContext(componentName, config, env);
+        var jobs = createRawJobs(context);
+        return __assign(__assign({}, acc), jobs.reduce(function (acc, _a) {
+            var _b;
+            var name = _a.name, job = _a.job, _c = _a.perEnv, perEnv = _c === void 0 ? true : _c;
+            var def = job;
+            return __assign(__assign({}, acc), (_b = {}, _b[getFullJobName(name, componentName, perEnv ? env : undefined)] = replaceReferences(def, componentName, perEnv ? env : undefined), _b));
+        }, {}));
+    }, {});
+};
+exports.createJobs = createJobs;

package/dist/scripts/magic/createPipeline.d.ts

@@ -0,0 +1,14 @@
+import { Config, PipelineTrigger } from "./types/config";
+export declare const createPipeline: (trigger: PipelineTrigger, config: Config) => Promise<{
+    image: string;
+    workflow: {
+        rules: ({
+            if: string;
+            when?: undefined;
+        } | {
+            if: string;
+            when: string;
+        })[];
+    };
+    stages: string[];
+}>;

package/dist/scripts/magic/createPipeline.js

@@ -0,0 +1,80 @@
+"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 (_) 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 };
+    }
+};
+exports.__esModule = true;
+exports.createPipeline = void 0;
+var createChildPipeline_1 = require("./createChildPipeline");
+var config_1 = require("./types/config");
+var createPipeline = function (trigger, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var envs, components, jobs, rules, mainPipeline;
+    return __generator(this, function (_a) {
+        envs = Object.keys(config_1.ENV_TYPES).filter(function (e) { return config_1.ENV_TYPES[e].trigger === trigger; });
+        components = Object.keys(config.components);
+        jobs = components.reduce(function (acc, componentName) {
+            return __assign(__assign({}, acc), createChildPipeline_1.createJobs(envs, config, componentName));
+        }, {});
+        rules = [
+            // same as rules "always", but with `changes` to only trigger changed branches
+            { "if": "$CI_COMMIT_TAG" },
+            {
+                "if": "$CI_COMMIT_MESSAGE =~ /^chore(release).*/",
+                when: "never"
+            },
+            { "if": "$CI_COMMIT_BRANCH =~ /^[0-9]+.([0-9]+|x).x$/" },
+            {
+                "if": "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH"
+            },
+            { "if": "$CI_MERGE_REQUEST_ID" },
+        ];
+        mainPipeline = __assign({ image: "git.panter.ch:5001/catladder/gitlab-ci/pipeline:$PIPELINE_IMAGE_TAG", workflow: {
+                rules: rules
+            }, stages: ["setup", "test", "build", "deploy", "verify", "actions"] }, jobs);
+        return [2 /*return*/, mainPipeline];
+    });
+}); };
+exports.createPipeline = createPipeline;

package/dist/scripts/magic/deploy/index.d.ts

@@ -0,0 +1,9 @@
+import { GitlabJobs } from "../types/gitlab-types";
+import { Context } from "../types/context";
+import { DeployConfig } from "./types";
+export declare const deployJobCreators: {
+    [type in DeployConfig["type"]]: (context: Context) => GitlabJobs;
+};
+export declare const getDeployDefaults: {
+    [type in DeployConfig["type"]]: () => Partial<DeployConfig>;
+};

package/dist/scripts/magic/deploy/index.js

@@ -0,0 +1,12 @@
+"use strict";
+exports.__esModule = true;
+exports.getDeployDefaults = exports.deployJobCreators = void 0;
+var kubernetes_1 = require("./kubernetes");
+exports.deployJobCreators = {
+    kubernetes: kubernetes_1.createKubernetesDeployJobs,
+    serverless: function () { return []; }
+};
+exports.getDeployDefaults = {
+    kubernetes: kubernetes_1.getKubernetesDefault,
+    serverless: function () { return ({}); }
+};

package/dist/scripts/magic/deploy/kubernetes.d.ts

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