@contrail/flexplm 1.7.4-alpha.72422a6 → 1.7.4-alpha.858e2cc

package/lib/interfaces/interfaces.d.ts

@@ -15,6 +15,12 @@ export interface FCConfig {
     vibeEventEndpoint: string;
     csrfEndpoint: string;
     useDistinctRestEndPointForImages?: boolean;
+    /** Opt-in. When true, an item family that itself passes meetsCriteria() is published to the
+     *  season even when every one of its options is still in a pre-development lifecycle stage. */
+    publishReleasedFamilyWithPreDevelopmentOptions?: boolean;
+    /** Only meaningful when publishReleasedFamilyWithPreDevelopmentOptions is true. When true, such a
+     *  family is republished on EVERY publish, not only when one of its options actually changed. */
+    alwaysPublishReleasedFamilyWithPreDevelopmentOptions?: boolean;
     itemPreDevelopmentLifecycleStages: string[];
     identifierAtts?: {
         [key: string]: string[];

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

@@ -12,6 +12,12 @@ 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,6 +14,12 @@ 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();
@@ -32,6 +38,8 @@ 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,6 +62,11 @@ 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;
+    protected publishReleasedFamilyWithPreDevelopmentOptions(): boolean;
+    protected alwaysPublishReleasedFamilyWithPreDevelopmentOptions(): boolean;
     meetsCriteria(aItem: any): boolean;
     processPublish(pcd: PublishChangeData, changeDetail: any, fullChange: any, deleteChanges: any): Promise<{
         results: {

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

@@ -9,7 +9,9 @@ const map_utils_1 = require("../util/map-utils");
 const type_conversion_utils_1 = require("../util/type-conversion-utils");
 const fsPromise = require("fs/promises");
 const path = require("path");
+const app_framework_1 = require("@contrail/app-framework");
 const event_short_message_status_1 = require("../util/event-short-message-status");
+const config_defaults_1 = require("../util/config-defaults");
 class BaseProcessPublishAssortment {
     constructor(_config, _dc, _mapFileUtil) {
         this.TTL = 30 * 24 * 60 * 60 * 1000; // 30 days
@@ -28,8 +30,7 @@ class BaseProcessPublishAssortment {
         let publisher;
         const assortmentId = event.assortmentId;
         try {
-            console.info('process-start: assortmentId: ' + assortmentId
-                + ', assortmentPublishChangeId: ' + assortmentPublishChangeId);
+            console.info('process-start!');
             let seasonFed;
             try {
                 seasonFed = await this.getSeasonFederation(assortmentId);
@@ -74,9 +75,9 @@ class BaseProcessPublishAssortment {
                 e.publishInfo = publishInfo;
             }
             catch (e2) {
-                console.error('getPublishInfo failed: ' + e2.message);
+                console.log('catch e2: ' + e2.message);
             }
-            console.error('process failed: assortmentId: ' + assortmentId + ': ' + e.message);
+            console.log('catch e: ' + e.message);
             throw e;
         }
     }
@@ -315,17 +316,19 @@ class BaseProcessPublishAssortment {
     }
     async downloadHydratedChangeDetail(assortmentPublishChange) {
         try {
+            console.info('downloadHydratedChangeDetail-start');
             const link = assortmentPublishChange?.hydratedDetailDownloadLink;
             const response = await fetch(link);
             const data = await response.json();
             return data;
         }
         catch (e) {
-            console.error('Error hydratedDetailDownloadLink: ' + e.message);
+            console.log('Error hydratedDetailDownloadLink: ' + e.message);
         }
         return undefined;
     }
     async downloadAssortmentBaseline(assortmentPublishChange) {
+        console.info('downloadAssortmentBaseline-start');
         try {
             const link = assortmentPublishChange?.assortmentBaselineDownloadLink;
             const response = await fetch(link);
@@ -333,12 +336,15 @@ class BaseProcessPublishAssortment {
             return data;
         }
         catch (e) {
-            console.error('Error assortmentBaselineDownloadLink: ' + e.message);
+            console.log('Error assortmentBaselineDownloadLink: ' + e.message);
         }
         return undefined;
     }
     async getDeleteChanges(assortmentPublishChange, apcHistory, assortmentBaseline, sinceDate) {
+        console.info('getDeleteChanges(): ' + assortmentPublishChange?.id);
+        console.info(sinceDate);
         const currentAPCIndex = apcHistory.findIndex(pc => pc?.id === assortmentPublishChange?.id);
+        console.info(' currentAPCIndex: ' + currentAPCIndex);
         if (currentAPCIndex == 0) {
             return [];
         }
@@ -347,13 +353,16 @@ class BaseProcessPublishAssortment {
         const apcDeletes = await this.downloadDeleteChanges(assortmentPublishChange);
         let previousApcDate = Date.parse(apcCreatedOn);
         const sinceDateMilliseconds = sinceDate.getTime();
-        console.info('getDeleteChanges(): apc: ' + assortmentPublishChange?.id
-            + ', index: ' + currentAPCIndex + ', previousApcCreatedOn: ' + apcCreatedOn);
+        if (app_framework_1.Logger.isInfoOn()) {
+            console.info('apcCreatedOn: ' + apcCreatedOn);
+            console.info('sinceDate: ' + sinceDate);
+            console.info('sinceDateMilliseconds: ' + sinceDateMilliseconds);
+            console.info('apcDateMilliseconds: ' + previousApcDate);
+        }
         //if only 1 apc, no processing needed
         if (sinceDateMilliseconds !== previousApcDate) {
+            console.info('sinceDateMilliseconds !== apcDateMilliseconds');
             const currentAssortmentItemIds = this.getBaselineItemIds(assortmentBaseline);
-            let scannedCount = 0;
-            let addedCount = 0;
             const deleteIds = (apcDeletes.length === 0)
                 ? []
                 : apcDeletes.map(item => item?.itemId);
@@ -368,20 +377,19 @@ class BaseProcessPublishAssortment {
                         ? apcHistory[i - 1]
                         : undefined;
                     const deleteChanges = await this.buildDeleteChanges(workingAPC, previousApc);
+                    console.info('checking deleteChanges');
                     for (const dItem of deleteChanges) {
                         const dItemId = dItem?.itemId;
-                        scannedCount++;
+                        console.info(dItemId);
                         if (!currentAssortmentItemIds.includes(dItemId) && !deleteIds.includes(dItemId)) {
-                            addedCount++;
+                            console.info('adding');
                             deleteIds.push(dItemId);
                             apcDeletes.push(dItem);
                         }
                     }
                 }
             }
-            console.info('getDeleteChanges(): baselineItems: ' + currentAssortmentItemIds.length
-                + ', scanned ' + scannedCount + ' historical delete changes, added ' + addedCount
-                + ', deleteIds: ' + deleteIds.length);
+            console.info('getDeleteChanges()-currentAssortmentItemIds: ' + currentAssortmentItemIds);
             console.info('getDeleteChanges()-deleteIds: ' + deleteIds);
         }
         return apcDeletes;
@@ -395,6 +403,7 @@ class BaseProcessPublishAssortment {
         return itemIds;
     }
     async downloadDeleteChanges(apc) {
+        console.info('deleteDataDownloadLink-start');
         try {
             const link = apc?.deleteDataDownloadLink;
             const response = await fetch(link);
@@ -402,17 +411,19 @@ class BaseProcessPublishAssortment {
             return data;
         }
         catch (e) {
-            console.error('Error deleteDataDownloadLink: ' + e.message);
+            console.log('Error deleteDataDownloadLink: ' + e.message);
         }
         return undefined;
     }
     async buildDeleteChanges(apc, previousApc) {
+        console.info('buildDeleteChanges()');
         if (apc?.deleteDataDownloadLink) {
             const deleteChanges = await this.downloadDeleteChanges(apc);
             if (deleteChanges) {
                 return deleteChanges;
             }
         }
+        console.info('pulling down full APC');
         apc = await this.downloadAssortmentPublishChange(apc?.assortmentId, apc?.id);
         if (apc?.deleteDataDownloadLink) {
             const deleteChanges = await this.downloadDeleteChanges(apc);
@@ -424,18 +435,19 @@ class BaseProcessPublishAssortment {
             throw new Error(BaseProcessPublishAssortment.NOT_ABLE_TO_PROCESS_DELETE_CHANGES);
         }
         let previousBaseline;
+        console.info('check previousApc');
         if (previousApc?.assortmentBaselineDownloadLink) {
             previousBaseline = await this.downloadAssortmentBaseline(previousApc);
         }
         else {
+            console.info('previousApc pulling down full APC');
             previousApc = await this.downloadAssortmentPublishChange(previousApc?.assortmentId, previousApc?.id);
             previousBaseline = await this.downloadAssortmentBaseline(previousApc);
         }
         const deleteIds = apc?.detail?.deletes.map(dItem => dItem?.id);
         //building deletes based on previous baseline; because some APCs don't have delete data
         const deleteArray = previousBaseline?.assortmentItems.filter(aItem => deleteIds.includes(aItem?.itemId));
-        console.info('buildDeleteChanges(): no deleteDataDownloadLink on apc ' + apc?.id
-            + '; rebuilding ' + deleteArray.length + ' deletes from previous baseline');
+        console.info('deleteArray.length: ' + deleteArray.length);
         return deleteArray;
     }
     async getItemFederatedIds( /*itemIds*/) {
@@ -473,6 +485,7 @@ class BaseProcessPublishAssortment {
         return deleteItems;
     }
     getReleasedForDevelopmentItemAndFamilyIds(fullChange, deleteChanges) {
+        console.info('getReleasedForDevelopmentItemAndFamilyIds');
         const releasedForDevelopmentItemIds = [];
         const itemFamilySet = new Set();
         const assortmentItemsArray = fullChange?.assortmentItems;
@@ -515,15 +528,50 @@ class BaseProcessPublishAssortment {
                 }
             }
         }
+        if (this.publishReleasedFamilyWithPreDevelopmentOptions()) {
+            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);
+            }
+        }
+    }
+    publishReleasedFamilyWithPreDevelopmentOptions() {
+        return config_defaults_1.ConfigDefaults.isPropertyTrue(this.config?.publishReleasedFamilyWithPreDevelopmentOptions);
+    }
+    alwaysPublishReleasedFamilyWithPreDevelopmentOptions() {
+        return this.publishReleasedFamilyWithPreDevelopmentOptions()
+            && config_defaults_1.ConfigDefaults.isPropertyTrue(this.config?.alwaysPublishReleasedFamilyWithPreDevelopmentOptions);
+    }
     meetsCriteria(aItem) {
         const item = aItem?.item;
         const lifecycleStage = item?.lifecycleStage;
         return !!lifecycleStage && !this.config.itemPreDevelopmentLifecycleStages.includes(lifecycleStage);
     }
     async processPublish(pcd, changeDetail, fullChange, deleteChanges) {
+        console.info('processPublish-start');
         const event = {
             assortmentId: pcd.assortmentId,
             assortmentPublishChangeId: pcd.assortmentPublishChangeId
@@ -707,6 +755,7 @@ class BaseProcessPublishAssortment {
             + '-' + d.getUTCMilliseconds();
     }
     getItemFamilyChanges(pcd, changeDetail, assortmentItemFullChangeMap, assortmentItemDeleteMap) {
+        console.info('getItemFamilyChanges-start');
         const itemFamilyChanges = new Map();
         const { adds, deletes, updates, familyItemsRemoved } = changeDetail;
         const addIds = adds.map(item => item.id);
@@ -716,7 +765,12 @@ class BaseProcessPublishAssortment {
         for (const [itemId, aItem] of assortmentItemFullChangeMap) {
             const projectItem = aItem?.projectItem;
             const itemFamilyId = aItem?.item?.itemFamilyId;
-            if (!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)) {
+            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
+                && this.publishReleasedFamilyWithPreDevelopmentOptions();
+            if (!familyInScope || (!itemInScope && !familyOnly)) {
                 continue;
             }
             const ifc = itemFamilyChanges.get(itemFamilyId) || new item_family_changes_1.ItemFamilyChanges(itemFamilyId, pcd.sinceDate);
@@ -724,10 +778,29 @@ class BaseProcessPublishAssortment {
                 ifc.itemFamilyObject = itemId === itemFamilyId ? aItem?.item : aItem?.item?.itemFamily;
                 itemFamilyChanges.set(itemFamilyId, ifc);
             }
+            else if (itemId === itemFamilyId && this.publishReleasedFamilyWithPreDevelopmentOptions()) {
+                // 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;
@@ -766,12 +839,17 @@ class BaseProcessPublishAssortment {
         for (const [itemId, delEntity] of assortmentItemDeleteMap) {
             const itemFamilyId = delEntity?.item?.itemFamilyId;
             const item = delEntity?.item;
-            if (!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)) {
+            const familyInScope = pcd.releasedForDevelopmentItemIds.includes(itemFamilyId);
+            const itemInScope = pcd.releasedForDevelopmentItemIds.includes(itemId);
+            const familyOnly = !itemInScope && familyInScope && itemId !== itemFamilyId
+                && this.publishReleasedFamilyWithPreDevelopmentOptions();
+            if (!familyInScope || (!itemInScope && !familyOnly)) {
                 continue;
             }
             else {
                 if (!item) {
-                    console.error('Failed to find deleted item entity: itemFamilyId: ' + itemFamilyId + ', itemId: ' + itemId);
+                    console.error('Failed to find deleted item entity');
+                    console.error(' itemFamilyId: ' + itemFamilyId + ' -itemId: ' + itemId);
                     continue;
                 }
             }
@@ -795,11 +873,15 @@ class BaseProcessPublishAssortment {
             if (itemId === itemFamilyId) {
                 ifc.familyDelete = true;
             }
+            else if (familyOnly) {
+                ifc.hasPreDevelopmentOnlyOptions = true;
+                ifc.preDevelopmentOptionChanges.push(itemId);
+            }
             else {
                 ifc.colorDeletes.push(itemId);
             }
         } //End deletes for loop
-        if (Logger.isDebugOn()) {
+        if (app_framework_1.Logger.isDebugOn()) {
             console.debug('returning size: ' + itemFamilyChanges.size);
             for (const [key, value] of itemFamilyChanges) {
                 console.debug(key + ' => ' + value);
@@ -808,6 +890,7 @@ class BaseProcessPublishAssortment {
         return itemFamilyChanges;
     }
     async getEventsForPublishChangeData(publishChangeData) {
+        console.info('getEventsForPublishChangeData-start');
         const seasonalPayloads = [];
         for (const itemFamilyChange of publishChangeData.itemFamilyChanges.values()) {
             const events = await this.getEventsForItemFamilyChanges(itemFamilyChange, publishChangeData.assortmentId, publishChangeData.seasonFed, publishChangeData.itemToFederatedIdMapping);
@@ -815,8 +898,6 @@ class BaseProcessPublishAssortment {
                 seasonalPayloads.push(...events);
             }
         }
-        console.info('getEventsForPublishChangeData: itemFamilies: '
-            + publishChangeData.itemFamilyChanges.size + ', payloads: ' + seasonalPayloads.length);
         return seasonalPayloads;
     }
     /**Returns the events for a given ItemFamilyChanges object
@@ -836,12 +917,15 @@ class BaseProcessPublishAssortment {
      * @returns
      */
     async getEventsForItemFamilyChanges(itemFamilyChanges, assortmentId, seasonFed, itemToFederatedIdMapping) {
+        console.info('getEventsForItemFamilyChanges()');
         const events = [];
         const LCSSeason = Object.assign({}, seasonFed);
         const assortment = await this.getAssortment(assortmentId);
         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
+            || (this.alwaysPublishReleasedFamilyWithPreDevelopmentOptions() && itemFamilyChanges.hasPreDevelopmentOnlyOptions)
             || (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,3 +1874,259 @@ describe('sendToFlexPLM / handleVibeIQFile / sendPublishPayloadEvent', () => {
         });
     });
 });
+describe('publishReleasedFamilyWithPreDevelopmentOptions', () => {
+    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 makePpa2 = (flagOn, alwaysOn) => {
+        const cfg = {
+            ...baseConfig,
+            publishReleasedFamilyWithPreDevelopmentOptions: flagOn,
+            alwaysPublishReleasedFamilyWithPreDevelopmentOptions: alwaysOn
+        };
+        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 makePpa = (flagOn) => makePpa2(flagOn, false);
+    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('should keep a released family out of scope when all options are pre-development and the flag is off', () => {
+        const fullChange = { assortmentItems: [optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE),
+                optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE)] };
+        expect(makePpa(false).getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toEqual([]);
+    });
+    it('flag on - 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(true).getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toEqual([FAMILY_ID]);
+    });
+    it('flag on - concept family with concept options still stays out of scope', () => {
+        const row = optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE);
+        row.item.itemFamily = { ...partialFamilyItem, lifecycleStage: 'concept' };
+        expect(makePpa(true).getReleasedForDevelopmentItemAndFamilyIds({ assortmentItems: [row] }, [])).toEqual([]);
+    });
+    it('flag on - family reached only through a delete record', () => {
+        const deleted = optionRow(MAROON_ID, 'Maroon', BEFORE_SINCE);
+        expect(makePpa(true).getReleasedForDevelopmentItemAndFamilyIds({ assortmentItems: [] }, [deleted]))
+            .toEqual([FAMILY_ID]);
+    });
+    it('flag on - 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(true).getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toHaveLength(1);
+    });
+    it('flag on - 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(true).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(false).getReleasedForDevelopmentItemAndFamilyIds(rows, [])).toEqual([FAMILY_ID]);
+        expect(makePpa(true).getReleasedForDevelopmentItemAndFamilyIds(rows, [])).toEqual([FAMILY_ID]);
+    });
+    it('string flag values from app config are honoured', () => {
+        const fullChange = { assortmentItems: [optionRow(LIME_ID, 'Lime Green', BEFORE_SINCE)] };
+        expect(makePpa('true').getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toEqual([FAMILY_ID]);
+        expect(makePpa('false').getReleasedForDevelopmentItemAndFamilyIds(fullChange, [])).toEqual([]);
+    });
+    /////////////////////////////////////////////////////////////////////////////
+    // getItemFamilyChanges
+    /////////////////////////////////////////////////////////////////////////////
+    it('ACTION 2: deleting a concept option marks the released family for republish', () => {
+        const ppa = makePpa(true);
+        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(true);
+        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(true);
+        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('REGRESSION: flag off - concept option rows produce no ItemFamilyChanges at all', () => {
+        const ppa = makePpa(false);
+        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(0);
+    });
+    it('REGRESSION: a released option is still a colorAdd, never a preDevelopmentOptionChange', () => {
+        const ppa = makePpa(true);
+        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(true);
+        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(true);
+        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(true);
+        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(true);
+        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(true);
+        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);
+    });
+    /////////////////////////////////////////////////////////////////////////////
+    // alwaysPublishReleasedFamilyWithPreDevelopmentOptions
+    /////////////////////////////////////////////////////////////////////////////
+    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 with always-flag: unchanged family still emits one LCSProductSeasonLink', async () => {
+        const ppa = makePpa2(true, true);
+        stubEventDeps(ppa);
+        const events = await ppa.getEventsForItemFamilyChanges(unchangedFamilyIfc(), 'a1', eventSeasonFed, new Map());
+        expect(events).toHaveLength(1);
+        expect(events[0].objectClass).toBe('LCSProductSeasonLink');
+    });
+    it('always-flag off: unchanged family emits nothing', async () => {
+        const ppa = makePpa2(true, false);
+        stubEventDeps(ppa);
+        expect(await ppa.getEventsForItemFamilyChanges(unchangedFamilyIfc(), 'a1', eventSeasonFed, new Map()))
+            .toHaveLength(0);
+    });
+    it('always-flag cannot act alone when the primary flag is off', async () => {
+        const ppa = makePpa2(false, true);
+        stubEventDeps(ppa);
+        expect(await ppa.getEventsForItemFamilyChanges(unchangedFamilyIfc(), 'a1', eventSeasonFed, new Map()))
+            .toHaveLength(0);
+    });
+    it('REGRESSION: always-flag does not republish an ordinary unchanged released family', async () => {
+        const ppa = makePpa2(true, true);
+        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/config-defaults.d.ts

@@ -20,6 +20,8 @@ export declare class ConfigDefaults {
             processAsItem: boolean;
         };
         useDistinctRestEndPointForImages: boolean;
+        publishReleasedFamilyWithPreDevelopmentOptions: boolean;
+        alwaysPublishReleasedFamilyWithPreDevelopmentOptions: boolean;
         csrfEndpoint: string;
         vibeEventEndpoint: string;
         payloadDefaultAsArray: boolean;

package/lib/util/config-defaults.js

@@ -67,6 +67,8 @@ class ConfigDefaults {
                 processAsItem: false,
             },
             useDistinctRestEndPointForImages: false,
+            publishReleasedFamilyWithPreDevelopmentOptions: false,
+            alwaysPublishReleasedFamilyWithPreDevelopmentOptions: false,
             csrfEndpoint: '/servlet/rest/security/csrf',
             vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
             payloadDefaultAsArray: true,

package/lib/util/config-defaults.spec.js

@@ -393,3 +393,50 @@ describe('all tests', () => {
         });
     });
 });
+describe('publishReleasedFamilyWithPreDevelopmentOptions config', () => {
+    const config = {
+        apiHost: 'http://test.com',
+        userName: 'vibeiq',
+        password: 'vibeiq',
+        plmEnviornment: 'SB'
+    };
+    it('publishReleasedFamilyWithPreDevelopmentOptions-get default', async () => {
+        const startConfig = Object.assign({}, config);
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(fcConfig['publishReleasedFamilyWithPreDevelopmentOptions']).toBe(false);
+    });
+    it('alwaysPublishReleasedFamilyWithPreDevelopmentOptions-get default', async () => {
+        const startConfig = Object.assign({}, config);
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(fcConfig['alwaysPublishReleasedFamilyWithPreDevelopmentOptions']).toBe(false);
+    });
+    it('publishReleasedFamilyWithPreDevelopmentOptions-set boolean true', async () => {
+        const startConfig = Object.assign({}, config);
+        startConfig['publishReleasedFamilyWithPreDevelopmentOptions'] = true;
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(config_defaults_1.ConfigDefaults.isPropertyTrue(fcConfig['publishReleasedFamilyWithPreDevelopmentOptions'])).toBe(true);
+    });
+    it('publishReleasedFamilyWithPreDevelopmentOptions-set string true from app config', async () => {
+        const startConfig = Object.assign({}, config);
+        startConfig['publishReleasedFamilyWithPreDevelopmentOptions'] = 'true';
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(config_defaults_1.ConfigDefaults.isPropertyTrue(fcConfig['publishReleasedFamilyWithPreDevelopmentOptions'])).toBe(true);
+    });
+    it('publishReleasedFamilyWithPreDevelopmentOptions-string false stays off', async () => {
+        const startConfig = Object.assign({}, config);
+        startConfig['publishReleasedFamilyWithPreDevelopmentOptions'] = 'false';
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(config_defaults_1.ConfigDefaults.isPropertyTrue(fcConfig['publishReleasedFamilyWithPreDevelopmentOptions'])).toBe(false);
+    });
+    it('both flags can be delivered through complexConfig', async () => {
+        const startConfig = Object.assign({}, config, {
+            complexConfig: {
+                publishReleasedFamilyWithPreDevelopmentOptions: true,
+                alwaysPublishReleasedFamilyWithPreDevelopmentOptions: 'true'
+            }
+        });
+        const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+        expect(config_defaults_1.ConfigDefaults.isPropertyTrue(fcConfig['publishReleasedFamilyWithPreDevelopmentOptions'])).toBe(true);
+        expect(config_defaults_1.ConfigDefaults.isPropertyTrue(fcConfig['alwaysPublishReleasedFamilyWithPreDevelopmentOptions'])).toBe(true);
+    });
+});

package/lib/util/data-converter.js

@@ -175,12 +175,18 @@ class DataConverter {
     }
     async getObjectReferenceValue(prop, newData, inflateObjRef = false) {
         const slug = prop['slug'];
+        if (app_framework_1.Logger.isDebugOn()) {
+            console.debug('getObjectReferenceValue-prop: ' + slug);
+        }
         let value = newData[slug];
         const entityType = prop['referencedTypeRootSlug'];
         const entityId = newData[slug + 'Id'];
         if ((!value || typeof value === 'string') && inflateObjRef) {
             if (entityId) {
                 if (this.objRefCache[entityId]) {
+                    if (app_framework_1.Logger.isDebugOn()) {
+                        console.debug('cache hit: ' + entityId);
+                    }
                     return this.objRefCache[entityId];
                 }
                 const criteria = {
@@ -426,6 +432,9 @@ class DataConverter {
             return "";
         }
         if (this.objRefCache[ctx.cacheKey]) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug(`object reference cache hit: ${ctx.cacheKey}`);
+            }
             return this.objRefCache[ctx.cacheKey];
         }
         const objectReferenceId = ctx.useIdentityService
@@ -625,6 +634,9 @@ class DataConverter {
         }
         let cacheUser = DataConverter.getFromStaticCache(nd.email);
         if (cacheUser) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('user cache hit: ' + nd.email);
+            }
             await this.processGroupMemberCheck(prop, nd.email);
             return cacheUser;
         }
@@ -694,12 +706,18 @@ class DataConverter {
      */
     async getUserListValue(prop, newData) {
         const slug = prop['slug'];
+        if (app_framework_1.Logger.isDebugOn()) {
+            console.debug('getUserListValue-prop: ' + slug);
+        }
         const entityId = newData[slug + 'Id'];
         if (!entityId) {
             return {};
         }
         const cacheUser = DataConverter.getFromStaticCache(entityId);
         if (cacheUser) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('user cache hit: ' + entityId);
+            }
             return Object.assign({}, cacheUser);
         }
         const user = await this.getUserById(entityId);

package/package.json

@@ -1,66 +1,66 @@
-{
-  "name": "@contrail/flexplm",
-  "version": "1.7.4-alpha.72422a6",
-  "description": "Library used for integration with flexplm.",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "bin": {
-    "flexplm-mapping": "lib/cli/index.js"
-  },
-  "files": [
-    "lib/**/*",
-    "scripts/copy-template.js"
-  ],
-  "scripts": {
-    "build": "tsc; node scripts/copy-template.js",
-    "build:win": "tsc && node scripts/copy-template.js",
-    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-    "lint": "tslint -p tsconfig.json",
-    "test": "jest",
-    "test-watch": "jest --watch",
-    "test-debug": "jest --runInBand",
-    "test-coverage": "jest --coverage"
-  },
-  "keywords": [],
-  "author": "VibeIQ",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/jest": "^29.5.2",
-    "jest": "^29.5.0",
-    "prettier": "^1.19.1",
-    "ts-jest": "^29.1.1",
-    "tslint": "^5.11.0",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.0.0"
-  },
-  "peerDependencies": {
-    "typescript": ">=4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "typescript": {
-      "optional": true
-    }
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".spec.ts$",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
-  },
-  "dependencies": {
-    "@contrail/app-framework": "^1.4.3",
-    "@contrail/sdk": "^1.5.10",
-    "@contrail/transform-data": "^1.3.2",
-    "@contrail/util": "^1.3.1",
-    "axios": "^1.4.0",
-    "p-limit": "^3.1.0"
-  }
-}
+{
+  "name": "@contrail/flexplm",
+  "version": "1.7.4-alpha.858e2cc",
+  "description": "Library used for integration with flexplm.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": {
+    "flexplm-mapping": "lib/cli/index.js"
+  },
+  "files": [
+    "lib/**/*",
+    "scripts/copy-template.js"
+  ],
+  "scripts": {
+    "build": "tsc; node scripts/copy-template.js",
+    "build:win": "tsc && node scripts/copy-template.js",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "jest",
+    "test-watch": "jest --watch",
+    "test-debug": "jest --runInBand",
+    "test-coverage": "jest --coverage"
+  },
+  "keywords": [],
+  "author": "VibeIQ",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.2",
+    "jest": "^29.5.0",
+    "prettier": "^1.19.1",
+    "ts-jest": "^29.1.1",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.0.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  },
+  "dependencies": {
+    "@contrail/app-framework": "^1.4.3",
+    "@contrail/sdk": "^1.5.10",
+    "@contrail/transform-data": "^1.3.2",
+    "@contrail/util": "^1.3.1",
+    "axios": "^1.4.0",
+    "p-limit": "^3.1.0"
+  }
+}