@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/entity-compare/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@contrail/entity-compare",
+  "version": "1.1.0",
+  "description": "Library for comparing entities.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "LOG_LEVEL=silent NODE_OPTIONS=--no-node-snapshot jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@contrail/telemetry": "^1.0.2",
+    "@contrail/util": "^1.1.18",
+    "es6-promisify": "^6.1.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.2",
+    "@types/node": "^14.10.1",
+    "jest": "^29.5.0",
+    "prettier": "^1.19.1",
+    "ts-jest": "^29.1.1",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.0.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/node_modules/@contrail/loader/lib/__mocks__/@contrail/cache.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="jest" />
+declare const CacheManager: jest.Mock<any, any, any>;

package/node_modules/@contrail/loader/lib/__mocks__/@contrail/cache.js

@@ -0,0 +1,18 @@
+const CacheManager = jest.fn().mockImplementation(() => {
+    return {
+        async setHashValue(hashName, hashKey, value, json = true, ttl = this.ttlDefault) {
+            if (json) {
+                value = JSON.stringify(value);
+            }
+            return value;
+        },
+        async getHashValue(hashName, hashKey, json = true) {
+            let value = '{}';
+            if (json) {
+                value = JSON.parse(value);
+            }
+            return value;
+        },
+    };
+});
+module.exports = { CacheManager };

package/node_modules/@contrail/loader/lib/base-processor.d.ts

@@ -0,0 +1,17 @@
+import { GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+export declare class BaseProcessor {
+    static typesToTransformBy: string[];
+    static requiredProperties: string[];
+    static transformData(data: any[]): any[];
+    static processFederatedId(federatedId: string, typePath: string): string;
+    static validateRow(row: {
+        federatedId: string;
+    }): boolean;
+    static setExtraProperties(entity: any, type: any): void;
+    static validateLoadFile(data: any[], config: LoaderProcess): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+}

package/node_modules/@contrail/loader/lib/base-processor.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessor = void 0;
+class BaseProcessor {
+    static typesToTransformBy = [];
+    static requiredProperties = [];
+    static transformData(data) {
+        return data;
+    }
+    static processFederatedId(federatedId, typePath) {
+        return federatedId;
+    }
+    static validateRow(row) {
+        return !!row.federatedId;
+    }
+    static setExtraProperties(entity, type) { }
+    static validateLoadFile(data, config) {
+        return {
+            errors: [],
+            warnings: [],
+            generalErrors: [],
+            generalWarnings: [],
+        };
+    }
+}
+exports.BaseProcessor = BaseProcessor;

package/node_modules/@contrail/loader/lib/color-processor.d.ts

@@ -0,0 +1,19 @@
+import { GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+import { BaseProcessor } from './base-processor';
+interface ColorData {
+    hex?: string;
+    [key: string]: any;
+}
+export declare class ColorProcessor extends BaseProcessor {
+    static typesToTransformBy: string[];
+    static requiredProperties: string[];
+    static transformData(data: ColorData[]): ColorData[];
+    private static validateTypePath;
+    static validateLoadFile(data: ColorData[], config: LoaderProcess): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+}
+export {};

package/node_modules/@contrail/loader/lib/color-processor.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorProcessor = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const base_processor_1 = require("./base-processor");
+const entity_processor_1 = require("./entity-processor");
+const constants_1 = require("./constants");
+function removeHexHash(data) {
+    for (const row of data ?? []) {
+        if (row.hex?.startsWith('#')) {
+            row.hex = row.hex.slice(1);
+        }
+    }
+    return data;
+}
+class ColorProcessor extends base_processor_1.BaseProcessor {
+    static typesToTransformBy = ['color'];
+    static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name', 'hex', 'red', 'green', 'blue'];
+    static transformData(data) {
+        if (!data) {
+            return [];
+        }
+        return removeHexHash(data);
+    }
+    static validateTypePath(data, config, csvHeaders, generalErrors) {
+        const typePathSource = {
+            conditional: config?.conditionalColumns?.some((column) => column.toProperty === 'typePath' && column.default === 'color'),
+            federated: config?.federatedMappings?.typePath,
+            csv: csvHeaders?.includes('typePath'),
+        };
+        if (typePathSource.csv) {
+            const hasCorrectTypePath = data.every((row) => row.typePath === 'color');
+            if (!hasCorrectTypePath) {
+                generalErrors.push({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+            return;
+        }
+        if (config?.conditionalColumns?.some((col) => col.toProperty === 'typePath')) {
+            if (!typePathSource.conditional) {
+                generalErrors.push({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+        }
+        if (typePathSource.federated && !csvHeaders.includes(typePathSource.federated)) {
+            generalErrors.push({
+                message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+    static validateLoadFile(data, config) {
+        const { errors, warnings, generalErrors, generalWarnings, csvHeaders } = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+        this.validateTypePath(data, config, csvHeaders, generalErrors);
+        const redColumn = config?.federatedMappings?.red || 'red';
+        const blueColumn = config?.federatedMappings?.blue || 'blue';
+        const greenColumn = config?.federatedMappings?.green || 'green';
+        const hexColumn = config?.federatedMappings?.hex || 'hex';
+        const hasRedColumn = csvHeaders.includes(redColumn);
+        const hasBlueColumn = csvHeaders.includes(blueColumn);
+        const hasGreenColumn = csvHeaders.includes(greenColumn);
+        const hasHexColumn = csvHeaders.includes(hexColumn);
+        if (hasHexColumn && hasRedColumn && hasGreenColumn && hasBlueColumn) {
+            generalWarnings.push({
+                message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        return { errors, warnings, generalErrors, generalWarnings };
+    }
+}
+exports.ColorProcessor = ColorProcessor;

package/node_modules/@contrail/loader/lib/color-processor.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@contrail/loader/lib/color-processor.spec.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_processor_1 = require("./color-processor");
+const entity_types_1 = require("@contrail/entity-types");
+const constants_1 = require("./constants");
+describe('ColorProcessor', () => {
+    const loaderProcess = {
+        id: 'mock-loader-process-id',
+        loadFileId: 'mock-load-file-id',
+        loadType: [entity_types_1.LoadType.COLOR],
+        status: entity_types_1.LoadStatus.COMPLETE,
+        federatedMappings: {
+            federatedId: 'name',
+            name: 'name',
+        },
+        conditionalColumns: [
+            {
+                toProperty: 'typePath',
+                default: 'color',
+            },
+        ],
+    };
+    describe('requiredProperties', () => {
+        it('should have the correct required properties', () => {
+            expect(color_processor_1.ColorProcessor.requiredProperties).toEqual([
+                'typePath',
+                'typeId',
+                'federatedId',
+                'name',
+                'hex',
+                'red',
+                'green',
+                'blue',
+            ]);
+        });
+    });
+    describe('transformData', () => {
+        it('should remove the hash from hex values', () => {
+            const data = [
+                { hex: '#ff0000', name: 'red' },
+                { hex: '#00ff00', name: 'green' },
+                { hex: '#0000ff', name: 'blue' },
+            ];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ]);
+        });
+        it('should not modify hex values that do not start with a hash', () => {
+            const data = [
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ]);
+        });
+        it('should handle empty data', () => {
+            const data = [];
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([]);
+        });
+        it('should handle null or undefined data', () => {
+            const data = null;
+            const result = color_processor_1.ColorProcessor.transformData(data);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('validateLoadFile', () => {
+        describe('typePath validation', () => {
+            it('should validate typePath in conditional columns', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate typePath in CSV data', () => {
+                const data = [
+                    { name: 'color1', typePath: 'color' },
+                    { name: 'color2', typePath: 'color' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should allow typePath to be in either conditional columns or CSV', () => {
+                const dataWithTypePath = [{ name: 'color1', typePath: 'color' }];
+                const configWithConditional = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result1 = color_processor_1.ColorProcessor.validateLoadFile(dataWithTypePath, loaderProcess);
+                const result2 = color_processor_1.ColorProcessor.validateLoadFile([{ name: 'color1' }], configWithConditional);
+                expect(result1.generalErrors).toHaveLength(0);
+                expect(result2.generalErrors).toHaveLength(0);
+            });
+            it('should return no error when typePath is missing from both conditional columns and CSV', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([]);
+            });
+            it('should error when typePath in CSV has incorrect value', () => {
+                const data = [
+                    { name: 'color1', typePath: 'wrong' },
+                    { name: 'color2', typePath: 'color' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when conditional column has incorrect typePath value', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'wrong',
+                        },
+                    ],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should handle mixed conditional columns', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: 'Default Color',
+                        },
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should prioritize CSV typePath over conditional columns', () => {
+                const data = [{ name: 'color1', typePath: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'wrong',
+                        },
+                    ],
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate federatedId in federatedMapping', () => {
+                const data = [{ name: 'color1', typePathCSV: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'typePathCSV',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when federatedId column from mapping is not in CSV', () => {
+                const data = [{ name: 'color1', typePathCSV: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'invalidTypePathCSV',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+        describe('color column validation', () => {
+            it('should warn when both hex and RGB columns are present', () => {
+                const data = [
+                    {
+                        name: 'test-color',
+                        red: '255',
+                        green: '0',
+                        blue: '0',
+                        hex: '#ff0000',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'red',
+                        green: 'green',
+                        blue: 'blue',
+                        hex: 'hex',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should not warn when only RGB columns are present', () => {
+                const data = [
+                    {
+                        name: 'test-color',
+                        red: '255',
+                        green: '0',
+                        blue: '0',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'red',
+                        green: 'green',
+                        blue: 'blue',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should not warn when only hex column is present', () => {
+                const data = [{ name: 'test-color', hex: '#ff0000' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        hex: 'hex',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should handle custom column names from federatedMappings', () => {
+                const data = [{ name: 'test-color', r: '255', g: '0', b: '0', hexcode: '#ff0000' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'r',
+                        green: 'g',
+                        blue: 'b',
+                        hex: 'hexcode',
+                    },
+                };
+                const result = color_processor_1.ColorProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/common/conditional-columns.d.ts

@@ -0,0 +1,16 @@
+export declare class ColumnDefinition {
+    fromProperty?: string;
+    toProperty: string;
+    conditions?: ConditionalValues[];
+    default?: any;
+}
+export declare class ConditionalValues {
+    conditional: string;
+    value: string;
+}
+export declare class ColumnDefinitionEvaluator {
+    static evaluateColumnDefinitionsOnBatch(columnDefinitions: ColumnDefinition[], rows: any[]): void;
+    static evaluateColumnDefinition(columnDefinition: ColumnDefinition, row: any): void;
+    static evaluateConditional(condition: string, row: any): boolean;
+    static getValue(value: any, row: any): any;
+}

package/node_modules/@contrail/loader/lib/common/conditional-columns.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnDefinitionEvaluator = exports.ConditionalValues = exports.ColumnDefinition = void 0;
+const util_1 = require("@contrail/util");
+class ColumnDefinition {
+    fromProperty;
+    toProperty;
+    conditions;
+    default;
+}
+exports.ColumnDefinition = ColumnDefinition;
+class ConditionalValues {
+    conditional;
+    value;
+}
+exports.ConditionalValues = ConditionalValues;
+class ColumnDefinitionEvaluator {
+    static evaluateColumnDefinitionsOnBatch(columnDefinitions, rows) {
+        for (const columnDefinition of columnDefinitions ?? []) {
+            for (const row of rows) {
+                ColumnDefinitionEvaluator.evaluateColumnDefinition(columnDefinition, row);
+            }
+        }
+    }
+    static evaluateColumnDefinition(columnDefinition, row) {
+        if (!columnDefinition?.conditions?.length) {
+            if (columnDefinition.fromProperty) {
+                if ((row[columnDefinition.fromProperty] === null ||
+                    row[columnDefinition.fromProperty] === undefined ||
+                    row[columnDefinition.fromProperty] === '') &&
+                    columnDefinition.default !== undefined) {
+                    row[columnDefinition.toProperty] = ColumnDefinitionEvaluator.getValue(columnDefinition.default, row);
+                }
+                else {
+                    row[columnDefinition.toProperty] = row[columnDefinition.fromProperty];
+                }
+            }
+            else if (columnDefinition.default !== undefined) {
+                row[columnDefinition.toProperty] = ColumnDefinitionEvaluator.getValue(columnDefinition.default, row);
+            }
+            return;
+        }
+        let hit = false;
+        for (const condition of columnDefinition.conditions) {
+            if (ColumnDefinitionEvaluator.evaluateConditional(condition.conditional, row)) {
+                row[columnDefinition.toProperty] = ColumnDefinitionEvaluator.getValue(condition.value, row);
+                hit = true;
+                break;
+            }
+        }
+        if (!hit && columnDefinition.default !== undefined) {
+            row[columnDefinition.toProperty] = ColumnDefinitionEvaluator.getValue(columnDefinition.default, row);
+        }
+    }
+    static evaluateConditional(condition, row) {
+        const parsedCondition = util_1.StringUtil.parseVariables(condition, row, true);
+        let result = false;
+        try {
+            result = evaluateAsBool(parsedCondition);
+        }
+        catch (e) {
+            console.warn('Failed to evaluate conditional. Error: ', e);
+        }
+        return result;
+    }
+    static getValue(value, row) {
+        if (util_1.StringUtil.isString(value) && value.includes('{')) {
+            try {
+                const val = evaluate(util_1.StringUtil.parseVariables(value, row, true));
+                return val;
+            }
+            catch {
+                console.warn(`Error parsing value: ${value}`);
+                return undefined;
+            }
+        }
+        else {
+            return value;
+        }
+    }
+}
+exports.ColumnDefinitionEvaluator = ColumnDefinitionEvaluator;
+const evaluateAsBool = (c) => Function(`return !!(${c})`)();
+const evaluate = (c) => Function(`return ${c}`)();

package/node_modules/@contrail/loader/lib/common/conditional-columns.spec.d.ts

@@ -0,0 +1 @@
+export {};