@catladder/pipeline 0.0.1

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;
+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,12 @@
+import { ComponentConfig, Config } from "./config";
+export declare type Environment = {
+    fullName: string;
+    shortName: string;
+    url: string;
+    variables: Record<string, string>;
+};
+export declare type Context = {
+    componentConfig: ComponentConfig;
+    componentName: string;
+    fullConfig: Config;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { GitlabJobs } from "../gitlab-types";
+import { ComponentConfig } from "../config";
+import { Context } from "../context";
+export declare const deployJobCreators: {
+    [type in ComponentConfig["deploy"]["type"]]: (context: Context) => GitlabJobs;
+};

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

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

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

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

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

@@ -0,0 +1,46 @@
+"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.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");
+    }
+    return [
+        {
+            name: "deploy-to-kubernetes",
+            env: true,
+            job: function (environment) { return ({
+                variables: __assign(__assign({}, environment.variables), { RELEASE_NAME: "${CUSTOMER_NAME}-${APP_NAME}-${CI_ENVIRONMENT_SLUG}" }),
+                stage: "deploy",
+                dependencies: [],
+                script: [
+                    "kubernetesEnsureNamespace",
+                    "kubernetesCreateSecret",
+                    "kubernetesDeploy",
+                ],
+                environment: {
+                    name: environment.fullName,
+                    url: environment.url,
+                    kubernetes: {
+                        namespace: environment.variables.KUBE_NAMESPACE
+                    }
+                }
+            }); }
+        },
+    ];
+};
+exports.createKubernetesDeployJobs = createKubernetesDeployJobs;

package/dist/scripts/magic/types/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/types/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/types/gitlab-types.d.ts

@@ -0,0 +1,63 @@
+import { Environment } from "./context";
+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;
+};
+export declare type GitlabVariables = Record<string, string | undefined>;
+export declare type JobEnvDependent = {
+    name: string;
+    env: true;
+    job: (environment: Environment) => GitlabJobDef;
+};
+export declare type JobNonEnv = {
+    name: string;
+    env: false;
+    job: () => GitlabJobDef;
+};
+export declare type GitlabJob = JobEnvDependent | JobNonEnv;
+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 fullName = function (ext) { return "catladder." + ext; };
+var readConfig = function () {
+    var found = ["ts", "js", "yml", "yaml"].find(function (extension) {
+        return fs_1.existsSync(fullName(extension));
+    });
+    if (found) {
+        if (found === "ts" || found === "js") {
+            return require(fullName(found));
+        }
+        else {
+            return yaml_1.parse(fullName(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 {};

package/dist/scripts/monorepoGenerate.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env ts-node
+"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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var yaml_1 = require("yaml");
+var yargs_1 = __importDefault(require("yargs"));
+var helpers_1 = require("yargs/helpers");
+var extractBuildEnv_1 = require("./utils/extractBuildEnv");
+var args = yargs_1["default"](helpers_1.hideBin(process.argv)).array("env").argv;
+var thisGitlabCi = yaml_1.parse(fs_1.readFileSync(".gitlab-ci.yml", { encoding: "utf-8" }));
+var subcis = fs_1.readdirSync(".")
+    .filter(function (file) { return fs_1.lstatSync(file).isDirectory(); })
+    .map(function (dir) { return ({
+    dirname: dir,
+    ci: path_1.join(dir, ".gitlab-ci.yml")
+}); })
+    .filter(function (_a) {
+    var ci = _a.ci;
+    return fs_1.existsSync(ci);
+});
+var makeConfig = function (_a) {
+    var subapp = _a.subapp, type = _a.type, ci = _a.ci, env = _a.env;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var changes, rules, _b;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    changes = [subapp + "/**/*"];
+                    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",
+                            changes: changes
+                        },
+                        // add it manually when no changes
+                        {
+                            "if": "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH",
+                            when: "manual"
+                        },
+                        { "if": "$CI_MERGE_REQUEST_ID", changes: changes },
+                        // add it manually when no changes
+                        { "if": "$CI_MERGE_REQUEST_ID", when: "manual" },
+                    ];
+                    _c = {};
+                    _b = [__assign(__assign({}, thisGitlabCi.variables), (_d = { APP_DIR: subapp, VALUES_DIR: subapp, COMPONENT_NAME: subapp, PARENT_PIPELINE_ID: "$CI_PIPELINE_ID" }, _d[type.toUpperCase() + "_ONLY"] = "1", _d))];
+                    return [4 /*yield*/, extractBuildEnv_1.extractBuildEnv(subapp, env)];
+                case 1: return [2 /*return*/, (_c.variables = __assign.apply(void 0, _b.concat([(_e.sent())])),
+                        _c.stage = type,
+                        _c.rules = rules,
+                        _c.trigger = {
+                            include: ci,
+                            strategy: "depend"
+                        },
+                        _c)];
+            }
+        });
+    });
+};
+var generateSubPipeline = function (type, envs) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, envs.reduce(function (acc, env) { return __awaiter(void 0, void 0, void 0, function () {
+                    var _a, _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _a = [{}];
+                                return [4 /*yield*/, acc];
+                            case 1:
+                                _b = [__assign.apply(void 0, _a.concat([(_c.sent())]))];
+                                return [4 /*yield*/, subcis.reduce(function (inneracc, _a) {
+                                        var dirname = _a.dirname, ci = _a.ci;
+                                        return __awaiter(void 0, void 0, void 0, function () {
+                                            var _b, _c, _d;
+                                            var _e;
+                                            return __generator(this, function (_f) {
+                                                switch (_f.label) {
+                                                    case 0:
+                                                        _b = [{}];
+                                                        return [4 /*yield*/, inneracc];
+                                                    case 1:
+                                                        _c = [__assign.apply(void 0, _b.concat([(_f.sent())]))];
+                                                        _e = {};
+                                                        _d = env + "-" + dirname + " " + type;
+                                                        return [4 /*yield*/, makeConfig({
+                                                                subapp: dirname,
+                                                                ci: ci,
+                                                                type: type,
+                                                                env: env
+                                                            })];
+                                                    case 2: return [2 /*return*/, (__assign.apply(void 0, _c.concat([(_e[_d] = _f.sent(), _e)])))];
+                                                }
+                                            });
+                                        });
+                                    }, {})];
+                            case 2: return [2 /*return*/, __assign.apply(void 0, _b.concat([(_c.sent())]))];
+                        }
+                    });
+                }); }, {})];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+generateSubPipeline(args.t, args.env).then(function (p) {
+    return console.log(JSON.stringify(p, null, 2));
+});

package/dist/scripts/printAllValues.d.ts

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

package/dist/scripts/printAllValues.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env ts-node
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var yargs_1 = __importDefault(require("yargs"));
+var helpers_1 = require("yargs/helpers");
+var extractAllValues_1 = require("./utils/extractAllValues");
+var args = yargs_1["default"](helpers_1.hideBin(process.argv)).argv;
+extractAllValues_1.extractAllValues(args.d, args.e)
+    .then(function (values) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        console.log((_a = JSON.stringify(values, null, 2)) !== null && _a !== void 0 ? _a : "");
+        return [2 /*return*/];
+    });
+}); })["catch"](function (e) {
+    console.error("could not extract values", {
+        error: e
+    });
+});

package/dist/scripts/printBuildEnv.d.ts

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

package/dist/scripts/printBuildEnv.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env ts-node
+"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 __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;
+var lodash_1 = require("lodash");
+var yargs_1 = __importDefault(require("yargs"));
+var helpers_1 = require("yargs/helpers");
+var extractBuildEnv_1 = require("./utils/extractBuildEnv");
+var args = yargs_1["default"](helpers_1.hideBin(process.argv)).argv;
+extractBuildEnv_1.extractBuildEnv(args.d, args.e)
+    .then(function (values) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        Object.entries(values).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            return console.log(key + ": \"" + (lodash_1.isObject(value) ? JSON.stringify(value) : value) + "\"");
+        });
+        return [2 /*return*/];
+    });
+}); })["catch"](function (e) {
+    console.error("could not extract values", {
+        error: e
+    });
+});

package/dist/scripts/utils/extractAllValues.d.ts

@@ -0,0 +1 @@
+export declare const extractAllValues: (appDirectory: string, env: string | null) => Promise<any>;