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

package/lib/util/data-converter.spec.js

@@ -454,6 +454,393 @@ describe('getObjectReferenceValue bad value', () => {
         }
     });
 });
+describe('setObjectReferenceValue - identity service', () => {
+    const baseConfig = () => ({
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    });
+    const refProp = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'material',
+        label: 'Material',
+        referencedTypeRootSlug: 'item',
+        referencedTypePath: 'item:material'
+    };
+    let identifierSpy;
+    let poolKeySpy;
+    let getByRootAndPathSpy;
+    let filterTypePropertiesSpy;
+    const setupTypeUtilsSpies = (dc, rootPropSlugs = ['itemNumber']) => {
+        getByRootAndPathSpy = jest.spyOn(dc['typeUtils'], 'getByRootAndPath')
+            .mockImplementation(async () => ({ typePath: 'item', typeProperties: [] }));
+        filterTypePropertiesSpy = jest.spyOn(dc['typeUtils'], 'filterTypeProperties')
+            .mockImplementation(() => rootPropSlugs.map(slug => ({ slug })));
+    };
+    afterEach(() => {
+        identifierSpy?.mockRestore();
+        poolKeySpy?.mockRestore();
+        getByRootAndPathSpy?.mockRestore();
+        filterTypePropertiesSpy?.mockRestore();
+        mockGetFunction.mockReset();
+        mockGetFunction.mockImplementation((options) => ((options?.criteria?.id === 1234) ? [mockObj1234] : [mockObj2222]));
+    });
+    it('flag off - uses getAllObjectReferences path', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'abc123', typePath: 'item:material' }]);
+        const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+        const result = await dc.setObjectReferenceValue(refProp, nd);
+        expect(mockGetFunction).toHaveBeenCalled();
+        const callArg = mockGetFunction.mock.calls[0][0];
+        expect(callArg.entityName).toEqual('item');
+        expect(callArg.entityName).not.toEqual('identity');
+        expect(result).toEqual('abc123');
+        expect(poolKeySpy).not.toHaveBeenCalled();
+    });
+    it('flag on, single identity match - returns parsed id', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ entityReference: 'item:abc123' }]);
+        const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+        const result = await dc.setObjectReferenceValue(refProp, nd);
+        expect(mockGetFunction).toHaveBeenCalledTimes(1);
+        const callArg = mockGetFunction.mock.calls[0][0];
+        expect(callArg.entityName).toEqual('identity');
+        expect(callArg.criteria).toEqual({
+            poolKey: 'item:material',
+            propertyName: 'itemNumber',
+            propertyValue: 'MAT-100'
+        });
+        expect(result).toEqual('abc123');
+    });
+    it('flag on, no identity match - returns empty and warns', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => []);
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const getAllSpy = jest.spyOn(dc, 'getAllObjectReferences');
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalled();
+            expect(getAllSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+            getAllSpy.mockRestore();
+        }
+    });
+    it('flag on, multiple identity matches - returns empty and does not throw', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [
+            { entityReference: 'item:abc123' },
+            { entityReference: 'item:def456' }
+        ]);
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('flag on, ambiguous identifier set - falls back to getAllObjectReferences', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'season', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'season', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'abc123', typePath: 'item:material' }]);
+        const nd = { itemNumber: 'MAT-100', season: 'SS24', roles: ['family'] };
+        const result = await dc.setObjectReferenceValue(refProp, nd);
+        expect(mockGetFunction).toHaveBeenCalled();
+        const callArg = mockGetFunction.mock.calls[0][0];
+        expect(callArg.entityName).toEqual('item');
+        expect(callArg.entityName).not.toEqual('identity');
+        expect(result).toEqual('abc123');
+        expect(poolKeySpy).not.toHaveBeenCalled();
+    });
+    it('flag on, cache hit - second call short-circuits', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ entityReference: 'item:abc123' }]);
+        const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+        const r1 = await dc.setObjectReferenceValue(refProp, nd);
+        const r2 = await dc.setObjectReferenceValue(refProp, nd);
+        expect(r1).toEqual('abc123');
+        expect(r2).toEqual('abc123');
+        expect(mockGetFunction).toHaveBeenCalledTimes(1);
+    });
+    it('flag on, project-item entityType - roles is filtered, identity path used', async () => {
+        const projectItemProp = {
+            ...refProp,
+            referencedTypeRootSlug: 'project-item',
+            referencedTypePath: 'project-item'
+        };
+        const config = baseConfig();
+        config.search = { 'project-item': { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'project-item');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ entityReference: 'project-item:pi-789' }]);
+        const result = await dc.setObjectReferenceValue(projectItemProp, { itemNumber: 'X1', roles: ['family'] });
+        expect(mockGetFunction).toHaveBeenCalledTimes(1);
+        const callArg = mockGetFunction.mock.calls[0][0];
+        expect(callArg.entityName).toEqual('identity');
+        expect(callArg.criteria.propertyName).toEqual('itemNumber');
+        expect(result).toEqual('pi-789');
+    });
+    it('flag on, non-item entityType - roles is NOT filtered, falls back to query path', async () => {
+        const colorProp = {
+            ...refProp,
+            referencedTypeRootSlug: 'color',
+            referencedTypePath: 'color'
+        };
+        const config = baseConfig();
+        config.search = { color: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['colorNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['colorNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'color');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'col-1', typePath: 'color' }]);
+        const result = await dc.setObjectReferenceValue(colorProp, { colorNumber: 'C1', roles: ['family'] });
+        expect(mockGetFunction).toHaveBeenCalled();
+        const callArg = mockGetFunction.mock.calls[0][0];
+        expect(callArg.entityName).toEqual('color');
+        expect(callArg.entityName).not.toEqual('identity');
+        expect(result).toEqual('col-1');
+        expect(poolKeySpy).not.toHaveBeenCalled();
+    });
+    it('query path, multiple matches - returns empty with single warn (no double warn)', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber']);
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [
+            { id: 'a1', typePath: 'item:material' },
+            { id: 'a2', typePath: 'item:material' }
+        ]);
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            expect(warnSpy.mock.calls[0][0]).toMatch(/duplicate records/);
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('flag on, identity returns null - normalized to empty array, returns empty', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => null);
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('null nd - returns empty string and does not query', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        mockGetFunction.mockClear();
+        const result = await dc.setObjectReferenceValue(refProp, null);
+        expect(result).toEqual('');
+        expect(mockGetFunction).not.toHaveBeenCalled();
+    });
+    it('zero identifier keys - warns and returns empty string', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => []);
+        mockGetFunction.mockClear();
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringMatching(/doesnt have all "identifier" properties/));
+            expect(mockGetFunction).not.toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('missing identifier keys on nd - warns and returns empty string', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'season']);
+        mockGetFunction.mockClear();
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+            expect(result).toEqual('');
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringMatching(/doesnt have all "identifier" properties/));
+            expect(mockGetFunction).not.toHaveBeenCalled();
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    it('transformMapFile set - applyInboundTransformMap is invoked before context build', async () => {
+        const config = baseConfig();
+        config['transformMapFile'] = 'file1';
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        const mapKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getMapKeyFromObject')
+            .mockImplementation(async () => 'LCSMaterial');
+        const applyMapSpy = jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap')
+            .mockImplementation(async (...args) => args[2]);
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'q-1', typePath: 'item:material' }]);
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+            expect(mapKeySpy).toHaveBeenCalledTimes(1);
+            expect(applyMapSpy).toHaveBeenCalledTimes(1);
+            expect(applyMapSpy.mock.calls[0][3]).toEqual('LCSMaterial');
+            expect(result).toEqual('q-1');
+        }
+        finally {
+            mapKeySpy.mockRestore();
+            applyMapSpy.mockRestore();
+        }
+    });
+    it('transformMapFile unset - applyInboundTransformMap does not invoke map utilities', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        const mapKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getMapKeyFromObject');
+        const applyMapSpy = jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'q-2', typePath: 'item:material' }]);
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+            expect(mapKeySpy).not.toHaveBeenCalled();
+            expect(applyMapSpy).not.toHaveBeenCalled();
+            expect(result).toEqual('q-2');
+        }
+        finally {
+            mapKeySpy.mockRestore();
+            applyMapSpy.mockRestore();
+        }
+    });
+    it('query path success - writes id to cache (second call short-circuits)', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'cached-q', typePath: 'item:material' }]);
+        const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+        const r1 = await dc.setObjectReferenceValue(refProp, nd);
+        const callsAfterFirst = mockGetFunction.mock.calls.length;
+        const r2 = await dc.setObjectReferenceValue(refProp, nd);
+        expect(r1).toEqual('cached-q');
+        expect(r2).toEqual('cached-q');
+        expect(mockGetFunction.mock.calls.length).toEqual(callsAfterFirst);
+    });
+    it('query path with subtype filter - applies checkKeysAndValues when entityType !== entityTypePath', async () => {
+        const dc = new data_converter_1.DataConverter(baseConfig(), new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc, ['itemNumber']);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'season']);
+        const checkSpy = jest.spyOn(dc, 'checkKeysAndValues')
+            .mockImplementation((_criteria, arr) => arr);
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ id: 'sub-1', typePath: 'item:material' }]);
+        try {
+            const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', season: 'SS24' });
+            expect(checkSpy).toHaveBeenCalledTimes(1);
+            expect(checkSpy.mock.calls[0][2]).toEqual('item:material');
+            expect(result).toEqual('sub-1');
+        }
+        finally {
+            checkSpy.mockRestore();
+        }
+    });
+    it('pickSingleResult single result - identity branch parses id from entityReference', async () => {
+        const config = baseConfig();
+        config.search = { item: { useIdentityServiceForInboundData: true } };
+        const dc = new data_converter_1.DataConverter(config, new transform_data_1.MapFileUtil(new sdk_1.Entities()));
+        setupTypeUtilsSpies(dc);
+        identifierSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+            .mockImplementation(async () => ['itemNumber', 'roles']);
+        poolKeySpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+            .mockImplementation(async () => 'item:material');
+        mockGetFunction.mockClear();
+        mockGetFunction.mockImplementation(() => [{ entityReference: 'item:parsed-id-from-ref' }]);
+        const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+        expect(result).toEqual('parsed-id-from-ref');
+    });
+});
 describe('getObjectReferenceValue - use mapping', () => {
     const maps = require('./data-converter-spec-mockData');
     const mapping = maps['mapping'];
@@ -525,6 +912,47 @@ describe('getObjectReferenceValue - use mapping', () => {
         }
     });
 });
+describe('getEntityValues', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const runWithStubs = async (typePath, objectClass, data) => {
+        const tcoSpy = jest.spyOn(dc['typeUtils'], 'getEntityTypeClientOptionsUsingMapping')
+            .mockImplementation(async () => ({ root: 'item' }));
+        const typeSpy = jest.spyOn(dc['typeUtils'], 'getByRootAndPath')
+            .mockImplementation(async () => ({ typePath, typeProperties: [] }));
+        const filterSpy = jest.spyOn(dc['typeUtils'], 'filterTypeProperties')
+            .mockImplementation(() => []);
+        try {
+            return await dc.getEntityValues(objectClass, data);
+        }
+        finally {
+            tcoSpy.mockRestore();
+            typeSpy.mockRestore();
+            filterSpy.mockRestore();
+        }
+    };
+    it('LCSProduct -> roles family', async () => {
+        const result = await runWithStubs('item', 'LCSProduct', { itemNumber: 'X1' });
+        expect(result['roles']).toEqual(['family']);
+    });
+    it('LCSSKU -> roles color, option', async () => {
+        const result = await runWithStubs('item', 'LCSSKU', { itemNumber: 'X1' });
+        expect(result['roles']).toEqual(['color', 'option']);
+    });
+    it('LCSMaterial -> roles family', async () => {
+        const result = await runWithStubs('item:material', 'LCSMaterial', { itemNumber: 'MAT-100' });
+        expect(result['roles']).toEqual(['family']);
+    });
+});
 describe('setEnumerationKeys', () => {
     const config = {
         apiHost: 'host',

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

@@ -2,7 +2,10 @@ export declare class TypeDefaults {
     static NO_ENTITY_TYPE: string;
     static NO_OBJECT_CLASS: string;
     static NO_TYPE_PATH: string;
+    static processLCSMaterialAsItem: boolean;
     constructor();
+    static applyConfig(config: any): void;
+    static isPropertyTrue(value: any): boolean;
     static getDefaultObjectClass(entity: any): string;
     static getDefaultObjectTypePath(entity: any): string;
     static getDefaultIdentifierProperties(entity: any): string[];

package/lib/util/type-defaults.js

@@ -4,6 +4,12 @@ exports.TypeDefaults = void 0;
 class TypeDefaults {
     constructor() {
     }
+    static applyConfig(config) {
+        TypeDefaults.processLCSMaterialAsItem = TypeDefaults.isPropertyTrue(config?.LCSMaterial?.processAsItem);
+    }
+    static isPropertyTrue(value) {
+        return value === true || (typeof value === 'string' && value.toLowerCase() === 'true');
+    }
     static getDefaultObjectClass(entity) {
         const entityType = this.getEntityType(entity);
         let objectClass = '';
@@ -130,7 +136,13 @@ class TypeDefaults {
     static getDefaultEntityClass(object) {
         let entityClass = '';
         let objectClass = TypeDefaults.getObjectClass(object);
-        if (['LCSProduct', 'LCSSKU'].includes(objectClass)) {
+        const itemClasses = TypeDefaults.processLCSMaterialAsItem
+            ? ['LCSProduct', 'LCSSKU', 'LCSMaterial']
+            : ['LCSProduct', 'LCSSKU'];
+        const customEntityClasses = TypeDefaults.processLCSMaterialAsItem
+            ? ['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast']
+            : ['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast', 'LCSMaterial'];
+        if (itemClasses.includes(objectClass)) {
             entityClass = 'item';
         }
         else if (['LCSProductSeasonLink', 'LCSSKUSeasonLink'].includes(objectClass)) {
@@ -142,7 +154,7 @@ class TypeDefaults {
         else if (['LCSSeason', 'SeasonGroup'].includes(objectClass)) {
             entityClass = 'assortment';
         }
-        else if (['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast', 'LCSMaterial'].includes(objectClass)) {
+        else if (customEntityClasses.includes(objectClass)) {
             entityClass = 'custom-entity';
         }
         if (entityClass === '')
@@ -157,6 +169,11 @@ class TypeDefaults {
             case 'LCSSKU':
                 typePath = 'item';
                 break;
+            case 'LCSMaterial':
+                if (TypeDefaults.processLCSMaterialAsItem) {
+                    typePath = 'item:material';
+                }
+                break;
             case 'LCSProductSeasonLink':
             case 'LCSSKUSeasonLink':
                 typePath = 'project-item';
@@ -181,6 +198,14 @@ class TypeDefaults {
             case 'LCSSKU':
                 identifierProps.push('itemNumber');
                 break;
+            case 'LCSMaterial':
+                if (TypeDefaults.processLCSMaterialAsItem) {
+                    identifierProps.push('itemNumber');
+                }
+                else {
+                    identifierProps.push('name');
+                }
+                break;
             case 'LCSSeason':
                 identifierProps.push('flexPLMSeasonName');
                 break;
@@ -191,7 +216,6 @@ class TypeDefaults {
             case 'LCSRevisableEntity':
             case 'LCSLifecycleManaged':
             case 'LCSLast':
-            case 'LCSMaterial':
                 identifierProps.push('name');
                 break;
         }
@@ -200,7 +224,10 @@ class TypeDefaults {
     static getDefaultInformationalPropertiesFromObject(object) {
         const objectClass = TypeDefaults.getObjectClass(object);
         let properties = [];
-        if ('LCSProduct' === objectClass) {
+        const itemClasses = TypeDefaults.processLCSMaterialAsItem
+            ? ['LCSProduct', 'LCSMaterial']
+            : ['LCSProduct'];
+        if (itemClasses.includes(objectClass)) {
             properties.push('name');
         }
         else if ('LCSSKU' === objectClass) {
@@ -219,3 +246,4 @@ exports.TypeDefaults = TypeDefaults;
 TypeDefaults.NO_ENTITY_TYPE = 'Not able to determine the entity type of the entity object';
 TypeDefaults.NO_OBJECT_CLASS = 'Please ensure that the flexPLMObjectClass property is provided.';
 TypeDefaults.NO_TYPE_PATH = 'Please ensure that the flexPLMTypePath property is provided.';
+TypeDefaults.processLCSMaterialAsItem = false;