aws-cfn2dot

#!/usr/bin/env node

let _ = require('lodash-firecloud');

let {
  stdin
} = process;
let chunks = [];

let isIntrinsicFun = function(Value) {
  if (!_.isPlainObject(Value)) {
    return false;
  }
  let keys = _.keys(Value);
  if (keys.length !== 1) {
    return false;
  }
  return /^(Fn::.*|Ref)$/.test(keys[0]);
};

let reduceToDeps = function(acc, statement) {
  if (isIntrinsicFun(statement)) {
    if (statement.Ref) {
      acc = acc.concat(statement.Ref);
    } else if (statement['Fn::GetAtt']) {
      // {'Fn::GetAtt': ['Ref', 'Att']}
      acc = acc.concat(statement['Fn::GetAtt'][0]);
    } else if (_.isString(statement['Fn::Sub'])) {
      // {'Fn::Sub': `${Ref}`}
      let subRefs = statement['Fn::Sub'].match(/\$\{[^}]+\}/g);
      subRefs = _.reject(subRefs, function(subRef) {
        return /^AWS::.+/.test(subRef);
      });
      _.forEach(subRefs, function(subRef) {
        subRef = subRef.match(/\$\{([^!][^.}]+)(\..+)?\}/)[1];
        acc.push(subRef);
      });
    } else if (_.isArray(statement['Fn::Sub'])) {
      // {'Fn::Sub': [`${Ref}${Var}`, {Var: Value}]}
      let subRefs = statement['Fn::Sub'][0].match(/\$\{[^}]+\}/g);
      subRefs = _.reject(subRefs, function(subRef) {
        return /^AWS::.+/.test(subRef);
      });
      let subVars = _.keys(statement['Fn::Sub'][1]);
      subRefs = _.without(subRefs, ...subVars);
      _.forEach(subRefs, function(subRef) {
        subRef = subRef.match(/\$\{([^!][^.}]+)(\..+)?\}/)[1];
        acc.push(subRef);
      });
    }
  } else if (_.isObjectLike(statement)) {
    acc = acc.concat(_.reduce(statement, reduceToDeps, []));
  }

  return acc;
};


let findDeps = function(obj) {
  let refs = _.reduce(obj, reduceToDeps, []);
  return refs;
};

let cfn2graph = function(cfn) {
  let graph = {
    name: cfn.Description || '',
    type: 'digraph',
    rank: 'same',
    shape: 'box',
    style: 'filled',
    nodes: [],
    edges: [],
    subgraphs: []
  };

  _.forEach(cfn.Resources, function(Resource, name) {
    graph.nodes.push({name, type: Resource.Type});
    let deps = findDeps(Resource.Properties);
    deps = deps.concat(Resource.DependsOn || []);
    deps = _.uniq(deps);
    _.forEach(deps, function(from) {
      graph.edges.push({from, to: name});
    });
  });
  graph.nodes = _.uniqBy(graph.nodes, 'name');

  let parametersSubgraph = {
    name: 'Parameters',
    type: 'subgraph',
    rank: 'same', // 'source',
    shape: 'ellipse',
    style: 'filled',
    nodes: [],
    edges: []
  };
  graph.subgraphs.push(parametersSubgraph);
  _.forEach(cfn.Parameters, function(Parameter, name) {
    parametersSubgraph.nodes.push({name, type: 'AWS::CloudFormation::Parameter'});
    _.forEach(findDeps(Parameter), function(from) {
      parametersSubgraph.edges.push({from, to: name});
    });
  });

  let outputsSubgraph = {
    name: 'Outputs',
    type: 'subgraph',
    rank: 'same', // 'max',
    shape: 'ellipse',
    style: 'solid',
    nodes: [],
    edges: []
  };
  graph.subgraphs.push(outputsSubgraph);
  _.forEach(cfn.Outputs, function(Output, name) {
    name = `output${name}`;
    outputsSubgraph.nodes.push({name, type: 'AWS::CloudFormation::Output'});
    _.forEach(findDeps(Output), function(from) {
      outputsSubgraph.edges.push({from, to: name});
    });
  });

  // TODO handle pseudo parameters

  return graph;
};

let render = function(graph) {
  let shape = graph.shape ? `node [shape="${graph.shape}"];` : '';
  let style = graph.style ? `node [style="${graph.style}"];` : '';

  console.log(`
${graph.type} "${graph.name}" {
rank=${graph.rank};
labeljust=l;
${shape}
${style}
`);

  _.forEach(graph.nodes, function({name, type}) {
    console.log(`"${name}" [label="${name}\n${type}"]`);
  });

  _.forEach(graph.subgraphs, render);

  _.forEach(graph.edges, function({from, to}) {
    // console.log(`"${to}" -> "${from}";`);
    console.log(`"${from}" -> "${to}";`);
  });

  console.log('}');
};

let read = function() {
  stdin.resume();
  stdin.setEncoding('utf-8');

  stdin.on('data', function(chunk) {
    chunks.push(chunk);
  });
  stdin.on('end', function() {
    let cfn = JSON.parse(chunks.join(''));
    let graph = cfn2graph(cfn);
    render(graph);
  });
};

read();