@contrail/flexplm 1.3.0-alpha.0 → 1.3.0-alpha.3

package/lib/entity-processor/base-entity-processor.spec.js

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("@contrail/sdk");
+const transform_data_1 = require("@contrail/transform-data");
+const data_converter_1 = require("../util/data-converter");
+const base_entity_processor_1 = require("./base-entity-processor");
+const type_conversion_utils_1 = require("../util/type-conversion-utils");
+const thumbnail_util_1 = require("../util/thumbnail-util");
+const mockRootType = {
+    typeProperties: [
+        { slug: 'rootText' }
+    ]
+};
+const mockTypeUtilGetByRootAndPath = jest.fn((options) => {
+    return Promise.resolve(mockRootType);
+});
+jest.mock('@contrail/sdk', () => {
+    const origModule = jest.requireActual('@contrail/sdk');
+    return {
+        __esModule: true,
+        ...origModule,
+        Types: jest.fn().mockImplementation(() => {
+            return {
+                getByRootAndPath: mockTypeUtilGetByRootAndPath
+            };
+        })
+    };
+});
+class TestBaseEntityProcessor extends base_entity_processor_1.BaseEntityProcessor {
+    getIncomingEntity(event, inboundData) {
+        throw new Error("Method not implemented.");
+    }
+    getCreateEntity(inboundData) {
+        throw new Error("Method not implemented.");
+    }
+    getOutgoingUpsertPayload(entityType, event) {
+        throw new Error("Method not implemented.");
+    }
+}
+describe('BaseEntityProcessor', () => {
+    describe('getOutboundEntityUpdates', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+        it('no payload', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = {};
+            const flexResponse = {};
+            const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(updates).toBeUndefined();
+        });
+        it('flexPayload.status === OK', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = {};
+            const flexResponse = {
+                data: {
+                    payload: [
+                        {
+                            status: 'OK'
+                        }
+                    ]
+                }
+            };
+            const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
+            const returnValue = {
+                name: 'Test'
+            };
+            const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
+            const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(getTransformedDataSpy).toBeCalledTimes(1);
+            expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
+            expect(updates).toBe(returnValue);
+        });
+        it('flexPayload.status === FAIL', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = {};
+            const flexResponse = {
+                data: {
+                    payload: [
+                        {
+                            status: 'FAIL'
+                        }
+                    ]
+                }
+            };
+            const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
+            const returnValue = {
+                name: 'Test'
+            };
+            const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
+            const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(getTransformedDataSpy).toBeCalledTimes(0);
+            expect(getUpdatesForEntitySpy).toBeCalledTimes(0);
+            expect(updates).toBeUndefined();
+        });
+        it('should set flexPLMObjectClass when data exists but flexPLMObjectClass is missing', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = { newData: { id: '123' } };
+            const flexResponse = {
+                data: {
+                    payload: [
+                        {
+                            status: 'OK',
+                            objectClass: 'Material',
+                            data: {
+                                name: 'Test Material'
+                            }
+                        }
+                    ]
+                }
+            };
+            const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
+            const returnValue = {
+                name: 'Test'
+            };
+            const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
+            await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(flexResponse.data.payload[0].data['flexPLMObjectClass']).toBe('Material');
+            expect(getTransformedDataSpy).toBeCalledTimes(1);
+            expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
+            expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
+        });
+        it('should not override existing flexPLMObjectClass', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = { newData: { id: '123' } };
+            const flexResponse = {
+                data: {
+                    payload: [
+                        {
+                            status: 'OK',
+                            objectClass: 'Material',
+                            data: {
+                                name: 'Test Material',
+                                flexPLMObjectClass: 'ExistingClass'
+                            }
+                        }
+                    ]
+                }
+            };
+            const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
+            const returnValue = {
+                name: 'Test'
+            };
+            const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
+            await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(flexResponse.data.payload[0].data.flexPLMObjectClass).toBe('ExistingClass');
+            expect(getTransformedDataSpy).toBeCalledTimes(1);
+            expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
+            expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
+        });
+        it('should skip setting flexPLMObjectClass when data is null or undefined', async () => {
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const event = { newData: { id: '123' } };
+            const flexResponse = {
+                data: {
+                    payload: [
+                        {
+                            status: 'OK',
+                            objectClass: 'Material',
+                            data: null
+                        }
+                    ]
+                }
+            };
+            const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
+            const returnValue = {
+                name: 'Test'
+            };
+            const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
+            await btep.getOutboundEntityUpdates(event, flexResponse);
+            expect(getTransformedDataSpy).toBeCalledTimes(1);
+            expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
+            expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
+        });
+    });
+    describe('queryEntityWithSubType', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('entity parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = '';
+            const subType = 'test';
+            const propertyCriteria = { a: 'val' };
+            expect(async () => { await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('entityTypePath not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = '';
+            const propertyCriteria = {};
+            expect(async () => { await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('propertyCriteria not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = 'test';
+            const propertyCriteria = {};
+            expect(async () => { await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('basic queryEntityWithSubTypeCriteria test', async () => {
+            const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const entityType = 'custom-entity';
+            const entityTypePath = 'custom-entity:sample';
+            const rootCriteria = {
+                rootText: 'root'
+            };
+            const subCriteria = {
+                sampleText: 'sample',
+                typePath: entityTypePath
+            };
+            const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+            const rootCriteriaResults = Object.assign({}, rootCriteria);
+            const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
+            const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
+            const results = await btep.queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria);
+            expect(results).toEqual([]);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType });
+            expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
+            expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
+            expect(mockDCgetAllObjectReferences).toBeCalledTimes(1);
+            expect(mockDCgetAllObjectReferences).toBeCalledWith(entityType, rootCriteriaResults, subCriteria);
+        });
+    });
+    describe('getCriteriaForEntity', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('entity parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = '';
+            const subType = 'test';
+            const propertyCriteria = { a: 'val' };
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('entityTypePath not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = '';
+            const propertyCriteria = {};
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('propertyCriteria not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = 'test';
+            const propertyCriteria = {};
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('basic getCriteriaForEntity test', async () => {
+            const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const entityType = 'custom-entity';
+            const entityTypePath = 'custom-entity:sample';
+            const rootCriteria = {
+                rootText: 'root'
+            };
+            const subCriteria = {
+                sampleText: 'sample',
+                typePath: entityTypePath
+            };
+            const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+            const rootCriteriaResults = Object.assign({}, rootCriteria);
+            const subCriteriaResults = Object.assign({}, subCriteria);
+            const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
+            const { rootTypeCriteria, subTypeCriteria } = await btep.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType });
+            expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
+            expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
+            expect(rootTypeCriteria).toEqual(rootCriteriaResults);
+            expect(subTypeCriteria).toEqual(subCriteriaResults);
+        });
+    });
+    describe('getRootTypePropertyKeys', () => {
+        it('rootType parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const rootType = '';
+            expect(async () => { await btep.getRootTypePropertyKeys(rootType); }).rejects.toThrow();
+        });
+        it('get keys from rootType.typeProperties', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const rootType = {
+                typeProperties: ['a', 'b']
+            };
+            const keys = await btep.getRootTypePropertyKeys(rootType);
+            expect(keys).not.toEqual(['a', 'b']);
+        });
+        it('get keys from rootType.typeProperties', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const rootType = {
+                typeProperties: [{ slug: 'a' }, { slug: 'b' }]
+            };
+            const keys = await btep.getRootTypePropertyKeys(rootType);
+            expect(keys).toEqual(['a', 'b']);
+        });
+    });
+    describe('handleIncomingUpsert - inbound image sync', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+        const mockEvent = { objectClass: 'TestClass', federatedId: 'fed-123', data: { name: 'test' }, entityReference: 'ref-1', eventType: 'PERSIST' };
+        const mockInboundData = { name: 'transformed-test' };
+        const mockCreatedEntity = { id: 'created-1', name: 'created', primaryViewableId: 'pv-created' };
+        const mockUpdatedEntity = { id: 'updated-1', name: 'updated', primaryViewableId: 'pv-updated' };
+        const mockExistingEntity = { id: 'existing-1', name: 'existing', typeId: 'type-1', roles: [] };
+        let btep;
+        let syncInboundImagesSpy;
+        let syncThumbnailSpy;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue(mockInboundData);
+            syncInboundImagesSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'syncInboundImages');
+            syncThumbnailSpy = jest.spyOn(thumbnail_util_1.ThumbnailUtil.prototype, 'syncThumbnailToVibeIQ').mockResolvedValue(undefined);
+        });
+        it('should call updateEntity with thumbnail updates after create when syncInboundImages returns true', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockCreatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new', primaryFileUrl: 'https://files/new.png' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'created-1', primaryViewableId: 'pv-created', event: mockEvent, entityName: 'test' });
+            expect(updateEntitySpy).toBeCalledWith('test', mockCreatedEntity, thumbnailUpdates);
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should not call updateEntity after create when syncThumbnailToVibeIQ returns undefined', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity');
+            syncInboundImagesSpy.mockResolvedValue(true);
+            syncThumbnailSpy.mockResolvedValue(undefined);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(updateEntitySpy).not.toHaveBeenCalled();
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should not sync images after create when syncInboundImages returns false', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should merge thumbnail updates with property diffs on update', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'existing-1', primaryViewableId: undefined, event: mockEvent, entityName: 'test' });
+            expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { name: 'changed', primaryViewableId: 'pv-new' });
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should update entity with only thumbnail changes when no property diffs', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { primaryViewableId: 'pv-new' });
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should not sync images on update when syncInboundImages returns false', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+            jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should not sync images on early return from getIncomingEntity', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({
+                earlyReturn: { status: 400, data: { message: 'error' }, shortStatusMessage: 'FAIL' }
+            });
+            await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(0);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+        });
+        it('should not sync images on early return from getCreateEntity', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({
+                earlyReturn: { status: 400, data: { message: 'not creatable' }, shortStatusMessage: 'NOT_CREATABLE' }
+            });
+            await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(0);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+        });
+        it('should return no changes when no property diffs and no thumbnail updates', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            syncInboundImagesSpy.mockResolvedValue(true);
+            syncThumbnailSpy.mockResolvedValue(undefined);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+        });
+        it('should return no changes when syncInboundImages is false and no property diffs', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+        });
+    });
+});

package/lib/flexplm-request.d.ts

@@ -0,0 +1,3 @@
+export declare class FlexPLMRequest {
+    static request(path: string, data: any): Promise<any>;
+}

package/lib/flexplm-request.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMRequest = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BASE_URL = 'https://PP-2006031951wo.portal.ptc.io/Windchill/servlet/rest/cdee';
+const BASE_CONFIG = {
+    method: 'POST',
+    headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'CSRF_NONCE': '2OaLp+0dWNBtrkTwtdDC491zaacu6Hykvqi/lpl6bZgJ/QXBrK/B1J5FErMkmAmktr/I3thcbO1Xn3HJ7Ne/l9kpaedUmn7H75Xey4ZbNLsenW+anM3vxIZ7ELosk3k=',
+        'Authorization': 'Basic d2NhZG1pbjpSZXRhaWwyMDIwLQ==',
+        'Cookie': 'JSESSIONID=36D5B3C74C1F963C6C73E9AF5B6BDA78.tomcat1; JSESSIONID=B8090C802D8548EA773C97F5886FAB79.tomcat1',
+    },
+};
+class FlexPLMRequest {
+    static async request(path, data) {
+        const config = Object.assign({}, BASE_CONFIG);
+        config.url = BASE_URL + path;
+        config.data = data;
+        try {
+            const resp = await (0, axios_1.default)(config);
+            return Promise.resolve(resp.data);
+        }
+        catch (error) {
+            console.error(`${FlexPLMRequest} error: ${error.message}`);
+            return Promise.resolve(null);
+        }
+    }
+}
+exports.FlexPLMRequest = FlexPLMRequest;

package/lib/flexplm-utils.d.ts

@@ -0,0 +1,5 @@
+export declare class FlexPLMUtils {
+    static convertTypePath: (path: string) => string;
+    static getParentTypePath: (path: string) => string;
+    static computeLevelFromPath(path: string): number;
+}

package/lib/flexplm-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMUtils = void 0;
+class FlexPLMUtils {
+    static computeLevelFromPath(path) {
+        return (path.match(/:/g) || []).length + 1;
+    }
+}
+exports.FlexPLMUtils = FlexPLMUtils;
+FlexPLMUtils.convertTypePath = (path) => {
+    if (!path) {
+        return null;
+    }
+    let newPath = path;
+    while (newPath.indexOf('\\') > 1) {
+        newPath = newPath.replace('\\', ':');
+    }
+    while (newPath.indexOf('[') > 1) {
+        newPath = newPath.replace('[', '*');
+    }
+    while (newPath.indexOf(']') > 1) {
+        newPath = newPath.replace(']', '*');
+    }
+    while (newPath.indexOf(' ') > 1) {
+        newPath = newPath.replace(' ', '_');
+    }
+    newPath = newPath.toLowerCase();
+    return newPath;
+};
+FlexPLMUtils.getParentTypePath = (path) => {
+    const newPath = FlexPLMUtils.convertTypePath(path);
+    return (!newPath || newPath.indexOf(':') < 0) ? null : newPath.substring(0, newPath.lastIndexOf(':'));
+};

package/lib/flexplm-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/flexplm-utils.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flexplm_utils_1 = require("./flexplm-utils");
+describe('Types Controller', () => {
+    beforeEach(async () => {
+    });
+    it('should convert a type path', () => {
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('Product')).toEqual('product');
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('Product\\Apparel')).toEqual('product:apparel');
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('Product\\Skin Care')).toEqual('product:skin_care');
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('Product\\Apparel\\Shirt')).toEqual('product:apparel:shirt');
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('Product\\Apparel\\[Shirt]')).toEqual('product:apparel:*shirt*');
+        expect(flexplm_utils_1.FlexPLMUtils.convertTypePath('')).toBeNull();
+    });
+    it('should compute level in tree', () => {
+        expect(flexplm_utils_1.FlexPLMUtils.computeLevelFromPath('product')).toEqual(1);
+        expect(flexplm_utils_1.FlexPLMUtils.computeLevelFromPath('product:apparel')).toEqual(2);
+        expect(flexplm_utils_1.FlexPLMUtils.computeLevelFromPath('product:apparel:dress:mini')).toEqual(4);
+    });
+    it('should get a parent type path', () => {
+        expect(flexplm_utils_1.FlexPLMUtils.getParentTypePath('product')).toBeNull();
+        expect(flexplm_utils_1.FlexPLMUtils.getParentTypePath('product:apparel')).toEqual('product');
+        expect(flexplm_utils_1.FlexPLMUtils.getParentTypePath('product:apparel:stuff')).toEqual('product:apparel');
+        expect(flexplm_utils_1.FlexPLMUtils.getParentTypePath('Product\\Apparel')).toEqual('product');
+    });
+});

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+export * from './flexplm-request';
+export * from './flexplm-utils';
+export * from './util/config-defaults';
+export * from './util/data-converter';
+export * from './util/error-response-object';
+export * from './util/event-short-message-status';
+export * from './util/federation';
+export * from './util/flexplm-connect';
+export * from './interfaces/interfaces';
+export * from './util/logger-config';
+export * from './util/thumbnail-util';
+export * from './util/type-conversion-utils';
+export * from './util/type-defaults';
+export * from './util/type-utils';
+export * from './util/map-utils';
+export * from './interfaces/interfaces';
+export * from './interfaces/item-family-changes';
+export * from './interfaces/publish-change-data';
+export * from './publish/base-process-publish-assortment';
+export * from './publish/base-process-publish-assortment-callback';
+export * from './entity-processor/base-entity-processor';
+export * from './transform/identifier-conversion';

package/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./flexplm-request"), exports);
+__exportStar(require("./flexplm-utils"), exports);
+__exportStar(require("./util/config-defaults"), exports);
+__exportStar(require("./util/data-converter"), exports);
+__exportStar(require("./util/error-response-object"), exports);
+__exportStar(require("./util/event-short-message-status"), exports);
+__exportStar(require("./util/federation"), exports);
+__exportStar(require("./util/flexplm-connect"), exports);
+__exportStar(require("./interfaces/interfaces"), exports);
+__exportStar(require("./util/logger-config"), exports);
+__exportStar(require("./util/thumbnail-util"), exports);
+__exportStar(require("./util/type-conversion-utils"), exports);
+__exportStar(require("./util/type-defaults"), exports);
+__exportStar(require("./util/type-utils"), exports);
+__exportStar(require("./util/map-utils"), exports);
+__exportStar(require("./interfaces/interfaces"), exports);
+__exportStar(require("./interfaces/item-family-changes"), exports);
+__exportStar(require("./interfaces/publish-change-data"), exports);
+__exportStar(require("./publish/base-process-publish-assortment"), exports);
+__exportStar(require("./publish/base-process-publish-assortment-callback"), exports);
+__exportStar(require("./entity-processor/base-entity-processor"), exports);
+__exportStar(require("./transform/identifier-conversion"), exports);