@app.json/cloudformation/src/generate.js

Plugin for @app.json/cli that parses CloudFormation templates and extract config information

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = require("@app.json/core");
var lodash_merge_1 = __importDefault(require("lodash.merge"));
var path_1 = require("path");
var load_cloud_formation_template_1 = require("./load-cloud-formation-template");
// todo: extract this to a separate package, which means also extracting the interfaces
function generateFromCf(templatePath) {
    var template = load_cloud_formation_template_1.loadCloudFormationTemplate(templatePath);
    var baseJson = core_1.getBaseConfig();
    var components = getComponents(template);
    var outJson = {
        env: getEnv(template, components),
        output: getOutputs(template),
        components: components
    };
    var appJson = lodash_merge_1.default(baseJson, outJson);
    var appJsonPath = path_1.resolve(path_1.parse(templatePath).dir, 'app.json');
    core_1.writeAppJson(appJsonPath, appJson);
}
exports.generateFromCf = generateFromCf;
function getEnv(template, components) {
    var cfParameters = template.Parameters || {};
    var env = {};
    Object.keys(cfParameters).forEach(function (key) {
        var param = cfParameters[key];
        var envKey = core_1.underscore(key).toUpperCase();
        env[envKey] = {
            description: param.Description || "CloudFormation parameter: " + key,
            value: param.Default,
            type: ['cf::param']
        };
    });
    if (components) {
        components.forEach(function (component) {
            component.variables.forEach(function (name) {
                var definition = (env[name] = env[name] || {
                    description: '',
                    value: '',
                    type: []
                });
                if (typeof definition === 'object') {
                    definition.type = definition.type || [];
                    if (definition.type.indexOf('cf::function-env-var') === -1) {
                        definition.type.push('cf::function-env-var');
                    }
                }
                else {
                    throw new Error("Unsupported case, trying to extend string def for env var " + name + ", should not happen when generating from cf template");
                }
            });
        });
    }
    return env;
}
function getOutputs(template) {
    var cfOutputs = template.Outputs || {};
    var output = {};
    Object.keys(cfOutputs).forEach(function (key) {
        var cfOutput = cfOutputs[key];
        var envKey = core_1.underscore(key).toUpperCase();
        output[key] = {
            description: cfOutput.Description ||
                "CloudFormation output: " + key,
            mapTo: envKey
        };
    });
    return output;
}
function getComponents(template) {
    var resources = template.Resources;
    var components = [];
    if (!resources) {
        return;
    }
    Object.keys(resources).forEach(function (key) {
        var resource = resources[key];
        var properties = resource.Properties;
        if (properties && typeof properties.Environment === 'object') {
            components.push({
                name: properties.FunctionName || key,
                variables: Object.keys(properties.Environment.Variables)
            });
        }
    });
    return components;
}