@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const item_helper_1 = require("./item-helper");
+describe('item helper tests', () => {
+    describe('convertToComparableEntities', () => {
+        it('should convert comparable items to comparable entities', () => {
+            const comparableItems = [
+                { id: 1, name: 'Item 1', price: 10, 'not-included': 'foo' },
+                { id: 2, name: 'Item 2', price: 20, 'not-included': 'bar' },
+                { id: 3, name: 'Item 3', price: 30, 'not-included': 'baz' },
+            ];
+            const assortmentItemProperties = ['name', 'price'];
+            const idFieldName = 'id';
+            const expectedComparableEntities = [
+                { id: 1, name: 'Item 1', price: 10 },
+                { id: 2, name: 'Item 2', price: 20 },
+                { id: 3, name: 'Item 3', price: 30 },
+            ];
+            const result = (0, item_helper_1.convertToComparableEntities)(comparableItems, assortmentItemProperties, idFieldName);
+            expect(result).toEqual(expectedComparableEntities);
+        });
+        it('should remove built-in keys even if they are included properties', () => {
+            const comparableItems = [
+                { id: 1, name: 'Item 1', price: 10, createdById: 'foo' },
+                { id: 2, name: 'Item 2', price: 20, createdById: 'bar' },
+                { id: 3, name: 'Item 3', price: 30, createdById: 'baz' },
+            ];
+            const assortmentItemProperties = ['name', 'price', 'createdById'];
+            const idFieldName = 'id';
+            const expectedComparableEntities = [
+                { id: 1, name: 'Item 1', price: 10 },
+                { id: 2, name: 'Item 2', price: 20 },
+                { id: 3, name: 'Item 3', price: 30 },
+            ];
+            const result = (0, item_helper_1.convertToComparableEntities)(comparableItems, assortmentItemProperties, idFieldName);
+            expect(result).toEqual(expectedComparableEntities);
+        });
+        it('should handle empty comparable items', () => {
+            const comparableItems = [];
+            const assortmentItemProperties = ['name', 'price'];
+            const idFieldName = 'id';
+            const expectedComparableEntities = [];
+            const result = (0, item_helper_1.convertToComparableEntities)(comparableItems, assortmentItemProperties, idFieldName);
+            expect(result).toEqual(expectedComparableEntities);
+        });
+        it('should handle missing id field', () => {
+            const comparableItems = [
+                { name: 'Item 1', price: 10 },
+                { id: 2, name: 'Item 2', price: 20 },
+                { name: 'Item 3', price: 50 },
+                { id: 3, name: 'Item 4', price: 30 },
+            ];
+            const assortmentItemProperties = ['name', 'price'];
+            const idFieldName = 'id';
+            const expectedComparableEntities = [
+                { id: 2, name: 'Item 2', price: 20 },
+                { id: 3, name: 'Item 4', price: 30 },
+            ];
+            const result = (0, item_helper_1.convertToComparableEntities)(comparableItems, assortmentItemProperties, idFieldName);
+            expect(result).toEqual(expectedComparableEntities);
+        });
+    });
+    describe('mapAssortmentItemsToItemsAndFillItemId', () => {
+        it('should map assortment items to items and fill item id, and handle failed mapping', () => {
+            const incomingAssortmentItems = [
+                { itemOptionFederatedId: 'option1', itemFamilyFederatedId: 'family1' },
+                { itemOptionFederatedId: 'option2', itemFamilyFederatedId: 'family2' },
+                { itemOptionFederatedId: 'option3', itemFamilyFederatedId: 'family3' },
+            ];
+            const itemsByFederatedId = {
+                option1: { id: 1 },
+                option2: { id: 2 },
+                family1: { id: 3 },
+                family2: { id: 4 },
+            };
+            const expectedUnmappedAssortmentItems = [{ itemOptionFederatedId: 'option3', itemFamilyFederatedId: 'family3' }];
+            const expectedCompleteIncomingAssortmentItems = [
+                {
+                    itemOptionFederatedId: 'option1',
+                    itemFamilyFederatedId: 'family1',
+                    itemId: 1,
+                },
+                {
+                    itemOptionFederatedId: 'option2',
+                    itemFamilyFederatedId: 'family2',
+                    itemId: 2,
+                },
+            ];
+            const result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual(expectedCompleteIncomingAssortmentItems);
+            expect(result.unmappedAssortmentItems).toEqual(expectedUnmappedAssortmentItems);
+        });
+        it('should handle missing itemOptionFederatedId and itemFamilyFederatedId', () => {
+            const incomingAssortmentItems = [{ itemOptionFederatedId: 'option1' }, { notFederatedIdHere: 'foo' }];
+            const itemsByFederatedId = {
+                option1: { id: 1 },
+                family1: { id: 2 },
+            };
+            const expectedCompleteIncomingAssortmentItems = [{ itemOptionFederatedId: 'option1', itemId: 1 }];
+            const expectedMissingIncomingAssortmentItems = [{ notFederatedIdHere: 'foo' }];
+            const result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual(expectedCompleteIncomingAssortmentItems);
+            expect(result.unmappedAssortmentItems).toEqual(expectedMissingIncomingAssortmentItems);
+        });
+        it('should handle empty incoming assortment items', () => {
+            const incomingAssortmentItems = [];
+            const itemsByFederatedId = {
+                option1: { id: 1 },
+                family1: { id: 2 },
+            };
+            const expectedCompleteIncomingAssortmentItems = [];
+            const result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual(expectedCompleteIncomingAssortmentItems);
+            expect(result.unmappedAssortmentItems).toEqual([]);
+        });
+        it('should handle empty federated mappings', () => {
+            let incomingAssortmentItems = null;
+            let itemsByFederatedId = {
+                option1: { id: 1 },
+                family1: { id: 2 },
+            };
+            let result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual([]);
+            expect(result.unmappedAssortmentItems).toEqual([]);
+            incomingAssortmentItems = [];
+            itemsByFederatedId = null;
+            result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual([]);
+            expect(result.unmappedAssortmentItems).toEqual([]);
+            incomingAssortmentItems = null;
+            itemsByFederatedId = null;
+            result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual([]);
+            expect(result.unmappedAssortmentItems).toEqual([]);
+        });
+        it('should not fall back to family when option federatedId is present but not found', () => {
+            const incomingAssortmentItems = [
+                { itemOptionFederatedId: 'missing-option', itemFamilyFederatedId: 'family1' },
+            ];
+            const itemsByFederatedId = {
+                family1: { id: 'fam-item-1' },
+            };
+            const result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual([]);
+            expect(result.unmappedAssortmentItems).toEqual([
+                { itemOptionFederatedId: 'missing-option', itemFamilyFederatedId: 'family1' },
+            ]);
+        });
+        it('should map family-only rows by family federatedId', () => {
+            const incomingAssortmentItems = [
+                { itemFamilyFederatedId: 'family1' },
+            ];
+            const itemsByFederatedId = {
+                family1: { id: 'fam-item-1' },
+            };
+            const result = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(incomingAssortmentItems, itemsByFederatedId);
+            expect(result.completeIncomingAssortmentItems).toEqual([
+                { itemFamilyFederatedId: 'family1', itemId: 'fam-item-1' },
+            ]);
+            expect(result.unmappedAssortmentItems).toEqual([]);
+        });
+    });
+    describe('convertToComparableEntities — falsy value handling', () => {
+        it('should preserve false boolean values', () => {
+            const items = [{ id: 'item-1', adoptionIntent: false }];
+            const result = (0, item_helper_1.convertToComparableEntities)(items, ['adoptionIntent'], 'id');
+            expect(result[0].adoptionIntent).toBe(false);
+        });
+        it('should preserve 0 numeric values', () => {
+            const items = [{ id: 'item-1', quantity: 0 }];
+            const result = (0, item_helper_1.convertToComparableEntities)(items, ['quantity'], 'id');
+            expect(result[0].quantity).toBe(0);
+        });
+        it('should exclude null values', () => {
+            const items = [{ id: 'item-1', color: null }];
+            const result = (0, item_helper_1.convertToComparableEntities)(items, ['color'], 'id');
+            expect(result[0]).not.toHaveProperty('color');
+        });
+        it('should exclude undefined values', () => {
+            const items = [{ id: 'item-1', color: undefined }];
+            const result = (0, item_helper_1.convertToComparableEntities)(items, ['color'], 'id');
+            expect(result[0]).not.toHaveProperty('color');
+        });
+        it('should exclude empty string values', () => {
+            const items = [{ id: 'item-1', color: '' }];
+            const result = (0, item_helper_1.convertToComparableEntities)(items, ['color'], 'id');
+            expect(result[0]).not.toHaveProperty('color');
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+import { EntityType, GeneralIssueDetails, ProcessingIssues } from '@contrail/entity-types';
+import { BaseProcessorV2 } from '../base-processor-v2';
+export interface ItemData {
+    [key: string]: any;
+}
+export declare class ItemProcessor extends BaseProcessorV2 {
+    static requiredProperties: string[];
+    static setExtraProperties(entity: any, type: any): void;
+    static validateRow(row: {
+        itemFamilyFederatedId: string;
+    }): boolean;
+    static assignExtraItems(client: any, typePaths: any, typesByPath: any, incomingItems: any): Promise<{
+        itemsByFamilyId: {
+            [key: string]: any[];
+        };
+        sizeRangeWarningsAsStringList: string[];
+    }>;
+    static logIncommingEntities(incomingEntities: any[], entityType: string, result: any): void;
+    static getFederatedIdKeys(): string[];
+    static getEntityTypeForFederatedId(entityType: EntityType): EntityType;
+    static validateLoadFile(data: ItemData[], config: any): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+    private static validateLoadType;
+    private static validateTypePathMapping;
+    private static validateOptionNameMapping;
+    private static validateItemOptionFederatedIdMapping;
+    private static validateFederatedIds;
+    private static prepareDataWithConditionalValues;
+    private static findConditionalColumn;
+    private static validateEmptyItemFamilyFederatedIds;
+    private static validateConflictingFederatedIds;
+    private static validateUniqueOptionNamesPerFamily;
+}

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

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemProcessor = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const lodash_1 = require("lodash");
+const base_processor_v2_1 = require("../base-processor-v2");
+const util_1 = require("../../common/util");
+const entities_helper_1 = require("../../common/entities-helper");
+const size_range_helpers_1 = require("../../common/size-range-helpers");
+const entity_processor_v2_1 = require("../entity-processor-v2");
+const constants_1 = require("../../constants");
+const conditional_columns_1 = require("../../common/conditional-columns");
+class ItemProcessor extends base_processor_v2_1.BaseProcessorV2 {
+    static requiredProperties = [
+        'typePath',
+        'typeId',
+        'itemOptionFederatedId',
+        'itemFamilyFederatedId',
+        'optionGroup',
+        'optionName',
+    ];
+    static setExtraProperties(entity, type) {
+        entity.typeId = type.type.id;
+        entity.typePath = type.type.typePath;
+    }
+    static validateRow(row) {
+        return !!row.itemFamilyFederatedId;
+    }
+    static async assignExtraItems(client, typePaths, typesByPath, incomingItems) {
+        await (0, entities_helper_1.assignUserLists)(client, typePaths, typesByPath, incomingItems);
+        const sizeRangeSanitizer = new size_range_helpers_1.SizeRangeSanitizer();
+        await sizeRangeSanitizer.sanitizeSizeRanges(client, typesByPath, incomingItems);
+        const sizeRangeWarningsAsStringList = sizeRangeSanitizer.getWarningsAsStringList();
+        const itemsByFamilyId = {};
+        for (const item of incomingItems) {
+            if (!itemsByFamilyId[item.itemFamilyFederatedId]) {
+                itemsByFamilyId[item.itemFamilyFederatedId] = [];
+            }
+            itemsByFamilyId[item.itemFamilyFederatedId].push(item);
+        }
+        return {
+            itemsByFamilyId,
+            sizeRangeWarningsAsStringList,
+        };
+    }
+    static logIncommingEntities(incomingEntities, entityType, result) {
+        const familyCount = Object.keys(result?.itemsByFamilyId ?? {}).length;
+        const optionCount = incomingEntities.filter((e) => e.itemOptionFederatedId).length;
+        console.debug(`Item load: ${incomingEntities.length} CSV rows → ${familyCount} families, ${optionCount} options`);
+    }
+    static getFederatedIdKeys() {
+        return ['itemFamilyFederatedId', 'itemOptionFederatedId'];
+    }
+    static getEntityTypeForFederatedId(entityType) {
+        return entity_types_1.EntityType.ITEM;
+    }
+    static validateLoadFile(data, config) {
+        const { errors, warnings, generalErrors, generalWarnings, csvHeaders, returnImmediately } = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config, 'itemFamilyFederatedId');
+        if (returnImmediately) {
+            return { errors, warnings, generalErrors, generalWarnings };
+        }
+        this.validateLoadType(config, generalErrors);
+        this.validateTypePathMapping(config, csvHeaders, data, generalErrors);
+        this.validateOptionNameMapping(config, csvHeaders, generalWarnings);
+        this.validateItemOptionFederatedIdMapping(config, csvHeaders, generalWarnings);
+        this.validateFederatedIds(data, config, errors, generalErrors, csvHeaders);
+        return { errors, warnings, generalErrors, generalWarnings };
+    }
+    static validateLoadType(config, generalErrors) {
+        if (config?.loadType?.length &&
+            !config.loadType.every((type) => [entity_types_1.LoadType.ITEM, entity_types_1.LoadType.PROJECT_ITEM, entity_types_1.LoadType.ASSORTMENT].includes(type))) {
+            generalErrors.push({
+                message: constants_1.ITEM_PROCESSOR_ERRORS.LOAD_TYPE_INVALID,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+    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 validateOptionNameMapping(config, csvHeaders, generalWarnings) {
+        const optionNameInConditional = config?.conditionalColumns?.some((column) => column.toProperty === 'optionName');
+        const optionNameInFederatedMapping = config?.federatedMappings?.optionName;
+        const optionNameInCSV = csvHeaders.includes('optionName');
+        if (!optionNameInFederatedMapping && !optionNameInCSV && !optionNameInConditional) {
+            generalWarnings.push({
+                message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        else if (optionNameInFederatedMapping && !csvHeaders.includes(config.federatedMappings?.optionName)) {
+            generalWarnings.push({
+                message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_NOT_FOUND(config.federatedMappings?.optionName),
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+    static validateItemOptionFederatedIdMapping(config, csvHeaders, generalWarnings) {
+        const optionFederatedIdInConditional = config?.conditionalColumns?.some((column) => column.toProperty === 'itemOptionFederatedId');
+        const optionFederatedIdInFederatedMapping = config?.federatedMappings?.itemOptionFederatedId;
+        const optionFederatedIdInCSV = csvHeaders.includes('itemOptionFederatedId');
+        if (!optionFederatedIdInFederatedMapping && !optionFederatedIdInCSV && !optionFederatedIdInConditional) {
+            generalWarnings.push({
+                message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_UNMAPPED,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        else if (optionFederatedIdInFederatedMapping &&
+            !csvHeaders.includes(config.federatedMappings?.itemOptionFederatedId)) {
+            generalWarnings.push({
+                message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_NOT_FOUND(config.federatedMappings?.itemOptionFederatedId),
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+    static validateFederatedIds(data, config, errors, generalErrors, csvHeaders) {
+        const processedData = this.prepareDataWithConditionalValues(data, config);
+        this.validateEmptyItemFamilyFederatedIds(processedData, config, errors);
+        this.validateConflictingFederatedIds(processedData, config, generalErrors, errors, csvHeaders);
+    }
+    static prepareDataWithConditionalValues(data, config) {
+        const dataCopy = JSON.parse(JSON.stringify(data));
+        const familyFederatedIdColumn = this.findConditionalColumn(config, 'itemFamilyFederatedId');
+        const familyNameColumn = this.findConditionalColumn(config, 'name');
+        const optionFederatedIdColumn = this.findConditionalColumn(config, 'itemOptionFederatedId');
+        const optionNameColumn = this.findConditionalColumn(config, 'optionName');
+        if (!familyFederatedIdColumn && !familyNameColumn && !optionFederatedIdColumn && !optionNameColumn) {
+            return dataCopy;
+        }
+        return dataCopy.map((row) => {
+            const processedRow = { ...row };
+            if (familyFederatedIdColumn) {
+                processedRow.itemFamilyFederatedId = conditional_columns_1.ColumnDefinitionEvaluator.getValue(familyFederatedIdColumn.default, row);
+            }
+            if (familyNameColumn) {
+                processedRow.name = conditional_columns_1.ColumnDefinitionEvaluator.getValue(familyNameColumn.default, row);
+            }
+            if (optionFederatedIdColumn) {
+                processedRow.itemOptionFederatedId = conditional_columns_1.ColumnDefinitionEvaluator.getValue(optionFederatedIdColumn.default, row);
+            }
+            if (optionNameColumn) {
+                processedRow.optionName = conditional_columns_1.ColumnDefinitionEvaluator.getValue(optionNameColumn.default, row);
+            }
+            return processedRow;
+        });
+    }
+    static findConditionalColumn(config, propertyName) {
+        const column = config?.conditionalColumns?.find((col) => col.toProperty === propertyName);
+        return column && Object.keys(column).length ? column : null;
+    }
+    static validateEmptyItemFamilyFederatedIds(data, config, errors) {
+        const itemFamilyFederatedIdKey = config.federatedMappings?.itemFamilyFederatedId || 'itemFamilyFederatedId';
+        for (const [index, row] of data.entries()) {
+            const familyFedId = row[itemFamilyFederatedIdKey];
+            if (!familyFedId || familyFedId === '') {
+                errors.push({
+                    rowNumber: index,
+                    columnIssues: [
+                        {
+                            columnName: config.federatedMappings?.itemFamilyFederatedId,
+                            message: constants_1.ITEM_PROCESSOR_ERRORS.FAMILY_ID_EMPTY,
+                            issueType: entity_types_1.IssueType.CONFIG,
+                            data: JSON.stringify(row),
+                        },
+                    ],
+                });
+            }
+        }
+    }
+    static validateConflictingFederatedIds(data, config, generalErrors, errors, csvHeaders) {
+        const itemFamilyFederatedId = config?.federatedMappings?.itemFamilyFederatedId || 'itemFamilyFederatedId';
+        const itemfamilyName = config?.federatedMappings?.name || 'name';
+        const familyNameInConditional = config?.conditionalColumns?.some((column) => column.toProperty === 'name');
+        const isFamilyNameMapped = Boolean(config?.federatedMappings?.name || csvHeaders.includes('name') || familyNameInConditional);
+        if (isFamilyNameMapped) {
+            const conflictingFieldsByFedId = (0, util_1.getConflictingFieldForFederatedId)(data, itemFamilyFederatedId, itemfamilyName);
+            if (conflictingFieldsByFedId.length) {
+                let prettyString = '';
+                for (const fedIdConflict of conflictingFieldsByFedId) {
+                    prettyString += `(${fedIdConflict.federatedId}: (${fedIdConflict.values.join(', ')}))`;
+                }
+                generalErrors.push({
+                    message: constants_1.ITEM_PROCESSOR_ERRORS.CONFLICTING_IDS(prettyString),
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+            const optionFederatedIdInConditional = config?.conditionalColumns?.some((column) => column.toProperty === 'itemOptionFederatedId');
+            const itemOptionFederatedId = config?.federatedMappings?.itemOptionFederatedId || 'itemOptionFederatedId';
+            if (config?.federatedMappings?.itemOptionFederatedId ||
+                csvHeaders.includes('itemOptionFederatedId') ||
+                optionFederatedIdInConditional) {
+                const duplicateOptionFedIds = (0, util_1.getDuplicateFederatedIds)(data, itemOptionFederatedId);
+                if (duplicateOptionFedIds.length) {
+                    errors.push(...duplicateOptionFedIds);
+                }
+            }
+            const optionNameInConditional = config?.conditionalColumns?.some((column) => column.toProperty === 'optionName');
+            const optionNameField = optionNameInConditional
+                ? 'optionName'
+                : (config?.federatedMappings?.optionName || 'optionName');
+            if (config?.federatedMappings?.optionName ||
+                csvHeaders.includes('optionName') ||
+                optionNameInConditional) {
+                const duplicateOptionNames = this.validateUniqueOptionNamesPerFamily(data, itemFamilyFederatedId, optionNameField, itemOptionFederatedId);
+                if (duplicateOptionNames.length) {
+                    errors.push(...duplicateOptionNames);
+                }
+            }
+        }
+    }
+    static validateUniqueOptionNamesPerFamily(data, groupByField, duplicateCheckField, optionIdentifierField = 'itemOptionFederatedId') {
+        if (!data || !groupByField || !duplicateCheckField)
+            return [];
+        const errors = [];
+        const indexMap = new Map(data.map((row, i) => [row, i]));
+        const grouped = (0, lodash_1.groupBy)(data, groupByField);
+        for (const [groupId, rows] of Object.entries(grouped)) {
+            const optionRows = rows.filter((row) => row[optionIdentifierField]);
+            const seen = {};
+            for (const row of optionRows) {
+                const value = row[duplicateCheckField];
+                if (!value)
+                    continue;
+                const rowIndex = indexMap.get(row) + 2;
+                if (!seen[value]) {
+                    seen[value] = [];
+                }
+                seen[value].push(rowIndex);
+            }
+            for (const [value, indices] of Object.entries(seen)) {
+                if (indices.length > 1) {
+                    for (const rowIndex of indices) {
+                        errors.push({
+                            rowNumber: rowIndex,
+                            columnIssues: [
+                                {
+                                    columnName: duplicateCheckField,
+                                    message: `Duplicate ${duplicateCheckField} "${value}" found within item family "${groupId}"`,
+                                    issueType: entity_types_1.IssueType.CONFIG,
+                                    data: JSON.stringify(data[rowIndex - 2]),
+                                },
+                            ],
+                        });
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+}
+exports.ItemProcessor = ItemProcessor;

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

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