@contrail/cli 3.5.0-alpha.dd20a19 → 3.5.1-alpha.63493a5

package/node_modules/@contrail/loader/lib/common/color-validation.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHexPriorityToRows = exports.buildColorRowIssues = exports.validateColorRow = exports.parseRgbComponent = exports.isValidHex = exports.DEFAULT_HEX = exports.COLOR_VALIDATION_MESSAGES = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const validate_color_1 = require("validate-color");
+exports.COLOR_VALIDATION_MESSAGES = {
+    HEX_INVALID: (hex) => `"hex" value "${hex}" is not a valid hex color code (expected 3, 4, 6, or 8 hex digits, optionally prefixed with #).`,
+    RGB_INCOMPLETE: (missingColumns) => `Row has partial RGB data — "${missingColumns.join('", "')}" must also be provided when using RGB. Provide all of red/green/blue, or use "hex" instead.`,
+    RGB_OUT_OF_RANGE: (column, value) => `"${column}" value "${value}" is not a valid RGB component (must be a whole number between 0 and 255).`,
+    HEX_PRIORITIZED_OVER_RGB: 'Both "hex" and red/green/blue values are provided — "hex" will be used and red/green/blue will be ignored for this row.',
+};
+exports.DEFAULT_HEX = '000000';
+const RGB_TARGET_KEYS = ['red', 'green', 'blue'];
+const HEX_TARGET_KEY = 'hex';
+function getColorValue(row, federatedMappings, targetKey) {
+    const target = row[targetKey];
+    if (!isEmpty(target))
+        return target;
+    const sourceColumn = federatedMappings?.[targetKey];
+    if (sourceColumn && sourceColumn !== targetKey)
+        return row[sourceColumn];
+    return target;
+}
+function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+function isValidHex(hex) {
+    if (typeof hex !== 'string' || hex.length === 0)
+        return false;
+    const normalized = hex.startsWith('#') ? hex : `#${hex}`;
+    return (0, validate_color_1.validateHTMLColorHex)(normalized);
+}
+exports.isValidHex = isValidHex;
+function parseRgbComponent(value) {
+    if (isEmpty(value))
+        return null;
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 255)
+        return value;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '' || !/^-?\d+$/.test(trimmed))
+            return null;
+        const n = Number(trimmed);
+        if (!Number.isInteger(n) || n < 0 || n > 255)
+            return null;
+        return n;
+    }
+    return null;
+}
+exports.parseRgbComponent = parseRgbComponent;
+function validateColorRow(row, federatedMappings) {
+    const errors = [];
+    const warnings = [];
+    const hexValue = getColorValue(row, federatedMappings, HEX_TARGET_KEY);
+    const rgbValues = {
+        red: getColorValue(row, federatedMappings, 'red'),
+        green: getColorValue(row, federatedMappings, 'green'),
+        blue: getColorValue(row, federatedMappings, 'blue'),
+    };
+    const rgbProvided = RGB_TARGET_KEYS.filter((k) => !isEmpty(rgbValues[k]));
+    const hexProvided = !isEmpty(hexValue);
+    if (hexProvided) {
+        if (!isValidHex(String(hexValue))) {
+            errors.push({
+                columnName: HEX_TARGET_KEY,
+                message: exports.COLOR_VALIDATION_MESSAGES.HEX_INVALID(String(hexValue)),
+            });
+        }
+        if (rgbProvided.length > 0) {
+            warnings.push({
+                columnName: HEX_TARGET_KEY,
+                message: exports.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+            });
+        }
+        return { errors, warnings };
+    }
+    if (rgbProvided.length === 0) {
+        return { errors, warnings };
+    }
+    if (rgbProvided.length < RGB_TARGET_KEYS.length) {
+        const missing = RGB_TARGET_KEYS.filter((k) => isEmpty(rgbValues[k]));
+        for (const k of missing) {
+            errors.push({
+                columnName: k,
+                message: exports.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE([...missing]),
+            });
+        }
+        return { errors, warnings };
+    }
+    for (const k of RGB_TARGET_KEYS) {
+        if (parseRgbComponent(rgbValues[k]) === null) {
+            errors.push({
+                columnName: k,
+                message: exports.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE(k, String(rgbValues[k])),
+            });
+        }
+    }
+    return { errors, warnings };
+}
+exports.validateColorRow = validateColorRow;
+function buildColorRowIssues(row, rowNumber, federatedMappings) {
+    const { errors, warnings } = validateColorRow(row, federatedMappings);
+    const rowJson = JSON.stringify(row);
+    const rowErrors = errors.length
+        ? {
+            rowNumber,
+            columnIssues: errors.map((e) => ({
+                columnName: e.columnName,
+                message: e.message,
+                issueType: entity_types_1.IssueType.INVALID_DATA,
+                data: rowJson,
+            })),
+        }
+        : null;
+    const rowWarnings = warnings.length
+        ? {
+            rowNumber,
+            columnIssues: warnings.map((w) => ({
+                columnName: w.columnName,
+                message: w.message,
+                issueType: entity_types_1.IssueType.INVALID_DATA,
+                data: rowJson,
+            })),
+        }
+        : null;
+    return { rowErrors, rowWarnings };
+}
+exports.buildColorRowIssues = buildColorRowIssues;
+function applyHexPriorityToRows(rows) {
+    for (const r of rows ?? []) {
+        if (!r)
+            continue;
+        const row = r;
+        const hexRaw = row.hex;
+        const hexNormalized = typeof hexRaw === 'string' && hexRaw.startsWith('#') ? hexRaw.slice(1) : hexRaw;
+        const hexValid = !isEmpty(hexNormalized) && isValidHex(String(hexNormalized));
+        if (hexValid) {
+            row.hex = hexNormalized;
+            delete row.red;
+            delete row.green;
+            delete row.blue;
+            continue;
+        }
+        const rgbAllValid = parseRgbComponent(row.red) !== null &&
+            parseRgbComponent(row.green) !== null &&
+            parseRgbComponent(row.blue) !== null;
+        if (rgbAllValid) {
+            if (!isEmpty(hexNormalized)) {
+                row.hex = hexNormalized;
+            }
+            else if ('hex' in row) {
+                delete row.hex;
+            }
+            continue;
+        }
+        row.hex = exports.DEFAULT_HEX;
+        delete row.red;
+        delete row.green;
+        delete row.blue;
+    }
+    return rows;
+}
+exports.applyHexPriorityToRows = applyHexPriorityToRows;

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_validation_1 = require("./color-validation");
+describe('isValidHex', () => {
+    it.each(['#ff0000', 'ff0000', '#FFF', 'fff', '#1a2b3c', '#FFFFFFFF'])('accepts %s', (hex) => {
+        expect((0, color_validation_1.isValidHex)(hex)).toBe(true);
+    });
+    it.each(['', 'notahex', 'gggggg', '#12345', '#1234567', '   ', '#'])('rejects %s', (hex) => {
+        expect((0, color_validation_1.isValidHex)(hex)).toBe(false);
+    });
+});
+describe('parseRgbComponent', () => {
+    it('parses valid integers in range', () => {
+        expect((0, color_validation_1.parseRgbComponent)('0')).toBe(0);
+        expect((0, color_validation_1.parseRgbComponent)('255')).toBe(255);
+        expect((0, color_validation_1.parseRgbComponent)(128)).toBe(128);
+    });
+    it('rejects out-of-range, non-integer, and empty values', () => {
+        expect((0, color_validation_1.parseRgbComponent)('-1')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('256')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('1.5')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('foo')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)('')).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)(null)).toBe(null);
+        expect((0, color_validation_1.parseRgbComponent)(undefined)).toBe(null);
+    });
+});
+describe('validateColorRow', () => {
+    it('returns no errors when only valid hex is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ hex: '#ff0000' })).toEqual({ errors: [], warnings: [] });
+    });
+    it('returns no errors when only valid RGB is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ red: '255', green: '0', blue: '0' })).toEqual({
+            errors: [],
+            warnings: [],
+        });
+    });
+    it('errors on invalid hex', () => {
+        const result = (0, color_validation_1.validateColorRow)({ hex: 'zzz' });
+        expect(result.errors).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('zzz') },
+        ]);
+    });
+    it('warns when both hex and RGB are populated', () => {
+        const result = (0, color_validation_1.validateColorRow)({ hex: '#fff', red: '1', green: '2', blue: '3' });
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
+        ]);
+    });
+    it('errors per-missing-column when RGB is partial and hex is missing', () => {
+        const result = (0, color_validation_1.validateColorRow)({ red: '255' });
+        expect(result.errors).toEqual([
+            { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
+            { columnName: 'blue', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['green', 'blue']) },
+        ]);
+    });
+    it('errors when an RGB component is out of range', () => {
+        const result = (0, color_validation_1.validateColorRow)({ red: '999', green: '0', blue: '0' });
+        expect(result.errors).toEqual([
+            { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '999') },
+        ]);
+    });
+    it('reports no errors when neither hex nor RGB is present', () => {
+        expect((0, color_validation_1.validateColorRow)({ name: 'foo' })).toEqual({ errors: [], warnings: [] });
+    });
+    it('resolves federatedMappings to source columns', () => {
+        const row = { hexcode: '#fff', r: '255', g: '0', b: '0' };
+        const mappings = { hex: 'hexcode', red: 'r', green: 'g', blue: 'b' };
+        const result = (0, color_validation_1.validateColorRow)(row, mappings);
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([
+            { columnName: 'hex', message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB },
+        ]);
+    });
+});
+describe('applyHexPriorityToRows', () => {
+    it('strips RGB columns when hex is valid', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([
+            { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'foo' },
+        ]);
+        expect(result).toEqual([{ hex: 'ff0000', name: 'foo' }]);
+    });
+    it('keeps RGB and removes empty hex when hex is absent', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
+        expect(result).toEqual([{ red: '1', green: '2', blue: '3', name: 'foo' }]);
+    });
+    it('defaults to DEFAULT_HEX when neither valid hex nor full RGB is present', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([{ name: 'foo' }]);
+        expect(result).toEqual([{ name: 'foo', hex: color_validation_1.DEFAULT_HEX }]);
+    });
+    it('treats invalid hex as missing and falls through to RGB or default', () => {
+        const result = (0, color_validation_1.applyHexPriorityToRows)([
+            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
+            { hex: 'zzz', name: 'no-rgb' },
+        ]);
+        expect(result).toEqual([
+            { hex: 'zzz', red: '1', green: '2', blue: '3', name: 'with-rgb' },
+            { hex: color_validation_1.DEFAULT_HEX, name: 'no-rgb' },
+        ]);
+    });
+});

package/node_modules/@contrail/loader/lib/common/size-range-helpers.js

@@ -53,7 +53,6 @@ class SizeRangeSanitizer {
                 }
                 const typePropertySlugs = type?.typeProperties?.map((x) => x.slug);
                 if ((0, lodash_1.intersection)(typePropertySlugs, [exports.SIZE_RANGE_SLUG, exports.SIZE_RANGE_TEMPLATE_SLUG]).length !== 2) {
-                    console.debug(`No size ranges for type ${JSON.stringify(type, null, 2)}, skipping.`);
                     continue;
                 }
                 validTypePaths.push(typePath);

package/node_modules/@contrail/loader/lib/constants.d.ts

@@ -1,9 +1,6 @@
 export declare const COLOR_PROCESSOR_ERRORS: {
     readonly TYPEPATH_MISSING: "\"typePath\" with value \"color\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"color\" with one of these methods, then try the load again.";
 };
-export declare const COLOR_PROCESSOR_WARNINGS: {
-    readonly HEX_IGNORED_WARNING: "\"Hex\" is ignored when red, green, and blue columns are present";
-};
 export declare const CUSTOM_ENTITY_PROCESSOR_ERRORS: {
     readonly TYPEPATH_MISSING: "\"typePath\" with value \"custom-entity:<subtypepath>\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"custom-entity:<subtypepath>\" with one of these methods, then try the load again.";
 };

package/node_modules/@contrail/loader/lib/constants.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ITEM_PROCESSOR_WARNINGS = exports.FEDERATED_ID_FETCH_MAX_COUNT = exports.FEDERATED_ID_FETCH_MAX_URL_BYTES = exports.ITEM_PROCESSOR_ERRORS = exports.ENTITY_PROCESSOR_ERRORS = exports.CUSTOM_ENTITY_PROCESSOR_ERRORS = exports.COLOR_PROCESSOR_WARNINGS = exports.COLOR_PROCESSOR_ERRORS = void 0;
+exports.ITEM_PROCESSOR_WARNINGS = exports.FEDERATED_ID_FETCH_MAX_COUNT = exports.FEDERATED_ID_FETCH_MAX_URL_BYTES = exports.ITEM_PROCESSOR_ERRORS = exports.ENTITY_PROCESSOR_ERRORS = exports.CUSTOM_ENTITY_PROCESSOR_ERRORS = exports.COLOR_PROCESSOR_ERRORS = void 0;
 exports.COLOR_PROCESSOR_ERRORS = {
     TYPEPATH_MISSING: '"typePath" with value "color" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "typePath" mapping with value "color" with one of these methods, then try the load again.',
 };
-exports.COLOR_PROCESSOR_WARNINGS = {
-    HEX_IGNORED_WARNING: '"Hex" is ignored when red, green, and blue columns are present',
-};
 exports.CUSTOM_ENTITY_PROCESSOR_ERRORS = {
     TYPEPATH_MISSING: '"typePath" with value "custom-entity:<subtypepath>" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "typePath" mapping with value "custom-entity:<subtypepath>" with one of these methods, then try the load again.',
 };

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

@@ -6,14 +6,7 @@ const util_1 = require("../../common/util");
 const entity_processor_v2_1 = require("../entity-processor-v2");
 const constants_1 = require("../../constants");
 const base_processor_v2_1 = require("../base-processor-v2");
-function removeHexHash(data) {
-    for (const row of data ?? []) {
-        if (row.hex?.startsWith('#')) {
-            row.hex = row.hex.slice(1);
-        }
-    }
-    return data;
-}
+const color_validation_1 = require("../../common/color-validation");
 class ColorProcessorV2 extends base_processor_v2_1.BaseProcessorV2 {
     static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name', 'hex', 'red', 'green', 'blue'];
     static canAddProperty(allPropertiesSlugs, propertyName) {
@@ -23,7 +16,7 @@ class ColorProcessorV2 extends base_processor_v2_1.BaseProcessorV2 {
         if (!data) {
             return [];
         }
-        return removeHexHash(data);
+        return (0, color_validation_1.applyHexPriorityToRows)(data);
     }
     static validateLoadFile(data, config) {
         const { errors, warnings, generalErrors, generalWarnings, csvHeaders, returnImmediately } = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
@@ -41,20 +34,13 @@ class ColorProcessorV2 extends base_processor_v2_1.BaseProcessorV2 {
         if (duplicateFederatedIdErrors.length) {
             errors.push(...duplicateFederatedIdErrors);
         }
-        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,
-            });
-        }
+        data.forEach((row, index) => {
+            const { rowErrors, rowWarnings } = (0, color_validation_1.buildColorRowIssues)(row, index + 2, config?.federatedMappings);
+            if (rowErrors)
+                errors.push(rowErrors);
+            if (rowWarnings)
+                warnings.push(rowWarnings);
+        });
         return { errors, warnings, generalErrors, generalWarnings };
     }
     static validateTypePath(data, config, csvHeaders, generalErrors) {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("../../constants");
 const color_processor_v2_1 = require("./color-processor-v2");
 const entity_types_1 = require("@contrail/entity-types");
+const color_validation_1 = require("../../common/color-validation");
 describe('ColorProcessorV2', () => {
     const loaderProcess = {
         id: 'mock-loader-process-id',
@@ -219,72 +220,38 @@ describe('ColorProcessorV2', () => {
             });
         });
         describe('color column validation', () => {
-            it('should warn when both hex and RGB columns are present', () => {
+            it('warns per-row when both hex and RGB are populated (hex prioritized)', () => {
                 const data = [
-                    {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                        hex: '#ff0000',
-                    },
+                    { 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_v2_1.ColorProcessorV2.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 = [
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([
                     {
-                        name: 'test-color',
-                        red: '255',
-                        green: '0',
-                        blue: '0',
-                    },
-                ];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        red: 'red',
-                        green: 'green',
-                        blue: 'blue',
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
                     },
-                };
-                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                ]);
+            });
+            it('does not warn when only RGB is populated and all components are valid', () => {
+                const data = [{ name: 'test-color', red: '255', green: '0', blue: '0' }];
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
             });
-            it('should not warn when only hex column is present', () => {
+            it('does not warn when only a valid hex is populated', () => {
                 const data = [{ name: 'test-color', hex: '#ff0000' }];
-                const config = {
-                    ...loaderProcess,
-                    federatedMappings: {
-                        ...loaderProcess.federatedMappings,
-                        hex: 'hex',
-                    },
-                };
-                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
-                expect(result.generalWarnings).not.toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.warnings).toEqual([]);
+                expect(result.errors).toEqual([]);
             });
-            it('should handle custom column names from federatedMappings', () => {
+            it('warns per-row when both hex and RGB are populated under federatedMappings', () => {
                 const data = [{ name: 'test-color', r: '255', g: '0', b: '0', hexcode: '#ff0000' }];
                 const config = {
                     ...loaderProcess,
@@ -297,11 +264,94 @@ describe('ColorProcessorV2', () => {
                     },
                 };
                 const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
-                expect(result.generalWarnings).toContainEqual({
-                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
-                    issueType: entity_types_1.IssueType.CONFIG,
+                expect(result.warnings).toEqual([
+                    {
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'hex',
+                                message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_PRIORITIZED_OVER_RGB,
+                                issueType: entity_types_1.IssueType.INVALID_DATA,
+                                data: JSON.stringify(data[0]),
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('errors when hex is invalid', () => {
+                const data = [{ name: 'bad', hex: 'notahex' }];
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        {
+                            columnName: 'hex',
+                            message: color_validation_1.COLOR_VALIDATION_MESSAGES.HEX_INVALID('notahex'),
+                            issueType: entity_types_1.IssueType.INVALID_DATA,
+                        },
+                    ],
                 });
             });
+            it('errors when RGB is partially populated and hex is missing', () => {
+                const data = [{ name: 'partial', red: '255', green: '128' }];
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(1);
+                expect(result.errors[0].rowNumber).toBe(2);
+                expect(result.errors[0].columnIssues).toEqual([
+                    {
+                        columnName: 'blue',
+                        message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_INCOMPLETE(['blue']),
+                        issueType: entity_types_1.IssueType.INVALID_DATA,
+                        data: JSON.stringify(data[0]),
+                    },
+                ]);
+            });
+            it('errors when an RGB component is out of range or non-numeric', () => {
+                const data = [
+                    { name: 'bad-red', red: '300', green: '0', blue: '0' },
+                    { name: 'nan-green', red: '10', green: 'foo', blue: '0' },
+                ];
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toHaveLength(2);
+                expect(result.errors[0]).toMatchObject({
+                    rowNumber: 2,
+                    columnIssues: [
+                        { columnName: 'red', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('red', '300') },
+                    ],
+                });
+                expect(result.errors[1]).toMatchObject({
+                    rowNumber: 3,
+                    columnIssues: [
+                        { columnName: 'green', message: color_validation_1.COLOR_VALIDATION_MESSAGES.RGB_OUT_OF_RANGE('green', 'foo') },
+                    ],
+                });
+            });
+            it('does not error when neither hex nor RGB are populated (defaults to black)', () => {
+                const data = [{ name: 'no-color' }];
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.errors).toEqual([]);
+                expect(result.warnings).toEqual([]);
+            });
+        });
+        describe('transformData (hex priority)', () => {
+            it('strips red/green/blue when hex is valid', () => {
+                const data = [
+                    { hex: '#ff0000', red: '255', green: '0', blue: '0', name: 'red' },
+                ];
+                const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+                expect(result).toEqual([{ hex: 'ff0000', name: 'red' }]);
+            });
+            it('keeps red/green/blue and removes empty hex when hex is missing', () => {
+                const data = [{ red: '255', green: '0', blue: '0', name: 'red' }];
+                const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+                expect(result).toEqual([{ red: '255', green: '0', blue: '0', name: 'red' }]);
+            });
+            it('defaults to #000000 (without hash) when neither hex nor full RGB is provided', () => {
+                const data = [{ name: 'fallback' }];
+                const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+                expect(result).toEqual([{ name: 'fallback', hex: color_validation_1.DEFAULT_HEX }]);
+            });
         });
         it('should return error if conditionalColumns format is incorrect', () => {
             const data = [{ name: 'color1' }];

package/node_modules/@contrail/loader/lib/entities-v2/entities-helper.js

@@ -67,7 +67,6 @@ async function retryOnTimeout(client, callType, callParams, maxRetries = 3) {
 }
 exports.retryOnTimeout = retryOnTimeout;
 function UpdateNeeded(incoming, existing, fieldsToSkip = [], fieldsToSkipIfOnlyOnExisting = [], type) {
-    console.debug('Comparing existing and incoming objects...');
     const diffs = compareIncomingAndExisting(incoming, existing, fieldsToSkip, fieldsToSkipIfOnlyOnExisting, type);
     return diffs?.length > 0;
 }

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/assortment-processor.js

@@ -253,7 +253,6 @@ class AssortmentProcessor extends base_processor_v2_1.BaseProcessorV2 {
     }
     static async loadObjects(client, data, passedItemsByFederatedId, assortmentId, assortmentIdentifier, typesByTypePath) {
         const { allPropertiesSlugs, typePropertyToValueType } = await (0, item_helper_1.getAssortmentItemProperties)(client, this.requiredProperties, typesByTypePath);
-        console.debug('using assortment types:', JSON.stringify({ allPropertiesSlugs, typePropertyToValueType }, null, 2));
         const { incomingAssortmentItems, badAssortmentItems } = this.processIncomingData(data, allPropertiesSlugs, typePropertyToValueType);
         const targetAssortment = await (0, item_helper_1.getAssortment)(client, assortmentId, assortmentIdentifier, data);
         if (!targetAssortment) {

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/item-processor.js

@@ -60,7 +60,7 @@ class ItemProcessor extends base_processor_v2_1.BaseProcessorV2 {
             return { errors, warnings, generalErrors, generalWarnings };
         }
         this.validateLoadType(config, generalErrors);
-        this.validateTypePathMapping(config, csvHeaders, data, generalErrors);
+        this.validateTypePathMapping(data, generalErrors);
         this.validateOptionNameMapping(config, csvHeaders, generalWarnings);
         this.validateItemOptionFederatedIdMapping(config, csvHeaders, generalWarnings);
         this.validateFederatedIds(data, config, errors, generalErrors, csvHeaders);
@@ -75,27 +75,13 @@ class ItemProcessor extends base_processor_v2_1.BaseProcessorV2 {
             });
         }
     }
-    static validateTypePathMapping(config, csvHeaders, data, generalErrors) {
-        if (Array.isArray(config?.conditionalColumns) && config.conditionalColumns.length) {
-            const hasTypePathColumn = config.conditionalColumns.some((column) => column.toProperty === 'typePath');
-            const hasRequiredConditionalColumn = config.conditionalColumns.some((column) => column.toProperty === 'typePath' &&
-                (column.default === 'item' ||
-                    (column.default?.startsWith('item:') && column.default?.split(':')[1]?.length > 0)));
-            if (hasTypePathColumn && !hasRequiredConditionalColumn) {
-                generalErrors.push({
-                    message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
-            }
-        }
-        else if (csvHeaders.includes('typePath')) {
-            const hasCorrectTypePath = data.every((row) => row.typePath === 'item' || (row.typePath?.startsWith('item:') && row.typePath?.split(':')[1]?.length > 0));
-            if (!hasCorrectTypePath) {
-                generalErrors.push({
-                    message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
-                    issueType: entity_types_1.IssueType.CONFIG,
-                });
-            }
+    static validateTypePathMapping(data, generalErrors) {
+        const hasCorrectTypePath = data.every((row) => row.typePath === 'item' || (row.typePath?.startsWith('item:') && row.typePath?.split(':')[1]?.length > 0));
+        if (!hasCorrectTypePath) {
+            generalErrors.push({
+                message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
         }
     }
     static validateOptionNameMapping(config, csvHeaders, generalWarnings) {