@contrail/flexplm 1.4.0 → 1.5.0-alpha.0d65410

package/CHANGELOG.md

@@ -7,6 +7,11 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.5.0] - 2026-05-12
+### Added
+- Added support for Inbound `LCSMaterial` to sync to the entity class `item` with type path `item:material` and `itemNumber` as identifier.  This is controlled by an `LCSMaterial.processAsItem` (default `false`) config default.
+- Added optional identity-service lookup in `DataConverter.setObjectReferenceValue` for resolving inbound `object_reference` values. Enabled per referenced entity type via `config.search.<entityType>.useIdentityServiceForInboundData`. When enabled the reference is resolved via the identity service using a uniqueness pool key; otherwise behavior falls through to the existing `getAllObjectReferences` query path.
+
 ## [1.4.0] - 2026-05-06
 ### Added
 - Added `getEntityUsingIdentityService` method to `BaseEntityProcessor` for looking up entities via the identity service using a pool key and property criteria. Returns the resolved entity from the identity's `entityReference`, `undefined` if not found, or throws if multiple matches exist.

package/lib/transform/identifier-conversion.js

@@ -201,7 +201,7 @@ class IdentifierConversion {
     }
     static async getItemCriteriaFromObject(transformMapFile, mapFileUtil, dc, object) {
         const criteria = await IdentifierConversion.getEntityCriteriaFromObject(transformMapFile, mapFileUtil, dc, object);
-        const roles = (object.flexPLMObjectClass === 'LCSProduct') ? 'family' : 'color';
+        const roles = (['LCSProduct', 'LCSMaterial'].includes(object.flexPLMObjectClass)) ? 'family' : 'color';
         criteria['roles'] = roles;
         return criteria;
     }

package/lib/transform/identifier-conversion.spec.js

@@ -4,6 +4,7 @@ const transform_data_1 = require("@contrail/transform-data");
 const identifier_conversion_1 = require("./identifier-conversion");
 const data_converter_1 = require("../util/data-converter");
 const sdk_1 = require("@contrail/sdk");
+const type_defaults_1 = require("../util/type-defaults");
 const mapFile1Data = require('./identifier-conversion-spec-mockData');
 const mapFile1Mappings = mapFile1Data?.mapping;
 const mapFile2Mappings = mapFile1Data?.mapping2;
@@ -296,6 +297,36 @@ describe('getItemCriteriaFromObject', () => {
             }
         }
     });
+    it('should return the item family criteria from the object -LCSMaterial', async () => {
+        const object = {
+            "flexPLMObjectClass": "LCSMaterial",
+            "flexPLMTypePath": "Material\\form",
+            "itemNumber": "MAT-100"
+        };
+        const criteriaObject = {
+            flexPLMObjectClass: 'LCSMaterial',
+            itemNumber: 'MAT-100',
+            flexPLMTypePath: 'Material\\form',
+        };
+        const resultsObject = {
+            roles: 'family',
+            itemNumber: 'MAT-100'
+        };
+        let getEntityValuesSpyOn = undefined;
+        type_defaults_1.TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+        try {
+            getEntityValuesSpyOn = jest.spyOn(dc, 'getEntityValues');
+            const result = await identifier_conversion_1.IdentifierConversion.getItemCriteriaFromObject(transformMapFile1, mapFileUtil, dc, object);
+            expect(getEntityValuesSpyOn).toHaveBeenCalledWith('LCSMaterial', criteriaObject, []);
+            expect(result).toEqual(resultsObject);
+        }
+        finally {
+            if (getEntityValuesSpyOn) {
+                getEntityValuesSpyOn.mockRestore();
+            }
+            type_defaults_1.TypeDefaults.applyConfig({});
+        }
+    });
     it('should return the item option criteria from the object -uniqueIdentifierA, uniqueIdentifierB', async () => {
         const object = {
             "flexBoolean": false,

package/lib/util/config-defaults.d.ts

@@ -3,6 +3,24 @@ export declare class ConfigDefaults {
     static NEED_CONFIG_VALUES: string;
     static STATIC_CONFIG_CACHE: {};
     static setConfigDefaults(config: any): Promise<FCConfig>;
+    static getDefaultConfig(): {
+        urlContext: string;
+        sendMode: {
+            ASYNC_PUBLISH_SEASON: string;
+        };
+        itemPreDevelopmentLifecycleStages: string[];
+        identifierAtts: {
+            LCSProduct: string[];
+            LCSSeason: string[];
+            LCSSKU: string[];
+        };
+        LCSMaterial: {
+            processAsItem: boolean;
+        };
+        csrfEndpoint: string;
+        vibeEventEndpoint: string;
+        payloadDefaultAsArray: boolean;
+    };
     static getConfigFile(fileId: string): Promise<any>;
     static isPropertyTrue(value: any): boolean;
     static clearConfigCache(): void;

package/lib/util/config-defaults.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigDefaults = void 0;
 const sdk_1 = require("@contrail/sdk");
 const util_1 = require("@contrail/util");
+const type_defaults_1 = require("./type-defaults");
 class ConfigDefaults {
     static async setConfigDefaults(config) {
         if (!config.apiHost || !config.userName || !config.password) {
@@ -14,7 +15,24 @@ class ConfigDefaults {
         else if (Object.keys(config).includes('itemPreDevelopmentLifecycleStages')) {
             delete config['itemPreDevelopmentLifecycleStages'];
         }
-        const defaultConfig = {
+        const configArr = [ConfigDefaults.getDefaultConfig()];
+        if (config.configFile) {
+            const fileConfig = await ConfigDefaults.getConfigFile(config.configFile);
+            configArr.push(fileConfig);
+        }
+        configArr.push(config);
+        const outputConfig = util_1.ObjectUtil.mergeDeep({}, ...configArr);
+        const uName = outputConfig.userName;
+        const pass = outputConfig.password;
+        outputConfig.userName = () => uName;
+        outputConfig.password = () => pass;
+        outputConfig['OOBvibeEventEndpoint'] = '/rfa/vibeiq/vibeEvents';
+        type_defaults_1.TypeDefaults.applyConfig(outputConfig);
+        console.log('outputConfig: ' + JSON.stringify(outputConfig));
+        return outputConfig;
+    }
+    static getDefaultConfig() {
+        return {
             urlContext: '/Windchill',
             sendMode: {
                 ASYNC_PUBLISH_SEASON: 'vibeiqfile'
@@ -25,24 +43,13 @@ class ConfigDefaults {
                 LCSSeason: ['flexPLMSeasonName'],
                 LCSSKU: ['itemNumber']
             },
+            LCSMaterial: {
+                processAsItem: false
+            },
             csrfEndpoint: '/servlet/rest/security/csrf',
             vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
             payloadDefaultAsArray: true
         };
-        const configArr = [defaultConfig];
-        if (config.configFile) {
-            const fileConfig = await ConfigDefaults.getConfigFile(config.configFile);
-            configArr.push(fileConfig);
-        }
-        configArr.push(config);
-        const outputConfig = util_1.ObjectUtil.mergeDeep({}, ...configArr);
-        const uName = outputConfig.userName;
-        const pass = outputConfig.password;
-        outputConfig.userName = () => uName;
-        outputConfig.password = () => pass;
-        outputConfig['OOBvibeEventEndpoint'] = '/rfa/vibeiq/vibeEvents';
-        console.log('outputConfig: ' + JSON.stringify(outputConfig));
-        return outputConfig;
     }
     static async getConfigFile(fileId) {
         try {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_defaults_1 = require("./config-defaults");
+const type_defaults_1 = require("./type-defaults");
 let entityObject = {};
 jest.mock('@contrail/sdk', () => {
     return {
@@ -296,6 +297,52 @@ describe('all tests', () => {
             expect(config_defaults_1.ConfigDefaults.isPropertyTrue(1)).toBe(false);
         });
     });
+    describe('getDefaultConfig', () => {
+        it('returns LCSMaterial.processAsItem=false by default', () => {
+            const dc = config_defaults_1.ConfigDefaults.getDefaultConfig();
+            expect(dc.LCSMaterial).toBeDefined();
+            expect(dc.LCSMaterial.processAsItem).toBe(false);
+        });
+        it('returns a fresh object each call (no shared reference)', () => {
+            const a = config_defaults_1.ConfigDefaults.getDefaultConfig();
+            const b = config_defaults_1.ConfigDefaults.getDefaultConfig();
+            expect(a).not.toBe(b);
+            expect(a.LCSMaterial).not.toBe(b.LCSMaterial);
+            a.LCSMaterial.processAsItem = true;
+            expect(b.LCSMaterial.processAsItem).toBe(false);
+        });
+    });
+    describe('setConfigDefaults - LCSMaterial', () => {
+        const config = {
+            apiHost: 'http://test.com',
+            userName: 'vibeiq',
+            password: 'vibeiq'
+        };
+        it('LCSMaterial.processAsItem-get default', async () => {
+            const startConfig = Object.assign({}, config);
+            const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+            expect(fcConfig.LCSMaterial.processAsItem).toBe(false);
+        });
+        it('LCSMaterial.processAsItem-override', async () => {
+            const startConfig = Object.assign({}, config);
+            startConfig.LCSMaterial = { processAsItem: true };
+            const fcConfig = await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+            expect(fcConfig.LCSMaterial.processAsItem).toBe(true);
+        });
+        it('applies LCSMaterial.processAsItem to TypeDefaults', async () => {
+            try {
+                const startConfig = Object.assign({}, config, { LCSMaterial: { processAsItem: true } });
+                await config_defaults_1.ConfigDefaults.setConfigDefaults(startConfig);
+                expect(type_defaults_1.TypeDefaults.processLCSMaterialAsItem).toBe(true);
+                const defaultStart = Object.assign({}, config);
+                await config_defaults_1.ConfigDefaults.setConfigDefaults(defaultStart);
+                expect(type_defaults_1.TypeDefaults.processLCSMaterialAsItem).toBe(false);
+            }
+            finally {
+                type_defaults_1.TypeDefaults.applyConfig({});
+            }
+        });
+    });
     describe('getConfigFile', () => {
         beforeEach(() => {
             config_defaults_1.ConfigDefaults.clearConfigCache();

package/lib/util/data-converter.d.ts

@@ -28,6 +28,11 @@ export declare class DataConverter {
     setEnumerationKeys(prop: any, nd: any, matchByDisplay: any): any;
     getPersistableChanges(entity: object, changes: object): object;
     setObjectReferenceValue(prop: any, nd: any): Promise<any>;
+    private applyInboundTransformMap;
+    private buildObjectReferenceContext;
+    private lookupObjectReferenceViaIdentityService;
+    private lookupObjectReferenceViaQuery;
+    private pickSingleResult;
     getAllObjectReferences(entityType: string, rootTypeCriteria: any, postProcessCriteria?: any): Promise<any[]>;
     checkKeysAndValues(criteria: any, arrayOfObjects: any, entityTypePath: any): any[];
     filterOutArchivedAndTrashedEntities(entities: any[]): any[];

package/lib/util/data-converter.js

@@ -7,6 +7,7 @@ const app_framework_1 = require("@contrail/app-framework");
 const util_1 = require("@contrail/util");
 const type_conversion_utils_1 = require("./type-conversion-utils");
 const map_utils_1 = require("./map-utils");
+const config_defaults_1 = require("./config-defaults");
 class DataConverter {
     static clearStaticUserCache() {
         DataConverter.staticUserCache = {};
@@ -235,7 +236,7 @@ class DataConverter {
         const type = await this.typeUtils.getByRootAndPath(tco);
         const typePath = type['typePath'];
         if (typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))) {
-            if (['LCSProduct', 'LCSProductSeasonLink'].includes(objectClass)) {
+            if (['LCSProduct', 'LCSProductSeasonLink', 'LCSMaterial'].includes(objectClass)) {
                 entityValues['roles'] = ['family'];
             }
             else {
@@ -347,30 +348,51 @@ class DataConverter {
         return diffValues;
     }
     async setObjectReferenceValue(prop, nd) {
-        let objectReferenceId = "";
         if (!nd) {
-            return objectReferenceId;
+            return "";
+        }
+        nd = await this.applyInboundTransformMap(nd);
+        const ctx = await this.buildObjectReferenceContext(prop, nd);
+        if (!ctx) {
+            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];
         }
-        if (this.transformMapFile) {
-            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, nd, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
-            nd = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, nd, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        const objectReferenceId = ctx.useIdentityService
+            ? await this.lookupObjectReferenceViaIdentityService(ctx, nd)
+            : await this.lookupObjectReferenceViaQuery(ctx);
+        if (objectReferenceId) {
+            this.objRefCache[ctx.cacheKey] = objectReferenceId;
         }
+        return objectReferenceId;
+    }
+    async applyInboundTransformMap(nd) {
+        if (!this.transformMapFile) {
+            return nd;
+        }
+        const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, nd, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        return map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, nd, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+    }
+    async buildObjectReferenceContext(prop, nd) {
         const entityType = prop['referencedTypeRootSlug'];
         const entityTypePath = prop['referencedTypePath'];
         const entityKeys = Object.keys(nd);
         const identifierKeys = await type_conversion_utils_1.TypeConversionUtils.getIdentifierPropertiesFromObject(this.transformMapFile, this.mapFileUtil, nd);
         const hasAllIdentifiers = identifierKeys.every(key => entityKeys.includes(key));
-        if (identifierKeys.length == 0 || !hasAllIdentifiers) {
+        if (identifierKeys.length === 0 || !hasAllIdentifiers) {
             console.warn(`The inbound ${entityType} for prop '${prop['slug']}' doesnt have all "identifier" properties, so there is no processing. Identifier properties: ${identifierKeys}`);
-            return objectReferenceId;
+            return null;
         }
         const rootType = await this.typeUtils.getByRootAndPath({ root: entityType });
         const rootTypeProps = this.typeUtils.filterTypeProperties(rootType, nd);
-        let rootTypeCriteria = {};
-        let typeCriteria = {};
+        const rootTypeCriteria = {};
+        const typeCriteria = {};
         identifierKeys.forEach(keyName => {
-            const foundInObjects = rootTypeProps.some(obj => obj.slug === keyName);
-            if (foundInObjects) {
+            if (rootTypeProps.some(obj => obj.slug === keyName)) {
                 rootTypeCriteria[keyName] = nd[keyName];
             }
             else {
@@ -379,30 +401,43 @@ class DataConverter {
         });
         const combinedCriteria = { ...rootTypeCriteria, ...typeCriteria, typePath: entityTypePath };
         const cacheKey = Object.values(combinedCriteria).join('_');
-        if (this.objRefCache[cacheKey]) {
-            if (app_framework_1.Logger.isDebugOn()) {
-                console.debug(`object reference cache hit: ${cacheKey}`);
-            }
-            return this.objRefCache[cacheKey];
-        }
-        let arrObjectReferences = await this.getAllObjectReferences(entityType, rootTypeCriteria);
-        if (entityType !== entityTypePath) {
-            arrObjectReferences = this.checkKeysAndValues(typeCriteria, arrObjectReferences, entityTypePath);
-        }
-        if (arrObjectReferences.length) {
-            if (arrObjectReferences.length === 1) {
-                objectReferenceId = arrObjectReferences[0].id;
-            }
-            else {
-                console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
-            }
+        const rolesIsTypeDiscriminator = entityType === 'item' || entityType === 'project-item';
+        const identityLookupKeys = rolesIsTypeDiscriminator
+            ? identifierKeys.filter(key => key !== 'roles')
+            : identifierKeys;
+        const useIdentityService = config_defaults_1.ConfigDefaults.isPropertyTrue(this.config?.search?.[entityType]?.useIdentityServiceForInboundData)
+            && identityLookupKeys.length === 1;
+        return { entityType, entityTypePath, rootTypeCriteria, typeCriteria, combinedCriteria, cacheKey, useIdentityService, identityLookupKeys };
+    }
+    async lookupObjectReferenceViaIdentityService(ctx, nd) {
+        const propertyName = ctx.identityLookupKeys[0];
+        const propertyValue = nd[propertyName];
+        const poolKey = await type_conversion_utils_1.TypeConversionUtils.getUniquenessPoolKeyFromObject(this.transformMapFile, this.mapFileUtil, nd);
+        const identityResults = await new sdk_1.Entities().get({
+            entityName: 'identity',
+            criteria: { poolKey, propertyName, propertyValue }
+        }) ?? [];
+        const match = this.pickSingleResult(identityResults, ctx.combinedCriteria);
+        return match ? match.entityReference.split(':')[1] : "";
+    }
+    async lookupObjectReferenceViaQuery(ctx) {
+        let arrObjectReferences = await this.getAllObjectReferences(ctx.entityType, ctx.rootTypeCriteria);
+        if (ctx.entityType !== ctx.entityTypePath) {
+            arrObjectReferences = this.checkKeysAndValues(ctx.typeCriteria, arrObjectReferences, ctx.entityTypePath);
         }
-        if (!objectReferenceId) {
+        const match = this.pickSingleResult(arrObjectReferences, ctx.combinedCriteria);
+        return match ? match.id : "";
+    }
+    pickSingleResult(results, combinedCriteria) {
+        if (!results.length) {
             console.warn(`The passed in object reference criteria ${JSON.stringify(combinedCriteria)} didn't match any entities.`);
-            return objectReferenceId;
+            return undefined;
         }
-        this.objRefCache[cacheKey] = objectReferenceId;
-        return objectReferenceId;
+        if (results.length > 1) {
+            console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
+            return undefined;
+        }
+        return results[0];
     }
     async getAllObjectReferences(entityType, rootTypeCriteria, postProcessCriteria = null) {
         const entities = new sdk_1.Entities();