k8ts/dist/env/env.js

Powerful framework for building Kubernetes manifests in TypeScript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EnvBuilder = void 0;
exports.Env = Env;
const immutable_1 = require("immutable");
const what_are_you_1 = require("what-are-you");
const error_1 = require("../error");
const kinds_1 = require("../kinds");
const validate_name_1 = require("./validate-name");
class EnvBuilder {
    _env;
    constructor(_env) {
        this._env = _env;
        for (const key of _env.keys()) {
            if (!(0, validate_name_1.isValidEnvVarName)(key)) {
                throw new error_1.MakeError("Invalid environment variable name", {
                    key: key
                });
            }
        }
    }
    get values() {
        return this._env;
    }
    _envFromSecret(value) {
        return {
            secretKeyRef: {
                name: value.$ref.name,
                key: value.key,
                optional: value.optional
            }
        };
    }
    _envFromConfigMap(value) {
        return {
            configMapKeyRef: {
                name: value.$ref.name,
                key: value.key,
                optional: value.optional
            }
        };
    }
    toEnvVars() {
        return this.values
            .map((value, key) => {
            if (!(0, what_are_you_1.isObject)(value)) {
                return {
                    name: key,
                    value: `${value}`
                };
            }
            const resourceValue = value;
            switch (resourceValue.$ref.kind) {
                case kinds_1.api.v1_.Secret:
                    return {
                        name: key,
                        valueFrom: this._envFromSecret(resourceValue)
                    };
                case kinds_1.api.v1_.ConfigMap:
                    return {
                        name: key,
                        valueFrom: this._envFromConfigMap(resourceValue)
                    };
                default:
                    throw new error_1.MakeError("Invalid environment variable reference", {
                        key: key,
                        value: value
                    });
            }
        })
            .valueSeq()
            .toArray();
    }
    _withEnv(f) {
        return new EnvBuilder(f(this._env));
    }
    add(a, b) {
        const pairs = typeof a === "string" ? [[a, b]] : Object.entries(a);
        const map = (0, immutable_1.Map)(pairs);
        const existingKeys = map
            .keySeq()
            .filter(k => this._env.has(k))
            .toList();
        if (existingKeys.size > 0) {
            throw new error_1.MakeError("Cannot overwrite existing keys using add", {
                keys: existingKeys.toArray()
            });
        }
        return this._withEnv(env => env.merge(map));
    }
    overwrite(a, b) {
        if (typeof a === "string") {
            return this._withEnv(env => env.set(a, b));
        }
        else {
            const map = (0, immutable_1.Map)(a);
            return this._withEnv(env => env.merge(map));
        }
    }
    toObject() {
        return this._env
            .filter(v => v != null)
            .map(x => `${x}`)
            .toObject();
    }
    static make(env) {
        if (!env) {
            return new EnvBuilder((0, immutable_1.Map)({}));
        }
        if (env instanceof EnvBuilder) {
            return env;
        }
        return new EnvBuilder((0, immutable_1.Map)(env ?? {}).filter(v => v != null));
    }
}
exports.EnvBuilder = EnvBuilder;
function Env(env) {
    return EnvBuilder.make(env);
}
//# sourceMappingURL=env.js.map