@contrail/flexplm 1.7.4-alpha.b9acb47 → 1.7.4

package/lib/interfaces/item-family-changes.d.ts

@@ -12,12 +12,6 @@ export declare class ItemFamilyChanges {
     colorDeletes: string[];
     colorUpdates: string[];
     colorUnchanged: string[];
-    /** Options that changed but are still pre-development. They do NOT produce
-     *  LCSSKUSeasonLink events - they only signal that the family needs republishing. */
-    preDevelopmentOptionChanges: string[];
-    /** True when at least one option row was tracked at family level only, because the option is
-     *  pre-development while the family itself is released. */
-    hasPreDevelopmentOnlyOptions: boolean;
     assortmentItemFullChangeMap: Map<string, any>;
     assortmentItemDeleteMap: Map<string, any>;
     itemToFederatedIdMapping: Map<string, string>;

package/lib/interfaces/item-family-changes.js

@@ -14,12 +14,6 @@ class ItemFamilyChanges {
         this.colorDeletes = [];
         this.colorUpdates = [];
         this.colorUnchanged = [];
-        /** Options that changed but are still pre-development. They do NOT produce
-         *  LCSSKUSeasonLink events - they only signal that the family needs republishing. */
-        this.preDevelopmentOptionChanges = [];
-        /** True when at least one option row was tracked at family level only, because the option is
-         *  pre-development while the family itself is released. */
-        this.hasPreDevelopmentOnlyOptions = false;
         this.assortmentItemFullChangeMap = new Map();
         this.assortmentItemDeleteMap = new Map();
         this.itemToFederatedIdMapping = new Map();
@@ -38,8 +32,6 @@ class ItemFamilyChanges {
         s += ' colorDeletes: [' + this.colorDeletes + ']\n';
         s += ' colorUpdates: [' + this.colorUpdates + ']\n';
         s += ' colorUnchanged: [' + this.colorUnchanged + ']\n';
-        s += ' preDevelopmentOptionChanges: [' + this.preDevelopmentOptionChanges + ']\n';
-        s += ' hasPreDevelopmentOnlyOptions: ' + this.hasPreDevelopmentOnlyOptions + '\n';
         s += 'assortmentItemFullChangeMap:\n';
         s += 'size: ' + this.assortmentItemFullChangeMap.size + '\n[';
         for (const key of this.assortmentItemFullChangeMap.keys()) {

package/lib/publish/base-process-publish-assortment.d.ts

@@ -62,9 +62,6 @@ export declare class BaseProcessPublishAssortment {
     getFullChangeAssortmentMap(fullChange: any): Map<string, object>;
     getDeleteChangesAssortmentMap(deleteChanges: any[]): Map<string, object>;
     getReleasedForDevelopmentItemAndFamilyIds(fullChange: any, deleteChanges: any): string[];
-    /** Adds item families that pass meetsCriteria() but whose option rows are all pre-development.
-     *  Only ever ADDS family ids - never option ids, and never removes anything. */
-    protected addReleasedFamiliesOfPreDevelopmentOptions(aItems: any[], releasedForDevelopmentItemIds: string[]): void;
     meetsCriteria(aItem: any): boolean;
     processPublish(pcd: PublishChangeData, changeDetail: any, fullChange: any, deleteChanges: any): Promise<{
         results: {

package/lib/publish/base-process-publish-assortment.js

@@ -527,34 +527,9 @@ class BaseProcessPublishAssortment {
                 }
             }
         }
-        this.addReleasedFamiliesOfPreDevelopmentOptions(assortmentItemsArray, releasedForDevelopmentItemIds);
-        this.addReleasedFamiliesOfPreDevelopmentOptions(deleteChanges, releasedForDevelopmentItemIds);
         console.info('releasedForDevelopmentItemIds: ' + releasedForDevelopmentItemIds);
         return releasedForDevelopmentItemIds;
     }
-    /** Adds item families that pass meetsCriteria() but whose option rows are all pre-development.
-     *  Only ever ADDS family ids - never option ids, and never removes anything. */
-    addReleasedFamiliesOfPreDevelopmentOptions(aItems, releasedForDevelopmentItemIds) {
-        for (const aItem of (aItems || [])) {
-            const item = aItem?.item;
-            const itemId = item?.id;
-            const itemFamilyId = item?.itemFamilyId;
-            if (!itemFamilyId || itemId === itemFamilyId) {
-                continue;
-            }
-            if (releasedForDevelopmentItemIds.includes(itemFamilyId)) {
-                continue;
-            }
-            if (this.meetsCriteria(aItem)) {
-                continue;
-            }
-            const familyItem = item?.itemFamily;
-            if (familyItem && this.meetsCriteria({ item: familyItem })) {
-                console.info('adding released family with pre-development options: ' + itemFamilyId);
-                releasedForDevelopmentItemIds.push(itemFamilyId);
-            }
-        }
-    }
     meetsCriteria(aItem) {
         const item = aItem?.item;
         const lifecycleStage = item?.lifecycleStage;
@@ -755,11 +730,7 @@ class BaseProcessPublishAssortment {
         for (const [itemId, aItem] of assortmentItemFullChangeMap) {
             const projectItem = aItem?.projectItem;
             const itemFamilyId = aItem?.item?.itemFamilyId;
-            const familyInScope = pcd.releasedForDevelopmentItemIds.includes(itemFamilyId);
-            const itemInScope = pcd.releasedForDevelopmentItemIds.includes(itemId);
-            // Released family + pre-development option: track at family level only (no SKU events).
-            const familyOnly = !itemInScope && familyInScope && itemId !== itemFamilyId;
-            if (!familyInScope || (!itemInScope && !familyOnly)) {
+            if (!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)) {
                 continue;
             }
             const ifc = itemFamilyChanges.get(itemFamilyId) || new item_family_changes_1.ItemFamilyChanges(itemFamilyId, pcd.sinceDate);
@@ -767,29 +738,10 @@ class BaseProcessPublishAssortment {
                 ifc.itemFamilyObject = itemId === itemFamilyId ? aItem?.item : aItem?.item?.itemFamily;
                 itemFamilyChanges.set(itemFamilyId, ifc);
             }
-            else if (itemId === itemFamilyId) {
-                // A pre-development option row may have created this bucket with the partial
-                // item.itemFamily; the family's own row carries the full item, so prefer it.
-                ifc.itemFamilyObject = aItem?.item;
-            }
             ifc.assortmentItemFullChangeMap.set(itemId, aItem);
             if (pcd.itemToFederatedIdMapping.has(itemId)) {
                 ifc.itemToFederatedIdMapping.set(itemId, pcd.itemToFederatedIdMapping.get(itemId));
             }
-            if (familyOnly) {
-                ifc.hasPreDevelopmentOnlyOptions = true;
-                if (addIds.includes(itemId) || deleteIds.includes(itemId) || updateIds.includes(itemId)
-                    || (projectItem && new Date(projectItem.updatedOn) > pcd.sinceDate)) {
-                    ifc.preDevelopmentOptionChanges.push(itemId);
-                }
-                else {
-                    ifc.colorUnchanged.push(itemId);
-                }
-                if (projectItem && !projectItem?.roles && aItem?.item?.roles) {
-                    projectItem.roles = aItem?.item?.roles;
-                }
-                continue;
-            }
             if (itemId === itemFamilyId) {
                 if (addIds.includes(itemId))
                     ifc.familyAdd = true;
@@ -828,10 +780,7 @@ class BaseProcessPublishAssortment {
         for (const [itemId, delEntity] of assortmentItemDeleteMap) {
             const itemFamilyId = delEntity?.item?.itemFamilyId;
             const item = delEntity?.item;
-            const familyInScope = pcd.releasedForDevelopmentItemIds.includes(itemFamilyId);
-            const itemInScope = pcd.releasedForDevelopmentItemIds.includes(itemId);
-            const familyOnly = !itemInScope && familyInScope && itemId !== itemFamilyId;
-            if (!familyInScope || (!itemInScope && !familyOnly)) {
+            if (!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)) {
                 continue;
             }
             else {
@@ -861,10 +810,6 @@ class BaseProcessPublishAssortment {
             if (itemId === itemFamilyId) {
                 ifc.familyDelete = true;
             }
-            else if (familyOnly) {
-                ifc.hasPreDevelopmentOnlyOptions = true;
-                ifc.preDevelopmentOptionChanges.push(itemId);
-            }
             else {
                 ifc.colorDeletes.push(itemId);
             }
@@ -912,7 +857,6 @@ class BaseProcessPublishAssortment {
         const projectItem = this.getProjectItem(itemFamilyChanges, itemFamilyChanges.itemFamilyId);
         const familyAssortmentItem = itemFamilyChanges.familyAdd || itemFamilyChanges.familyUpdate || itemFamilyChanges.familyDelete
             || itemFamilyChanges.colorAdds.length > 0 || itemFamilyChanges.colorUpdates.length > 0 || itemFamilyChanges.colorDeletes.length > 0
-            || itemFamilyChanges.preDevelopmentOptionChanges.length > 0
             || (projectItem && this.updatedSinceDate(projectItem, itemFamilyChanges.sinceDate));
         //familyItemRemoved is used when adding the first option to an assortment
         //and will have updates for the family item.

package/lib/publish/base-process-publish-assortment.spec.js

@@ -1874,234 +1874,3 @@ describe('sendToFlexPLM / handleVibeIQFile / sendPublishPayloadEvent', () => {
         });
     });
 });
-describe('released family with pre-development options', () => {
-    const FAMILY_ID = 'AERfdvdAt1HHEVvQ';
-    const LIME_ID = 'limeGreenItemId__';
-    const MAROON_ID = 'maroonItemId_____';
-    const SINCE = new Date('2026-09-03T16:54:20.778Z');
-    const BEFORE_SINCE = '2026-09-01T00:00:00.000Z';
-    const AFTER_SINCE = '2026-09-03T17:00:00.000Z';
-    /** The full family item, as it appears on the family's own assortment row. */
-    const fullFamilyItem = {
-        id: FAMILY_ID, itemFamilyId: FAMILY_ID, name: 'Sweatpant', itemNumber: 11,
-        lifecycleStage: 'released', roles: ['family'], richFamilyOnlyField: 'PRESENT'
-    };
-    /** The partial family item, as hydrated onto an option row. */
-    const partialFamilyItem = {
-        id: FAMILY_ID, itemFamilyId: FAMILY_ID, name: 'Sweatpant', itemNumber: 11,
-        lifecycleStage: 'released', roles: ['family']
-    };
-    const familyRow = () => ({
-        entityType: 'assortment-item',
-        id: 'ai-' + FAMILY_ID,
-        itemId: FAMILY_ID,
-        item: { ...fullFamilyItem },
-        projectItem: { id: 'proj:' + FAMILY_ID, itemId: FAMILY_ID, updatedOn: BEFORE_SINCE, roles: ['family'] }
-    });
-    const optionRow = (itemId, optionName, projectItemUpdatedOn) => ({
-        entityType: 'assortment-item',
-        id: 'ai-' + itemId,
-        itemId,
-        item: {
-            id: itemId, itemFamilyId: FAMILY_ID, name: 'Sweatpant', optionName,
-            optionGroup: 'color', lifecycleStage: 'concept', roles: ['color', 'option'],
-            itemFamily: { ...partialFamilyItem }
-        },
-        projectItem: { id: 'proj:' + itemId, itemId, updatedOn: projectItemUpdatedOn, roles: ['color', 'option'] },
-        familyProjectItem: { id: 'proj:' + FAMILY_ID, itemId: FAMILY_ID, updatedOn: BEFORE_SINCE, roles: ['family'] }
-    });
-    const emptyDetail = { adds: [], deletes: [], updates: [], familyItemsRemoved: [] };
-    const baseConfig = { identifierAtts: { LCSProduct: ['itemNumber'] }, itemPreDevelopmentLifecycleStages: ['concept'] };
-    const makePpa = () => {
-        const cfg = { ...baseConfig };
-        const mfu = new transform_data_1.MapFileUtil(new sdk_1.Entities());
-        return new base_process_publish_assortment_1.BaseProcessPublishAssortment(cfg, new data_converter_1.DataConverter(cfg, mfu), mfu);
-    };
-    const makePcd = (releasedIds) => {
-        const sf = { entityReference: 'assortment:11EZML5dMn3tREuT', objectClass: 'LCSSeason' };
-        const pcd = new publish_change_data_1.PublishChangeData('11EZML5dMn3tREuT', sf, 'apc1', SINCE);
-        pcd.itemToFederatedIdMapping = new Map();
-        pcd.releasedForDevelopmentItemIds = releasedIds;
-        return pcd;
-    };
-    const eventSeasonFed = { entityReference: 'assortment:a1', objectClass: 'LCSSeason' };
-    const stubEventDeps = (ppa) => {
-        jest.spyOn(ppa, 'getAssortment').mockResolvedValue({ id: 'a1', publishToFlexPLM: true });
-        jest.spyOn(ppa, 'getSeasonalData').mockResolvedValue({});
-        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockImplementation(async (...args) => args[2]);
-        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['itemNumber']);
-        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
-        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity').mockResolvedValue(true);
-    };
-    afterEach(() => { jest.restoreAllMocks(); });
-    /////////////////////////////////////////////////////////////////////////////
-    // getReleasedForDevelopmentItemAndFamilyIds
-    /////////////////////////////////////////////////////////////////////////////
-    it('released family enters scope; concept options do NOT', () => {
-        const fullChange = { assortmentItems: [optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE),
-                optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE)] };
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toEqual([FAMILY_ID]);
-    });
-    it('released family enters scope; concept options do NOT', () => {
-        const row = optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE);
-        row.item.itemFamily = { ...partialFamilyItem, lifecycleStage: 'concept' };
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds({ assortmentItems: [row] }, [])).toEqual([]);
-    });
-    it('family reached only through a delete record', () => {
-        const deleted = optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE);
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds({ assortmentItems: [] }, [deleted]))
-            .toEqual([FAMILY_ID]);
-    });
-    it('two concept options of the same family add the family only once', () => {
-        const fullChange = { assortmentItems: [optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE),
-                optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE)] };
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toHaveLength(1);
-    });
-    it('option row with no hydrated itemFamily is skipped without throwing', () => {
-        const bare = optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE);
-        delete bare.item.itemFamily;
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds({ assortmentItems: [bare] }, [])).toEqual([]);
-    });
-    it('released family WITH its own assortment row is in scope with or without the flag', () => {
-        const rows = { assortmentItems: [familyRow(), optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE)] };
-        expect(makePpa().getReleasedForDevelopmentItemAndFamilyIds(rows, [])).toEqual([FAMILY_ID]);
-    });
-    /////////////////////////////////////////////////////////////////////////////
-    // getItemFamilyChanges
-    /////////////////////////////////////////////////////////////////////////////
-    it('ACTION 2: deleting a concept option marks the released family for republish', () => {
-        const ppa = makePpa();
-        const remaining = optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE);
-        const deleted = optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE);
-        const pcd = makePcd([FAMILY_ID]);
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, ppa.getFullChangeAssortmentMap({ assortmentItems: [remaining] }), ppa.getDeleteChangesAssortmentMap([deleted]));
-        expect(pcd.itemFamilyChanges.size).toEqual(1);
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.preDevelopmentOptionChanges).toEqual([MAROON_ID]);
-        expect(ifc.hasPreDevelopmentOnlyOptions).toBe(true);
-        expect(ifc.colorDeletes).toEqual([]);
-        expect(ifc.colorAdds).toEqual([]);
-        expect(ifc.itemFamilyObject.id).toEqual(FAMILY_ID);
-    });
-    it('adding a concept option marks the family, not a colorAdd', () => {
-        const ppa = makePpa();
-        const added = optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE);
-        const pcd = makePcd([FAMILY_ID]);
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, { ...emptyDetail, adds: [{ id: MAROON_ID }] }, ppa.getFullChangeAssortmentMap({ assortmentItems: [added] }), new Map());
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.preDevelopmentOptionChanges).toEqual([MAROON_ID]);
-        expect(ifc.colorAdds).toEqual([]);
-    });
-    it('ACTION 1: nothing changed - family bucket exists but signals no change', () => {
-        const ppa = makePpa();
-        const pcd = makePcd([FAMILY_ID]);
-        const rows = { assortmentItems: [optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE),
-                optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE)] };
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, ppa.getFullChangeAssortmentMap(rows), new Map());
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.preDevelopmentOptionChanges).toEqual([]);
-        expect(ifc.colorUnchanged.sort()).toEqual([LIME_ID, MAROON_ID].sort());
-    });
-    it('a concept option updated after sinceDate becomes a preDevelopmentOptionChange', () => {
-        const ppa = makePpa();
-        const pcd = makePcd([FAMILY_ID]);
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, ppa.getFullChangeAssortmentMap({ assortmentItems: [optionRow(LIME_ID, 'Lime Green', AFTER_SINCE)] }), new Map());
-        expect(pcd.itemFamilyChanges.size).toEqual(1);
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.preDevelopmentOptionChanges).toEqual([LIME_ID]);
-        expect(ifc.colorUnchanged).toEqual([]);
-        expect(ifc.hasPreDevelopmentOnlyOptions).toBe(true);
-    });
-    it('REGRESSION: a released option is still a colorAdd, never a preDevelopmentOptionChange', () => {
-        const ppa = makePpa();
-        const released = optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE);
-        released.item.lifecycleStage = 'development';
-        const pcd = makePcd([FAMILY_ID, LIME_ID]);
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, { ...emptyDetail, adds: [{ id: LIME_ID }] }, ppa.getFullChangeAssortmentMap({ assortmentItems: [released] }), new Map());
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.colorAdds).toEqual([LIME_ID]);
-        expect(ifc.preDevelopmentOptionChanges).toEqual([]);
-        expect(ifc.hasPreDevelopmentOnlyOptions).toBe(false);
-    });
-    it('itemFamilyObject prefers the full family item when the OPTION row is iterated first', () => {
-        const ppa = makePpa();
-        const pcd = makePcd([FAMILY_ID]);
-        const map = new Map();
-        map.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        map.set(FAMILY_ID, familyRow());
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, map, new Map());
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.itemFamilyObject.richFamilyOnlyField).toEqual('PRESENT');
-    });
-    it('itemFamilyObject is the full family item when the FAMILY row is iterated first', () => {
-        const ppa = makePpa();
-        const pcd = makePcd([FAMILY_ID]);
-        const map = new Map();
-        map.set(FAMILY_ID, familyRow());
-        map.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, map, new Map());
-        const ifc = pcd.itemFamilyChanges.get(FAMILY_ID);
-        expect(ifc.itemFamilyObject.richFamilyOnlyField).toEqual('PRESENT');
-    });
-    it('delete record with a missing item entity is skipped safely', () => {
-        const ppa = makePpa();
-        const pcd = makePcd([FAMILY_ID]);
-        const delMap = new Map();
-        delMap.set('GHOST', { itemId: 'GHOST', item: undefined });
-        pcd.itemFamilyChanges = ppa.getItemFamilyChanges(pcd, emptyDetail, new Map(), delMap);
-        expect(pcd.itemFamilyChanges.size).toEqual(0);
-    });
-    /////////////////////////////////////////////////////////////////////////////
-    // getEventsForItemFamilyChanges
-    /////////////////////////////////////////////////////////////////////////////
-    it('emits exactly one LCSProductSeasonLink and zero LCSSKUSeasonLink', async () => {
-        const ppa = makePpa();
-        const ifc = new item_family_changes_1.ItemFamilyChanges(FAMILY_ID, SINCE);
-        ifc.itemFamilyObject = fullFamilyItem;
-        ifc.hasPreDevelopmentOnlyOptions = true;
-        ifc.preDevelopmentOptionChanges.push(MAROON_ID);
-        ifc.assortmentItemFullChangeMap.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        stubEventDeps(ppa);
-        const events = await ppa.getEventsForItemFamilyChanges(ifc, 'a1', eventSeasonFed, new Map());
-        expect(events).toHaveLength(1);
-        expect(events[0].objectClass).toBe('LCSProductSeasonLink');
-        expect(events[0].eventType).toBe('UPSERT_ON_SEASON');
-        expect(events[0].entityReference).toBe('item:' + FAMILY_ID);
-        expect(events[0].LCSProduct['itemNumber']).toBe(11);
-    });
-    it('REGRESSION: an ItemFamilyChanges with no changes still emits nothing', async () => {
-        const ppa = makePpa();
-        const ifc = new item_family_changes_1.ItemFamilyChanges(FAMILY_ID, SINCE);
-        ifc.itemFamilyObject = fullFamilyItem;
-        ifc.colorUnchanged.push(LIME_ID, MAROON_ID);
-        ifc.assortmentItemFullChangeMap.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        stubEventDeps(ppa);
-        expect(await ppa.getEventsForItemFamilyChanges(ifc, 'a1', eventSeasonFed, new Map())).toHaveLength(0);
-    });
-    /////////////////////////////////////////////////////////////////////////////
-    // republish of an unchanged released family
-    /////////////////////////////////////////////////////////////////////////////
-    const unchangedFamilyIfc = () => {
-        const ifc = new item_family_changes_1.ItemFamilyChanges(FAMILY_ID, SINCE);
-        ifc.itemFamilyObject = fullFamilyItem;
-        ifc.hasPreDevelopmentOnlyOptions = true;
-        ifc.colorUnchanged.push(LIME_ID, MAROON_ID);
-        ifc.assortmentItemFullChangeMap.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        return ifc;
-    };
-    it('ACTION 1: unchanged family with pre-development-only options emits nothing', async () => {
-        const ppa = makePpa();
-        stubEventDeps(ppa);
-        expect(await ppa.getEventsForItemFamilyChanges(unchangedFamilyIfc(), 'a1', eventSeasonFed, new Map()))
-            .toHaveLength(0);
-    });
-    it('REGRESSION: an ordinary unchanged released family is not republished', async () => {
-        const ppa = makePpa();
-        stubEventDeps(ppa);
-        const ifc = new item_family_changes_1.ItemFamilyChanges(FAMILY_ID, SINCE);
-        ifc.itemFamilyObject = fullFamilyItem;
-        ifc.colorUnchanged.push(LIME_ID);
-        ifc.assortmentItemFullChangeMap.set(LIME_ID, optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE));
-        expect(await ppa.getEventsForItemFamilyChanges(ifc, 'a1', eventSeasonFed, new Map())).toHaveLength(0);
-    });
-});

package/lib/util/flexplm-connect.js

@@ -63,7 +63,6 @@ class FlexPLMConnect {
             const nonce_key = body.items[0].attributes.nonce_key;
             const nonce = body.items[0].attributes.nonce;
             console.info('nonce_key: ' + nonce_key);
-            console.info('nonce: ' + nonce);
             return {
                 nonce_key,
                 nonce
@@ -89,7 +88,10 @@ class FlexPLMConnect {
             console.info('Request:');
             console.info('vibeEventsURL: ' + vibeEventsURL);
             const logOptions = JSON.parse(JSON.stringify(xferOptions));
-            logOptions['headers']['Authorization'] = logOptions?.headers?.Authorization.substring(0, 9);
+            if (logOptions?.headers?.Authorization)
+                logOptions.headers.Authorization = logOptions?.headers?.Authorization.substring(0, 9);
+            if (csrf?.nonce_key)
+                logOptions.headers[csrf.nonce_key] = csrf.nonce ? `***masked(length:${csrf.nonce.length})***` : '***masked(empty)***';
             console.info('csrfOptions: ' + JSON.stringify(logOptions));
             console.info('Making call to xfer data to FlexPLM');
         }

package/lib/util/flexplm-connect.spec.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const flexplm_connect_1 = require("./flexplm-connect");
+const app_framework_1 = require("@contrail/app-framework");
 const mockJsonData = { items: [{ id: '123', name: 'test' }] };
 const mockResponse = (status, json = mockJsonData) => ({
     status,
@@ -87,3 +88,36 @@ describe('FlexPLMConnect.getRequest', () => {
         await expect(connect.getRequest()).rejects.toThrow('Error getting json data from FlexPLM: Invalid JSON');
     });
 });
+describe('FlexPLMConnect.sendRequest', () => {
+    it('should mask csrf nonce value in logged request options', async () => {
+        const loggerIsInfoOnSpy = jest.spyOn(app_framework_1.Logger, 'isInfoOn').mockReturnValue(true);
+        const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+        const csrf = { nonce_key: 'CSRF_NONCE', nonce: 'raw-secret-nonce' };
+        const payload = { id: '123' };
+        const connect = new flexplm_connect_1.FlexPLMConnect(createConfig());
+        await connect.sendRequest(csrf, payload);
+        const csrfOptionsLogMessages = consoleInfoSpy.mock.calls
+            .map(([message]) => String(message ?? ''))
+            .filter(message => message.startsWith('csrfOptions: '));
+        const sendRequestOptionsLogMessage = csrfOptionsLogMessages.find(message => message.includes('"CSRF_NONCE":'));
+        expect(sendRequestOptionsLogMessage).toBeDefined();
+        expect(sendRequestOptionsLogMessage ?? '').not.toContain('raw-secret-nonce');
+        expect(sendRequestOptionsLogMessage ?? '').toContain(`"CSRF_NONCE":"***masked(length:${'raw-secret-nonce'.length})***"`);
+        loggerIsInfoOnSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+    });
+    it('should log masked(empty) when csrf nonce is empty', async () => {
+        const loggerIsInfoOnSpy = jest.spyOn(app_framework_1.Logger, 'isInfoOn').mockReturnValue(true);
+        const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+        const csrf = { nonce_key: 'CSRF_NONCE', nonce: '' };
+        const connect = new flexplm_connect_1.FlexPLMConnect(createConfig());
+        await connect.sendRequest(csrf, { id: '123' });
+        const csrfOptionsLog = consoleInfoSpy.mock.calls
+            .map(([message]) => String(message ?? ''))
+            .find(message => message.includes('"CSRF_NONCE":'));
+        expect(csrfOptionsLog).toBeDefined();
+        expect(csrfOptionsLog ?? '').toContain('"CSRF_NONCE":"***masked(empty)***"');
+        loggerIsInfoOnSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.4-alpha.b9acb47",
+  "version": "1.7.4",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",