@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorProcessorV2 = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const util_1 = require("../../common/util");
+const entity_processor_v2_1 = require("../entity-processor-v2");
+const constants_1 = require("../../constants");
+const base_processor_v2_1 = require("../base-processor-v2");
+function removeHexHash(data) {
+    for (const row of data ?? []) {
+        if (row.hex?.startsWith('#')) {
+            row.hex = row.hex.slice(1);
+        }
+    }
+    return data;
+}
+class ColorProcessorV2 extends base_processor_v2_1.BaseProcessorV2 {
+    static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name', 'hex', 'red', 'green', 'blue'];
+    static canAddProperty(allPropertiesSlugs, propertyName) {
+        return allPropertiesSlugs.includes(propertyName);
+    }
+    static transformData(data) {
+        if (!data) {
+            return [];
+        }
+        return removeHexHash(data);
+    }
+    static validateLoadFile(data, config) {
+        const { errors, warnings, generalErrors, generalWarnings, csvHeaders, returnImmediately } = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+        if (returnImmediately) {
+            return { errors, warnings, generalErrors, generalWarnings };
+        }
+        if (config?.loadType?.length && config?.loadType[0] !== entity_types_1.LoadType.COLOR) {
+            generalErrors.push({
+                message: constants_1.ENTITY_PROCESSOR_ERRORS.SINGLE_LOAD_TYPE(entity_types_1.LoadType.COLOR),
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        this.validateTypePath(data, config, csvHeaders, generalErrors);
+        const duplicateFederatedIdErrors = (0, util_1.getDuplicateFederatedIds)(data, config?.federatedMappings?.federatedId || 'federatedId');
+        if (duplicateFederatedIdErrors.length) {
+            errors.push(...duplicateFederatedIdErrors);
+        }
+        const redColumn = config?.federatedMappings?.red || 'red';
+        const blueColumn = config?.federatedMappings?.blue || 'blue';
+        const greenColumn = config?.federatedMappings?.green || 'green';
+        const hexColumn = config?.federatedMappings?.hex || 'hex';
+        const hasRedColumn = csvHeaders.includes(redColumn);
+        const hasBlueColumn = csvHeaders.includes(blueColumn);
+        const hasGreenColumn = csvHeaders.includes(greenColumn);
+        const hasHexColumn = csvHeaders.includes(hexColumn);
+        if (hasHexColumn && hasRedColumn && hasGreenColumn && hasBlueColumn) {
+            generalWarnings.push({
+                message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        return { errors, warnings, generalErrors, generalWarnings };
+    }
+    static validateTypePath(data, config, csvHeaders, generalErrors) {
+        const typePathSource = {
+            conditional: config?.conditionalColumns?.some((column) => column.toProperty === 'typePath' && column.default === 'color'),
+            federated: config?.federatedMappings?.typePath,
+            csv: csvHeaders?.includes('typePath'),
+        };
+        if (typePathSource.csv) {
+            const hasCorrectTypePath = data.every((row) => row.typePath === 'color');
+            if (!hasCorrectTypePath) {
+                generalErrors.push({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+            return;
+        }
+        if (config?.conditionalColumns?.some((col) => col.toProperty === 'typePath')) {
+            if (!typePathSource.conditional) {
+                generalErrors.push({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            }
+        }
+        if (typePathSource.federated && !csvHeaders.includes(typePathSource.federated)) {
+            generalErrors.push({
+                message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+    }
+}
+exports.ColorProcessorV2 = ColorProcessorV2;

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

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

package/node_modules/@contrail/loader/lib/entities-v2/colors-v2/color-processor-v2.spec.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const color_processor_v2_1 = require("./color-processor-v2");
+const entity_types_1 = require("@contrail/entity-types");
+describe('ColorProcessorV2', () => {
+    const loaderProcess = {
+        id: 'mock-loader-process-id',
+        loadFileId: 'mock-load-file-id',
+        loadType: [entity_types_1.LoadType.COLOR],
+        status: entity_types_1.LoadStatus.COMPLETE,
+        federatedMappings: {
+            federatedId: 'name',
+            name: 'name',
+        },
+        conditionalColumns: [
+            {
+                toProperty: 'typePath',
+                default: 'color',
+            },
+        ],
+    };
+    describe('requiredProperties', () => {
+        it('should have the correct required properties', () => {
+            expect(color_processor_v2_1.ColorProcessorV2.requiredProperties).toEqual([
+                'typePath',
+                'typeId',
+                'federatedId',
+                'name',
+                'hex',
+                'red',
+                'green',
+                'blue',
+            ]);
+        });
+    });
+    describe('transformData', () => {
+        it('should remove the hash from hex values', () => {
+            const data = [
+                { hex: '#ff0000', name: 'red' },
+                { hex: '#00ff00', name: 'green' },
+                { hex: '#0000ff', name: 'blue' },
+            ];
+            const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+            expect(result).toEqual([
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ]);
+        });
+        it('should not modify hex values that do not start with a hash', () => {
+            const data = [
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ];
+            const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+            expect(result).toEqual([
+                { hex: 'ff0000', name: 'red' },
+                { hex: '00ff00', name: 'green' },
+                { hex: '0000ff', name: 'blue' },
+            ]);
+        });
+        it('should handle empty data', () => {
+            const data = [];
+            const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+            expect(result).toEqual([]);
+        });
+        it('should handle null or undefined data', () => {
+            const data = null;
+            const result = color_processor_v2_1.ColorProcessorV2.transformData(data);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('validateLoadFile', () => {
+        describe('typePath validation', () => {
+            it('should validate typePath in conditional columns', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate typePath in CSV data', () => {
+                const data = [
+                    { name: 'color1', typePath: 'color' },
+                    { name: 'color2', typePath: 'color' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should allow typePath to be in either conditional columns or CSV', () => {
+                const dataWithTypePath = [{ name: 'color1', typePath: 'color' }];
+                const configWithConditional = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result1 = color_processor_v2_1.ColorProcessorV2.validateLoadFile(dataWithTypePath, loaderProcess);
+                const result2 = color_processor_v2_1.ColorProcessorV2.validateLoadFile([{ name: 'color1' }], configWithConditional);
+                expect(result1.generalErrors).toHaveLength(0);
+                expect(result2.generalErrors).toHaveLength(0);
+            });
+            it('should return no error when typePath is missing from both conditional columns and CSV', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([]);
+            });
+            it('should error when typePath in CSV has incorrect value', () => {
+                const data = [
+                    { name: 'color1', typePath: 'wrong' },
+                    { name: 'color2', typePath: 'color' },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when conditional column has incorrect typePath value', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'wrong',
+                        },
+                    ],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should handle mixed conditional columns', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: 'Default Color',
+                        },
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should prioritize CSV typePath over conditional columns', () => {
+                const data = [{ name: 'color1', typePath: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'wrong',
+                        },
+                    ],
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+            it('should validate federatedId in federatedMapping', () => {
+                const data = [{ name: 'color1', typePathCSV: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'typePathCSV',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.COLOR_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: 'color1', typePathCSV: 'color' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        typePath: 'invalidTypePathCSV',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+        describe('color column validation', () => {
+            it('should warn when both hex and RGB columns are present', () => {
+                const data = [
+                    {
+                        name: 'test-color',
+                        red: '255',
+                        green: '0',
+                        blue: '0',
+                        hex: '#ff0000',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'red',
+                        green: 'green',
+                        blue: 'blue',
+                        hex: 'hex',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalWarnings).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should not warn when only RGB columns are present', () => {
+                const data = [
+                    {
+                        name: 'test-color',
+                        red: '255',
+                        green: '0',
+                        blue: '0',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'red',
+                        green: 'green',
+                        blue: 'blue',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should not warn when only hex column is present', () => {
+                const data = [{ name: 'test-color', hex: '#ff0000' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        hex: 'hex',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should handle custom column names from federatedMappings', () => {
+                const data = [{ name: 'test-color', r: '255', g: '0', b: '0', hexcode: '#ff0000' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        ...loaderProcess.federatedMappings,
+                        red: 'r',
+                        green: 'g',
+                        blue: 'b',
+                        hex: 'hexcode',
+                    },
+                };
+                const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+                expect(result.generalWarnings).toContainEqual({
+                    message: constants_1.COLOR_PROCESSOR_WARNINGS.HEX_IGNORED_WARNING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+        it('should return error if conditionalColumns format is incorrect', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [{ toProperty: 'typePath', default: 'wrong' }],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should return duplicate federated ID errors', () => {
+            const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color1' }];
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+            expect(result.errors).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"}',
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('should handle no duplicate federated IDs', () => {
+            const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color3' }];
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, loaderProcess);
+            expect(result.errors).toEqual([]);
+        });
+        it('should throw error if typepath is present in the config file but have incorrect typePath', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [
+                    {
+                        toProperty: 'typePath',
+                        default: 'color1',
+                    },
+                ],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should throw error if typepath is present in the csv header but have incorrect typePath', () => {
+            const data = [{ name: 'color1', typePath: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.COLOR_PROCESSOR_ERRORS.TYPEPATH_MISSING,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should not throw error if typepath is present in the csv header and have correct typePath', () => {
+            const data = [{ name: 'color1', typePath: 'color' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([]);
+        });
+        it('should not throw error if typepath is present in the config file and have correct typePath', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [
+                    {
+                        toProperty: 'typePath',
+                        default: 'color',
+                    },
+                ],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([]);
+        });
+        it('should not throw error if typepath is not present in the config file and csv headers', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([]);
+        });
+        it('should throw an error if duplicate federated id is present', () => {
+            const data = [{ name: 'color1' }, { name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                conditionalColumns: [
+                    {
+                        toProperty: 'typePath',
+                        default: 'color',
+                    },
+                ],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.errors).toEqual([
+                {
+                    rowNumber: 2,
+                    columnIssues: [
+                        {
+                            columnName: 'name',
+                            message: 'Duplicate federatedId found: color1',
+                            issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                            data: '{"name":"color1"}',
+                        },
+                    ],
+                },
+                {
+                    rowNumber: 3,
+                    columnIssues: [
+                        {
+                            columnName: 'name',
+                            message: 'Duplicate federatedId found: color1',
+                            issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                            data: '{"name":"color1"}',
+                        },
+                    ],
+                },
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { GeneralIssueDetails, LoaderProcess, ProcessingIssues } from '@contrail/entity-types';
+import { BaseProcessorV2 } from '../base-processor-v2';
+interface CustomEntityData {
+    [key: string]: any;
+}
+export declare class CustomEntityProcessorV2 extends BaseProcessorV2 {
+    static requiredProperties: string[];
+    static processFederatedId(federatedId: string, typePath: string): string;
+    static canAddProperty(allPropertiesSlugs: string[], propertyName: string): boolean;
+    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/entities-v2/custom-entities-v2/custom-entity-processor-v2.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomEntityProcessorV2 = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const base_processor_v2_1 = require("../base-processor-v2");
+const entity_processor_v2_1 = require("../entity-processor-v2");
+const util_1 = require("../../common/util");
+const constants_1 = require("../../constants");
+class CustomEntityProcessorV2 extends base_processor_v2_1.BaseProcessorV2 {
+    static requiredProperties = ['typePath', 'typeId', 'federatedId', 'name'];
+    static processFederatedId(federatedId, typePath) {
+        if (!federatedId.startsWith('custom-entity:')) {
+            federatedId = typePath + ':' + federatedId;
+        }
+        return federatedId;
+    }
+    static canAddProperty(allPropertiesSlugs, propertyName) {
+        return allPropertiesSlugs.includes(propertyName);
+    }
+    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, returnImmediately } = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+        if (returnImmediately) {
+            return { errors, warnings, generalErrors, generalWarnings };
+        }
+        if (config?.loadType?.length && config?.loadType[0] !== entity_types_1.LoadType.CUSTOM_ENTITY) {
+            generalErrors.push({
+                message: constants_1.ENTITY_PROCESSOR_ERRORS.SINGLE_LOAD_TYPE(entity_types_1.LoadType.CUSTOM_ENTITY),
+                issueType: entity_types_1.IssueType.CONFIG,
+            });
+        }
+        this.validateTypePath(data, config, csvHeaders, generalErrors);
+        const duplicateFederatedIdErrors = (0, util_1.getDuplicateFederatedIds)(data, config?.federatedMappings?.federatedId || 'federatedId');
+        if (duplicateFederatedIdErrors.length) {
+            errors.push(...duplicateFederatedIdErrors);
+        }
+        return { errors, warnings, generalErrors, generalWarnings };
+    }
+}
+exports.CustomEntityProcessorV2 = CustomEntityProcessorV2;

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

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