@contrail/cli 3.5.0-alpha.dd20a19 → 3.5.1-alpha.68d57e0

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const identifier_resolver_1 = require("./identifier-resolver");
+const types_1 = require("./types");
+describe('resolveIdentifiers', () => {
+    describe('validateAssortmentColumns', () => {
+        it('skips for non-ASSORTMENT loads', async () => {
+            const config = { loadType: [types_1.LoadType.ITEM] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const assortmentIssue = issues.find((i) => i.columnName?.includes('assortmentId'));
+            expect(assortmentIssue).toBeUndefined();
+        });
+        it('errors when no rows have assortmentId or assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A' }];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const issue = issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(issue).toBeDefined();
+        });
+        it('errors when rows have both assortmentId and assortmentIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'id-1', assortmentIdentifier: 'ident-1' }];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const issue = issues.find((i) => i.message.includes('both "assortmentId" and "assortmentIdentifier"'));
+            expect(issue).toBeDefined();
+        });
+        it('errors when assortmentId values are empty', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: '' }];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const issue = issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(issue).toBeDefined();
+        });
+        it('does not error when rows have valid assortmentId (no client)', async () => {
+            const config = { loadType: [types_1.LoadType.ASSORTMENT] };
+            const rows = [{ itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' }];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const columnIssue = issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(columnIssue).toBeUndefined();
+        });
+        it('does not error on rows missing assortmentId when derived from conditional columns with conditions', async () => {
+            const config = {
+                loadType: [types_1.LoadType.ASSORTMENT],
+                conditionalColumns: [
+                    { toProperty: 'assortmentId', conditions: [{ conditional: "{gender} === 'mens'", value: 'assort-1' }] },
+                ],
+            };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B' },
+            ];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const emptyIssue = issues.find((i) => i.message.includes('"assortmentId" cannot be empty'));
+            expect(emptyIssue).toBeUndefined();
+        });
+    });
+    describe('combo mode: PROJECT_ITEM + ASSORTMENT', () => {
+        const buildClient = (handler) => ({
+            get: jest.fn(async (params) => handler(params)),
+            create: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn(),
+            batchDelete: jest.fn(),
+            getAllReferences: jest.fn(),
+        });
+        it('stamps projectId on rows from the assortment workspace when assortmentId is per-row', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
+                { itemFamilyFederatedId: 'fam-2', name: 'B', assortmentId: 'assort-1' },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'assortment' && params.id === 'assort-1') {
+                    return { id: 'assort-1', name: 'Assort 1', workspaceId: 'ws-1' };
+                }
+                if (params.entityName === 'workspace' && params.id === 'ws-1') {
+                    return { id: 'ws-1', project: { id: 'proj-1', name: 'Project 1' } };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            expect(issues).toHaveLength(0);
+            expect(rows[0].projectId).toBe('proj-1');
+            expect(rows[1].projectId).toBe('proj-1');
+            expect(rows[0].projectName).toBe('Project 1');
+            expect(rows[0].assortmentWorkspaceId).toBe('ws-1');
+        });
+        it('resolves assortmentIdentifier → assortment → workspace → project', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentIdentifier: 'NORD-2026' },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'assortment' && params.criteria?.identifier === 'NORD-2026') {
+                    return [{ id: 'assort-9', name: 'Nord 2026', workspaceId: 'ws-9' }];
+                }
+                if (params.entityName === 'workspace' && params.id === 'ws-9') {
+                    return { id: 'ws-9', project: { id: 'proj-9', name: 'Nord Project' } };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            expect(issues).toHaveLength(0);
+            expect(rows[0].assortmentId).toBe('assort-9');
+            expect(rows[0].projectId).toBe('proj-9');
+            expect(rows[0].projectName).toBe('Nord Project');
+            expect(rows[0].assortmentIdentifier).toBeUndefined();
+        });
+        it('reports assortment-only error when a row is missing assortmentId (no project/workspace mention)', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A' },
+            ];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const projectIssue = issues.find((i) => i.message.includes('workspaceIdentifier') || i.message.includes('projectId'));
+            expect(projectIssue).toBeUndefined();
+            const assortmentIssue = issues.find((i) => i.message.includes('ASSORTMENT loads require'));
+            expect(assortmentIssue).toBeDefined();
+        });
+        it('errors when the assortment has no workspaceId (assortment-scoped error)', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-x' },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'assortment' && params.id === 'assort-x') {
+                    return { id: 'assort-x', name: 'X' };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            const issue = issues.find((i) => i.message.includes('has no workspaceId'));
+            expect(issue).toBeDefined();
+            expect(issue?.columnName).toBe('assortmentId');
+        });
+        it('errors when the assortment workspace has no project relation', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-y' },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'assortment' && params.id === 'assort-y') {
+                    return { id: 'assort-y', name: 'Y', workspaceId: 'ws-y' };
+                }
+                if (params.entityName === 'workspace' && params.id === 'ws-y') {
+                    return { id: 'ws-y' };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            const issue = issues.find((i) => i.message.includes('has no associated project'));
+            expect(issue).toBeDefined();
+            expect(issue?.columnName).toBe('assortmentId');
+            expect(rows[0].projectId).toBeUndefined();
+        });
+        it('does not require workspaceIdentifier or projectId on rows in combo mode', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A', assortmentId: 'assort-1' },
+            ];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const projectItemIssue = issues.find((i) => i.message.includes('PROJECT_ITEM loads require'));
+            expect(projectItemIssue).toBeUndefined();
+        });
+        it('does NOT trigger combo mode when rows already have a workspaceIdentifier', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                {
+                    itemFamilyFederatedId: 'fam-1',
+                    name: 'A',
+                    assortmentId: 'assort-1',
+                    workspaceIdentifier: 'project_one',
+                },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'workspace' && params.criteria?.identifier === 'project_one') {
+                    return [{ id: 'ws-1' }];
+                }
+                if (params.entityName === 'workspace' && params.id === 'ws-1') {
+                    return { id: 'ws-1', project: { id: 'proj-1', name: 'Project 1' } };
+                }
+                if (params.entityName === 'assortment' && params.id === 'assort-1') {
+                    return { id: 'assort-1', name: 'A1', workspaceId: 'totally-bogus-id' };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            expect(issues).toHaveLength(0);
+            expect(rows[0].projectId).toBe('proj-1');
+            expect(rows[0].workspaceIdentifier).toBeUndefined();
+        });
+        it('does NOT trigger combo mode when rows already have a projectId', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT] };
+            const rows = [
+                {
+                    itemFamilyFederatedId: 'fam-1',
+                    name: 'A',
+                    assortmentId: 'assort-1',
+                    projectId: 'proj-explicit',
+                },
+            ];
+            const client = buildClient((params) => {
+                if (params.entityName === 'project' && params.id === 'proj-explicit') {
+                    return { id: 'proj-explicit', name: 'Explicit Project' };
+                }
+                if (params.entityName === 'assortment' && params.id === 'assort-1') {
+                    return { id: 'assort-1', name: 'A1', workspaceId: 'totally-bogus-id' };
+                }
+                return undefined;
+            });
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config, client);
+            expect(issues).toHaveLength(0);
+            expect(rows[0].projectId).toBe('proj-explicit');
+            expect(rows[0].projectName).toBe('Explicit Project');
+        });
+    });
+    describe('PROJECT_ITEM-only loads (no assortment)', () => {
+        it('still requires workspaceIdentifier or projectId on rows', async () => {
+            const config = { loadType: [types_1.LoadType.PROJECT_ITEM] };
+            const rows = [
+                { itemFamilyFederatedId: 'fam-1', name: 'A' },
+            ];
+            const { issues } = await (0, identifier_resolver_1.resolveIdentifiers)(rows, config);
+            const issue = issues.find((i) => i.message.includes('PROJECT_ITEM loads require'));
+            expect(issue).toBeDefined();
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/pipeline/item-execute-helpers.js

@@ -11,23 +11,97 @@ const pLimit = require('p-limit');
 const DEFAULT_BATCH_SIZE = 50;
 const DEFAULT_CONCURRENCY = 20;
 const DEFAULT_MAX_RETRIES = 3;
+function findUniquenessPayload(node, depth = 0) {
+    if (!node || depth > 6)
+        return undefined;
+    if (Array.isArray(node?.failedEntities))
+        return node;
+    if (typeof node === 'string') {
+        const trimmed = node.trim();
+        if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+            try {
+                return findUniquenessPayload(JSON.parse(trimmed), depth + 1);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            const found = findUniquenessPayload(child, depth + 1);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (typeof node === 'object') {
+        for (const key of ['error', 'response', 'message', 'data', 'body']) {
+            if (node[key] !== undefined) {
+                const found = findUniquenessPayload(node[key], depth + 1);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return undefined;
+}
 function extractApiErrorMessage(err) {
-    const validationErrors = err?.error?.response?.validationSummary?.validationErrors;
+    const validationErrors = err?.error?.response?.validationSummary?.validationErrors ??
+        err?.error?.response?.validationErrors;
     if (validationErrors && typeof validationErrors === 'object') {
         const messages = [];
         for (const [field, errors] of Object.entries(validationErrors)) {
             if (Array.isArray(errors)) {
                 for (const e of errors) {
-                    messages.push(`${field}: ${e.message || JSON.stringify(e)}`);
+                    const isObj = typeof e === 'object' && e !== null;
+                    const valuePart = isObj && 'value' in e ? ` (value=${JSON.stringify(e.value)})` : '';
+                    const msg = isObj ? e.message || JSON.stringify(e) : String(e);
+                    messages.push(`${field}${valuePart}: ${msg}`);
                 }
             }
         }
         if (messages.length > 0)
-            return messages.join('; ');
+            return `Validation failed — ${messages.join('; ')}`;
+    }
+    const uniquePayload = findUniquenessPayload(err);
+    if (uniquePayload?.failedEntities?.length) {
+        const parts = uniquePayload.failedEntities.map((f) => {
+            const label = f.propertyLabel ?? f.propertyName ?? '<unknown>';
+            const value = f.propertyValue ?? '';
+            return `${label}=${JSON.stringify(value)}`;
+        });
+        const offending = uniquePayload.propertiesMustBeUnique?.length
+            ? ` (one of ${uniquePayload.propertiesMustBeUnique.join(', ')} is already taken or duplicated in batch)`
+            : '';
+        return `Uniqueness conflict — attempted: ${parts.join(', ')}${offending}`;
+    }
+    try {
+        console.warn('[extractApiErrorMessage] unknown error shape:', summarizeErrorShape(err));
+    }
+    catch {
     }
     return err?.error?.message ?? err?.error?.response?.message ?? String(err?.error);
 }
 exports.extractApiErrorMessage = extractApiErrorMessage;
+function summarizeErrorShape(err) {
+    const truncate = (s, max = 200) => {
+        if (s === undefined || s === null)
+            return undefined;
+        const str = typeof s === 'string' ? s : JSON.stringify(s);
+        return str.length > max ? `${str.slice(0, max)}…` : str;
+    };
+    const errInner = err?.error;
+    return {
+        topLevelKeys: err && typeof err === 'object' ? Object.keys(err) : undefined,
+        errorKeys: errInner && typeof errInner === 'object' ? Object.keys(errInner) : undefined,
+        status: errInner?.status ?? errInner?.response?.status,
+        name: errInner?.name,
+        message: truncate(errInner?.message),
+        responseMessage: truncate(errInner?.response?.message),
+    };
+}
 function extractFailureId(err) {
     return (err?.data?.federatedId ??
         err?.entity?.federatedId ??

package/node_modules/@contrail/loader/lib/pipeline/item-execute-helpers.spec.js

@@ -2,6 +2,88 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@contrail/types");
 const item_execute_helpers_1 = require("./item-execute-helpers");
+describe('extractApiErrorMessage', () => {
+    it('formats current-shape validation errors (response.validationErrors)', () => {
+        const err = {
+            entity: { federatedId: 'TB0A41MG' },
+            error: {
+                response: {
+                    validationErrorCount: 1,
+                    validationErrors: {
+                        vfAdvConceptsTech: [
+                            { value: 'GRIPMAX SLIP RESISTANT', message: 'The value provided is not a valid option for this property.' },
+                        ],
+                    },
+                },
+                status: 400,
+                message: 'Bad Request Exception',
+                name: 'BadRequestException',
+            },
+        };
+        const msg = (0, item_execute_helpers_1.extractApiErrorMessage)(err);
+        expect(msg).toContain('Validation failed');
+        expect(msg).toContain('vfAdvConceptsTech');
+        expect(msg).toContain('GRIPMAX SLIP RESISTANT');
+        expect(msg).toContain('The value provided is not a valid option');
+    });
+    it('formats older-shape validation errors (validationSummary.validationErrors)', () => {
+        const err = {
+            error: {
+                response: {
+                    validationSummary: {
+                        validationErrors: {
+                            name: [{ message: 'Required.' }],
+                        },
+                    },
+                },
+            },
+        };
+        expect((0, item_execute_helpers_1.extractApiErrorMessage)(err)).toBe('Validation failed — name: Required.');
+    });
+    it('does not throw when a validation-error array contains primitive entries', () => {
+        const err = {
+            error: {
+                response: {
+                    validationErrors: { someField: ['oops'] },
+                },
+            },
+        };
+        expect(() => (0, item_execute_helpers_1.extractApiErrorMessage)(err)).not.toThrow();
+        expect((0, item_execute_helpers_1.extractApiErrorMessage)(err)).toContain('someField');
+    });
+    describe('uniqueness conflict payloads', () => {
+        const sample = [
+            {
+                failedEntities: [
+                    { propertyName: 'federatedId', propertyLabel: 'Federated Id', propertyValue: '0A294C', entityReference: 'item:abc' },
+                    { propertyName: 'vfStyleNumber', propertyLabel: 'Style Number', propertyValue: '0A294C', entityReference: 'item:abc' },
+                ],
+                propertiesMustBeUnique: ['federatedId', 'vfStyleNumber'],
+            },
+        ];
+        it('finds the payload nested under err.error.response.message (object form)', () => {
+            const msg = (0, item_execute_helpers_1.extractApiErrorMessage)({ error: { response: { message: sample } } });
+            expect(msg).toContain('Uniqueness conflict');
+            expect(msg).toContain('Style Number="0A294C"');
+            expect(msg).toContain('vfStyleNumber');
+        });
+        it('parses the payload when err.error.response.message is a JSON-stringified array', () => {
+            const msg = (0, item_execute_helpers_1.extractApiErrorMessage)({ error: { response: { message: JSON.stringify(sample) } } });
+            expect(msg).toContain('Uniqueness conflict');
+            expect(msg).toContain('Federated Id="0A294C"');
+        });
+        it('finds the payload at the top level', () => {
+            expect((0, item_execute_helpers_1.extractApiErrorMessage)(sample[0])).toContain('Uniqueness conflict');
+        });
+        it('falls back to a redacted summary for unknown shapes', () => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => { });
+            const result = (0, item_execute_helpers_1.extractApiErrorMessage)({ error: { something: 'else', message: 'mystery' } });
+            expect(result).toBe('mystery');
+            expect(warn).toHaveBeenCalledWith('[extractApiErrorMessage] unknown error shape:', expect.objectContaining({ message: 'mystery' }));
+            warn.mockRestore();
+        });
+    });
+});
 describe('splitIntoFamiliesAndOptions', () => {
     const makeTypesByPath = (typeProperties) => ({
         item: {

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

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

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

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

package/node_modules/@contrail/loader/lib/pipeline/project-item-execute-helpers.js

@@ -232,7 +232,7 @@ async function executeProjectItemEntities(client, entitySet, config, options) {
                     failures: [{
                             federatedId: 'N/A',
                             operation: 'create',
-                            error: 'Could not resolve a target Project\'s ID from the data or config provided. Include or map a workspaceIdentifier column if loading only ProjectItems, or a projectId column with the project\'s ID directly.',
+                            error: 'Could not resolve a target Project\'s ID. For combined PROJECT_ITEM + ASSORTMENT loads, ensure each row has an assortmentId so the project can be derived from the assortment\'s workspace. Otherwise, include or map a workspaceIdentifier column, or a projectId column with the project\'s ID directly.',
                         }],
                 }],
             skippedRows: [],

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transform = void 0;
 const types_1 = require("./types");
+const identifier_resolver_1 = require("./identifier-resolver");
 const data_transformer_functions_1 = require("../common/data-transformer-functions");
 const type_helper_1 = require("../common/type-helper");
 const types_2 = require("./types");
@@ -127,6 +128,22 @@ async function transform(client, rows, config) {
         typeAware.generalErrors.push({ message: errorMessage, issueType: types_1.IssueType.SYSTEM_ERROR });
     }
     const { columns, unmappedTypeProperties } = analyzeColumns(processedData, typePropertyMaps, config);
+    let identifierIssues = [];
+    try {
+        const resolved = await (0, identifier_resolver_1.resolveIdentifiers)(processedData, config, client);
+        identifierIssues = resolved.issues;
+    }
+    catch (e) {
+        const errorMessage = `Error in transform step "Resolve Identifiers": ${e.message}`;
+        console.error(errorMessage);
+        typeAware.generalErrors.push({ message: errorMessage, issueType: types_1.IssueType.SYSTEM_ERROR });
+    }
+    typeAware.stepResults.push({
+        stepName: 'Resolve Identifiers',
+        rowCountAfter: processedData.length,
+        errorCount: identifierIssues.filter((i) => i.severity === 'error').length,
+        warningCount: identifierIssues.filter((i) => i.severity === 'warning').length,
+    });
     const merged = mergeResults(structural, typeAware);
     merged.stepResults.push({
         stepName: 'Analyze Columns',
@@ -140,6 +157,7 @@ async function transform(client, rows, config) {
         typesByPath,
         columns,
         unmappedTypeProperties,
+        identifierIssues,
         ...collectIssues(merged),
     };
 }

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

@@ -63,10 +63,10 @@ describe('transform', () => {
         expect(result.stepResults).toEqual([]);
         expect(result.errors).toEqual([]);
     });
-    it('should run all 8 transform steps (including type fetch and column analysis)', async () => {
+    it('should run all 9 transform steps (including type fetch, identifier resolution, and column analysis)', async () => {
         const rows = [{ sku: 'ABC-123', name: 'Test', active: 'true' }];
         const result = await (0, transform_1.transform)(mockClient, rows, baseConfig);
-        expect(result.stepResults).toHaveLength(8);
+        expect(result.stepResults).toHaveLength(9);
         expect(result.stepResults.map((s) => s.stepName)).toEqual([
             'Evaluate Conditional Columns',
             'Remove Unwanted Properties',
@@ -75,6 +75,7 @@ describe('transform', () => {
             'Fetch Type Definitions',
             'Transform Data Based on Types',
             'Coerce Values by Type',
+            'Resolve Identifiers',
             'Analyze Columns',
         ]);
     });

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

@@ -41,7 +41,9 @@ export declare enum PreValidationCategory {
     SELF_REFERENCE = "SELF_REFERENCE",
     UNMAPPED_COLUMN = "UNMAPPED_COLUMN",
     UNMAPPED_TYPE_PROPERTY = "UNMAPPED_TYPE_PROPERTY",
-    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION"
+    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION",
+    INVALID_DATA = "INVALID_DATA",
+    DUPLICATE_FEDERATED_ID = "DUPLICATE_FEDERATED_ID"
 }
 export declare enum PreValidationSeverity {
     ERROR = "error",
@@ -133,8 +135,9 @@ export interface TransformResult {
     generalErrors: GeneralIssueDetails[];
     generalWarnings: GeneralIssueDetails[];
     stepResults: PreprocessingStepSummary[];
+    identifierIssues?: PreValidationIssue[];
 }
-export declare type ColumnAnalysisResult = Pick<TransformResult, 'columns' | 'unmappedTypeProperties' | 'typePropertyMaps' | 'typesByPath'>;
+export declare type ColumnAnalysisResult = Pick<TransformResult, 'columns' | 'unmappedTypeProperties' | 'typePropertyMaps' | 'typesByPath' | 'identifierIssues'> & Partial<Pick<TransformResult, 'warnings' | 'errors'>>;
 export interface ColumnMetaData {
     csvHeader: string;
     matchedSlug?: string;

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

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