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

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/partial-assortment-processor.d.ts

@@ -0,0 +1,35 @@
+import { EntitiesClient, EntityType } from '@contrail/entity-types';
+import { PartialAssortmentLoadOperation } from './assortment-processor';
+import { EntityComparisonSummary } from '@contrail/entity-compare';
+import { BaseProcessorV2 } from '../base-processor-v2';
+import { Type } from '@contrail/types';
+export declare class PartialAssortmentProcessor extends BaseProcessorV2 {
+    static requiredProperties: string[];
+    static loadCSVJson(partialLoadOperation: PartialAssortmentLoadOperation, client: EntitiesClient, itemsByFederatedId: any, typesByTypePath?: Record<string, Type>): Promise<{
+        badAssortmentItems: any[];
+        assortment: any;
+        fullSummary: EntityComparisonSummary;
+        incomingAssortmentItems: any[];
+    }>;
+    private static logBadItems;
+    static loadObjects(requiredProperties: string[], loadOperation: PartialAssortmentLoadOperation, client: EntitiesClient, passedItemsByFederatedId: any, typesByTypePath?: Record<string, Type>): Promise<{
+        badAssortmentItems: any[];
+        assortment: any;
+        fullSummary: EntityComparisonSummary;
+        incomingAssortmentItems: any[];
+    }>;
+    private static getTargetAssortment;
+    private static fetchAssortmentById;
+    private static fetchAssortmentByIdentifier;
+    private static processRows;
+    private static processAssortmentItemRow;
+    private static getItemsByFederatedId;
+    private static mapAndHydrateItems;
+    private static getFamilyIdsToRemove;
+    private static getAllFamilyIdsAndOptions;
+    private static filterOperationsByCurrentAssortment;
+    private static getPartialUpdateSummary;
+    private static logSummary;
+    private static processComparableEntitiesProperties;
+    static getEntityTypeForFederatedId(entityType: EntityType): EntityType;
+}

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialAssortmentProcessor = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const item_helper_1 = require("./item-helper");
+const entities_helper_1 = require("../../common/entities-helper");
+const entity_builder_helpers_1 = require("../../common/entity-builder-helpers");
+const entity_compare_1 = require("@contrail/entity-compare");
+const lodash_1 = require("lodash");
+const base_processor_v2_1 = require("../base-processor-v2");
+class PartialAssortmentProcessor extends base_processor_v2_1.BaseProcessorV2 {
+    static requiredProperties = ['itemOptionFederatedId', 'itemFamilyFederatedId', 'assortmentId'];
+    static async loadCSVJson(partialLoadOperation, client, itemsByFederatedId, typesByTypePath) {
+        try {
+            console.info('Start loading Assortment-Items: ', new Date(), partialLoadOperation);
+            const result = await this.loadObjects(this.requiredProperties, partialLoadOperation, client, itemsByFederatedId, typesByTypePath);
+            this.logBadItems(result.badAssortmentItems);
+            return result;
+        }
+        catch (error) {
+            console.error('Error in loading Assortment-Items:', error);
+            throw error;
+        }
+    }
+    static logBadItems(badItems) {
+        if (badItems?.length) {
+            console.warn('Assortment-Items missing required properties:', badItems);
+        }
+    }
+    static async loadObjects(requiredProperties, loadOperation, client, passedItemsByFederatedId, typesByTypePath) {
+        const targetAssortment = await this.getTargetAssortment(client, loadOperation.assortmentId, loadOperation.assortmentIdentifier, loadOperation.rowsToAdd);
+        if (!targetAssortment) {
+            const errorMessage = 'Target Assortment not found.';
+            console.error(errorMessage);
+            throw new Error(errorMessage);
+        }
+        const currentAssortmentItems = await (0, item_helper_1.getAssortmentItems)(targetAssortment);
+        console.debug('Got current assortment-items: ', currentAssortmentItems?.length);
+        targetAssortment.assortmentItems = currentAssortmentItems;
+        const { allPropertiesSlugs, typePropertyToValueType } = await (0, item_helper_1.getAssortmentItemProperties)(client, requiredProperties, typesByTypePath);
+        const processedRows = this.processRows(loadOperation, allPropertiesSlugs, typePropertyToValueType);
+        const itemsByFederatedId = await this.getItemsByFederatedId(client, passedItemsByFederatedId, processedRows.incomingAssortmentItems);
+        const completeIncomingItems = this.mapAndHydrateItems(loadOperation, itemsByFederatedId);
+        this.getAllFamilyIdsAndOptions(currentAssortmentItems, itemsByFederatedId);
+        const { validAdds, validDrops, validUpdates } = this.filterOperationsByCurrentAssortment(currentAssortmentItems, loadOperation);
+        loadOperation = { ...loadOperation, rowsToAdd: validAdds, rowsToDrop: validDrops, rowsToUpdate: validUpdates };
+        console.debug('Add Row Count: ', loadOperation.rowsToAdd?.length);
+        console.debug('Drop Row Count: ', loadOperation.rowsToDrop?.length);
+        console.debug('Update Row Count: ', loadOperation.rowsToUpdate?.length);
+        const fullSummary = this.getPartialUpdateSummary(loadOperation, currentAssortmentItems, allPropertiesSlugs, processedRows.familyIdsToRemove);
+        this.logSummary(fullSummary);
+        delete fullSummary.unchanged;
+        return {
+            badAssortmentItems: processedRows.badItems,
+            assortment: targetAssortment,
+            fullSummary,
+            incomingAssortmentItems: completeIncomingItems,
+        };
+    }
+    static async getTargetAssortment(client, assortmentId, assortmentIdentifier, rows) {
+        if (!assortmentId && rows?.length > 0) {
+            assortmentId = rows[0].assortmentId;
+        }
+        if (!assortmentId && !assortmentIdentifier) {
+            const errorMessage = 'No assortmentId or assortmentIdentifier provided.';
+            console.error(errorMessage);
+            throw new Error(errorMessage);
+        }
+        return assortmentId
+            ? await this.fetchAssortmentById(client, assortmentId)
+            : await this.fetchAssortmentByIdentifier(client, assortmentIdentifier);
+    }
+    static async fetchAssortmentById(client, assortmentId) {
+        console.debug('Getting assortment-items for ', assortmentId);
+        return (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+            entityName: 'assortment',
+            id: assortmentId,
+            relations: ['assortmentItems'],
+            skipHydrateRelationships: true,
+        });
+    }
+    static async fetchAssortmentByIdentifier(client, identifier) {
+        console.debug('Getting assortment-items for assortment identifier ', identifier);
+        const assortments = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+            entityName: 'assortment',
+            criteria: { identifier },
+            relations: ['assortmentItems'],
+            skipHydrateRelationships: true,
+        });
+        return assortments?.[0];
+    }
+    static processRows(loadOperation, allPropertiesSlugs, typePropertyToValueType) {
+        const badItems = [];
+        const incomingAssortmentItems = [];
+        ['rowsToAdd', 'rowsToDrop', 'rowsToUpdate'].forEach((key) => {
+            const { badAssortmentItems, processedAssortmentItems } = this.processAssortmentItemRow(loadOperation[key], allPropertiesSlugs, typePropertyToValueType);
+            badItems.push(...badAssortmentItems);
+            loadOperation[key] = processedAssortmentItems;
+            incomingAssortmentItems.push(...processedAssortmentItems);
+        });
+        const familyIdsToRemove = this.getFamilyIdsToRemove(incomingAssortmentItems);
+        return { badItems, incomingAssortmentItems, familyIdsToRemove };
+    }
+    static processAssortmentItemRow(rows, allPropertiesSlugs, typePropertyToValueType) {
+        const badAssortmentItems = [];
+        const processedAssortmentItems = [];
+        for (const row of rows) {
+            if (!row.itemFamilyFederatedId) {
+                badAssortmentItems.push(row);
+                continue;
+            }
+            const assortmentItem = {};
+            for (const propertyName in row) {
+                (0, entity_builder_helpers_1.addProperty)(propertyName, allPropertiesSlugs, typePropertyToValueType[propertyName], assortmentItem, row[propertyName]);
+            }
+            processedAssortmentItems.push(assortmentItem);
+        }
+        return { badAssortmentItems, processedAssortmentItems };
+    }
+    static async getItemsByFederatedId(client, itemsByFederatedId, incomingAssortmentItems) {
+        if (!Object.keys(itemsByFederatedId)?.length && incomingAssortmentItems.length) {
+            return (0, item_helper_1.getItemsFromFederatedIds)(client, incomingAssortmentItems);
+        }
+        return itemsByFederatedId;
+    }
+    static mapAndHydrateItems(loadOperation, itemsByFederatedId) {
+        const completeIncomingItems = [];
+        const unmappedItems = [];
+        ['rowsToAdd', 'rowsToDrop', 'rowsToUpdate'].forEach((key) => {
+            const { completeIncomingAssortmentItems, unmappedAssortmentItems } = (0, item_helper_1.mapAssortmentItemsToItemsAndFillItemId)(loadOperation[key], itemsByFederatedId);
+            completeIncomingItems.push(...completeIncomingAssortmentItems);
+            unmappedItems.push(...unmappedAssortmentItems);
+        });
+        console.debug(`unmappedAssortmentItems: ${unmappedItems?.length}`);
+        return completeIncomingItems;
+    }
+    static getFamilyIdsToRemove(incomingAssortmentItems) {
+        const familyIds = (0, lodash_1.groupBy)(incomingAssortmentItems, 'itemFamilyFederatedId');
+        return Object.keys(familyIds).filter((id) => familyIds[id].some((item) => item.itemOptionFederatedId));
+    }
+    static getAllFamilyIdsAndOptions(completeIncomingAssortmentItems, itemsByFederatedId) {
+        const assortmentOptionItemsByFamilyFedId = {};
+        for (const completeIncomingAssortmentItem of completeIncomingAssortmentItems) {
+            const itemOptionFederatedId = completeIncomingAssortmentItem.itemOptionFederatedId;
+            const itemFamilyFederatedId = completeIncomingAssortmentItem.itemFamilyFederatedId;
+            if (!itemOptionFederatedId && itemFamilyFederatedId) {
+                delete completeIncomingAssortmentItem.itemFamilyFederatedId;
+            }
+            else if (itemOptionFederatedId && itemFamilyFederatedId) {
+                if (!assortmentOptionItemsByFamilyFedId[itemFamilyFederatedId]) {
+                    assortmentOptionItemsByFamilyFedId[itemFamilyFederatedId] = [];
+                }
+                delete completeIncomingAssortmentItem.itemOptionFederatedId;
+                delete completeIncomingAssortmentItem.itemFamilyFederatedId;
+                assortmentOptionItemsByFamilyFedId[itemFamilyFederatedId].push(completeIncomingAssortmentItem);
+            }
+        }
+        const familyFederatedIdsToRemove = Object.keys(assortmentOptionItemsByFamilyFedId);
+        console.debug(`familyFederatedIdsToRemove: ${familyFederatedIdsToRemove?.length}`);
+        const familyIdsToRemove = familyFederatedIdsToRemove.map((fedId) => itemsByFederatedId[fedId]?.id);
+        console.debug(`familyIdsToRemove: ${familyIdsToRemove?.length}`);
+        console.debug(`Assortment-Item hydration complete. ${completeIncomingAssortmentItems?.length} complete incomingAssortmentItems`);
+    }
+    static filterOperationsByCurrentAssortment(currentAssortmentItems, loadOperation) {
+        const currentItemIds = new Set(currentAssortmentItems.map((item) => item.itemId));
+        const { rowsToAdd, rowsToDrop, rowsToUpdate } = loadOperation;
+        const validAdds = rowsToAdd.filter((row) => row.itemId && !currentItemIds.has(row.itemId));
+        const addsAlreadyExist = rowsToAdd.filter((row) => row.itemId && currentItemIds.has(row.itemId));
+        const validUpdates = rowsToUpdate.filter((row) => row.itemId && currentItemIds.has(row.itemId));
+        const validDrops = rowsToDrop.filter((row) => row.itemId && currentItemIds.has(row.itemId));
+        const allValidUpdates = [...validUpdates, ...addsAlreadyExist];
+        return {
+            validAdds,
+            validDrops,
+            validUpdates: allValidUpdates,
+        };
+    }
+    static getPartialUpdateSummary(loadOperation, currentAssortmentItems, allPropertiesSlugs, familyIdsToRemove) {
+        const comparableEntitiesAdds = (0, item_helper_1.convertToComparableEntities)(loadOperation.rowsToAdd, allPropertiesSlugs, 'itemId');
+        const comparableEntitiesDrop = (0, item_helper_1.convertToComparableEntities)(loadOperation.rowsToDrop, allPropertiesSlugs, 'itemId');
+        const comparableEntitiesUpdate = (0, item_helper_1.convertToComparableEntities)(loadOperation.rowsToUpdate, allPropertiesSlugs, 'itemId');
+        const targetAssortmentComparableEntities = (0, item_helper_1.convertToComparableEntities)(currentAssortmentItems, allPropertiesSlugs, 'itemId');
+        console.debug(`comparableEntitiesUpdate count: ${comparableEntitiesUpdate?.length}`);
+        console.debug(`targetAssortmentComparableEntities count: ${targetAssortmentComparableEntities?.length}`);
+        for (const entityList of [
+            comparableEntitiesAdds,
+            comparableEntitiesDrop,
+            comparableEntitiesUpdate,
+            targetAssortmentComparableEntities,
+            targetAssortmentComparableEntities,
+        ]) {
+            this.processComparableEntitiesProperties(entityList);
+        }
+        const updatesSummary = (0, entity_compare_1.compareEntityCollections)(targetAssortmentComparableEntities, comparableEntitiesUpdate, 'id');
+        const updatesMap = {};
+        const unchangedMap = {};
+        for (const update of updatesSummary.updates) {
+            updatesMap[update.id] = update;
+        }
+        for (const unchanged of updatesSummary.unchanged) {
+            unchangedMap[unchanged.id] = unchanged;
+        }
+        const removedFamilyUpdates = [];
+        const removedFamilyUnchanged = [];
+        for (const familyIdToRemove of familyIdsToRemove) {
+            if (updatesMap[familyIdToRemove]) {
+                removedFamilyUpdates.push(updatesMap[familyIdToRemove]);
+                delete updatesMap[familyIdToRemove];
+            }
+            if (unchangedMap[familyIdToRemove]) {
+                removedFamilyUnchanged.push(unchangedMap[familyIdToRemove]);
+                delete unchangedMap[familyIdToRemove];
+            }
+        }
+        console.debug('Removed Family Updates: ', JSON.stringify(removedFamilyUpdates));
+        console.debug('Removed Family Unchanged: ', JSON.stringify(removedFamilyUnchanged));
+        const summary = {};
+        summary.adds = comparableEntitiesAdds;
+        summary.updates = Object.values(updatesMap);
+        summary.deletes = comparableEntitiesDrop;
+        summary.unchanged = Object.values(unchangedMap);
+        return summary;
+    }
+    static logSummary(summary) {
+        console.info(`Total Adds: ${summary.adds?.length}`);
+        console.info(`Total Deletes: ${summary.deletes?.length}`);
+        console.info(`Total Updates: ${summary.updates?.length}`);
+        console.info(`Total Unchanged: ${summary.unchanged?.length}`);
+    }
+    static processComparableEntitiesProperties(incomingAssortmentComparableEntities) {
+        for (const incomingAssortmentComparableEntity of incomingAssortmentComparableEntities) {
+            const incomingKeys = Object.keys(incomingAssortmentComparableEntity);
+            for (const key of incomingKeys) {
+                (0, entities_helper_1.parseDateOrNumberKey)(incomingAssortmentComparableEntity, key);
+            }
+        }
+    }
+    static getEntityTypeForFederatedId(entityType) {
+        return entity_types_1.EntityType.ITEM;
+    }
+}
+exports.PartialAssortmentProcessor = PartialAssortmentProcessor;

package/node_modules/@contrail/loader/lib/entities-v2/linesheet-v2/partial-assortment-processor.spec.d.ts

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

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const partial_assortment_processor_1 = require("./partial-assortment-processor");
+const item_helper_1 = require("./item-helper");
+const entities_helper_1 = require("../../common/entities-helper");
+jest.mock('./item-helper', () => ({
+    getAssortmentItemProperties: jest.fn(),
+    getAssortmentItems: jest.fn(),
+    getItemsFromFederatedIds: jest.fn(),
+    mapAssortmentItemsToItemsAndFillItemId: jest.fn(),
+}));
+jest.mock('../../common/entities-helper', () => ({
+    retryOnTimeout: jest.fn(),
+    EntitiesLambdaCallType: {
+        GET: 'GET',
+    },
+}));
+jest.mock('@contrail/entity-compare', () => ({
+    compareEntityCollections: jest.fn(),
+}));
+jest.mock('lodash', () => ({
+    groupBy: jest.fn(),
+}));
+describe('PartialAssortmentProcessor', () => {
+    let client;
+    beforeEach(() => {
+        client = {};
+        jest.clearAllMocks();
+    });
+    describe('loadObjects', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        it('should process rows and return the result', async () => {
+            const mockLoadOperation = {
+                rowsToAdd: [{ itemFamilyFederatedId: 'mockId1' }],
+                rowsToDrop: [],
+                rowsToUpdate: [],
+            };
+            const mockItemsByFederatedId = {};
+            const mockTargetAssortment = { id: 'mockAssortmentId' };
+            const mockCurrentAssortmentItems = [{ itemId: 'mockItemId' }];
+            const mockProperties = {
+                allPropertiesSlugs: ['mockProperty'],
+                typePropertyToValueType: { mockProperty: 'string' },
+            };
+            const mockProcessedRows = {
+                badItems: [],
+                incomingAssortmentItems: [{ itemId: 'mockItemId' }],
+                familyIdsToRemove: [],
+            };
+            const mockCompleteIncomingItems = [{ itemId: 'mockItemId' }];
+            const mockSummary = {
+                adds: [],
+                deletes: [],
+                updates: [],
+                unchanged: [],
+            };
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'getTargetAssortment').mockResolvedValue(mockTargetAssortment);
+            item_helper_1.getAssortmentItems.mockResolvedValue(mockCurrentAssortmentItems);
+            item_helper_1.getAssortmentItemProperties.mockResolvedValue(mockProperties);
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'processRows').mockReturnValue(mockProcessedRows);
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'getItemsByFederatedId').mockResolvedValue(mockItemsByFederatedId);
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'mapAndHydrateItems').mockReturnValue(mockCompleteIncomingItems);
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'filterOperationsByCurrentAssortment').mockReturnValue({
+                validAdds: mockLoadOperation.rowsToAdd,
+                validDrops: mockLoadOperation.rowsToDrop,
+                validUpdates: mockLoadOperation.rowsToUpdate,
+            });
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'getPartialUpdateSummary').mockReturnValue(mockSummary);
+            const logSummarySpy = jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'logSummary');
+            const result = await partial_assortment_processor_1.PartialAssortmentProcessor.loadObjects(partial_assortment_processor_1.PartialAssortmentProcessor.requiredProperties, mockLoadOperation, client, mockItemsByFederatedId);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['getTargetAssortment']).toHaveBeenCalledWith(client, undefined, undefined, mockLoadOperation.rowsToAdd);
+            expect(item_helper_1.getAssortmentItems).toHaveBeenCalledWith(mockTargetAssortment);
+            expect(item_helper_1.getAssortmentItemProperties).toHaveBeenCalledWith(client, partial_assortment_processor_1.PartialAssortmentProcessor.requiredProperties, undefined);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['processRows']).toHaveBeenCalledWith(mockLoadOperation, mockProperties.allPropertiesSlugs, mockProperties.typePropertyToValueType);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['getItemsByFederatedId']).toHaveBeenCalledWith(client, mockItemsByFederatedId, mockProcessedRows.incomingAssortmentItems);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['mapAndHydrateItems']).toHaveBeenCalledWith(mockLoadOperation, mockItemsByFederatedId);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['filterOperationsByCurrentAssortment']).toHaveBeenCalledWith(mockCurrentAssortmentItems, mockLoadOperation);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor['getPartialUpdateSummary']).toHaveBeenCalledWith(mockLoadOperation, mockCurrentAssortmentItems, mockProperties.allPropertiesSlugs, mockProcessedRows.familyIdsToRemove);
+            expect(logSummarySpy).toHaveBeenCalledWith(mockSummary);
+            expect(result).toEqual({
+                badAssortmentItems: mockProcessedRows.badItems,
+                assortment: mockTargetAssortment,
+                fullSummary: mockSummary,
+                incomingAssortmentItems: mockCompleteIncomingItems,
+            });
+        });
+        it('should throw an error if target assortment is not found', async () => {
+            const mockLoadOperation = {
+                rowsToAdd: [],
+                rowsToDrop: [],
+                rowsToUpdate: [],
+            };
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'getTargetAssortment').mockResolvedValue(null);
+            await expect(partial_assortment_processor_1.PartialAssortmentProcessor.loadObjects(partial_assortment_processor_1.PartialAssortmentProcessor.requiredProperties, mockLoadOperation, client, {})).rejects.toThrow('Target Assortment not found.');
+        });
+    });
+    describe('loadCSVJson', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        it('should load objects and log bad items', async () => {
+            const mockPartialLoadOperation = {
+                rowsToAdd: [],
+                rowsToDrop: [],
+                rowsToUpdate: [],
+            };
+            const mockItemsByFederatedId = {};
+            const mockResult = {
+                badAssortmentItems: [],
+                assortment: {},
+                fullSummary: {
+                    adds: [],
+                    updates: [],
+                    deletes: [],
+                    unchanged: [],
+                },
+                incomingAssortmentItems: [],
+            };
+            jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'loadObjects').mockResolvedValue(mockResult);
+            const logBadItemsSpy = jest.spyOn(partial_assortment_processor_1.PartialAssortmentProcessor, 'logBadItems');
+            const result = await partial_assortment_processor_1.PartialAssortmentProcessor.loadCSVJson(mockPartialLoadOperation, client, mockItemsByFederatedId);
+            expect(partial_assortment_processor_1.PartialAssortmentProcessor.loadObjects).toHaveBeenCalledWith(partial_assortment_processor_1.PartialAssortmentProcessor.requiredProperties, mockPartialLoadOperation, client, mockItemsByFederatedId, undefined);
+            expect(logBadItemsSpy).toHaveBeenCalledWith(mockResult.badAssortmentItems);
+            expect(result).toEqual(mockResult);
+        });
+    });
+    describe('getTargetAssortment', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.resetAllMocks();
+            jest.restoreAllMocks();
+        });
+        it('should fetch assortment by ID if assortmentId is provided', async () => {
+            const mockAssortment = { id: 'mockAssortmentId' };
+            entities_helper_1.retryOnTimeout.mockResolvedValue(mockAssortment);
+            const result = await partial_assortment_processor_1.PartialAssortmentProcessor['getTargetAssortment'](client, 'mockAssortmentId', undefined, []);
+            expect(entities_helper_1.retryOnTimeout).toHaveBeenCalledWith(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'assortment',
+                id: 'mockAssortmentId',
+                relations: ['assortmentItems'],
+                skipHydrateRelationships: true,
+            });
+            expect(result).toEqual(mockAssortment);
+        });
+        it('should fetch assortment by identifier if assortmentId is not provided', async () => {
+            const mockAssortments = [{ id: 'mockAssortmentId' }];
+            entities_helper_1.retryOnTimeout.mockResolvedValue(mockAssortments);
+            const result = await partial_assortment_processor_1.PartialAssortmentProcessor['getTargetAssortment'](client, undefined, 'mockIdentifier', []);
+            expect(entities_helper_1.retryOnTimeout).toHaveBeenCalledWith(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+                entityName: 'assortment',
+                criteria: { identifier: 'mockIdentifier' },
+                relations: ['assortmentItems'],
+                skipHydrateRelationships: true,
+            });
+            expect(result).toEqual(mockAssortments[0]);
+        });
+        it('should throw an error if neither assortmentId nor identifier is provided', async () => {
+            await expect(partial_assortment_processor_1.PartialAssortmentProcessor['getTargetAssortment'](client, undefined, undefined, [])).rejects.toThrow('No assortmentId or assortmentIdentifier provided.');
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+import { EntitiesClient, EntityType } from '@contrail/entity-types';
+import { BaseProcessorV2 } from '../base-processor-v2';
+export declare class ProjectItemProcessor extends BaseProcessorV2 {
+    static requiredProperties: string[];
+    static validateRow(row: {
+        itemFamilyFederatedId: string;
+    }): boolean;
+    static getFederatedIdKeys(): string[];
+    static getTypePath(row: any, entityType: any): string;
+    static processEntitiesProperties(client: EntitiesClient, entitySpecificProps: any, data: any[]): Promise<{
+        projectId: string | null;
+    }>;
+    private static getProjectIdFromWorkspace;
+    static setExtraProperties(entity: any, type: any, row?: any): void;
+    static assignExtraItems(client: any, typePaths: any, typesByPath: any, incomingProjectItems: any, projectId: String): Promise<{
+        sizeRangeWarningsAsStringList: string[];
+    }>;
+    static canExtractFederatedIds(itemsByFederatedId: any, incomingEntities: any[]): boolean;
+    static getEntityTypeForFederatedId(entityType: EntityType): EntityType;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectItemProcessor = void 0;
+const entity_types_1 = require("@contrail/entity-types");
+const entities_helper_1 = require("../../common/entities-helper");
+const size_range_helpers_1 = require("../../common/size-range-helpers");
+const base_processor_v2_1 = require("../base-processor-v2");
+class ProjectItemProcessor extends base_processor_v2_1.BaseProcessorV2 {
+    static requiredProperties = ['itemOptionFederatedId', 'itemFamilyFederatedId'];
+    static validateRow(row) {
+        return !!row.itemFamilyFederatedId;
+    }
+    static getFederatedIdKeys() {
+        return ['itemFamilyFederatedId', 'itemOptionFederatedId'];
+    }
+    static getTypePath(row, entityType) {
+        return 'project-item';
+    }
+    static async processEntitiesProperties(client, entitySpecificProps, data) {
+        if (!data?.length)
+            return { projectId: null };
+        const hasWorkspaceIdentifier = data.some((row) => row.workspaceIdentifier);
+        const hasProjectId = data.some((row) => row.projectId);
+        if (hasWorkspaceIdentifier && hasProjectId) {
+            console.error('Rows contain both workspaceIdentifier and projectId columns. Use one or the other, not both.');
+            return { projectId: null };
+        }
+        if (hasProjectId) {
+            const firstProjectId = data.find((row) => row.projectId)?.projectId || null;
+            return { projectId: firstProjectId };
+        }
+        if (hasWorkspaceIdentifier) {
+            const cache = {};
+            for (const row of data) {
+                const wsId = row.workspaceIdentifier;
+                if (!wsId)
+                    continue;
+                if (!(wsId in cache)) {
+                    cache[wsId] = await this.getProjectIdFromWorkspace(client, wsId);
+                }
+                row.projectId = cache[wsId];
+                delete row.workspaceIdentifier;
+            }
+            const firstProjectId = Object.values(cache).find((id) => id != null) || null;
+            return { projectId: firstProjectId };
+        }
+        console.debug('No workspaceIdentifier or projectId column found on project-item rows.');
+        return { projectId: null };
+    }
+    static async getProjectIdFromWorkspace(client, workspaceIdentifier) {
+        const workspaces = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+            entityName: 'workspace',
+            criteria: {
+                identifier: workspaceIdentifier,
+                workspaceType: 'PROJECT',
+            },
+            skipHydrateRelationships: true,
+        });
+        if (!workspaces?.length) {
+            return null;
+        }
+        const workspaceId = workspaces[0]?.id;
+        if (!workspaceId) {
+            return null;
+        }
+        const workspace = await (0, entities_helper_1.retryOnTimeout)(client, entities_helper_1.EntitiesLambdaCallType.GET, {
+            entityName: 'workspace',
+            id: workspaceId,
+            relations: ['project'],
+            skipHydrateRelationships: true,
+        });
+        return workspace?.project?.id || null;
+    }
+    static setExtraProperties(entity, type, row) {
+        entity.typeId = type.type.id;
+        entity.typePath = type.type.typePath;
+        if (row?.projectId) {
+            entity.projectId = row.projectId;
+        }
+    }
+    static async assignExtraItems(client, typePaths, typesByPath, incomingProjectItems, projectId) {
+        await (0, entities_helper_1.assignUserLists)(client, ['project-item'], typesByPath, incomingProjectItems);
+        const sizeRangeSanitizer = new size_range_helpers_1.SizeRangeSanitizer();
+        await sizeRangeSanitizer.sanitizeSizeRanges(client, typesByPath, incomingProjectItems);
+        const sizeRangeWarningsAsStringList = sizeRangeSanitizer.getWarningsAsStringList();
+        if (projectId) {
+            for (const incomingProjectItem of incomingProjectItems) {
+                if (!incomingProjectItem.projectId) {
+                    incomingProjectItem.projectId = projectId;
+                }
+            }
+        }
+        return {
+            sizeRangeWarningsAsStringList,
+        };
+    }
+    static canExtractFederatedIds(itemsByFederatedId, incomingEntities) {
+        return !(Object.keys(itemsByFederatedId)?.length > 0) && incomingEntities.length > 0;
+    }
+    static getEntityTypeForFederatedId(entityType) {
+        return entity_types_1.EntityType.ITEM;
+    }
+}
+exports.ProjectItemProcessor = ProjectItemProcessor;

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

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