Merge pull request #29 from gitops-toolbox/feature/group-by

Add group-by option and rename limit to filter-by

Author: LucaLanziani

README.md

@@ -251,7 +251,7 @@ locations:
 ## Render one file in human readable
 
 ```
-> ./bin/cli.js -b examples generate nested/example.njk dev -h --limit-to '{"type": "database"}' # renderHumanReadableLimitTo
+> ./bin/cli.js -b examples generate nested/example.njk dev -h --filter-by '{"type": "database"}' # renderHumanReadableFilterBy
 ---
 {"destination":{"type":"echo","params":{"repo":"myorg/development","filepath":"database.json"}},"tags":{"type":"database"}}
 ---
@@ -265,7 +265,7 @@ locations:
 ## Render human readable limit to one file and hide header
 
 ```
-> ./bin/cli.js -b examples generate nested/example.njk dev -h --limit-to '{"type": "database"}' --hide-headers # renderFileContent
+> ./bin/cli.js -b examples generate nested/example.njk dev -h --filter-by '{"type": "database"}' --hide-headers # renderFileContent
 # Template file templates/context.js
 # Mapping file mappings/nested/example.njk
 
@@ -333,6 +333,74 @@ locations:
 }
 ```
 
+## Persist the result grouping by a tag
+
+```
+./bin/cli.js -b examples generate nested/example.njk dev --persist --group-by type # groupBy
+{
+  "echo": {
+    "application": {
+      "templates": [
+        {
+          "template": "context.njk",
+          "contextSelector": "components.application",
+          "destination": {
+            "type": "echo",
+            "params": {
+              "repo": "myorg/development",
+              "filepath": "application.json"
+            }
+          },
+          "tags": {
+            "type": "application"
+          },
+          "templateData": {
+            "context": {
+              "name": "templator"
+            },
+            "meta": {
+              "__mapping": "mappings/nested/example.njk",
+              "__template": "templates/context.njk"
+            }
+          },
+          "renderedTemplate": "# Template file templates/context.njk\n# Mapping file mappings/nested/example.njk\n\n{\"name\":\"templator\"}\n",
+          "group": "application"
+        }
+      ]
+    },
+    "database": {
+      "templates": [
+        {
+          "template": "context.js",
+          "contextSelector": "components.database",
+          "destination": {
+            "type": "echo",
+            "params": {
+              "repo": "myorg/development",
+              "filepath": "database.json"
+            }
+          },
+          "tags": {
+            "type": "database"
+          },
+          "templateData": {
+            "context": {
+              "name": "Database"
+            },
+            "meta": {
+              "__mapping": "mappings/nested/example.njk",
+              "__template": "templates/context.js"
+            }
+          },
+          "renderedTemplate": "# Template file templates/context.js\n# Mapping file mappings/nested/example.njk\n\n{\"name\":\"Database\"}\n",
+          "group": "database"
+        }
+      ]
+    }
+  }
+}
+```
+
 ## Create a new mapping
 
 ```

cmds/generate.js

@@ -1,7 +1,12 @@
 const lodash = require('lodash');
 const Templator = require('../lib/templator');
 const persist = require('../lib/persist');
-const { tryJSONParse, output, commonYargsOptions } = require('../lib/utils');
+const {
+  tryJSONParse,
+  output,
+  commonYargsOptions,
+  parseTags,
+} = require('../lib/utils');
 
 exports.command = 'generate <mapping> [context-selector]';
 
@@ -28,13 +33,17 @@ exports.builder = (yargs) => {
       describe: 'Hide the header from the human readable output',
       type: 'boolean',
       default: false,
-      implies: 'limit-to',
+      implies: 'filter-by',
     })
-    .options('limit-to', {
+    .options('filter-by', {
       describe: 'Only show file with a give set of tags',
       type: 'string',
       implies: 'human-readable',
-      coerce: (param) => tryJSONParse(param),
+      coerce: (param) => parseTags(param),
+    })
+    .options('group-by', {
+      describe: 'group templates by a set of given tags names',
+      type: 'array',
     })
     .options('just-mapping', {
       describe: 'Just render mapping, not templates, useful to debug issues',
@@ -49,13 +58,6 @@ exports.builder = (yargs) => {
 
 function _human_reabable(render, args) {
   for (const item of render.locations) {
-    if (
-      !lodash.isUndefined(args.limitTo) &&
-      !lodash.isMatch(item.tags, args.limitTo)
-    ) {
-      continue;
-    }
-
     if (!args.hideHeaders) {
       console.log('---');
       console.log(
@@ -83,15 +85,29 @@ exports.handler = async (args) => {
     return;
   }
 
-  const render = await templator.render(args.mapping, args.contextSelector);
+  let render = await templator.render(args.mapping, args.contextSelector);
+
+  if (!lodash.isUndefined(args.filterBy)) {
+    render.locations = lodash.filter(render.locations, (render) =>
+      lodash.isMatch(render.tags, args.filterBy)
+    );
+  }
 
   if (args.h) {
     _human_reabable(render, args);
   }
 
-  output(render, args.output);
+  if (!lodash.isUndefined(args.groupBy)) {
+    for (const location of render.locations) {
+      location.group = Object.values(
+        lodash.pick(location.tags, args.groupBy)
+      ).join('_');
+    }
+  }
 
   if (args.persist) {
     output(await persist(render, args), args.output || 'json');
+  } else {
+    output(render, args.output);
   }
 };

examples/mappings/example.js

@@ -1,12 +1,26 @@
-exports.render = function (data) {
+exports.render = function (context, meta) {
   const locations = [];
 
-  for (const [key, value] of Object.entries(data.context.components)) {
-    locations.push({
-      template: '<path_component_to_template>',
-      contextSelector: `components.${key}`,
-      destination: {},
-    });
+  for (const [environment, environment_data] of Object.entries(context)) {
+    for (const [component, component_data] of Object.entries(
+      environment_data.components
+    )) {
+      locations.push({
+        template: `context.js`,
+        contextSelector: `${environment}.components.${component}`,
+        destination: {
+          type: 'echo',
+          params: {
+            repo: environment_data.environment,
+            filepath: `${component}.json`,
+          },
+        },
+        tags: {
+          env: environment_data.environment,
+          component: component,
+        },
+      });
+    }
   }
 
   return { locations };

lib/destinations/echo.js

@@ -1,3 +1,5 @@
+const _ = require('lodash');
+
 class EchoDestination {
   constructor(templates, logs, args) {
     this.templates = templates;
@@ -6,8 +8,10 @@ class EchoDestination {
   }
 
   async persist() {
+    let templates = this.templates;
+
     return {
-      templates: this.templates,
+      templates,
     };
   }
 }

lib/persist.js

@@ -2,6 +2,28 @@ const _ = require('lodash');
 const destinations = require('./destinations');
 const [log, error] = require('./utils').getLogger(__filename);
 
+async function _persist(dest_type, templates, args) {
+  let results;
+  try {
+    const destination = new destinations[dest_type](templates, log, args);
+    results = await destination.persist();
+  } catch (e) {
+    results = e.message;
+  }
+
+  return results;
+}
+
+async function _persistByGroup(dest_type, templates, args) {
+  const results = {};
+  const templates_by_group = _.groupBy(templates, 'group');
+  for (const [group, template] of Object.entries(templates_by_group)) {
+    results[group] = await _persist(dest_type, template, args);
+  }
+
+  return results;
+}
+
 module.exports = async function (mappings, args) {
   const templates_by_destinations = _.groupBy(
     mappings.locations,
@@ -19,11 +41,10 @@ module.exports = async function (mappings, args) {
       continue;
     }
 
-    try {
-      const destination = new destinations[dest_type](templates, log, args);
-      results[dest_type] = await destination.persist();
-    } catch (e) {
-      results[dest_type] = e.message;
+    if (!_.isUndefined(args.groupBy)) {
+      results[dest_type] = await _persistByGroup(dest_type, templates, args);
+    } else {
+      results[dest_type] = await _persist(dest_type, templates, args);
     }
   }
 

lib/utils.js

@@ -77,6 +77,27 @@ function getContextParser(base, args) {
   });
 }
 
+function parseTags(str) {
+  const tags = {};
+
+  if (str === undefined || str === '') {
+    return undefined;
+  }
+
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    error('Could not json parse %s tags', str);
+  }
+
+  for (const tag of str.split(',')) {
+    const [key, value] = tag.split('=');
+    tags[key] = value;
+  }
+
+  return tags;
+}
+
 function output(obj, type) {
   if (type === 'json') {
     console.log(JSON.stringify(obj, null, 2));
@@ -108,4 +129,5 @@ module.exports = {
   output,
   commonYargsOptions,
   loadJsonOrYaml,
+  parseTags,
 };

tests/cli.test.js

@@ -1,6 +1,6 @@
 const tap = require('tap');
 const { readFileSync } = require('fs');
-const { execSync, spawnSync } = require('child_process');
+const { execSync } = require('child_process');
 
 const README = readFileSync('./README.md').toString('utf-8').split('\n');
 
@@ -18,7 +18,7 @@ function getCommand(comment) {
 }
 
 tap.test('Give the readme examples', (t) => {
-  t.plan(14);
+  t.plan(15);
 
   t.test('Sohuld list mappings', (t) => {
     t.plan(1);
@@ -102,7 +102,7 @@ tap.test('Give the readme examples', (t) => {
 
   t.test('Should render the example template in human readable format', (t) => {
     t.plan(1);
-    const [command, output] = getCommand('# renderHumanReadableLimitTo');
+    const [command, output] = getCommand('# renderHumanReadableFilterBy');
     const result = execSync(command, { encoding: 'utf-8' });
 
     t.strictSame(result, output);
@@ -124,6 +124,17 @@ tap.test('Give the readme examples', (t) => {
     t.strictSame(result, output);
   });
 
+  t.test(
+    'Should render the example template and persist groupping by the type tag',
+    (t) => {
+      t.plan(1);
+      const [command, output] = getCommand('# groupBy');
+      const result = execSync(command, { encoding: 'utf-8' });
+
+      t.strictSame(result, output);
+    }
+  );
+
   t.test('Should render the example to generate a njk mapping', (t) => {
     t.plan(1);
     const [command, output] = getCommand('# createNjkMapping');