@grnsft/if 0.7.0 → 0.7.1

package/build/if-csv/types/process-args.d.ts

@@ -0,0 +1,5 @@
+export interface IFCsvArgs {
+    manifest?: string;
+    output?: string;
+    params: string;
+}

package/build/if-csv/types/process-args.js

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

package/build/if-csv/util/args.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks for `manifest` and `params` flags to be present.
+ */
+export declare const parseIfCsvArgs: () => Promise<{
+    manifest: string;
+    output: string | undefined;
+    params: string;
+} | {
+    output: string | undefined;
+    params: string;
+    manifest?: undefined;
+}>;

package/build/if-csv/util/args.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfCsvArgs = void 0;
+const ts_command_line_args_1 = require("ts-command-line-args");
+const utils_1 = require("@grnsft/if-core/utils");
+const yaml_1 = require("../../common/util/yaml");
+const helpers_1 = require("../../common/util/helpers");
+const config_1 = require("../config");
+const config_2 = require("../../common/config");
+const fs_1 = require("../../common/util/fs");
+const { ParseCliParamsError, CliSourceFileError } = utils_1.ERRORS;
+const { ARGS, HELP } = config_1.CONFIG;
+const { SOURCE_IS_NOT_YAML, MANIFEST_NOT_FOUND } = config_2.STRINGS;
+/**
+ * Parses `if-csv` process arguments.
+ */
+const validateAndParseIfCsvArgs = () => {
+    try {
+        return (0, ts_command_line_args_1.parse)(ARGS, HELP);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new ParseCliParamsError(error.message);
+        }
+        throw error;
+    }
+};
+/**
+ * Checks for `manifest` and `params` flags to be present.
+ */
+const parseIfCsvArgs = async () => {
+    const { manifest, output, params } = validateAndParseIfCsvArgs();
+    if (manifest) {
+        const response = (0, helpers_1.prependFullFilePath)(manifest);
+        const isManifestFileExists = await (0, fs_1.isFileExists)(response);
+        if (!isManifestFileExists) {
+            throw new ParseCliParamsError(MANIFEST_NOT_FOUND);
+        }
+        if ((0, yaml_1.checkIfFileIsYaml)(manifest)) {
+            return { manifest, output, params };
+        }
+        throw new CliSourceFileError(SOURCE_IS_NOT_YAML);
+    }
+    return { output, params };
+};
+exports.parseIfCsvArgs = parseIfCsvArgs;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-csv/util/helpers.d.ts

@@ -0,0 +1,9 @@
+import { CsvOptions } from '../types/csv';
+/**
+ * Gets the manifest data if `outputs` is present in it.
+ */
+export declare const getManifestData: (manifest: string) => Promise<any>;
+/**
+ * Generates a CSV file based on the provided tree structure, context, output path, and params.
+ */
+export declare const generateCsv: (options: CsvOptions) => Promise<string | void>;

package/build/if-csv/util/helpers.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCsv = exports.getManifestData = void 0;
+const fs = __importStar(require("fs/promises"));
+const sync_1 = require("csv-stringify/sync");
+const utils_1 = require("@grnsft/if-core/utils");
+const load_1 = require("../../common/lib/load");
+const config_1 = require("../config");
+const { FAILURE_MESSAGE_OUTPUTS } = config_1.STRINGS;
+const { ManifestValidationError } = utils_1.ERRORS;
+/**
+ * Gets the manifest data if `outputs` is present in it.
+ */
+const getManifestData = async (manifest) => {
+    const { rawManifest } = await (0, load_1.load)(manifest);
+    const { children } = rawManifest.tree;
+    if (children?.child?.outputs || children?.['child-0']?.outputs) {
+        return rawManifest;
+    }
+    throw new ManifestValidationError(FAILURE_MESSAGE_OUTPUTS);
+};
+exports.getManifestData = getManifestData;
+/**
+ * Generates a CSV file based on the provided tree structure, context, output path, and params.
+ */
+const generateCsv = async (options) => {
+    const { tree, context, outputPath, params } = options;
+    const columns = ['Path'];
+    const matrix = [columns];
+    const aggregationIsEnabled = !!context.aggregation;
+    const traverseTree = (node, params, path = 'tree') => {
+        if (node.aggregated) {
+            if (path === 'tree') {
+                columns.push('Aggregated');
+            }
+            matrix.push([`${path}.${params}`, node.aggregated[params]]);
+        }
+        if (node.outputs) {
+            node.outputs.forEach((output) => {
+                const { timestamp } = output;
+                if (!columns.includes(timestamp)) {
+                    columns.push(timestamp);
+                }
+                const lastRow = matrix[matrix.length - 1];
+                if (aggregationIsEnabled) {
+                    lastRow.push(output[params]);
+                }
+                else {
+                    if (matrix.length === 1 || lastRow.length === columns.length) {
+                        matrix.push([`${path}.${params}`, output[params]]);
+                    }
+                    else {
+                        lastRow.push(output[params]);
+                    }
+                }
+            });
+        }
+        if (node.children) {
+            Object.keys(node.children).forEach(childKey => {
+                traverseTree(node.children[childKey], params, `${path}.children.${childKey}`);
+            });
+        }
+    };
+    traverseTree(tree, params);
+    const csvString = (0, sync_1.stringify)(matrix, { columns });
+    if (!outputPath) {
+        return csvString;
+    }
+    return await fs.writeFile(`${outputPath}.csv`, csvString);
+};
+exports.generateCsv = generateCsv;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pZi1jc3YvdXRpbC9oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQWtDO0FBQ2xDLDZDQUE2QztBQUU3QyxpREFBNkM7QUFFN0MsZ0RBQTJDO0FBRzNDLHNDQUFrQztBQUVsQyxNQUFNLEVBQUMsdUJBQXVCLEVBQUMsR0FBRyxnQkFBTyxDQUFDO0FBQzFDLE1BQU0sRUFBQyx1QkFBdUIsRUFBQyxHQUFHLGNBQU0sQ0FBQztBQUV6Qzs7R0FFRztBQUNJLE1BQU0sZUFBZSxHQUFHLEtBQUssRUFBRSxRQUFnQixFQUFFLEVBQUU7SUFDeEQsTUFBTSxFQUFDLFdBQVcsRUFBQyxHQUFHLE1BQU0sSUFBQSxXQUFJLEVBQUMsUUFBUSxDQUFDLENBQUM7SUFDM0MsTUFBTSxFQUFDLFFBQVEsRUFBQyxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUM7SUFFcEMsSUFBSSxRQUFRLEVBQUUsS0FBSyxFQUFFLE9BQU8sSUFBSSxRQUFRLEVBQUUsQ0FBQyxTQUFTLENBQUMsRUFBRSxPQUFPLEVBQUU7UUFDOUQsT0FBTyxXQUFXLENBQUM7S0FDcEI7SUFFRCxNQUFNLElBQUksdUJBQXVCLENBQUMsdUJBQXVCLENBQUMsQ0FBQztBQUM3RCxDQUFDLENBQUM7QUFUVyxRQUFBLGVBQWUsbUJBUzFCO0FBRUY7O0dBRUc7QUFDSSxNQUFNLFdBQVcsR0FBRyxLQUFLLEVBQUUsT0FBbUIsRUFBRSxFQUFFO0lBQ3ZELE1BQU0sRUFBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUMsR0FBRyxPQUFPLENBQUM7SUFDcEQsTUFBTSxPQUFPLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUN6QixNQUFNLE1BQU0sR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3pCLE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUM7SUFFbkQsTUFBTSxZQUFZLEdBQUcsQ0FBQyxJQUFTLEVBQUUsTUFBYyxFQUFFLElBQUksR0FBRyxNQUFNLEVBQUUsRUFBRTtRQUNoRSxJQUFJLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDbkIsSUFBSSxJQUFJLEtBQUssTUFBTSxFQUFFO2dCQUNuQixPQUFPLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO2FBQzVCO1lBQ0QsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsSUFBSSxJQUFJLE1BQU0sRUFBRSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQzdEO1FBRUQsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBb0IsRUFBRSxFQUFFO2dCQUM1QyxNQUFNLEVBQUMsU0FBUyxFQUFDLEdBQUcsTUFBTSxDQUFDO2dCQUUzQixJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsRUFBRTtvQkFDaEMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztpQkFDekI7Z0JBRUQsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7Z0JBRTFDLElBQUksb0JBQW9CLEVBQUU7b0JBQ3hCLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7aUJBQzlCO3FCQUFNO29CQUNMLElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxPQUFPLENBQUMsTUFBTSxFQUFFO3dCQUM1RCxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxJQUFJLElBQUksTUFBTSxFQUFFLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztxQkFDcEQ7eUJBQU07d0JBQ0wsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztxQkFDOUI7aUJBQ0Y7WUFDSCxDQUFDLENBQUMsQ0FBQztTQUNKO1FBRUQsSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2pCLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRTtnQkFDNUMsWUFBWSxDQUNWLElBQUksQ0FBQyxRQUFTLENBQUMsUUFBUSxDQUFDLEVBQ3hCLE1BQU0sRUFDTixHQUFHLElBQUksYUFBYSxRQUFRLEVBQUUsQ0FDL0IsQ0FBQztZQUNKLENBQUMsQ0FBQyxDQUFDO1NBQ0o7SUFDSCxDQUFDLENBQUM7SUFFRixZQUFZLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBRTNCLE1BQU0sU0FBUyxHQUFHLElBQUEsZ0JBQVMsRUFBQyxNQUFNLEVBQUUsRUFBQyxPQUFPLEVBQUMsQ0FBQyxDQUFDO0lBRS9DLElBQUksQ0FBQyxVQUFVLEVBQUU7UUFDZixPQUFPLFNBQVMsQ0FBQztLQUNsQjtJQUVELE9BQU8sTUFBTSxFQUFFLENBQUMsU0FBUyxDQUFDLEdBQUcsVUFBVSxNQUFNLEVBQUUsU0FBUyxDQUFDLENBQUM7QUFDNUQsQ0FBQyxDQUFDO0FBeERXLFFBQUEsV0FBVyxlQXdEdEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBmcyBmcm9tICdmcy9wcm9taXNlcyc7XG5pbXBvcnQge3N0cmluZ2lmeX0gZnJvbSAnY3N2LXN0cmluZ2lmeS9zeW5jJztcbmltcG9ydCB7UGx1Z2luUGFyYW1zfSBmcm9tICdAZ3Juc2Z0L2lmLWNvcmUvdHlwZXMnO1xuaW1wb3J0IHtFUlJPUlN9IGZyb20gJ0Bncm5zZnQvaWYtY29yZS91dGlscyc7XG5cbmltcG9ydCB7bG9hZH0gZnJvbSAnLi4vLi4vY29tbW9uL2xpYi9sb2FkJztcblxuaW1wb3J0IHtDc3ZPcHRpb25zfSBmcm9tICcuLi90eXBlcy9jc3YnO1xuaW1wb3J0IHtTVFJJTkdTfSBmcm9tICcuLi9jb25maWcnO1xuXG5jb25zdCB7RkFJTFVSRV9NRVNTQUdFX09VVFBVVFN9ID0gU1RSSU5HUztcbmNvbnN0IHtNYW5pZmVzdFZhbGlkYXRpb25FcnJvcn0gPSBFUlJPUlM7XG5cbi8qKlxuICogR2V0cyB0aGUgbWFuaWZlc3QgZGF0YSBpZiBgb3V0cHV0c2AgaXMgcHJlc2VudCBpbiBpdC5cbiAqL1xuZXhwb3J0IGNvbnN0IGdldE1hbmlmZXN0RGF0YSA9IGFzeW5jIChtYW5pZmVzdDogc3RyaW5nKSA9PiB7XG4gIGNvbnN0IHtyYXdNYW5pZmVzdH0gPSBhd2FpdCBsb2FkKG1hbmlmZXN0KTtcbiAgY29uc3Qge2NoaWxkcmVufSA9IHJhd01hbmlmZXN0LnRyZWU7XG5cbiAgaWYgKGNoaWxkcmVuPy5jaGlsZD8ub3V0cHV0cyB8fCBjaGlsZHJlbj8uWydjaGlsZC0wJ10/Lm91dHB1dHMpIHtcbiAgICByZXR1cm4gcmF3TWFuaWZlc3Q7XG4gIH1cblxuICB0aHJvdyBuZXcgTWFuaWZlc3RWYWxpZGF0aW9uRXJyb3IoRkFJTFVSRV9NRVNTQUdFX09VVFBVVFMpO1xufTtcblxuLyoqXG4gKiBHZW5lcmF0ZXMgYSBDU1YgZmlsZSBiYXNlZCBvbiB0aGUgcHJvdmlkZWQgdHJlZSBzdHJ1Y3R1cmUsIGNvbnRleHQsIG91dHB1dCBwYXRoLCBhbmQgcGFyYW1zLlxuICovXG5leHBvcnQgY29uc3QgZ2VuZXJhdGVDc3YgPSBhc3luYyAob3B0aW9uczogQ3N2T3B0aW9ucykgPT4ge1xuICBjb25zdCB7dHJlZSwgY29udGV4dCwgb3V0cHV0UGF0aCwgcGFyYW1zfSA9IG9wdGlvbnM7XG4gIGNvbnN0IGNvbHVtbnMgPSBbJ1BhdGgnXTtcbiAgY29uc3QgbWF0cml4ID0gW2NvbHVtbnNdO1xuICBjb25zdCBhZ2dyZWdhdGlvbklzRW5hYmxlZCA9ICEhY29udGV4dC5hZ2dyZWdhdGlvbjtcblxuICBjb25zdCB0cmF2ZXJzZVRyZWUgPSAobm9kZTogYW55LCBwYXJhbXM6IHN0cmluZywgcGF0aCA9ICd0cmVlJykgPT4ge1xuICAgIGlmIChub2RlLmFnZ3JlZ2F0ZWQpIHtcbiAgICAgIGlmIChwYXRoID09PSAndHJlZScpIHtcbiAgICAgICAgY29sdW1ucy5wdXNoKCdBZ2dyZWdhdGVkJyk7XG4gICAgICB9XG4gICAgICBtYXRyaXgucHVzaChbYCR7cGF0aH0uJHtwYXJhbXN9YCwgbm9kZS5hZ2dyZWdhdGVkW3BhcmFtc11dKTtcbiAgICB9XG5cbiAgICBpZiAobm9kZS5vdXRwdXRzKSB7XG4gICAgICBub2RlLm91dHB1dHMuZm9yRWFjaCgob3V0cHV0OiBQbHVnaW5QYXJhbXMpID0+IHtcbiAgICAgICAgY29uc3Qge3RpbWVzdGFtcH0gPSBvdXRwdXQ7XG5cbiAgICAgICAgaWYgKCFjb2x1bW5zLmluY2x1ZGVzKHRpbWVzdGFtcCkpIHtcbiAgICAgICAgICBjb2x1bW5zLnB1c2godGltZXN0YW1wKTtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnN0IGxhc3RSb3cgPSBtYXRyaXhbbWF0cml4Lmxlbmd0aCAtIDFdO1xuXG4gICAgICAgIGlmIChhZ2dyZWdhdGlvbklzRW5hYmxlZCkge1xuICAgICAgICAgIGxhc3RSb3cucHVzaChvdXRwdXRbcGFyYW1zXSk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgaWYgKG1hdHJpeC5sZW5ndGggPT09IDEgfHwgbGFzdFJvdy5sZW5ndGggPT09IGNvbHVtbnMubGVuZ3RoKSB7XG4gICAgICAgICAgICBtYXRyaXgucHVzaChbYCR7cGF0aH0uJHtwYXJhbXN9YCwgb3V0cHV0W3BhcmFtc11dKTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgbGFzdFJvdy5wdXNoKG91dHB1dFtwYXJhbXNdKTtcbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH0pO1xuICAgIH1cblxuICAgIGlmIChub2RlLmNoaWxkcmVuKSB7XG4gICAgICBPYmplY3Qua2V5cyhub2RlLmNoaWxkcmVuKS5mb3JFYWNoKGNoaWxkS2V5ID0+IHtcbiAgICAgICAgdHJhdmVyc2VUcmVlKFxuICAgICAgICAgIG5vZGUuY2hpbGRyZW4hW2NoaWxkS2V5XSxcbiAgICAgICAgICBwYXJhbXMsXG4gICAgICAgICAgYCR7cGF0aH0uY2hpbGRyZW4uJHtjaGlsZEtleX1gXG4gICAgICAgICk7XG4gICAgICB9KTtcbiAgICB9XG4gIH07XG5cbiAgdHJhdmVyc2VUcmVlKHRyZWUsIHBhcmFtcyk7XG5cbiAgY29uc3QgY3N2U3RyaW5nID0gc3RyaW5naWZ5KG1hdHJpeCwge2NvbHVtbnN9KTtcblxuICBpZiAoIW91dHB1dFBhdGgpIHtcbiAgICByZXR1cm4gY3N2U3RyaW5nO1xuICB9XG5cbiAgcmV0dXJuIGF3YWl0IGZzLndyaXRlRmlsZShgJHtvdXRwdXRQYXRofS5jc3ZgLCBjc3ZTdHJpbmcpO1xufTtcbiJdfQ==

package/build/if-diff/config/config.d.ts

@@ -0,0 +1,6 @@
+import { ArgumentConfig, ParseOptions } from 'ts-command-line-args';
+import { IFDiffArgs } from '../types/process-args';
+export declare const CONFIG: {
+    ARGS: ArgumentConfig<IFDiffArgs>;
+    HELP: ParseOptions<any>;
+};

package/build/if-diff/config/config.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const config_1 = require("../../common/config");
+const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+exports.CONFIG = {
+    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 },
+        ],
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/if-diff/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaWYtZGlmZi9jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQWdDO0FBQXhCLGdHQUFBLE1BQU0sT0FBQTtBQUNkLHFDQUFrQztBQUExQixrR0FBQSxPQUFPLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge0NPTkZJR30gZnJvbSAnLi9jb25maWcnO1xuZXhwb3J0IHtTVFJJTkdTfSBmcm9tICcuL3N0cmluZ3MnO1xuIl19

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

@@ -0,0 +1,6 @@
+export declare const STRINGS: {
+    INVALID_TARGET: string;
+    INVALID_SOURCE: string;
+    FAILURE_MESSAGE: string;
+    SUCCESS_MESSAGE: string;
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = void 0;
+exports.STRINGS = {
+    INVALID_TARGET: 'Target is invalid.',
+    INVALID_SOURCE: 'Source is invalid.',
+    FAILURE_MESSAGE: 'Files do not match!',
+    SUCCESS_MESSAGE: 'Files match!',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pZi1kaWZmL2NvbmZpZy9zdHJpbmdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFhLFFBQUEsT0FBTyxHQUFHO0lBQ3JCLGNBQWMsRUFBRSxvQkFBb0I7SUFDcEMsY0FBYyxFQUFFLG9CQUFvQjtJQUNwQyxlQUFlLEVBQUUscUJBQXFCO0lBQ3RDLGVBQWUsRUFBRSxjQUFjO0NBQ2hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgU1RSSU5HUyA9IHtcbiAgSU5WQUxJRF9UQVJHRVQ6ICdUYXJnZXQgaXMgaW52YWxpZC4nLFxuICBJTlZBTElEX1NPVVJDRTogJ1NvdXJjZSBpcyBpbnZhbGlkLicsXG4gIEZBSUxVUkVfTUVTU0FHRTogJ0ZpbGVzIGRvIG5vdCBtYXRjaCEnLFxuICBTVUNDRVNTX01FU1NBR0U6ICdGaWxlcyBtYXRjaCEnLFxufTtcbiJdfQ==

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

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

package/build/if-diff/index.js

@@ -0,0 +1,46 @@
+#!/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 helpers_2 = require("../common/util/helpers");
+const validations_1 = require("../common/util/validations");
+const logger_1 = require("../common/util/logger");
+const debug_logger_1 = require("../common/util/debug-logger");
+const config_1 = require("./config");
+const { FAILURE_MESSAGE, SUCCESS_MESSAGE } = config_1.STRINGS;
+const IfDiff = async () => {
+    const pipedSourceManifest = await (0, helpers_2.parseManifestFromStdin)();
+    const { sourcePath, targetPath } = (0, args_1.parseIfDiffArgs)();
+    // Call this function with false parameter to prevent log debug messages.
+    debug_logger_1.debugLogger.overrideConsoleMethods(false);
+    const { rawSourceManifest, rawTargetManifest } = await (0, load_1.loadIfDiffFiles)({
+        targetPath,
+        sourcePath,
+        pipedSourceManifest,
+    });
+    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/if-diff/lib/compare.d.ts

@@ -0,0 +1,10 @@
+import { Difference } from '../types/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;

package/build/if-diff/lib/compare.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = void 0;
+const helpers_1 = require("../util/helpers");
+/**
+ * 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.
+ */
+const compare = (source, target, path = '') => {
+    if ((0, helpers_1.oneIsPrimitive)(source, target)) {
+        return (0, helpers_1.checkIfEqual)(source, target)
+            ? {}
+            : {
+                path,
+                source,
+                target,
+            };
+    }
+    const keys1 = Object.keys(source);
+    const keys2 = Object.keys(target);
+    const allKeys = new Set([...keys1, ...keys2]);
+    if (path === '') {
+        allKeys.delete('name');
+        allKeys.delete('description');
+        allKeys.delete('tags');
+    }
+    if (path === 'initialize') {
+        allKeys.delete('outputs');
+    }
+    if (path === 'execution') {
+        const whitelist = ['status', 'error'];
+        allKeys.forEach(value => {
+            if (!whitelist.includes(value)) {
+                allKeys.delete(value);
+            }
+        });
+    }
+    if (Array.isArray(source) && Array.isArray(target)) {
+        source.forEach((_record, i) => {
+            (0, exports.compare)(source[i], target[i], path ? `${path}[${i}]` : `${i}`);
+        });
+    }
+    for (const key of allKeys) {
+        const result = (0, exports.compare)(source[key], target[key], path ? `${path}.${key}` : key);
+        if (Object.keys(result).length) {
+            return result;
+        }
+    }
+    return {};
+};
+exports.compare = compare;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-diff/lib/load.d.ts

@@ -0,0 +1,63 @@
+import { LoadDiffParams } from '../types/args';
+/**
+ * Loads files to compare. As a source file checks if data is piped and then decides which one to take.
+ */
+export declare const loadIfDiffFiles: (params: LoadDiffParams) => Promise<{
+    rawSourceManifest: unknown;
+    rawTargetManifest: {
+        name: string;
+        initialize: {
+            plugins: Record<string, {
+                path: string;
+                method: string;
+                mapping?: Record<string, string> | undefined;
+                config?: Record<string, any> | undefined;
+                'parameter-metadata'?: {
+                    inputs?: Record<string, {
+                        unit: string;
+                        description: string;
+                        'aggregation-method': {
+                            time: "sum" | "avg" | "none" | "copy";
+                            component: "sum" | "avg" | "none" | "copy";
+                        };
+                    }> | null | undefined;
+                    outputs?: Record<string, {
+                        unit: string;
+                        description: string;
+                        'aggregation-method': {
+                            time: "sum" | "avg" | "none" | "copy";
+                            component: "sum" | "avg" | "none" | "copy";
+                        };
+                    }> | null | undefined;
+                } | undefined;
+            } | undefined>;
+        };
+        tree: Record<string, any>;
+        description?: string | null | undefined;
+        tags?: {
+            kind?: string | null | undefined;
+            complexity?: string | null | undefined;
+            category?: string | null | undefined;
+        } | null | undefined;
+        explainer?: boolean | undefined;
+        explain?: Record<string, any> | undefined;
+        aggregation?: {
+            type: "horizontal" | "time" | "vertical" | "component" | "both";
+            metrics: string[];
+            'skip-components'?: string[] | undefined;
+        } | null | undefined;
+        execution?: {
+            status: string;
+            command?: string | undefined;
+            environment?: {
+                'if-version': string;
+                os: string;
+                'os-version': string;
+                'node-version': string;
+                'date-time': string;
+                dependencies: string[];
+            } | undefined;
+            error?: string | undefined;
+        } | undefined;
+    };
+}>;

package/build/if-diff/lib/load.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIfDiffFiles = void 0;
+const YAML = __importStar(require("js-yaml"));
+const utils_1 = require("@grnsft/if-core/utils");
+const yaml_1 = require("../../common/util/yaml");
+const config_1 = require("../config");
+const { CliSourceFileError } = utils_1.ERRORS;
+const { INVALID_SOURCE } = config_1.STRINGS;
+/**
+ * Loads files to compare. As a source file checks if data is piped and then decides which one to take.
+ */
+const loadIfDiffFiles = async (params) => {
+    const { sourcePath, targetPath, pipedSourceManifest } = params;
+    if (!sourcePath && !pipedSourceManifest) {
+        throw new CliSourceFileError(INVALID_SOURCE);
+    }
+    const loadFromSource = sourcePath && (await (0, yaml_1.openYamlFileAsObject)(sourcePath));
+    const loadFromSTDIN = pipedSourceManifest && (await YAML.load(pipedSourceManifest));
+    const rawSourceManifest = loadFromSource || loadFromSTDIN;
+    const rawTargetManifest = await (0, yaml_1.openYamlFileAsObject)(targetPath);
+    return {
+        rawSourceManifest,
+        rawTargetManifest,
+    };
+};
+exports.loadIfDiffFiles = loadIfDiffFiles;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-diff/types/args.d.ts

@@ -0,0 +1,5 @@
+export type LoadDiffParams = {
+    sourcePath?: string;
+    targetPath: string;
+    pipedSourceManifest?: string;
+};

package/build/if-diff/types/args.js

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

package/build/if-diff/types/compare.d.ts

@@ -0,0 +1,7 @@
+export type Difference = {
+    path?: string;
+    source?: any;
+    target?: any;
+    message?: string;
+    [key: string]: any;
+};

package/build/if-diff/types/compare.js

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

package/build/if-diff/types/process-args.d.ts

@@ -0,0 +1,4 @@
+export interface IFDiffArgs {
+    source?: string;
+    target: string;
+}

package/build/if-diff/types/process-args.js

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

package/build/if-diff/util/args.d.ts

@@ -0,0 +1,5 @@
+import { LoadDiffParams } from '../types/args';
+/**
+ * Checks for `source` and `target` flags to be present.
+ */
+export declare const parseIfDiffArgs: () => LoadDiffParams;

package/build/if-diff/util/args.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfDiffArgs = void 0;
+const ts_command_line_args_1 = require("ts-command-line-args");
+const utils_1 = require("@grnsft/if-core/utils");
+const yaml_1 = require("../../common/util/yaml");
+const helpers_1 = require("../../common/util/helpers");
+const config_1 = require("../config");
+const config_2 = require("../../common/config");
+const { ParseCliParamsError, CliTargetFileError, CliSourceFileError } = utils_1.ERRORS;
+const { ARGS, HELP } = config_1.CONFIG;
+const { INVALID_TARGET } = config_1.STRINGS;
+const { SOURCE_IS_NOT_YAML, TARGET_IS_NOT_YAML } = config_2.STRINGS;
+/**
+ * Parses `if-diff` process arguments.
+ */
+const validateAndParseIfDiffArgs = () => {
+    try {
+        return (0, ts_command_line_args_1.parse)(ARGS, HELP);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new ParseCliParamsError(error.message);
+        }
+        throw error;
+    }
+};
+/**
+ * Checks for `source` and `target` flags to be present.
+ */
+const parseIfDiffArgs = () => {
+    const { source, target } = validateAndParseIfDiffArgs();
+    if (target) {
+        if (source && !(0, yaml_1.checkIfFileIsYaml)(source)) {
+            throw new CliSourceFileError(SOURCE_IS_NOT_YAML);
+        }
+        if ((0, yaml_1.checkIfFileIsYaml)(target)) {
+            const response = {
+                targetPath: (0, helpers_1.prependFullFilePath)(target),
+            };
+            if (source && (0, yaml_1.checkIfFileIsYaml)(source)) {
+                response.sourcePath = (0, helpers_1.prependFullFilePath)(source);
+            }
+            return response;
+        }
+        throw new CliTargetFileError(TARGET_IS_NOT_YAML);
+    }
+    throw new ParseCliParamsError(INVALID_TARGET);
+};
+exports.parseIfDiffArgs = parseIfDiffArgs;
+//# sourceMappingURL=data:application/json;base64,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