@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/common/util.d.ts

@@ -0,0 +1,11 @@
+import { ProcessingIssues } from '@contrail/entity-types';
+export declare function getUniqueAndDuplicateEntries(strings: string[]): {
+    uniqueStrings: Array<string>;
+    duplicateStrings: Array<string>;
+};
+export declare function getDuplicateFederatedIds(data: any[], federatedIdField: string): ProcessingIssues[];
+export declare function getConflictingFederatedIdsGroupedByField(data: any[], federatedIdField: string, groupByField: string): string[];
+export declare function getConflictingFieldForFederatedId(data: any[], federatedIdField: string, field: string): {
+    federatedId: string;
+    values: string[];
+}[];

package/node_modules/@contrail/loader/lib/common/util.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConflictingFieldForFederatedId = exports.getConflictingFederatedIdsGroupedByField = exports.getDuplicateFederatedIds = exports.getUniqueAndDuplicateEntries = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const lodash_1 = require("lodash");
+function getUniqueAndDuplicateEntries(strings) {
+    const uniqueStrings = new Set();
+    const duplicateStrings = new Set();
+    for (const string of strings) {
+        if (duplicateStrings.has(string)) {
+            continue;
+        }
+        else if (uniqueStrings.has(string)) {
+            duplicateStrings.add(string);
+            uniqueStrings.delete(string);
+        }
+        else {
+            uniqueStrings.add(string);
+        }
+    }
+    return {
+        uniqueStrings: Array.from(uniqueStrings),
+        duplicateStrings: Array.from(duplicateStrings),
+    };
+}
+exports.getUniqueAndDuplicateEntries = getUniqueAndDuplicateEntries;
+function getDuplicateFederatedIds(data, federatedIdField) {
+    if (!data || !federatedIdField)
+        return [];
+    const errors = [];
+    const federatedIdCounts = {};
+    data.forEach((item, index) => {
+        const federatedId = item[federatedIdField];
+        if (!federatedId)
+            return;
+        if (!federatedIdCounts[federatedId]) {
+            federatedIdCounts[federatedId] = [];
+        }
+        federatedIdCounts[federatedId].push(index + 2);
+    });
+    Object.entries(federatedIdCounts).forEach(([federatedId, indices]) => {
+        if (indices.length > 1) {
+            indices.forEach((rowIndex) => {
+                errors.push({
+                    rowNumber: rowIndex,
+                    columnIssues: [
+                        {
+                            columnName: federatedIdField,
+                            message: `Duplicate federatedId found: ${federatedId}`,
+                            issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                            data: JSON.stringify(data[rowIndex - 2]),
+                        },
+                    ],
+                });
+            });
+        }
+    });
+    return errors;
+}
+exports.getDuplicateFederatedIds = getDuplicateFederatedIds;
+function getConflictingFederatedIdsGroupedByField(data, federatedIdField, groupByField) {
+    if (!data || !federatedIdField || !groupByField)
+        return [];
+    const groupedByField = (0, lodash_1.groupBy)(data, groupByField);
+    const conflictingFedIds = Object.entries(groupedByField)
+        .map(([uniqueNames, rows]) => [uniqueNames, (0, lodash_1.uniq)(rows.map((x) => x[federatedIdField]))])
+        .filter(([uniqueNames, uniqueFedIds]) => uniqueFedIds.length > 1)
+        .map(([uniqueNames, conflictingFedIds]) => conflictingFedIds);
+    return (0, lodash_1.flatten)(conflictingFedIds);
+}
+exports.getConflictingFederatedIdsGroupedByField = getConflictingFederatedIdsGroupedByField;
+function getConflictingFieldForFederatedId(data, federatedIdField, field) {
+    if (!data || !federatedIdField || !field)
+        return [];
+    const groupedByFedId = (0, lodash_1.groupBy)(data, federatedIdField);
+    const conflictingValues = Object.entries(groupedByFedId)
+        .map(([federatedId, rows]) => [federatedId, (0, lodash_1.uniq)(rows.map((x) => x[field]))])
+        .filter(([federatedId, uniqueNames]) => uniqueNames.length > 1)
+        .map(([federatedId, names]) => ({
+        federatedId,
+        values: names,
+    }));
+    return conflictingValues;
+}
+exports.getConflictingFieldForFederatedId = getConflictingFieldForFederatedId;

package/node_modules/@contrail/loader/lib/common/util.spec.d.ts

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

package/node_modules/@contrail/loader/lib/common/util.spec.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_types_1 = require("@contrail/entity-types");
+const util_1 = require("./util");
+describe('getUniqueAndDuplicateEntries', () => {
+    it('should return unique and duplicate strings correctly', () => {
+        const input = ['a', 'b', 'a', 'c', 'd', 'b'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: ['c', 'd'],
+            duplicateStrings: ['a', 'b'],
+        });
+    });
+    it('should return all unique strings when there are no duplicates', () => {
+        const input = ['a', 'b', 'c', 'd'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: ['a', 'b', 'c', 'd'],
+            duplicateStrings: [],
+        });
+    });
+    it('should return all duplicate strings when all elements are the same', () => {
+        const input = ['a', 'a', 'a', 'a'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: [],
+            duplicateStrings: ['a'],
+        });
+    });
+    it('should handle an empty array', () => {
+        const input = [];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: [],
+            duplicateStrings: [],
+        });
+    });
+    it('should handle an array with one element', () => {
+        const input = ['a'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: ['a'],
+            duplicateStrings: [],
+        });
+    });
+    it('should handle an array with two different elements', () => {
+        const input = ['a', 'b'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: ['a', 'b'],
+            duplicateStrings: [],
+        });
+    });
+    it('should handle an array with two same elements', () => {
+        const input = ['a', 'a'];
+        const result = (0, util_1.getUniqueAndDuplicateEntries)(input);
+        expect(result).toEqual({
+            uniqueStrings: [],
+            duplicateStrings: ['a'],
+        });
+    });
+});
+describe('getDuplicateFederatedIds', () => {
+    it('should return duplicate federated IDs', () => {
+        const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color1' }, { name: 'color1' }];
+        const result = (0, util_1.getDuplicateFederatedIds)(data, 'name');
+        console.log(JSON.stringify(result, null, 2));
+        expect(result).toEqual([
+            {
+                rowNumber: 2,
+                columnIssues: [
+                    {
+                        columnName: 'name',
+                        message: 'Duplicate federatedId found: color1',
+                        issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                        data: '{"name":"color1"}',
+                    },
+                ],
+            },
+            {
+                rowNumber: 4,
+                columnIssues: [
+                    {
+                        columnName: 'name',
+                        message: 'Duplicate federatedId found: color1',
+                        issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                        data: '{"name":"color1"}',
+                    },
+                ],
+            },
+            {
+                rowNumber: 5,
+                columnIssues: [
+                    {
+                        columnName: 'name',
+                        message: 'Duplicate federatedId found: color1',
+                        issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                        data: '{"name":"color1"}',
+                    },
+                ],
+            },
+        ]);
+    });
+    it('should handle no duplicate federated IDs', () => {
+        const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color3' }];
+        const result = (0, util_1.getDuplicateFederatedIds)(data, 'name');
+        expect(result).toEqual([]);
+    });
+});

package/node_modules/@contrail/loader/lib/constants.d.ts

@@ -0,0 +1,29 @@
+export declare const COLOR_PROCESSOR_ERRORS: {
+    readonly TYPEPATH_MISSING: "\"typePath\" with value \"color\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"color\" with one of these methods, then try the load again.";
+};
+export declare const COLOR_PROCESSOR_WARNINGS: {
+    readonly HEX_IGNORED_WARNING: "\"Hex\" is ignored when red, green, and blue columns are present";
+};
+export declare const CUSTOM_ENTITY_PROCESSOR_ERRORS: {
+    readonly TYPEPATH_MISSING: "\"typePath\" with value \"custom-entity:<subtypepath>\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"typePath\" mapping with value \"custom-entity:<subtypepath>\" with one of these methods, then try the load again.";
+};
+export declare const ENTITY_PROCESSOR_ERRORS: {
+    readonly CONFIG_EMPTY: "Config file is empty";
+    readonly LOAD_TYPE_REQUIRED: "\"loadType\" is required in the config file";
+    readonly LOAD_TYPE_INVALID: (type: string) => string;
+    readonly FEDERATED_ID_REQUIRED: "\"federatedId\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"federatedId\" mapping with one of these methods, then try the load again.";
+    readonly NAME_REQUIRED: "\"name\" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping \"name\" mapping with one of these methods, then try the load again.";
+    readonly SINGLE_LOAD_TYPE: (entityType: string) => string;
+};
+export declare const ITEM_PROCESSOR_ERRORS: {
+    readonly LOAD_TYPE_INVALID: "\"loadType\" must be either of values [\"ITEM\", \"PROJECT_ITEM\", \"ASSORTMENT\"] in the config file";
+    readonly TYPEPATH_INVALID: "\"typePath\" must be \"item\" or \"item:<subtypepath>\" in the config file";
+    readonly FAMILY_ID_EMPTY: "itemFamilyFederatedId is null or undefined or empty in the CSV file";
+    readonly CONFLICTING_IDS: (ids: any) => string;
+};
+export declare const ITEM_PROCESSOR_WARNINGS: {
+    readonly OPTIONNAME_UNMAPPED: "\"optionName\" is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file.";
+    readonly OPTIONNAME_NOT_FOUND: (optionName: string) => string;
+    readonly OPTION_FEDERATED_ID_UNMAPPED: "\"itemOptionFederatedId\" is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file.";
+    readonly OPTION_FEDERATED_ID_NOT_FOUND: (itemOptionFederatedId: string) => string;
+};

package/node_modules/@contrail/loader/lib/constants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_PROCESSOR_WARNINGS = exports.ITEM_PROCESSOR_ERRORS = exports.ENTITY_PROCESSOR_ERRORS = exports.CUSTOM_ENTITY_PROCESSOR_ERRORS = exports.COLOR_PROCESSOR_WARNINGS = exports.COLOR_PROCESSOR_ERRORS = void 0;
+exports.COLOR_PROCESSOR_ERRORS = {
+    TYPEPATH_MISSING: '"typePath" with value "color" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "typePath" mapping with value "color" with one of these methods, then try the load again.',
+};
+exports.COLOR_PROCESSOR_WARNINGS = {
+    HEX_IGNORED_WARNING: '"Hex" is ignored when red, green, and blue columns are present',
+};
+exports.CUSTOM_ENTITY_PROCESSOR_ERRORS = {
+    TYPEPATH_MISSING: '"typePath" with value "custom-entity:<subtypepath>" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "typePath" mapping with value "custom-entity:<subtypepath>" with one of these methods, then try the load again.',
+};
+exports.ENTITY_PROCESSOR_ERRORS = {
+    CONFIG_EMPTY: 'Config file is empty',
+    LOAD_TYPE_REQUIRED: '"loadType" is required in the config file',
+    LOAD_TYPE_INVALID: (type) => `"loadType" must be single value "${type}" in the config file`,
+    FEDERATED_ID_REQUIRED: '"federatedId" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "federatedId" mapping with one of these methods, then try the load again.',
+    NAME_REQUIRED: '"name" is required property but is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file. Please add a mapping "name" mapping with one of these methods, then try the load again.',
+    SINGLE_LOAD_TYPE: (entityType) => `"loadType" must be single value "${entityType}" in the config file`,
+};
+exports.ITEM_PROCESSOR_ERRORS = {
+    LOAD_TYPE_INVALID: '"loadType" must be either of values ["ITEM", "PROJECT_ITEM", "ASSORTMENT"] in the config file',
+    TYPEPATH_INVALID: '"typePath" must be "item" or "item:<subtypepath>" in the config file',
+    FAMILY_ID_EMPTY: 'itemFamilyFederatedId is null or undefined or empty in the CSV file',
+    CONFLICTING_IDS: (ids) => `Found conflicting family federated Ids: ${ids}`,
+};
+exports.ITEM_PROCESSOR_WARNINGS = {
+    OPTIONNAME_UNMAPPED: '"optionName" is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file.',
+    OPTIONNAME_NOT_FOUND: (optionName) => `"${optionName}" column not found in the CSV file`,
+    OPTION_FEDERATED_ID_UNMAPPED: '"itemOptionFederatedId" is not found in the federatedMapping config, conditionalColumns config, or as a header in the CSV file.',
+    OPTION_FEDERATED_ID_NOT_FOUND: (itemOptionFederatedId) => `"${itemOptionFederatedId}" column not found in the CSV file`,
+};

package/node_modules/@contrail/loader/lib/custom-entity-processor.d.ts

@@ -0,0 +1,20 @@
+import { GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+import { BaseProcessor } from './base-processor';
+interface CustomEntityData {
+    [key: string]: any;
+}
+export declare class CustomEntityProcessor extends BaseProcessor {
+    static typesToTransformBy: string[];
+    static requiredProperties: string[];
+    static processFederatedId(federatedId: string, typePath: string): string;
+    static setExtraProperties(entity: any, type: any): void;
+    private static isValidCustomEntityTypePath;
+    private static validateTypePath;
+    static validateLoadFile(data: CustomEntityData[], config: LoaderProcess): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+}
+export {};

package/node_modules/@contrail/loader/lib/custom-entity-processor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomEntityProcessor = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const base_processor_1 = require("./base-processor");
+const entity_processor_1 = require("./entity-processor");
+const constants_1 = require("./constants");
+class CustomEntityProcessor extends base_processor_1.BaseProcessor {
+    static typesToTransformBy = ['custom-entity'];
+    static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name'];
+    static processFederatedId(federatedId, typePath) {
+        if (!federatedId.startsWith('custom-entity:')) {
+            federatedId = typePath + ':' + federatedId;
+        }
+        return federatedId;
+    }
+    static setExtraProperties(entity, type) {
+        entity.typeId = type.type.id;
+    }
+    static isValidCustomEntityTypePath(typePath) {
+        return !!typePath?.startsWith('custom-entity:') && !!typePath?.split(':')[1]?.length;
+    }
+    static validateTypePath(data, config, csvHeaders, generalErrors) {
+        const typePathSource = {
+            conditional: config?.conditionalColumns?.some((column) => column.toProperty === 'typePath' && this.isValidCustomEntityTypePath(column.default)),
+            federated: config?.federatedMappings?.typePath,
+            csv: csvHeaders?.includes('typePath'),
+        };
+        if (typePathSource.csv) {
+            const hasCorrectTypePath = data.every((row) => this.isValidCustomEntityTypePath(row.typePath));
+            if (!hasCorrectTypePath) {
+                generalErrors.push({
+                    message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+            return;
+        }
+        if (!typePathSource.conditional && !typePathSource.federated) {
+            generalErrors.push({
+                message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+            return;
+        }
+        if (typePathSource.federated && !csvHeaders.includes(typePathSource.federated)) {
+            generalErrors.push({
+                message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+    static validateLoadFile(data, config) {
+        const { errors, warnings, generalErrors, generalWarnings, csvHeaders } = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.CUSTOM_ENTITY);
+        this.validateTypePath(data, config, csvHeaders, generalErrors);
+        return { errors, warnings, generalErrors, generalWarnings };
+    }
+}
+exports.CustomEntityProcessor = CustomEntityProcessor;

package/node_modules/@contrail/loader/lib/custom-entity-processor.spec.d.ts

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

package/node_modules/@contrail/loader/lib/custom-entity-processor.spec.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const custom_entity_processor_1 = require("./custom-entity-processor");
+const entity_types_1 = require("@contrail/entity-types");
+describe('Custom Entity Processor', () => {
+    const loaderProcess = {
+        id: 'mock-loader-process-id',
+        loadFileId: 'mock-load-file-id',
+        loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+        status: entity_types_1.LoadStatus.COMPLETE,
+        federatedMappings: {
+            federatedId: 'name',
+            name: 'name',
+        },
+        conditionalColumns: [
+            {
+                toProperty: 'typePath',
+                default: 'custom-entity:material',
+            },
+        ],
+    };
+    describe('requiredProperties', () => {
+        it('should have the correct required properties', () => {
+            expect(custom_entity_processor_1.CustomEntityProcessor.requiredProperties).toEqual(['typePath', 'typeId', 'federatedId', 'name']);
+        });
+    });
+    describe('validateLoadFile', () => {
+        describe('typePath validation', () => {
+            it('should validate typePath in conditional columns', () => {
+                const data = [{ name: 'material1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity:material',
+                        },
+                    ],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate typePath in CSV data', () => {
+                const data = [
+                    { name: 'material1', typePath: 'custom-entity:material' },
+                    { name: 'material2', typePath: 'custom-entity:material' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should allow typePath to be in either conditional columns or CSV', () => {
+                const dataWithTypePath = [{ name: 'material1', typePath: 'custom-entity:material' }];
+                const configWithConditional = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity:material',
+                        },
+                    ],
+                };
+                const result1 = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(dataWithTypePath, loaderProcess);
+                const result2 = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile([{ name: 'material1' }], configWithConditional);
+                expect(result1.generalErrors).toHaveLength(0);
+                expect(result2.generalErrors).toHaveLength(0);
+            });
+            it('should error when typePath is missing from both conditional columns and CSV', () => {
+                const data = [{ name: 'material1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when typePath in CSV has incorrect format', () => {
+                const data = [
+                    { name: 'material1', typePath: 'wrong:material' },
+                    { name: 'material2', typePath: 'custom-entity:' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should handle mixed conditional columns', () => {
+                const data = [{ name: 'material1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: 'Default Material',
+                        },
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity:material',
+                        },
+                    ],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should prioritize CSV typePath over conditional columns', () => {
+                const data = [{ name: 'material1', typePath: 'custom-entity:material' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity:wrong',
+                        },
+                    ],
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate federatedId in federatedMapping', () => {
+                const data = [{ name: 'material1', typePathCSV: 'custom-entity:material' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'typePathCSV',
+                    },
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when federatedId column from mapping is not in CSV', () => {
+                const data = [{ name: 'material1', typePathCSV: 'custom-entity:material' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'invalidTypePathCSV',
+                    },
+                };
+                const result = custom_entity_processor_1.CustomEntityProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.CUSTOM_ENTITY_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/entities-v2/base-processor-v2.d.ts

@@ -0,0 +1,27 @@
+import { EntitiesClient, EntityType, GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+export declare class BaseProcessorV2 {
+    static requiredProperties: string[];
+    static transformData(data: any[]): any[];
+    static getTypePath(row: any, entityType: any): any;
+    static processFederatedId(federatedId: string, typePath: string): string;
+    static getEntityTypeForFederatedId(entityType: EntityType): EntityType;
+    static validateRow(row: {
+        [key: string]: string;
+    }): boolean;
+    static setExtraProperties(entity: any, type: any, row?: any): void;
+    static assignExtraItems(client: any, typePaths: any, typesByPath: any, incomingItems: any, projectId: string): Promise<any>;
+    static getFederatedIdKeys(): string[];
+    static logIncommingEntities(incomingEntities: any[], entityType: string, result: any): void;
+    static validateLoadFile(data: any[], config: LoaderProcess): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+    static processEntitiesProperties(client: EntitiesClient, entitiSpecificProps: any, data: any[]): Promise<{
+        projectId: string | null;
+    }>;
+    static canExtractFederatedIds(entityResult: any, incomingEntities: any[]): boolean;
+    static canAddProperty(allPropertiesSlugs: string[], propertyName: string): boolean;
+    static buildAssortmentEntities(client: EntitiesClient, rawData: any[], loaderProcess: LoaderProcess, entitySpecificProperties: any): any;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessorV2 = void 0;
+class BaseProcessorV2 {
+    static requiredProperties = [];
+    static transformData(data) {
+        return data;
+    }
+    static getTypePath(row, entityType) {
+        return row?.typePath || entityType;
+    }
+    static processFederatedId(federatedId, typePath) {
+        return federatedId;
+    }
+    static getEntityTypeForFederatedId(entityType) {
+        return entityType;
+    }
+    static validateRow(row) {
+        return !!row.federatedId;
+    }
+    static setExtraProperties(entity, type, row) { }
+    static async assignExtraItems(client, typePaths, typesByPath, incomingItems, projectId) {
+        return {
+            itemsByFamilyId: null,
+            sizeRangeWarningsAsStringList: null,
+        };
+    }
+    static getFederatedIdKeys() {
+        return ['federatedId'];
+    }
+    static logIncommingEntities(incomingEntities, entityType, result) {
+        console.debug(`${entityType}s to upload: `, incomingEntities.length);
+    }
+    static validateLoadFile(data, config) {
+        return {
+            errors: [],
+            warnings: [],
+            generalErrors: [],
+            generalWarnings: [],
+        };
+    }
+    static async processEntitiesProperties(client, entitiSpecificProps, data) {
+        return { projectId: null };
+    }
+    static canExtractFederatedIds(entityResult, incomingEntities) {
+        return true;
+    }
+    static canAddProperty(allPropertiesSlugs, propertyName) {
+        return true;
+    }
+    static buildAssortmentEntities(client, rawData, loaderProcess, entitySpecificProperties) {
+        return {};
+    }
+}
+exports.BaseProcessorV2 = BaseProcessorV2;

package/node_modules/@contrail/loader/lib/entities-v2/colors-v2/color-processor-v2.d.ts

@@ -0,0 +1,19 @@
+import { GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+import { BaseProcessorV2 } from '../base-processor-v2';
+interface ColorData {
+    hex?: string;
+    [key: string]: any;
+}
+export declare class ColorProcessorV2 extends BaseProcessorV2 {
+    static requiredProperties: string[];
+    static canAddProperty(allPropertiesSlugs: string[], propertyName: string): boolean;
+    static transformData(data: ColorData[]): ColorData[];
+    static validateLoadFile(data: ColorData[], config: LoaderProcess): {
+        errors: ProcessingIssues[];
+        warnings: ProcessingIssues[];
+        generalErrors: GeneralIssueDetails[];
+        generalWarnings: GeneralIssueDetails[];
+    };
+    private static validateTypePath;
+}
+export {};