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

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/identifier-resolver.d.ts

@@ -0,0 +1,5 @@
+import { EntitiesClient, LoaderConfig, PreValidationIssue } from './types';
+export declare function isProjectItemAndAssortmentLoad(config: LoaderConfig): boolean;
+export declare function resolveIdentifiers(rows: Record<string, any>[], config: LoaderConfig, client?: EntitiesClient): Promise<{
+    issues: PreValidationIssue[];
+}>;

package/node_modules/@contrail/loader/lib/pipeline/identifier-resolver.js

@@ -0,0 +1,562 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIdentifiers = exports.isProjectItemAndAssortmentLoad = void 0;
+const entities_helper_1 = require("../entities-v2/entities-helper");
+const types_1 = require("./types");
+const CONFIG_CATEGORY = types_1.PreValidationCategory.CONFIG;
+const MISSING_REQUIRED_FIELD_CATEGORY = types_1.PreValidationCategory.MISSING_REQUIRED_FIELD;
+const REFERENCE_NOT_FOUND_CATEGORY = types_1.PreValidationCategory.REFERENCE_DATA_NOT_FOUND;
+function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+function forEachRow(rows, callback) {
+    rows.forEach((row, index) => callback(row, index + 2));
+}
+function isProjectItemAndAssortmentLoad(config) {
+    const types = new Set(config.loadType);
+    return types.has(types_1.LoadType.PROJECT_ITEM) && types.has(types_1.LoadType.ASSORTMENT);
+}
+exports.isProjectItemAndAssortmentLoad = isProjectItemAndAssortmentLoad;
+async function resolveIdentifiers(rows, config, client) {
+    const issues = [];
+    if (!rows?.length)
+        return { issues };
+    const hasProjectSource = rows.some((row) => row.workspaceIdentifier !== undefined || row.projectId !== undefined);
+    const useComboMode = isProjectItemAndAssortmentLoad(config) && !hasProjectSource;
+    const projectItemColumnIssues = useComboMode ? [] : validateProjectItemColumns(rows, config);
+    issues.push(...projectItemColumnIssues);
+    if (!useComboMode && client && projectItemColumnIssues.length === 0) {
+        issues.push(...(await validateAndResolveProjectIdentifiers(rows, config, client)));
+    }
+    const assortmentColumnIssues = validateAssortmentColumns(rows, config);
+    issues.push(...assortmentColumnIssues);
+    if (client && assortmentColumnIssues.length === 0) {
+        issues.push(...(await validateAndResolveAssortmentIdentifiers(rows, config, client)));
+    }
+    if (useComboMode && client && assortmentColumnIssues.length === 0) {
+        issues.push(...(await stampProjectIdsFromAssortmentWorkspaces(rows, client)));
+    }
+    return { issues };
+}
+exports.resolveIdentifiers = resolveIdentifiers;
+async function validateAndResolveProjectIdentifiers(rows, config, client) {
+    const isProjectItemLoad = config.loadType.some((lt) => lt === types_1.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_1.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_1.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_1.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_1.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_1.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_1.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_1.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_1.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 validateAssortmentColumns(rows, config) {
+    const isAssortmentLoad = config.loadType.some((lt) => lt === types_1.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_1.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_1.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_1.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_1.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_1.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_1.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,
+                    workspaceId: assortment.workspaceId,
+                };
+            }
+        }
+        catch (e) {
+            issues.push({
+                severity: types_1.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;
+                if (assortment.workspaceId) {
+                    row.assortmentWorkspaceId = assortment.workspaceId;
+                }
+                delete row.assortmentIdentifier;
+            }
+        }
+    }
+    return issues;
+}
+async function validateAssortmentIds(rows, client) {
+    const issues = [];
+    const nameCache = {};
+    const workspaceCache = {};
+    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;
+                workspaceCache[assortmentId] = assortment.workspaceId;
+            }
+        }
+        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_1.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) {
+                if (nameCache[row.assortmentId]) {
+                    row.assortmentName = nameCache[row.assortmentId];
+                }
+                if (workspaceCache[row.assortmentId]) {
+                    row.assortmentWorkspaceId = workspaceCache[row.assortmentId];
+                }
+            }
+        }
+    }
+    return issues;
+}
+async function stampProjectIdsFromAssortmentWorkspaces(rows, client) {
+    const issues = [];
+    const assortmentToWorkspace = new Map();
+    const assortmentsMissingWorkspace = new Set();
+    for (const row of rows) {
+        const assortmentId = row.assortmentId;
+        if (!assortmentId)
+            continue;
+        const workspaceId = row.assortmentWorkspaceId;
+        if (!workspaceId) {
+            assortmentsMissingWorkspace.add(assortmentId);
+        }
+        else {
+            assortmentToWorkspace.set(assortmentId, workspaceId);
+        }
+    }
+    for (const assortmentId of assortmentsMissingWorkspace) {
+        const affectedRows = [];
+        rows.forEach((row, index) => {
+            if (row.assortmentId === assortmentId && !row.assortmentWorkspaceId) {
+                affectedRows.push({ row: index + 2, value: assortmentId });
+            }
+        });
+        issues.push({
+            severity: types_1.PreValidationSeverity.ERROR,
+            category: REFERENCE_NOT_FOUND_CATEGORY,
+            columnName: 'assortmentId',
+            propertySlug: 'assortmentId',
+            propertyType: 'string',
+            message: `Assortment "${assortmentId}" has no workspaceId. Cannot derive a project for project-item rows from this assortment.`,
+            affectedRows,
+        });
+    }
+    if (issues.length > 0) {
+        return issues;
+    }
+    const projectByWorkspaceId = {};
+    const uniqueWorkspaceIds = new Set(assortmentToWorkspace.values());
+    for (const workspaceId of uniqueWorkspaceIds) {
+        try {
+            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) {
+                const affectedAssortmentIds = [...assortmentToWorkspace.entries()]
+                    .filter(([, wsId]) => wsId === workspaceId)
+                    .map(([aId]) => aId);
+                const affectedRows = [];
+                rows.forEach((row, index) => {
+                    if (row.assortmentId && affectedAssortmentIds.includes(row.assortmentId)) {
+                        affectedRows.push({ row: index + 2, value: row.assortmentId });
+                    }
+                });
+                issues.push({
+                    severity: types_1.PreValidationSeverity.ERROR,
+                    category: REFERENCE_NOT_FOUND_CATEGORY,
+                    columnName: 'assortmentId',
+                    propertySlug: 'assortmentId',
+                    propertyType: 'string',
+                    message: `Assortment workspace "${workspaceId}" has no associated project. Cannot derive a project for project-item rows. Verify the assortment lives in a PROJECT-type workspace.`,
+                    affectedRows,
+                });
+                continue;
+            }
+            projectByWorkspaceId[workspaceId] = { id: project.id, name: project.name || project.id };
+        }
+        catch (e) {
+            issues.push({
+                severity: types_1.PreValidationSeverity.ERROR,
+                category: REFERENCE_NOT_FOUND_CATEGORY,
+                columnName: 'assortmentId',
+                propertySlug: 'assortmentId',
+                propertyType: 'string',
+                message: `Failed to resolve workspace "${workspaceId}" for assortment-derived project: ${e.message}`,
+                affectedRows: [],
+            });
+        }
+    }
+    if (issues.length > 0) {
+        return issues;
+    }
+    for (const row of rows) {
+        const workspaceId = row.assortmentWorkspaceId;
+        if (!workspaceId)
+            continue;
+        const project = projectByWorkspaceId[workspaceId];
+        if (!project)
+            continue;
+        row.projectId = project.id;
+        row.projectName = project.name;
+    }
+    return issues;
+}

package/node_modules/@contrail/loader/lib/pipeline/identifier-resolver.spec.d.ts

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