@contrail/cli 3.5.0-alpha.dd20a19 → 3.5.1-alpha.68d57e0

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) {

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

@@ -28,18 +28,21 @@ describe('Item Processor', () => {
                     family_federated_id: 'family_1',
                     input_col_1: 'value_1',
                     input_col_2: 'value_2',
+                    typePath: 'item',
                 },
                 {
                     name: 'item2',
                     family_federated_id: 'family_2',
                     input_col_1: 'value_3',
                     input_col_2: 'value_4',
+                    typePath: 'item',
                 },
                 {
                     name: 'item3',
                     family_federated_id: 'family_3',
                     input_col_1: 'value_5',
                     input_col_2: 'value_6',
+                    typePath: 'item',
                 },
             ];
             const config = {
@@ -167,7 +170,7 @@ describe('Item Processor', () => {
                     },
                 ]);
             });
-            it('should not throw error if typepath is not present in csv header and config file', () => {
+            it('should throw error if typepath is not present in csv header', () => {
                 const data = [
                     {
                         name: 'item1',
@@ -193,6 +196,42 @@ describe('Item Processor', () => {
                     conditionalColumns: [],
                 };
                 const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should not throw error if every row has a valid typePath', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                        typePath: 'item',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                        typePath: 'item:material:fabric:yarn',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                        typePath: 'item:material:fabric:leather',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
                 expect(result.generalErrors).toEqual([]);
             });
         });
@@ -600,14 +639,17 @@ describe('Item Processor', () => {
                     {
                         itemFamilyFederatedId: '1',
                         name: 'foo',
+                        typePath: 'item',
                     },
                     {
                         itemFamilyFederatedId: '1',
                         name: 'bar',
+                        typePath: 'item',
                     },
                     {
                         itemFamilyFederatedId: '3',
                         name: 'test',
+                        typePath: 'item',
                     },
                 ];
                 const config = {

package/node_modules/@contrail/loader/lib/pipeline/identifier-resolver.d.ts

@@ -0,0 +1,5 @@
+import { EntitiesClient, LoaderConfig, PreValidationIssue } from './types';
+export declare function isProjectItemAndAssortmentLoad(config: LoaderConfig): boolean;
+export declare function resolveIdentifiers(rows: Record<string, any>[], config: LoaderConfig, client?: EntitiesClient): Promise<{
+    issues: PreValidationIssue[];
+}>;