@contrail/cli 3.4.5-alpha.18160f5 → 3.4.6-alpha.c203463

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

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assortment_processor_1 = require("./assortment-processor");
+const item_helper_1 = require("./item-helper");
+jest.mock('./item-helper', () => ({
+    getAssortment: jest.fn(),
+    getAssortmentItemProperties: jest.fn(),
+    getAssortmentItems: jest.fn(),
+    getItemsFromFederatedIds: jest.fn(),
+    mapAssortmentItemsToItemsAndFillItemId: jest.fn(),
+}));
+jest.mock('./partial-assortment-processor', () => ({
+    PartialAssortmentProcessor: {
+        loadCSVJson: jest.fn(),
+    },
+}));
+jest.mock('@contrail/entity-compare', () => ({
+    compareEntityCollections: jest.fn(),
+}));
+jest.mock('lodash', () => ({
+    flatMap: jest.fn((array, iteratee) => array.flatMap(iteratee)),
+}));
+describe('AssortmentProcessor', () => {
+    const client = {};
+    const loaderProcess = {
+        partialAssortmentUpdate: false,
+        assortmentSplit: {
+            values: [{ value: 'group1' }, { value: 'group2' }],
+            fieldToSplitOn: 'groupField',
+            dropField: 'dropField',
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('buildEntities', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        const mockRawData = [{ itemFamilyFederatedId: 'mockId1' }];
+        const mockItemsByFederatedId = { mockId1: { id: 'mockItem1' } };
+        const mockResult = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: [],
+            projectId: null,
+            badAssortmentItems: [],
+            assortment: {},
+            fullSummary: {
+                adds: [],
+                updates: [],
+                deletes: [],
+                unchanged: [],
+            },
+            incomingAssortmentItems: [],
+            unmappedAssortmentItems: [],
+        };
+        it('should process assortment load and return result', async () => {
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'processAssortmentLoad').mockResolvedValue(mockResult);
+            const result = await assortment_processor_1.AssortmentProcessor.buildAssortmentEntities(client, mockRawData, loaderProcess, mockItemsByFederatedId);
+            expect(assortment_processor_1.AssortmentProcessor['processAssortmentLoad']).toHaveBeenCalledWith(loaderProcess, mockRawData, mockItemsByFederatedId, client, undefined);
+            expect(result).toEqual(mockResult);
+        });
+    });
+    describe('splitDataByAssortment', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        it('should group rows by valid fieldToSplitOn values', () => {
+            const mockRows = [
+                { groupField: 'group1', itemFamilyFederatedId: 'mockId1' },
+                { groupField: 'group2', itemFamilyFederatedId: 'mockId2' },
+                { groupField: 'invalidGroup', itemFamilyFederatedId: 'mockId3' },
+            ];
+            const result = assortment_processor_1.AssortmentProcessor['splitDataByAssortment'](mockRows, loaderProcess);
+            expect(result).toEqual({
+                group1: [{ groupField: 'group1', itemFamilyFederatedId: 'mockId1' }],
+                group2: [{ groupField: 'group2', itemFamilyFederatedId: 'mockId2' }],
+            });
+        });
+    });
+    describe('loadCSVJson', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        it('should call loadObjects and return the result', async () => {
+            const mockData = [{ itemFamilyFederatedId: 'mockId1' }];
+            const mockItemsByFederatedId = {};
+            const mockResult = {
+                badAssortmentItems: [],
+                incomingAssortmentItems: [],
+            };
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'loadObjects').mockResolvedValue(mockResult);
+            const result = await assortment_processor_1.AssortmentProcessor.loadCSVJson(client, mockData, mockItemsByFederatedId);
+            expect(assortment_processor_1.AssortmentProcessor['loadObjects']).toHaveBeenCalledWith(client, mockData, mockItemsByFederatedId, undefined, undefined, undefined);
+            expect(result).toEqual(mockResult);
+        });
+    });
+    describe('loadObjects', () => {
+        let client;
+        let consoleLogSpy;
+        let consoleErrorSpy;
+        const mockAllPropertiesSlugs = ['itemId', 'itemFamilyFederatedId', 'itemOptionFederatedId'];
+        const mockTypePropertyToValueType = {
+            itemId: 'string',
+            itemFamilyFederatedId: 'string',
+            itemOptionFederatedId: 'string',
+        };
+        const mockTargetAssortment = {
+            id: 'assortment-1',
+            name: 'Test Assortment',
+        };
+        const mockCurrentAssortmentItems = [{ itemId: 'item-1', id: 'assortment-item-1' }];
+        const mockItemsByFederatedId = {
+            'family-1': { id: 'item-1' },
+            'option-1': { id: 'item-2' },
+        };
+        const mockIncomingSummary = {
+            adds: [{ id: 'item-3' }],
+            deletes: [],
+            updates: [{ id: 'item-1' }],
+            unchanged: [{ id: 'item-2' }],
+        };
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+            client = {};
+            consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+            jest.spyOn(console, 'info').mockImplementation();
+            jest.spyOn(console, 'debug').mockImplementation();
+            consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            jest.clearAllMocks();
+            item_helper_1.getAssortmentItemProperties.mockResolvedValue({
+                allPropertiesSlugs: mockAllPropertiesSlugs,
+                typePropertyToValueType: mockTypePropertyToValueType,
+            });
+            item_helper_1.getAssortment.mockResolvedValue(mockTargetAssortment);
+            item_helper_1.getAssortmentItems.mockResolvedValue(mockCurrentAssortmentItems);
+            item_helper_1.getItemsFromFederatedIds.mockResolvedValue(mockItemsByFederatedId);
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'processIncomingData').mockReturnValue({
+                incomingAssortmentItems: [
+                    {
+                        itemFamilyFederatedId: 'family-1',
+                        itemOptionFederatedId: 'option-1',
+                    },
+                ],
+                badAssortmentItems: [],
+            });
+            item_helper_1.mapAssortmentItemsToItemsAndFillItemId.mockReturnValue({
+                completeIncomingAssortmentItems: [
+                    {
+                        itemId: 'item-1',
+                        itemFamilyFederatedId: 'family-1',
+                        itemOptionFederatedId: 'option-1',
+                    },
+                ],
+                unmappedAssortmentItems: [],
+            });
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'getSummary').mockReturnValue(mockIncomingSummary);
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'logSummary').mockImplementation();
+        });
+        afterEach(() => {
+            consoleLogSpy.mockRestore();
+            consoleErrorSpy.mockRestore();
+        });
+        it('Uses passed itemsByFederatedId when provided', async () => {
+            const data = [
+                {
+                    itemFamilyFederatedId: 'family-1',
+                    itemOptionFederatedId: 'option-1',
+                },
+            ];
+            const passedItemsByFederatedId = { 'existing-item': { id: 'item-0' } };
+            await assortment_processor_1.AssortmentProcessor['loadObjects'](client, data, passedItemsByFederatedId, 'assortment-1');
+            expect(item_helper_1.getItemsFromFederatedIds).not.toHaveBeenCalled();
+            expect(item_helper_1.mapAssortmentItemsToItemsAndFillItemId).toHaveBeenCalledWith(expect.anything(), passedItemsByFederatedId);
+        });
+        it('Throws error when target assortment is not found', async () => {
+            item_helper_1.getAssortment.mockResolvedValue(null);
+            const data = [{ itemFamilyFederatedId: 'family-1' }];
+            await expect(assortment_processor_1.AssortmentProcessor['loadObjects'](client, data, {}, 'non-existent')).rejects.toThrow('Target Assortment not found.');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Target Assortment not found.');
+        });
+        it('Handles items with only family ID and no option ID', async () => {
+            const data = [{ itemFamilyFederatedId: 'family-1' }];
+            item_helper_1.mapAssortmentItemsToItemsAndFillItemId.mockReturnValue({
+                completeIncomingAssortmentItems: [{ itemId: 'item-1', itemFamilyFederatedId: 'family-1' }],
+                unmappedAssortmentItems: [],
+            });
+            const result = await assortment_processor_1.AssortmentProcessor['loadObjects'](client, data, mockItemsByFederatedId, 'assortment-1');
+            expect(assortment_processor_1.AssortmentProcessor['getSummary']).toHaveBeenCalledWith(expect.arrayContaining([expect.not.objectContaining({ itemFamilyFederatedId: 'family-1' })]), mockCurrentAssortmentItems, mockAllPropertiesSlugs, mockTypePropertyToValueType, expect.any(Array));
+        });
+        it('Handles items with both family ID and option ID', async () => {
+            const data = [
+                {
+                    itemFamilyFederatedId: 'family-1',
+                    itemOptionFederatedId: 'option-1',
+                },
+            ];
+            item_helper_1.mapAssortmentItemsToItemsAndFillItemId.mockReturnValue({
+                completeIncomingAssortmentItems: [
+                    {
+                        itemId: 'item-2',
+                        itemFamilyFederatedId: 'family-1',
+                        itemOptionFederatedId: 'option-1',
+                    },
+                ],
+                unmappedAssortmentItems: [],
+            });
+            const result = await assortment_processor_1.AssortmentProcessor['loadObjects'](client, data, mockItemsByFederatedId, 'assortment-1');
+            expect(assortment_processor_1.AssortmentProcessor['getSummary']).toHaveBeenCalledWith(expect.arrayContaining([
+                expect.not.objectContaining({
+                    itemFamilyFederatedId: 'family-1',
+                    itemOptionFederatedId: 'option-1',
+                }),
+            ]), mockCurrentAssortmentItems, mockAllPropertiesSlugs, mockTypePropertyToValueType, expect.arrayContaining(['item-1']));
+        });
+        it('Handles unmapped assortment items', async () => {
+            item_helper_1.mapAssortmentItemsToItemsAndFillItemId.mockReturnValue({
+                completeIncomingAssortmentItems: [{ itemId: 'item-1', itemFamilyFederatedId: 'family-1' }],
+                unmappedAssortmentItems: [{ itemFamilyFederatedId: 'unknown-family' }],
+            });
+            await assortment_processor_1.AssortmentProcessor['loadObjects'](client, [{ itemFamilyFederatedId: 'family-1' }, { itemFamilyFederatedId: 'unknown-family' }], mockItemsByFederatedId, 'assortment-1');
+            expect(console.debug).toHaveBeenCalledWith('unmappedAssortmentItems: 1');
+        });
+        it('Processes empty data array', async () => {
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'processIncomingData').mockReturnValue({
+                incomingAssortmentItems: [],
+                badAssortmentItems: [],
+            });
+            const result = await assortment_processor_1.AssortmentProcessor['loadObjects'](client, [], mockItemsByFederatedId, 'assortment-1');
+            expect(result).toEqual({
+                badAssortmentItems: [],
+                assortment: mockTargetAssortment,
+                fullSummary: expect.objectContaining({
+                    adds: expect.any(Array),
+                    deletes: expect.any(Array),
+                    updates: expect.any(Array),
+                }),
+                incomingAssortmentItems: [],
+                unmappedAssortmentItems: [],
+            });
+        });
+        it('Handles data with bad assortment items', async () => {
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'processIncomingData').mockReturnValue({
+                incomingAssortmentItems: [],
+                badAssortmentItems: [{ someBadData: true }],
+            });
+            const result = await assortment_processor_1.AssortmentProcessor['loadObjects'](client, [{ someBadData: true }], mockItemsByFederatedId, 'assortment-1');
+            expect(result.badAssortmentItems).toEqual([{ someBadData: true }]);
+        });
+        it('Uses assortment identifier when assortment id is not provided', async () => {
+            await assortment_processor_1.AssortmentProcessor['loadObjects'](client, [{ itemFamilyFederatedId: 'family-1' }], mockItemsByFederatedId, undefined, 'test-identifier');
+            expect(item_helper_1.getAssortment).toHaveBeenCalledWith(client, undefined, 'test-identifier', expect.any(Array));
+        });
+        it('Should add assortment items, if assortmentItems are not directly present in the assortment', async () => {
+            const result = await assortment_processor_1.AssortmentProcessor['loadObjects'](client, [{ itemFamilyFederatedId: 'family-1' }], mockItemsByFederatedId, undefined, 'test-identifier');
+            expect(result).not.toEqual(null);
+            expect(result.assortment.assortmentItems).toBeDefined();
+            expect(result.assortment.assortmentItems).toHaveLength(1);
+        });
+    });
+    describe('processAssortmentLoad', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        const mockRows = [{ itemFamilyFederatedId: 'mockId1' }];
+        const mockItemsByFederatedId = { mockId1: { id: 'mockItem1' } };
+        const mockResult = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: mockItemsByFederatedId,
+            typesByPath: [],
+            projectId: null,
+            assortmentDetails: [
+                {
+                    badAssortmentItems: [],
+                    assortment: {},
+                    fullSummary: {
+                        adds: [],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                },
+            ],
+            badAssortmentItems: [],
+            incomingAssortmentItems: [],
+        };
+        it('should handle partial load with split', async () => {
+            const mockRows = [
+                { groupField: 'group1', itemFamilyFederatedId: 'mockId1' },
+                { groupField: 'group2', itemFamilyFederatedId: 'mockId2' },
+            ];
+            const mockGroupedData = {
+                group1: [{ groupField: 'group1', itemFamilyFederatedId: 'mockId1' }],
+                group2: [{ groupField: 'group2', itemFamilyFederatedId: 'mockId2' }],
+            };
+            const mockLoadResult = {
+                badAssortmentItems: [],
+                incomingAssortmentItems: [],
+                assortmentDetails: [],
+            };
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'splitDataByAssortment').mockReturnValue(mockGroupedData);
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'handleFullLoad').mockResolvedValue(mockLoadResult);
+            const result = await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, mockRows, {}, client);
+            expect(assortment_processor_1.AssortmentProcessor['splitDataByAssortment']).toHaveBeenCalledWith(mockRows, loaderProcess);
+            expect(assortment_processor_1.AssortmentProcessor['handleFullLoad']).toHaveBeenCalledWith(loaderProcess, mockGroupedData, client, {}, undefined);
+            expect(result).toEqual({
+                incomingEntities: mockLoadResult.incomingAssortmentItems,
+                badEntities: mockLoadResult.badAssortmentItems,
+                allCurrentEntitiesByFederatedId: {},
+                typesByPath: [],
+                projectId: null,
+                ...mockLoadResult,
+            });
+        });
+        it('should log warnings for rows without valid fieldToSplitOn', async () => {
+            const mockRows = [{ groupField: 'invalidGroup', itemFamilyFederatedId: 'mockId1' }];
+            const mockGroupedData = {};
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'splitDataByAssortment').mockReturnValue(mockGroupedData);
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, mockRows, {}, client);
+            expect(consoleWarnSpy).toHaveBeenCalledWith('Warning: 1 rows do not have a valid value for fieldToSplitOn');
+        });
+        it('should handle full load without split', async () => {
+            loaderProcess.assortmentSplit = null;
+            jest.spyOn(assortment_processor_1.AssortmentProcessor, 'loadCSVJson').mockResolvedValue(mockResult.assortmentDetails[0]);
+            const result = await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, mockRows, mockItemsByFederatedId, client);
+            expect(result).toEqual({
+                incomingEntities: mockResult.incomingEntities,
+                badEntities: mockResult.badEntities,
+                allCurrentEntitiesByFederatedId: mockResult.allCurrentEntitiesByFederatedId,
+                typesByPath: [],
+                projectId: null,
+                ...mockResult,
+            });
+        });
+        it('should use row-based path when rows have assortmentId', async () => {
+            loaderProcess.assortmentSplit = null;
+            const rowsWithAssortmentId = [
+                { itemFamilyFederatedId: 'fam-1', assortmentId: 'assort-A' },
+                { itemFamilyFederatedId: 'fam-2', assortmentId: 'assort-A' },
+            ];
+            const runLoaderSpy = jest.spyOn(assortment_processor_1.AssortmentProcessor, 'runLoaderOperations').mockResolvedValue({
+                badAssortmentItems: [],
+                assortmentDetails: [],
+                incomingAssortmentItems: [],
+            });
+            await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, rowsWithAssortmentId, mockItemsByFederatedId, client);
+            expect(runLoaderSpy).toHaveBeenCalled();
+            const operations = runLoaderSpy.mock.calls[0][0];
+            expect(operations).toHaveLength(1);
+            expect(operations[0].assortmentId).toBe('assort-A');
+            expect(operations[0].rowsToLoad).toHaveLength(2);
+        });
+        it('should group rows by assortmentId into separate operations', async () => {
+            loaderProcess.assortmentSplit = null;
+            const rowsWithMultipleAssortments = [
+                { itemFamilyFederatedId: 'fam-1', assortmentId: 'assort-A' },
+                { itemFamilyFederatedId: 'fam-2', assortmentId: 'assort-B' },
+                { itemFamilyFederatedId: 'fam-3', assortmentId: 'assort-A' },
+            ];
+            const runLoaderSpy = jest.spyOn(assortment_processor_1.AssortmentProcessor, 'runLoaderOperations').mockResolvedValue({
+                badAssortmentItems: [],
+                assortmentDetails: [],
+                incomingAssortmentItems: [],
+            });
+            await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, rowsWithMultipleAssortments, mockItemsByFederatedId, client);
+            const operations = runLoaderSpy.mock.calls[0][0];
+            expect(operations).toHaveLength(2);
+            const assortAOp = operations.find((op) => op.assortmentId === 'assort-A');
+            const assortBOp = operations.find((op) => op.assortmentId === 'assort-B');
+            expect(assortAOp.rowsToLoad).toHaveLength(2);
+            expect(assortBOp.rowsToLoad).toHaveLength(1);
+        });
+        it('should use partial operations when partialAssortmentUpdate and dropField are set', async () => {
+            loaderProcess.assortmentSplit = null;
+            loaderProcess.partialAssortmentUpdate = true;
+            loaderProcess.assortmentItemDropField = 'toDrop';
+            const rowsWithDrop = [
+                { itemFamilyFederatedId: 'fam-1', assortmentId: 'assort-A', toDrop: '' },
+                { itemFamilyFederatedId: 'fam-2', assortmentId: 'assort-A', toDrop: 'yes' },
+            ];
+            const runPartialSpy = jest.spyOn(assortment_processor_1.AssortmentProcessor, 'runPartialLoaderOperations').mockResolvedValue({
+                badAssortmentItems: [],
+                assortmentDetails: [],
+                incomingAssortmentItems: [],
+            });
+            await assortment_processor_1.AssortmentProcessor['processAssortmentLoad'](loaderProcess, rowsWithDrop, mockItemsByFederatedId, client);
+            expect(runPartialSpy).toHaveBeenCalled();
+            const operations = runPartialSpy.mock.calls[0][0];
+            expect(operations).toHaveLength(1);
+            expect(operations[0].rowsToAdd).toHaveLength(1);
+            expect(operations[0].rowsToDrop).toHaveLength(1);
+            expect(operations[0].assortmentId).toBe('assort-A');
+        });
+    });
+});

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/item-helper.d.ts

@@ -0,0 +1,20 @@
+import { ComparableEntity } from '@contrail/entity-compare';
+import { EntitiesClient, PropertyType } from '@contrail/entity-types';
+import { Type } from '@contrail/types';
+export declare type ObjectTypeCache = Map<string, any>;
+export declare function getAssortmentItems(targetAssortment: any): Promise<any>;
+export declare function getAssortmentItemProperties(client: EntitiesClient, requiredNonTypeProperties: string[], typesByTypePath?: Record<string, Type>): Promise<{
+    allPropertiesSlugs: string[];
+    typePropertyToValueType: {
+        [key: string]: PropertyType;
+    };
+}>;
+export declare function getItemsFromFederatedIds(client: EntitiesClient, incomingRows: any[]): Promise<{
+    [key: string]: any;
+}>;
+export declare function mapAssortmentItemsToItemsAndFillItemId(incomingAssortmentItems: any[], itemsByFederatedId: any): {
+    completeIncomingAssortmentItems: any[];
+    unmappedAssortmentItems: any[];
+};
+export declare function convertToComparableEntities(comparableItems: any[], assortmentItemProperties: string[], idFieldName: string): ComparableEntity[];
+export declare function getAssortment(ctx: any, passedAssortmentId: string, passedAssortmentIdentifier: string, data: any[]): Promise<any>;

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

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssortment = exports.convertToComparableEntities = exports.mapAssortmentItemsToItemsAndFillItemId = exports.getItemsFromFederatedIds = exports.getAssortmentItemProperties = exports.getAssortmentItems = void 0;
+const lodash_1 = require("lodash");
+const entities_helper_1 = require("../../common/entities-helper");
+const pLimit = require('p-limit');
+const limit = pLimit(5);
+async function getAssortmentItems(targetAssortment) {
+    if (targetAssortment.assortmentItems) {
+        return targetAssortment.assortmentItems;
+    }
+    else if (targetAssortment.itemsDownloadURL) {
+        return fetchJSON(targetAssortment.itemsDownloadURL);
+    }
+    return [];
+}
+exports.getAssortmentItems = getAssortmentItems;
+async function fetchJSON(url) {
+    try {
+        const response = await fetch(url);
+        return await response.json();
+    }
+    catch (error) {
+        console.error(`Error fetching JSON from ${url}:`, error);
+        throw error;
+    }
+}
+async function getAssortmentItemProperties(client, requiredNonTypeProperties, typesByTypePath) {
+    const typePath = 'assortment-item';
+    const cachedType = typesByTypePath?.[typePath];
+    const objType = cachedType ? cachedType : await fetchObjectType(client, typePath);
+    const typeProperties = objType?.typeProperties?.map((property) => property.slug) ?? [];
+    const typePropertyToValueType = mapTypePropertiesToValueType(objType?.typeProperties);
+    const allPropertiesSlugs = [...typeProperties, ...requiredNonTypeProperties];
+    return { allPropertiesSlugs, typePropertyToValueType };
+}
+exports.getAssortmentItemProperties = getAssortmentItemProperties;
+async function fetchObjectType(client, path) {
+    try {
+        const suffix = `roots/${path}/path/${path}`;
+        const objType = await client.get({
+            entityName: 'type',
+            suffix,
+            relations: ['typeProperties'],
+        });
+        return objType;
+    }
+    catch (error) {
+        console.error('Error fetching object type:', error);
+        throw new Error('Invalid Type');
+    }
+}
+function mapTypePropertiesToValueType(typeProperties) {
+    return (typeProperties?.reduce((acc, property) => {
+        acc[property.slug] = property.propertyType;
+        return acc;
+    }, {}) || {});
+}
+async function getItemsFromFederatedIds(client, incomingRows) {
+    const federatedIds = extractUniqueFederatedIds(incomingRows);
+    const chunks = (0, lodash_1.chunk)(federatedIds, 200);
+    const allCurrentItemsByFederatedId = await fetchItemsByFederatedIds(client, chunks);
+    return allCurrentItemsByFederatedId;
+}
+exports.getItemsFromFederatedIds = getItemsFromFederatedIds;
+function extractUniqueFederatedIds(incomingRows) {
+    const allFederatedIds = incomingRows
+        .flatMap((row) => [
+        row.itemFamilyFederatedId?.replace(/\//g, '%2F'),
+        row.itemOptionFederatedId?.replace(/\//g, '%2F'),
+    ])
+        .filter(Boolean);
+    const uniqueFederatedIds = (0, lodash_1.uniq)(allFederatedIds);
+    return uniqueFederatedIds;
+}
+async function fetchItemsByFederatedIds(client, chunks) {
+    const allCurrentItemsByFederatedId = {};
+    const federatedPromises = chunks.map((chunk) => limit(async () => {
+        try {
+            const currentItemBatch = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'item',
+                federatedIds: chunk,
+                skipHydrateRelationships: true,
+            });
+            if (currentItemBatch?.length) {
+                currentItemBatch.forEach((item) => {
+                    allCurrentItemsByFederatedId[item.federatedId] = item;
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to get items by FederatedIds:', error);
+            throw error;
+        }
+    }));
+    await Promise.all(federatedPromises);
+    return allCurrentItemsByFederatedId;
+}
+function mapAssortmentItemsToItemsAndFillItemId(incomingAssortmentItems, itemsByFederatedId) {
+    const completeIncomingAssortmentItems = [];
+    const unmappedAssortmentItems = [];
+    if (!incomingAssortmentItems || !incomingAssortmentItems?.length || !Object.keys(itemsByFederatedId)?.length) {
+        return { completeIncomingAssortmentItems, unmappedAssortmentItems };
+    }
+    incomingAssortmentItems.forEach((assortmentItem) => {
+        const item = findItemByFederatedId(assortmentItem, itemsByFederatedId);
+        if (item) {
+            assortmentItem.itemId = item.id;
+            completeIncomingAssortmentItems.push(assortmentItem);
+        }
+        else {
+            unmappedAssortmentItems.push(assortmentItem);
+            logUnmappedItem(assortmentItem);
+        }
+    });
+    return { completeIncomingAssortmentItems, unmappedAssortmentItems };
+}
+exports.mapAssortmentItemsToItemsAndFillItemId = mapAssortmentItemsToItemsAndFillItemId;
+function findItemByFederatedId(assortmentItem, itemsByFederatedId) {
+    if (assortmentItem.itemOptionFederatedId) {
+        return itemsByFederatedId[assortmentItem.itemOptionFederatedId];
+    }
+    return itemsByFederatedId[assortmentItem.itemFamilyFederatedId];
+}
+function logUnmappedItem(assortmentItem) {
+    const federatedId = assortmentItem.itemOptionFederatedId || assortmentItem.itemFamilyFederatedId;
+    console.warn('Item not found for federatedId:', federatedId);
+}
+function convertToComparableEntities(comparableItems, assortmentItemProperties, idFieldName) {
+    return comparableItems
+        .filter((item) => item[idFieldName])
+        .map((item) => createComparableEntity(item, assortmentItemProperties, idFieldName));
+}
+exports.convertToComparableEntities = convertToComparableEntities;
+function createComparableEntity(item, properties, idFieldName) {
+    const comparableEntity = { id: item[idFieldName] };
+    properties.forEach((property) => {
+        const value = item[property];
+        if (value !== undefined && value !== null && value !== '') {
+            comparableEntity[property] = value;
+        }
+    });
+    return removeUnnecessaryKeys(comparableEntity);
+}
+function removeUnnecessaryKeys(object) {
+    const keysToRemove = [
+        'itemOptionId',
+        'itemId',
+        'typeId',
+        'assortmentId',
+        'createdOn',
+        'createdBy',
+        'createdById',
+        'updatedOn',
+        'updatedBy',
+        'updatedById',
+        'pk',
+        'persistent',
+        'item',
+    ];
+    keysToRemove.forEach((key) => delete object[key]);
+    return object;
+}
+async function getAssortment(ctx, passedAssortmentId, passedAssortmentIdentifier, data) {
+    const assortmentId = passedAssortmentId || extractAssortmentIdFromData(data);
+    if (!assortmentId && !passedAssortmentIdentifier) {
+        throw new Error('No assortmentId or assortmentIdentifier provided.');
+    }
+    return assortmentId
+        ? await fetchAssortmentById(ctx, assortmentId)
+        : await fetchAssortmentByIdentifier(ctx, passedAssortmentIdentifier);
+}
+exports.getAssortment = getAssortment;
+function extractAssortmentIdFromData(data) {
+    return data?.[0]?.assortmentId;
+}
+async function fetchAssortmentById(ctx, assortmentId) {
+    return (0, entities_helper_1.retryOnTimeout)(ctx, entities_helper_1.EntitiesLambdaCallType.GET, {
+        entityName: 'assortment',
+        id: assortmentId,
+        relations: ['assortmentItems'],
+        skipHydrateRelationships: true,
+    });
+}
+async function fetchAssortmentByIdentifier(ctx, identifier) {
+    const assortments = await (0, entities_helper_1.retryOnTimeout)(ctx, entities_helper_1.EntitiesLambdaCallType.GET, {
+        entityName: 'assortment',
+        criteria: { identifier },
+        relations: ['assortmentItems'],
+        skipHydrateRelationships: true,
+    });
+    return assortments?.[0];
+}

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/item-helper.spec.d.ts

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