@grnsft/if 0.5.0 → 0.6.0

package/build/{config → if-run/config}/strings.d.ts

@@ -1,11 +1,7 @@
-import { ManifestParameter } from '../types/manifest';
 export declare const STRINGS: {
-    MANIFEST_IS_MISSING: string;
     MISSING_METHOD: string;
     MISSING_PATH: string;
     UNSUPPORTED_PLUGIN: string;
-    OVERRIDE_WARNING: string;
-    DISCLAIMER_MESSAGE: string;
     NOT_NATIVE_PLUGIN: (path: string) => string;
     INVALID_MODULE_PATH: (path: string, error?: any) => string;
     INVALID_TIME_NORMALIZATION: string;
@@ -15,55 +11,19 @@ export declare const STRINGS: {
     AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) => string;
     INVALID_AGGREGATION_METHOD: (metric: string) => string;
     METRIC_MISSING: (metric: string, index: number) => string;
-    INVALID_GROUP_BY: (type: string) => string;
-    REJECTING_OVERRIDE: (param: ManifestParameter) => string;
+    INVALID_GROUP_KEY: (key: string) => string;
+    REGROUP_ERROR: string;
     INVALID_EXHAUST_PLUGIN: (pluginName: string) => string;
     UNKNOWN_PARAM: (name: string) => string;
     NOT_INITALIZED_PLUGIN: (name: string) => string;
     NO_OUTPUT: string;
-    SOURCE_IS_NOT_YAML: string;
-    TARGET_IS_NOT_YAML: string;
-    INVALID_TARGET: string;
-    INVALID_SOURCE: string;
     UNSUPPORTED_ERROR: (errorName: string) => string;
-    /** Plugin messages */
-    MISSING_GLOBAL_CONFIG: string;
-    MISSING_INPUT_DATA: (param: string) => string;
-    MANIFEST_NOT_FOUND: string;
-    INITIALIZING_PACKAGE_JSON: string;
-    INSTALLING_NPM_PACKAGES: string;
-    NOT_NUMERIC_VALUE: (str: any) => string;
-    MISSING_FUNCTIONAL_UNIT_CONFIG: string;
-    MISSING_FUNCTIONAL_UNIT_INPUT: string;
-    REGEX_MISMATCH: (input: any, match: string) => string;
-    SCI_EMBODIED_ERROR: (unit: string) => string;
-    MISSING_MIN_MAX: string;
-    INVALID_MIN_MAX: (name: string) => string;
-    FILE_FETCH_FAILED: (filepath: string, message: string) => string;
-    FILE_READ_FAILED: (filepath: string, error: string) => string;
-    MISSING_CSV_COLUMN: (columnName: string) => string;
-    NO_QUERY_DATA: string;
-    INVALID_DATE_TYPE: (date: any) => string;
-    INVALID_OBSERVATION_OVERLAP: string;
-    SCI_MISSING_FN_UNIT: (functionalUnit: string) => string;
-    /** Exhaust messages */
-    OUTPUT_REQUIRED: string;
-    CSV_EXPORT: string;
-    WRITE_CSV_ERROR: (outputPath: string, error: any) => string;
-    INVALID_NAME: string;
-    START_LOWER_END: string;
-    TIMESTAMP_REQUIRED: (index: number) => string;
-    INVALID_DATETIME: (index: number) => string;
-    X_Y_EQUAL: string;
-    ARRAY_LENGTH_NON_EMPTY: string;
-    WITHIN_THE_RANGE: string;
     /** Debugging logs */
     STARTING_IF: string;
     EXITING_IF: string;
     LOADING_MANIFEST: string;
     VALIDATING_MANIFEST: string;
     CAPTURING_RUNTIME_ENVIRONMENT_DATA: string;
-    SYNCING_PARAMETERS: string;
     CHECKING_AGGREGATION_METHOD: (unitName: string) => string;
     INITIALIZING_PLUGINS: string;
     INITIALIZING_PLUGIN: (pluginName: string) => string;
@@ -74,17 +34,31 @@ export declare const STRINGS: {
     AGGREGATING_NODE: (nodeName: string) => string;
     PREPARING_OUTPUT_DATA: string;
     EXPORTING_TO_YAML_FILE: (savepath: string) => string;
-    EXPORTING_TO_CSV_FILE: (savepath: string) => string;
-    EXPORTING_RAW_CSV_FILE: (savepath: string) => string;
-    CHECKING: string;
-    IF_CHECK_FLAGS_MISSING: string;
-    DIRECTORY_NOT_FOUND: string;
-    DIRECTORY_YAML_FILES_NOT_FOUND: string;
-    IF_CHECK_EXECUTING: (filename: string) => string;
-    IF_CHECK_VERIFICATION_FAILURES: string;
-    IF_CHECK_FAILED: (filename: string) => string;
-    IF_CHECK_VERIFIED: (filename: string) => string;
-    IF_CHECK_SUMMARY_ERROR_MESSAGE: (filename: string, message: string) => string;
-    IF_CHECK_SUMMARY_LOG: (passedCount: number, totalCount: number) => string;
+    EMPTY_PIPELINE: string;
+    /** Exhaust messages */
+    OUTPUT_REQUIRED: string;
+    /** Plugins messages */
+    INVALID_NAME: string;
+    START_LOWER_END: string;
+    TIMESTAMP_REQUIRED: (index: number) => string;
+    INVALID_DATETIME: (index: number) => string;
+    X_Y_EQUAL: string;
+    ARRAY_LENGTH_NON_EMPTY: string;
+    WITHIN_THE_RANGE: string;
+    MISSING_CSV_COLUMN: (columnName: string) => string;
+    NO_QUERY_DATA: string;
+    INVALID_DATE_TYPE: (date: any) => string;
+    INVALID_OBSERVATION_OVERLAP: string;
+    SCI_MISSING_FN_UNIT: (functionalUnit: string) => string;
+    MISSING_FUNCTIONAL_UNIT_CONFIG: string;
+    MISSING_FUNCTIONAL_UNIT_INPUT: string;
+    REGEX_MISMATCH: (input: any, match: string) => string;
+    SCI_EMBODIED_ERROR: (unit: string) => string;
+    MISSING_MIN_MAX: string;
+    INVALID_MIN_MAX: (name: string) => string;
+    FILE_FETCH_FAILED: (filepath: string, message: string) => string;
+    FILE_READ_FAILED: (filepath: string, error: string) => string;
     ZERO_DIVISION: (moduleName: string, index: number) => string;
+    MISSING_GLOBAL_CONFIG: string;
+    MISSING_INPUT_DATA: (param: string) => string;
 };

package/build/if-run/config/strings.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = void 0;
+exports.STRINGS = {
+    MISSING_METHOD: "Initalization param 'method' is missing.",
+    MISSING_PATH: "Initalization param 'path' is missing.",
+    UNSUPPORTED_PLUGIN: "Plugin interface doesn't implement 'execute' or 'metadata' methods.",
+    NOT_NATIVE_PLUGIN: (path) => `
+  You are using plugin ${path} which is not part of the Impact Framework standard library. You should do your own research to ensure the plugins are up to date and accurate. They may not be actively maintained.`,
+    INVALID_MODULE_PATH: (path, error) => `Provided module \`${path}\` is invalid or not found. ${error ?? ''}
+`,
+    INVALID_TIME_NORMALIZATION: 'Start time or end time is missing.',
+    UNEXPECTED_TIME_CONFIG: 'Unexpected node-level config provided for time-sync plugin.',
+    INVALID_TIME_INTERVAL: 'Interval is missing.',
+    AVOIDING_PADDING: (description) => `Avoiding padding at ${description}`,
+    AVOIDING_PADDING_BY_EDGES: (start, end) => `Avoiding padding at ${start && end ? 'start and end' : start ? 'start' : 'end'}`,
+    INVALID_AGGREGATION_METHOD: (metric) => `Aggregation is not possible for given ${metric} since method is 'none'.`,
+    METRIC_MISSING: (metric, index) => `Aggregation metric ${metric} is not found in inputs[${index}].`,
+    INVALID_GROUP_KEY: (key) => `Invalid group ${key}.`,
+    REGROUP_ERROR: 'not an array or should contain at least one key',
+    INVALID_EXHAUST_PLUGIN: (pluginName) => `Invalid exhaust plugin: ${pluginName}.`,
+    UNKNOWN_PARAM: (name) => `Unknown parameter: ${name}. Omitting from the output.`,
+    NOT_INITALIZED_PLUGIN: (name) => `Not initalized plugin: ${name}. Check if ${name} is in 'manifest.initalize.plugins'.`,
+    NO_OUTPUT: `
+You have not added an output command: 
+--output <savepath>: will save your output data to the given filepath (do not provide file extension)
+Note that for the '--output' option you also need to define the output type in your manifest file. See https://if.greensoftware.foundation/major-concepts/manifest-file#initialize`,
+    UNSUPPORTED_ERROR: (errorName) => `UnsupportedErrorClass: plugin threw error class: ${errorName} that is not recognized by Impact Framework`,
+    /** Debugging logs */
+    STARTING_IF: 'Starting IF',
+    EXITING_IF: 'Exiting IF',
+    LOADING_MANIFEST: 'Loading manifest',
+    VALIDATING_MANIFEST: 'Validating manifest',
+    CAPTURING_RUNTIME_ENVIRONMENT_DATA: 'Capturing runtime environment data',
+    CHECKING_AGGREGATION_METHOD: (unitName) => `Checking aggregation method for ${unitName}`,
+    INITIALIZING_PLUGINS: 'Initializing plugins',
+    INITIALIZING_PLUGIN: (pluginName) => `Initializing ${pluginName}`,
+    LOADING_PLUGIN_FROM_PATH: (pluginName, path) => `Loading ${pluginName} from ${path}`,
+    COMPUTING_PIPELINE_FOR_NODE: (nodeName) => `Computing pipeline for \`${nodeName}\``,
+    MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',
+    AGGREGATING_OUTPUTS: 'Aggregating outputs',
+    AGGREGATING_NODE: (nodeName) => `Aggregating node ${nodeName}`,
+    PREPARING_OUTPUT_DATA: 'Preparing output data',
+    EXPORTING_TO_YAML_FILE: (savepath) => `Exporting to yaml file: ${savepath}`,
+    EMPTY_PIPELINE: `You're using an old style manifest. Please update for phased execution. More information can be found here: 
+https://if.greensoftware.foundation/major-concepts/manifest-file`,
+    /** Exhaust messages */
+    OUTPUT_REQUIRED: 'Output path is required, please make sure output is configured properly.',
+    /** Plugins messages */
+    INVALID_NAME: '`name` global config parameter is empty or contains all spaces',
+    START_LOWER_END: '`start-time` should be lower than `end-time`',
+    TIMESTAMP_REQUIRED: (index) => `required in input[${index}]`,
+    INVALID_DATETIME: (index) => `invalid datetime in input[${index}]`,
+    X_Y_EQUAL: 'The length of `x` and `y` should be equal',
+    ARRAY_LENGTH_NON_EMPTY: 'the length of the input arrays must be greater than 1',
+    WITHIN_THE_RANGE: 'The target x value must be within the range of the given x values',
+    MISSING_CSV_COLUMN: (columnName) => `There is no column with the name: ${columnName}.`,
+    NO_QUERY_DATA: 'One or more of the given query parameters are not found in the target CSV file column headers.',
+    INVALID_DATE_TYPE: (date) => `Unexpected date datatype: ${typeof date}: ${date}`,
+    INVALID_OBSERVATION_OVERLAP: 'Observation timestamps overlap, please check inputs.',
+    SCI_MISSING_FN_UNIT: (functionalUnit) => `'carbon' and ${functionalUnit} should be present in your input data.`,
+    MISSING_FUNCTIONAL_UNIT_CONFIG: '`functional-unit` should be provided in your global config',
+    MISSING_FUNCTIONAL_UNIT_INPUT: '`functional-unit` value is missing from input data or it is not a positive integer',
+    REGEX_MISMATCH: (input, match) => `\`${input}\` does not match the ${match} regex expression`,
+    SCI_EMBODIED_ERROR: (unit) => `invalid number. please provide it as \`${unit}\` to input`,
+    MISSING_MIN_MAX: 'Config is missing min or max value',
+    INVALID_MIN_MAX: (name) => `Min value should not be greater than or equal to max value of ${name}`,
+    FILE_FETCH_FAILED: (filepath, message) => `Failed fetching the file: ${filepath}.
+${message}`,
+    FILE_READ_FAILED: (filepath, error) => `Failed reading the file: ${filepath}. 
+${error}`,
+    ZERO_DIVISION: (moduleName, index) => `-- SKIPPING -- DivisionByZero: you are attempting to divide by zero in ${moduleName} plugin : inputs[${index}]\n`,
+    MISSING_GLOBAL_CONFIG: 'Global config is not provided.',
+    MISSING_INPUT_DATA: (param) => `${param} is missing from the input array, or has nullish value.`,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../../src/if-run/config/strings.ts"],"names":[],"mappings":"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","sourcesContent":["export const STRINGS = {\n  MISSING_METHOD: \"Initalization param 'method' is missing.\",\n  MISSING_PATH: \"Initalization param 'path' is missing.\",\n  UNSUPPORTED_PLUGIN:\n    \"Plugin interface doesn't implement 'execute' or 'metadata' methods.\",\n  NOT_NATIVE_PLUGIN: (path: string) =>\n    `\n  You are using plugin ${path} which is not part of the Impact Framework standard library. You should do your own research to ensure the plugins are up to date and accurate. They may not be actively maintained.`,\n  INVALID_MODULE_PATH: (path: string, error?: any) =>\n    `Provided module \\`${path}\\` is invalid or not found. ${error ?? ''}\n`,\n  INVALID_TIME_NORMALIZATION: 'Start time or end time is missing.',\n  UNEXPECTED_TIME_CONFIG:\n    'Unexpected node-level config provided for time-sync plugin.',\n  INVALID_TIME_INTERVAL: 'Interval is missing.',\n  AVOIDING_PADDING: (description: string) =>\n    `Avoiding padding at ${description}`,\n  AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) =>\n    `Avoiding padding at ${\n      start && end ? 'start and end' : start ? 'start' : 'end'\n    }`,\n  INVALID_AGGREGATION_METHOD: (metric: string) =>\n    `Aggregation is not possible for given ${metric} since method is 'none'.`,\n  METRIC_MISSING: (metric: string, index: number) =>\n    `Aggregation metric ${metric} is not found in inputs[${index}].`,\n  INVALID_GROUP_KEY: (key: string) => `Invalid group ${key}.`,\n  REGROUP_ERROR: 'not an array or should contain at least one key',\n  INVALID_EXHAUST_PLUGIN: (pluginName: string) =>\n    `Invalid exhaust plugin: ${pluginName}.`,\n  UNKNOWN_PARAM: (name: string) =>\n    `Unknown parameter: ${name}. Omitting from the output.`,\n  NOT_INITALIZED_PLUGIN: (name: string) =>\n    `Not initalized plugin: ${name}. Check if ${name} is in 'manifest.initalize.plugins'.`,\n  NO_OUTPUT: `\nYou have not added an output command: \n--output <savepath>: will save your output data to the given filepath (do not provide file extension)\nNote that for the '--output' option you also need to define the output type in your manifest file. See https://if.greensoftware.foundation/major-concepts/manifest-file#initialize`,\n  UNSUPPORTED_ERROR: (errorName: string) =>\n    `UnsupportedErrorClass: plugin threw error class: ${errorName} that is not recognized by Impact Framework`,\n  /** Debugging logs */\n  STARTING_IF: 'Starting IF',\n  EXITING_IF: 'Exiting IF',\n  LOADING_MANIFEST: 'Loading manifest',\n  VALIDATING_MANIFEST: 'Validating manifest',\n  CAPTURING_RUNTIME_ENVIRONMENT_DATA: 'Capturing runtime environment data',\n  CHECKING_AGGREGATION_METHOD: (unitName: string) =>\n    `Checking aggregation method for ${unitName}`,\n  INITIALIZING_PLUGINS: 'Initializing plugins',\n  INITIALIZING_PLUGIN: (pluginName: string) => `Initializing ${pluginName}`,\n  LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) =>\n    `Loading ${pluginName} from ${path}`,\n  COMPUTING_PIPELINE_FOR_NODE: (nodeName: string) =>\n    `Computing pipeline for \\`${nodeName}\\``,\n  MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',\n  AGGREGATING_OUTPUTS: 'Aggregating outputs',\n  AGGREGATING_NODE: (nodeName: string) => `Aggregating node ${nodeName}`,\n  PREPARING_OUTPUT_DATA: 'Preparing output data',\n  EXPORTING_TO_YAML_FILE: (savepath: string) =>\n    `Exporting to yaml file: ${savepath}`,\n  EMPTY_PIPELINE: `You're using an old style manifest. Please update for phased execution. More information can be found here: \nhttps://if.greensoftware.foundation/major-concepts/manifest-file`,\n  /** Exhaust messages */\n  OUTPUT_REQUIRED:\n    'Output path is required, please make sure output is configured properly.',\n  /** Plugins messages */\n  INVALID_NAME:\n    '`name` global config parameter is empty or contains all spaces',\n  START_LOWER_END: '`start-time` should be lower than `end-time`',\n  TIMESTAMP_REQUIRED: (index: number) => `required in input[${index}]`,\n  INVALID_DATETIME: (index: number) => `invalid datetime in input[${index}]`,\n  X_Y_EQUAL: 'The length of `x` and `y` should be equal',\n  ARRAY_LENGTH_NON_EMPTY:\n    'the length of the input arrays must be greater than 1',\n  WITHIN_THE_RANGE:\n    'The target x value must be within the range of the given x values',\n  MISSING_CSV_COLUMN: (columnName: string) =>\n    `There is no column with the name: ${columnName}.`,\n  NO_QUERY_DATA:\n    'One or more of the given query parameters are not found in the target CSV file column headers.',\n  INVALID_DATE_TYPE: (date: any) =>\n    `Unexpected date datatype: ${typeof date}: ${date}`,\n  INVALID_OBSERVATION_OVERLAP:\n    'Observation timestamps overlap, please check inputs.',\n  SCI_MISSING_FN_UNIT: (functionalUnit: string) =>\n    `'carbon' and ${functionalUnit} should be present in your input data.`,\n  MISSING_FUNCTIONAL_UNIT_CONFIG:\n    '`functional-unit` should be provided in your global config',\n  MISSING_FUNCTIONAL_UNIT_INPUT:\n    '`functional-unit` value is missing from input data or it is not a positive integer',\n  REGEX_MISMATCH: (input: any, match: string) =>\n    `\\`${input}\\` does not match the ${match} regex expression`,\n  SCI_EMBODIED_ERROR: (unit: string) =>\n    `invalid number. please provide it as \\`${unit}\\` to input`,\n  MISSING_MIN_MAX: 'Config is missing min or max value',\n  INVALID_MIN_MAX: (name: string) =>\n    `Min value should not be greater than or equal to max value of ${name}`,\n  FILE_FETCH_FAILED: (\n    filepath: string,\n    message: string\n  ) => `Failed fetching the file: ${filepath}.\n${message}`,\n  FILE_READ_FAILED: (\n    filepath: string,\n    error: string\n  ) => `Failed reading the file: ${filepath}. \n${error}`,\n  ZERO_DIVISION: (moduleName: string, index: number) =>\n    `-- SKIPPING -- DivisionByZero: you are attempting to divide by zero in ${moduleName} plugin : inputs[${index}]\\n`,\n  MISSING_GLOBAL_CONFIG: 'Global config is not provided.',\n  MISSING_INPUT_DATA: (param: string) =>\n    `${param} is missing from the input array, or has nullish value.`,\n};\n"]}

package/build/if-run/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/if-run/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../common/config");
+const validations_1 = require("../common/util/validations");
+const debug_logger_1 = require("../common/util/debug-logger");
+const logger_1 = require("../common/util/logger");
+const load_1 = require("../common/lib/load");
+const aggregate_1 = require("./lib/aggregate");
+const environment_1 = require("./lib/environment");
+const initialize_1 = require("./lib/initialize");
+const compute_1 = require("./lib/compute");
+const exhaust_1 = require("./lib/exhaust");
+const explain_1 = require("./lib/explain");
+const aggregation_1 = require("./types/aggregation");
+const args_1 = require("./util/args");
+const helpers_1 = require("./util/helpers");
+const config_2 = require("./config");
+const { EXITING_IF, STARTING_IF } = config_2.STRINGS;
+const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+const impactEngine = async () => {
+    const options = (0, args_1.parseIfRunProcessArgs)();
+    const { inputPath, outputOptions, debug, observe, regroup, compute: computeFlag, } = options;
+    debug_logger_1.debugLogger.overrideConsoleMethods(!!debug);
+    logger_1.logger.info(DISCLAIMER_MESSAGE);
+    console.info(STARTING_IF);
+    const { rawManifest } = await (0, load_1.load)(inputPath);
+    const envManifest = await (0, environment_1.injectEnvironment)(rawManifest);
+    try {
+        const { tree, ...context } = (0, validations_1.validateManifest)(envManifest);
+        if (context.aggregation) {
+            const convertMetrics = context.aggregation?.metrics.map((metric) => ({
+                [metric]: aggregation_1.AGGREGATION_METHODS[2],
+            }));
+            (0, aggregate_1.storeAggregationMetrics)(...convertMetrics);
+        }
+        const pluginStorage = await (0, initialize_1.initialize)(context);
+        const computedTree = await (0, compute_1.compute)(tree, {
+            context,
+            pluginStorage,
+            observe,
+            regroup,
+            compute: computeFlag,
+        });
+        const aggregatedTree = (0, aggregate_1.aggregate)(computedTree, context.aggregation);
+        envManifest.explainer && (context.explain = (0, explain_1.explain)());
+        await (0, exhaust_1.exhaust)(aggregatedTree, context, outputOptions);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            envManifest.execution.status = 'fail';
+            envManifest.execution.error = error.toString();
+            logger_1.logger.error(error);
+            const { tree, ...context } = envManifest;
+            if (error.name !== 'ExhaustError') {
+                (0, exhaust_1.exhaust)(tree, context, outputOptions);
+            }
+        }
+    }
+    console.info(EXITING_IF);
+};
+impactEngine().catch(helpers_1.andHandle);
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/lib/aggregate.d.ts

@@ -0,0 +1,15 @@
+import { AggregationParams, AggregationMetricsWithMethod } from '../../common/types/manifest';
+import { AggregationMetric } from '../types/aggregation';
+/**
+ * If aggregation is disabled, then returns given `tree`.
+ * Otherwise creates copy of the tree, then applies aggregation to it.
+ */
+export declare const aggregate: (tree: any, aggregationParams: AggregationParams) => any;
+/**
+ * Gets or stores aggregation metrics.
+ */
+export declare const storeAggregationMetrics: (aggregationMetrics?: AggregationMetricsWithMethod) => AggregationMetric;
+/**
+ * Returns aggregation method for given `unitName`. If doesn't exist then returns value `sum`.
+ */
+export declare const getAggregationMethod: (unitName: string) => import("../types/aggregation").AggregationMethodTypes | undefined;

package/build/if-run/lib/aggregate.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAggregationMethod = exports.storeAggregationMetrics = exports.aggregate = void 0;
+const debug_logger_1 = require("../../common/util/debug-logger");
+const logger_1 = require("../../common/util/logger");
+const aggregation_helper_1 = require("../util/aggregation-helper");
+const log_memoize_1 = require("../util/log-memoize");
+const strings_1 = require("../config/strings");
+const { AGGREGATING_NODE, AGGREGATING_OUTPUTS, UNKNOWN_PARAM, CHECKING_AGGREGATION_METHOD, } = strings_1.STRINGS;
+/**
+ * Gets `i`th element from all children outputs and collects them in single array.
+ */
+const getIthElementsFromChildren = (children, i) => {
+    const values = Object.values(children);
+    return values.map((value) => {
+        const output = value.outputs;
+        return output[i];
+    });
+};
+/**
+ * 1. Gets the i'th element from each childrens outputs (treating children as rows and we are after a column of data).
+ * 2. Now we just aggregate over the `ithSliceOfOutputs` the same as we did for the normal outputs.
+ */
+const temporalAggregation = (node, metrics) => {
+    const outputs = [];
+    const values = Object.values(node.children);
+    for (let i = 0; i < values[0].outputs.length; i++) {
+        const ithSliceOfOutputs = getIthElementsFromChildren(node.children, i);
+        outputs.push((0, aggregation_helper_1.aggregateInputsIntoOne)(ithSliceOfOutputs, metrics, true));
+    }
+    return outputs;
+};
+/**
+ * Navigates the tree depth first, bottom up,
+ *  left to right aggregating the component nodes and then the grouping nodes will be aggregated
+ *  only when all their child nodes have been aggregated.
+ * 1. Aggregates all the children.
+ * 2. At this point you can be positive all your children have been aggregated and so you can now work on aggregating yourself.
+ * 3. It's component node, аggregates just the outputs of THIS component node (horizontal/component aggregation).
+ * 4. Else it's grouping node, first does temporal aggregation. This assumes everything is on the same time-grid.
+ *    The outputs of the grouping node are the aggregated time bucketed outputs of it's children.
+ * 5. Now a grouping node has it's own outputs, it can horizotnally aggregate them.
+ */
+const aggregateNode = (node, aggregationParams) => {
+    const metrics = aggregationParams.metrics.map(metric => ({ [metric]: 'none' }));
+    const type = aggregationParams.type;
+    if (node.children) {
+        for (const child in node.children) {
+            console.debug(AGGREGATING_NODE(child));
+            aggregateNode(node.children[child], aggregationParams);
+        }
+    }
+    if (!node.children) {
+        if (type === 'horizontal' || type === 'both') {
+            node.aggregated = (0, aggregation_helper_1.aggregateInputsIntoOne)(node.outputs, metrics);
+        }
+    }
+    else {
+        if (type === 'vertical' || type === 'both') {
+            const outputs = temporalAggregation(node, metrics);
+            node.outputs = outputs;
+            node.aggregated = (0, aggregation_helper_1.aggregateInputsIntoOne)(outputs, metrics);
+        }
+    }
+};
+/**
+ * If aggregation is disabled, then returns given `tree`.
+ * Otherwise creates copy of the tree, then applies aggregation to it.
+ */
+const aggregate = (tree, aggregationParams) => {
+    console.debug(AGGREGATING_OUTPUTS);
+    if (!aggregationParams || !aggregationParams.type) {
+        return tree;
+    }
+    const copyOfTree = structuredClone(tree);
+    aggregateNode(copyOfTree, aggregationParams);
+    return copyOfTree;
+};
+exports.aggregate = aggregate;
+/**
+ * Gets or stores aggregation metrics.
+ */
+const storeAggregationMetrics = (aggregationMetrics) => {
+    if (aggregationMetrics) {
+        metricManager.metrics = {
+            ...metricManager.metrics,
+            ...aggregationMetrics,
+        };
+    }
+    return metricManager.metrics;
+};
+exports.storeAggregationMetrics = storeAggregationMetrics;
+/**
+ * Creates an encapsulated object to retrieve the metrics.
+ */
+const metricManager = (() => {
+    let metric;
+    const manager = {
+        get metrics() {
+            return metric;
+        },
+        set metrics(value) {
+            metric = value;
+        },
+    };
+    return manager;
+})();
+/**
+ * Returns aggregation method for given `unitName`. If doesn't exist then returns value `sum`.
+ */
+const getAggregationMethod = (unitName) => {
+    debug_logger_1.debugLogger.setExecutingPluginName();
+    (0, log_memoize_1.memoizedLog)(console.debug, CHECKING_AGGREGATION_METHOD(unitName));
+    const aggregationMetricsStorage = (0, exports.storeAggregationMetrics)();
+    if (aggregationMetricsStorage &&
+        Object.keys(aggregationMetricsStorage).includes(unitName)) {
+        return aggregationMetricsStorage[unitName];
+    }
+    (0, log_memoize_1.memoizedLog)(logger_1.logger.warn, UNKNOWN_PARAM(unitName));
+    return undefined;
+};
+exports.getAggregationMethod = getAggregationMethod;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregate.js","sourceRoot":"","sources":["../../../src/if-run/lib/aggregate.ts"],"names":[],"mappings":"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","sourcesContent":["import {PluginParams} from '@grnsft/if-core/types';\n\nimport {debugLogger} from '../../common/util/debug-logger';\nimport {logger} from '../../common/util/logger';\nimport {\n  AggregationParams,\n  AggregationParamsSure,\n  AggregationMetricsWithMethod,\n} from '../../common/types/manifest';\n\nimport {aggregateInputsIntoOne} from '../util/aggregation-helper';\nimport {memoizedLog} from '../util/log-memoize';\n\nimport {AggregationMetric} from '../types/aggregation';\n\nimport {STRINGS} from '../config/strings';\n\nconst {\n  AGGREGATING_NODE,\n  AGGREGATING_OUTPUTS,\n  UNKNOWN_PARAM,\n  CHECKING_AGGREGATION_METHOD,\n} = STRINGS;\n\n/**\n * Gets `i`th element from all children outputs and collects them in single array.\n */\nconst getIthElementsFromChildren = (children: any, i: number) => {\n  const values = Object.values(children);\n\n  return values.map((value: any) => {\n    const output = value.outputs;\n\n    return output[i];\n  });\n};\n\n/**\n * 1. Gets the i'th element from each childrens outputs (treating children as rows and we are after a column of data).\n * 2. Now we just aggregate over the `ithSliceOfOutputs` the same as we did for the normal outputs.\n */\nconst temporalAggregation = (node: any, metrics: AggregationMetric[]) => {\n  const outputs: PluginParams[] = [];\n  const values: any = Object.values(node.children);\n\n  for (let i = 0; i < values[0].outputs.length; i++) {\n    const ithSliceOfOutputs = getIthElementsFromChildren(node.children, i);\n    outputs.push(aggregateInputsIntoOne(ithSliceOfOutputs, metrics, true));\n  }\n\n  return outputs;\n};\n\n/**\n * Navigates the tree depth first, bottom up,\n *  left to right aggregating the component nodes and then the grouping nodes will be aggregated\n *  only when all their child nodes have been aggregated.\n * 1. Aggregates all the children.\n * 2. At this point you can be positive all your children have been aggregated and so you can now work on aggregating yourself.\n * 3. It's component node, аggregates just the outputs of THIS component node (horizontal/component aggregation).\n * 4. Else it's grouping node, first does temporal aggregation. This assumes everything is on the same time-grid.\n *    The outputs of the grouping node are the aggregated time bucketed outputs of it's children.\n * 5. Now a grouping node has it's own outputs, it can horizotnally aggregate them.\n */\nconst aggregateNode = (node: any, aggregationParams: AggregationParamsSure) => {\n  const metrics: AggregationMetric[] = aggregationParams!.metrics.map(\n    metric => ({[metric]: 'none'})\n  );\n  const type = aggregationParams!.type;\n\n  if (node.children) {\n    for (const child in node.children) {\n      console.debug(AGGREGATING_NODE(child));\n\n      aggregateNode(node.children[child], aggregationParams);\n    }\n  }\n\n  if (!node.children) {\n    if (type === 'horizontal' || type === 'both') {\n      node.aggregated = aggregateInputsIntoOne(node.outputs, metrics);\n    }\n  } else {\n    if (type === 'vertical' || type === 'both') {\n      const outputs = temporalAggregation(node, metrics);\n      node.outputs = outputs;\n      node.aggregated = aggregateInputsIntoOne(outputs, metrics);\n    }\n  }\n};\n\n/**\n * If aggregation is disabled, then returns given `tree`.\n * Otherwise creates copy of the tree, then applies aggregation to it.\n */\nexport const aggregate = (tree: any, aggregationParams: AggregationParams) => {\n  console.debug(AGGREGATING_OUTPUTS);\n\n  if (!aggregationParams || !aggregationParams.type) {\n    return tree;\n  }\n\n  const copyOfTree = structuredClone(tree);\n  aggregateNode(copyOfTree, aggregationParams);\n\n  return copyOfTree;\n};\n\n/**\n * Gets or stores aggregation metrics.\n */\nexport const storeAggregationMetrics = (\n  aggregationMetrics?: AggregationMetricsWithMethod\n) => {\n  if (aggregationMetrics) {\n    metricManager.metrics = {\n      ...metricManager.metrics,\n      ...aggregationMetrics,\n    };\n  }\n\n  return metricManager.metrics;\n};\n\n/**\n * Creates an encapsulated object to retrieve the metrics.\n */\nconst metricManager = (() => {\n  let metric: AggregationMetric;\n\n  const manager = {\n    get metrics() {\n      return metric;\n    },\n    set metrics(value: AggregationMetric) {\n      metric = value;\n    },\n  };\n\n  return manager;\n})();\n\n/**\n * Returns aggregation method for given `unitName`. If doesn't exist then returns value `sum`.\n */\nexport const getAggregationMethod = (unitName: string) => {\n  debugLogger.setExecutingPluginName();\n  memoizedLog(console.debug, CHECKING_AGGREGATION_METHOD(unitName));\n  const aggregationMetricsStorage = storeAggregationMetrics();\n\n  if (\n    aggregationMetricsStorage &&\n    Object.keys(aggregationMetricsStorage).includes(unitName)\n  ) {\n    return aggregationMetricsStorage[unitName];\n  }\n\n  memoizedLog(logger.warn, UNKNOWN_PARAM(unitName));\n\n  return undefined;\n};\n"]}

package/build/if-run/lib/compute.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compute = void 0;
+const regroup_1 = require("./regroup");
+const explain_1 = require("./explain");
+const helpers_1 = require("../util/helpers");
+const debug_logger_1 = require("../../common/util/debug-logger");
+const logger_1 = require("../../common/util/logger");
+const strings_1 = require("../config/strings");
+const interface_1 = require("../types/interface");
+const { MERGING_DEFAULTS_WITH_INPUT_DATA, EMPTY_PIPELINE } = strings_1.STRINGS;
+/**
+ * Traverses all child nodes based on children grouping.
+ */
+const traverse = async (children, params) => {
+    for (const child in children) {
+        await computeNode(children[child], params);
+    }
+};
+/**
+ * Appends `default` values to `inputs`.
+ */
+const mergeDefaults = (inputs, defaults) => {
+    if (inputs) {
+        const response = defaults
+            ? inputs.map(input => (0, helpers_1.mergeObjects)(defaults, input))
+            : inputs;
+        return response;
+    }
+    console.debug(MERGING_DEFAULTS_WITH_INPUT_DATA);
+    return defaults ? [defaults] : [];
+};
+/**
+ * 1. If the node has it's own pipeline, defaults or config then use that,
+ *    otherwise use whatever has been passed down from further up the tree.
+ * 2. If it's a grouping node, then first of all computes all it's children.
+ *    This is doing a depth first traversal.
+ * 3. Otherwise merges the defaults into the inputs.
+ * 4. Iterates over pipeline phases (observe, regroup, compute).
+ * 5. Observe plugins are used to insert input values
+ *    (isolated execution can be achived by passing `--observe` flag to CLI command).
+ * 6. Regroup plugin is used to group existing inputs by criteria
+ *    (isolated execution can be achived by passing `--regroup` flag to CLI command).
+ *    Since it creates new children for node, existing inputs and outputs are dropped and recursive traversal is called
+ *    for newbord child component.
+ * 7. Compute plugins are used to do desired computations and appending the result to outputs
+ *    (isolated execution can be achived by passing `--compute` flag to CLI command).
+ */
+const computeNode = async (node, params) => {
+    const pipeline = node.pipeline || params.pipeline;
+    const config = node.config || params.config;
+    const defaults = node.defaults || params.defaults;
+    const noFlags = !params.observe && !params.regroup && !params.compute;
+    if (node.children) {
+        return traverse(node.children, {
+            ...params,
+            pipeline,
+            defaults,
+            config,
+        });
+    }
+    let inputStorage = structuredClone(node.inputs);
+    inputStorage = mergeDefaults(inputStorage, defaults);
+    const pipelineCopy = structuredClone(pipeline) || {};
+    /** Checks if pipeline is not an array or empty object. */
+    if (Array.isArray(pipelineCopy) ||
+        (typeof pipelineCopy === 'object' &&
+            pipelineCopy !== null &&
+            Object.keys(pipelineCopy).length === 0)) {
+        logger_1.logger.warn(EMPTY_PIPELINE);
+    }
+    /**
+     * If iteration is on observe pipeline, then executes observe plugins and sets the inputs value.
+     */
+    if ((noFlags || params.observe) && pipelineCopy.observe) {
+        while (pipelineCopy.observe.length !== 0) {
+            const pluginName = pipelineCopy.observe.shift();
+            const plugin = params.pluginStorage.get(pluginName);
+            const nodeConfig = config && config[pluginName];
+            if ((0, interface_1.isExecute)(plugin)) {
+                inputStorage = await plugin.execute(inputStorage, nodeConfig);
+                node.inputs = inputStorage;
+                if (params.context.explainer) {
+                    (0, explain_1.addExplainData)({
+                        pluginName,
+                        metadata: plugin.metadata,
+                        pluginData: params.context.initialize.plugins[pluginName],
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * If regroup is requested, execute regroup strategy, delete child's inputs, outputs and empty regroup array.
+     */
+    if ((noFlags || params.regroup) && pipelineCopy.regroup) {
+        node.children = (0, regroup_1.Regroup)(inputStorage, pipelineCopy.regroup);
+        delete node.inputs;
+        delete node.outputs;
+        return traverse(node.children, {
+            ...params,
+            pipeline: {
+                ...pipelineCopy,
+                regroup: undefined,
+            },
+            defaults,
+            config,
+        });
+    }
+    /**
+     * If iteration is on compute plugin, then executes compute plugins and sets the outputs value.
+     */
+    if ((noFlags || params.compute) && pipelineCopy.compute) {
+        while (pipelineCopy.compute.length !== 0) {
+            const pluginName = pipelineCopy.compute.shift();
+            const plugin = params.pluginStorage.get(pluginName);
+            const nodeConfig = config && config[pluginName];
+            if ((0, interface_1.isExecute)(plugin)) {
+                inputStorage = await plugin.execute(inputStorage, nodeConfig);
+                node.outputs = inputStorage;
+                if (params.context.explainer) {
+                    (0, explain_1.addExplainData)({
+                        pluginName,
+                        metadata: plugin.metadata,
+                        pluginData: params.context.initialize.plugins[pluginName],
+                    });
+                }
+                debug_logger_1.debugLogger.setExecutingPluginName();
+            }
+        }
+    }
+};
+/**
+ * Creates copy of existing tree, then applies computing strategy.
+ */
+const compute = async (tree, params) => {
+    const copyOfTree = structuredClone(tree);
+    await computeNode(copyOfTree, params);
+    return copyOfTree;
+};
+exports.compute = compute;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../../src/if-run/lib/compute.ts"],"names":[],"mappings":"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","sourcesContent":["import {PluginParams} from '@grnsft/if-core/types';\n\nimport {Regroup} from './regroup';\nimport {addExplainData} from './explain';\n\nimport {mergeObjects} from '../util/helpers';\nimport {debugLogger} from '../../common/util/debug-logger';\nimport {logger} from '../../common/util/logger';\n\nimport {STRINGS} from '../config/strings';\n\nimport {ComputeParams, Node, PhasedPipeline} from '../types/compute';\nimport {isExecute} from '../types/interface';\n\nconst {MERGING_DEFAULTS_WITH_INPUT_DATA, EMPTY_PIPELINE} = STRINGS;\n\n/**\n * Traverses all child nodes based on children grouping.\n */\nconst traverse = async (children: any, params: ComputeParams) => {\n  for (const child in children) {\n    await computeNode(children[child], params);\n  }\n};\n\n/**\n * Appends `default` values to `inputs`.\n */\nconst mergeDefaults = (\n  inputs: PluginParams[],\n  defaults: PluginParams | undefined\n) => {\n  if (inputs) {\n    const response = defaults\n      ? inputs.map(input => mergeObjects(defaults, input))\n      : inputs;\n\n    return response;\n  }\n\n  console.debug(MERGING_DEFAULTS_WITH_INPUT_DATA);\n\n  return defaults ? [defaults] : [];\n};\n\n/**\n * 1. If the node has it's own pipeline, defaults or config then use that,\n *    otherwise use whatever has been passed down from further up the tree.\n * 2. If it's a grouping node, then first of all computes all it's children.\n *    This is doing a depth first traversal.\n * 3. Otherwise merges the defaults into the inputs.\n * 4. Iterates over pipeline phases (observe, regroup, compute).\n * 5. Observe plugins are used to insert input values\n *    (isolated execution can be achived by passing `--observe` flag to CLI command).\n * 6. Regroup plugin is used to group existing inputs by criteria\n *    (isolated execution can be achived by passing `--regroup` flag to CLI command).\n *    Since it creates new children for node, existing inputs and outputs are dropped and recursive traversal is called\n *    for newbord child component.\n * 7. Compute plugins are used to do desired computations and appending the result to outputs\n *    (isolated execution can be achived by passing `--compute` flag to CLI command).\n */\nconst computeNode = async (node: Node, params: ComputeParams): Promise<any> => {\n  const pipeline = node.pipeline || (params.pipeline as PhasedPipeline);\n  const config = node.config || params.config;\n  const defaults = node.defaults || params.defaults;\n  const noFlags = !params.observe && !params.regroup && !params.compute;\n\n  if (node.children) {\n    return traverse(node.children, {\n      ...params,\n      pipeline,\n      defaults,\n      config,\n    });\n  }\n\n  let inputStorage = structuredClone(node.inputs) as PluginParams[];\n  inputStorage = mergeDefaults(inputStorage, defaults);\n  const pipelineCopy = structuredClone(pipeline) || {};\n\n  /** Checks if pipeline is not an array or empty object. */\n  if (\n    Array.isArray(pipelineCopy) ||\n    (typeof pipelineCopy === 'object' &&\n      pipelineCopy !== null &&\n      Object.keys(pipelineCopy).length === 0)\n  ) {\n    logger.warn(EMPTY_PIPELINE);\n  }\n\n  /**\n   * If iteration is on observe pipeline, then executes observe plugins and sets the inputs value.\n   */\n  if ((noFlags || params.observe) && pipelineCopy.observe) {\n    while (pipelineCopy.observe.length !== 0) {\n      const pluginName = pipelineCopy.observe.shift() as string;\n      const plugin = params.pluginStorage.get(pluginName);\n      const nodeConfig = config && config[pluginName];\n\n      if (isExecute(plugin)) {\n        inputStorage = await plugin.execute(inputStorage, nodeConfig);\n        node.inputs = inputStorage;\n\n        if (params.context.explainer) {\n          addExplainData({\n            pluginName,\n            metadata: plugin.metadata,\n            pluginData: params.context.initialize!.plugins[pluginName],\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * If regroup is requested, execute regroup strategy, delete child's inputs, outputs and empty regroup array.\n   */\n  if ((noFlags || params.regroup) && pipelineCopy.regroup) {\n    node.children = Regroup(inputStorage, pipelineCopy.regroup);\n    delete node.inputs;\n    delete node.outputs;\n\n    return traverse(node.children, {\n      ...params,\n      pipeline: {\n        ...pipelineCopy,\n        regroup: undefined,\n      },\n      defaults,\n      config,\n    });\n  }\n\n  /**\n   * If iteration is on compute plugin, then executes compute plugins and sets the outputs value.\n   */\n  if ((noFlags || params.compute) && pipelineCopy.compute) {\n    while (pipelineCopy.compute.length !== 0) {\n      const pluginName = pipelineCopy.compute.shift() as string;\n      const plugin = params.pluginStorage.get(pluginName);\n      const nodeConfig = config && config[pluginName];\n\n      if (isExecute(plugin)) {\n        inputStorage = await plugin.execute(inputStorage, nodeConfig);\n        node.outputs = inputStorage;\n\n        if (params.context.explainer) {\n          addExplainData({\n            pluginName,\n            metadata: plugin.metadata,\n            pluginData: params.context.initialize!.plugins[pluginName],\n          });\n        }\n        debugLogger.setExecutingPluginName();\n      }\n    }\n  }\n};\n\n/**\n * Creates copy of existing tree, then applies computing strategy.\n */\nexport const compute = async (tree: any, params: ComputeParams) => {\n  const copyOfTree = structuredClone(tree);\n\n  await computeNode(copyOfTree, params);\n\n  return copyOfTree;\n};\n"]}

package/build/{lib → if-run/lib}/environment.d.ts

@@ -1,4 +1,4 @@
-import { Manifest } from '../types/manifest';
+import { Manifest } from '../../common/types/manifest';
 /**
  * Injects execution information (command, environment) to existing manifest.
  */