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

package/node_modules/@contrail/loader/lib/pipeline/assortment-execute-helpers.spec.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const assortment_execute_helpers_1 = require("./assortment-execute-helpers");
+describe('executeAssortmentEntities', () => {
+    let mockClient;
+    const baseConfig = {
+        loadType: [types_1.LoadType.ASSORTMENT],
+    };
+    beforeEach(() => {
+        mockClient = {
+            create: jest.fn().mockResolvedValue({}),
+            update: jest.fn(),
+            get: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn().mockResolvedValue({ data: [], errors: [] }),
+            batchDelete: jest.fn().mockResolvedValue({ data: [], errors: [] }),
+            getAllReferences: jest.fn(),
+        };
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should return empty summaries when no assortmentDetails', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(result.summaries).toEqual([]);
+        expect(result.hasFailures).toBe(false);
+        expect(result.warnings).toContain('No assortment details available for execution.');
+    });
+    it('should return zero-count summary when assortment has no changes', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test Assortment' },
+                    fullSummary: { adds: [], updates: [], deletes: [], unchanged: [] },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(result.summaries).toHaveLength(1);
+        expect(result.summaries[0]).toEqual(expect.objectContaining({
+            entityType: 'assortment-item',
+            created: 0,
+            updated: 0,
+            dropped: 0,
+            targetName: 'Test Assortment',
+            targetId: 'assort-1',
+        }));
+        expect(mockClient.create).not.toHaveBeenCalled();
+        expect(mockClient.batchUpdate).not.toHaveBeenCalled();
+        expect(mockClient.batchDelete).not.toHaveBeenCalled();
+    });
+    it('should call client.create with assortment relation for adds', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test Assortment' },
+                    fullSummary: {
+                        adds: [{ id: 'item-1' }, { id: 'item-2' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}, {}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(mockClient.create).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'assortment',
+            relation: 'items',
+            id: 'assort-1',
+            object: { itemIds: ['item-1', 'item-2'] },
+        }));
+        expect(result.summaries[0].created).toBe(2);
+        expect(result.summaries[0].targetName).toBe('Test Assortment');
+    });
+    it('should call client.batchUpdate for updates from diffs', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [],
+                        updates: [{ id: 'item-1', diffs: [{ propertyName: 'color', newValue: 'red' }] }],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(mockClient.batchUpdate).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'assortment-item',
+            objects: [{ id: 'assort-1:item-1', changes: { color: 'red' } }],
+        }));
+        expect(result.summaries[0].updated).toBe(1);
+    });
+    it('should call client.batchDelete for deletes with composite IDs', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [],
+                        updates: [],
+                        deletes: [{ id: 'item-1' }, { id: 'item-2' }],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(mockClient.batchDelete).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'assortment-item',
+            ids: ['assort-1:item-1', 'assort-1:item-2'],
+        }));
+        expect(result.summaries[0].dropped).toBe(2);
+    });
+    it('should apply property updates to newly added items', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [{ id: 'item-1', adoptionIntent: true }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(mockClient.create).toHaveBeenCalledTimes(1);
+        expect(mockClient.batchUpdate).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'assortment-item',
+            objects: [{ id: 'assort-1:item-1', changes: { adoptionIntent: true } }],
+        }));
+    });
+    it('should skip property update for adds with only id', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [{ id: 'item-1' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(mockClient.create).toHaveBeenCalledTimes(1);
+        expect(mockClient.batchUpdate).not.toHaveBeenCalled();
+    });
+    it('should capture failures without stopping other operations', async () => {
+        mockClient.create.mockRejectedValue(new Error('Create failed'));
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [{ id: 'item-1' }],
+                        updates: [],
+                        deletes: [{ id: 'item-2' }],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(result.hasFailures).toBe(true);
+        expect(result.summaries[0].failed).toBeGreaterThan(0);
+        expect(result.summaries[0].failures).toEqual(expect.arrayContaining([
+            expect.objectContaining({ operation: 'create', error: 'Create failed' }),
+        ]));
+        expect(mockClient.batchDelete).toHaveBeenCalled();
+    });
+    it('should handle multiple assortments independently', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [
+                {
+                    assortment: { id: 'assort-1', name: 'Assortment A' },
+                    fullSummary: { adds: [{ id: 'item-1' }], updates: [], deletes: [], unchanged: [] },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                },
+                {
+                    assortment: { id: 'assort-2', name: 'Assortment B' },
+                    fullSummary: { adds: [{ id: 'item-2' }, { id: 'item-3' }], updates: [], deletes: [], unchanged: [] },
+                    incomingAssortmentItems: [{}, {}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                },
+            ],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(result.summaries).toHaveLength(2);
+        expect(result.summaries[0]).toEqual(expect.objectContaining({
+            targetName: 'Assortment A',
+            targetId: 'assort-1',
+            created: 1,
+        }));
+        expect(result.summaries[1]).toEqual(expect.objectContaining({
+            targetName: 'Assortment B',
+            targetId: 'assort-2',
+            created: 2,
+        }));
+    });
+    it('should report progress via onProgress callback', async () => {
+        const onProgress = jest.fn();
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: { id: 'assort-1', name: 'Test' },
+                    fullSummary: {
+                        adds: [{ id: 'item-1' }],
+                        updates: [],
+                        deletes: [],
+                        unchanged: [],
+                    },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig, { onProgress });
+        expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({
+            stage: 'execute:assortment-item',
+            total: 1,
+        }));
+    });
+    it('should skip assortment detail with no assortment ID', async () => {
+        const entitySet = {
+            incomingEntities: [],
+            badEntities: [],
+            allCurrentEntitiesByFederatedId: {},
+            typesByPath: {},
+            assortmentDetails: [{
+                    assortment: {},
+                    fullSummary: { adds: [{ id: 'item-1' }], updates: [], deletes: [], unchanged: [] },
+                    incomingAssortmentItems: [{}],
+                    badAssortmentItems: [],
+                    unmappedAssortmentItems: [],
+                }],
+        };
+        const result = await (0, assortment_execute_helpers_1.executeAssortmentEntities)(mockClient, entitySet, baseConfig);
+        expect(result.summaries).toHaveLength(0);
+        expect(result.warnings).toContain('Skipping assortment detail with no assortment ID.');
+        expect(mockClient.create).not.toHaveBeenCalled();
+    });
+});

package/node_modules/@contrail/loader/lib/pipeline/coerce-values-by-type.d.ts

@@ -0,0 +1,7 @@
+import { TypePropertyMaps } from '../common/data-transformer-functions';
+import { PreprocessingStepSummary } from './types';
+export interface CoercionResult {
+    rows: Record<string, any>[];
+    summary: PreprocessingStepSummary;
+}
+export declare function coerceValuesByType(rows: Record<string, any>[], typePropertyMaps: TypePropertyMaps): CoercionResult;

package/node_modules/@contrail/loader/lib/pipeline/coerce-values-by-type.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceValuesByType = void 0;
+const constants_1 = require("../common/constants");
+const BOOLEAN_TRUE = new Set(['true', 'yes', 'y', '1']);
+const BOOLEAN_FALSE = constants_1.FALSY_VALUES;
+const NUMERIC_TYPES = new Set(['number', 'currency', 'percent', 'sequence']);
+const MONTH_NAMES = {
+    jan: 0, january: 0,
+    feb: 1, february: 1,
+    mar: 2, march: 2,
+    apr: 3, april: 3,
+    may: 4,
+    jun: 5, june: 5,
+    jul: 6, july: 6,
+    aug: 7, august: 7,
+    sep: 8, september: 8,
+    oct: 9, october: 9,
+    nov: 10, november: 10,
+    dec: 11, december: 11,
+};
+function coerceValuesByType(rows, typePropertyMaps) {
+    const { typePropertiesBySlug } = typePropertyMaps;
+    const result = rows.map((row) => {
+        const coerced = { ...row };
+        for (const key of Object.keys(coerced)) {
+            const property = resolveProperty(key, typePropertiesBySlug);
+            if (!property)
+                continue;
+            const value = coerced[key];
+            if (value === null || value === undefined)
+                continue;
+            const propertyType = property.propertyType;
+            if (propertyType === 'boolean') {
+                coerced[key] = coerceBoolean(value);
+            }
+            else if (NUMERIC_TYPES.has(propertyType)) {
+                coerced[key] = coerceNumber(value);
+            }
+            else if (propertyType === 'date') {
+                coerced[key] = coerceDate(value);
+            }
+        }
+        return coerced;
+    });
+    return {
+        rows: result,
+        summary: {
+            stepName: 'Coerce Values by Type',
+            rowCountAfter: result.length,
+            errorCount: 0,
+            warningCount: 0,
+        },
+    };
+}
+exports.coerceValuesByType = coerceValuesByType;
+function resolveProperty(key, typePropertiesBySlug) {
+    const direct = typePropertiesBySlug[key];
+    if (direct)
+        return direct;
+    if (key.endsWith('Family') || key.endsWith('Option')) {
+        const base = key.replace(/(Family|Option)$/, '');
+        return typePropertiesBySlug[base] || null;
+    }
+    return null;
+}
+function coerceBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value !== 'string')
+        return value;
+    const lower = value.toLowerCase().trim();
+    if (lower === '')
+        return value;
+    if (BOOLEAN_TRUE.has(lower))
+        return true;
+    if (BOOLEAN_FALSE.has(lower))
+        return false;
+    return value;
+}
+function coerceNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return value;
+    const cleaned = trimmed
+        .replace(/[$,\\"]/g, '')
+        .trim();
+    const parsed = Number(cleaned);
+    if (!isNaN(parsed))
+        return parsed;
+    return value;
+}
+function coerceDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return value;
+    if (/^\d{4}-\d{2}-\d{2}/.test(trimmed))
+        return value;
+    const slashMatch = trimmed.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+    if (slashMatch) {
+        return formatISODate(parseInt(slashMatch[3]), parseInt(slashMatch[1]), parseInt(slashMatch[2]));
+    }
+    const dashMDYMatch = trimmed.match(/^(\d{1,2})-(\d{1,2})-(\d{4})$/);
+    if (dashMDYMatch) {
+        return formatISODate(parseInt(dashMDYMatch[3]), parseInt(dashMDYMatch[1]), parseInt(dashMDYMatch[2]));
+    }
+    const dMyMatch = trimmed.match(/^(\d{1,2})[\s-](\w+)[\s-](\d{4})$/);
+    if (dMyMatch) {
+        const month = MONTH_NAMES[dMyMatch[2].toLowerCase()];
+        if (month !== undefined) {
+            return formatISODate(parseInt(dMyMatch[3]), month + 1, parseInt(dMyMatch[1]));
+        }
+    }
+    const longMatch = trimmed.match(/^(\w+)\s+(\d{1,2}),?\s+(\d{4})$/);
+    if (longMatch) {
+        const month = MONTH_NAMES[longMatch[1].toLowerCase()];
+        if (month !== undefined) {
+            return formatISODate(parseInt(longMatch[3]), month + 1, parseInt(longMatch[2]));
+        }
+    }
+    return value;
+}
+function formatISODate(year, month, day) {
+    return `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+}

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

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