@kosko/cli/dist/commands/generate.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const config_1 = require("@kosko/config");
const generate_1 = require("@kosko/generate");
const require_1 = require("@kosko/require");
const path_1 = require("path");
const debug_1 = tslib_1.__importDefault(require("../cli/debug"));
const error_1 = require("../cli/error");
const debug = debug_1.default.extend("generate");
function localRequire(id, cwd) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        debug("Finding module %s in %s", id, cwd);
        const path = yield require_1.resolve(id, { basedir: cwd });
        debug("Importing %s from %s", id, path);
        return require_1.requireDefault(path);
    });
}
function importEnv(cwd) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        return localRequire("@kosko/env", cwd);
    });
}
function resolveConfig(base, args) {
    const { components = [], require = [] } = args.env
        ? config_1.getConfig(base, args.env)
        : base;
    return {
        components: args.components && args.components.length ? args.components : components,
        require: [...require, ...(args.require || [])]
    };
}
/* istanbul ignore next */
function generateBuilder(argv) {
    return argv
        .option("env", {
        type: "string",
        describe: "Environment name",
        alias: "e"
    })
        .option("require", {
        type: "array",
        describe: "Require modules. Modules set in config file will also be required.",
        default: [],
        alias: "r"
    })
        .positional("components", {
        describe: "Components to generate. This overrides components set in config file."
    });
}
exports.generateBuilder = generateBuilder;
function generateHandler(args) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        // Load config
        const globalConfig = yield config_1.searchConfig(args.cwd);
        const config = Object.assign({}, globalConfig, resolveConfig(globalConfig, args));
        if (!config.components.length) {
            throw new error_1.CLIError("No components are given", {
                output: "No components are given. Set components in a config file or in arguments."
            });
        }
        // Set env
        if (args.env) {
            const env = yield importEnv(args.cwd);
            env.cwd = args.cwd;
            env.env = args.env;
            if (config.paths && config.paths.environment) {
                const paths = config.paths.environment;
                if (paths.global)
                    env.paths.global = paths.global;
                if (paths.component)
                    env.paths.component = paths.component;
            }
            debug("Set env as", args.env);
        }
        // Require external modules
        for (const id of config.require) {
            yield localRequire(id, args.cwd);
        }
        // Generate manifests
        const result = yield generate_1.generate({
            path: path_1.join(args.cwd, "components"),
            components: config.components,
            extensions: config.extensions,
            validate: args.validate
        });
        if (!result.manifests.length) {
            throw new error_1.CLIError("No manifests are exported from components", {
                output: `No manifests are exported from components. Make sure there are exported manifests in components.`
            });
        }
        return result;
    });
}
exports.generateHandler = generateHandler;
exports.generateCmd = {
    command: "generate [components..]",
    describe: "Generate Kubernetes manifests",
    builder(argv) {
        /* istanbul ignore next */
        return generateBuilder(argv)
            .option("output", {
            type: "string",
            describe: "Output format",
            default: generate_1.PrintFormat.YAML,
            choices: Object.keys(generate_1.PrintFormat).map(key => generate_1.PrintFormat[key]),
            alias: "o"
        })
            .option("validate", {
            type: "boolean",
            describe: "Validate components",
            default: true
        })
            .example("$0 generate", "Generate manifests")
            .example("$0 generate foo bar", "Specify components")
            .example("$0 generate foo_*", "Use glob pattern")
            .example("$0 generate --env foo", "Set environment")
            .example("$0 generate -r ts-node/register", "Require external modules");
    },
    handler(args) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const result = yield generateHandler(args);
            generate_1.print(result, {
                format: args.output,
                writer: process.stdout
            });
        });
    }
};
//# sourceMappingURL=generate.js.map