@contrail/cli 3.4.11-alpha.feeaf0b → 3.4.12-alpha.54199ed

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

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

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

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

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

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

package/node_modules/@contrail/loader/lib/pipeline/preview.js

@@ -21,11 +21,6 @@ async function preview(client, rows, config, columnAnalysis) {
         const itemsByFederatedId = entityType !== types_1.EntityType.ITEM ? { ...sharedItemsByFederatedId } : {};
         const clonedRows = rows.map(row => ({ ...row }));
         const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entityType, clonedRows, undefined, loaderProcess, itemsByFederatedId, doConstructEntities, columnAnalysis.typesByPath ? buildTypesByTypePathCache(columnAnalysis) : undefined);
-        if (result.generalWarnings?.length) {
-            for (const warning of result.generalWarnings) {
-                allWarnings.push(warning.message);
-            }
-        }
         if (result.badEntities?.length) {
             for (let i = 0; i < result.badEntities.length; i++) {
                 const badEntity = result.badEntities[i];

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

@@ -122,7 +122,7 @@ describe('preview (non-item entity types)', () => {
         expect(result.staleRows[0].details?.incomingTimestamp).toBe('2024-01-01T00:00:00Z');
         expect(result.staleRows[0].details?.existingTimestamp).toBe('2024-06-01T00:00:00Z');
     });
-    it('should collect warnings from object reference resolution', async () => {
+    it('should not duplicate object-reference resolution warnings (now surfaced by validate)', async () => {
         entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({
             incomingEntities: [],
             badEntities: [],
@@ -135,7 +135,7 @@ describe('preview (non-item entity types)', () => {
         });
         const rows = [{ federatedId: '1' }];
         const result = await (0, preview_1.preview)(mockClient, rows, baseConfig, baseAnalysis);
-        expect(result.warnings).toContain('ObjectReference not found for vendor with value acme');
+        expect(result.warnings).not.toContain('ObjectReference not found for vendor with value acme');
     });
     it('should store constructed entities for execute stage', async () => {
         entity_processor_v2_1.EntityProcessorV2.setupEntities.mockResolvedValue({

package/node_modules/@contrail/loader/lib/pipeline/types.d.ts

@@ -41,7 +41,9 @@ export declare enum PreValidationCategory {
     SELF_REFERENCE = "SELF_REFERENCE",
     UNMAPPED_COLUMN = "UNMAPPED_COLUMN",
     UNMAPPED_TYPE_PROPERTY = "UNMAPPED_TYPE_PROPERTY",
-    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION"
+    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION",
+    INVALID_DATA = "INVALID_DATA",
+    DUPLICATE_FEDERATED_ID = "DUPLICATE_FEDERATED_ID"
 }
 export declare enum PreValidationSeverity {
     ERROR = "error",

package/node_modules/@contrail/loader/lib/pipeline/types.js

@@ -49,6 +49,8 @@ var PreValidationCategory;
     PreValidationCategory["UNMAPPED_COLUMN"] = "UNMAPPED_COLUMN";
     PreValidationCategory["UNMAPPED_TYPE_PROPERTY"] = "UNMAPPED_TYPE_PROPERTY";
     PreValidationCategory["FORMAT_NUMBER_PRECISION"] = "FORMAT_NUMBER_PRECISION";
+    PreValidationCategory["INVALID_DATA"] = "INVALID_DATA";
+    PreValidationCategory["DUPLICATE_FEDERATED_ID"] = "DUPLICATE_FEDERATED_ID";
 })(PreValidationCategory = exports.PreValidationCategory || (exports.PreValidationCategory = {}));
 var PreValidationSeverity;
 (function (PreValidationSeverity) {

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

@@ -2,15 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = void 0;
 const types_1 = require("@contrail/types");
+const lodash_1 = require("lodash");
 const entity_processor_v2_1 = require("../entities-v2/entity-processor-v2");
 const processor_registry_1 = require("../processor-registry");
 const entities_helper_1 = require("../entities-v2/entities-helper");
+const entities_helper_2 = require("../common/entities-helper");
+const chunk_by_url_length_1 = require("../common/chunk-by-url-length");
+const pLimit = require('p-limit');
 const types_2 = require("./types");
 const CONFIG_CATEGORY = types_2.PreValidationCategory.CONFIG;
 const MISSING_REQUIRED_FIELD_CATEGORY = types_2.PreValidationCategory.MISSING_REQUIRED_FIELD;
 const REFERENCE_NOT_FOUND_CATEGORY = types_2.PreValidationCategory.REFERENCE_DATA_NOT_FOUND;
 const FAMILY_INCONSISTENT_CATEGORY = types_2.PreValidationCategory.FAMILY_PROPERTY_VALUES_INCONSISTENT;
 const SELF_REFERENCE_CATEGORY = types_2.PreValidationCategory.SELF_REFERENCE;
+function issueTypeToCategory(issueType) {
+    switch (issueType) {
+        case types_2.IssueType.INVALID_DATA:
+            return types_2.PreValidationCategory.INVALID_DATA;
+        case types_2.IssueType.MISSING_DATA:
+            return types_2.PreValidationCategory.MISSING_REQUIRED_FIELD;
+        case types_2.IssueType.DUPLICATE_FEDERATED_ID:
+            return types_2.PreValidationCategory.DUPLICATE_FEDERATED_ID;
+        case types_2.IssueType.CONFIG:
+        default:
+            return types_2.PreValidationCategory.CONFIG;
+    }
+}
 function isEmpty(value) {
     return value === null || value === undefined || value === '';
 }
@@ -54,6 +71,10 @@ async function validate(rows, config, columnAnalysis, client) {
     issues.push(...suffixIssues);
     const selfRefIssues = validateSelfReferences(rows, config, columnAnalysis.typesByPath);
     issues.push(...selfRefIssues);
+    if (client) {
+        const objectRefIssues = await validateObjectReferences(rows, columnAnalysis.typesByPath, client);
+        issues.push(...objectRefIssues);
+    }
     const optionSetIssues = validateOptionSets(rows, columnAnalysis.typePropertyMaps);
     issues.push(...optionSetIssues);
     const booleanIssues = validateBooleanFormats(rows, columnAnalysis.typePropertyMaps);
@@ -143,7 +164,7 @@ function runProcessorValidation(rows, config) {
         for (const colIssue of error.columnIssues ?? []) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
-                category: CONFIG_CATEGORY,
+                category: issueTypeToCategory(colIssue.issueType),
                 columnName: colIssue.columnName,
                 propertySlug: colIssue.columnName,
                 propertyType: '',
@@ -156,7 +177,7 @@ function runProcessorValidation(rows, config) {
         for (const colIssue of warning.columnIssues ?? []) {
             issues.push({
                 severity: types_2.PreValidationSeverity.WARNING,
-                category: CONFIG_CATEGORY,
+                category: issueTypeToCategory(colIssue.issueType),
                 columnName: colIssue.columnName,
                 propertySlug: colIssue.columnName,
                 propertyType: '',
@@ -1130,6 +1151,107 @@ function buildObjectRefColumnChecks(typesByPath, isItemBased) {
     }
     return checks;
 }
+async function validateObjectReferences(rows, typesByPath, client) {
+    const objectRefColumns = [];
+    for (const typePath of Object.keys(typesByPath ?? {})) {
+        const typeObj = typesByPath[typePath];
+        for (const prop of typeObj?.objectReferenceProperties ?? []) {
+            objectRefColumns.push({
+                slug: prop.slug,
+                rootType: prop.referencedTypeRootSlug,
+                referencedTypePath: prop.referencedTypePath,
+            });
+        }
+    }
+    if (objectRefColumns.length === 0)
+        return [];
+    const fedIdsByRootType = {};
+    const prefixFedId = (fedId, referencedTypePath) => {
+        if (referencedTypePath?.startsWith('custom-entity') && !fedId.startsWith('custom-entity:')) {
+            return `${referencedTypePath}:${fedId}`;
+        }
+        return fedId;
+    };
+    for (const row of rows) {
+        for (const ref of objectRefColumns) {
+            if (!ref.rootType)
+                continue;
+            const variants = (0, entities_helper_2.getPropertyVariants)(row, ref.slug, 'values');
+            for (const rawValue of variants) {
+                if (isEmpty(rawValue))
+                    continue;
+                const fedId = prefixFedId(String(rawValue), ref.referencedTypePath);
+                if (!fedIdsByRootType[ref.rootType])
+                    fedIdsByRootType[ref.rootType] = [];
+                fedIdsByRootType[ref.rootType].push(fedId);
+            }
+        }
+    }
+    const limit = pLimit(5);
+    const resolvedFedIds = new Set();
+    for (const rootType of Object.keys(fedIdsByRootType)) {
+        const uniqueFedIds = [...new Set(fedIdsByRootType[rootType])];
+        if (uniqueFedIds.length === 0)
+            continue;
+        const chunks = (0, chunk_by_url_length_1.chunkByUrlLength)(uniqueFedIds);
+        const promises = [];
+        for (const chunk of chunks) {
+            if (!chunk?.length)
+                continue;
+            promises.push(limit(async () => {
+                const batch = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                    entityName: rootType,
+                    federatedIds: (0, lodash_1.uniq)(chunk),
+                    skipHydrateRelationships: true,
+                });
+                if (Array.isArray(batch)) {
+                    for (const entity of batch) {
+                        if (entity?.federatedId)
+                            resolvedFedIds.add(entity.federatedId);
+                    }
+                }
+            }));
+        }
+        await Promise.all(promises);
+    }
+    const missingByColumnAndValue = {};
+    forEachRow(rows, (row, rowNumber) => {
+        for (const ref of objectRefColumns) {
+            if (!ref.rootType)
+                continue;
+            const variants = (0, entities_helper_2.getPropertyVariants)(row, ref.slug, 'keyValue');
+            for (const variant of variants) {
+                if (isEmpty(variant.value))
+                    continue;
+                const rawValue = String(variant.value);
+                const lookupKey = prefixFedId(rawValue, ref.referencedTypePath);
+                if (resolvedFedIds.has(lookupKey))
+                    continue;
+                if (!missingByColumnAndValue[variant.key])
+                    missingByColumnAndValue[variant.key] = new Map();
+                const byValue = missingByColumnAndValue[variant.key];
+                if (!byValue.has(rawValue))
+                    byValue.set(rawValue, []);
+                byValue.get(rawValue).push({ row: rowNumber, value: rawValue });
+            }
+        }
+    });
+    const issues = [];
+    for (const [columnName, byValue] of Object.entries(missingByColumnAndValue)) {
+        for (const [missingValue, affectedRows] of byValue) {
+            issues.push({
+                severity: types_2.PreValidationSeverity.WARNING,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName,
+                propertySlug: columnName,
+                propertyType: 'object_reference',
+                message: `Value "${missingValue}" does not match any existing entity for object reference property "${columnName}".`,
+                affectedRows,
+            });
+        }
+    }
+    return issues;
+}
 const NUMERIC_PROPERTY_TYPES = new Set(['number', 'currency', 'percent', 'sequence']);
 function validateNumberPrecision(rows, typePropertyMaps) {
     const { typePropertiesBySlug } = typePropertyMaps;