@grnsft/if 0.2.1 → 0.3.1

package/.commitlintrc.js

@@ -31,15 +31,12 @@ module.exports = {
         '.github',
         '.husky',
         'scripts',
-        'models',
+        'builtins',
         'plugins',
         'integration',
-        'doc'
-      ]
+        'doc',
+      ],
     ],
-    'scope-empty': [
-      2, 
-      'never'
-    ]
+    'scope-empty': [2, 'never'],
   },
 };

package/README.md

@@ -24,10 +24,14 @@
 > [!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!
+
+
+
 [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/).
 
 
-**Our documentation is online at [if.greensoftware.foundation]([if.greensoftware.foundation](https://if.greensoftware.foundation/))**
+**Our documentation is online at [if.greensoftware.foundation](https://if.greensoftware.foundation/)**
 
 
 **IF** is a framework to **M**odel, **M**easure, si**M**ulate and **M**onitor the environmental impacts of software

package/Refactor-migration-guide.md

@@ -0,0 +1,342 @@
+# Managing the IF refactor
+
+We recently completed a major refactor of the entire IF codebase, moving from an object oriented to functional programmign style.
+
+If you are a IF user or developer, there are some changes you must be aware of resulting from a recent refactor of the IF codebase. This guide will help you to update your processes to integrate your work with the newly refactored IF.
+
+## Running IF
+
+There have been some name changes to the CLI, specifically:
+
+- `impact-engine` --> `ie`
+    The command line tool has been renamed from `impact-engine` to simply `ie`. This means that to invoke the Impact Framework on the command line you simply use 
+
+    ```
+    ie ...
+    ```
+-  `impl` --> `manifest` 
+    We have deprecated the original `impl` and `ompl` terminology across all our repositories and on the command line. Now, to pass a manifest file to IF, you use the `--manifest` command, as follows:
+
+    ```sh
+    ie --manifest <path-to-manifest>
+    ```
+
+
+- `ompl` --> `output`
+ 
+    We have deprecated the original `impl` and `ompl` terminology across all our repositories and on the command line. Now, to define a savepath for your output file, you use the `--output` command, as follows:
+
+    ```sh
+    ie --manifest <path-to-manifest> --output <savepath>
+    ```
+
+## Outputs
+
+We currently default to exporting output data to the console only. If you want to export to a file, you have to add a small piece of config inside your manifest, as follows:
+
+```yaml
+initalize:
+  plugins: ...
+  outputs: ['yaml']
+```
+
+You then provide your savepatrh (without file extension) to the `--output` command on the CLI.
+
+The available options are currently `csv`, `yaml` or `log`.
+
+### Summary of how to run the refactored IF 
+
+As before, you can install IF from our npm package using
+
+```
+npm i @grnsft/if
+```
+
+Then run IF using the following command:
+
+```sh
+ie --manifest <path-to-manifest>
+```
+
+This will dump the output to the console. If you want to save the output to a yaml file, provide a savepath to the `--output` command:
+
+```sh
+ie --manifest <path-to-manifest> --output <savepath>
+```
+
+
+If you want to clone the source code and install and run a local copy of IF, you can do so using:
+
+```sh
+git clone https://github.com/Green-Software-Foundation/if &&
+cd if &&
+npm i
+```
+
+Then run IF using the following command:
+
+```sh
+npm run if -- --manifest <path-to-manifest>
+```
+
+
+## Manifest files
+
+There have also been some changes to the structure of manifest files. Some of these are simple renaming changes, others are more functional.
+
+- **Rename `graph` -> `tree`**
+    The `graph` section of the manifest file is now renamed to `tree`. This is just to help us stay consistent in our metaphors and provide a more familiar naming convention for the data beneath.
+
+- **Use plugin name as key in `Initialize` block**
+    In the previous version of IF, the plugins were organized into an array each having a `name` key, with the plugin name as the value. In the refactored IF, we use the name as the key identifying the plugin. For example, this is the OLD way:
+    
+    ```yaml
+    initialize:
+      plugins:
+        - name: ccf
+          model: CloudCarbonFootprint
+          path: if-plugins
+    ```
+
+    This is the new way:
+    
+    ```yaml
+    initialize:
+      plugins:
+        "sci-e":
+          path: "@grnsft/if-plugins"
+          method: SciE
+    ```
+
+- **Rename `model` to `method` in `Initialize` block**
+    Each plugin in the initialize block 
+
+    Each plugin in the `Initialize` block has a field where the name of the exported function representing that plugin is defined. Previously, these were class names and they were defined using the `model` key. Now, they are functions, and they are defined using the `method` key. We use `method` instead of `function` because `function` is a reserved keyword in Typescript.
+    
+    For example:
+    
+    ```yaml
+    "sci-m":
+      path: "@grnsft/if-plugins"
+      method: SciM
+    ```
+
+- **Global config**
+    We have introduced the concept of global config to the plugins. This is truly global configuration data that should be kept constant regardless of where the plugin is invoked across the manifest file. 
+    
+    A good example is the `interpolation` method to use in the Teads curve plugin - this is not expected to vary from component to component and can therefore be defined in global config. The plugin code itself must expect the global config. Then, the config can be passed in the `Initialize` block, for example:
+    
+    ```yaml
+    initialize:
+      plugins:
+        "time-sync":
+           method: TimeSync
+           path: "builtin"
+           global-config:
+             start-time: "2023-12-12T00:00:00.000Z"
+             end-time: "2023-12-12T00:01:00.000Z"
+             interval: 5
+             allow-padding: true
+    ```
+
+- **Node level config**
+
+    We have also introduced the concept of node-level config. This is designed for pluin configuration that might vary between components in the tree. For example, for each child in the tree you might wish to use the `groupby` plugin to group the outputs according to a different set of keys.
+
+    ```yaml
+    tree:
+      children:
+        child-1:
+          pipeline:
+            - teads-curve
+            - sci-e
+            - sci-m
+            - sci-o
+            - time-sync
+            - sci
+          config:
+            group-by:
+              group:
+                - region
+                - cloud/instance-type
+    ```
+
+- **Defaults**
+
+    We have also introduced the concept of `defaults`. This is a section in each component's definition that can be used to provide fallbacks for missing input data. For example, perhaps you have a value arriving from an external API that should be present in every observation in your inputs array, but for soem reason the API fails to deliver a value for some timestamps. In this case, IF would fallback to the value provided for that metric in the `defaults` section of the manifest for that component.
+
+    You can also use `defaults` as a quick way to add values to everyobservation in your input array if those values are expected to be constant over time (e.g. some of the lifespan values for embodied carbon calculations could be appropriate to include in defaults). This saves you from having to enter the value in every observation in the input array, instead IF can automatically grab it from `defaults` for every timestamp. 
+
+    ```yaml
+    tree:
+      children:
+        child-1:
+          pipeline:
+            - teads-curve
+            - sci-e
+            - sci-m
+            - sci-o
+            - time-sync
+            - sci
+         defaults:
+            cpu/thermal-design-power: 100
+            grid/carbon-intensity: 800
+            device/emissions-embodied: 1533.120 # gCO2eq
+            time-reserved: 3600 # 1hr in seconds
+            device/expected-lifespan: 94608000 # 3 years in seconds
+            resources-reserved: 1
+            resources-total: 8
+            functional-unit-time: "1 min"
+    ```
+
+
+
+## New IF features
+
+### Time-sync
+Technically time-sync is not a new feature as it was present in IF before the refactor, but there are some tweaks to how the plugin is configured that are worth explaining here. Time sync snaps all input arrays across an entire graph to a common time grid. 
+
+This means you have to define a global start time, end time and interval to use everywhere. There is also a boolean to toggle whether you should allow the time sync model to pad the start and end of your time series with zeroes. You should default to `true` unless you have a specific reason not to. In the refactored IF we expect this information to be provided in global config, as follows:
+
+```yaml
+initialize:
+    plugins:
+        "time-sync":
+          method: TimeSync
+          path: "builtin"
+          global-config:
+            start-time: "2023-12-12T00:00:00.000Z"
+            end-time: "2023-12-12T00:01:00.000Z"
+            interval: 5
+            allow-padding: true
+```
+
+### Aggregate
+
+The aggregate plugin aggregates data in two ways: first it condenses individual time series down into a single value (in many cases, this will be the total across the observation period for each metric) and aggregating multiple time series from several components into a single time series (in many cases this means the sum of the metric across multiple componments for each timestep).
+
+This is a builtin feature of IF, meaning it does not have to be initialized as a plugin. Instead, you just have to include a short config block in the top of the manifest file. There are two pieces of information required:
+
+- `metrics`: which metrics do you want to aggregate? Every metric you provide here must exist in the output array. 
+
+- `type`: the options are `horizontal`, `vertical` or both. Horizontal aggregation is the type that condenses each time series into a single summary value. Vertical aggregation is aggregated across components.
+
+Here's what the config block should look like:
+
+```yaml
+aggregation:
+  metrics:
+    - 'carbon'
+  type: 'both'
+```
+
+
+### Groupby
+
+Groupby allows you to regroup your outputs according to keys you define. For example, maybe you want to group your outputs by region (show me all the outputs for applications run in `uk-south` etc). Groupby *is* a plugin that needs to be initialized in the manifest.
+
+You can initialize the plugin as follows:
+
+```yaml
+initialize:
+  plugins:
+    'group-by':
+      path: builtin
+      method: GroupBy
+```
+
+Then you configure groupby for each component in the node level config. In the following example we will regroup the outputs by the `region`:
+
+```yaml
+tree:
+  children:
+    child-1:
+      pipeline:
+        - teads-curve
+        - sci-e
+        - sci-m
+        - sci-o
+        - time-sync
+        - group-by
+        - sci
+      config:
+        group-by:
+          group:
+            - region
+```
+
+### Exhaust
+
+We have introduced `exhaust` as an IF feature. This is a wrapper around export plugins and it allows community contributors to create plugins for exporting to different formats. 
+
+Details tbc...
+
+
+## Plugins
+
+The plugins themselves require some changes to keep them compatible with the refactored IF.
+
+Instead of the old class-based model, plugins are now functions. They conform to the following interface:
+
+```ts
+export type PluginInterface = {
+  execute: (
+    inputs: PluginParams[],
+    config?: Record<string, any>
+  ) => PluginParams[];
+  metadata: {
+    kind: string;
+  };
+  [key: string]: any;
+};
+```
+
+The plugin still requires an execute function. This is where you implement the plugin logic.
+
+Here's a minimal example for a plugin that sums some inputs defined in global config - see inline comments for some important notes:
+
+```ts
+
+// Here's the function definition - notice that global config is passed in here!
+export const Sum = (globalConfig: SumConfig): PluginInterface => {
+  const inputParameters = globalConfig['input-parameters'] || [];
+  const outputParameter = globalConfig['output-parameter'];
+    
+    // we also return metadata now too - you can add more or just use this default
+  const metadata = {
+    kind: 'execute',
+  };
+    
+   /**
+   * Calculate the sum of the input metrics for each timestamp.
+   */
+  const execute = async (inputs: PluginParams[]): Promise<PluginParams[]> => {
+    inputs.map(input => {
+      return calculateSum(input, inputParameters, outputParameter);
+    });
+    return inputs;
+  };
+
+  /**
+   * Calculates the sum of the energy components.
+   */
+  const calculateSum = (
+    input: PluginParams,
+    inputParameters: string[],
+    outputParameter: string
+  ) => {
+    input[outputParameter] = inputParameters.reduce(
+      (accumulator, metricToSum) => {
+        return accumulator + input[metricToSum];
+      },
+      0
+    );
+  };
+
+    // return the metadata and the execute function
+  return {
+    metadata,
+    execute,
+  };
+};
+```

package/build/{models/export-csv.d.ts → builtins/export-csv-raw.d.ts}

@@ -1,2 +1,2 @@
 import { ExhaustPluginInterface } from '../types/exhaust-plugin-interface';
-export declare const ExportCsv: () => ExhaustPluginInterface;
+export declare const ExportCSVRaw: () => ExhaustPluginInterface;

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

@@ -0,0 +1,129 @@
+"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.ExportCSVRaw = void 0;
+const fs = __importStar(require("fs/promises"));
+const errors_1 = require("../util/errors");
+const { WriteFileError, CliInputError } = 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
+     * and capturing key as a header
+     */
+    const handleLeafValue = (value, fullPath, key, flatMap, headers) => {
+        if (fullPath.includes('outputs')) {
+            headers.add(key);
+            flatMap[fullPath] = value;
+        }
+    };
+    /**
+     * handle a tree node, recursively traverse the children and append their results to the flat map and captured headers
+     */
+    const handleNodeValue = (value, fullPath, flatMap, headers) => {
+        const [subFlatMap, subHeaders] = extractFlatMapAndHeaders(value, fullPath);
+        if (Object.keys(subFlatMap).length > 0) {
+            Object.entries(subFlatMap).forEach(([subKey, value]) => {
+                flatMap[subKey] = value;
+            });
+            subHeaders.forEach(subHeader => {
+                headers.add(subHeader);
+            });
+        }
+    };
+    /**
+     * Handles a key at the top level of the tree
+     */
+    const handleKey = (value, key, prefix, flatMap, headers) => {
+        const fullPath = prefix ? `${prefix}.${key}` : key;
+        if (value !== null && typeof value === 'object') {
+            return handleNodeValue(value, fullPath, flatMap, headers);
+        }
+        return handleLeafValue(value, fullPath, key, flatMap, headers);
+    };
+    /**
+     * Recursively extract a flat map and headers from the hierarcial tree.
+     */
+    const extractFlatMapAndHeaders = (tree, prefix = '') => {
+        const headers = new Set();
+        const flatMap = [];
+        for (const key in tree) {
+            if (key in tree) {
+                handleKey(tree[key], key, prefix, flatMap, headers);
+            }
+        }
+        return [flatMap, headers];
+    };
+    /**
+     * extract the id of the key, that is removing the last token (which is the index).
+     * in this manner, multiple keys that identical besides their index share the same id.
+     */
+    const extractIdHelper = (key) => {
+        const parts = key.split('.');
+        parts.pop();
+        return parts.join('.');
+    };
+    /**
+     * generate a CSV formatted string based on a flat key->value map, headers and ids
+     */
+    const getCsvString = (map, headers, ids) => {
+        const csvRows = [];
+        csvRows.push(['id', ...headers].join(','));
+        ids.forEach(id => {
+            const rowData = [id];
+            headers.forEach(header => {
+                const value = map[`${id}.${header}`] ?? '';
+                rowData.push(value.toString());
+            });
+            csvRows.push(rowData.join(','));
+        });
+        return csvRows.join('\n');
+    };
+    /**
+     * write the given string content to a file at the provided path
+     */
+    const writeOutputFile = async (content, outputPath) => {
+        try {
+            await fs.writeFile(`${outputPath}.csv`, content);
+        }
+        catch (error) {
+            throw new WriteFileError(`Failed to write CSV to ${outputPath}: ${error}`);
+        }
+    };
+    /**
+     * export the provided tree content to a CSV file, represented in a flat structure
+     */
+    const execute = async (tree, _context, outputPath) => {
+        if (!outputPath) {
+            throw new CliInputError('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);
+    };
+    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"]}

package/build/builtins/export-csv.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '../types/manifest';
+/**
+ * Extension to IF that outputs the tree in a CSV format.
+ */
+export declare const ExportCSV: () => {
+    execute: (tree: any, context: Context, outputPath: string) => Promise<void>;
+    metadata: {
+        kind: string;
+    };
+};

package/build/builtins/export-csv.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+/**
+ * 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 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>#.');
+        }
+        return {
+            output,
+            criteria,
+        };
+    };
+    /**
+     * Grabs output and criteria from cli args, then call tree walker to collect csv data.
+     */
+    const execute = async (tree, context, outputPath) => {
+        const columns = ['Path'];
+        const matrix = [columns];
+        const { output, criteria } = parseOutputAndField(outputPath);
+        const aggregationIsEnabled = !!context.aggregation;
+        /**
+         * Walks through all tree branches and leaves, collecting the data
+         */
+        const treeWalker = (node, criteria, path = 'tree') => {
+            /** Hmm aggregated, then checks if it's the first one. If so adds column, pushes the value. */
+            if (node.aggregated) {
+                if (path === 'tree') {
+                    columns.push('Aggregated');
+                }
+                matrix.push([`${path}.${criteria}`, node.aggregated[criteria]]);
+            }
+            /** So it has outputs, whats then? checks if timestamp is not there, adds one. Then appends values to it. */
+            if (node.outputs) {
+                node.outputs.forEach((output) => {
+                    const { timestamp } = output;
+                    if (!columns.includes(timestamp)) {
+                        columns.push(output.timestamp);
+                    }
+                    const lastRow = matrix[matrix.length - 1];
+                    if (aggregationIsEnabled) {
+                        lastRow.push(output[criteria]);
+                    }
+                    else {
+                        /** Handle without aggregation export strategy. */
+                        if (matrix.length === 1 || lastRow.length === columns.length) {
+                            matrix.push([`${path}.${criteria}`, output[criteria]]);
+                        }
+                        else {
+                            lastRow.push(output[criteria]);
+                        }
+                    }
+                });
+            }
+            /** Ohh children? then call every one and execute. */
+            if (node.children) {
+                for (const child in node.children) {
+                    treeWalker(node.children[child], criteria, `${path}.children.${child}`);
+                }
+            }
+        };
+        treeWalker(tree, criteria);
+        await (0, promises_1.writeFile)(`${output}.csv`, (0, sync_1.stringify)(matrix, { columns }));
+    };
+    return {
+        execute,
+        metadata: {
+            kind: 'exhaust',
+        },
+    };
+};
+exports.ExportCSV = ExportCSV;
+//# sourceMappingURL=data:application/json;base64,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

package/build/builtins/export-log.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportLog = void 0;
+const ExportLog = () => {
+    /**
+     * Logs output manifest in console.
+     */
+    const execute = async (tree, context) => {
+        const outputFile = {
+            ...context,
+            tree,
+        };
+        console.log(JSON.stringify(outputFile, null, 2));
+    };
+    return { execute };
+};
+exports.ExportLog = ExportLog;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LWxvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsdGlucy9leHBvcnQtbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVPLE1BQU0sU0FBUyxHQUFHLEdBQUcsRUFBRTtJQUM1Qjs7T0FFRztJQUNILE1BQU0sT0FBTyxHQUFHLEtBQUssRUFBRSxJQUFTLEVBQUUsT0FBZ0IsRUFBRSxFQUFFO1FBQ3BELE1BQU0sVUFBVSxHQUFHO1lBQ2pCLEdBQUcsT0FBTztZQUNWLElBQUk7U0FDTCxDQUFDO1FBRUYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNuRCxDQUFDLENBQUM7SUFFRixPQUFPLEVBQUMsT0FBTyxFQUFDLENBQUM7QUFDbkIsQ0FBQyxDQUFDO0FBZFcsUUFBQSxTQUFTLGFBY3BCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb250ZXh0fSBmcm9tICcuLi90eXBlcy9tYW5pZmVzdCc7XG5cbmV4cG9ydCBjb25zdCBFeHBvcnRMb2cgPSAoKSA9PiB7XG4gIC8qKlxuICAgKiBMb2dzIG91dHB1dCBtYW5pZmVzdCBpbiBjb25zb2xlLlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IGFzeW5jICh0cmVlOiBhbnksIGNvbnRleHQ6IENvbnRleHQpID0+IHtcbiAgICBjb25zdCBvdXRwdXRGaWxlID0ge1xuICAgICAgLi4uY29udGV4dCxcbiAgICAgIHRyZWUsXG4gICAgfTtcblxuICAgIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KG91dHB1dEZpbGUsIG51bGwsIDIpKTtcbiAgfTtcblxuICByZXR1cm4ge2V4ZWN1dGV9O1xufTtcbiJdfQ==