@grnsft/if 0.3.4 → 0.4.0-beta.1

package/build/builtins/shell/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shell = void 0;
+const child_process_1 = require("child_process");
+const js_yaml_1 = require("js-yaml");
+const zod_1 = require("zod");
+const validations_1 = require("../../util/validations");
+const errors_1 = require("../../util/errors");
+const { InputValidationError } = errors_1.ERRORS;
+const Shell = (globalConfig) => {
+    const metadata = {
+        kind: 'execute',
+    };
+    /**
+     * Calculate the total emissions for a list of inputs.
+     */
+    const execute = (inputs) => {
+        const inputWithConfig = Object.assign({}, inputs[0], validateConfig());
+        const command = inputWithConfig.command;
+        const inputAsString = (0, js_yaml_1.dump)(inputs, { indent: 2 });
+        const results = runModelInShell(inputAsString, command);
+        return results?.outputs?.flat();
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateConfig = () => {
+        const schema = zod_1.z.object({
+            command: zod_1.z.string(),
+        });
+        return (0, validations_1.validate)(schema, globalConfig);
+    };
+    /**
+     * Runs the model in a shell. Spawns a child process to run an external IMP,
+     * an executable with a CLI exposing two methods: `--execute` and `--manifest`.
+     * The shell command then calls the `--command` method passing var manifest as the path to the desired manifest file.
+     */
+    const runModelInShell = (input, command) => {
+        try {
+            const [executable, ...args] = command.split(' ');
+            const result = (0, child_process_1.spawnSync)(executable, args, {
+                input,
+                encoding: 'utf8',
+            });
+            const outputs = (0, js_yaml_1.loadAll)(result.stdout);
+            return { outputs };
+        }
+        catch (error) {
+            throw new InputValidationError(error.message);
+        }
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Shell = Shell;
+//# sourceMappingURL=data:application/json;base64,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

package/build/builtins/subtract/index.d.ts

@@ -0,0 +1,3 @@
+import { ExecutePlugin } from '../../types/interface';
+import { SubtractConfig } from './types';
+export declare const Subtract: (globalConfig: SubtractConfig) => ExecutePlugin;

package/build/builtins/subtract/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subtract = void 0;
+const zod_1 = require("zod");
+const errors_1 = require("../../util/errors");
+const helpers_1 = require("../../util/helpers");
+const validations_1 = require("../../util/validations");
+const { InputValidationError } = errors_1.ERRORS;
+const Subtract = (globalConfig) => {
+    const errorBuilder = (0, helpers_1.buildErrorMessage)(exports.Subtract.name);
+    const metadata = {
+        kind: 'execute',
+    };
+    /**
+     * Checks global config value are valid.
+     */
+    const validateGlobalConfig = () => {
+        const globalConfigSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(globalConfigSchema, globalConfig);
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateSingleInput = (input, inputParameters) => {
+        inputParameters.forEach(metricToSubtract => {
+            validateParamExists(input, metricToSubtract);
+            validateNumericString(input[metricToSubtract]);
+        });
+        return input;
+    };
+    const validateParamExists = (input, param) => {
+        if (input[param] === undefined) {
+            throw new InputValidationError(errorBuilder({
+                message: `${param} is missing from the input array`,
+            }));
+        }
+    };
+    const validateNumericString = (str) => {
+        if (isNaN(+Number(str))) {
+            throw new InputValidationError(errorBuilder({
+                message: `${str} is not numberic`,
+            }));
+        }
+    };
+    /**
+     * Subtract items from inputParams[1..n] from inputParams[0] and write the result in a new param outputParam.
+     */
+    const execute = (inputs) => {
+        const { 'input-parameters': inputParameters, 'output-parameter': outputParameter, } = validateGlobalConfig();
+        return inputs.map(input => {
+            validateSingleInput(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculateDiff(input, inputParameters),
+            };
+        });
+    };
+    /**
+     * Calculates the diff between the 1st item in the inputs nad the rest of the items
+     */
+    const calculateDiff = (input, inputParameters) => {
+        const [firstItem, ...restItems] = inputParameters;
+        return restItems.reduce((accumulator, metricToSubtract) => accumulator - input[metricToSubtract], input[firstItem] // Starting accumulator with the value of the first item
+        );
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Subtract = Subtract;
+//# sourceMappingURL=data:application/json;base64,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

package/build/builtins/subtract/types.d.ts

@@ -0,0 +1,4 @@
+export type SubtractConfig = {
+    'input-parameters': string[];
+    'output-parameter': string;
+};

package/build/builtins/subtract/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYnVpbHRpbnMvc3VidHJhY3QvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIFN1YnRyYWN0Q29uZmlnID0ge1xuICAnaW5wdXQtcGFyYW1ldGVycyc6IHN0cmluZ1tdO1xuICAnb3V0cHV0LXBhcmFtZXRlcic6IHN0cmluZztcbn07XG4iXX0=

package/build/builtins/sum/index.d.ts

@@ -0,0 +1,3 @@
+import { ExecutePlugin } from '../../types/interface';
+import { SumConfig } from './types';
+export declare const Sum: (globalConfig: SumConfig) => ExecutePlugin;

package/build/builtins/sum/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sum = void 0;
+const zod_1 = require("zod");
+const validations_1 = require("../../util/validations");
+const errors_1 = require("../../util/errors");
+const { InputValidationError, ConfigNotFoundError } = errors_1.ERRORS;
+const Sum = (globalConfig) => {
+    const metadata = {
+        kind: 'execute',
+    };
+    /**
+     * Calculate the sum of each input-paramters.
+     */
+    const execute = (inputs) => {
+        const safeGlobalConfig = validateGlobalConfig();
+        const inputParameters = safeGlobalConfig['input-parameters'];
+        const outputParameter = safeGlobalConfig['output-parameter'];
+        return inputs.map(input => {
+            const safeInput = validateSingleInput(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculateSum(safeInput, inputParameters),
+            };
+        });
+    };
+    /**
+     * Checks global config value are valid.
+     */
+    const validateGlobalConfig = () => {
+        if (!globalConfig) {
+            throw new ConfigNotFoundError('Global config is not provided.');
+        }
+        const globalConfigSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(globalConfigSchema, globalConfig);
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateSingleInput = (input, inputParameters) => {
+        inputParameters.forEach(metricToSum => {
+            if (!input[metricToSum]) {
+                throw new InputValidationError(`${metricToSum} is missing from the input array.`);
+            }
+        });
+        return input;
+    };
+    /**
+     * Calculates the sum of the energy components.
+     */
+    const calculateSum = (input, inputParameters) => inputParameters.reduce((accumulator, metricToSum) => accumulator + input[metricToSum], 0);
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Sum = Sum;
+//# sourceMappingURL=data:application/json;base64,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

package/build/builtins/sum/types.d.ts

@@ -0,0 +1,4 @@
+export type SumConfig = {
+    'input-parameters': string[];
+    'output-parameter': string;
+};

package/build/builtins/sum/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYnVpbHRpbnMvc3VtL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTdW1Db25maWcgPSB7XG4gICdpbnB1dC1wYXJhbWV0ZXJzJzogc3RyaW5nW107XG4gICdvdXRwdXQtcGFyYW1ldGVyJzogc3RyaW5nO1xufTtcbiJdfQ==

package/build/config/config.d.ts

@@ -1,10 +1,16 @@
 import { ArgumentConfig, ParseOptions } from 'ts-command-line-args';
-import { ManifestProcessArgs } from '../types/process-args';
+import { IFDiffArgs, IEArgs } from '../types/process-args';
 export declare const CONFIG: {
     IE: {
-        ARGS: ArgumentConfig<ManifestProcessArgs>;
+        ARGS: ArgumentConfig<IEArgs>;
         HELP: ParseOptions<any>;
     };
+    IF_DIFF: {
+        ARGS: ArgumentConfig<IFDiffArgs>;
+        HELP: ParseOptions<any>;
+        SUCCESS_MESSAGE: string;
+        FAILURE_MESSAGE: string;
+    };
     GITHUB_PATH: string;
     NATIVE_PLUGIN: string;
     AGGREGATION_ADDITIONAL_PARAMS: string[];

package/build/config/config.js

@@ -36,6 +36,12 @@ exports.CONFIG = {
                 alias: 'h',
                 description: '[prints out the above help instruction]',
             },
+            debug: {
+                type: Boolean,
+                optional: true,
+                alias: 'd',
+                description: '[prints out debug logs to the console]',
+            },
         },
         HELP: {
             helpArg: 'help',
@@ -47,8 +53,35 @@ exports.CONFIG = {
             ],
         },
     },
+    IF_DIFF: {
+        ARGS: {
+            source: {
+                type: String,
+                optional: true,
+                alias: 's',
+                description: '[path to the source file]',
+            },
+            target: {
+                type: String,
+                optional: false,
+                alias: 't',
+                description: '[path to the target file',
+            },
+        },
+        HELP: {
+            helpArg: 'help',
+            headerContentSections: [
+                { header: 'Impact Framework', content: 'IF-Diff Helpful keywords:' },
+            ],
+            footerContentSections: [
+                { header: 'Green Software Foundation', content: DISCLAIMER_MESSAGE },
+            ],
+        },
+        SUCCESS_MESSAGE: 'Files match!',
+        FAILURE_MESSAGE: 'Files do not match!',
+    },
     GITHUB_PATH: 'https://github.com',
     NATIVE_PLUGIN: 'if-plugins',
     AGGREGATION_ADDITIONAL_PARAMS: ['timestamp', 'duration'],
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/config/strings.d.ts

@@ -25,4 +25,26 @@ export declare const STRINGS: {
     UNKNOWN_PARAM: (name: string) => string;
     NOT_INITALIZED_PLUGIN: (name: string) => string;
     NO_OUTPUT: string;
+    SOURCE_IS_NOT_YAML: string;
+    TARGET_IS_NOT_YAML: string;
+    INVALID_TARGET: string;
+    INVALID_SOURCE: string;
+    STARTING_IF: string;
+    EXITING_IF: string;
+    LOADING_MANIFEST: string;
+    VALIDATING_MANIFEST: string;
+    CAPTURING_RUNTIME_ENVIRONMENT_DATA: string;
+    SYNCING_PARAMETERS: string;
+    CHECKING_AGGREGATION_METHOD: (unitName: string) => string;
+    INITIALIZING_PLUGINS: string;
+    INITIALIZING_PLUGIN: (pluginName: string) => string;
+    LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) => string;
+    COMPUTING_PIPELINE_FOR_NODE: (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;
+    EXPORTING_TO_CSV_FILE: (savepath: string) => string;
+    EXPORTING_RAW_CSV_FILE: (savepath: string) => string;
 };

package/build/config/strings.js

@@ -38,5 +38,27 @@ You have not selected an output method. To see your output data, you can choose
 --stdout: this will print your output data to the console
 --output <savepath>: this 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`,
+    SOURCE_IS_NOT_YAML: 'Given source file is not in yaml format.',
+    TARGET_IS_NOT_YAML: 'Given target is not in yaml format.',
+    INVALID_TARGET: 'Target is invalid.',
+    INVALID_SOURCE: 'Source is invalid.',
+    STARTING_IF: 'Starting IF',
+    EXITING_IF: 'Exiting IF',
+    LOADING_MANIFEST: 'Loading manifest',
+    VALIDATING_MANIFEST: 'Validating manifest',
+    CAPTURING_RUNTIME_ENVIRONMENT_DATA: 'Capturing runtime environment data',
+    SYNCING_PARAMETERS: 'Syncing parameters',
+    CHECKING_AGGREGATION_METHOD: (unitName) => `Checking aggregation method for ${unitName}`,
+    INITIALIZING_PLUGINS: 'Initializing plugins',
+    INITIALIZING_PLUGIN: (pluginName) => `Initializing ${pluginName}`,
+    LOADING_PLUGIN_FROM_PATH: (pluginName, path) => `Loading ${pluginName} from ${path}`,
+    COMPUTING_PIPELINE_FOR_NODE: (nodeName) => `Computing pipeline for \`${nodeName}\``,
+    MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',
+    AGGREGATING_OUTPUTS: 'Aggregating outputs',
+    AGGREGATING_NODE: (nodeName) => `Aggregating node ${nodeName}`,
+    PREPARING_OUTPUT_DATA: 'Preparing output data',
+    EXPORTING_TO_YAML_FILE: (savepath) => `Exporting to yaml file: ${savepath}`,
+    EXPORTING_TO_CSV_FILE: (savepath) => `Exporting to csv file: ${savepath}`,
+    EXPORTING_RAW_CSV_FILE: (savepath) => `Exporting raw csv file: ${savepath}`,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../src/config/strings.ts"],"names":[],"mappings":";;;AAEa,QAAA,OAAO,GAAG;IACrB,gBAAgB,EAAE,0CAA0C;IAC5D,mBAAmB,EAAE,sBAAsB;IAC3C,cAAc,EAAE,0CAA0C;IAC1D,YAAY,EAAE,wCAAwC;IACtD,kBAAkB,EAChB,qEAAqE;IACvE,gBAAgB,EACd,qJAAqJ;IACvJ,kBAAkB,EAAE;;;;2NAIqM;IACzN,iBAAiB,EAAE,CAAC,IAAY,EAAE,EAAE,CAClC;uBACmB,IAAI,sLAAsL;IAC/M,eAAe,EAAE,wDAAwD;IACzE,cAAc,EAAE;;uIAEqH;IACrI,mBAAmB,EAAE,CAAC,IAAY,EAAE,EAAE,CACpC,qBAAqB,IAAI,4BAA4B;IACvD,0BAA0B,EAAE,oCAAoC;IAChE,sBAAsB,EACpB,6DAA6D;IAC/D,qBAAqB,EAAE,sBAAsB;IAC7C,gBAAgB,EAAE,CAAC,WAAmB,EAAE,EAAE,CACxC,uBAAuB,WAAW,EAAE;IACtC,yBAAyB,EAAE,CAAC,KAAc,EAAE,GAAY,EAAE,EAAE,CAC1D,uBACE,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KACrD,EAAE;IACJ,2BAA2B,EAAE,iCAAiC;IAC9D,0BAA0B,EAAE,CAAC,MAAc,EAAE,EAAE,CAC7C,yCAAyC,MAAM,0BAA0B;IAC3E,cAAc,EAAE,CAAC,MAAc,EAAE,KAAa,EAAE,EAAE,CAChD,sBAAsB,MAAM,2BAA2B,KAAK,IAAI;IAClE,gBAAgB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,iBAAiB,IAAI,GAAG;IAC5D,kBAAkB,EAAE,CAAC,KAAwB,EAAE,EAAE,CAC/C,gDAAgD,KAAK,CAAC,IAAI,GAAG;IAC/D,sBAAsB,EAAE,CAAC,UAAkB,EAAE,EAAE,CAC7C,2BAA2B,UAAU,GAAG;IAC1C,aAAa,EAAE,CAAC,IAAY,EAAE,EAAE,CAC9B,sBAAsB,IAAI,mCAAmC;IAC/D,qBAAqB,EAAE,CAAC,IAAY,EAAE,EAAE,CACtC,0BAA0B,IAAI,cAAc,IAAI,sCAAsC;IACxF,SAAS,EAAE;;;;mLAIsK;IACjL,kBAAkB,EAAE,0CAA0C;IAC9D,kBAAkB,EAAE,qCAAqC;IACzD,cAAc,EAAE,oBAAoB;IACpC,cAAc,EAAE,oBAAoB;IACpC,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,gBAAgB,EAAE,kBAAkB;IACpC,mBAAmB,EAAE,qBAAqB;IAC1C,kCAAkC,EAAE,oCAAoC;IACxE,kBAAkB,EAAE,oBAAoB;IACxC,2BAA2B,EAAE,CAAC,QAAgB,EAAE,EAAE,CAChD,mCAAmC,QAAQ,EAAE;IAC/C,oBAAoB,EAAE,sBAAsB;IAC5C,mBAAmB,EAAE,CAAC,UAAkB,EAAE,EAAE,CAAC,gBAAgB,UAAU,EAAE;IACzE,wBAAwB,EAAE,CAAC,UAAkB,EAAE,IAAY,EAAE,EAAE,CAC7D,WAAW,UAAU,SAAS,IAAI,EAAE;IACtC,2BAA2B,EAAE,CAAC,QAAgB,EAAE,EAAE,CAChD,4BAA4B,QAAQ,IAAI;IAC1C,gCAAgC,EAAE,kCAAkC;IACpE,mBAAmB,EAAE,qBAAqB;IAC1C,gBAAgB,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,oBAAoB,QAAQ,EAAE;IACtE,qBAAqB,EAAE,uBAAuB;IAC9C,sBAAsB,EAAE,CAAC,QAAgB,EAAE,EAAE,CAC3C,2BAA2B,QAAQ,EAAE;IACvC,qBAAqB,EAAE,CAAC,QAAgB,EAAE,EAAE,CAC1C,0BAA0B,QAAQ,EAAE;IACtC,sBAAsB,EAAE,CAAC,QAAgB,EAAE,EAAE,CAC3C,2BAA2B,QAAQ,EAAE;CACxC,CAAC","sourcesContent":["import {ManifestParameter} from '../types/manifest';\n\nexport const STRINGS = {\n  FILE_IS_NOT_YAML: 'Provided manifest is not in yaml format.',\n  MANIFEST_IS_MISSING: 'Manifest is missing.',\n  MISSING_METHOD: \"Initalization param 'method' is missing.\",\n  MISSING_PATH: \"Initalization param 'path' is missing.\",\n  UNSUPPORTED_PLUGIN:\n    \"Plugin interface doesn't implement 'execute' or 'metadata' methods.\",\n  OVERRIDE_WARNING:\n    '\\n**WARNING**: You are overriding the IF default parameters file. Please be extremely careful of unintended side-effects in your plugin pipeline!\\n',\n  DISCLAIMER_MESSAGE: `\nIncubation Project\n\nThis project is an incubation project being run inside the Green Software Foundation; as such, we DON’T recommend using it in any critical use case. \nIncubation projects are experimental, offer no support guarantee, have minimal governance and process, and may be retired at any moment. This project may one day graduate, in which case this disclaimer will be removed.`,\n  NOT_NATIVE_PLUGIN: (path: string) =>\n    `\nYou 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  SOMETHING_WRONG: 'Something wrong with cli arguments. Please check docs.',\n  ISSUE_TEMPLATE: `\nImpact Framework is an alpha release from the Green Software Foundation and is released to capture early feedback. If you'd like to offer some feedback, please use this issue template: \nhttps://github.com/Green-Software-Foundation/if/issues/new?assignees=&labels=feedback&projects=&template=feedback.md&title=Feedback+-+`,\n  INVALID_MODULE_PATH: (path: string) =>\n    `Provided module: '${path}' is invalid or not found.`,\n  INVALID_TIME_NORMALIZATION: 'Start time or end time is missing.',\n  UNEXPECTED_TIME_CONFIG:\n    'Unexpected node-level config provided for time-sync plugin.',\n  INVALID_TIME_INTERVAL: 'Interval is missing.',\n  AVOIDING_PADDING: (description: string) =>\n    `Avoiding padding at ${description}`,\n  AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) =>\n    `Avoiding padding at ${\n      start && end ? 'start and end' : start ? 'start' : 'end'\n    }`,\n  INVALID_OBSERVATION_OVERLAP: 'Observation timestamps overlap.',\n  INVALID_AGGREGATION_METHOD: (metric: string) =>\n    `Aggregation is not possible for given ${metric} since method is 'none'.`,\n  METRIC_MISSING: (metric: string, index: number) =>\n    `Aggregation metric ${metric} is not found in inputs[${index}].`,\n  INVALID_GROUP_BY: (type: string) => `Invalid group ${type}.`,\n  REJECTING_OVERRIDE: (param: ManifestParameter) =>\n    `Rejecting overriding of canonical parameter: ${param.name}.`,\n  INVALID_EXHAUST_PLUGIN: (pluginName: string) =>\n    `Invalid exhaust plugin: ${pluginName}.`,\n  UNKNOWN_PARAM: (name: string) =>\n    `Unknown parameter: ${name}. Using 'sum' aggregation method.`,\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 selected an output method. To see your output data, you can choose from:\n--stdout: this will print your output data to the console\n--output <savepath>: this 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  SOURCE_IS_NOT_YAML: 'Given source file is not in yaml format.',\n  TARGET_IS_NOT_YAML: 'Given target is not in yaml format.',\n  INVALID_TARGET: 'Target is invalid.',\n  INVALID_SOURCE: 'Source is invalid.',\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  SYNCING_PARAMETERS: 'Syncing parameters',\n  CHECKING_AGGREGATION_METHOD: (unitName: string) =>\n    `Checking aggregation method for ${unitName}`,\n  INITIALIZING_PLUGINS: 'Initializing plugins',\n  INITIALIZING_PLUGIN: (pluginName: string) => `Initializing ${pluginName}`,\n  LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) =>\n    `Loading ${pluginName} from ${path}`,\n  COMPUTING_PIPELINE_FOR_NODE: (nodeName: string) =>\n    `Computing pipeline for \\`${nodeName}\\``,\n  MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',\n  AGGREGATING_OUTPUTS: 'Aggregating outputs',\n  AGGREGATING_NODE: (nodeName: string) => `Aggregating node ${nodeName}`,\n  PREPARING_OUTPUT_DATA: 'Preparing output data',\n  EXPORTING_TO_YAML_FILE: (savepath: string) =>\n    `Exporting to yaml file: ${savepath}`,\n  EXPORTING_TO_CSV_FILE: (savepath: string) =>\n    `Exporting to csv file: ${savepath}`,\n  EXPORTING_RAW_CSV_FILE: (savepath: string) =>\n    `Exporting raw csv file: ${savepath}`,\n};\n"]}

package/build/diff.d.ts

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

package/build/diff.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-process-exit */
+const load_1 = require("./lib/load");
+const compare_1 = require("./lib/compare");
+const args_1 = require("./util/args");
+const helpers_1 = require("./util/helpers");
+const validations_1 = require("./util/validations");
+const config_1 = require("./config");
+const logger_1 = require("./util/logger");
+const { IF_DIFF } = config_1.CONFIG;
+const { SUCCESS_MESSAGE, FAILURE_MESSAGE } = IF_DIFF;
+const IfDiff = async () => {
+    const { sourcePath, targetPath } = (0, args_1.parseIfDiffArgs)();
+    const { rawSourceManifest, rawTargetManifest } = await (0, load_1.loadIfDiffFiles)({
+        targetPath,
+        sourcePath,
+    });
+    const [sourceManifest, targetManifest] = [
+        rawSourceManifest,
+        rawTargetManifest,
+    ].map(validations_1.validateManifest);
+    const result = (0, compare_1.compare)(sourceManifest, targetManifest);
+    if (Object.keys(result).length) {
+        (0, helpers_1.formatNotMatchingLog)({
+            message: FAILURE_MESSAGE,
+            ...result,
+        });
+        process.exit(1);
+    }
+    console.log(SUCCESS_MESSAGE);
+    process.exit(0);
+};
+IfDiff().catch(error => {
+    if (error instanceof Error) {
+        logger_1.logger.error(error);
+        process.exit(2);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.js

@@ -8,16 +8,19 @@ const exhaust_1 = require("./lib/exhaust");
 const initialize_1 = require("./lib/initialize");
 const load_1 = require("./lib/load");
 const parameterize_1 = require("./lib/parameterize");
+const debug_logger_1 = require("./util/debug-logger");
 const args_1 = require("./util/args");
 const helpers_1 = require("./util/helpers");
 const logger_1 = require("./util/logger");
 const validations_1 = require("./util/validations");
 const config_1 = require("./config");
-const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+const { DISCLAIMER_MESSAGE, EXITING_IF, STARTING_IF } = config_1.STRINGS;
 const impactEngine = async () => {
-    const options = (0, args_1.parseArgs)();
+    const options = (0, args_1.parseIEProcessArgs)();
+    const { inputPath, paramPath, outputOptions, debug } = options;
+    debug_logger_1.debugLogger.overrideConsoleMethods(!!debug);
     logger_1.logger.info(DISCLAIMER_MESSAGE);
-    const { inputPath, paramPath, outputOptions } = options;
+    console.info(STARTING_IF);
     const { rawManifest, parameters } = await (0, load_1.load)(inputPath, paramPath);
     const envManifest = await (0, environment_1.injectEnvironment)(rawManifest);
     try {
@@ -39,6 +42,7 @@ const impactEngine = async () => {
             }
         }
     }
+    console.info(EXITING_IF);
 };
 impactEngine().catch(helpers_1.andHandle);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsK0NBQTBDO0FBQzFDLDJDQUFzQztBQUN0QyxtREFBb0Q7QUFDcEQsMkNBQXNDO0FBQ3RDLGlEQUE0QztBQUM1QyxxQ0FBZ0M7QUFDaEMscURBQWdEO0FBRWhELHNDQUFzQztBQUN0Qyw0Q0FBeUM7QUFDekMsMENBQXFDO0FBQ3JDLG9EQUFvRDtBQUVwRCxxQ0FBaUM7QUFFakMsTUFBTSxFQUFDLGtCQUFrQixFQUFDLEdBQUcsZ0JBQU8sQ0FBQztBQUVyQyxNQUFNLFlBQVksR0FBRyxLQUFLLElBQUksRUFBRTtJQUM5QixNQUFNLE9BQU8sR0FBRyxJQUFBLGdCQUFTLEdBQUUsQ0FBQztJQUU1QixlQUFNLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDaEMsTUFBTSxFQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFDLEdBQUcsT0FBTyxDQUFDO0lBRXRELE1BQU0sRUFBQyxXQUFXLEVBQUUsVUFBVSxFQUFDLEdBQUcsTUFBTSxJQUFBLFdBQUksRUFBQyxTQUFTLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDbkUsTUFBTSxXQUFXLEdBQUcsTUFBTSxJQUFBLCtCQUFpQixFQUFDLFdBQVcsQ0FBQyxDQUFDO0lBRXpELElBQUk7UUFDRixNQUFNLEVBQUMsSUFBSSxFQUFFLEdBQUcsT0FBTyxFQUFDLEdBQUcsSUFBQSw4QkFBZ0IsRUFBQyxXQUFXLENBQUMsQ0FBQztRQUN6RCwyQkFBWSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2pELE1BQU0sYUFBYSxHQUFHLE1BQU0sSUFBQSx1QkFBVSxFQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbkUsTUFBTSxZQUFZLEdBQUcsTUFBTSxJQUFBLGlCQUFPLEVBQUMsSUFBSSxFQUFFLEVBQUMsT0FBTyxFQUFFLGFBQWEsRUFBQyxDQUFDLENBQUM7UUFDbkUsTUFBTSxjQUFjLEdBQUcsSUFBQSxxQkFBUyxFQUFDLFlBQVksRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDcEUsTUFBTSxJQUFBLGlCQUFPLEVBQUMsY0FBYyxFQUFFLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQztLQUN2RDtJQUFDLE9BQU8sS0FBSyxFQUFFO1FBQ2QsSUFBSSxLQUFLLFlBQVksS0FBSyxFQUFFO1lBQzFCLFdBQVcsQ0FBQyxTQUFTLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztZQUN0QyxXQUFXLENBQUMsU0FBUyxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDL0MsZUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNwQixNQUFNLEVBQUMsSUFBSSxFQUFFLEdBQUcsT0FBTyxFQUFDLEdBQUcsV0FBVyxDQUFDO1lBRXZDLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxjQUFjLEVBQUU7Z0JBQ2pDLElBQUEsaUJBQU8sRUFBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLGFBQWEsQ0FBQyxDQUFDO2FBQ3ZDO1NBQ0Y7S0FDRjtBQUNILENBQUMsQ0FBQztBQUVGLFlBQVksRUFBRSxDQUFDLEtBQUssQ0FBQyxtQkFBUyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiBub2RlXG5pbXBvcnQge2FnZ3JlZ2F0ZX0gZnJvbSAnLi9saWIvYWdncmVnYXRlJztcbmltcG9ydCB7Y29tcHV0ZX0gZnJvbSAnLi9saWIvY29tcHV0ZSc7XG5pbXBvcnQge2luamVjdEVudmlyb25tZW50fSBmcm9tICcuL2xpYi9lbnZpcm9ubWVudCc7XG5pbXBvcnQge2V4aGF1c3R9IGZyb20gJy4vbGliL2V4aGF1c3QnO1xuaW1wb3J0IHtpbml0aWFsaXplfSBmcm9tICcuL2xpYi9pbml0aWFsaXplJztcbmltcG9ydCB7bG9hZH0gZnJvbSAnLi9saWIvbG9hZCc7XG5pbXBvcnQge3BhcmFtZXRlcml6ZX0gZnJvbSAnLi9saWIvcGFyYW1ldGVyaXplJztcblxuaW1wb3J0IHtwYXJzZUFyZ3N9IGZyb20gJy4vdXRpbC9hcmdzJztcbmltcG9ydCB7YW5kSGFuZGxlfSBmcm9tICcuL3V0aWwvaGVscGVycyc7XG5pbXBvcnQge2xvZ2dlcn0gZnJvbSAnLi91dGlsL2xvZ2dlcic7XG5pbXBvcnQge3ZhbGlkYXRlTWFuaWZlc3R9IGZyb20gJy4vdXRpbC92YWxpZGF0aW9ucyc7XG5cbmltcG9ydCB7U1RSSU5HU30gZnJvbSAnLi9jb25maWcnO1xuXG5jb25zdCB7RElTQ0xBSU1FUl9NRVNTQUdFfSA9IFNUUklOR1M7XG5cbmNvbnN0IGltcGFjdEVuZ2luZSA9IGFzeW5jICgpID0+IHtcbiAgY29uc3Qgb3B0aW9ucyA9IHBhcnNlQXJncygpO1xuXG4gIGxvZ2dlci5pbmZvKERJU0NMQUlNRVJfTUVTU0FHRSk7XG4gIGNvbnN0IHtpbnB1dFBhdGgsIHBhcmFtUGF0aCwgb3V0cHV0T3B0aW9uc30gPSBvcHRpb25zO1xuXG4gIGNvbnN0IHtyYXdNYW5pZmVzdCwgcGFyYW1ldGVyc30gPSBhd2FpdCBsb2FkKGlucHV0UGF0aCwgcGFyYW1QYXRoKTtcbiAgY29uc3QgZW52TWFuaWZlc3QgPSBhd2FpdCBpbmplY3RFbnZpcm9ubWVudChyYXdNYW5pZmVzdCk7XG5cbiAgdHJ5IHtcbiAgICBjb25zdCB7dHJlZSwgLi4uY29udGV4dH0gPSB2YWxpZGF0ZU1hbmlmZXN0KGVudk1hbmlmZXN0KTtcbiAgICBwYXJhbWV0ZXJpemUuY29tYmluZShjb250ZXh0LnBhcmFtcywgcGFyYW1ldGVycyk7XG4gICAgY29uc3QgcGx1Z2luU3RvcmFnZSA9IGF3YWl0IGluaXRpYWxpemUoY29udGV4dC5pbml0aWFsaXplLnBsdWdpbnMpO1xuICAgIGNvbnN0IGNvbXB1dGVkVHJlZSA9IGF3YWl0IGNvbXB1dGUodHJlZSwge2NvbnRleHQsIHBsdWdpblN0b3JhZ2V9KTtcbiAgICBjb25zdCBhZ2dyZWdhdGVkVHJlZSA9IGFnZ3JlZ2F0ZShjb21wdXRlZFRyZWUsIGNvbnRleHQuYWdncmVnYXRpb24pO1xuICAgIGF3YWl0IGV4aGF1c3QoYWdncmVnYXRlZFRyZWUsIGNvbnRleHQsIG91dHB1dE9wdGlvbnMpO1xuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGlmIChlcnJvciBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgICBlbnZNYW5pZmVzdC5leGVjdXRpb24uc3RhdHVzID0gJ2ZhaWwnO1xuICAgICAgZW52TWFuaWZlc3QuZXhlY3V0aW9uLmVycm9yID0gZXJyb3IudG9TdHJpbmcoKTtcbiAgICAgIGxvZ2dlci5lcnJvcihlcnJvcik7XG4gICAgICBjb25zdCB7dHJlZSwgLi4uY29udGV4dH0gPSBlbnZNYW5pZmVzdDtcblxuICAgICAgaWYgKGVycm9yLm5hbWUgIT09ICdFeGhhdXN0RXJyb3InKSB7XG4gICAgICAgIGV4aGF1c3QodHJlZSwgY29udGV4dCwgb3V0cHV0T3B0aW9ucyk7XG4gICAgICB9XG4gICAgfVxuICB9XG59O1xuXG5pbXBhY3RFbmdpbmUoKS5jYXRjaChhbmRIYW5kbGUpO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/aggregate.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregate = void 0;
 const aggregation_helper_1 = require("../util/aggregation-helper");
+const strings_1 = require("../config/strings");
+const { AGGREGATING_NODE, AGGREGATING_OUTPUTS } = strings_1.STRINGS;
 /**
  * Gets `i`th element from all children outputs and collects them in single array.
  */
@@ -41,6 +43,7 @@ const aggregateNode = (node, aggregationParams) => {
     const type = aggregationParams.type;
     if (node.children) {
         for (const child in node.children) {
+            console.debug(AGGREGATING_NODE(child));
             aggregateNode(node.children[child], aggregationParams);
         }
     }
@@ -62,6 +65,7 @@ const aggregateNode = (node, aggregationParams) => {
  * 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;
     }
@@ -70,4 +74,4 @@ const aggregate = (tree, aggregationParams) => {
     return copyOfTree;
 };
 exports.aggregate = aggregate;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/compare.d.ts

@@ -0,0 +1,10 @@
+import { Difference } from '../types/lib/compare';
+/**
+ * 1. If objects are not of the same type or are primitive types, compares directly.
+ * 2. Gets the keys from both objects.
+ * 3. If both are arrays, checks their elements.
+ * 4. Checks for keys present in both objects.
+ *    If key is `execution`, omit unnecessary params.
+ * 5. If all keys are checked and no differences are found, return empty object.
+ */
+export declare const compare: (source: any, target: any, path?: string) => Difference;