@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/pipeline/validate.spec.js

@@ -0,0 +1,1214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const types_2 = require("@contrail/types");
+const validate_1 = require("./validate");
+const types_3 = require("./types");
+describe('validate', () => {
+    const makeAnalysis = (typePropertyMaps, typesByPath) => ({
+        columns: [],
+        unmappedTypeProperties: [],
+        typePropertyMaps: {
+            typePropertiesBySlug: {},
+            typePropertiesByLabel: {},
+            optionSetUsingTypePropertiesBySlug: {},
+            ...typePropertyMaps,
+        },
+        typesByPath: typesByPath ?? {},
+    });
+    const baseConfig = {
+        loadType: [types_1.LoadType.ITEM],
+        federatedMappings: { federatedId: 'federatedId', name: 'name' },
+    };
+    it('should return valid for empty rows', async () => {
+        const result = await (0, validate_1.validate)([], baseConfig, makeAnalysis());
+        expect(result.valid).toBe(true);
+        expect(result.issues).toEqual([]);
+    });
+    it('should detect missing option set values', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                status: {
+                    slug: 'status',
+                    label: 'Status',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: 'os-1',
+                    options: [{ value: 'active', display: 'Active' }],
+                    optionLookupByValue: { active: { value: 'active', display: 'Active' } },
+                    optionLookupByDisplay: { Active: { value: 'active', display: 'Active' } },
+                },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', status: 'active' },
+            { federatedId: '2', name: 'B', status: 'inactive' },
+            { federatedId: '3', name: 'C', status: 'retired' },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        expect(result.valid).toBe(false);
+        const optionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'status');
+        expect(optionIssues.length).toBeGreaterThan(0);
+        const inactiveIssue = optionIssues.find((i) => i.message.includes('inactive'));
+        expect(inactiveIssue).toBeDefined();
+        expect(inactiveIssue.suggestedFix?.type).toBe(types_3.SuggestedFixType.ADD_OPTION_SET_VALUES);
+    });
+    it('should detect multi-select missing values', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                tags: {
+                    slug: 'tags',
+                    label: 'Tags',
+                    propertyType: 'multi_select',
+                    typePropertyOptionSetId: 'os-2',
+                    options: [{ value: 'sale', display: 'Sale' }],
+                    optionLookupByValue: { sale: { value: 'sale', display: 'Sale' } },
+                    optionLookupByDisplay: { Sale: { value: 'sale', display: 'Sale' } },
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', tags: 'sale,new,clearance' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        expect(result.valid).toBe(false);
+        const tagIssues = result.issues.filter((i) => i.columnName === 'tags');
+        expect(tagIssues.length).toBeGreaterThan(0);
+    });
+    it('should detect non-standard boolean values', async () => {
+        const analysis = makeAnalysis({
+            typePropertiesBySlug: {
+                isActive: { slug: 'isActive', label: 'Is Active', propertyType: 'boolean' },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', isActive: 'yes' },
+            { federatedId: '2', name: 'B', isActive: 'maybe' },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const boolIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_BOOLEAN);
+        expect(boolIssues).toHaveLength(1);
+        expect(boolIssues[0].severity).toBe(types_3.PreValidationSeverity.WARNING);
+        expect(boolIssues[0].affectedRows).toHaveLength(1);
+        expect(boolIssues[0].affectedRows[0].value).toBe('maybe');
+    });
+    it('should detect semicolons in multi-select columns', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                colors: {
+                    slug: 'colors',
+                    label: 'Colors',
+                    propertyType: 'multi_select',
+                    typePropertyOptionSetId: 'os-3',
+                    options: [
+                        { value: 'red', display: 'Red' },
+                        { value: 'blue', display: 'Blue' },
+                    ],
+                    optionLookupByValue: {
+                        red: { value: 'red', display: 'Red' },
+                        blue: { value: 'blue', display: 'Blue' },
+                    },
+                    optionLookupByDisplay: {
+                        Red: { value: 'red', display: 'Red' },
+                        Blue: { value: 'blue', display: 'Blue' },
+                    },
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', colors: 'red;blue' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const multiSelectIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_MULTI_SELECT);
+        expect(multiSelectIssues).toHaveLength(1);
+        expect(multiSelectIssues[0].suggestedFix?.type).toBe(types_3.SuggestedFixType.CHANGE_SEPARATOR);
+    });
+    it('should skip empty values in option set validation', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                status: {
+                    slug: 'status',
+                    label: 'Status',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: 'os-1',
+                    options: [{ value: 'active', display: 'Active' }],
+                    optionLookupByValue: { active: { value: 'active', display: 'Active' } },
+                    optionLookupByDisplay: { Active: { value: 'active', display: 'Active' } },
+                },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', status: '' },
+            { federatedId: '2', name: 'B', status: null },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const optionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'status');
+        expect(optionIssues).toHaveLength(0);
+    });
+    describe('family property consistency', () => {
+        const itemConfig = {
+            loadType: [types_1.LoadType.ITEM],
+            federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+        };
+        const typesByPathWithFamilyProp = {
+            item: {
+                type: {
+                    typeProperties: [
+                        { slug: 'globalProjectedVolume', propertyLevel: types_2.PropertyLevel.FAMILY, propertyType: 'number' },
+                        { slug: 'sport', propertyLevel: types_2.PropertyLevel.OVERRIDABLE, propertyType: 'string' },
+                        { slug: 'color', propertyLevel: types_2.PropertyLevel.OPTION, propertyType: 'string' },
+                    ],
+                },
+                allPropertiesSlugs: ['globalProjectedVolume', 'sport', 'color'],
+                typePropertyToValueType: {},
+                objectReferenceProperties: [],
+                userListProperties: [],
+            },
+        };
+        it('should detect inconsistent family-level property values with family-specific message', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', globalProjectedVolume: '200', sportFamily: 'basketball' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', globalProjectedVolume: '300', sportFamily: 'basketball' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(1);
+            expect(consistencyIssues[0].columnName).toBe('globalProjectedVolume');
+            expect(consistencyIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+            expect(consistencyIssues[0].category).toBe(types_3.PreValidationCategory.FAMILY_PROPERTY_VALUES_INCONSISTENT);
+            expect(consistencyIssues[0].message).toContain('Family-level property');
+            expect(consistencyIssues[0].message).toContain('fam-1');
+            expect(consistencyIssues[0].message).toContain('"200"');
+            expect(consistencyIssues[0].message).toContain('"300"');
+        });
+        it('should pass when family-level property values are consistent', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', globalProjectedVolume: '200' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', globalProjectedVolume: '200' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(0);
+        });
+        it('should not flag option-level properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', color: 'red' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', color: 'blue' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(0);
+        });
+        it('should detect inconsistency in overridable Family-suffixed columns with family message', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', sportFamily: 'basketball' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', sportFamily: 'soccer' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(1);
+            expect(consistencyIssues[0].columnName).toBe('sportFamily');
+            expect(consistencyIssues[0].message).toContain('Family-level property');
+        });
+        it('should suggest splitting into Family/Option columns for unsuffixed overridable properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', sport: 'basketball' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', sport: 'soccer' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.columnName === 'sport' && i.category === types_3.PreValidationCategory.FAMILY_PROPERTY_VALUES_INCONSISTENT);
+            expect(consistencyIssues).toHaveLength(1);
+            expect(consistencyIssues[0].message).toContain('Override-level property');
+            expect(consistencyIssues[0].message).toContain('"sportFamily"');
+            expect(consistencyIssues[0].message).toContain('"sportOption"');
+            const suffixIssues = result.issues.filter((i) => i.columnName === 'sport' && i.category === types_3.PreValidationCategory.CONFIG);
+            expect(suffixIssues).toHaveLength(1);
+        });
+        it('should suggest splitting into Family/Option columns for "all" level properties', async () => {
+            const typesByPathWithAllProp = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'sharedProp', propertyLevel: types_2.PropertyLevel.ALL, propertyType: 'string' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['sharedProp'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', sharedProp: 'a' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', sharedProp: 'b' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithAllProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.columnName === 'sharedProp' && i.category === types_3.PreValidationCategory.FAMILY_PROPERTY_VALUES_INCONSISTENT);
+            expect(consistencyIssues).toHaveLength(1);
+            expect(consistencyIssues[0].message).toContain('All-level property');
+            expect(consistencyIssues[0].message).toContain('"sharedPropFamily"');
+            expect(consistencyIssues[0].message).toContain('"sharedPropOption"');
+            const suffixIssues = result.issues.filter((i) => i.columnName === 'sharedProp' && i.category === types_3.PreValidationCategory.CONFIG);
+            expect(suffixIssues).toHaveLength(1);
+        });
+        it('should skip validation for non-item load types', async () => {
+            const colorConfig = {
+                loadType: [types_1.LoadType.COLOR],
+                federatedMappings: { federatedId: 'federatedId', name: 'name' },
+            };
+            const rows = [
+                { federatedId: 'c1', name: 'Color 1', globalProjectedVolume: '200' },
+                { federatedId: 'c1', name: 'Color 1', globalProjectedVolume: '300' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(0);
+        });
+        it('should not flag single-row families', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', globalProjectedVolume: '200' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithFamilyProp);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const consistencyIssues = result.issues.filter((i) => i.message.includes('inconsistent values'));
+            expect(consistencyIssues).toHaveLength(0);
+        });
+    });
+    it('should detect empty option set for choice property', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                status: {
+                    slug: 'status',
+                    label: 'Status',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: 'some-id',
+                    options: [],
+                    optionLookupByValue: {},
+                    optionLookupByDisplay: {},
+                },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', status: 'active' },
+            { federatedId: '2', name: 'B', status: 'inactive' },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const optionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'status');
+        expect(optionIssues).toHaveLength(1);
+        expect(optionIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+        expect(optionIssues[0].message).toContain('is empty');
+        expect(optionIssues[0].affectedRows).toHaveLength(2);
+        expect(optionIssues[0].affectedRows).toEqual(expect.arrayContaining([
+            { row: 2, value: 'active' },
+            { row: 3, value: 'inactive' },
+        ]));
+    });
+    it('should detect empty option set for multi_select property', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                tags: {
+                    slug: 'tags',
+                    label: 'Tags',
+                    propertyType: 'multi_select',
+                    typePropertyOptionSetId: 'some-id',
+                    options: undefined,
+                    optionLookupByValue: {},
+                    optionLookupByDisplay: {},
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', tags: 'sale,new' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const tagIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'tags');
+        expect(tagIssues).toHaveLength(1);
+        expect(tagIssues[0].message).toContain('is empty');
+        expect(tagIssues[0].affectedRows).toHaveLength(1);
+        expect(tagIssues[0].affectedRows[0]).toEqual({ row: 2, value: 'sale,new' });
+    });
+    it('should detect option set not attached to property', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                category: {
+                    slug: 'category',
+                    label: 'Category',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: null,
+                    options: [],
+                    optionLookupByValue: {},
+                    optionLookupByDisplay: {},
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', category: 'shoes' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const categoryIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'category');
+        expect(categoryIssues).toHaveLength(1);
+        expect(categoryIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+        expect(categoryIssues[0].message).toContain('no option set attached');
+        expect(categoryIssues[0].affectedRows).toHaveLength(1);
+        expect(categoryIssues[0].affectedRows[0]).toEqual({ row: 2, value: 'shoes' });
+    });
+    it('should not produce per-row errors when option set is empty', async () => {
+        const analysis = makeAnalysis({
+            optionSetUsingTypePropertiesBySlug: {
+                status: {
+                    slug: 'status',
+                    label: 'Status',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: 'some-id',
+                    options: [],
+                    optionLookupByValue: {},
+                    optionLookupByDisplay: {},
+                },
+            },
+        });
+        const rows = [
+            { federatedId: '1', name: 'A', status: 'active' },
+            { federatedId: '2', name: 'B', status: 'inactive' },
+            { federatedId: '3', name: 'C', status: 'retired' },
+        ];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        const optionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.OPTION_SET && i.columnName === 'status');
+        expect(optionIssues).toHaveLength(1);
+        expect(optionIssues[0].message).not.toContain('Value "');
+        expect(optionIssues[0].affectedRows).toHaveLength(3);
+        expect(optionIssues[0].affectedRows).toEqual(expect.arrayContaining([
+            { row: 2, value: 'active' },
+            { row: 3, value: 'inactive' },
+            { row: 4, value: 'retired' },
+        ]));
+    });
+    it('should include summary with correct counts', async () => {
+        const analysis = makeAnalysis({
+            typePropertiesBySlug: {
+                isActive: { slug: 'isActive', label: 'Is Active', propertyType: 'boolean' },
+            },
+            optionSetUsingTypePropertiesBySlug: {
+                status: {
+                    slug: 'status',
+                    propertyType: 'choice',
+                    typePropertyOptionSetId: 'os-4',
+                    options: [{ value: 'ok', display: 'OK' }],
+                    optionLookupByValue: { ok: { value: 'ok', display: 'OK' } },
+                    optionLookupByDisplay: { OK: { value: 'ok', display: 'OK' } },
+                },
+            },
+        });
+        const rows = [{ federatedId: '1', name: 'A', status: 'bad', isActive: 'maybe' }];
+        const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+        expect(result.summary.errorCount).toBeGreaterThanOrEqual(1);
+        expect(result.summary.warningCount).toBeGreaterThanOrEqual(1);
+        expect(result.valid).toBe(false);
+    });
+    describe('number precision validation', () => {
+        const makePrecisionAnalysis = (properties) => makeAnalysis({ typePropertiesBySlug: properties });
+        it('should warn when value exceeds configured precision', async () => {
+            const analysis = makePrecisionAnalysis({
+                wholesale: {
+                    slug: 'wholesale',
+                    label: 'Wholesale',
+                    propertyType: 'currency',
+                    numberFormat: { format: 'currency', precision: 2 },
+                },
+            });
+            const rows = [
+                { federatedId: '1', name: 'A', wholesale: 1.333 },
+                { federatedId: '2', name: 'B', wholesale: 2.5 },
+            ];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(1);
+            expect(precisionIssues[0].severity).toBe(types_3.PreValidationSeverity.WARNING);
+            expect(precisionIssues[0].affectedRows).toHaveLength(1);
+            expect(precisionIssues[0].affectedRows[0].value).toBe('1.333');
+            expect(precisionIssues[0].message).toContain('2 decimal places');
+        });
+        it('should not warn when value is within configured precision', async () => {
+            const analysis = makePrecisionAnalysis({
+                wholesale: {
+                    slug: 'wholesale',
+                    label: 'Wholesale',
+                    propertyType: 'currency',
+                    numberFormat: { format: 'currency', precision: 2 },
+                },
+            });
+            const rows = [
+                { federatedId: '1', name: 'A', wholesale: 1.33 },
+                { federatedId: '2', name: 'B', wholesale: 2.5 },
+            ];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(0);
+        });
+        it('should not warn when no precision is configured', async () => {
+            const analysis = makePrecisionAnalysis({
+                wholesale: {
+                    slug: 'wholesale',
+                    label: 'Wholesale',
+                    propertyType: 'number',
+                },
+            });
+            const rows = [{ federatedId: '1', name: 'A', wholesale: 1.33333 }];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(0);
+        });
+        it('should not warn for integer values', async () => {
+            const analysis = makePrecisionAnalysis({
+                wholesale: {
+                    slug: 'wholesale',
+                    label: 'Wholesale',
+                    propertyType: 'currency',
+                    numberFormat: { format: 'currency', precision: 2 },
+                },
+            });
+            const rows = [{ federatedId: '1', name: 'A', wholesale: 100 }];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(0);
+        });
+        it('should produce separate issues for multiple columns', async () => {
+            const analysis = makePrecisionAnalysis({
+                wholesale: {
+                    slug: 'wholesale',
+                    label: 'Wholesale',
+                    propertyType: 'currency',
+                    numberFormat: { format: 'currency', precision: 2 },
+                },
+                margin: {
+                    slug: 'margin',
+                    label: 'Margin',
+                    propertyType: 'percent',
+                    numberFormat: { format: 'percent', precision: 1 },
+                },
+            });
+            const rows = [{ federatedId: '1', name: 'A', wholesale: 1.333, margin: 0.555 }];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(2);
+            const columns = precisionIssues.map((i) => i.columnName).sort();
+            expect(columns).toEqual(['margin', 'wholesale']);
+        });
+        it('should skip non-numeric property types', async () => {
+            const analysis = makePrecisionAnalysis({
+                description: {
+                    slug: 'description',
+                    label: 'Description',
+                    propertyType: 'string',
+                    numberFormat: { format: 'decimal', precision: 2 },
+                },
+            });
+            const rows = [{ federatedId: '1', name: 'A', description: 1.333 }];
+            const result = await (0, validate_1.validate)(rows, baseConfig, analysis);
+            const precisionIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.FORMAT_NUMBER_PRECISION);
+            expect(precisionIssues).toHaveLength(0);
+        });
+    });
+    describe('validateStaticIdentifierConflicts', () => {
+        it('should error when assortmentId is set in config AND in conditionalColumns', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                assortmentId: 'assort-1',
+                conditionalColumns: [{ toProperty: 'assortmentId', default: 'assort-2' }],
+            };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const conflict = result.issues.find((i) => i.message.includes('static config value and also as a conditionalColumns target'));
+            expect(conflict).toBeDefined();
+            expect(conflict.columnName).toBe('assortmentId');
+        });
+        it('should not error when static value set but no matching conditionalColumn', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                assortmentId: 'assort-1',
+                conditionalColumns: [{ toProperty: 'someOtherField', default: 'val' }],
+            };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const conflict = result.issues.find((i) => i.message.includes('static config value'));
+            expect(conflict).toBeUndefined();
+        });
+    });
+    describe('validateAssortmentColumns', () => {
+        it('should skip for non-ASSORTMENT loads', async () => {
+            const config = { loadType: [types_1.LoadType.ITEM] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const assortmentIssue = result.issues.find((i) => i.columnName?.includes('assortmentId'));
+            expect(assortmentIssue).toBeUndefined();
+        });
+        it('should error when no rows have assortmentId or assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(issue).toBeDefined();
+            expect(result.valid).toBe(false);
+        });
+        it('should error when rows have both assortmentId and assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'id-1', assortmentIdentifier: 'ident-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('both "assortmentId" and "assortmentIdentifier"'));
+            expect(issue).toBeDefined();
+        });
+        it('should error when assortmentId values are empty', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: '' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(issue).toBeDefined();
+        });
+        it('should not error when rows have valid assortmentId', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const columnIssue = result.issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(columnIssue).toBeUndefined();
+        });
+        it('should not error on rows missing assortmentId when derived from conditional columns with conditions', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                conditionalColumns: [
+                    { toProperty: 'assortmentId', conditions: [{ conditional: "{gender} === 'mens'", value: 'assort-1' }] },
+                ],
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B' },
+            ];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const emptyIssue = result.issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(emptyIssue).toBeUndefined();
+        });
+    });
+    describe('validatePartialAssortmentConfig', () => {
+        it('should skip for non-ASSORTMENT loads', async () => {
+            const config = { loadType: [types_1.LoadType.ITEM], partialAssortmentUpdate: true };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('partialAssortmentUpdate'));
+            expect(issue).toBeUndefined();
+        });
+        it('should skip when partialAssortmentUpdate is false', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT], assortmentId: 'a' };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'a' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('partialAssortmentUpdate'));
+            expect(issue).toBeUndefined();
+        });
+        it('should error when partialAssortmentUpdate is true but assortmentItemDropField not set', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT], partialAssortmentUpdate: true, assortmentId: 'a' };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'a' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('assortmentItemDropField is not set'));
+            expect(issue).toBeDefined();
+        });
+        it('should error when drop field column not present in data', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                partialAssortmentUpdate: true,
+                assortmentItemDropField: 'toDrop',
+                assortmentId: 'a',
+            };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'a' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('drop field column'));
+            expect(issue).toBeDefined();
+        });
+        it('should not error when drop field is set and present in data', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                partialAssortmentUpdate: true,
+                assortmentItemDropField: 'toDrop',
+                assortmentId: 'a',
+            };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'a', toDrop: '' }];
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis());
+            const issue = result.issues.find((i) => i.message.includes('drop field'));
+            expect(issue).toBeUndefined();
+        });
+    });
+    describe('typePath existence validation', () => {
+        it('should error when typesByPath contains entries with errors (non-existent type)', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ITEM],
+                conditionalColumns: [{ default: 'item:product:test', toProperty: 'typePath' }],
+                federatedMappings: { itemFamilyFederatedId: 'family_federated_id', name: 'family_name' },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', typePath: 'item:product:test' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B', typePath: 'item:product:test' },
+            ];
+            const typesByPath = {
+                'item:product:test': {
+                    type: null,
+                    allPropertiesSlugs: [],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                    error: { message: 'Invalid Type: item:product:test', issueType: 'INVALID_DATA' },
+                },
+            };
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis({}, typesByPath));
+            expect(result.valid).toBe(false);
+            const typeIssue = result.issues.find((i) => i.severity === types_3.PreValidationSeverity.ERROR && i.message.includes('item:product:test'));
+            expect(typeIssue).toBeDefined();
+        });
+        it('should not error when typesByPath entries have no errors', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ITEM],
+                conditionalColumns: [{ default: 'item:product', toProperty: 'typePath' }],
+                federatedMappings: { itemFamilyFederatedId: 'family_federated_id', name: 'family_name' },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', typePath: 'item:product' },
+            ];
+            const typesByPath = {
+                'item:product': {
+                    type: { typeProperties: [] },
+                    allPropertiesSlugs: [],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis({}, typesByPath));
+            const typeIssue = result.issues.find((i) => i.severity === types_3.PreValidationSeverity.ERROR && i.message.includes('item:product'));
+            expect(typeIssue).toBeUndefined();
+        });
+        it('should error for each invalid typePath when multiple types have errors', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { itemFamilyFederatedId: 'family_federated_id', name: 'family_name' },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', typePath: 'item:foo' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B', typePath: 'item:bar' },
+            ];
+            const typesByPath = {
+                'item:foo': {
+                    type: null,
+                    allPropertiesSlugs: [],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                    error: { message: 'Invalid Type: item:foo', issueType: 'INVALID_DATA' },
+                },
+                'item:bar': {
+                    type: null,
+                    allPropertiesSlugs: [],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                    error: { message: 'Invalid Type: item:bar', issueType: 'INVALID_DATA' },
+                },
+            };
+            const result = await (0, validate_1.validate)(rows, config, makeAnalysis({}, typesByPath));
+            expect(result.valid).toBe(false);
+            const fooIssue = result.issues.find((i) => i.message.includes('item:foo'));
+            const barIssue = result.issues.find((i) => i.message.includes('item:bar'));
+            expect(fooIssue).toBeDefined();
+            expect(barIssue).toBeDefined();
+        });
+    });
+    describe('ALL/OVERRIDABLE suffix validation', () => {
+        const makeTypesByPathWithLevels = () => ({
+            'item:item': {
+                type: {
+                    typeProperties: [
+                        { slug: 'allProp', propertyLevel: types_2.PropertyLevel.ALL, propertyType: 'string' },
+                        { slug: 'overrideProp', propertyLevel: types_2.PropertyLevel.OVERRIDABLE, propertyType: 'string' },
+                        { slug: 'familyProp', propertyLevel: types_2.PropertyLevel.FAMILY, propertyType: 'string' },
+                        { slug: 'optionProp', propertyLevel: types_2.PropertyLevel.OPTION, propertyType: 'string' },
+                    ],
+                },
+                allPropertiesSlugs: ['allProp', 'overrideProp', 'familyProp', 'optionProp'],
+                typePropertyToValueType: {},
+                objectReferenceProperties: [],
+                userListProperties: [],
+            },
+        });
+        it('should reject unsuffixed ALL property column', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', allProp: 'value1' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            expect(result.valid).toBe(false);
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'allProp');
+            expect(suffixIssues).toHaveLength(1);
+            expect(suffixIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+            expect(suffixIssues[0].message).toContain('"allPropFamily"');
+            expect(suffixIssues[0].message).toContain('"allPropOption"');
+        });
+        it('should reject unsuffixed OVERRIDABLE property column', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', overrideProp: 'value1' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            expect(result.valid).toBe(false);
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'overrideProp');
+            expect(suffixIssues).toHaveLength(1);
+            expect(suffixIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+            expect(suffixIssues[0].message).toContain('"overridePropFamily"');
+            expect(suffixIssues[0].message).toContain('"overridePropOption"');
+        });
+        it('should allow suffixed Family/Option columns for ALL properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', allPropFamily: 'famVal', allPropOption: 'optVal' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && (i.columnName === 'allProp' || i.columnName === 'allPropFamily' || i.columnName === 'allPropOption'));
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should allow suffixed Family/Option columns for OVERRIDABLE properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', overridePropFamily: 'famVal', overridePropOption: 'optVal' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && (i.columnName === 'overrideProp' || i.columnName === 'overridePropFamily' || i.columnName === 'overridePropOption'));
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should allow only Family suffix without Option', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', allPropFamily: 'famVal' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'allProp');
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should not flag FAMILY-level properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', familyProp: 'value1' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'familyProp');
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should not flag OPTION-level properties', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', optionProp: 'value1' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'optionProp');
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should not run for non-item loads', async () => {
+            const colorConfig = {
+                loadType: [types_1.LoadType.COLOR],
+                federatedMappings: { federatedId: 'federatedId', name: 'name' },
+            };
+            const rows = [
+                { federatedId: 'color-1', name: 'Red', allProp: 'value1' },
+            ];
+            const typesByPath = {
+                'color': {
+                    type: {
+                        typeProperties: [
+                            { slug: 'allProp', propertyLevel: types_2.PropertyLevel.ALL, propertyType: 'string' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['allProp'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            const result = await (0, validate_1.validate)(rows, colorConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'allProp');
+            expect(suffixIssues).toHaveLength(0);
+        });
+        it('should include affected rows with values', async () => {
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', allProp: 'val1' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', allProp: 'val2' },
+            ];
+            const typesByPath = makeTypesByPathWithLevels();
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'allProp');
+            expect(suffixIssues).toHaveLength(1);
+            expect(suffixIssues[0].affectedRows).toHaveLength(2);
+            expect(suffixIssues[0].affectedRows[0]).toEqual({ row: 2, value: 'val1' });
+            expect(suffixIssues[0].affectedRows[1]).toEqual({ row: 3, value: 'val2' });
+        });
+        it('should reject columns matching by property label (not slug)', async () => {
+            const typesByPath = {
+                'item:item': {
+                    type: {
+                        typeProperties: [
+                            { slug: 'allProp', label: 'All Property', propertyLevel: types_2.PropertyLevel.ALL, propertyType: 'string' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['allProp'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', 'All Property': 'value1' },
+            ];
+            const result = await (0, validate_1.validate)(rows, baseConfig, makeAnalysis({}, typesByPath));
+            const suffixIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.CONFIG && i.columnName === 'All Property');
+            expect(suffixIssues).toHaveLength(1);
+            expect(suffixIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+            expect(suffixIssues[0].message).toContain('"allPropFamily"');
+            expect(suffixIssues[0].message).toContain('"allPropOption"');
+            expect(suffixIssues[0].propertySlug).toBe('allProp');
+        });
+    });
+    describe('self-reference validation', () => {
+        const colorConfig = {
+            loadType: [types_1.LoadType.COLOR],
+            federatedMappings: { federatedId: 'federatedId', name: 'name' },
+        };
+        const typesByPathWithObjectRef = {
+            color: {
+                type: {
+                    typeProperties: [
+                        { slug: 'relatedColor', propertyType: 'object_reference' },
+                    ],
+                },
+                allPropertiesSlugs: ['relatedColor'],
+                typePropertyToValueType: {},
+                objectReferenceProperties: [
+                    { slug: 'relatedColor', propertyType: 'object_reference' },
+                ],
+                userListProperties: [],
+            },
+        };
+        it('should detect self-referencing object reference on color', async () => {
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', relatedColor: 'color-1' },
+                { federatedId: 'color-2', name: 'Color 2', relatedColor: 'color-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithObjectRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].severity).toBe(types_3.PreValidationSeverity.ERROR);
+            expect(selfRefIssues[0].columnName).toBe('relatedColor');
+            expect(selfRefIssues[0].affectedRows).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows[0].row).toBe(2);
+            expect(selfRefIssues[0].affectedRows[0].value).toBe('color-1');
+            expect(result.valid).toBe(false);
+        });
+        it('should not flag non-self-referencing object references', async () => {
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', relatedColor: 'color-2' },
+                { federatedId: 'color-2', name: 'Color 2', relatedColor: 'color-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithObjectRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(0);
+        });
+        it('should detect family-level self-references on item-based loads', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathWithItemRef = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'parentStyleName', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.FAMILY },
+                        ],
+                    },
+                    allPropertiesSlugs: ['parentStyleName'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'parentStyleName', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.FAMILY },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'item-1', name: 'Item 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', parentStyleName: 'item-1' },
+                { itemFamilyFederatedId: 'item-2', name: 'Item 2', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', parentStyleName: 'item-3' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithItemRef);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].columnName).toBe('parentStyleName');
+            expect(selfRefIssues[0].affectedRows).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows[0].value).toBe('item-1');
+        });
+        it('should detect option-level self-references using itemOptionFederatedId', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathWithOptionRef = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'relatedOption', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OPTION },
+                        ],
+                    },
+                    allPropertiesSlugs: ['relatedOption'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'relatedOption', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OPTION },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', relatedOption: 'opt-1' },
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', relatedOption: 'opt-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithOptionRef);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows[0].row).toBe(2);
+        });
+        it('should not flag option-level ref matching family id', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathWithOptionRef = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'relatedOption', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OPTION },
+                        ],
+                    },
+                    allPropertiesSlugs: ['relatedOption'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'relatedOption', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OPTION },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', relatedOption: 'fam-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithOptionRef);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(0);
+        });
+        it('should check overridable Family-suffixed column against itemFamilyFederatedId', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathOverridable = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'parentRef', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OVERRIDABLE },
+                        ],
+                    },
+                    allPropertiesSlugs: ['parentRef'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'parentRef', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OVERRIDABLE },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', parentRefFamily: 'fam-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathOverridable);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].columnName).toBe('parentRefFamily');
+        });
+        it('should check overridable Option-suffixed column against itemOptionFederatedId', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathOverridable = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'parentRef', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OVERRIDABLE },
+                        ],
+                    },
+                    allPropertiesSlugs: ['parentRef'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'parentRef', propertyType: 'object_reference', propertyLevel: types_2.PropertyLevel.OVERRIDABLE },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', parentRefOption: 'opt-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathOverridable);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].columnName).toBe('parentRefOption');
+        });
+        it('should treat undefined property level as family-level for items', async () => {
+            const itemConfig = {
+                loadType: [types_1.LoadType.ITEM],
+                federatedMappings: { federatedId: 'itemFamilyFederatedId', name: 'name' },
+            };
+            const typesByPathNoLevel = {
+                item: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'parentStyleName', propertyType: 'object_reference' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['parentStyleName'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'parentStyleName', propertyType: 'object_reference' },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'Fam 1', itemOptionFederatedId: 'opt-1', optionName: 'Opt 1', parentStyleName: 'fam-1' },
+                { itemFamilyFederatedId: 'fam-2', name: 'Fam 2', itemOptionFederatedId: 'opt-2', optionName: 'Opt 2', parentStyleName: 'opt-2' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathNoLevel);
+            const result = await (0, validate_1.validate)(rows, itemConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows[0].value).toBe('fam-1');
+        });
+        it('should detect multiple self-referencing rows on the same property', async () => {
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', relatedColor: 'color-1' },
+                { federatedId: 'color-2', name: 'Color 2', relatedColor: 'color-2' },
+                { federatedId: 'color-3', name: 'Color 3', relatedColor: 'color-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithObjectRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(1);
+            expect(selfRefIssues[0].affectedRows).toHaveLength(2);
+            expect(selfRefIssues[0].message).toContain('2 row(s)');
+        });
+        it('should skip empty object reference values', async () => {
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', relatedColor: '' },
+                { federatedId: 'color-2', name: 'Color 2', relatedColor: null },
+            ];
+            const analysis = makeAnalysis({}, typesByPathWithObjectRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(0);
+        });
+        it('should handle multiple object reference properties on the same type', async () => {
+            const typesByPathMultiRef = {
+                color: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'relatedColor', propertyType: 'object_reference' },
+                            { slug: 'parentColor', propertyType: 'object_reference' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['relatedColor', 'parentColor'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [
+                        { slug: 'relatedColor', propertyType: 'object_reference' },
+                        { slug: 'parentColor', propertyType: 'object_reference' },
+                    ],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', relatedColor: 'color-1', parentColor: 'color-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathMultiRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(2);
+            const slugs = selfRefIssues.map((i) => i.columnName).sort();
+            expect(slugs).toEqual(['parentColor', 'relatedColor']);
+        });
+        it('should not flag when no object reference properties exist', async () => {
+            const typesByPathNoRef = {
+                color: {
+                    type: {
+                        typeProperties: [
+                            { slug: 'colorName', propertyType: 'string' },
+                        ],
+                    },
+                    allPropertiesSlugs: ['colorName'],
+                    typePropertyToValueType: {},
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            const rows = [
+                { federatedId: 'color-1', name: 'Color 1', colorName: 'color-1' },
+            ];
+            const analysis = makeAnalysis({}, typesByPathNoRef);
+            const result = await (0, validate_1.validate)(rows, colorConfig, analysis);
+            const selfRefIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.SELF_REFERENCE);
+            expect(selfRefIssues).toHaveLength(0);
+        });
+    });
+    describe('unmapped column and type property warnings', () => {
+        it('should generate WARNING for unmapped CSV columns', async () => {
+            const analysis = makeAnalysis();
+            analysis.columns = [
+                { csvHeader: 'unknownCol', isMapped: false, isRequired: false, isArchived: false, hasOptionSet: false },
+            ];
+            const result = await (0, validate_1.validate)([{ unknownCol: 'val' }], baseConfig, analysis);
+            const unmappedColIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.UNMAPPED_COLUMN);
+            expect(unmappedColIssues).toHaveLength(1);
+            expect(unmappedColIssues[0].severity).toBe(types_3.PreValidationSeverity.WARNING);
+            expect(unmappedColIssues[0].columnName).toBe('unknownCol');
+            expect(unmappedColIssues[0].message).toContain('unknownCol');
+        });
+        it('should generate WARNING for unmapped type properties', async () => {
+            const analysis = makeAnalysis();
+            analysis.unmappedTypeProperties = [
+                { slug: 'missingProp', label: 'Missing Property', propertyType: 'string', isRequired: false, hasOptionSet: false },
+            ];
+            const result = await (0, validate_1.validate)([{ name: 'test' }], baseConfig, analysis);
+            const unmappedPropIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.UNMAPPED_TYPE_PROPERTY);
+            expect(unmappedPropIssues).toHaveLength(1);
+            expect(unmappedPropIssues[0].severity).toBe(types_3.PreValidationSeverity.WARNING);
+            expect(unmappedPropIssues[0].propertySlug).toBe('missingProp');
+            expect(unmappedPropIssues[0].message).toContain('Missing Property');
+        });
+        it('should not generate unmapped issues when all columns and properties are mapped', async () => {
+            const analysis = makeAnalysis();
+            analysis.columns = [
+                { csvHeader: 'color', isMapped: true, matchedSlug: 'color', isRequired: false, isArchived: false, hasOptionSet: false },
+            ];
+            analysis.unmappedTypeProperties = [];
+            const result = await (0, validate_1.validate)([{ color: 'red' }], baseConfig, analysis);
+            const unmappedIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.UNMAPPED_COLUMN || i.category === types_3.PreValidationCategory.UNMAPPED_TYPE_PROPERTY);
+            expect(unmappedIssues).toHaveLength(0);
+        });
+        it('should use label in message when available, fall back to slug', async () => {
+            const analysis = makeAnalysis();
+            analysis.unmappedTypeProperties = [
+                { slug: 'noLabel', propertyType: 'string', isRequired: false, hasOptionSet: false },
+            ];
+            const result = await (0, validate_1.validate)([{ name: 'test' }], baseConfig, analysis);
+            const unmappedPropIssues = result.issues.filter((i) => i.category === types_3.PreValidationCategory.UNMAPPED_TYPE_PROPERTY);
+            expect(unmappedPropIssues[0].message).toContain('noLabel');
+        });
+    });
+});