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

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

@@ -1,363 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntityProcessor = exports.IncomingEntityResponse = void 0;
-const type_utils_1 = require("../util/type-utils");
-const flexplm_connect_1 = require("../util/flexplm-connect");
-const map_utils_1 = require("../util/map-utils");
-const sdk_1 = require("@contrail/sdk");
-const type_conversion_utils_1 = require("../util/type-conversion-utils");
-const event_short_message_status_1 = require("../util/event-short-message-status");
-const UNSUPPORTED_TYPE = 'Unsupported eventType.';
-class IncomingEntityResponse {
-}
-exports.IncomingEntityResponse = IncomingEntityResponse;
-class BaseEntityProcessor {
-    constructor(config, dc, mapFileUtil, baseType) {
-        this.config = config;
-        this.dc = dc;
-        this.mapFileUtil = mapFileUtil;
-        this.baseType = baseType;
-        this.typeUtil = new type_utils_1.TypeUtils();
-        this.transformMapFile = this.config?.transformMapFile;
-        this.entities = new sdk_1.Entities();
-        this.orgSlug = this.config?.orgSlug || 'unset-orgSlug';
-    }
-    async inbound(event) {
-        const eventType = event.eventType;
-        console.log(`inbound entity: ${eventType}:${event.objectClass}`);
-        switch (eventType) {
-            case 'PERSIST':
-                return await this.handleIncomingUpsert(event);
-            case 'DELETE':
-                return await this.handleIncomingDelete(event);
-            default:
-                console.error(UNSUPPORTED_TYPE);
-                return {
-                    status: 500,
-                    data: { UNSUPPORTED_TYPE }
-                };
-        }
-    }
-    async handleIncomingUpsert(event) {
-        const inboundData = await this.getTransformedData(event);
-        const incomingEntityResponse = await this.getIncomingEntity(event, inboundData);
-        if (incomingEntityResponse.earlyReturn) {
-            const statusMsg = this.getInboundStatusMessage({
-                status: event_short_message_status_1.EventShortMessageStatus.FAILURE,
-                statusMessage: incomingEntityResponse.earlyReturn.shortStatusMessage || '',
-                objectClass: event.objectClass,
-                federatedId: event.federatedId
-            });
-            console.log(statusMsg);
-            return incomingEntityResponse.earlyReturn;
-        }
-        const entity = incomingEntityResponse.entity;
-        if (!entity) {
-            const createEntityResponse = await this.getCreateEntity(inboundData);
-            if (createEntityResponse.earlyReturn) {
-                const status = (createEntityResponse.earlyReturn.shortStatusMessage === event_short_message_status_1.EventShortMessageStatus.NOT_CREATABLE)
-                    ? event_short_message_status_1.EventShortMessageStatus.SUCCESS
-                    : event_short_message_status_1.EventShortMessageStatus.FAILURE;
-                const statusMsg = this.getInboundStatusMessage({
-                    status,
-                    statusMessage: createEntityResponse.earlyReturn.shortStatusMessage || '',
-                    objectClass: event.objectClass,
-                    federatedId: event.federatedId
-                });
-                console.log(statusMsg);
-                return createEntityResponse.earlyReturn;
-            }
-            const createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
-            const statusMsg = this.getInboundStatusMessage({
-                status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
-                statusMessage: event_short_message_status_1.EventShortMessageStatus.CREATED,
-                objectClass: event.objectClass,
-                entityId: 'id',
-                federatedId: event.federatedId
-            });
-            console.log(statusMsg);
-            return createdEntity;
-        }
-        const diffs = await this.getUpdatesForEntity(entity, inboundData);
-        if (Object.getOwnPropertyNames(diffs).length == 0) {
-            const statusMsg = this.getInboundStatusMessage({
-                status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
-                statusMessage: event_short_message_status_1.EventShortMessageStatus.NO_CHANGES,
-                objectClass: event.objectClass,
-                entityId: entity.id,
-                federatedId: event.federatedId
-            });
-            console.log(statusMsg);
-            const message = 'No Changes to persist for entity: ' + entity.id;
-            return {
-                status: 200,
-                data: { message }
-            };
-        }
-        const updatedEntity = await this.updateEntity(this.baseType, entity, diffs);
-        const statusMsg = this.getInboundStatusMessage({
-            status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
-            statusMessage: event_short_message_status_1.EventShortMessageStatus.UPDATED,
-            objectClass: event.objectClass,
-            entityId: entity.id,
-            federatedId: event.federatedId
-        });
-        console.log(statusMsg);
-        return updatedEntity;
-    }
-    getInboundStatusMessage(statusObject) {
-        return 'BaseEntityProcessor: inbound: status: ' + statusObject.status
-            + ', statusMessage: ' + statusObject.statusMessage
-            + ', entityType: ' + this.baseType
-            + ', entityId: ' + statusObject.entityId
-            + ', objectClass: ' + statusObject.objectClass
-            + ', federatedId: ' + statusObject.federatedId
-            + ', orgSlug: ' + this.orgSlug;
-    }
-    async queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria) {
-        if (!entityType || !entityTypePath) {
-            throw new Error('type and entityTypePath must be defined');
-        }
-        if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
-            throw new Error('propertyCriteria must be defined and have at least one property');
-        }
-        const { rootTypeCriteria, subTypeCriteria } = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
-        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
-        return returnedEntities;
-    }
-    async getCriteriaForEntity(entityType, entityTypePath, propertyCriteria) {
-        if (!entityType || !entityTypePath) {
-            throw new Error('type and entityTypePath must be defined');
-        }
-        if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
-            throw new Error('propertyCriteria must be defined and have at least one property');
-        }
-        const rootType = await this.typeUtil.getByRootAndPath({ root: entityType });
-        const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
-        const rootTypeCriteria = {};
-        const subTypeCriteria = {};
-        if (entityType !== entityTypePath) {
-            subTypeCriteria['typePath'] = entityTypePath;
-        }
-        for (const key in propertyCriteria) {
-            if (rootTypePropertyKeys.includes(key)) {
-                rootTypeCriteria[key] = propertyCriteria[key];
-            }
-            else {
-                subTypeCriteria[key] = propertyCriteria[key];
-            }
-        }
-        return { rootTypeCriteria, subTypeCriteria };
-    }
-    getRootTypePropertyKeys(rootType, propertyCriteria = null) {
-        const props = rootType['typeProperties'];
-        const rootTypePropertyKeys = props.map(prop => prop.slug);
-        return rootTypePropertyKeys;
-    }
-    async handleIncomingDelete(event) {
-        console.warn('delete is not configured', event);
-    }
-    async getTransformedData(event) {
-        let inboundData = event.data;
-        console.debug('inboundData: ' + JSON.stringify(inboundData));
-        const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, inboundData, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
-        inboundData = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, inboundData, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
-        console.debug('Transformed-inboundData: ' + JSON.stringify(inboundData));
-        return inboundData;
-    }
-    async getUpdatesForEntity(entity, inboundData) {
-        const vibeOwningKeys = await this.getVibeOwningKeys(entity);
-        let updates = {
-            typeId: entity.typeId,
-            roles: entity.roles,
-            id: entity.id,
-        };
-        updates = await this.dc.setEntityValues(updates, inboundData, vibeOwningKeys);
-        for (const prop of ['typeId', 'roles', 'id']) {
-            delete updates[prop];
-        }
-        return this.dc.getPersistableChanges(entity, updates);
-    }
-    async getVibeOwningKeys(entity) {
-        let vibeOwningKeys = [];
-        if (this.transformMapFile && entity) {
-            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, entity, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
-            const mapSection = await map_utils_1.MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
-            vibeOwningKeys = mapSection?.vibeOwningKeys || [];
-        }
-        console.debug('vibeOwningKeys: ' + vibeOwningKeys);
-        return vibeOwningKeys;
-    }
-    async getVibeOwningKeysFromInbound(entity) {
-        let vibeOwningKeys = [];
-        if (this.transformMapFile && entity) {
-            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, entity, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
-            const mapSection = await map_utils_1.MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
-            vibeOwningKeys = mapSection?.vibeOwningKeys || [];
-        }
-        console.debug('vibeOwningKeys: ' + vibeOwningKeys);
-        return vibeOwningKeys;
-    }
-    async createEntity(entityName, changes) {
-        const options = {
-            entityName: entityName,
-            object: changes,
-        };
-        console.log("createEntity: " + JSON.stringify(options));
-        return await new sdk_1.Entities().create(options);
-    }
-    async updateEntity(entityName, entity, diffs) {
-        const options = {
-            entityName: entityName,
-            id: entity['id'],
-            object: diffs
-        };
-        console.log('updateEntity: ' + JSON.stringify(options));
-        return await new sdk_1.Entities().update(options);
-    }
-    async outbound(event) {
-        const entityType = event.entityType;
-        const eventType = event.eventType;
-        const entityId = event.id;
-        console.log(`outbound: ${entityType}:${entityId}`);
-        switch (eventType) {
-            case 'update':
-            case 'create':
-                return await this.handleOutgoingUpsert(entityType, event);
-            case 'delete':
-                return await this.handleOutgoingDelete(entityType, event);
-            case 'sendUpsertToFlexPLM':
-                return await this.sendUpsertToFlexPLM(event);
-            default:
-                console.log(UNSUPPORTED_TYPE);
-                return {
-                    status: 500,
-                    data: { UNSUPPORTED_TYPE }
-                };
-        }
-    }
-    async handleOutgoingUpsert(entityType, event) {
-        const objectClass = await type_conversion_utils_1.TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
-        if (!objectClass) {
-            const message = 'ObjectClass must have a value.';
-            console.log(message);
-            return {
-                status: 500,
-                data: { message }
-            };
-        }
-        try {
-            const payload = await this.getOutgoingUpsertPayload(entityType, event);
-            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
-            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-            if (outboundEntityUpdates) {
-                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
-            }
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
-                + ', statusMessage: ' + flexResponse.status
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + payload.objectClass
-                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            return flexResponse;
-        }
-        catch (e) {
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
-                + ', statusMessage: ' + e.httpResponseStatus
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + 'false'
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            throw e;
-        }
-    }
-    async getOutboundEntityUpdates(event, flexResponse) {
-        const payload = flexResponse?.data?.payload;
-        const flexPayload = (payload) ? payload[0] : undefined;
-        let outboundEntityUpdates = undefined;
-        if (flexPayload && 'OK' === flexPayload.status) {
-            if (flexPayload.data && !flexPayload.data?.flexPLMObjectClass) {
-                flexPayload.data.flexPLMObjectClass = flexPayload.objectClass;
-            }
-            const inboundData = await this.getTransformedData(flexPayload);
-            outboundEntityUpdates = await this.getUpdatesForEntity(event.newData, inboundData);
-        }
-        return outboundEntityUpdates;
-    }
-    async handleOutgoingDelete(entityType, event) {
-        console.warn('delete is not configured', entityType, event.oldData);
-    }
-    async triggerNewEvent(triggerKey, event) {
-        const newEvent = {
-            entityName: 'event-workflow-request',
-            object: {
-                triggerKey,
-                event
-            }
-        };
-        const response = await this.entities.create(newEvent);
-        return response;
-    }
-    async sendUpsertToFlexPLM(event) {
-        const payload = await this.getEntityCurrentStateUpsertPayload(event);
-        if (!payload) {
-            const message = 'No payload to send to FlexPLM';
-            console.log(message);
-            return {
-                status: 500,
-                data: { message }
-            };
-        }
-        ;
-        let objectClass = payload.objectClass;
-        try {
-            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
-            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-            if (outboundEntityUpdates) {
-                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
-            }
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
-                + ', statusMessage: ' + flexResponse.status
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            return flexResponse;
-        }
-        catch (e) {
-            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
-                + ', statusMessage: ' + e.httpResponseStatus
-                + ', entityType: ' + this.baseType
-                + ', entityId: ' + event.id
-                + ', objectClass: ' + objectClass
-                + ', updateFromResponse: ' + 'false'
-                + ', orgSlug: ' + this.orgSlug;
-            console.log(statusMsg);
-            throw e;
-        }
-    }
-    async getEntityCurrentStateUpsertPayload(event) {
-        const id = event.id;
-        if (!id) {
-            return undefined;
-        }
-        const entity = await this.entities.get({
-            entityName: this.baseType,
-            id
-        });
-        if (!entity) {
-            return undefined;
-        }
-        event.newData = entity;
-        event.oldData = entity;
-        const payload = await this.getOutgoingUpsertPayload(this.baseType, event);
-        return payload;
-    }
-}
-exports.BaseEntityProcessor = BaseEntityProcessor;

package/lib/entity-processor/base-entity-processor.spec.d.ts

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

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

@@ -1,302 +0,0 @@
-"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 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']);
-        });
-    });
-});

package/lib/flexplm-request.d.ts

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