@grnsft/if 1.0.2 → 1.1.0

package/build/if-metadata-check/util/metadata-checker.d.ts

@@ -0,0 +1,44 @@
+import { IFPlugin } from '../types/plugin';
+/**
+ * Extracts a set of parameter values from the configurations of the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing configuration data.
+ * @param parameters - Additional parameter keys to extract from the plugin configurations.
+ * @returns A set of parameter values extracted from the plugin configurations.
+ */
+export declare const getParameters: (plugins: IFPlugin[], parameters: string[]) => Set<string>;
+/**
+ * Extracts a set of parameters that have defined metadata from the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing metadata information.
+ * @returns A set of parameter names that have associated metadata.
+ */
+export declare const getParametersWithMetadata: (plugins: IFPlugin[]) => Set<string>;
+/**
+ * Extracts parameters with metadata from a single plugin.
+ *
+ * @param plugin - A plugin object containing metadata information.
+ * @returns An array of parameter names that have associated metadata, including inputs and outputs.
+ */
+export declare const extractParametersWithMetadata: (plugin: IFPlugin) => string[];
+/**
+ * Extracts parameter values from a plugin's configuration based on specified keys.
+ *
+ * @param config - The configuration object of a plugin.
+ * @param keys - An array of keys to look for in the configuration object.
+ * @returns An array of parameter values corresponding to the specified keys.
+ */
+export declare const extractParameters: (config: Record<string, any> | undefined, keys: string[]) => any[];
+/**
+ * Calculates the coverage of metadata for a given set of parameters.
+ *
+ * @param parameterSet - A set of all parameters extracted from plugin configurations.
+ * @param parameterWithMetadataSet - A set of parameters that have associated metadata.
+ * @returns An object containing:
+ *   - `percentage`: The percentage of parameters with metadata coverage.
+ *   - `missingParameters`: An array of parameters that lack metadata coverage.
+ */
+export declare const calculateMetadataCoverage: (parameterSet: Set<string>, parameterWithMetadataSet: Set<string>) => {
+    percentage: number;
+    missingParameters: string[];
+};

package/build/if-metadata-check/util/metadata-checker.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMetadataCoverage = exports.extractParameters = exports.extractParametersWithMetadata = exports.getParametersWithMetadata = exports.getParameters = void 0;
+/**
+ * Extracts a set of parameter values from the configurations of the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing configuration data.
+ * @param parameters - Additional parameter keys to extract from the plugin configurations.
+ * @returns A set of parameter values extracted from the plugin configurations.
+ */
+const getParameters = (plugins, parameters) => {
+    return new Set(plugins.flatMap(plugin => (0, exports.extractParameters)(plugin.config, [
+        'input-parameter',
+        'output-parameter',
+        'input-parameters',
+        'output',
+        ...parameters,
+    ])));
+};
+exports.getParameters = getParameters;
+/**
+ * Extracts a set of parameters that have defined metadata from the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing metadata information.
+ * @returns A set of parameter names that have associated metadata.
+ */
+const getParametersWithMetadata = (plugins) => {
+    return new Set(plugins.flatMap(plugin => (0, exports.extractParametersWithMetadata)(plugin)));
+};
+exports.getParametersWithMetadata = getParametersWithMetadata;
+/**
+ * Extracts parameters with metadata from a single plugin.
+ *
+ * @param plugin - A plugin object containing metadata information.
+ * @returns An array of parameter names that have associated metadata, including inputs and outputs.
+ */
+const extractParametersWithMetadata = (plugin) => {
+    if (!plugin['parameter-metadata'])
+        return [];
+    const { inputs, outputs } = plugin['parameter-metadata'];
+    return [
+        ...(inputs ? Object.keys(inputs) : []),
+        ...(outputs ? Object.keys(outputs) : []),
+    ];
+};
+exports.extractParametersWithMetadata = extractParametersWithMetadata;
+/**
+ * Extracts parameter values from a plugin's configuration based on specified keys.
+ *
+ * @param config - The configuration object of a plugin.
+ * @param keys - An array of keys to look for in the configuration object.
+ * @returns An array of parameter values corresponding to the specified keys.
+ */
+const extractParameters = (config, keys) => {
+    if (!config)
+        return [];
+    return keys.flatMap(key => {
+        if (key in config && isStringOrStringArray(config[key])) {
+            return config[key];
+        }
+        return [];
+    });
+};
+exports.extractParameters = extractParameters;
+/**
+ * Calculates the coverage of metadata for a given set of parameters.
+ *
+ * @param parameterSet - A set of all parameters extracted from plugin configurations.
+ * @param parameterWithMetadataSet - A set of parameters that have associated metadata.
+ * @returns An object containing:
+ *   - `percentage`: The percentage of parameters with metadata coverage.
+ *   - `missingParameters`: An array of parameters that lack metadata coverage.
+ */
+const calculateMetadataCoverage = (parameterSet, parameterWithMetadataSet) => {
+    const totalParameters = parameterSet.size;
+    const parametersWithMetadata = [...parameterSet].filter(param => parameterWithMetadataSet.has(param)).length;
+    const percentage = totalParameters === 0
+        ? 100
+        : (parametersWithMetadata / totalParameters) * 100;
+    const missingParameters = [...parameterSet].filter(parameter => !parameterWithMetadataSet.has(parameter));
+    return { percentage, missingParameters };
+};
+exports.calculateMetadataCoverage = calculateMetadataCoverage;
+/**
+ * Checks if the given parameter is a string or an array of strings.
+ *
+ * @param parameter - The parameter to validate.
+ * @returns `true` if the parameter is a string or an array of strings, otherwise `false`.
+ */
+const isStringOrStringArray = (parameter) => {
+    if (typeof parameter === 'string') {
+        return true;
+    }
+    if (Array.isArray(parameter)) {
+        return parameter.every(item => typeof item === 'string');
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata-checker.js","sourceRoot":"","sources":["../../../src/if-metadata-check/util/metadata-checker.ts"],"names":[],"mappings":"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","sourcesContent":["import {IFPlugin} from '../types/plugin';\n\n/**\n * Extracts a set of parameter values from the configurations of the provided plugins.\n *\n * @param plugins - An array of plugins, each containing configuration data.\n * @param parameters - Additional parameter keys to extract from the plugin configurations.\n * @returns A set of parameter values extracted from the plugin configurations.\n */\nexport const getParameters = (plugins: IFPlugin[], parameters: string[]) => {\n  return new Set<string>(\n    plugins.flatMap(plugin =>\n      extractParameters(plugin.config, [\n        'input-parameter',\n        'output-parameter',\n        'input-parameters',\n        'output',\n        ...parameters,\n      ])\n    )\n  );\n};\n\n/**\n * Extracts a set of parameters that have defined metadata from the provided plugins.\n *\n * @param plugins - An array of plugins, each containing metadata information.\n * @returns A set of parameter names that have associated metadata.\n */\nexport const getParametersWithMetadata = (plugins: IFPlugin[]) => {\n  return new Set<string>(\n    plugins.flatMap(plugin => extractParametersWithMetadata(plugin))\n  );\n};\n\n/**\n * Extracts parameters with metadata from a single plugin.\n *\n * @param plugin - A plugin object containing metadata information.\n * @returns An array of parameter names that have associated metadata, including inputs and outputs.\n */\nexport const extractParametersWithMetadata = (plugin: IFPlugin) => {\n  if (!plugin['parameter-metadata']) return [];\n  const {inputs, outputs} = plugin['parameter-metadata'];\n  return [\n    ...(inputs ? Object.keys(inputs) : []),\n    ...(outputs ? Object.keys(outputs) : []),\n  ];\n};\n\n/**\n * Extracts parameter values from a plugin's configuration based on specified keys.\n *\n * @param config - The configuration object of a plugin.\n * @param keys - An array of keys to look for in the configuration object.\n * @returns An array of parameter values corresponding to the specified keys.\n */\nexport const extractParameters = (\n  config: Record<string, any> | undefined,\n  keys: string[]\n) => {\n  if (!config) return [];\n  return keys.flatMap(key => {\n    if (key in config && isStringOrStringArray(config[key])) {\n      return config[key];\n    }\n    return [];\n  });\n};\n\n/**\n * Calculates the coverage of metadata for a given set of parameters.\n *\n * @param parameterSet - A set of all parameters extracted from plugin configurations.\n * @param parameterWithMetadataSet - A set of parameters that have associated metadata.\n * @returns An object containing:\n *   - `percentage`: The percentage of parameters with metadata coverage.\n *   - `missingParameters`: An array of parameters that lack metadata coverage.\n */\nexport const calculateMetadataCoverage = (\n  parameterSet: Set<string>,\n  parameterWithMetadataSet: Set<string>\n) => {\n  const totalParameters = parameterSet.size;\n  const parametersWithMetadata = [...parameterSet].filter(param =>\n    parameterWithMetadataSet.has(param)\n  ).length;\n  const percentage =\n    totalParameters === 0\n      ? 100\n      : (parametersWithMetadata / totalParameters) * 100;\n\n  const missingParameters = [...parameterSet].filter(\n    parameter => !parameterWithMetadataSet.has(parameter)\n  );\n\n  return {percentage, missingParameters};\n};\n\n/**\n * Checks if the given parameter is a string or an array of strings.\n *\n * @param parameter - The parameter to validate.\n * @returns `true` if the parameter is a string or an array of strings, otherwise `false`.\n */\nconst isStringOrStringArray = (parameter: unknown): boolean => {\n  if (typeof parameter === 'string') {\n    return true;\n  }\n  if (Array.isArray(parameter)) {\n    return parameter.every(item => typeof item === 'string');\n  }\n  return false;\n};\n"]}

package/build/if-run/index.js

@@ -55,4 +55,4 @@ const impactEngine = async () => {
     console.info(EXITING_IF);
 };
 impactEngine().catch(helpers_1.andHandle);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,8 +7,8 @@ export declare const aggregate: (tree: any, aggregationParams: AggregationParams
 /**
  * Gets or stores aggregation metrics.
  */
-export declare const storeAggregationMetrics: (aggregationMetrics?: AggregationMetricsWithMethod) => AggregationMetricsWithMethod;
+export declare const storeAggregationMetrics: (aggregationMetrics?: AggregationMetricsWithMethod) => any;
 /**
  * Returns aggregation method for given `metric`.
  */
-export declare const getAggregationInfoFor: (metric: string) => import("@grnsft/if-core/types").AggregationOptions;
+export declare const getAggregationInfoFor: (metric: string) => any;

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

@@ -4,6 +4,7 @@ exports.getAggregationInfoFor = exports.storeAggregationMetrics = exports.aggreg
 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 storage_1 = require("../../common/util/storage");
 const aggregation_helper_1 = require("../util/aggregation-helper");
 const log_memoize_1 = require("../util/log-memoize");
 const strings_1 = require("../config/strings");
@@ -85,29 +86,14 @@ exports.aggregate = aggregate;
  */
 const storeAggregationMetrics = (aggregationMetrics) => {
     if (aggregationMetrics) {
-        metricManager.metrics = {
-            ...metricManager.metrics,
+        (0, storage_1.getStorage)().metrics = {
+            ...(0, storage_1.getStorage)().metrics,
             ...aggregationMetrics,
         };
     }
-    return metricManager.metrics;
+    return (0, storage_1.getStorage)().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`.
  */
@@ -127,4 +113,4 @@ const getAggregationInfoFor = (metric) => {
     };
 };
 exports.getAggregationInfoFor = getAggregationInfoFor;
-//# 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 {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"]}
+//# 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 {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 {getStorage} from '../../common/util/storage';\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    getStorage().metrics = {\n      ...getStorage().metrics,\n      ...aggregationMetrics,\n    };\n  }\n\n  return getStorage().metrics;\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

@@ -1,4 +1,4 @@
-import { ComputeParams } from '../types/compute';
+import type { ComputeParams } from '../types/compute';
 /**
  * Creates copy of existing tree, then applies computing strategy.
  */

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

@@ -8,15 +8,13 @@ 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, SKIPPING_REGROUP, } = strings_1.STRINGS;
-const childNames = new Set();
 /**
  * Traverses all child nodes based on children grouping.
  */
-const traverse = async (children, params) => {
+const traverse = async (children, childNames, params) => {
     for (const child in children) {
         console.debug(COMPUTING_COMPONENT_PIPELINE(child));
-        childNames.add(child);
-        await computeNode(children[child], params);
+        await computeNode(children[child], [...childNames, child], params);
     }
 };
 /**
@@ -58,15 +56,18 @@ const warnIfConfigProvided = (node) => {
  * 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 computeNode = async (node, childNames, 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.pipeline) {
+        childNames = [];
+    }
     if (node.children) {
-        return traverse(node.children, {
+        return traverse(node.children, childNames, {
             ...params,
             pipeline,
             defaults,
@@ -124,7 +125,7 @@ const computeNode = async (node, params) => {
             delete node.outputs;
             debug_logger_1.debugLogger.setExecutingPluginName();
             console.debug(REGROUPING);
-            return traverse(node.children, {
+            return traverse(node.children, childNames, {
                 ...params,
                 pipeline: {
                     ...pipelineCopy,
@@ -179,8 +180,8 @@ const computeNode = async (node, params) => {
  */
 const compute = async (tree, params) => {
     const copyOfTree = structuredClone(tree);
-    await computeNode(copyOfTree, params);
+    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 {isRegrouped, 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  SKIPPING_REGROUP,\n} = STRINGS;\n\nconst childNames = new Set<string>();\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    childNames.add(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    return defaults\n      ? inputs.map(input => mergeObjects(defaults, input))\n      : inputs;\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 outputStorage = (structuredClone(node.inputs) as PluginParams[]) || [];\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      outputStorage = await plugin.execute(outputStorage, nodeConfig);\n      node.inputs = outputStorage;\n\n      if (params.context.explainer) {\n        addExplainData({\n          pluginName,\n          metadata: plugin.metadata,\n        });\n      }\n    }\n\n    /**\n     * Merges defaults with inputs after observing.\n     * Defaults are needed to be merged after observing because observing can change the inputs.\n     */\n    node.inputs = mergeDefaults(outputStorage, defaults);\n  }\n\n  /**\n   * If observe is not requested, then merge defaults with inputs.\n   */\n  if (!params.observe && outputStorage.length > 0) {\n    outputStorage = mergeDefaults(outputStorage, defaults);\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    if (!isRegrouped(pipelineCopy.regroup, outputStorage, childNames)) {\n      node.children = Regroup(\n        outputStorage,\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    } else {\n      console.debug(SKIPPING_REGROUP);\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      /** Keep previous state to check after computation. */\n      const previousOutputsState = outputStorage;\n\n      outputStorage = await plugin.execute(outputStorage, nodeConfig);\n\n      /**\n       * If there are no previous inputs/outputs (compute phase initalizes values), then merge defaults with outputs postfactum.\n       */\n      if (previousOutputsState.length === 0 && outputStorage.length > 0) {\n        outputStorage = mergeDefaults(outputStorage, defaults);\n      }\n\n      debugLogger.setExecutingPluginName();\n\n      node.outputs = outputStorage;\n\n      if (params.context.explainer) {\n        addExplainData({\n          pluginName,\n          metadata: plugin.metadata,\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"]}
+//# 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 {isRegrouped, 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 type {ComputeParams, Node} 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  SKIPPING_REGROUP,\n} = STRINGS;\n\n/**\n * Traverses all child nodes based on children grouping.\n */\nconst traverse = async (\n  children: Record<string, Node>,\n  childNames: readonly string[],\n  params: ComputeParams\n): Promise<void> => {\n  for (const child in children) {\n    console.debug(COMPUTING_COMPONENT_PIPELINE(child));\n    await computeNode(children[child], [...childNames, child], params);\n  }\n};\n\n/**\n * Appends `default` values to `inputs`.\n */\nconst mergeDefaults = (\n  inputs: PluginParams[],\n  defaults: PluginParams | undefined\n): PluginParams[] => {\n  if (inputs) {\n    return defaults\n      ? inputs.map(input => mergeObjects(defaults, input))\n      : inputs;\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: Node): void => {\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 (\n  node: Node,\n  childNames: readonly string[],\n  params: ComputeParams\n): Promise<void> => {\n  const pipeline = node.pipeline || params.pipeline;\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.pipeline) {\n    childNames = [];\n  }\n\n  if (node.children) {\n    return traverse(node.children, childNames, {\n      ...params,\n      pipeline,\n      defaults,\n      config,\n    });\n  }\n\n  let outputStorage = structuredClone(node.inputs) || [];\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      outputStorage = await plugin.execute(outputStorage, nodeConfig);\n      node.inputs = outputStorage;\n\n      if (params.context.explainer) {\n        addExplainData({\n          pluginName,\n          metadata: plugin.metadata,\n        });\n      }\n    }\n\n    /**\n     * Merges defaults with inputs after observing.\n     * Defaults are needed to be merged after observing because observing can change the inputs.\n     */\n    node.inputs = mergeDefaults(outputStorage, defaults);\n  }\n\n  /**\n   * If observe is not requested, then merge defaults with inputs.\n   */\n  if (!params.observe && outputStorage.length > 0) {\n    outputStorage = mergeDefaults(outputStorage, defaults);\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    if (!isRegrouped(pipelineCopy.regroup, outputStorage, childNames)) {\n      node.children = Regroup(\n        outputStorage,\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, childNames, {\n        ...params,\n        pipeline: {\n          ...pipelineCopy,\n          regroup: undefined,\n        },\n        defaults,\n        config,\n      });\n    } else {\n      console.debug(SKIPPING_REGROUP);\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      /** Keep previous state to check after computation. */\n      const previousOutputsState = outputStorage;\n\n      outputStorage = await plugin.execute(outputStorage, nodeConfig);\n\n      /**\n       * If there are no previous inputs/outputs (compute phase initalizes values), then merge defaults with outputs postfactum.\n       */\n      if (previousOutputsState.length === 0 && outputStorage.length > 0) {\n        outputStorage = mergeDefaults(outputStorage, defaults);\n      }\n\n      debugLogger.setExecutingPluginName();\n\n      node.outputs = outputStorage;\n\n      if (params.context.explainer) {\n        addExplainData({\n          pluginName,\n          metadata: plugin.metadata,\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

@@ -1,4 +1,8 @@
-import { Manifest } from '../../common/types/manifest';
+import type { Execution, Manifest } from '../../common/types/manifest';
+/**
+ * Get execution information (command, environment).
+ */
+export declare const getExecution: () => Promise<Execution>;
 /**
  * Injects execution information (command, environment) to existing manifest.
  */

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectEnvironment = void 0;
+exports.injectEnvironment = exports.getExecution = void 0;
 const os_checker_1 = require("../util/os-checker");
 const helpers_1 = require("../../common/util/helpers");
 const strings_1 = require("../config/strings");
@@ -44,28 +44,33 @@ const listDependencies = async () => {
     return [];
 };
 /**
- * Injects execution information (command, environment) to existing manifest.
+ * Get execution information (command, environment).
  */
-const injectEnvironment = async (manifest) => {
+const getExecution = async () => {
     console.debug(CAPTURING_RUNTIME_ENVIRONMENT_DATA);
     const dependencies = await listDependencies();
     const info = await (0, os_checker_1.osInfo)();
     const dateTime = `${getProcessStartingTimestamp()} (UTC)`;
     return {
-        ...manifest,
-        execution: {
-            status: 'success',
-            command: process.argv.join(' '),
-            environment: {
-                'if-version': packageJson.version,
-                os: info.os,
-                'os-version': info['os-version'],
-                'node-version': process.versions.node,
-                'date-time': dateTime,
-                dependencies,
-            },
+        status: 'success',
+        command: process.argv.join(' '),
+        environment: {
+            'if-version': packageJson.version,
+            os: info.os,
+            'os-version': info['os-version'],
+            'node-version': process.versions.node,
+            'date-time': dateTime,
+            dependencies,
         },
     };
 };
+exports.getExecution = getExecution;
+/**
+ * Injects execution information (command, environment) to existing manifest.
+ */
+const injectEnvironment = async (manifest) => ({
+    ...manifest,
+    execution: await (0, exports.getExecution)(),
+});
 exports.injectEnvironment = injectEnvironment;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,17 @@
 import { Context } from '../../common/types/manifest';
 import { PluginStorageInterface } from '../types/plugin-storage';
+/**
+ * Set whether to output warnings for external plugins.
+ * @param enable true if warnings for external plugins should be output
+ */
+export declare const setExternalPluginWarning: (enable: boolean) => void;
+/**
+ * Set plugins to be disabled.
+ * Each element is specified in the format `plugin-path:method-name`.
+ * Built-in plugins are specified as `builtin:method-name`.
+ * @param pluginsToBeDisabled List of plugins to be disabled
+ */
+export declare const setDisabledPlugins: (pluginsToBeDisabled: Set<string>) => void;
 /**
  * Registers all plugins from `manifest`.`initialize` property.
  * 1. Initalizes plugin storage.