@contrail/flexplm 1.1.67-alpha.2 → 1.1.67-alpha.4

package/CHANGELOG.md

@@ -11,6 +11,7 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 - Added EventShortMessageStatus status values for adding items to projects functionality.
+- Added `TypeConversionUtils.isOutboundCreatableFromEntity` method to determine if VibeIQ entities are creatable in FlexPLM (defaults to true).
 
 ### Changed
 - Added optional `context` parameter to `TypeConversionUtils.isInboundCreatableFromObject` method to allow passing context data to map file `isInboundCreatable` functions.

package/lib/interfaces/interfaces.d.ts

@@ -82,7 +82,7 @@ export interface ItemPayloadType extends EntityPayloadType {
     LCSProduct?: ProductFederation;
 }
 export interface SeasonalPayload extends EntityPayloadType {
-    eventType: 'UPSERT_ON_SEASON' | 'REMOVE_FROM_SEASON';
+    eventType: 'UPSERT_ON_SEASON' | 'UPDATE_ON_SEASON' | 'REMOVE_FROM_SEASON';
     objectClass: 'LCSProductSeasonLink' | 'LCSSKUSeasonLink';
     LCSSeason: SeasonFederation;
     LCSProduct?: ProductFederation;

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

@@ -759,6 +759,7 @@ class BaseProcessPublishAssortment {
         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
@@ -771,8 +772,10 @@ class BaseProcessPublishAssortment {
             let seasonalData = await this.getSeasonalData(projectItem);
             seasonalData = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSProductSeasonLink', 'vibe2flex');
             const LCSProduct = await this.getProductFederation(entityReference, itemToFederatedIdMapping, prodEntityData);
+            const isCreatable = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(this.transformMapFile, this.mapFileUtil, projectItem, { item: prodEntityData, assortment });
+            const eventType = isCreatable ? 'UPSERT_ON_SEASON' : 'UPDATE_ON_SEASON';
             const psUpsert = {
-                eventType: 'UPSERT_ON_SEASON',
+                eventType,
                 objectClass: 'LCSProductSeasonLink',
                 entityReference: 'item:' + entityReference,
                 LCSSeason,
@@ -801,8 +804,10 @@ class BaseProcessPublishAssortment {
             let seasonalData = await this.getSeasonalData(projectItem);
             seasonalData = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSSKUSeasonLink', 'vibe2flex');
             const LCSSKU = await this.getSKUFederation(entityReference, itemToFederatedIdMapping, item);
+            const isCreatable = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(this.transformMapFile, this.mapFileUtil, projectItem, { item, assortment });
+            const eventType = isCreatable ? 'UPSERT_ON_SEASON' : 'UPDATE_ON_SEASON';
             const csUpsert = {
-                eventType: 'UPSERT_ON_SEASON',
+                eventType,
                 objectClass: 'LCSSKUSeasonLink',
                 entityReference: 'item:' + entityReference,
                 LCSSeason,

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

@@ -1467,3 +1467,204 @@ describe('meetsCriteria', () => {
         expect(results).toBeTruthy();
     });
 });
+describe('getEventsForItemFamilyChanges - conditional eventType', () => {
+    const config = {
+        identifierAtts: {
+            LCSSeason: ['flexPLMSeasonName']
+        },
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should use UPSERT_ON_SEASON for LCSProductSeasonLink when isOutboundCreatableFromEntity returns true', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const itemFamilyId = 'family123';
+        const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+        const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+        const seasonFed = {
+            entityReference: 'assortment:assort123',
+            objectClass: 'LCSSeason',
+            flexPLMSeasonName: 'Fall 2023'
+        };
+        const itemFamilyChanges = new item_family_changes_1.ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+        itemFamilyChanges.familyAdd = true;
+        itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+            item: prodEntityData,
+            projectItem
+        });
+        jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+        jest.spyOn(bppa, 'getProjectItem').mockReturnValue(projectItem);
+        jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity').mockResolvedValue(true);
+        const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+        expect(events).toHaveLength(1);
+        expect(events[0].eventType).toBe('UPSERT_ON_SEASON');
+        expect(events[0].objectClass).toBe('LCSProductSeasonLink');
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(undefined, mapFileUtil, projectItem, { item: prodEntityData, assortment });
+    });
+    it('should use UPDATE_ON_SEASON for LCSProductSeasonLink when isOutboundCreatableFromEntity returns false', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const itemFamilyId = 'family123';
+        const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+        const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+        const seasonFed = {
+            entityReference: 'assortment:assort123',
+            objectClass: 'LCSSeason',
+            flexPLMSeasonName: 'Fall 2023'
+        };
+        const itemFamilyChanges = new item_family_changes_1.ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+        itemFamilyChanges.familyUpdate = true;
+        itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+            item: prodEntityData,
+            projectItem
+        });
+        jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+        jest.spyOn(bppa, 'getProjectItem').mockReturnValue(projectItem);
+        jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity').mockResolvedValue(false);
+        const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+        expect(events).toHaveLength(1);
+        expect(events[0].eventType).toBe('UPDATE_ON_SEASON');
+        expect(events[0].objectClass).toBe('LCSProductSeasonLink');
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(undefined, mapFileUtil, projectItem, { item: prodEntityData, assortment });
+    });
+    it('should use UPSERT_ON_SEASON for LCSSKUSeasonLink when isOutboundCreatableFromEntity returns true', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const itemFamilyId = 'family123';
+        const colorId = 'color456';
+        const familyItemData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+        const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+        const familyProjectItem = { id: 'proj0', updatedOn: '2023-01-14T00:00:00.000Z' };
+        const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+        const seasonFed = {
+            entityReference: 'assortment:assort123',
+            objectClass: 'LCSSeason',
+            flexPLMSeasonName: 'Fall 2023'
+        };
+        const itemFamilyChanges = new item_family_changes_1.ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+        itemFamilyChanges.colorAdds.push(colorId);
+        itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+            item: familyItemData,
+            projectItem: familyProjectItem
+        });
+        itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+            item: itemData,
+            projectItem
+        });
+        jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+        jest.spyOn(bppa, 'getProjectItem')
+            .mockReturnValueOnce(familyProjectItem)
+            .mockReturnValueOnce(projectItem);
+        jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity')
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(true);
+        const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+        expect(events).toHaveLength(2);
+        const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+        expect(skuEvent.eventType).toBe('UPSERT_ON_SEASON');
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(undefined, mapFileUtil, projectItem, { item: itemData, assortment });
+    });
+    it('should use UPDATE_ON_SEASON for LCSSKUSeasonLink when isOutboundCreatableFromEntity returns false', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const itemFamilyId = 'family123';
+        const colorId = 'color456';
+        const familyItemData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+        const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+        const familyProjectItem = { id: 'proj0', updatedOn: '2023-01-14T00:00:00.000Z' };
+        const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+        const seasonFed = {
+            entityReference: 'assortment:assort123',
+            objectClass: 'LCSSeason',
+            flexPLMSeasonName: 'Fall 2023'
+        };
+        const itemFamilyChanges = new item_family_changes_1.ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+        itemFamilyChanges.colorUpdates.push(colorId);
+        itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+            item: familyItemData,
+            projectItem: familyProjectItem
+        });
+        itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+            item: itemData,
+            projectItem
+        });
+        jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+        jest.spyOn(bppa, 'getProjectItem')
+            .mockReturnValueOnce(familyProjectItem)
+            .mockReturnValueOnce(projectItem);
+        jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity')
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(false);
+        const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+        expect(events).toHaveLength(2);
+        const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+        expect(skuEvent.eventType).toBe('UPDATE_ON_SEASON');
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(undefined, mapFileUtil, projectItem, { item: itemData, assortment });
+    });
+    it('should create both product and SKU events with correct eventTypes based on isOutboundCreatableFromEntity', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const itemFamilyId = 'family123';
+        const colorId = 'color456';
+        const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+        const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+        const familyProjectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const colorProjectItem = { id: 'proj2', updatedOn: '2023-01-15T00:00:00.000Z' };
+        const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+        const seasonFed = {
+            entityReference: 'assortment:assort123',
+            objectClass: 'LCSSeason',
+            flexPLMSeasonName: 'Fall 2023'
+        };
+        const itemFamilyChanges = new item_family_changes_1.ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+        itemFamilyChanges.familyAdd = true;
+        itemFamilyChanges.colorAdds.push(colorId);
+        itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+            item: prodEntityData,
+            projectItem: familyProjectItem
+        });
+        itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+            item: itemData,
+            projectItem: colorProjectItem
+        });
+        jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+        jest.spyOn(bppa, 'getProjectItem')
+            .mockReturnValueOnce(familyProjectItem)
+            .mockReturnValueOnce(colorProjectItem);
+        jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+        jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+        jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'isOutboundCreatableFromEntity')
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false);
+        const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+        expect(events).toHaveLength(2);
+        const productEvent = events.find(e => e.objectClass === 'LCSProductSeasonLink');
+        const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+        expect(productEvent.eventType).toBe('UPSERT_ON_SEASON');
+        expect(skuEvent.eventType).toBe('UPDATE_ON_SEASON');
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledTimes(2);
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenNthCalledWith(1, undefined, mapFileUtil, familyProjectItem, { item: prodEntityData, assortment });
+        expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenNthCalledWith(2, undefined, mapFileUtil, colorProjectItem, { item: itemData, assortment });
+    });
+});

package/lib/util/type-conversion-utils-spec-mockData.js

@@ -134,6 +134,9 @@ exports.mapping = {
         }
     },
     packaging: {
+        isOutboundCreatable: (entity, context) => {
+            return false;
+        },
         vibe2flex: {
             transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
             rekey: {
@@ -160,6 +163,12 @@ exports.mapping = {
             }
             return true;
         },
+        isOutboundCreatable: (entity, context) => {
+            if (context && context.skipPrefix) {
+                return false;
+            }
+            return true;
+        },
         vibe2flex: {
             transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
             rekey: {

package/lib/util/type-conversion-utils.d.ts

@@ -16,5 +16,6 @@ export declare class TypeConversionUtils {
     static getInformationalPropertiesFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any): Promise<string[]>;
     static getMapKeyFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any, direction: string): Promise<string>;
     static isInboundCreatableFromObject(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean>;
+    static isOutboundCreatableFromEntity(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean>;
     static getObjectType(object: any): any;
 }

package/lib/util/type-conversion-utils.js

@@ -191,6 +191,27 @@ class TypeConversionUtils {
         }
         return isInboundCreatable;
     }
+    static async isOutboundCreatableFromEntity(fileId, mapFileUtil, entity, context) {
+        let isOutboundCreatable = true;
+        if (!fileId) {
+            return isOutboundCreatable;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        catch {
+            return isOutboundCreatable;
+        }
+        if (!mapKey) {
+            return isOutboundCreatable;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['isOutboundCreatable']) {
+            isOutboundCreatable = await mapData['isOutboundCreatable'](entity, context);
+        }
+        return isOutboundCreatable;
+    }
     static getObjectType(object) {
         let objectType = object['flexPLMObjectClass'];
         return objectType;

package/lib/util/type-conversion-utils.spec.js

@@ -616,4 +616,93 @@ describe('conversion-utils', () => {
             }
         });
     });
+    describe('isOutboundCreatableFromEntity', () => {
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        it('should return false for custom-entity:pack', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:pack'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should return true for custom-entity:prefix', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:prefix'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should pass context to isOutboundCreatable function', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:prefix'
+            };
+            const context = { skipPrefix: true };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should work without context parameter', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:prefix'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should default to true when no mapping exists', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:catName'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+    });
 });

package/package.json

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

package/src/interfaces/interfaces.ts

@@ -93,7 +93,7 @@ export interface ItemPayloadType extends EntityPayloadType {
 ///////// Custom seasonalPayload: start
 /////////////////////////////////////////////////////////////////////////////
 export interface SeasonalPayload extends EntityPayloadType {
-    eventType: 'UPSERT_ON_SEASON' | 'REMOVE_FROM_SEASON';
+    eventType: 'UPSERT_ON_SEASON' | 'UPDATE_ON_SEASON' | 'REMOVE_FROM_SEASON';
     objectClass: 'LCSProductSeasonLink' | 'LCSSKUSeasonLink';
     LCSSeason : SeasonFederation;
     LCSProduct? : ProductFederation;

package/src/publish/base-process-publish-assortment.spec.ts

@@ -1713,4 +1713,280 @@ describe('meetsCriteria', () =>{
     expect(results).toBeTruthy();
   });
 
+});
+
+describe('getEventsForItemFamilyChanges - conditional eventType', () => {
+  const config = {
+    identifierAtts: {
+      LCSSeason: ['flexPLMSeasonName']
+    },
+    itemPreDevelopmentLifecycleStages: ['concept']
+  } as unknown as FCConfig;
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should use UPSERT_ON_SEASON for LCSProductSeasonLink when isOutboundCreatableFromEntity returns true', async () => {
+    const bppa = new BaseProcessPublishAssortment(config, dc, mapFileUtil);
+
+    const itemFamilyId = 'family123';
+    const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+    const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+    const seasonFed: SeasonFederation = {
+      entityReference: 'assortment:assort123',
+      objectClass: 'LCSSeason',
+      flexPLMSeasonName: 'Fall 2023'
+    };
+
+    const itemFamilyChanges = new ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+    itemFamilyChanges.familyAdd = true;
+    itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+      item: prodEntityData,
+      projectItem
+    });
+
+    jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+    jest.spyOn(bppa, 'getProjectItem').mockReturnValue(projectItem);
+    jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+    jest.spyOn(MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+    jest.spyOn(TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+    jest.spyOn(TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+    jest.spyOn(TypeConversionUtils, 'isOutboundCreatableFromEntity').mockResolvedValue(true);
+
+    const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+
+    expect(events).toHaveLength(1);
+    expect(events[0].eventType).toBe('UPSERT_ON_SEASON');
+    expect(events[0].objectClass).toBe('LCSProductSeasonLink');
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(
+      undefined,
+      mapFileUtil,
+      projectItem,
+      { item: prodEntityData, assortment }
+    );
+  });
+
+  it('should use UPDATE_ON_SEASON for LCSProductSeasonLink when isOutboundCreatableFromEntity returns false', async () => {
+    const bppa = new BaseProcessPublishAssortment(config, dc, mapFileUtil);
+
+    const itemFamilyId = 'family123';
+    const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+    const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+    const seasonFed: SeasonFederation = {
+      entityReference: 'assortment:assort123',
+      objectClass: 'LCSSeason',
+      flexPLMSeasonName: 'Fall 2023'
+    };
+
+    const itemFamilyChanges = new ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+    itemFamilyChanges.familyUpdate = true;
+    itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+      item: prodEntityData,
+      projectItem
+    });
+
+    jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+    jest.spyOn(bppa, 'getProjectItem').mockReturnValue(projectItem);
+    jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+    jest.spyOn(MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+    jest.spyOn(TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+    jest.spyOn(TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+    jest.spyOn(TypeConversionUtils, 'isOutboundCreatableFromEntity').mockResolvedValue(false);
+
+    const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+
+    expect(events).toHaveLength(1);
+    expect(events[0].eventType).toBe('UPDATE_ON_SEASON');
+    expect(events[0].objectClass).toBe('LCSProductSeasonLink');
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(
+      undefined,
+      mapFileUtil,
+      projectItem,
+      { item: prodEntityData, assortment }
+    );
+  });
+
+  it('should use UPSERT_ON_SEASON for LCSSKUSeasonLink when isOutboundCreatableFromEntity returns true', async () => {
+    const bppa = new BaseProcessPublishAssortment(config, dc, mapFileUtil);
+
+    const itemFamilyId = 'family123';
+    const colorId = 'color456';
+    const familyItemData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+    const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+    const familyProjectItem = { id: 'proj0', updatedOn: '2023-01-14T00:00:00.000Z' };
+    const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+    const seasonFed: SeasonFederation = {
+      entityReference: 'assortment:assort123',
+      objectClass: 'LCSSeason',
+      flexPLMSeasonName: 'Fall 2023'
+    };
+
+    const itemFamilyChanges = new ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+    itemFamilyChanges.colorAdds.push(colorId);
+    itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+      item: familyItemData,
+      projectItem: familyProjectItem
+    });
+    itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+      item: itemData,
+      projectItem
+    });
+
+    jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+    jest.spyOn(bppa, 'getProjectItem')
+      .mockReturnValueOnce(familyProjectItem)
+      .mockReturnValueOnce(projectItem);
+    jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+    jest.spyOn(MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+    jest.spyOn(TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+    jest.spyOn(TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+    jest.spyOn(TypeConversionUtils, 'isOutboundCreatableFromEntity')
+      .mockResolvedValueOnce(true) // for family
+      .mockResolvedValueOnce(true); // for SKU
+
+    const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+
+    // Should have both family and SKU events because familyAssortmentItem is true when colorAdds.length > 0
+    expect(events).toHaveLength(2);
+    
+    const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+    expect(skuEvent.eventType).toBe('UPSERT_ON_SEASON');
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(
+      undefined,
+      mapFileUtil,
+      projectItem,
+      { item: itemData, assortment }
+    );
+  });
+
+  it('should use UPDATE_ON_SEASON for LCSSKUSeasonLink when isOutboundCreatableFromEntity returns false', async () => {
+    const bppa = new BaseProcessPublishAssortment(config, dc, mapFileUtil);
+
+    const itemFamilyId = 'family123';
+    const colorId = 'color456';
+    const familyItemData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+    const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+    const familyProjectItem = { id: 'proj0', updatedOn: '2023-01-14T00:00:00.000Z' };
+    const projectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+    const seasonFed: SeasonFederation = {
+      entityReference: 'assortment:assort123',
+      objectClass: 'LCSSeason',
+      flexPLMSeasonName: 'Fall 2023'
+    };
+
+    const itemFamilyChanges = new ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+    itemFamilyChanges.colorUpdates.push(colorId);
+    itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+      item: familyItemData,
+      projectItem: familyProjectItem
+    });
+    itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+      item: itemData,
+      projectItem
+    });
+
+    jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+    jest.spyOn(bppa, 'getProjectItem')
+      .mockReturnValueOnce(familyProjectItem)
+      .mockReturnValueOnce(projectItem);
+    jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+    jest.spyOn(MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+    jest.spyOn(TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+    jest.spyOn(TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+    jest.spyOn(TypeConversionUtils, 'isOutboundCreatableFromEntity')
+      .mockResolvedValueOnce(false) // for family
+      .mockResolvedValueOnce(false); // for SKU
+
+    const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+
+    // Should have both family and SKU events because familyAssortmentItem is true when colorUpdates.length > 0
+    expect(events).toHaveLength(2);
+    
+    const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+    expect(skuEvent.eventType).toBe('UPDATE_ON_SEASON');
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledWith(
+      undefined,
+      mapFileUtil,
+      projectItem,
+      { item: itemData, assortment }
+    );
+  });
+
+  it('should create both product and SKU events with correct eventTypes based on isOutboundCreatableFromEntity', async () => {
+    const bppa = new BaseProcessPublishAssortment(config, dc, mapFileUtil);
+
+    const itemFamilyId = 'family123';
+    const colorId = 'color456';
+    const prodEntityData = { id: itemFamilyId, identifier: 'FAM-123', itemNumber: 'FAM-123' };
+    const itemData = { id: colorId, identifier: 'COLOR-456', itemNumber: 'COLOR-456' };
+    const familyProjectItem = { id: 'proj1', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const colorProjectItem = { id: 'proj2', updatedOn: '2023-01-15T00:00:00.000Z' };
+    const assortment = { id: 'assort123', name: 'Fall 2023 Assortment', publishToFlexPLM: true };
+    const seasonFed: SeasonFederation = {
+      entityReference: 'assortment:assort123',
+      objectClass: 'LCSSeason',
+      flexPLMSeasonName: 'Fall 2023'
+    };
+
+    const itemFamilyChanges = new ItemFamilyChanges(itemFamilyId, new Date('2023-01-01T00:00:00.000Z'));
+    itemFamilyChanges.familyAdd = true;
+    itemFamilyChanges.colorAdds.push(colorId);
+    itemFamilyChanges.assortmentItemFullChangeMap.set(itemFamilyId, {
+      item: prodEntityData,
+      projectItem: familyProjectItem
+    });
+    itemFamilyChanges.assortmentItemFullChangeMap.set(colorId, {
+      item: itemData,
+      projectItem: colorProjectItem
+    });
+
+    jest.spyOn(bppa, 'getAssortment').mockResolvedValue(assortment);
+    jest.spyOn(bppa, 'getProjectItem')
+      .mockReturnValueOnce(familyProjectItem)
+      .mockReturnValueOnce(colorProjectItem);
+    jest.spyOn(bppa, 'getSeasonalData').mockResolvedValue({ someData: 'value' });
+    jest.spyOn(MapUtil, 'applyTransformMap').mockResolvedValue({ transformedData: 'value' });
+    jest.spyOn(TypeConversionUtils, 'getIdentifierProperties').mockResolvedValue(['identifier']);
+    jest.spyOn(TypeConversionUtils, 'getInformationalProperties').mockResolvedValue([]);
+    // Product is creatable (true), SKU is not (false)
+    jest.spyOn(TypeConversionUtils, 'isOutboundCreatableFromEntity')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false);
+
+    const events = await bppa.getEventsForItemFamilyChanges(itemFamilyChanges, 'assort123', seasonFed, new Map());
+
+    expect(events).toHaveLength(2);
+    
+    const productEvent = events.find(e => e.objectClass === 'LCSProductSeasonLink');
+    const skuEvent = events.find(e => e.objectClass === 'LCSSKUSeasonLink');
+    
+    expect(productEvent.eventType).toBe('UPSERT_ON_SEASON');
+    expect(skuEvent.eventType).toBe('UPDATE_ON_SEASON');
+    
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenCalledTimes(2);
+    // Verify product event called with assortment entity
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenNthCalledWith(
+      1,
+      undefined,
+      mapFileUtil,
+      familyProjectItem,
+      { item: prodEntityData, assortment }
+    );
+    // Verify SKU event called with assortment entity
+    expect(TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenNthCalledWith(
+      2,
+      undefined,
+      mapFileUtil,
+      colorProjectItem,
+      { item: itemData, assortment }
+    );
+  });
+
 });

package/src/publish/base-process-publish-assortment.ts

@@ -906,7 +906,7 @@ export class BaseProcessPublishAssortment {
     console.info('getEventsForItemFamilyChanges()');
     const events: SeasonalPayload[] = [];
     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
@@ -925,8 +925,12 @@ export class BaseProcessPublishAssortment {
       seasonalData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSProductSeasonLink', 'vibe2flex');
 
       const LCSProduct: ProductFederation = await this.getProductFederation(entityReference, itemToFederatedIdMapping, prodEntityData);
+      
+      const isCreatable = await TypeConversionUtils.isOutboundCreatableFromEntity(this.transformMapFile, this.mapFileUtil, projectItem, { item: prodEntityData, assortment });
+      const eventType = isCreatable ? 'UPSERT_ON_SEASON' : 'UPDATE_ON_SEASON';
+      
       const psUpsert: SeasonalPayload = {
-        eventType: 'UPSERT_ON_SEASON',
+        eventType,
         objectClass: 'LCSProductSeasonLink',
         entityReference: 'item:' + entityReference,
         LCSSeason,
@@ -962,8 +966,12 @@ export class BaseProcessPublishAssortment {
       seasonalData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSSKUSeasonLink', 'vibe2flex');
 
       const LCSSKU: SkuFederation = await this.getSKUFederation(entityReference, itemToFederatedIdMapping, item);
+      
+      const isCreatable = await TypeConversionUtils.isOutboundCreatableFromEntity(this.transformMapFile, this.mapFileUtil, projectItem, { item, assortment });
+      const eventType = isCreatable ? 'UPSERT_ON_SEASON' : 'UPDATE_ON_SEASON';
+      
       const csUpsert: SeasonalPayload = {
-        eventType: 'UPSERT_ON_SEASON',
+        eventType,
         objectClass: 'LCSSKUSeasonLink',
         entityReference: 'item:' + entityReference,
         LCSSeason,

package/src/util/event-short-message-status.ts

@@ -2,9 +2,9 @@ export enum EventShortMessageStatus {
   SUCCESS = 'Success',
   FAILURE = 'Failure',
   CREATED = 'Created',
-  ITEM_FAMILY_ID_MISSING = "Item_family_id_missing",
-  ITEM_FAMILY_NOT_FOUND = "Item_family_not_found",
-  PROJECT_ITEM_NOT_FOUND = "Project_item_not_found",
+  ITEM_FAMILY_ID_MISSING = 'Item_family_id_missing',
+  ITEM_FAMILY_NOT_FOUND = 'Item_family_not_found',
+  PROJECT_ITEM_NOT_FOUND = 'Project_item_not_found',
   MISSING_IDENTIFIER_PROPERTIES = 'Missing_identifier_properties',
   MISSING_INPUT = 'Missing_input',
   NOT_CREATABLE = 'Not_creatable',

package/src/util/type-conversion-utils-spec-mockData.ts

@@ -139,6 +139,9 @@ exports.mapping = {
   },
 
   packaging: {
+    isOutboundCreatable: (entity, context) => {
+      return false;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {
@@ -166,6 +169,12 @@ exports.mapping = {
       }
       return true;
     },
+    isOutboundCreatable: (entity, context) => {
+      if (context && context.skipPrefix) {
+        return false;
+      }
+      return true;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {

package/src/util/type-conversion-utils.spec.ts

@@ -680,4 +680,105 @@ describe('conversion-utils', () => {
     });
 
   });
+
+  describe('isOutboundCreatableFromEntity', () =>{
+    const mapFileUtil = new MapFileUtil(new Entities());
+
+    it('should return false for custom-entity:pack', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      try{
+        const results = await TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should return true for custom-entity:prefix', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should pass context to isOutboundCreatable function', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+      const context = { skipPrefix: true };
+
+      try{
+        const results = await TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should work without context parameter', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to true when no mapping exists', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:catName'
+      }
+
+      try{
+        const results = await TypeConversionUtils.isOutboundCreatableFromEntity(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+  });
 });

package/src/util/type-conversion-utils.ts

@@ -351,6 +351,32 @@ export class TypeConversionUtils {
     return isInboundCreatable;
   }
 
+  static async isOutboundCreatableFromEntity(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean> {
+
+    let isOutboundCreatable = true;
+
+    if (!fileId) {
+      return isOutboundCreatable;
+    }
+
+    let mapKey: string | undefined;
+    try {
+      mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+    } catch {
+      return isOutboundCreatable;
+    }
+
+    if (!mapKey) {
+      return isOutboundCreatable;
+    }
+
+    const mapData = await MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+    if (mapData && mapData['isOutboundCreatable']) {
+      isOutboundCreatable = await mapData['isOutboundCreatable'](entity, context);
+    }
+    return isOutboundCreatable;
+  }
+
   static getObjectType(object:any) {
     let objectType = object['flexPLMObjectClass'];
     return objectType;