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

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

@@ -2,15 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = void 0;
 const types_1 = require("@contrail/types");
+const lodash_1 = require("lodash");
+const data_transformer_functions_1 = require("../common/data-transformer-functions");
 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 === '';
 }
@@ -26,24 +44,15 @@ async function validate(rows, config, columnAnalysis, client) {
     if (!rows?.length) {
         return buildResult(issues);
     }
+    if (columnAnalysis.identifierIssues?.length) {
+        issues.push(...columnAnalysis.identifierIssues);
+    }
     const processorIssues = runProcessorValidation(rows, config);
     issues.push(...processorIssues);
     const itemNameIssues = validateItemNames(rows, config);
     issues.push(...itemNameIssues);
     const identifierConflictIssues = validateStaticIdentifierConflicts(config);
     issues.push(...identifierConflictIssues);
-    const projectItemColumnIssues = validateProjectItemColumns(rows, config);
-    issues.push(...projectItemColumnIssues);
-    if (client && projectItemColumnIssues.length === 0) {
-        const resolutionIssues = await validateAndResolveProjectIdentifiers(rows, config, client);
-        issues.push(...resolutionIssues);
-    }
-    const assortmentColumnIssues = validateAssortmentColumns(rows, config);
-    issues.push(...assortmentColumnIssues);
-    if (client && assortmentColumnIssues.length === 0) {
-        const assortmentIssues = await validateAndResolveAssortmentIdentifiers(rows, config, client);
-        issues.push(...assortmentIssues);
-    }
     const partialUpdateIssues = validatePartialAssortmentConfig(rows, config);
     issues.push(...partialUpdateIssues);
     const typePathExistenceIssues = validateTypePathExistence(columnAnalysis.typesByPath);
@@ -54,6 +63,12 @@ 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 transformIssues = promoteTransformValidationErrors(columnAnalysis);
+    issues.push(...transformIssues);
     const optionSetIssues = validateOptionSets(rows, columnAnalysis.typePropertyMaps);
     issues.push(...optionSetIssues);
     const booleanIssues = validateBooleanFormats(rows, columnAnalysis.typePropertyMaps);
@@ -143,7 +158,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 +171,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: '',
@@ -167,48 +182,89 @@ function runProcessorValidation(rows, config) {
     }
     return issues;
 }
+function promoteTransformValidationErrors(columnAnalysis) {
+    const issues = [];
+    const buckets = [
+        ...(columnAnalysis.errors ?? []),
+        ...(columnAnalysis.warnings ?? []),
+    ];
+    const optionSetMap = columnAnalysis.typePropertyMaps?.optionSetUsingTypePropertiesBySlug ?? {};
+    const isOptionSetColumn = (col) => Boolean(optionSetMap[col] || optionSetMap[(0, data_transformer_functions_1.removeOptionOrFamilySuffix)(col)]);
+    const grouped = new Map();
+    for (const issue of buckets) {
+        for (const ci of issue?.columnIssues ?? []) {
+            if (ci?.issueType !== types_2.IssueType.VALIDATION_ERROR)
+                continue;
+            if (isOptionSetColumn(ci.columnName))
+                continue;
+            const key = `${ci.columnName}::${ci.message}`;
+            if (!grouped.has(key)) {
+                grouped.set(key, { columnName: ci.columnName, message: ci.message, affectedRows: [] });
+            }
+            grouped.get(key).affectedRows.push({
+                row: issue.rowNumber ?? -1,
+                value: ci.data ?? '',
+            });
+        }
+    }
+    for (const { columnName, message, affectedRows } of grouped.values()) {
+        issues.push({
+            severity: types_2.PreValidationSeverity.ERROR,
+            category: types_2.PreValidationCategory.OPTION_SET,
+            columnName,
+            propertySlug: (0, data_transformer_functions_1.removeOptionOrFamilySuffix)(columnName),
+            propertyType: 'multi_select',
+            message,
+            affectedRows,
+        });
+    }
+    return issues;
+}
 function validateOptionSets(rows, typePropertyMaps) {
     const { optionSetUsingTypePropertiesBySlug } = typePropertyMaps;
     const issues = [];
     const skipColumns = new Set();
+    const propertyForColumn = (key) => optionSetUsingTypePropertiesBySlug[key] ??
+        optionSetUsingTypePropertiesBySlug[(0, data_transformer_functions_1.removeOptionOrFamilySuffix)(key)];
     const affectedRowsByColumn = {};
+    const propertyByColumn = {};
     forEachRow(rows, (row, rowNumber) => {
         for (const [key, value] of Object.entries(row)) {
             if (isEmpty(value))
                 continue;
-            if (!optionSetUsingTypePropertiesBySlug[key])
+            const property = propertyForColumn(key);
+            if (!property)
                 continue;
             if (!affectedRowsByColumn[key])
                 affectedRowsByColumn[key] = [];
             affectedRowsByColumn[key].push({ row: rowNumber, value: String(value) });
+            propertyByColumn[key] = property;
         }
     });
-    for (const [slug, property] of Object.entries(optionSetUsingTypePropertiesBySlug)) {
-        if (!affectedRowsByColumn[slug])
-            continue;
+    for (const [columnName, property] of Object.entries(propertyByColumn)) {
         if (!property.typePropertyOptionSetId) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
                 category: types_2.PreValidationCategory.OPTION_SET,
-                columnName: slug,
+                columnName,
                 propertySlug: property.slug,
                 propertyType: property.propertyType,
-                message: `Property "${slug}" is type ${PROPERTY_TYPE_DISPLAY[property.propertyType] ?? property.propertyType} but has no option set attached. Attach an option set to this property or change the property type.`,
-                affectedRows: affectedRowsByColumn[slug],
+                message: `Property "${columnName}" is type ${PROPERTY_TYPE_DISPLAY[property.propertyType] ?? property.propertyType} but has no option set attached. Attach an option set to this property or change the property type.`,
+                affectedRows: affectedRowsByColumn[columnName],
             });
-            skipColumns.add(slug);
+            skipColumns.add(columnName);
         }
         else if (!property.options || property.options.length === 0) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
                 category: types_2.PreValidationCategory.OPTION_SET,
-                columnName: slug,
+                columnName,
                 propertySlug: property.slug,
                 propertyType: property.propertyType,
-                message: `Option set for property "${slug}" is empty. Values in this column cannot be validated. Populate the option set or remove data from this column.`,
-                affectedRows: affectedRowsByColumn[slug],
+                message: `Option set for property "${columnName}" is empty. Values in this column cannot be validated. Populate the option set or remove data from this column.`,
+                affectedRows: affectedRowsByColumn[columnName],
             });
-            skipColumns.add(slug);
+            skipColumns.add(columnName);
         }
     }
     const issuesByColumn = {};
@@ -216,7 +272,7 @@ function validateOptionSets(rows, typePropertyMaps) {
         for (const [key, value] of Object.entries(row)) {
             if (isEmpty(value))
                 continue;
-            const property = optionSetUsingTypePropertiesBySlug[key];
+            const property = propertyForColumn(key);
             if (!property)
                 continue;
             if (skipColumns.has(key))
@@ -598,211 +654,6 @@ function validateAllOverrideSuffixes(rows, config, columnAnalysis) {
     }
     return issues;
 }
-async function validateAndResolveProjectIdentifiers(rows, config, client) {
-    const isProjectItemLoad = config.loadType.some((lt) => lt === types_2.LoadType.PROJECT_ITEM);
-    if (!isProjectItemLoad)
-        return [];
-    const hasWorkspaceIdentifier = rows.some((row) => row.workspaceIdentifier);
-    if (hasWorkspaceIdentifier) {
-        return validateWorkspaceIdentifiers(rows, client);
-    }
-    return validateProjectIds(rows, client);
-}
-async function validateWorkspaceIdentifiers(rows, client) {
-    const issues = [];
-    const cache = {};
-    const uniqueIdentifiers = new Set();
-    for (const row of rows) {
-        if (row.workspaceIdentifier)
-            uniqueIdentifiers.add(row.workspaceIdentifier);
-    }
-    for (const wsIdentifier of uniqueIdentifiers) {
-        try {
-            const project = await resolveProjectIdFromWorkspace(client, wsIdentifier);
-            cache[wsIdentifier] = project;
-            if (!project) {
-                const affectedRows = [];
-                rows.forEach((row, index) => {
-                    if (row.workspaceIdentifier === wsIdentifier) {
-                        affectedRows.push({ row: index + 2, value: wsIdentifier });
-                    }
-                });
-                issues.push({
-                    severity: types_2.PreValidationSeverity.ERROR,
-                    category: REFERENCE_NOT_FOUND_CATEGORY,
-                    columnName: 'workspaceIdentifier',
-                    propertySlug: 'workspaceIdentifier',
-                    propertyType: 'string',
-                    message: `Could not resolve workspace identifier "${wsIdentifier}" to a project. Verify the workspace exists and is a PROJECT type workspace.`,
-                    affectedRows,
-                });
-            }
-        }
-        catch (e) {
-            issues.push({
-                severity: types_2.PreValidationSeverity.ERROR,
-                category: REFERENCE_NOT_FOUND_CATEGORY,
-                columnName: 'workspaceIdentifier',
-                propertySlug: 'workspaceIdentifier',
-                propertyType: 'string',
-                message: `Failed to resolve workspace identifier "${wsIdentifier}": ${e.message}`,
-                affectedRows: [],
-            });
-        }
-    }
-    if (issues.length === 0) {
-        for (const row of rows) {
-            if (row.workspaceIdentifier) {
-                const project = cache[row.workspaceIdentifier];
-                row.projectId = project.id;
-                row.projectName = project.name;
-                delete row.workspaceIdentifier;
-            }
-        }
-    }
-    return issues;
-}
-async function validateProjectIds(rows, client) {
-    const issues = [];
-    const nameCache = {};
-    const uniqueProjectIds = new Set();
-    for (const row of rows) {
-        if (row.projectId)
-            uniqueProjectIds.add(row.projectId);
-    }
-    if (uniqueProjectIds.size === 0)
-        return [];
-    for (const projectId of uniqueProjectIds) {
-        try {
-            const project = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
-                entityName: 'project',
-                id: projectId,
-                skipHydrateRelationships: true,
-            });
-            if (!project) {
-                const affectedRows = [];
-                rows.forEach((row, index) => {
-                    if (row.projectId === projectId) {
-                        affectedRows.push({ row: index + 2, value: projectId });
-                    }
-                });
-                issues.push({
-                    severity: types_2.PreValidationSeverity.ERROR,
-                    category: REFERENCE_NOT_FOUND_CATEGORY,
-                    columnName: 'projectId',
-                    propertySlug: 'projectId',
-                    propertyType: 'string',
-                    message: `Project "${projectId}" not found. Verify the project ID is correct and the project exists.`,
-                    affectedRows,
-                });
-            }
-            else {
-                nameCache[projectId] = project.name || project.identifier || projectId;
-            }
-        }
-        catch (e) {
-            const affectedRows = [];
-            rows.forEach((row, index) => {
-                if (row.projectId === projectId) {
-                    affectedRows.push({ row: index + 2, value: projectId });
-                }
-            });
-            issues.push({
-                severity: types_2.PreValidationSeverity.ERROR,
-                category: REFERENCE_NOT_FOUND_CATEGORY,
-                columnName: 'projectId',
-                propertySlug: 'projectId',
-                propertyType: 'string',
-                message: `Failed to validate project "${projectId}": ${e.message}`,
-                affectedRows,
-            });
-        }
-    }
-    if (issues.length === 0) {
-        for (const row of rows) {
-            if (row.projectId && nameCache[row.projectId]) {
-                row.projectName = nameCache[row.projectId];
-            }
-        }
-    }
-    return issues;
-}
-async function resolveProjectIdFromWorkspace(client, workspaceIdentifier) {
-    const workspaces = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
-        entityName: 'workspace',
-        criteria: {
-            identifier: workspaceIdentifier,
-            workspaceType: 'PROJECT',
-        },
-        skipHydrateRelationships: true,
-    });
-    if (!workspaces?.length)
-        return null;
-    const workspaceId = workspaces[0]?.id;
-    if (!workspaceId)
-        return null;
-    const workspace = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
-        entityName: 'workspace',
-        id: workspaceId,
-        relations: ['project'],
-        skipHydrateRelationships: true,
-    });
-    const project = workspace?.project;
-    if (!project?.id)
-        return null;
-    return { id: project.id, name: project.name || project.id };
-}
-function validateProjectItemColumns(rows, config) {
-    const isProjectItemLoad = config.loadType.some((lt) => lt === types_2.LoadType.PROJECT_ITEM);
-    if (!isProjectItemLoad)
-        return [];
-    const issues = [];
-    const hasWorkspaceIdentifier = rows.some((row) => row.workspaceIdentifier !== undefined);
-    const hasProjectId = rows.some((row) => row.projectId !== undefined);
-    if (hasWorkspaceIdentifier && hasProjectId) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: CONFIG_CATEGORY,
-            columnName: 'workspaceIdentifier / projectId',
-            propertySlug: '',
-            propertyType: '',
-            message: 'Rows contain both "workspaceIdentifier" and "projectId" columns. Use one or the other to identify the target project.',
-            affectedRows: [],
-        });
-        return issues;
-    }
-    if (!hasWorkspaceIdentifier && !hasProjectId) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: CONFIG_CATEGORY,
-            columnName: 'workspaceIdentifier / projectId',
-            propertySlug: '',
-            propertyType: '',
-            message: 'PROJECT_ITEM loads require a "workspaceIdentifier" or "projectId" column (or a config-level workspaceIdentifier) to identify the target project.',
-            affectedRows: [],
-        });
-        return issues;
-    }
-    const columnName = hasWorkspaceIdentifier ? 'workspaceIdentifier' : 'projectId';
-    const emptyRows = [];
-    forEachRow(rows, (row, rowNumber) => {
-        if (isEmpty(row[columnName])) {
-            emptyRows.push({ row: rowNumber, value: '' });
-        }
-    });
-    if (emptyRows.length > 0) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: MISSING_REQUIRED_FIELD_CATEGORY,
-            columnName,
-            propertySlug: columnName,
-            propertyType: 'string',
-            message: `"${columnName}" cannot be empty for project-item rows. ${emptyRows.length} row(s) have an empty value.`,
-            affectedRows: emptyRows,
-        });
-    }
-    return issues;
-}
 function validateStaticIdentifierConflicts(config) {
     const issues = [];
     const conditionalTargets = new Set((config.conditionalColumns || []).map((col) => col.toProperty));
@@ -827,211 +678,6 @@ function validateStaticIdentifierConflicts(config) {
     }
     return issues;
 }
-function validateAssortmentColumns(rows, config) {
-    const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
-    if (!isAssortmentLoad)
-        return [];
-    const issues = [];
-    const hasAssortmentId = rows.some((row) => row.assortmentId !== undefined);
-    const hasAssortmentIdentifier = rows.some((row) => row.assortmentIdentifier !== undefined);
-    const assortmentIdFromConditions = (config.conditionalColumns || []).some((col) => (col.toProperty === 'assortmentId' || col.toProperty === 'assortmentIdentifier') && col.conditions?.length);
-    if (!hasAssortmentId && !hasAssortmentIdentifier) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: CONFIG_CATEGORY,
-            columnName: 'assortmentId / assortmentIdentifier',
-            propertySlug: '',
-            propertyType: '',
-            message: 'ASSORTMENT loads require an "assortmentId" or "assortmentIdentifier" column (or a config-level assortmentId/assortmentIdentifier) to identify the target assortment.',
-            affectedRows: [],
-        });
-        return issues;
-    }
-    const bothRows = [];
-    forEachRow(rows, (row, rowNumber) => {
-        const hasId = !isEmpty(row.assortmentId);
-        const hasIdent = !isEmpty(row.assortmentIdentifier);
-        if (hasId && hasIdent) {
-            bothRows.push({ row: rowNumber, value: `${row.assortmentId} / ${row.assortmentIdentifier}` });
-        }
-    });
-    if (bothRows.length > 0) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: CONFIG_CATEGORY,
-            columnName: 'assortmentId / assortmentIdentifier',
-            propertySlug: '',
-            propertyType: '',
-            message: `${bothRows.length} row(s) have both "assortmentId" and "assortmentIdentifier". Each row must use one or the other.`,
-            affectedRows: bothRows,
-        });
-        return issues;
-    }
-    const emptyIdRows = [];
-    const emptyIdentRows = [];
-    forEachRow(rows, (row, rowNumber) => {
-        if (hasAssortmentId && row.assortmentId !== undefined) {
-            if (isEmpty(row.assortmentId)) {
-                emptyIdRows.push({ row: rowNumber, value: '' });
-            }
-        }
-        else if (hasAssortmentId && row.assortmentId === undefined && !assortmentIdFromConditions) {
-            emptyIdRows.push({ row: rowNumber, value: '' });
-        }
-        if (hasAssortmentIdentifier && row.assortmentIdentifier !== undefined) {
-            if (isEmpty(row.assortmentIdentifier)) {
-                emptyIdentRows.push({ row: rowNumber, value: '' });
-            }
-        }
-    });
-    if (emptyIdRows.length > 0) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: MISSING_REQUIRED_FIELD_CATEGORY,
-            columnName: 'assortmentId',
-            propertySlug: 'assortmentId',
-            propertyType: 'string',
-            message: `"assortmentId" cannot be empty for assortment rows. ${emptyIdRows.length} row(s) have an empty value.`,
-            affectedRows: emptyIdRows,
-        });
-    }
-    if (emptyIdentRows.length > 0) {
-        issues.push({
-            severity: types_2.PreValidationSeverity.ERROR,
-            category: MISSING_REQUIRED_FIELD_CATEGORY,
-            columnName: 'assortmentIdentifier',
-            propertySlug: 'assortmentIdentifier',
-            propertyType: 'string',
-            message: `"assortmentIdentifier" cannot be empty for assortment rows. ${emptyIdentRows.length} row(s) have an empty value.`,
-            affectedRows: emptyIdentRows,
-        });
-    }
-    return issues;
-}
-async function validateAndResolveAssortmentIdentifiers(rows, config, client) {
-    const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
-    if (!isAssortmentLoad)
-        return [];
-    const hasAssortmentIdentifier = rows.some((row) => row.assortmentIdentifier);
-    if (hasAssortmentIdentifier) {
-        return resolveAssortmentIdentifiers(rows, client);
-    }
-    return validateAssortmentIds(rows, client);
-}
-async function resolveAssortmentIdentifiers(rows, client) {
-    const issues = [];
-    const cache = {};
-    const uniqueIdentifiers = new Set();
-    for (const row of rows) {
-        if (row.assortmentIdentifier)
-            uniqueIdentifiers.add(row.assortmentIdentifier);
-    }
-    for (const identifier of uniqueIdentifiers) {
-        try {
-            const assortments = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
-                entityName: 'assortment',
-                criteria: { identifier },
-                skipHydrateRelationships: true,
-            });
-            if (!assortments?.length) {
-                cache[identifier] = null;
-                const affectedRows = [];
-                rows.forEach((row, index) => {
-                    if (row.assortmentIdentifier === identifier) {
-                        affectedRows.push({ row: index + 2, value: identifier });
-                    }
-                });
-                issues.push({
-                    severity: types_2.PreValidationSeverity.ERROR,
-                    category: REFERENCE_NOT_FOUND_CATEGORY,
-                    columnName: 'assortmentIdentifier',
-                    propertySlug: 'assortmentIdentifier',
-                    propertyType: 'string',
-                    message: `Assortment with identifier "${identifier}" not found. Verify the identifier is correct and the assortment exists.`,
-                    affectedRows,
-                });
-            }
-            else {
-                const assortment = assortments[0];
-                cache[identifier] = { id: assortment.id, name: assortment.name || assortment.id };
-            }
-        }
-        catch (e) {
-            issues.push({
-                severity: types_2.PreValidationSeverity.ERROR,
-                category: REFERENCE_NOT_FOUND_CATEGORY,
-                columnName: 'assortmentIdentifier',
-                propertySlug: 'assortmentIdentifier',
-                propertyType: 'string',
-                message: `Failed to resolve assortment identifier "${identifier}": ${e.message}`,
-                affectedRows: [],
-            });
-        }
-    }
-    if (issues.length === 0) {
-        for (const row of rows) {
-            if (row.assortmentIdentifier) {
-                const assortment = cache[row.assortmentIdentifier];
-                row.assortmentId = assortment.id;
-                row.assortmentName = assortment.name;
-                delete row.assortmentIdentifier;
-            }
-        }
-    }
-    return issues;
-}
-async function validateAssortmentIds(rows, client) {
-    const issues = [];
-    const nameCache = {};
-    const uniqueIds = new Set();
-    for (const row of rows) {
-        if (row.assortmentId)
-            uniqueIds.add(row.assortmentId);
-    }
-    if (uniqueIds.size === 0)
-        return [];
-    for (const assortmentId of uniqueIds) {
-        try {
-            const assortment = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
-                entityName: 'assortment',
-                id: assortmentId,
-                skipHydrateRelationships: true,
-            });
-            if (assortment) {
-                nameCache[assortmentId] = assortment.name || assortmentId;
-            }
-        }
-        catch (e) {
-            const affectedRows = [];
-            rows.forEach((row, index) => {
-                if (row.assortmentId === assortmentId) {
-                    affectedRows.push({ row: index + 2, value: assortmentId });
-                }
-            });
-            const parsedDetails = typeof e?.details === 'string' ? JSON.parse(e.details).statusCode : e?.details?.statusCode;
-            const message = parsedDetails === 404
-                ? `Assortment "${assortmentId}" not found. Verify the assortment ID is correct and the assortment exists.`
-                : `Failed to validate assortment "${assortmentId}": ${e.message}`;
-            issues.push({
-                severity: types_2.PreValidationSeverity.ERROR,
-                category: REFERENCE_NOT_FOUND_CATEGORY,
-                columnName: 'assortmentId',
-                propertySlug: 'assortmentId',
-                propertyType: 'string',
-                message,
-                affectedRows,
-            });
-        }
-    }
-    if (issues.length === 0) {
-        for (const row of rows) {
-            if (row.assortmentId && nameCache[row.assortmentId]) {
-                row.assortmentName = nameCache[row.assortmentId];
-            }
-        }
-    }
-    return issues;
-}
 function validatePartialAssortmentConfig(rows, config) {
     const isAssortmentLoad = config.loadType.some((lt) => lt === types_2.LoadType.ASSORTMENT);
     if (!isAssortmentLoad || !config.partialAssortmentUpdate)
@@ -1130,6 +776,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;