@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/pipeline/execute-multi-type.spec.js

@@ -0,0 +1,454 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const execute_1 = require("./execute");
+const entity_processor_v2_1 = require("../entities-v2/entity-processor-v2");
+const item_execute_helpers_1 = require("./item-execute-helpers");
+const project_item_execute_helpers_1 = require("./project-item-execute-helpers");
+const assortment_execute_helpers_1 = require("./assortment-execute-helpers");
+jest.mock('../entities-v2/entity-processor-v2');
+jest.mock('./item-execute-helpers', () => ({
+    ...jest.requireActual('./item-execute-helpers'),
+    executeItemEntities: jest.fn(),
+}));
+jest.mock('./project-item-execute-helpers', () => ({
+    ...jest.requireActual('./project-item-execute-helpers'),
+    executeProjectItemEntities: jest.fn(),
+}));
+jest.mock('./assortment-execute-helpers', () => ({
+    ...jest.requireActual('./assortment-execute-helpers'),
+    executeAssortmentEntities: jest.fn(),
+}));
+const mockExecuteItemEntities = item_execute_helpers_1.executeItemEntities;
+const mockExecuteProjectItemEntities = project_item_execute_helpers_1.executeProjectItemEntities;
+const mockExecuteAssortmentEntities = assortment_execute_helpers_1.executeAssortmentEntities;
+const mockSetupEntities = entity_processor_v2_1.EntityProcessorV2.setupEntities;
+describe('execute (multi-entity-type loads)', () => {
+    let mockClient;
+    const makeAnalysis = () => ({
+        columns: [],
+        unmappedTypeProperties: [],
+        typePropertyMaps: {
+            typePropertiesBySlug: {},
+            typePropertiesByLabel: {},
+            optionSetUsingTypePropertiesBySlug: {},
+        },
+        typesByPath: {},
+    });
+    const successResult = () => ({
+        summaries: [{ entityType: 'item', created: 2, updated: 0, dropped: 0, skippedStale: 0, failed: 0, failures: [] }],
+        skippedRows: [],
+        warnings: [],
+        hasFailures: false,
+    });
+    beforeEach(() => {
+        mockClient = {
+            create: jest.fn(),
+            update: jest.fn(),
+            get: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn().mockResolvedValue({ data: [], errors: [] }),
+            batchUpdate: jest.fn().mockResolvedValue({ data: [], errors: [] }),
+            batchDelete: jest.fn(),
+            getAllReferences: jest.fn(),
+        };
+        mockExecuteItemEntities.mockResolvedValue(successResult());
+        mockExecuteProjectItemEntities.mockResolvedValue({
+            summaries: [{ entityType: 'project-item', created: 2, updated: 0, dropped: 0, skippedStale: 0, failed: 0, failures: [] }],
+            skippedRows: [],
+            warnings: [],
+            hasFailures: false,
+        });
+        mockExecuteAssortmentEntities.mockResolvedValue({
+            summaries: [{ entityType: 'assortment-item', created: 2, updated: 0, dropped: 0, skippedStale: 0, failed: 0, failures: [] }],
+            skippedRows: [],
+            warnings: [],
+            hasFailures: false,
+        });
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should execute all three entity types and produce a complete result', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [
+                { federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' },
+                { federatedId: 'fam-2', itemFamilyFederatedId: 'fam-2', name: 'Family 2' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const staleProjectItemEntitySet = {
+            incomingEntities: [
+                { federatedId: 'fam-1', projectId: 'proj-1', itemFamilyFederatedId: 'fam-1' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {
+                'fam-1': { id: 'pending:fam-1', federatedId: 'fam-1' },
+            },
+            typesByPath: {},
+        };
+        const staleAssortmentEntitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    fullSummary: {
+                        adds: [{ id: 'pending:fam-1' }, { id: 'pending:fam-2' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    assortment: { id: 'assortment-1', name: 'Test Assortment' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+                [types_1.EntityType.PROJECT_ITEM]: staleProjectItemEntitySet,
+                [types_1.EntityType.ASSORTMENT]: staleAssortmentEntitySet,
+            },
+        };
+        const freshProjectItemResult = {
+            incomingEntities: [
+                { federatedId: 'fam-1', projectId: 'proj-1', itemFamilyFederatedId: 'fam-1' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {
+                'fam-1': { id: 'real-db-id-1', federatedId: 'fam-1' },
+            },
+            typesByPath: {},
+            projectId: 'proj-1',
+            generalWarnings: [],
+        };
+        const freshAssortmentResult = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            projectId: null,
+            generalWarnings: [],
+            assortmentDetails: [{
+                    fullSummary: {
+                        adds: [{ id: 'real-db-id-1' }, { id: 'real-db-id-2' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    assortment: { id: 'assortment-1', name: 'Test Assortment' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        mockSetupEntities
+            .mockResolvedValueOnce(freshProjectItemResult)
+            .mockResolvedValueOnce(freshAssortmentResult);
+        const rows = [
+            { federatedId: 'fam-1', name: 'Family 1', projectId: 'proj-1', assortmentId: 'assortment-1' },
+            { federatedId: 'fam-2', name: 'Family 2', projectId: 'proj-1', assortmentId: 'assortment-1' },
+        ];
+        const analysis = makeAnalysis();
+        const result = await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        expect(mockExecuteItemEntities).toHaveBeenCalledTimes(1);
+        expect(mockExecuteProjectItemEntities).toHaveBeenCalledTimes(1);
+        expect(mockExecuteAssortmentEntities).toHaveBeenCalledTimes(1);
+        expect(result.entities).toHaveLength(3);
+        expect(result.status).toBe('complete');
+    });
+    it('should use preview cache for ITEM but reconstruct PROJECT_ITEM and ASSORTMENT', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [{ federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const staleProjectItemEntitySet = {
+            incomingEntities: [{ federatedId: 'fam-1', projectId: 'proj-1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const staleAssortmentEntitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    fullSummary: { adds: [{ id: 'pending:fam-1' }], updates: [], deletes: [], unchanged: [] },
+                    assortment: { id: 'assortment-1', name: 'Test' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+                [types_1.EntityType.PROJECT_ITEM]: staleProjectItemEntitySet,
+                [types_1.EntityType.ASSORTMENT]: staleAssortmentEntitySet,
+            },
+        };
+        mockSetupEntities
+            .mockResolvedValueOnce({
+            incomingEntities: [{ federatedId: 'fam-1', projectId: 'proj-1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            projectId: 'proj-1',
+            generalWarnings: [],
+        })
+            .mockResolvedValueOnce({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            generalWarnings: [],
+            assortmentDetails: [{
+                    fullSummary: { adds: [{ id: 'real-db-id-1' }], updates: [], deletes: [], unchanged: [] },
+                    assortment: { id: 'assortment-1', name: 'Test' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        });
+        const rows = [{ federatedId: 'fam-1', name: 'Family 1' }];
+        const analysis = makeAnalysis();
+        await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        expect(mockSetupEntities).toHaveBeenCalledTimes(2);
+        expect(mockExecuteItemEntities).toHaveBeenCalledWith(mockClient, itemEntitySet, config, undefined);
+        expect(mockSetupEntities).toHaveBeenCalledWith(mockClient, types_1.EntityType.PROJECT_ITEM, expect.any(Array), undefined, expect.anything(), {}, true);
+        expect(mockSetupEntities).toHaveBeenCalledWith(mockClient, types_1.EntityType.ASSORTMENT, expect.any(Array), undefined, expect.anything(), {}, false);
+    });
+    it('should not pass pending: IDs to assortment execution in a multi-type load', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [
+                { federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' },
+            ],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const staleAssortmentEntitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    fullSummary: {
+                        adds: [{ id: 'pending:fam-1' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    assortment: { id: 'assortment-1', name: 'Test Assortment' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+                [types_1.EntityType.ASSORTMENT]: staleAssortmentEntitySet,
+            },
+        };
+        mockSetupEntities.mockResolvedValue({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            generalWarnings: [],
+            assortmentDetails: [{
+                    fullSummary: {
+                        adds: [{ id: 'real-db-id-1' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    assortment: { id: 'assortment-1', name: 'Test Assortment' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        });
+        const rows = [{ federatedId: 'fam-1', name: 'Family 1', assortmentId: 'assortment-1' }];
+        const analysis = makeAnalysis();
+        await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        const assortmentCallArgs = mockExecuteAssortmentEntities.mock.calls[0];
+        const entitySetPassedToAssortment = assortmentCallArgs[1];
+        const addIds = entitySetPassedToAssortment.assortmentDetails[0].fullSummary.adds.map((a) => a.id);
+        expect(addIds).not.toContain('pending:fam-1');
+        expect(addIds).toContain('real-db-id-1');
+    });
+    it('should execute ITEM before dependent types (sequential ordering)', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.PROJECT_ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [{ federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+            },
+        };
+        mockSetupEntities.mockResolvedValue({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            generalWarnings: [],
+            assortmentDetails: [],
+        });
+        const executionOrder = [];
+        mockExecuteItemEntities.mockImplementation(async () => {
+            executionOrder.push('ITEM');
+            return successResult();
+        });
+        mockExecuteProjectItemEntities.mockImplementation(async () => {
+            executionOrder.push('PROJECT_ITEM');
+            return { summaries: [], skippedRows: [], warnings: [], hasFailures: false };
+        });
+        mockExecuteAssortmentEntities.mockImplementation(async () => {
+            executionOrder.push('ASSORTMENT');
+            return { summaries: [], skippedRows: [], warnings: [], hasFailures: false };
+        });
+        const rows = [{ federatedId: 'fam-1', name: 'Family 1' }];
+        const analysis = makeAnalysis();
+        await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        expect(executionOrder[0]).toBe('ITEM');
+        expect(executionOrder).toContain('PROJECT_ITEM');
+        expect(executionOrder).toContain('ASSORTMENT');
+        expect(executionOrder.indexOf('ITEM')).toBeLessThan(executionOrder.indexOf('PROJECT_ITEM'));
+        expect(executionOrder.indexOf('ITEM')).toBeLessThan(executionOrder.indexOf('ASSORTMENT'));
+    });
+    it('should handle ITEM + ASSORTMENT without PROJECT_ITEM (partial multi-type)', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [{ federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+            },
+        };
+        mockSetupEntities.mockResolvedValue({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            generalWarnings: [],
+            assortmentDetails: [{
+                    fullSummary: { adds: [{ id: 'real-id-1' }], updates: [], deletes: [], unchanged: [] },
+                    assortment: { id: 'assortment-1', name: 'Test' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        });
+        const rows = [{ federatedId: 'fam-1', name: 'Family 1', assortmentId: 'assortment-1' }];
+        const analysis = makeAnalysis();
+        const result = await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        expect(mockExecuteItemEntities).toHaveBeenCalledTimes(1);
+        expect(mockExecuteProjectItemEntities).not.toHaveBeenCalled();
+        expect(mockExecuteAssortmentEntities).toHaveBeenCalledTimes(1);
+        expect(result.entities).toHaveLength(2);
+        expect(result.status).toBe('complete');
+    });
+    it('should propagate failures from ITEM execution into the overall result', async () => {
+        const config = {
+            loadType: [types_1.LoadType.ITEM, types_1.LoadType.ASSORTMENT],
+        };
+        const itemEntitySet = {
+            incomingEntities: [{ federatedId: 'fam-1', itemFamilyFederatedId: 'fam-1', name: 'Family 1' }],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+        };
+        const previewData = {
+            entities: [],
+            badRows: [],
+            staleRows: [],
+            warnings: [],
+            constructedEntities: {
+                [types_1.EntityType.ITEM]: itemEntitySet,
+            },
+        };
+        mockExecuteItemEntities.mockResolvedValue({
+            summaries: [{
+                    entityType: 'item',
+                    created: 0,
+                    updated: 0,
+                    dropped: 0,
+                    skippedStale: 0,
+                    failed: 1,
+                    failures: [{ federatedId: 'fam-1', operation: 'create', error: 'API error' }],
+                }],
+            skippedRows: [],
+            warnings: [],
+            hasFailures: true,
+        });
+        mockSetupEntities.mockResolvedValue({
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            generalWarnings: [],
+            assortmentDetails: [{
+                    fullSummary: { adds: [], updates: [], deletes: [], unchanged: [] },
+                    assortment: { id: 'assortment-1', name: 'Test' },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        });
+        const rows = [{ federatedId: 'fam-1', name: 'Family 1', assortmentId: 'assortment-1' }];
+        const analysis = makeAnalysis();
+        const result = await (0, execute_1.execute)(mockClient, rows, config, analysis, undefined, previewData);
+        expect(mockExecuteAssortmentEntities).toHaveBeenCalledTimes(1);
+        expect(result.status).toBe('partial-failure');
+    });
+});

package/node_modules/@contrail/loader/lib/pipeline/execute.d.ts

@@ -0,0 +1,3 @@
+import { EntitiesClient } from '@contrail/entity-types';
+import { LoaderConfig, ColumnAnalysisResult, ExecuteOptions, ExecutionResult, PreviewResult } from './types';
+export declare function execute(client: EntitiesClient, rows: Record<string, any>[], config: LoaderConfig, columnAnalysis: ColumnAnalysisResult, options?: ExecuteOptions, previewData?: PreviewResult): Promise<ExecutionResult>;