@catladder/pipeline 0.0.4 → 0.0.8

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

@@ -0,0 +1,62 @@
+"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.getKubernetesDefault = exports.createKubernetesDeployJobs = void 0;
+var types_1 = require("./types");
+var createKubernetesDeployJobs = function (context) {
+    var deployConfig = context.componentConfig.deploy;
+    if (!types_1.isOfType(deployConfig, "kubernetes")) {
+        // should not happen
+        throw new Error("deploy config is not kubernetes");
+    }
+    var defaltKubeValues = {
+        application: {
+            hostname: context.environment.hostname,
+            command: context.componentConfig.build.startCommand
+        }
+    };
+    var kubeValues = __assign(__assign({}, defaltKubeValues), deployConfig.values); // TODO: merge with some defaults
+    return [
+        {
+            name: "deploy-to-kubernetes",
+            job: {
+                variables: __assign(__assign({}, context.environment.variables), { 
+                    // TODO: refactor and unify with other stages
+                    HELM_EXPERIMENTAL_OCI: "1", IMAGE_PULL_SECRET: "gitlab-registry-" + context.componentName, KUBE_VALUES: JSON.stringify(kubeValues), HELM_GITLAB_CHART_PATH: "catladder/helm-charts", HELM_GITLAB_CHART_NAME: "the-panter-chart", COMPONENT_NAME: context.componentName, 
+                    // TODO: unify with docker build stage
+                    IMAGE_TAG: "$CI_COMMIT_SHA", HELM_GITLAB_CHART_VERSION: "3.2.0", RELEASE_NAME: context.fullConfig.customerName + "-" + context.fullConfig.appName + "-$CI_ENVIRONMENT_SLUG" }),
+                stage: "deploy",
+                dependencies: [],
+                script: [
+                    "kubernetesEnsureNamespace",
+                    "kubernetesCreateSecret",
+                    "kubernetesDeploy",
+                ],
+                environment: {
+                    name: context.environment.fullName,
+                    url: context.environment.url,
+                    kubernetes: {
+                        namespace: context.environment.variables.KUBE_NAMESPACE
+                    }
+                }
+            }
+        },
+    ];
+};
+exports.createKubernetesDeployJobs = createKubernetesDeployJobs;
+var getKubernetesDefault = function () {
+    return {
+        values: {}
+    };
+};
+exports.getKubernetesDefault = getKubernetesDefault;

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

@@ -0,0 +1,41 @@
+export declare type DeployConfigBase = {};
+export declare type DeployConfigKubernetes = {
+    type: "kubernetes";
+    additionalHelmArgs?: string[];
+    values?: {
+        application?: {
+            resources?: {
+                limits?: {
+                    cpu?: any;
+                };
+                requests?: {
+                    cpu?: any;
+                };
+            };
+        } & Record<string, any>;
+    } & Record<string, any>;
+} & DeployConfigBase;
+export declare type DeployConfigServerless = {
+    type: "serverless";
+};
+export declare type DeployConfig = DeployConfigKubernetes | DeployConfigServerless;
+export declare const isOfType: <T extends "kubernetes" | "serverless">(t: DeployConfig, type: T) => t is Extract<{
+    type: "kubernetes";
+    additionalHelmArgs?: string[] | undefined;
+    values?: ({
+        application?: ({
+            resources?: {
+                limits?: {
+                    cpu?: any;
+                } | undefined;
+                requests?: {
+                    cpu?: any;
+                } | undefined;
+            } | undefined;
+        } & Record<string, any>) | undefined;
+    } & Record<string, any>) | undefined;
+}, {
+    type: T;
+}> | Extract<DeployConfigServerless, {
+    type: T;
+}>;

package/dist/scripts/magic/deploy/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/index.d.ts

@@ -0,0 +1,2 @@
+export { createPipeline } from "./createPipeline";
+export * from "./types";

package/dist/scripts/magic/sample-config.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "./types/config";
+declare const sampleConfig: Config;
+export default sampleConfig;

package/dist/scripts/magic/sample-config.js

@@ -0,0 +1,77 @@
+"use strict";
+exports.__esModule = true;
+var sampleConfig = {
+    customerName: "pan",
+    appName: "fonsi",
+    components: {
+        web: {
+            dir: "web",
+            build: {
+                type: "node"
+            },
+            deploy: {
+                type: "kubernetes",
+                values: {
+                    application: {
+                        resources: {
+                            limits: {
+                                cpu: "100m"
+                            }
+                        }
+                    }
+                }
+            },
+            vars: {
+                public: {
+                    GOOGLE_TAG_MANAGER_ID: "1234"
+                },
+                fromComponents: {
+                    api: {
+                        API_URL: "ROOT_URL"
+                    }
+                }
+            },
+            env: {
+                prod: {
+                    hostname: "fudilo.ch",
+                    vars: {},
+                    deploy: {
+                        type: "kubernetes",
+                        values: {
+                            application: {
+                                resources: {
+                                    limits: {
+                                        cpu: "1000m"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                myCustomProd: {
+                    type: "prod",
+                    hostname: "fudilo2.ch"
+                }
+            }
+        },
+        api: {
+            env: {
+                prod: {
+                    hostname: "api.fudilo.ch"
+                },
+                myCustomProd: {
+                    type: "prod",
+                    hostname: "api.fudilo2.ch"
+                }
+            },
+            build: {
+                type: "node"
+            },
+            deploy: {
+                type: "kubernetes"
+            },
+            dir: "api"
+        }
+    }
+};
+exports["default"] = sampleConfig;

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

@@ -0,0 +1 @@
+export {};

package/dist/scripts/magic/tests/createPipeline.test.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) 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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+exports.__esModule = true;
+var createPipeline_1 = require("../createPipeline");
+describe("createPipeline", function () {
+    describe("node-app to kuberntes", function () {
+        var config = {
+            appName: "test",
+            customerName: "pan",
+            components: {
+                "my-app": {
+                    dir: "myapp",
+                    build: {
+                        type: "node"
+                    },
+                    deploy: {
+                        type: "kubernetes"
+                    }
+                }
+            }
+        };
+        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, stages, workflow, jobs;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, createPipeline_1.createPipeline("mainBranch", config)];
+                    case 1:
+                        _a = _b.sent(), image = _a.image, stages = _a.stages, workflow = _a.workflow, jobs = __rest(_a, ["image", "stages", "workflow"]);
+                        expect(image).toEqual("git.panter.ch:5001/catladder/gitlab-ci/pipeline:$PIPELINE_IMAGE_TAG");
+                        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",
+                        ]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

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

@@ -0,0 +1,49 @@
+import { BuildConfig } from "../build/types";
+import { DeployConfig } from "../deploy/types";
+export declare type PipelineTrigger = "mainBranch" | "mr" | "taggedRelease";
+export declare const ENV_TYPES: {
+    readonly dev: {
+        readonly trigger: "mainBranch";
+    };
+    readonly review: {
+        readonly trigger: "mr";
+    };
+    readonly prod: {
+        readonly trigger: "taggedRelease";
+    };
+    readonly stage: {
+        readonly trigger: "taggedRelease";
+    };
+};
+declare type EnvType = keyof typeof ENV_TYPES;
+export declare type DefaultEnvConfig = {
+    deploy: DeployConfig;
+    build: BuildConfig;
+    vars?: {
+        public?: Record<string, any>;
+        secret?: Record<string, string>;
+        fromComponents?: {
+            [otherApp: string]: Record<string, string>;
+        };
+    };
+};
+declare type EnvConfig<E extends EnvType = EnvType> = {
+    type?: E;
+    hostname?: string;
+} & Partial<DefaultEnvConfig>;
+export declare type Env = {
+    dev?: EnvConfig<"dev">;
+    stage?: EnvConfig<"stage">;
+    review?: EnvConfig<"review">;
+    prod?: EnvConfig<"prod">;
+} & Record<string, EnvConfig>;
+export declare type ComponentConfig = {
+    env?: Env;
+    dir: string;
+} & DefaultEnvConfig;
+export declare type Config = {
+    customerName: string;
+    appName: string;
+    components: Record<string, ComponentConfig>;
+};
+export {};

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

@@ -0,0 +1,17 @@
+"use strict";
+exports.__esModule = true;
+exports.ENV_TYPES = void 0;
+exports.ENV_TYPES = {
+    dev: {
+        trigger: "mainBranch"
+    },
+    review: {
+        trigger: "mr"
+    },
+    prod: {
+        trigger: "taggedRelease"
+    },
+    stage: {
+        trigger: "taggedRelease"
+    }
+};

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

@@ -0,0 +1,19 @@
+import { ComponentConfig, Config } from "./config";
+export declare type Environment = {
+    hostname: string;
+    fullName: string;
+    shortName: string;
+    url: string;
+    variables: Record<string, string>;
+};
+export declare type CommitInfo = {
+    refName: string;
+    refSlug: string;
+};
+export declare type Context = {
+    componentConfig: ComponentConfig;
+    componentName: string;
+    fullConfig: Config;
+    environment: Environment;
+    commit: CommitInfo;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

package/dist/scripts/magic/types/gitlab-types.d.ts

@@ -0,0 +1,57 @@
+export declare type GitlabStage = "setup" | "test" | "build" | "deploy" | "verify" | "actions";
+export declare type Artifacts = {
+    paths: string[];
+};
+export declare type GitlabJobCache = {
+    key: string;
+    policy?: string;
+    paths: string[];
+};
+export declare type GitlabRule = {
+    if: string;
+    when?: "always" | "on_success" | "manual" | "never";
+};
+export declare type Retry = {
+    max: number;
+    when: string[];
+};
+export declare type Service = {
+    name: string;
+    command: string[];
+};
+export declare type GitlabEnvironment = {
+    url: string;
+    name: string;
+    kubernetes?: {
+        namespace?: string;
+    };
+};
+export declare type GitlabJobDef = {
+    stage: GitlabStage;
+    before_script?: string[];
+    script: string[];
+    interruptible?: boolean;
+    needs?: string[];
+    rules?: GitlabRule[];
+    cache?: GitlabJobCache | GitlabJobCache[];
+    artifacts?: Artifacts;
+    retry?: Retry;
+    services?: Service[];
+    image?: string;
+    variables?: GitlabVariables;
+    dependencies?: string[];
+    environment?: GitlabEnvironment;
+    allow_failure?: boolean;
+};
+export declare type GitlabVariables = Record<string, string | undefined>;
+export declare type GitlabJob = {
+    name: string;
+    perEnv?: boolean;
+    job: GitlabJobDef;
+};
+export declare type GitlabJobs = GitlabJob[];
+export declare type GitlabPipeline = {
+    variables: GitlabVariables;
+    stages: GitlabStage[];
+    jobs: GitlabJobs;
+};

package/dist/scripts/magic/types/gitlab-types.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

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

@@ -0,0 +1,3 @@
+export * from "./config";
+export * from "./gitlab-types";
+export * from "./context";

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

@@ -0,0 +1,15 @@
+"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("./config"), exports);
+__exportStar(require("./gitlab-types"), exports);
+__exportStar(require("./context"), exports);

package/dist/scripts/magic.d.ts

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

package/dist/scripts/magic.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env ts-node
+"use strict";
+exports.__esModule = true;
+var fs_1 = require("fs");
+var yaml_1 = require("yaml");
+var createPipeline_1 = require("./magic/createPipeline");
+var _a = process.env, CI_MERGE_REQUEST_ID = _a.CI_MERGE_REQUEST_ID, CI_COMMIT_TAG = _a.CI_COMMIT_TAG, CI_COMMIT_BRANCH = _a.CI_COMMIT_BRANCH, CI_DEFAULT_BRANCH = _a.CI_DEFAULT_BRANCH;
+var isDefaultBranch = CI_COMMIT_BRANCH == CI_DEFAULT_BRANCH;
+var isHotfixBranch = false; // TODO:  $CI_COMMIT_BRANCH =~ /^[0-9]+\.([0-9]+|x)\.x$/
+var isMergeRequest = Boolean(CI_MERGE_REQUEST_ID);
+var isTaggedRelease = Boolean(CI_COMMIT_TAG);
+var fullPath = function (ext) { return process.cwd() + "/catladder." + ext; };
+var readConfig = function () {
+    var found = ["ts", "js", "yml", "yaml"].find(function (extension) {
+        return fs_1.existsSync(fullPath(extension));
+    });
+    if (found) {
+        if (found === "ts" || found === "js") {
+            return require(fullPath(found))["default"];
+        }
+        else {
+            return yaml_1.parse(fullPath(found));
+        }
+    }
+};
+var trigger = isMergeRequest || isHotfixBranch
+    ? "mr"
+    : isDefaultBranch
+        ? "mainBranch"
+        : isTaggedRelease
+            ? "taggedRelease"
+            : null;
+if (trigger) {
+    var config = readConfig();
+    createPipeline_1.createPipeline(trigger, config).then(function (mainPipeline) {
+        fs_1.writeFileSync("__pipeline.yml", JSON.stringify(mainPipeline, null, 2), {
+            encoding: "utf-8"
+        });
+    });
+}
+else {
+    throw new Error("no matching trigger");
+}

package/dist/scripts/monorepoGenerate.d.ts

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