@grnsft/if 0.3.1 → 0.3.3-beta.0

package/.commitlintrc.js

@@ -35,6 +35,9 @@ module.exports = {
         'plugins',
         'integration',
         'doc',
+        'manifests',
+        'release',
+        '.commitlint'
       ],
     ],
     'scope-empty': [2, 'never'],

package/.release-it.json

@@ -0,0 +1,18 @@
+{
+  "git": { 
+    "requireBranch": false,
+    "requireUpstream": true,  
+    "commit": true,
+    "commitMessage": "chore(release): ${version} ✨",
+    "push": true,
+    "pushArgs": ["--follow-tags"],
+    "tag": false
+  },
+  "github": {    
+    "tokenRef": "GITHUB_TOKEN",
+    "preRelease": true
+  },
+  "npm": {
+    "publish": false
+  }
+}

package/CONTRIBUTING.md

@@ -1,12 +1,13 @@
 ## Contribution Guidelines <!-- omit from toc -->
 
-
 First off, thanks for taking the time to contribute! 🎉
 
 The following document is a rule set of guidelines for contributing.
 
 ## Table of Contents <!-- omit from toc -->
 
+- [What and when to contribute](#what-and-when-to-contribute)
+- [Reporting bugs](#reporting-bugs)
 - [Code Contributions](#code-contributions)
   - [Step 1: Fork](#step-1-fork)
   - [Step 2: Branch](#step-2-branch)
@@ -20,6 +21,64 @@ The following document is a rule set of guidelines for contributing.
     - [Documentation](#documentation)
   - [Writing tests](#writing-tests)
 
+## What and when to contribute
+
+You can contribute anything to the IF, but we are likely to close out unsolicited PRs without merging them. Our issue board is completely open and we have tags (`help-wanted`, `good-first-issue`) to help contributors to choose tasks to work on. We recommend speaking to the core team on Github before starting working on an issue. You can do this by raising an issue or commenting on an existing issue. This helps us to direct your energy in directions that are aligned with our roadmap, prevent multiple people working on the same task, and better manage our board. This all makes it much more likely that your work will get merged.
+
+## Reporting bugs
+
+We appreciate bug reports! If you experience an issue with IF or one of our plugins, you can report it using our bug reporting template. To do this:
+
+1. Go to the [IF repository](https://github.com/Green-Software-Foundation/if) (or [plugin repository](https://github.com/Green-Software-Foundation/if-plugins) if you bug relates to a specific plugin)
+2. Click on the `Issues` tab
+3. Click on `Create New Issue` and select the `Bug Report` template.
+4. Fill out the requested information.
+
+The more detailed information you provide in the bug report, the easier it will be for us to diagnose, triage and resolve your issue. We ask for some simple information about your issue, including a description of the error, the expected behaviour, the actual behaviour and the stepos we can take to reproduce the error in our local environments. We also then prompt you to provide a link to [Stackblitz](https://stackblitz.com/) or a similar online environment where we can run your manifest and observe the error. If you prefer *not* to send a link, we would appreciate a copy of the manifest file that you ran to produce the error, information about your runtime environment and any additional code that's required to reproduce the error. This is all designed to enable us to reproduce the same error and debug it for you as quickly as possible.
+
+Once a suitably detailed bug report exists, we will triage it. We hold weekly triage calls on Tuesdays. In most cases, the triage call will be the core team's first interaction with the bug, although in some cases we may engage asynchronously in advance of the call. Triage means that the core team will examine the issue and assign an urgency label - either Low, Medium or High. 
+
+The assessment rubric is as follows:
+
+|                                                                                                                        | Consequence                                                                              | Severity |
+| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | -------- |
+| Bugs in IF core leading to incorrect calculations                                                                      | unusable framework                                                                       | 5        |
+| Bugs in if-plugins leading to incorrect calculations                                                                   | core pathways fail, IF very limited in functionality                                     | 5        |
+| Bugs in if-unofficial-pluginsd leading to incorrect calculations                                                       | Third party plugins harder to use, limits IF to standard lib                             | 3        |
+| Bugs in template                                                                                                       | Harder to build plugins, ecosystem growth is impacted                                    | 2        |
+| Bugs in docs                                                                                                           | product does not match expectation, hard to debug, frustration, loss of adoption         | 2        |
+| Security flaw: privacy related                                                                                         | leak user data, unlikely to achieve adoption in serious orgs                             | 5        |
+| Security flaw: permissions escalation                                                                                  | expose user to malware                                                                   | 5        |
+| Code not addressing user needs                                                                                         | no product market fit, loss of adoption                                                  | 5        |
+| Communication failures within team                                                                                     | Conflicting or duplicating work, frustration, morale damage                              | 4        |
+| Communication failures with community                                                                                  | we lose product market fit, we do not have good community retention, reputational damage | 3        |
+| Communication failures with leadership                                                                                 | product does not meet business goals                                                     | 3        |
+| License compliance failures, including in supply chain (e.g. exposing privileged api responses for free via  a plugin) | 4                                                                                        |
+| Bugs affecting releases                                                                                                | users stuck on old versions                                                              | 4        |
+| Strategy failures                                                                                                      | no product market fit                                                                    | 2        |
+
+The mapping of severity to label is as follows:
+
+| Severity | Label |
+| -------- | ----- |
+| 1        | L     |
+| 2        | M     |
+| 3        | M     |
+| 4        | H     |
+| 5        | H     |
+
+During the bug triage we will also discuss a remediation plan for the bug. This will be communicated in the comments on the bug report. For high urgency bugs, the fix will be implemented as soon as possible, maybe reorganizing our current work to accommodate it. For medium priority bugs, we will schedule the fix in the next available sprint. Low priority bugs will be backlogged and addressed when there is developer time available. Low priority bugs will also be tagged `help-wanted` so that they can be addressed by community members.
+
+Not every bug will be fixed. We may decide *not* to fix a bug in cases such as:
+
+- fixing the bug has some detrimental side effect elsewhere in the product
+- the bug has a fix coming soon as part of another upgrade
+- the bug is only problematic for a single specific use case and fixing it would break features relied upon by other users
+- the bug is contentious for some reason and there is reputational or community risks associated with the fix
+
+The bug will be labelled `fix-now`, `fix-later` or `wont-fix` to reflect our remediation plan and details will be provided in issue comments.
+
+
 ## Code Contributions
 
 ### Step 1: Fork
@@ -160,4 +219,26 @@ describe('util/args: ', () => {
 })
 ```
 
+### How to report issues (bugs)
+
+Bug report should contain all the information required to reproduce a bug and to make it as easy as possible to fix. This includes providing the following information
+
+- a description of the error,
+- a description of the expected behaviour,
+- a description of the actual behaviour,
+- steps to reproduce
+
+To help us to diagnose and debug your issue, please provide either a [Stackblitz](https://stackblitz.com/) link that captures your local environment and failing manifest file, OR:
+
+- the manifest file that generated the error,
+- links to any code (e.g. your own plugin code), it must be available online,
+- runtime information such as OS, node version, package.json, IF version
+
+Reported bugs will be discussed among the team in a weekly bug triage and be assigned a severity (low, medium or high). 
+
+High severity bugs will be fixed as soon as possible, whereas medium and low severity bug fixes will likely be backlogged for attention in the next available sprint. 
+
+In some cases, we might decide not to fix certain bugs if they are low severity, either because we anticipate fixes coming soon as part of already-scheduled upgrades or because we think the fixes make "good first issues" for community contributors.
+Community members are welcome to report any issue they face and also work on fixing the low priority bugs.
+
 *[⬅️ back to the root](/README.md#ief)*

package/README.md

@@ -1,31 +1,10 @@
-<div id="header" align="center">
-<img style=”margin: 0px” src=hack-banner.png alt=”banner” height=”500" />
-</div>
-
-----------------------------
-
-**Welcome to [CarbonHack 24](https://grnsft.org/hack/github) from the Green Software Foundation.**
-
-> From Monday, 18th March - Monday, 8th April 2024, participants will compete to showcase their best application of IF in measuring the environmental impacts of software. 
-> 
-> Carbon Hack is a dynamic competition that combines healthy rivalry with collaborative innovation. Hackers will push the limits of the framework, uncover potential weaknesses, and create innovations to enhance the tool.
-> 
-> CarbonHack is open to all, including software practitioners and those with a passion for Green Software.
->
-> Find out more about CarbonHack 2024 on the [CarbonHack website](https://grnsft.org/hack/github). Check out the [FAQ on GitHub](https://grnsft.org/hack/faq).
-> 
-> Registration opens 15th January!
-----------------------------
-
-
 # Impact Framework
 
 
 > [!IMPORTANT]
 > Incubation Project: This project is an incubation project being run inside the Green Software Foundation; as such, we DON’T recommend using it in any critical use case. Incubation projects are experimental, offer no support guarantee, have minimal governance and process, and may be retired at any moment. This project may one day Graduate, in which case this disclaimer will be removed.
 
-**Note** We have recently refactored the IF codebase and introduced some changes affecting both users and developers. You can read our migration guide [HERE](./Refactor-migration-guide.md) to help you update to the latest version!
-
+**Note** We have recently (March 2024) refactored the IF codebase and introduced some changes affecting both users and developers. You can read our migration guide [HERE](./Refactor-migration-guide.md) to help you update to the latest version!
 
 
 [Impact Framework](https://greensoftwarefoundation.atlassian.net/wiki/spaces/~612dd45e45cd76006a84071a/pages/17072136/Opensource+Impact+Engine+Framework) (IF) is an [Incubation](https://oc.greensoftware.foundation/project-lifecycle.html#incubation) project from the [Open Source Working Group](https://greensoftwarefoundation.atlassian.net/wiki/spaces/~612dd45e45cd76006a84071a/pages/852049/Open+Source+Working+Group) in the [Green Software Foundation](https://greensoftware.foundation/).
@@ -66,16 +45,42 @@ Then, run `if` using the following command:
 
 ```sh
 ie --manifest <path-to-your-manifest-file>
+## or you can use aliases
+ie -m <path-to-your-manifest-file>
+```
+
+Note that above command will not print the final output. In order to print the final output to the console, run `if` using the optional stdout argument:
+```sh
+ie --manifest <path-to-your-manifest-file> --stdout
+## or using aliases
+ie -m <path-to-your-manifest-file> -s
 ```
 
-You can also add an optional savepath for your output yaml (if you do not provide one, the output will be printed to the console):
+You can also add a savepath for your output yaml in order to have the output stored in a file. Note that you also have to add configuration to your manifest to enable this, as follows:
+
+```yaml
+initialize:
+  output:
+    - yaml
+```
+
+On the command line:
 
 ```sh
 ie --manifest <path-to-your-manifest-file> --output <your-savepath>
+## or using aliases
+ie -m <path-to-your-manifest-file> -o <your-savepath>
 ```
 
 The `ie` CLI tool will configure and run the plugins defined in your input `yaml` (`manifest`) and return the results as an output `yaml` (`output`).
 
+Use the `help` command if you need guidance about the available commands
+
+```sh
+ie --help
+## or using alias
+ie -h
+```
 
 ## Documentation
 
@@ -97,3 +102,9 @@ You can check our issue board for issues tagged `help-wanted`. These are issues
 Please read the full contribution guidelines at [if.greensoftware.foundation](https://if.greensoftware.foundation/Contributing)
 
 The same guidelines also apply to `if-docs`, `if-plugins` and `if-unofficial-plugins`.
+
+## Bug reports
+
+To report bugs please use our bug report template. You can do this by opening a new issue and selecting `Bug Report` when you are prompted to pick a template. The more information you provide,.the quicker we will be able to reproduce, diagnose and triage your issue.
+
+To read about our bug reporting and triage process, please see [our contribution guidelines](contributing.md#reporting-bugs).

package/build/builtins/export-csv-raw.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportCSVRaw = void 0;
 const fs = __importStar(require("fs/promises"));
 const errors_1 = require("../util/errors");
-const { WriteFileError, CliInputError } = errors_1.ERRORS;
+const { ExhaustError } = errors_1.ERRORS;
 const ExportCSVRaw = () => {
     /**
      * handle a tree leaf, where there are no child nodes, by adding it as key->value pair to the flat map
@@ -108,7 +108,7 @@ const ExportCSVRaw = () => {
             await fs.writeFile(`${outputPath}.csv`, content);
         }
         catch (error) {
-            throw new WriteFileError(`Failed to write CSV to ${outputPath}: ${error}`);
+            throw new ExhaustError(`Failed to write CSV to ${outputPath}: ${error}`);
         }
     };
     /**
@@ -116,14 +116,14 @@ const ExportCSVRaw = () => {
      */
     const execute = async (tree, _context, outputPath) => {
         if (!outputPath) {
-            throw new CliInputError('Output path is required.');
+            throw new ExhaustError('Output path is required.');
         }
         const [extractredFlatMap, extractedHeaders] = extractFlatMapAndHeaders(tree);
         const ids = new Set(Object.keys(extractredFlatMap).map(key => extractIdHelper(key)));
         const csvString = getCsvString(extractredFlatMap, extractedHeaders, ids);
-        writeOutputFile(csvString, outputPath);
+        await writeOutputFile(csvString, outputPath);
     };
     return { execute };
 };
 exports.ExportCSVRaw = ExportCSVRaw;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-csv-raw.js","sourceRoot":"","sources":["../../src/builtins/export-csv-raw.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\n\nimport {ERRORS} from '../util/errors';\n\nimport {ExhaustPluginInterface} from '../types/exhaust-plugin-interface';\nimport {Context} from '../types/manifest';\n\nconst {WriteFileError, CliInputError} = ERRORS;\n\nexport const ExportCSVRaw = (): ExhaustPluginInterface => {\n  /**\n   * handle a tree leaf, where there are no child nodes, by adding it as key->value pair to the flat map\n   * and capturing key as a header\n   */\n  const handleLeafValue = (\n    value: any,\n    fullPath: string,\n    key: any,\n    flatMap: {[key: string]: any},\n    headers: Set<string>\n  ) => {\n    if (fullPath.includes('outputs')) {\n      headers.add(key);\n      flatMap[fullPath] = value;\n    }\n  };\n\n  /**\n   * handle a tree node, recursively traverse the children and append their results to the flat map and captured headers\n   */\n  const handleNodeValue = (\n    value: any,\n    fullPath: string,\n    flatMap: Record<string, any>,\n    headers: Set<string>\n  ) => {\n    const [subFlatMap, subHeaders] = extractFlatMapAndHeaders(value, fullPath);\n\n    if (Object.keys(subFlatMap).length > 0) {\n      Object.entries(subFlatMap).forEach(([subKey, value]) => {\n        flatMap[subKey] = value;\n      });\n\n      subHeaders.forEach(subHeader => {\n        headers.add(subHeader);\n      });\n    }\n  };\n\n  /**\n   * Handles a key at the top level of the tree\n   */\n  const handleKey = (\n    value: any,\n    key: any,\n    prefix: string,\n    flatMap: Record<string, any>,\n    headers: Set<string>\n  ) => {\n    const fullPath = prefix ? `${prefix}.${key}` : key;\n\n    if (value !== null && typeof value === 'object') {\n      return handleNodeValue(value, fullPath, flatMap, headers);\n    }\n\n    return handleLeafValue(value, fullPath, key, flatMap, headers);\n  };\n\n  /**\n   * Recursively extract a flat map and headers from the hierarcial tree.\n   */\n  const extractFlatMapAndHeaders = (\n    tree: any,\n    prefix = ''\n  ): [Record<string, any>, Set<string>] => {\n    const headers: Set<string> = new Set();\n    const flatMap: Record<string, any> = [];\n\n    for (const key in tree) {\n      if (key in tree) {\n        handleKey(tree[key], key, prefix, flatMap, headers);\n      }\n    }\n\n    return [flatMap, headers];\n  };\n\n  /**\n   * extract the id of the key, that is removing the last token (which is the index).\n   * in this manner, multiple keys that identical besides their index share the same id.\n   */\n  const extractIdHelper = (key: string): string => {\n    const parts = key.split('.');\n    parts.pop();\n\n    return parts.join('.');\n  };\n\n  /**\n   * generate a CSV formatted string based on a flat key->value map, headers and ids\n   */\n  const getCsvString = (\n    map: {[key: string]: any},\n    headers: Set<string>,\n    ids: Set<string>\n  ): string => {\n    const csvRows: string[] = [];\n    csvRows.push(['id', ...headers].join(','));\n\n    ids.forEach(id => {\n      const rowData = [id];\n\n      headers.forEach(header => {\n        const value = map[`${id}.${header}`] ?? '';\n        rowData.push(value.toString());\n      });\n      csvRows.push(rowData.join(','));\n    });\n\n    return csvRows.join('\\n');\n  };\n\n  /**\n   * write the given string content to a file at the provided path\n   */\n  const writeOutputFile = async (content: string, outputPath: string) => {\n    try {\n      await fs.writeFile(`${outputPath}.csv`, content);\n    } catch (error) {\n      throw new WriteFileError(\n        `Failed to write CSV to ${outputPath}: ${error}`\n      );\n    }\n  };\n\n  /**\n   * export the provided tree content to a CSV file, represented in a flat structure\n   */\n  const execute = async (tree: any, _context: Context, outputPath: string) => {\n    if (!outputPath) {\n      throw new CliInputError('Output path is required.');\n    }\n\n    const [extractredFlatMap, extractedHeaders] =\n      extractFlatMapAndHeaders(tree);\n    const ids = new Set(\n      Object.keys(extractredFlatMap).map(key => extractIdHelper(key))\n    );\n    const csvString = getCsvString(extractredFlatMap, extractedHeaders, ids);\n\n    writeOutputFile(csvString, outputPath);\n  };\n\n  return {execute};\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-csv-raw.js","sourceRoot":"","sources":["../../src/builtins/export-csv-raw.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\n\nimport {ERRORS} from '../util/errors';\n\nimport {ExhaustPluginInterface} from '../types/exhaust-plugin-interface';\nimport {Context} from '../types/manifest';\n\nconst {ExhaustError} = ERRORS;\n\nexport const ExportCSVRaw = (): ExhaustPluginInterface => {\n  /**\n   * handle a tree leaf, where there are no child nodes, by adding it as key->value pair to the flat map\n   * and capturing key as a header\n   */\n  const handleLeafValue = (\n    value: any,\n    fullPath: string,\n    key: any,\n    flatMap: {[key: string]: any},\n    headers: Set<string>\n  ) => {\n    if (fullPath.includes('outputs')) {\n      headers.add(key);\n      flatMap[fullPath] = value;\n    }\n  };\n\n  /**\n   * handle a tree node, recursively traverse the children and append their results to the flat map and captured headers\n   */\n  const handleNodeValue = (\n    value: any,\n    fullPath: string,\n    flatMap: Record<string, any>,\n    headers: Set<string>\n  ) => {\n    const [subFlatMap, subHeaders] = extractFlatMapAndHeaders(value, fullPath);\n\n    if (Object.keys(subFlatMap).length > 0) {\n      Object.entries(subFlatMap).forEach(([subKey, value]) => {\n        flatMap[subKey] = value;\n      });\n\n      subHeaders.forEach(subHeader => {\n        headers.add(subHeader);\n      });\n    }\n  };\n\n  /**\n   * Handles a key at the top level of the tree\n   */\n  const handleKey = (\n    value: any,\n    key: any,\n    prefix: string,\n    flatMap: Record<string, any>,\n    headers: Set<string>\n  ) => {\n    const fullPath = prefix ? `${prefix}.${key}` : key;\n\n    if (value !== null && typeof value === 'object') {\n      return handleNodeValue(value, fullPath, flatMap, headers);\n    }\n\n    return handleLeafValue(value, fullPath, key, flatMap, headers);\n  };\n\n  /**\n   * Recursively extract a flat map and headers from the hierarcial tree.\n   */\n  const extractFlatMapAndHeaders = (\n    tree: any,\n    prefix = ''\n  ): [Record<string, any>, Set<string>] => {\n    const headers: Set<string> = new Set();\n    const flatMap: Record<string, any> = [];\n\n    for (const key in tree) {\n      if (key in tree) {\n        handleKey(tree[key], key, prefix, flatMap, headers);\n      }\n    }\n\n    return [flatMap, headers];\n  };\n\n  /**\n   * extract the id of the key, that is removing the last token (which is the index).\n   * in this manner, multiple keys that identical besides their index share the same id.\n   */\n  const extractIdHelper = (key: string): string => {\n    const parts = key.split('.');\n    parts.pop();\n\n    return parts.join('.');\n  };\n\n  /**\n   * generate a CSV formatted string based on a flat key->value map, headers and ids\n   */\n  const getCsvString = (\n    map: {[key: string]: any},\n    headers: Set<string>,\n    ids: Set<string>\n  ): string => {\n    const csvRows: string[] = [];\n    csvRows.push(['id', ...headers].join(','));\n\n    ids.forEach(id => {\n      const rowData = [id];\n\n      headers.forEach(header => {\n        const value = map[`${id}.${header}`] ?? '';\n        rowData.push(value.toString());\n      });\n      csvRows.push(rowData.join(','));\n    });\n\n    return csvRows.join('\\n');\n  };\n\n  /**\n   * write the given string content to a file at the provided path\n   */\n  const writeOutputFile = async (content: string, outputPath: string) => {\n    try {\n      await fs.writeFile(`${outputPath}.csv`, content);\n    } catch (error) {\n      throw new ExhaustError(`Failed to write CSV to ${outputPath}: ${error}`);\n    }\n  };\n\n  /**\n   * export the provided tree content to a CSV file, represented in a flat structure\n   */\n  const execute = async (tree: any, _context: Context, outputPath: string) => {\n    if (!outputPath) {\n      throw new ExhaustError('Output path is required.');\n    }\n\n    const [extractredFlatMap, extractedHeaders] =\n      extractFlatMapAndHeaders(tree);\n    const ids = new Set(\n      Object.keys(extractredFlatMap).map(key => extractIdHelper(key))\n    );\n    const csvString = getCsvString(extractredFlatMap, extractedHeaders, ids);\n\n    await writeOutputFile(csvString, outputPath);\n  };\n\n  return {execute};\n};\n"]}

package/build/builtins/export-csv.js

@@ -4,26 +4,36 @@ exports.ExportCSV = void 0;
 const promises_1 = require("fs/promises");
 const sync_1 = require("csv-stringify/sync");
 const errors_1 = require("../util/errors");
-const { CliInputError } = errors_1.ERRORS;
+const { ExhaustError } = errors_1.ERRORS;
 /**
  * Extension to IF that outputs the tree in a CSV format.
  */
 const ExportCSV = () => {
     const parseOutputAndField = (outputPath) => {
-        if (!outputPath) {
-            throw new CliInputError('Output path is required.');
-        }
-        const paths = outputPath.split('#');
+        const validatedPath = validateOutputPath(outputPath);
+        const paths = validatedPath.split('#');
         const output = paths.slice(0, paths.length - 1).join('');
         const criteria = paths[paths.length - 1];
         if (paths.length <= 1 || !criteria) {
-            throw new CliInputError('CSV export criteria is not found in output path. Please append it after --output <path>#.');
+            throw new ExhaustError('CSV export criteria is not found in output path. Please append it after --output <path>#.');
         }
         return {
             output,
             criteria,
         };
     };
+    /**
+     * Validates output path.
+     */
+    const validateOutputPath = (outputPath) => {
+        if (!outputPath) {
+            throw new ExhaustError('Output path is required.');
+        }
+        if (!outputPath.includes('#')) {
+            throw new ExhaustError('Output path should contain `#`.');
+        }
+        return outputPath;
+    };
     /**
      * Grabs output and criteria from cli args, then call tree walker to collect csv data.
      */
@@ -83,4 +93,4 @@ const ExportCSV = () => {
     };
 };
 exports.ExportCSV = ExportCSV;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LWNzdi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsdGlucy9leHBvcnQtY3N2LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDBDQUFzQztBQUN0Qyw2Q0FBNkM7QUFFN0MsMkNBQXNDO0FBS3RDLE1BQU0sRUFBQyxhQUFhLEVBQUMsR0FBRyxlQUFNLENBQUM7QUFFL0I7O0dBRUc7QUFDSSxNQUFNLFNBQVMsR0FBRyxHQUFHLEVBQUU7SUFDNUIsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLFVBQWtCLEVBQUUsRUFBRTtRQUNqRCxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ2YsTUFBTSxJQUFJLGFBQWEsQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1NBQ3JEO1FBRUQsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNwQyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUN6RCxNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztRQUV6QyxJQUFJLEtBQUssQ0FBQyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2xDLE1BQU0sSUFBSSxhQUFhLENBQ3JCLDJGQUEyRixDQUM1RixDQUFDO1NBQ0g7UUFFRCxPQUFPO1lBQ0wsTUFBTTtZQUNOLFFBQVE7U0FDVCxDQUFDO0lBQ0osQ0FBQyxDQUFDO0lBRUY7O09BRUc7SUFDSCxNQUFNLE9BQU8sR0FBRyxLQUFLLEVBQUUsSUFBUyxFQUFFLE9BQWdCLEVBQUUsVUFBa0IsRUFBRSxFQUFFO1FBQ3hFLE1BQU0sT0FBTyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDekIsTUFBTSxNQUFNLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUN6QixNQUFNLEVBQUMsTUFBTSxFQUFFLFFBQVEsRUFBQyxHQUFHLG1CQUFtQixDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzNELE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUM7UUFFbkQ7O1dBRUc7UUFDSCxNQUFNLFVBQVUsR0FBRyxDQUFDLElBQVMsRUFBRSxRQUFnQixFQUFFLElBQUksR0FBRyxNQUFNLEVBQUUsRUFBRTtZQUNoRSw4RkFBOEY7WUFDOUYsSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO2dCQUNuQixJQUFJLElBQUksS0FBSyxNQUFNLEVBQUU7b0JBQ25CLE9BQU8sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7aUJBQzVCO2dCQUVELE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLElBQUksSUFBSSxRQUFRLEVBQUUsRUFBRSxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQzthQUNqRTtZQUVELDRHQUE0RztZQUM1RyxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUU7Z0JBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBb0IsRUFBRSxFQUFFO29CQUM1QyxNQUFNLEVBQUMsU0FBUyxFQUFDLEdBQUcsTUFBTSxDQUFDO29CQUUzQixJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsRUFBRTt3QkFDaEMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7cUJBQ2hDO29CQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDO29CQUUxQyxJQUFJLG9CQUFvQixFQUFFO3dCQUN4QixPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO3FCQUNoQzt5QkFBTTt3QkFDTCxrREFBa0Q7d0JBQ2xELElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxPQUFPLENBQUMsTUFBTSxFQUFFOzRCQUM1RCxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxJQUFJLElBQUksUUFBUSxFQUFFLEVBQUUsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQzt5QkFDeEQ7NkJBQU07NEJBQ0wsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQzt5QkFDaEM7cUJBQ0Y7Z0JBQ0gsQ0FBQyxDQUFDLENBQUM7YUFDSjtZQUVELHFEQUFxRDtZQUNyRCxJQUFJLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ2pCLEtBQUssTUFBTSxLQUFLLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtvQkFDakMsVUFBVSxDQUNSLElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEVBQ3BCLFFBQVEsRUFDUixHQUFHLElBQUksYUFBYSxLQUFLLEVBQUUsQ0FDNUIsQ0FBQztpQkFDSDthQUNGO1FBQ0gsQ0FBQyxDQUFDO1FBRUYsVUFBVSxDQUFDLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztRQUUzQixNQUFNLElBQUEsb0JBQVMsRUFBQyxHQUFHLE1BQU0sTUFBTSxFQUFFLElBQUEsZ0JBQVMsRUFBQyxNQUFNLEVBQUUsRUFBQyxPQUFPLEVBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakUsQ0FBQyxDQUFDO0lBRUYsT0FBTztRQUNMLE9BQU87UUFDUCxRQUFRLEVBQUU7WUFDUixJQUFJLEVBQUUsU0FBUztTQUNoQjtLQUNGLENBQUM7QUFDSixDQUFDLENBQUM7QUEzRlcsUUFBQSxTQUFTLGFBMkZwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7d3JpdGVGaWxlfSBmcm9tICdmcy9wcm9taXNlcyc7XG5pbXBvcnQge3N0cmluZ2lmeX0gZnJvbSAnY3N2LXN0cmluZ2lmeS9zeW5jJztcblxuaW1wb3J0IHtFUlJPUlN9IGZyb20gJy4uL3V0aWwvZXJyb3JzJztcblxuaW1wb3J0IHtDb250ZXh0fSBmcm9tICcuLi90eXBlcy9tYW5pZmVzdCc7XG5pbXBvcnQge1BsdWdpblBhcmFtc30gZnJvbSAnLi4vdHlwZXMvaW50ZXJmYWNlJztcblxuY29uc3Qge0NsaUlucHV0RXJyb3J9ID0gRVJST1JTO1xuXG4vKipcbiAqIEV4dGVuc2lvbiB0byBJRiB0aGF0IG91dHB1dHMgdGhlIHRyZWUgaW4gYSBDU1YgZm9ybWF0LlxuICovXG5leHBvcnQgY29uc3QgRXhwb3J0Q1NWID0gKCkgPT4ge1xuICBjb25zdCBwYXJzZU91dHB1dEFuZEZpZWxkID0gKG91dHB1dFBhdGg6IHN0cmluZykgPT4ge1xuICAgIGlmICghb3V0cHV0UGF0aCkge1xuICAgICAgdGhyb3cgbmV3IENsaUlucHV0RXJyb3IoJ091dHB1dCBwYXRoIGlzIHJlcXVpcmVkLicpO1xuICAgIH1cblxuICAgIGNvbnN0IHBhdGhzID0gb3V0cHV0UGF0aC5zcGxpdCgnIycpO1xuICAgIGNvbnN0IG91dHB1dCA9IHBhdGhzLnNsaWNlKDAsIHBhdGhzLmxlbmd0aCAtIDEpLmpvaW4oJycpO1xuICAgIGNvbnN0IGNyaXRlcmlhID0gcGF0aHNbcGF0aHMubGVuZ3RoIC0gMV07XG5cbiAgICBpZiAocGF0aHMubGVuZ3RoIDw9IDEgfHwgIWNyaXRlcmlhKSB7XG4gICAgICB0aHJvdyBuZXcgQ2xpSW5wdXRFcnJvcihcbiAgICAgICAgJ0NTViBleHBvcnQgY3JpdGVyaWEgaXMgbm90IGZvdW5kIGluIG91dHB1dCBwYXRoLiBQbGVhc2UgYXBwZW5kIGl0IGFmdGVyIC0tb3V0cHV0IDxwYXRoPiMuJ1xuICAgICAgKTtcbiAgICB9XG5cbiAgICByZXR1cm4ge1xuICAgICAgb3V0cHV0LFxuICAgICAgY3JpdGVyaWEsXG4gICAgfTtcbiAgfTtcblxuICAvKipcbiAgICogR3JhYnMgb3V0cHV0IGFuZCBjcml0ZXJpYSBmcm9tIGNsaSBhcmdzLCB0aGVuIGNhbGwgdHJlZSB3YWxrZXIgdG8gY29sbGVjdCBjc3YgZGF0YS5cbiAgICovXG4gIGNvbnN0IGV4ZWN1dGUgPSBhc3luYyAodHJlZTogYW55LCBjb250ZXh0OiBDb250ZXh0LCBvdXRwdXRQYXRoOiBzdHJpbmcpID0+IHtcbiAgICBjb25zdCBjb2x1bW5zID0gWydQYXRoJ107XG4gICAgY29uc3QgbWF0cml4ID0gW2NvbHVtbnNdO1xuICAgIGNvbnN0IHtvdXRwdXQsIGNyaXRlcmlhfSA9IHBhcnNlT3V0cHV0QW5kRmllbGQob3V0cHV0UGF0aCk7XG4gICAgY29uc3QgYWdncmVnYXRpb25Jc0VuYWJsZWQgPSAhIWNvbnRleHQuYWdncmVnYXRpb247XG5cbiAgICAvKipcbiAgICAgKiBXYWxrcyB0aHJvdWdoIGFsbCB0cmVlIGJyYW5jaGVzIGFuZCBsZWF2ZXMsIGNvbGxlY3RpbmcgdGhlIGRhdGFcbiAgICAgKi9cbiAgICBjb25zdCB0cmVlV2Fsa2VyID0gKG5vZGU6IGFueSwgY3JpdGVyaWE6IHN0cmluZywgcGF0aCA9ICd0cmVlJykgPT4ge1xuICAgICAgLyoqIEhtbSBhZ2dyZWdhdGVkLCB0aGVuIGNoZWNrcyBpZiBpdCdzIHRoZSBmaXJzdCBvbmUuIElmIHNvIGFkZHMgY29sdW1uLCBwdXNoZXMgdGhlIHZhbHVlLiAqL1xuICAgICAgaWYgKG5vZGUuYWdncmVnYXRlZCkge1xuICAgICAgICBpZiAocGF0aCA9PT0gJ3RyZWUnKSB7XG4gICAgICAgICAgY29sdW1ucy5wdXNoKCdBZ2dyZWdhdGVkJyk7XG4gICAgICAgIH1cblxuICAgICAgICBtYXRyaXgucHVzaChbYCR7cGF0aH0uJHtjcml0ZXJpYX1gLCBub2RlLmFnZ3JlZ2F0ZWRbY3JpdGVyaWFdXSk7XG4gICAgICB9XG5cbiAgICAgIC8qKiBTbyBpdCBoYXMgb3V0cHV0cywgd2hhdHMgdGhlbj8gY2hlY2tzIGlmIHRpbWVzdGFtcCBpcyBub3QgdGhlcmUsIGFkZHMgb25lLiBUaGVuIGFwcGVuZHMgdmFsdWVzIHRvIGl0LiAqL1xuICAgICAgaWYgKG5vZGUub3V0cHV0cykge1xuICAgICAgICBub2RlLm91dHB1dHMuZm9yRWFjaCgob3V0cHV0OiBQbHVnaW5QYXJhbXMpID0+IHtcbiAgICAgICAgICBjb25zdCB7dGltZXN0YW1wfSA9IG91dHB1dDtcblxuICAgICAgICAgIGlmICghY29sdW1ucy5pbmNsdWRlcyh0aW1lc3RhbXApKSB7XG4gICAgICAgICAgICBjb2x1bW5zLnB1c2gob3V0cHV0LnRpbWVzdGFtcCk7XG4gICAgICAgICAgfVxuXG4gICAgICAgICAgY29uc3QgbGFzdFJvdyA9IG1hdHJpeFttYXRyaXgubGVuZ3RoIC0gMV07XG5cbiAgICAgICAgICBpZiAoYWdncmVnYXRpb25Jc0VuYWJsZWQpIHtcbiAgICAgICAgICAgIGxhc3RSb3cucHVzaChvdXRwdXRbY3JpdGVyaWFdKTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgLyoqIEhhbmRsZSB3aXRob3V0IGFnZ3JlZ2F0aW9uIGV4cG9ydCBzdHJhdGVneS4gKi9cbiAgICAgICAgICAgIGlmIChtYXRyaXgubGVuZ3RoID09PSAxIHx8IGxhc3RSb3cubGVuZ3RoID09PSBjb2x1bW5zLmxlbmd0aCkge1xuICAgICAgICAgICAgICBtYXRyaXgucHVzaChbYCR7cGF0aH0uJHtjcml0ZXJpYX1gLCBvdXRwdXRbY3JpdGVyaWFdXSk7XG4gICAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgICBsYXN0Um93LnB1c2gob3V0cHV0W2NyaXRlcmlhXSk7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgfVxuICAgICAgICB9KTtcbiAgICAgIH1cblxuICAgICAgLyoqIE9oaCBjaGlsZHJlbj8gdGhlbiBjYWxsIGV2ZXJ5IG9uZSBhbmQgZXhlY3V0ZS4gKi9cbiAgICAgIGlmIChub2RlLmNoaWxkcmVuKSB7XG4gICAgICAgIGZvciAoY29uc3QgY2hpbGQgaW4gbm9kZS5jaGlsZHJlbikge1xuICAgICAgICAgIHRyZWVXYWxrZXIoXG4gICAgICAgICAgICBub2RlLmNoaWxkcmVuW2NoaWxkXSxcbiAgICAgICAgICAgIGNyaXRlcmlhLFxuICAgICAgICAgICAgYCR7cGF0aH0uY2hpbGRyZW4uJHtjaGlsZH1gXG4gICAgICAgICAgKTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH07XG5cbiAgICB0cmVlV2Fsa2VyKHRyZWUsIGNyaXRlcmlhKTtcblxuICAgIGF3YWl0IHdyaXRlRmlsZShgJHtvdXRwdXR9LmNzdmAsIHN0cmluZ2lmeShtYXRyaXgsIHtjb2x1bW5zfSkpO1xuICB9O1xuXG4gIHJldHVybiB7XG4gICAgZXhlY3V0ZSxcbiAgICBtZXRhZGF0YToge1xuICAgICAga2luZDogJ2V4aGF1c3QnLFxuICAgIH0sXG4gIH07XG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-csv.js","sourceRoot":"","sources":["../../src/builtins/export-csv.ts"],"names":[],"mappings":"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","sourcesContent":["import {writeFile} from 'fs/promises';\nimport {stringify} from 'csv-stringify/sync';\n\nimport {ERRORS} from '../util/errors';\n\nimport {Context} from '../types/manifest';\nimport {PluginParams} from '../types/interface';\n\nconst {ExhaustError} = ERRORS;\n\n/**\n * Extension to IF that outputs the tree in a CSV format.\n */\nexport const ExportCSV = () => {\n  const parseOutputAndField = (outputPath: string) => {\n    const validatedPath = validateOutputPath(outputPath);\n\n    const paths = validatedPath.split('#');\n    const output = paths.slice(0, paths.length - 1).join('');\n    const criteria = paths[paths.length - 1];\n\n    if (paths.length <= 1 || !criteria) {\n      throw new ExhaustError(\n        'CSV export criteria is not found in output path. Please append it after --output <path>#.'\n      );\n    }\n\n    return {\n      output,\n      criteria,\n    };\n  };\n\n  /**\n   * Validates output path.\n   */\n  const validateOutputPath = (outputPath: string) => {\n    if (!outputPath) {\n      throw new ExhaustError('Output path is required.');\n    }\n\n    if (!outputPath.includes('#')) {\n      throw new ExhaustError('Output path should contain `#`.');\n    }\n\n    return outputPath;\n  };\n\n  /**\n   * Grabs output and criteria from cli args, then call tree walker to collect csv data.\n   */\n  const execute = async (tree: any, context: Context, outputPath: string) => {\n    const columns = ['Path'];\n    const matrix = [columns];\n    const {output, criteria} = parseOutputAndField(outputPath);\n    const aggregationIsEnabled = !!context.aggregation;\n\n    /**\n     * Walks through all tree branches and leaves, collecting the data\n     */\n    const treeWalker = (node: any, criteria: string, path = 'tree') => {\n      /** Hmm aggregated, then checks if it's the first one. If so adds column, pushes the value. */\n      if (node.aggregated) {\n        if (path === 'tree') {\n          columns.push('Aggregated');\n        }\n\n        matrix.push([`${path}.${criteria}`, node.aggregated[criteria]]);\n      }\n\n      /** So it has outputs, whats then? checks if timestamp is not there, adds one. Then appends values to it. */\n      if (node.outputs) {\n        node.outputs.forEach((output: PluginParams) => {\n          const {timestamp} = output;\n\n          if (!columns.includes(timestamp)) {\n            columns.push(output.timestamp);\n          }\n\n          const lastRow = matrix[matrix.length - 1];\n\n          if (aggregationIsEnabled) {\n            lastRow.push(output[criteria]);\n          } else {\n            /** Handle without aggregation export strategy. */\n            if (matrix.length === 1 || lastRow.length === columns.length) {\n              matrix.push([`${path}.${criteria}`, output[criteria]]);\n            } else {\n              lastRow.push(output[criteria]);\n            }\n          }\n        });\n      }\n\n      /** Ohh children? then call every one and execute. */\n      if (node.children) {\n        for (const child in node.children) {\n          treeWalker(\n            node.children[child],\n            criteria,\n            `${path}.children.${child}`\n          );\n        }\n      }\n    };\n\n    treeWalker(tree, criteria);\n\n    await writeFile(`${output}.csv`, stringify(matrix, {columns}));\n  };\n\n  return {\n    execute,\n    metadata: {\n      kind: 'exhaust',\n    },\n  };\n};\n"]}

package/build/builtins/export-log.js

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportLog = void 0;
+const YAML = __importStar(require("js-yaml"));
 const ExportLog = () => {
     /**
      * Logs output manifest in console.
@@ -10,9 +34,9 @@ const ExportLog = () => {
             ...context,
             tree,
         };
-        console.log(JSON.stringify(outputFile, null, 2));
+        console.log(YAML.dump(outputFile, { noRefs: true }));
     };
     return { execute };
 };
 exports.ExportLog = ExportLog;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LWxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsdGlucy9leHBvcnQtbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVPLE1BQU0sU0FBUyxHQUFHLEdBQUcsRUFBRTtJQUM1Qjs7T0FFRztJQUNILE1BQU0sT0FBTyxHQUFHLEtBQUssRUFBRSxJQUFTLEVBQUUsT0FBZ0IsRUFBRSxFQUFFO1FBQ3BELE1BQU0sVUFBVSxHQUFHO1lBQ2pCLEdBQUcsT0FBTztZQUNWLElBQUk7U0FDTCxDQUFDO1FBRUYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNuRCxDQUFDLENBQUM7SUFFRixPQUFPLEVBQUMsT0FBTyxFQUFDLENBQUM7QUFDbkIsQ0FBQyxDQUFDO0FBZFcsUUFBQSxTQUFTLGFBY3BCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb250ZXh0fSBmcm9tICcuLi90eXBlcy9tYW5pZmVzdCc7XG5cbmV4cG9ydCBjb25zdCBFeHBvcnRMb2cgPSAoKSA9PiB7XG4gIC8qKlxuICAgKiBMb2dzIG91dHB1dCBtYW5pZmVzdCBpbiBjb25zb2xlLlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IGFzeW5jICh0cmVlOiBhbnksIGNvbnRleHQ6IENvbnRleHQpID0+IHtcbiAgICBjb25zdCBvdXRwdXRGaWxlID0ge1xuICAgICAgLi4uY29udGV4dCxcbiAgICAgIHRyZWUsXG4gICAgfTtcblxuICAgIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KG91dHB1dEZpbGUsIG51bGwsIDIpKTtcbiAgfTtcblxuICByZXR1cm4ge2V4ZWN1dGV9O1xufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LWxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsdGlucy9leHBvcnQtbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQWdDO0FBR3pCLE1BQU0sU0FBUyxHQUFHLEdBQUcsRUFBRTtJQUM1Qjs7T0FFRztJQUNILE1BQU0sT0FBTyxHQUFHLEtBQUssRUFBRSxJQUFTLEVBQUUsT0FBZ0IsRUFBRSxFQUFFO1FBQ3BELE1BQU0sVUFBVSxHQUFHO1lBQ2pCLEdBQUcsT0FBTztZQUNWLElBQUk7U0FDTCxDQUFDO1FBQ0YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxFQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUMsQ0FBQyxDQUFDLENBQUM7SUFDckQsQ0FBQyxDQUFDO0lBRUYsT0FBTyxFQUFDLE9BQU8sRUFBQyxDQUFDO0FBQ25CLENBQUMsQ0FBQztBQWJXLFFBQUEsU0FBUyxhQWFwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFlBTUwgZnJvbSAnanMteWFtbCc7XG5pbXBvcnQge0NvbnRleHR9IGZyb20gJy4uL3R5cGVzL21hbmlmZXN0JztcblxuZXhwb3J0IGNvbnN0IEV4cG9ydExvZyA9ICgpID0+IHtcbiAgLyoqXG4gICAqIExvZ3Mgb3V0cHV0IG1hbmlmZXN0IGluIGNvbnNvbGUuXG4gICAqL1xuICBjb25zdCBleGVjdXRlID0gYXN5bmMgKHRyZWU6IGFueSwgY29udGV4dDogQ29udGV4dCkgPT4ge1xuICAgIGNvbnN0IG91dHB1dEZpbGUgPSB7XG4gICAgICAuLi5jb250ZXh0LFxuICAgICAgdHJlZSxcbiAgICB9O1xuICAgIGNvbnNvbGUubG9nKFlBTUwuZHVtcChvdXRwdXRGaWxlLCB7bm9SZWZzOiB0cnVlfSkpO1xuICB9O1xuXG4gIHJldHVybiB7ZXhlY3V0ZX07XG59O1xuIl19

package/build/builtins/export-yaml.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportYaml = void 0;
 const yaml_1 = require("../util/yaml");
 const errors_1 = require("../util/errors");
-const { CliInputError } = errors_1.ERRORS;
+const { ExhaustError } = errors_1.ERRORS;
 const ExportYaml = () => {
     /** Takes string before hashtag. */
     const stripHashtag = (path) => path.split('#')[0];
@@ -12,7 +12,7 @@ const ExportYaml = () => {
      */
     const execute = async (tree, context, outputPath) => {
         if (!outputPath) {
-            throw new CliInputError('Output path is required.');
+            throw new ExhaustError('Output path is required.');
         }
         const outputFile = {
             ...context,
@@ -24,4 +24,4 @@ const ExportYaml = () => {
     return { execute };
 };
 exports.ExportYaml = ExportYaml;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LXlhbWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbHRpbnMvZXhwb3J0LXlhbWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQTRDO0FBRTVDLDJDQUFzQztBQUl0QyxNQUFNLEVBQUMsYUFBYSxFQUFDLEdBQUcsZUFBTSxDQUFDO0FBRXhCLE1BQU0sVUFBVSxHQUFHLEdBQUcsRUFBRTtJQUM3QixtQ0FBbUM7SUFDbkMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFMUQ7O09BRUc7SUFDSCxNQUFNLE9BQU8sR0FBRyxLQUFLLEVBQUUsSUFBUyxFQUFFLE9BQWdCLEVBQUUsVUFBa0IsRUFBRSxFQUFFO1FBQ3hFLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDZixNQUFNLElBQUksYUFBYSxDQUFDLDBCQUEwQixDQUFDLENBQUM7U0FDckQ7UUFFRCxNQUFNLFVBQVUsR0FBRztZQUNqQixHQUFHLE9BQU87WUFDVixJQUFJO1NBQ0wsQ0FBQztRQUNGLE1BQU0sSUFBSSxHQUFHLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUV0QyxNQUFNLElBQUEscUJBQWMsRUFBQyxVQUFVLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO0lBQ25ELENBQUMsQ0FBQztJQUVGLE9BQU8sRUFBQyxPQUFPLEVBQUMsQ0FBQztBQUNuQixDQUFDLENBQUM7QUF0QlcsUUFBQSxVQUFVLGNBc0JyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7c2F2ZVlhbWxGaWxlQXN9IGZyb20gJy4uL3V0aWwveWFtbCc7XG5cbmltcG9ydCB7RVJST1JTfSBmcm9tICcuLi91dGlsL2Vycm9ycyc7XG5cbmltcG9ydCB7Q29udGV4dH0gZnJvbSAnLi4vdHlwZXMvbWFuaWZlc3QnO1xuXG5jb25zdCB7Q2xpSW5wdXRFcnJvcn0gPSBFUlJPUlM7XG5cbmV4cG9ydCBjb25zdCBFeHBvcnRZYW1sID0gKCkgPT4ge1xuICAvKiogVGFrZXMgc3RyaW5nIGJlZm9yZSBoYXNodGFnLiAqL1xuICBjb25zdCBzdHJpcEhhc2h0YWcgPSAocGF0aDogc3RyaW5nKSA9PiBwYXRoLnNwbGl0KCcjJylbMF07XG5cbiAgLyoqXG4gICAqIFNhdmVzIG91dHB1dCBmaWxlIGluIFlBTUwgZm9ybWF0LlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IGFzeW5jICh0cmVlOiBhbnksIGNvbnRleHQ6IENvbnRleHQsIG91dHB1dFBhdGg6IHN0cmluZykgPT4ge1xuICAgIGlmICghb3V0cHV0UGF0aCkge1xuICAgICAgdGhyb3cgbmV3IENsaUlucHV0RXJyb3IoJ091dHB1dCBwYXRoIGlzIHJlcXVpcmVkLicpO1xuICAgIH1cblxuICAgIGNvbnN0IG91dHB1dEZpbGUgPSB7XG4gICAgICAuLi5jb250ZXh0LFxuICAgICAgdHJlZSxcbiAgICB9O1xuICAgIGNvbnN0IHBhdGggPSBzdHJpcEhhc2h0YWcob3V0cHV0UGF0aCk7XG5cbiAgICBhd2FpdCBzYXZlWWFtbEZpbGVBcyhvdXRwdXRGaWxlLCBgJHtwYXRofS55YW1sYCk7XG4gIH07XG5cbiAgcmV0dXJuIHtleGVjdXRlfTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LXlhbWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbHRpbnMvZXhwb3J0LXlhbWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQTRDO0FBQzVDLDJDQUFzQztBQUl0QyxNQUFNLEVBQUMsWUFBWSxFQUFDLEdBQUcsZUFBTSxDQUFDO0FBRXZCLE1BQU0sVUFBVSxHQUFHLEdBQUcsRUFBRTtJQUM3QixtQ0FBbUM7SUFDbkMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFMUQ7O09BRUc7SUFDSCxNQUFNLE9BQU8sR0FBRyxLQUFLLEVBQUUsSUFBUyxFQUFFLE9BQWdCLEVBQUUsVUFBa0IsRUFBRSxFQUFFO1FBQ3hFLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDZixNQUFNLElBQUksWUFBWSxDQUFDLDBCQUEwQixDQUFDLENBQUM7U0FDcEQ7UUFFRCxNQUFNLFVBQVUsR0FBRztZQUNqQixHQUFHLE9BQU87WUFDVixJQUFJO1NBQ0wsQ0FBQztRQUNGLE1BQU0sSUFBSSxHQUFHLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUV0QyxNQUFNLElBQUEscUJBQWMsRUFBQyxVQUFVLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO0lBQ25ELENBQUMsQ0FBQztJQUVGLE9BQU8sRUFBQyxPQUFPLEVBQUMsQ0FBQztBQUNuQixDQUFDLENBQUM7QUF0QlcsUUFBQSxVQUFVLGNBc0JyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7c2F2ZVlhbWxGaWxlQXN9IGZyb20gJy4uL3V0aWwveWFtbCc7XG5pbXBvcnQge0VSUk9SU30gZnJvbSAnLi4vdXRpbC9lcnJvcnMnO1xuXG5pbXBvcnQge0NvbnRleHR9IGZyb20gJy4uL3R5cGVzL21hbmlmZXN0JztcblxuY29uc3Qge0V4aGF1c3RFcnJvcn0gPSBFUlJPUlM7XG5cbmV4cG9ydCBjb25zdCBFeHBvcnRZYW1sID0gKCkgPT4ge1xuICAvKiogVGFrZXMgc3RyaW5nIGJlZm9yZSBoYXNodGFnLiAqL1xuICBjb25zdCBzdHJpcEhhc2h0YWcgPSAocGF0aDogc3RyaW5nKSA9PiBwYXRoLnNwbGl0KCcjJylbMF07XG5cbiAgLyoqXG4gICAqIFNhdmVzIG91dHB1dCBmaWxlIGluIFlBTUwgZm9ybWF0LlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IGFzeW5jICh0cmVlOiBhbnksIGNvbnRleHQ6IENvbnRleHQsIG91dHB1dFBhdGg6IHN0cmluZykgPT4ge1xuICAgIGlmICghb3V0cHV0UGF0aCkge1xuICAgICAgdGhyb3cgbmV3IEV4aGF1c3RFcnJvcignT3V0cHV0IHBhdGggaXMgcmVxdWlyZWQuJyk7XG4gICAgfVxuXG4gICAgY29uc3Qgb3V0cHV0RmlsZSA9IHtcbiAgICAgIC4uLmNvbnRleHQsXG4gICAgICB0cmVlLFxuICAgIH07XG4gICAgY29uc3QgcGF0aCA9IHN0cmlwSGFzaHRhZyhvdXRwdXRQYXRoKTtcblxuICAgIGF3YWl0IHNhdmVZYW1sRmlsZUFzKG91dHB1dEZpbGUsIGAke3BhdGh9LnlhbWxgKTtcbiAgfTtcblxuICByZXR1cm4ge2V4ZWN1dGV9O1xufTtcbiJdfQ==

package/build/builtins/group-by.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupBy = void 0;
-const errors_1 = require("../util/errors");
+const zod_1 = require("zod");
 const config_1 = require("../config");
-const { InvalidGrouping } = errors_1.ERRORS;
+const errors_1 = require("../util/errors");
+const validations_1 = require("../util/validations");
+const { InvalidGroupingError, InputValidationError } = errors_1.ERRORS;
 const { INVALID_GROUP_BY } = config_1.STRINGS;
 /**
  * Plugin for inputs grouping.
@@ -38,9 +40,10 @@ const GroupBy = () => {
      * Based on grouping types, initializes the structure grouped structure.
      */
     const execute = (inputs, config) => inputs.reduce((acc, input) => {
-        const groups = config.group.map(groupType => {
+        const validatedConfig = validateConfig(config);
+        const groups = validatedConfig.group.map(groupType => {
             if (!input[groupType]) {
-                throw new InvalidGrouping(INVALID_GROUP_BY(groupType));
+                throw new InvalidGroupingError(INVALID_GROUP_BY(groupType));
             }
             return input[groupType];
         });
@@ -50,7 +53,19 @@ const GroupBy = () => {
         };
         return acc;
     }, {}).children;
+    /**
+     * Validates config parameter.
+     */
+    const validateConfig = (config) => {
+        if (!config) {
+            throw new InputValidationError('Config is not provided.');
+        }
+        const schema = zod_1.z.object({
+            group: zod_1.z.array(zod_1.z.string()).min(1),
+        });
+        return (0, validations_1.validate)(schema, config);
+    };
     return { metadata, execute };
 };
 exports.GroupBy = GroupBy;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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