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

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

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

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

@@ -28,21 +28,18 @@ 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 = {
@@ -170,7 +167,7 @@ describe('Item Processor', () => {
                     },
                 ]);
             });
-            it('should throw error if typepath is not present in csv header', () => {
+            it('should not throw error if typepath is not present in csv header and config file', () => {
                 const data = [
                     {
                         name: 'item1',
@@ -196,42 +193,6 @@ 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([]);
             });
         });
@@ -639,17 +600,14 @@ 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/item-execute-helpers.js

@@ -11,97 +11,23 @@ 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 ??
-        err?.error?.response?.validationErrors;
+    const validationErrors = err?.error?.response?.validationSummary?.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) {
-                    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}`);
+                    messages.push(`${field}: ${e.message || JSON.stringify(e)}`);
                 }
             }
         }
         if (messages.length > 0)
-            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 messages.join('; ');
     }
     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,88 +2,6 @@
 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,6 +21,11 @@ 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 not duplicate object-reference resolution warnings (now surfaced by validate)', async () => {
+    it('should collect warnings from object reference resolution', 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).not.toContain('ObjectReference not found for vendor with value acme');
+        expect(result.warnings).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. 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.',
+                            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.',
                         }],
                 }],
             skippedRows: [],

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

@@ -2,7 +2,6 @@
 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");
@@ -128,22 +127,6 @@ 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',
@@ -157,7 +140,6 @@ 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 9 transform steps (including type fetch, identifier resolution, and column analysis)', async () => {
+    it('should run all 8 transform steps (including type fetch 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(9);
+        expect(result.stepResults).toHaveLength(8);
         expect(result.stepResults.map((s) => s.stepName)).toEqual([
             'Evaluate Conditional Columns',
             'Remove Unwanted Properties',
@@ -75,7 +75,6 @@ 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,9 +41,7 @@ export declare enum PreValidationCategory {
     SELF_REFERENCE = "SELF_REFERENCE",
     UNMAPPED_COLUMN = "UNMAPPED_COLUMN",
     UNMAPPED_TYPE_PROPERTY = "UNMAPPED_TYPE_PROPERTY",
-    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION",
-    INVALID_DATA = "INVALID_DATA",
-    DUPLICATE_FEDERATED_ID = "DUPLICATE_FEDERATED_ID"
+    FORMAT_NUMBER_PRECISION = "FORMAT_NUMBER_PRECISION"
 }
 export declare enum PreValidationSeverity {
     ERROR = "error",
@@ -135,9 +133,8 @@ export interface TransformResult {
     generalErrors: GeneralIssueDetails[];
     generalWarnings: GeneralIssueDetails[];
     stepResults: PreprocessingStepSummary[];
-    identifierIssues?: PreValidationIssue[];
 }
-export declare type ColumnAnalysisResult = Pick<TransformResult, 'columns' | 'unmappedTypeProperties' | 'typePropertyMaps' | 'typesByPath' | 'identifierIssues'> & Partial<Pick<TransformResult, 'warnings' | 'errors'>>;
+export declare type ColumnAnalysisResult = Pick<TransformResult, 'columns' | 'unmappedTypeProperties' | 'typePropertyMaps' | 'typesByPath'>;
 export interface ColumnMetaData {
     csvHeader: string;
     matchedSlug?: string;

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

@@ -49,8 +49,6 @@ 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) {