@contrail/cli 3.5.1-alpha.68d57e0 → 3.5.1-alpha.9da7ac5

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

@@ -2,33 +2,15 @@
 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 === '';
 }
@@ -44,15 +26,24 @@ 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);
@@ -63,12 +54,6 @@ 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);
@@ -158,7 +143,7 @@ function runProcessorValidation(rows, config) {
         for (const colIssue of error.columnIssues ?? []) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
-                category: issueTypeToCategory(colIssue.issueType),
+                category: CONFIG_CATEGORY,
                 columnName: colIssue.columnName,
                 propertySlug: colIssue.columnName,
                 propertyType: '',
@@ -171,7 +156,7 @@ function runProcessorValidation(rows, config) {
         for (const colIssue of warning.columnIssues ?? []) {
             issues.push({
                 severity: types_2.PreValidationSeverity.WARNING,
-                category: issueTypeToCategory(colIssue.issueType),
+                category: CONFIG_CATEGORY,
                 columnName: colIssue.columnName,
                 propertySlug: colIssue.columnName,
                 propertyType: '',
@@ -182,89 +167,48 @@ 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;
-            const property = propertyForColumn(key);
-            if (!property)
+            if (!optionSetUsingTypePropertiesBySlug[key])
                 continue;
             if (!affectedRowsByColumn[key])
                 affectedRowsByColumn[key] = [];
             affectedRowsByColumn[key].push({ row: rowNumber, value: String(value) });
-            propertyByColumn[key] = property;
         }
     });
-    for (const [columnName, property] of Object.entries(propertyByColumn)) {
+    for (const [slug, property] of Object.entries(optionSetUsingTypePropertiesBySlug)) {
+        if (!affectedRowsByColumn[slug])
+            continue;
         if (!property.typePropertyOptionSetId) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
                 category: types_2.PreValidationCategory.OPTION_SET,
-                columnName,
+                columnName: slug,
                 propertySlug: property.slug,
                 propertyType: property.propertyType,
-                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],
+                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],
             });
-            skipColumns.add(columnName);
+            skipColumns.add(slug);
         }
         else if (!property.options || property.options.length === 0) {
             issues.push({
                 severity: types_2.PreValidationSeverity.ERROR,
                 category: types_2.PreValidationCategory.OPTION_SET,
-                columnName,
+                columnName: slug,
                 propertySlug: property.slug,
                 propertyType: property.propertyType,
-                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],
+                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],
             });
-            skipColumns.add(columnName);
+            skipColumns.add(slug);
         }
     }
     const issuesByColumn = {};
@@ -272,7 +216,7 @@ function validateOptionSets(rows, typePropertyMaps) {
         for (const [key, value] of Object.entries(row)) {
             if (isEmpty(value))
                 continue;
-            const property = propertyForColumn(key);
+            const property = optionSetUsingTypePropertiesBySlug[key];
             if (!property)
                 continue;
             if (skipColumns.has(key))
@@ -654,6 +598,211 @@ 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));
@@ -678,6 +827,211 @@ 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)
@@ -776,107 +1130,6 @@ 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;