@grnsft/if 0.7.0-beta.0 → 0.7.1

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

@@ -0,0 +1,2 @@
+export { CONFIG } from './config';
+export { STRINGS } from './strings';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = exports.CONFIG = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "CONFIG", { enumerable: true, get: function () { return config_1.CONFIG; } });
+var strings_1 = require("./strings");
+Object.defineProperty(exports, "STRINGS", { enumerable: true, get: function () { return strings_1.STRINGS; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaWYtcnVuL2NvbmZpZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtQ0FBZ0M7QUFBeEIsZ0dBQUEsTUFBTSxPQUFBO0FBQ2QscUNBQWtDO0FBQTFCLGtHQUFBLE9BQU8sT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7Q09ORklHfSBmcm9tICcuL2NvbmZpZyc7XG5leHBvcnQge1NUUklOR1N9IGZyb20gJy4vc3RyaW5ncyc7XG4iXX0=

package/build/if-run/config/strings.d.ts

@@ -0,0 +1,62 @@
+export declare const STRINGS: {
+    MISSING_METHOD: string;
+    MISSING_PATH: string;
+    NOT_NATIVE_PLUGIN: (path: string) => string;
+    INVALID_MODULE_PATH: (path: string, error?: any) => string;
+    INCOMPATIBLE_RESOLUTION_WITH_INTERVAL: string;
+    INCOMPATIBLE_RESOLUTION_WITH_INPUTS: string;
+    INCOMPATIBLE_RESOLUTION_WITH_GAPS: string;
+    UNEXPECTED_TIME_CONFIG: string;
+    AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) => string;
+    METRIC_MISSING: (metric: string, index: number) => string;
+    INVALID_GROUP_KEY: (key: string) => string;
+    REGROUP_ERROR: string;
+    UNKNOWN_PARAM: (name: string) => string;
+    NOT_INITALIZED_PLUGIN: (name: string) => string;
+    NO_OUTPUT: string;
+    UNSUPPORTED_ERROR: (errorName: string) => string;
+    /** Debugging logs */
+    STARTING_IF: string;
+    EXITING_IF: string;
+    LOADING_MANIFEST: string;
+    VALIDATING_MANIFEST: string;
+    CAPTURING_RUNTIME_ENVIRONMENT_DATA: string;
+    CHECKING_AGGREGATION_METHOD: (unitName: string) => string;
+    INITIALIZING_PLUGINS: string;
+    INITIALIZING_PLUGIN: (pluginName: string) => string;
+    LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) => string;
+    COMPUTING_PIPELINE_FOR_NODE: (nodeName: string) => string;
+    COMPUTING_COMPONENT_PIPELINE: (component: string) => string;
+    REGROUPING: string;
+    OBSERVING: (nodeName: string) => string;
+    MERGING_DEFAULTS_WITH_INPUT_DATA: string;
+    AGGREGATING_OUTPUTS: string;
+    AGGREGATING_NODE: (nodeName: string) => string;
+    PREPARING_OUTPUT_DATA: () => string;
+    EXPORTING_TO_YAML_FILE: (savepath: string) => string;
+    EMPTY_PIPELINE: string;
+    /** Exhaust messages */
+    OUTPUT_REQUIRED: string;
+    /** Plugins messages */
+    INVALID_NAME: string;
+    START_LOWER_END: 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;
+    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_CONFIG: string;
+    MISSING_INPUT_DATA: (param: string) => string;
+    CONFIG_WARN: (plugins: string, isMore: boolean) => string;
+};

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

@@ -0,0 +1,81 @@
+"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.",
+    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 ?? ''}
+`,
+    INCOMPATIBLE_RESOLUTION_WITH_INTERVAL: 'The upsampling resolution must be a divisor of the given interval, but the provided value does not satisfy this criteria.',
+    INCOMPATIBLE_RESOLUTION_WITH_INPUTS: 'The upsampling resolution must be a divisor of all inputs durations, but the provided values do not satisfy this criteria.',
+    INCOMPATIBLE_RESOLUTION_WITH_GAPS: 'The upsampling resolution must be a divisor of gaps and paddings in the time-series, but the provided values do not satisfy this criteria.',
+    UNEXPECTED_TIME_CONFIG: 'Unexpected node-level config provided for time-sync plugin.',
+    AVOIDING_PADDING_BY_EDGES: (start, end) => `Avoiding padding at ${start && end ? 'start and end' : start ? 'start' : 'end'}`,
+    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',
+    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}\` instance`,
+    LOADING_PLUGIN_FROM_PATH: (pluginName, path) => `Loading ${pluginName} from ${path}`,
+    COMPUTING_PIPELINE_FOR_NODE: (nodeName) => `Running compute pipeline: \`${nodeName}\` plugin`,
+    COMPUTING_COMPONENT_PIPELINE: (component) => `**Computing \`${component}\` pipeline**`,
+    REGROUPING: 'Regrouping',
+    OBSERVING: (nodeName) => `Running observe pipeline: \`${nodeName}\` plugin`,
+    MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',
+    AGGREGATING_OUTPUTS: 'Aggregating outputs',
+    AGGREGATING_NODE: (nodeName) => `Aggregating node ${nodeName}`,
+    PREPARING_OUTPUT_DATA: () => {
+        console.debug('\n');
+        return '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` config parameter is empty or contains all spaces',
+    START_LOWER_END: '`start-time` should be lower than `end-time`',
+    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 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`,
+    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_CONFIG: 'Config is not provided.',
+    MISSING_INPUT_DATA: (param) => `${param} is missing from the input array, or has nullish value.`,
+    CONFIG_WARN: (plugins, isMore) => {
+        const withoutPlugins = 'You have included node-level config in your manifest. IF no longer supports node-level config. The manifest should be refactored to accept all its node-level config from config or input data.';
+        const withPlugins = `You have included node-level config in your manifest to support \`${plugins}\` plugin${isMore ? 's' : ''}. IF no longer supports node-level config. \`${plugins}\` plugin${isMore ? 's' : ''} should be refactored to accept all its config from config or input data.`;
+        return plugins.length ? withPlugins : withoutPlugins;
+    },
+};
+//# 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  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  INCOMPATIBLE_RESOLUTION_WITH_INTERVAL:\n    'The upsampling resolution must be a divisor of the given interval, but the provided value does not satisfy this criteria.',\n  INCOMPATIBLE_RESOLUTION_WITH_INPUTS:\n    'The upsampling resolution must be a divisor of all inputs durations, but the provided values do not satisfy this criteria.',\n  INCOMPATIBLE_RESOLUTION_WITH_GAPS:\n    'The upsampling resolution must be a divisor of gaps and paddings in the time-series, but the provided values do not satisfy this criteria.',\n  UNEXPECTED_TIME_CONFIG:\n    'Unexpected node-level config provided for time-sync plugin.',\n  AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) =>\n    `Avoiding padding at ${\n      start && end ? 'start and end' : start ? 'start' : 'end'\n    }`,\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  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) =>\n    `Initializing \\`${pluginName}\\` instance`,\n  LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) =>\n    `Loading ${pluginName} from ${path}`,\n  COMPUTING_PIPELINE_FOR_NODE: (nodeName: string) =>\n    `Running compute pipeline: \\`${nodeName}\\` plugin`,\n  COMPUTING_COMPONENT_PIPELINE: (component: string) =>\n    `**Computing \\`${component}\\` pipeline**`,\n  REGROUPING: 'Regrouping',\n  OBSERVING: (nodeName: string) =>\n    `Running observe pipeline: \\`${nodeName}\\` plugin`,\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: () => {\n    console.debug('\\n');\n    return 'Preparing output data';\n  },\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: '`name` config parameter is empty or contains all spaces',\n  START_LOWER_END: '`start-time` should be lower than `end-time`',\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 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  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_CONFIG: 'Config is not provided.',\n  MISSING_INPUT_DATA: (param: string) =>\n    `${param} is missing from the input array, or has nullish value.`,\n  CONFIG_WARN: (plugins: string, isMore: boolean) => {\n    const withoutPlugins =\n      'You have included node-level config in your manifest. IF no longer supports node-level config. The manifest should be refactored to accept all its node-level config from config or input data.';\n    const withPlugins = `You have included node-level config in your manifest to support \\`${plugins}\\` plugin${\n      isMore ? 's' : ''\n    }. IF no longer supports node-level config. \\`${plugins}\\` plugin${\n      isMore ? 's' : ''\n    } should be refactored to accept all its config from config or input data.`;\n\n    return plugins.length ? withPlugins : withoutPlugins;\n  },\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,58 @@
+#!/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 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, append, } = 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);
+        const pluginStorage = await (0, initialize_1.initialize)(context);
+        const computedTree = await (0, compute_1.compute)(tree, {
+            context,
+            pluginStorage,
+            observe,
+            regroup,
+            compute: computeFlag,
+            append,
+        });
+        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) {
+            /** Execution block exists because manifest is already processed. Set's status to `fail`. */
+            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,14 @@
+import { AggregationParams, AggregationMetricsWithMethod } from '../../common/types/manifest';
+/**
+ * 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) => AggregationMetricsWithMethod;
+/**
+ * Returns aggregation method for given `metric`.
+ */
+export declare const getAggregationInfoFor: (metric: string) => import("@grnsft/if-core/types").AggregationOptions;

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAggregationInfoFor = exports.storeAggregationMetrics = exports.aggregate = void 0;
+const consts_1 = require("@grnsft/if-core/consts");
+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.aggregateOutputsIntoOne)(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;
+    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) {
+        /** `time` aggregation is the new name of `horizontal`. */
+        if (type === 'horizontal' || type === 'time' || type === 'both') {
+            node.aggregated = (0, aggregation_helper_1.aggregateOutputsIntoOne)(node.outputs, metrics);
+        }
+    }
+    else {
+        /** `component` aggregation is the new name of `vertical`. */
+        if (type === 'vertical' || type === 'component' || type === 'both') {
+            const outputs = temporalAggregation(node, metrics);
+            node.outputs = outputs;
+            node.aggregated = (0, aggregation_helper_1.aggregateOutputsIntoOne)(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 `metric`.
+ */
+const getAggregationInfoFor = (metric) => {
+    debug_logger_1.debugLogger.setExecutingPluginName();
+    (0, log_memoize_1.memoizedLog)(console.debug, '\n');
+    (0, log_memoize_1.memoizedLog)(console.debug, CHECKING_AGGREGATION_METHOD(metric));
+    const aggregationMetricsStorage = (0, exports.storeAggregationMetrics)();
+    if (aggregationMetricsStorage &&
+        Object.keys(aggregationMetricsStorage).includes(metric)) {
+        return aggregationMetricsStorage[metric];
+    }
+    (0, log_memoize_1.memoizedLog)(logger_1.logger.warn, UNKNOWN_PARAM(metric));
+    return {
+        time: consts_1.AGGREGATION_METHODS[3],
+        component: consts_1.AGGREGATION_METHODS[3],
+    };
+};
+exports.getAggregationInfoFor = getAggregationInfoFor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregate.js","sourceRoot":"","sources":["../../../src/if-run/lib/aggregate.ts"],"names":[],"mappings":";;;AAAA,mDAA2D;AAG3D,iEAA2D;AAC3D,qDAAgD;AAOhD,mEAAmE;AACnE,qDAAgD;AAEhD,+CAA0C;AAE1C,MAAM,EACJ,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,2BAA2B,GAC5B,GAAG,iBAAO,CAAC;AAEZ;;GAEG;AACH,MAAM,0BAA0B,GAAG,CAAC,QAAa,EAAE,CAAS,EAAE,EAAE;IAC9D,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAEvC,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAU,EAAE,EAAE;QAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC;QAE7B,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,mBAAmB,GAAG,CAAC,IAAS,EAAE,OAAiB,EAAE,EAAE;IAC3D,MAAM,OAAO,GAAmB,EAAE,CAAC;IACnC,MAAM,MAAM,GAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAEjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACjD,MAAM,iBAAiB,GAAG,0BAA0B,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACvE,OAAO,CAAC,IAAI,CAAC,IAAA,4CAAuB,EAAC,iBAAiB,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;KACzE;IAED,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,aAAa,GAAG,CAAC,IAAS,EAAE,iBAAwC,EAAE,EAAE;IAC5E,MAAM,OAAO,GAAG,iBAAkB,CAAC,OAAO,CAAC;IAC3C,MAAM,IAAI,GAAG,iBAAkB,CAAC,IAAI,CAAC;IAErC,IAAI,IAAI,CAAC,QAAQ,EAAE;QACjB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;YAEvC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,iBAAiB,CAAC,CAAC;SACxD;KACF;IAED,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;QAClB,0DAA0D;QAC1D,IAAI,IAAI,KAAK,YAAY,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,MAAM,EAAE;YAC/D,IAAI,CAAC,UAAU,GAAG,IAAA,4CAAuB,EAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;SAClE;KACF;SAAM;QACL,6DAA6D;QAC7D,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,MAAM,EAAE;YAClE,MAAM,OAAO,GAAG,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACnD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,IAAI,CAAC,UAAU,GAAG,IAAA,4CAAuB,EAAC,OAAO,EAAE,OAAO,CAAC,CAAC;SAC7D;KACF;AACH,CAAC,CAAC;AAEF;;;GAGG;AACI,MAAM,SAAS,GAAG,CAAC,IAAS,EAAE,iBAAoC,EAAE,EAAE;IAC3E,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAEnC,IAAI,CAAC,iBAAiB,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE;QACjD,OAAO,IAAI,CAAC;KACb;IAED,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACzC,aAAa,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;IAE7C,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAXW,QAAA,SAAS,aAWpB;AAEF;;GAEG;AACI,MAAM,uBAAuB,GAAG,CACrC,kBAAiD,EACjD,EAAE;IACF,IAAI,kBAAkB,EAAE;QACtB,aAAa,CAAC,OAAO,GAAG;YACtB,GAAG,aAAa,CAAC,OAAO;YACxB,GAAG,kBAAkB;SACtB,CAAC;KACH;IAED,OAAO,aAAa,CAAC,OAAO,CAAC;AAC/B,CAAC,CAAC;AAXW,QAAA,uBAAuB,2BAWlC;AAEF;;GAEG;AACH,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE;IAC1B,IAAI,MAAoC,CAAC;IAEzC,MAAM,OAAO,GAAG;QACd,IAAI,OAAO;YACT,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,OAAO,CAAC,KAAmC;YAC7C,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;KACF,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC,EAAE,CAAC;AAEL;;GAEG;AACI,MAAM,qBAAqB,GAAG,CAAC,MAAc,EAAE,EAAE;IACtD,0BAAW,CAAC,sBAAsB,EAAE,CAAC;IACrC,IAAA,yBAAW,EAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACjC,IAAA,yBAAW,EAAC,OAAO,CAAC,KAAK,EAAE,2BAA2B,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,MAAM,yBAAyB,GAAG,IAAA,+BAAuB,GAAE,CAAC;IAE5D,IACE,yBAAyB;QACzB,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EACvD;QACA,OAAO,yBAAyB,CAAC,MAAM,CAAC,CAAC;KAC1C;IAED,IAAA,yBAAW,EAAC,eAAM,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;IAEhD,OAAO;QACL,IAAI,EAAE,4BAAmB,CAAC,CAAC,CAAC;QAC5B,SAAS,EAAE,4BAAmB,CAAC,CAAC,CAAC;KAClC,CAAC;AACJ,CAAC,CAAC;AAnBW,QAAA,qBAAqB,yBAmBhC","sourcesContent":["import {AGGREGATION_METHODS} from '@grnsft/if-core/consts';\nimport {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 {aggregateOutputsIntoOne} from '../util/aggregation-helper';\nimport {memoizedLog} from '../util/log-memoize';\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: string[]) => {\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(aggregateOutputsIntoOne(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 = aggregationParams!.metrics;\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    /** `time` aggregation is the new name of `horizontal`. */\n    if (type === 'horizontal' || type === 'time' || type === 'both') {\n      node.aggregated = aggregateOutputsIntoOne(node.outputs, metrics);\n    }\n  } else {\n    /** `component` aggregation is the new name of `vertical`. */\n    if (type === 'vertical' || type === 'component' || type === 'both') {\n      const outputs = temporalAggregation(node, metrics);\n      node.outputs = outputs;\n      node.aggregated = aggregateOutputsIntoOne(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: AggregationMetricsWithMethod;\n\n  const manager = {\n    get metrics() {\n      return metric;\n    },\n    set metrics(value: AggregationMetricsWithMethod) {\n      metric = value;\n    },\n  };\n\n  return manager;\n})();\n\n/**\n * Returns aggregation method for given `metric`.\n */\nexport const getAggregationInfoFor = (metric: string) => {\n  debugLogger.setExecutingPluginName();\n  memoizedLog(console.debug, '\\n');\n  memoizedLog(console.debug, CHECKING_AGGREGATION_METHOD(metric));\n  const aggregationMetricsStorage = storeAggregationMetrics();\n\n  if (\n    aggregationMetricsStorage &&\n    Object.keys(aggregationMetricsStorage).includes(metric)\n  ) {\n    return aggregationMetricsStorage[metric];\n  }\n\n  memoizedLog(logger.warn, UNKNOWN_PARAM(metric));\n\n  return {\n    time: AGGREGATION_METHODS[3],\n    component: AGGREGATION_METHODS[3],\n  };\n};\n"]}

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

@@ -0,0 +1,5 @@
+import { ComputeParams } from '../types/compute';
+/**
+ * Creates copy of existing tree, then applies computing strategy.
+ */
+export declare const compute: (tree: any, params: ComputeParams) => Promise<any>;

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compute = void 0;
+const regroup_1 = require("./regroup");
+const explain_1 = require("./explain");
+const debug_logger_1 = require("../../common/util/debug-logger");
+const logger_1 = require("../../common/util/logger");
+const helpers_1 = require("../util/helpers");
+const strings_1 = require("../config/strings");
+const { MERGING_DEFAULTS_WITH_INPUT_DATA, EMPTY_PIPELINE, CONFIG_WARN, COMPUTING_PIPELINE_FOR_NODE, COMPUTING_COMPONENT_PIPELINE, REGROUPING, OBSERVING, } = strings_1.STRINGS;
+/**
+ * Traverses all child nodes based on children grouping.
+ */
+const traverse = async (children, params) => {
+    for (const child in children) {
+        console.debug(COMPUTING_COMPONENT_PIPELINE(child));
+        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, '\n');
+    return defaults ? [defaults] : [];
+};
+/**
+ * Warns if the `config` is provided in the manifest.
+ */
+const warnIfConfigProvided = (node) => {
+    if ('config' in node) {
+        const plugins = Object.keys(node.config || {});
+        const joinedPlugins = plugins.join(', ');
+        const isMore = plugins.length > 1;
+        logger_1.logger.warn(CONFIG_WARN(joinedPlugins, isMore));
+    }
+};
+/**
+ * 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;
+    debug_logger_1.debugLogger.setExecutingPluginName();
+    warnIfConfigProvided(node);
+    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();
+            console.debug(OBSERVING(pluginName));
+            debug_logger_1.debugLogger.setExecutingPluginName(pluginName);
+            const plugin = params.pluginStorage.get(pluginName);
+            const nodeConfig = config && config[pluginName];
+            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) {
+        const originalOutputs = params.append ? node.outputs || [] : [];
+        node.children = (0, regroup_1.Regroup)(inputStorage, originalOutputs, pipelineCopy.regroup);
+        delete node.inputs;
+        delete node.outputs;
+        debug_logger_1.debugLogger.setExecutingPluginName();
+        console.debug(REGROUPING);
+        return traverse(node.children, {
+            ...params,
+            pipeline: {
+                ...pipelineCopy,
+                regroup: undefined,
+            },
+            defaults,
+            config,
+        });
+    }
+    console.debug('\n');
+    /**
+     * If iteration is on compute plugin, then executes compute plugins and sets the outputs value.
+     */
+    if ((noFlags || params.compute) && pipelineCopy.compute) {
+        const originalOutputs = params.append ? node.outputs || [] : [];
+        while (pipelineCopy.compute.length !== 0) {
+            const pluginName = pipelineCopy.compute.shift();
+            const plugin = params.pluginStorage.get(pluginName);
+            const nodeConfig = config && config[pluginName];
+            console.debug(COMPUTING_PIPELINE_FOR_NODE(pluginName));
+            debug_logger_1.debugLogger.setExecutingPluginName(pluginName);
+            inputStorage = await plugin.execute(inputStorage, nodeConfig);
+            debug_logger_1.debugLogger.setExecutingPluginName();
+            node.outputs = inputStorage;
+            if (params.context.explainer) {
+                (0, explain_1.addExplainData)({
+                    pluginName,
+                    metadata: plugin.metadata,
+                    pluginData: params.context.initialize.plugins[pluginName],
+                });
+            }
+        }
+        if (params.append) {
+            node.outputs = originalOutputs.concat(node.outputs || []);
+        }
+    }
+    console.debug('\n');
+};
+/**
+ * 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 {debugLogger} from '../../common/util/debug-logger';\nimport {logger} from '../../common/util/logger';\n\nimport {mergeObjects} from '../util/helpers';\n\nimport {STRINGS} from '../config/strings';\n\nimport {ComputeParams, Node, PhasedPipeline} from '../types/compute';\n\nconst {\n  MERGING_DEFAULTS_WITH_INPUT_DATA,\n  EMPTY_PIPELINE,\n  CONFIG_WARN,\n  COMPUTING_PIPELINE_FOR_NODE,\n  COMPUTING_COMPONENT_PIPELINE,\n  REGROUPING,\n  OBSERVING,\n} = 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    console.debug(COMPUTING_COMPONENT_PIPELINE(child));\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\n  return defaults ? [defaults] : [];\n};\n\n/**\n * Warns if the `config` is provided in the manifest.\n */\nconst warnIfConfigProvided = (node: any) => {\n  if ('config' in node) {\n    const plugins = Object.keys(node.config || {});\n    const joinedPlugins = plugins.join(', ');\n    const isMore = plugins.length > 1;\n\n    logger.warn(CONFIG_WARN(joinedPlugins, isMore));\n  }\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  debugLogger.setExecutingPluginName();\n  warnIfConfigProvided(node);\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      console.debug(OBSERVING(pluginName));\n      debugLogger.setExecutingPluginName(pluginName);\n\n      const plugin = params.pluginStorage.get(pluginName);\n      const nodeConfig = config && config[pluginName];\n\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   * 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    const originalOutputs = params.append ? node.outputs || [] : [];\n\n    node.children = Regroup(\n      inputStorage,\n      originalOutputs,\n      pipelineCopy.regroup\n    );\n\n    delete node.inputs;\n    delete node.outputs;\n\n    debugLogger.setExecutingPluginName();\n    console.debug(REGROUPING);\n\n    return traverse(node.children, {\n      ...params,\n      pipeline: {\n        ...pipelineCopy,\n        regroup: undefined,\n      },\n      defaults,\n      config,\n    });\n  }\n\n  console.debug('\\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    const originalOutputs = params.append ? node.outputs || [] : [];\n\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      console.debug(COMPUTING_PIPELINE_FOR_NODE(pluginName));\n      debugLogger.setExecutingPluginName(pluginName);\n\n      inputStorage = await plugin.execute(inputStorage, nodeConfig);\n      debugLogger.setExecutingPluginName();\n\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    }\n\n    if (params.append) {\n      node.outputs = originalOutputs.concat(node.outputs || []);\n    }\n  }\n\n  console.debug('\\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/if-run/lib/environment.d.ts

@@ -0,0 +1,5 @@
+import { Manifest } from '../../common/types/manifest';
+/**
+ * Injects execution information (command, environment) to existing manifest.
+ */
+export declare const injectEnvironment: (manifest: Manifest) => Promise<Manifest>;