@contrail/flexplm 1.0.3 → 1.0.5

package/lib/index.d.ts

@@ -1,2 +1,10 @@
 export * from './flexplm-request';
 export * from './flexplm-utils';
+export * from './util/config-defaults';
+export * from './util/data-converter';
+export * from './util/federation';
+export * from './util/flexplm-connect';
+export * from './util/interfaces';
+export * from './util/logger-config';
+export * from './util/thumbnail-util';
+export * from './util/type-utils';

package/lib/index.js

@@ -16,3 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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/federation"), exports);
+__exportStar(require("./util/flexplm-connect"), exports);
+__exportStar(require("./util/interfaces"), exports);
+__exportStar(require("./util/logger-config"), exports);
+__exportStar(require("./util/thumbnail-util"), exports);
+__exportStar(require("./util/type-utils"), exports);

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

@@ -0,0 +1,6 @@
+import { FCConfig } from './interfaces';
+export declare class ConfigDefaults {
+    static NEED_CONFIG_VALUES: string;
+    static setConfigDefaults(config: any): Promise<FCConfig>;
+    static getConfigFile(fileId: string): Promise<any>;
+}

package/lib/util/config-defaults.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigDefaults = void 0;
+const sdk_1 = require("@contrail/sdk");
+const util_1 = require("@contrail/util");
+class ConfigDefaults {
+    static setConfigDefaults(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!config.apiHost || !config.userName || !config.password) {
+                throw new Error(ConfigDefaults.NEED_CONFIG_VALUES);
+            }
+            if ((config === null || config === void 0 ? void 0 : config.itemPreDevelopmentLifecycleStages) && !((config === null || config === void 0 ? void 0 : config.itemPreDevelopmentLifecycleStages) instanceof Array)) {
+                config.itemPreDevelopmentLifecycleStages = config.itemPreDevelopmentLifecycleStages.split(',');
+            }
+            const defaultConfig = {
+                urlContext: '/Windchill',
+                sendMode: {
+                    ASYNC_PUBLISH_SEASON: 'vibeiqfile'
+                },
+                itemPreDevelopmentLifecycleStages: ['concept'],
+                identifierAtts: {
+                    LCSProduct: ['itemNumber'],
+                    LCSSeason: ['flexPLMSeasonName'],
+                    LCSSKU: ['itemNumber']
+                },
+                csrfEndpoint: '/servlet/rest/security/csrf',
+                vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+                payloadDefaultAsArray: true
+            };
+            const configArr = [defaultConfig];
+            if (config.configFile) {
+                const fileConfig = yield ConfigDefaults.getConfigFile(config.configFile);
+                configArr.push(fileConfig);
+            }
+            configArr.push(config);
+            const outputConfig = util_1.ObjectUtil.mergeDeep({}, ...configArr);
+            const uName = outputConfig.userName;
+            const pass = outputConfig.password;
+            outputConfig.userName = () => uName;
+            outputConfig.password = () => pass;
+            outputConfig['OOBvibeEventEndpoint'] = '/rfa/vibeiq/vibeEvents';
+            console.log('outputConfig: ' + JSON.stringify(outputConfig));
+            return outputConfig;
+        });
+    }
+    static getConfigFile(fileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const options = {
+                    entityName: 'file',
+                    id: fileId,
+                };
+                const file = yield new sdk_1.Entities().get(options);
+                if (!file) {
+                    console.log('failed to find file with id: ' + fileId);
+                    return {};
+                }
+                const downloadUrl = file['downloadUrl'];
+                if (!downloadUrl) {
+                    console.log('file didnt have downloadUrl. fileId: ' + fileId);
+                    return {};
+                }
+                const response = yield fetch(downloadUrl);
+                const config = yield response.json();
+                return config ? config : {};
+            }
+            catch (e) {
+                console.log('Error getting config file: ' + fileId + '- ' + e.message);
+                return {};
+            }
+        });
+    }
+}
+exports.ConfigDefaults = ConfigDefaults;
+ConfigDefaults.NEED_CONFIG_VALUES = 'To connect to FlexPLM all these APP values need to be set apiHost, userName, and password';

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

@@ -0,0 +1,22 @@
+import { FCConfig } from './interfaces';
+import { MapFileUtil } from '@contrail/transform-data';
+export declare class DataConverter {
+    private config;
+    private mapFileUtil;
+    private typeUtils;
+    private transformMapFile;
+    private useDisplayForEnumerationMatching;
+    private objRefCache;
+    constructor(config: FCConfig, mapFileUtil: MapFileUtil);
+    getFlexPLMObjectDataFromEvent(event: any, dataToSkip: string[]): Promise<{}>;
+    getFlexPLMObjectData(newData: any, dataToSkip: string[], expandObjRef: boolean): Promise<{}>;
+    getFlexPLMValue(prop: any, newData: any, expandObjRef: boolean): Promise<any>;
+    getEnumerationValue(prop: any, nd: any): any;
+    getObjectReferenceValue(prop: any, newData: any, expandObjRef?: boolean): Promise<any>;
+    getMappingClass(entity: object, mapping: any): string;
+    setEntityValues(entity: any, data: any, keysToSkip?: string[]): Promise<any>;
+    getEntityValues(objectClass: string, data: any, keysToSkip?: string[]): Promise<{}>;
+    getEntityValue(prop: any, data: any): Promise<any>;
+    setEnumerationKeys(prop: any, nd: any, matchByDisplay: any): any;
+    getPersistableChanges(entity: object, changes: object): object;
+}

package/lib/util/data-converter.js

@@ -0,0 +1,341 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataConverter = void 0;
+const sdk_1 = require("@contrail/sdk");
+const type_utils_1 = require("./type-utils");
+const transform_data_1 = require("@contrail/transform-data");
+const app_framework_1 = require("@contrail/app-framework");
+const util_1 = require("@contrail/util");
+class DataConverter {
+    constructor(config, mapFileUtil) {
+        this.config = config;
+        this.mapFileUtil = mapFileUtil;
+        this.useDisplayForEnumerationMatching = false;
+        this.objRefCache = {};
+        this.typeUtils = new type_utils_1.TypeUtils();
+        this.transformMapFile = this.config['transformMapFile'];
+        this.useDisplayForEnumerationMatching = this.config['dataConverter']
+            && this.config['dataConverter']['useDisplayForEnumerationMatching'];
+    }
+    getFlexPLMObjectDataFromEvent(event, dataToSkip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getFlexPLMObjectData(event.newData, dataToSkip, true);
+        });
+    }
+    getFlexPLMObjectData(newData, dataToSkip, expandObjRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('newData: ' + JSON.stringify(newData));
+            }
+            dataToSkip = dataToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'workspaceId']);
+            const data = {};
+            const typeId = newData === null || newData === void 0 ? void 0 : newData.typeId;
+            if (!typeId) {
+                return;
+            }
+            data['typePath'] = newData['typePath'];
+            const type = yield this.typeUtils.getTypeById(typeId);
+            const typeProps = this.typeUtils.filterTypeProperties(type, newData);
+            for (const prop of typeProps) {
+                const slug = prop['slug'];
+                if (dataToSkip.includes(slug)) {
+                    continue;
+                }
+                data[slug] = yield this.getFlexPLMValue(prop, newData, expandObjRef);
+            }
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('getFlexPLMObjectData-data:  ' + JSON.stringify(data));
+            }
+            return data;
+        });
+    }
+    getFlexPLMValue(prop, newData, expandObjRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const propertyType = prop['propertyType'];
+            const slug = prop['slug'];
+            const nd = newData[slug];
+            let value;
+            if (['string', 'text'].includes(propertyType)) {
+                value = nd || '';
+            }
+            else if (['number', 'currency', 'percent', 'sequence'].includes(propertyType)) {
+                value = nd || 0;
+            }
+            else if ('date' === propertyType) {
+                if (nd) {
+                    value = nd;
+                }
+                else {
+                    value = null;
+                }
+            }
+            else if ('boolean' === propertyType) {
+                value = (nd) ? true : false;
+            }
+            else if ('choice' === propertyType) {
+                value = this.getEnumerationValue(prop, nd);
+            }
+            else if ('multi_select' === propertyType) {
+                value = this.getEnumerationValue(prop, nd);
+            }
+            else if ('object_reference' === propertyType) {
+                value = yield this.getObjectReferenceValue(prop, newData, expandObjRef);
+                if (app_framework_1.Logger.isDebugOn()) {
+                    console.debug('object_reference: ' + JSON.stringify(value));
+                }
+            }
+            else if ('image' === propertyType) {
+            }
+            else if ('formula' === propertyType) {
+                value = nd;
+            }
+            else if ('json' === propertyType) {
+                value = nd;
+            }
+            return value;
+        });
+    }
+    getEnumerationValue(prop, nd) {
+        const propertyType = prop['propertyType'];
+        let value;
+        if (['choice', 'multi_select'].includes(propertyType)) {
+            const options = prop['options'];
+            if ('choice' === propertyType) {
+                if (nd) {
+                    const option = options.find(option => option.value == nd);
+                    if (option) {
+                        value = Object.assign({}, option);
+                    }
+                }
+                else {
+                    value = {};
+                }
+            }
+            else if ('multi_select' === propertyType) {
+                value = [];
+                if (nd instanceof Array) {
+                    nd.forEach(key => {
+                        const optionObject = options.find(option => option.value == key);
+                        if (optionObject) {
+                            const option = Object.assign({}, optionObject);
+                            value.push(option);
+                        }
+                    });
+                }
+                else if (typeof nd === 'string' && '' !== nd) {
+                    const optionObject = options.find(option => option.value == nd);
+                    if (optionObject) {
+                        const option = Object.assign({}, optionObject);
+                        value.push(option);
+                    }
+                }
+            }
+        }
+        return value;
+    }
+    getObjectReferenceValue(prop, newData, expandObjRef = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const slug = prop['slug'];
+            console.debug('getObjectReferenceValue-prop: ' + slug);
+            let value = newData[slug];
+            const entityType = prop['referencedTypeRootSlug'];
+            const entityId = newData[slug + 'Id'];
+            if (!value && expandObjRef) {
+                if (entityId) {
+                    if (this.objRefCache[entityId]) {
+                        console.log('cache hit: ' + entityId);
+                        return this.objRefCache[entityId];
+                    }
+                    const criteria = {
+                        id: entityId
+                    };
+                    const entities = yield new sdk_1.Entities().get({
+                        entityName: entityType,
+                        criteria
+                    });
+                    value = (entities && entities[0]) ? entities[0] : undefined;
+                }
+            }
+            if (value) {
+                const unprocessedValue = value;
+                const objectClass = this.typeUtils.getEventObjectClass(entityType, newData);
+                value = yield this.getFlexPLMObjectData(value, [], false);
+                value['entityReference'] = entityType + ':' + entityId;
+                value['objectClass'] = objectClass;
+                value['typePath'] = unprocessedValue['typePath'];
+                if (this.transformMapFile) {
+                    const wholeMap = yield this.mapFileUtil.getMapFile(this.transformMapFile);
+                    const objClass = this.getMappingClass(unprocessedValue, wholeMap);
+                    const mapping = yield this.mapFileUtil.getMappingSection(this.transformMapFile, objClass, 'vibe2flex');
+                    if (mapping) {
+                        const tasks = transform_data_1.MapFileUtil.getTransformTasks(mapping);
+                        if (tasks.length > 0) {
+                            const convertedArray = transform_data_1.TransformProcessor.transformData([value], tasks);
+                            value = convertedArray[0];
+                        }
+                    }
+                }
+            }
+            else {
+                value = {};
+            }
+            this.objRefCache[entityId] = value;
+            return value;
+        });
+    }
+    getMappingClass(entity, mapping) {
+        const entityTypePath = entity['typePath'];
+        const typeMapKey = mapping['typeMapKey'];
+        let objClass = typeMapKey[entityTypePath];
+        const entityType = entity['entityType'];
+        if (!objClass) {
+            objClass = this.typeUtils.getEventObjectClass(entityType, entity);
+        }
+        if (!objClass) {
+            objClass = entityType;
+        }
+        return objClass;
+    }
+    setEntityValues(entity, data, keysToSkip = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = yield this.typeUtils.getTypeById(entity.typeId);
+            keysToSkip = keysToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'workspaceId']);
+            let typeProps = this.typeUtils.filterTypeProperties(type, entity);
+            typeProps = typeProps.filter(prop => !keysToSkip.includes(prop['slug']));
+            const dataKeys = Object.getOwnPropertyNames(data);
+            typeProps = typeProps.filter(prop => dataKeys.includes(prop['slug']));
+            for (const prop of typeProps) {
+                const slug = prop['slug'];
+                entity[slug] = yield this.getEntityValue(prop, data);
+            }
+            return entity;
+        });
+    }
+    getEntityValues(objectClass, data, keysToSkip = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entityValues = {};
+            const tco = this.typeUtils.getEntityTypeClientOptions(objectClass, data);
+            const type = yield this.typeUtils.getByRootAndPath(tco);
+            const typePath = type['typePath'];
+            if (typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))) {
+                if (['LCSProduct', 'LCSProductSeasonLink'].includes(objectClass)) {
+                    entityValues['roles'] = ['family'];
+                }
+                else {
+                    entityValues['roles'] = ['color', 'option'];
+                }
+            }
+            let typeProps = this.typeUtils.filterTypeProperties(type, entityValues);
+            typeProps = typeProps.filter(prop => !keysToSkip.includes(prop['slug']));
+            for (const prop of typeProps) {
+                const slug = prop['slug'];
+                const value = yield this.getEntityValue(prop, data);
+                if (value) {
+                    entityValues[slug] = value;
+                }
+            }
+            return entityValues;
+        });
+    }
+    getEntityValue(prop, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const propertyType = prop['propertyType'];
+            const slug = prop['slug'];
+            const nd = data[slug];
+            let value;
+            if (['string', 'text'].includes(propertyType)) {
+                value = nd;
+            }
+            else if (['number', 'currency', 'percent', 'sequence'].includes(propertyType)) {
+                value = (null === nd) ? 0 : nd;
+            }
+            else if ('date' === propertyType) {
+                if (nd) {
+                    const d = new Date(nd);
+                    value = d.toISOString();
+                }
+                else {
+                    value = null;
+                }
+            }
+            else if ('boolean' === propertyType) {
+                value = (nd) ? true : false;
+            }
+            else if ('choice' === propertyType) {
+                value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+            }
+            else if ('multi_select' === propertyType) {
+                value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+            }
+            else if ('object_reference' === propertyType) {
+            }
+            else if ('image' === propertyType) {
+                console.log('TODO');
+            }
+            else if ('formula' === propertyType) {
+                console.log('TODO');
+            }
+            else if ('json' === propertyType) {
+                console.log('TODO');
+            }
+            return value;
+        });
+    }
+    setEnumerationKeys(prop, nd, matchByDisplay) {
+        const propertyType = prop['propertyType'];
+        let value;
+        if (['choice', 'multi_select'].includes(propertyType)) {
+            const options = prop['options'];
+            if ('choice' === propertyType) {
+                if (nd) {
+                    const matchKey = (matchByDisplay) ? 'display' : 'value';
+                    const option = options.find(option => option[matchKey] == nd[matchKey]);
+                    if (option) {
+                        value = option.value;
+                    }
+                }
+                else {
+                    value = undefined;
+                }
+            }
+            else if ('multi_select' === propertyType) {
+                value = [];
+                const matchKey = (matchByDisplay) ? 'display' : 'value';
+                if (nd instanceof Array) {
+                    nd.forEach(selectedOpt => {
+                        const optionObject = options.find(option => option[matchKey] == selectedOpt[matchKey]);
+                        if (optionObject) {
+                            const option = optionObject.value;
+                            value.push(option);
+                        }
+                    });
+                }
+            }
+        }
+        return value;
+    }
+    getPersistableChanges(entity, changes) {
+        const entityCompareValues = {};
+        for (const key of (Object.getOwnPropertyNames(changes))) {
+            entityCompareValues[key] = entity[key];
+        }
+        const diffs = util_1.ObjectUtil.compareDeep(entityCompareValues, changes, '');
+        const diffValues = {};
+        if (diffs && diffs.length > 0) {
+            for (const diff of diffs) {
+                diffValues[diff.propertyName] = diff.newValue;
+            }
+        }
+        return diffValues;
+    }
+}
+exports.DataConverter = DataConverter;

package/lib/util/federation.d.ts

@@ -0,0 +1,15 @@
+import { FederationRecord } from './interfaces';
+export declare class Federation {
+    private CHUNK_SIZE;
+    getFederatedMappedRefId(entityType: string, entityId: string): Promise<string>;
+    createFederatedRecord(eventBody: any): Promise<any>;
+    getFederationRecordFromMappedRefId(mappedRefId: string): Promise<FederationRecord>;
+    static getEntityId(fedRecord: FederationRecord): {
+        entityType: string;
+        entityId: string;
+    };
+    getEntityFromMappedRefId(mappedRefId: string): Promise<any>;
+    getFederationRecordsFromIds(ids: string[]): Promise<FederationRecord[]>;
+    getFederationRecordsFromIdsBulk(ids: string[]): Promise<FederationRecord[]>;
+    splitIntoChunksByLen(arr: any, len: any): any[];
+}

package/lib/util/federation.js

@@ -0,0 +1,167 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Federation = void 0;
+const sdk_1 = require("@contrail/sdk");
+const p_limit_1 = require("p-limit");
+const limit = (0, p_limit_1.default)(30);
+const FED_CONFIG = {
+    appIdentifier: '@vibeiq/flexplm-connector',
+    federationSchema: 'DEFAULT'
+};
+class Federation {
+    constructor() {
+        this.CHUNK_SIZE = 50;
+    }
+    getFederatedMappedRefId(entityType, entityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const criteria = {
+                reference: entityType + ':' + entityId,
+                appIdentifier: FED_CONFIG.appIdentifier,
+                federationSchema: FED_CONFIG.federationSchema
+            };
+            console.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+            const fedRecords = yield new sdk_1.Entities().get({
+                entityName: 'federation',
+                criteria
+            });
+            const federatedId = (fedRecords[0])
+                ? fedRecords[0]['mappedReference']
+                : '';
+            return federatedId;
+        });
+    }
+    createFederatedRecord(eventBody) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemResults = eventBody.payload;
+            for (let i = 0; i < itemResults.length; i++) {
+                if (!itemResults[i].federatedId) {
+                    continue;
+                }
+                const payload = {
+                    appIdentifier: FED_CONFIG.appIdentifier,
+                    reference: itemResults[i].entityReference,
+                    mappedReference: itemResults[i].federatedId,
+                    federationSchema: FED_CONFIG.federationSchema
+                };
+                try {
+                    const results = yield new sdk_1.Entities().create({ entityName: 'federation', object: payload });
+                    return results;
+                }
+                catch (error) {
+                    console.log('createFederatedRecord-error: ', error);
+                    throw new Error('Error creating federation record: ' + error.message);
+                }
+            }
+        });
+    }
+    getFederationRecordFromMappedRefId(mappedRefId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const criteria = {
+                appIdentifier: FED_CONFIG.appIdentifier,
+                mappedReference: mappedRefId,
+                federationSchema: FED_CONFIG.federationSchema
+            };
+            try {
+                const fedRecords = yield new sdk_1.Entities().get({
+                    entityName: 'federation',
+                    criteria
+                });
+                return (fedRecords && fedRecords[0]) ? fedRecords[0] : undefined;
+            }
+            catch (e) {
+                console.log('getFederationData-error: ' + e.message);
+            }
+            return undefined;
+        });
+    }
+    static getEntityId(fedRecord) {
+        const entityString = fedRecord['reference'];
+        const entitySplit = entityString.split(':');
+        const entityType = entitySplit[0];
+        const entityId = entitySplit[1];
+        return { entityType, entityId };
+    }
+    getEntityFromMappedRefId(mappedRefId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fedRecord = yield this.getFederationRecordFromMappedRefId(mappedRefId);
+            console.log('fedRecord: ' + JSON.stringify(fedRecord));
+            if (!fedRecord) {
+                console.log('Federation Record doesnt exist. Cant get entity!');
+                return;
+            }
+            const { entityType, entityId } = Federation.getEntityId(fedRecord);
+            const criteria = {
+                id: entityId
+            };
+            const entities = yield new sdk_1.Entities().get({
+                entityName: entityType,
+                criteria
+            });
+            const entity = (entities && entities[0]) ? entities[0] : undefined;
+            return entity;
+        });
+    }
+    getFederationRecordsFromIds(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fedRecords = [];
+            for (let i = 0; i < ids.length; i++) {
+                const criteria = {
+                    reference: ids[i],
+                    appIdentifier: FED_CONFIG.appIdentifier,
+                    federationSchema: FED_CONFIG.federationSchema
+                };
+                const recs = yield new sdk_1.Entities().get({
+                    entityName: 'federation',
+                    criteria
+                });
+                if (recs[0]) {
+                    fedRecords.push(recs[0]);
+                }
+            }
+            return fedRecords;
+        });
+    }
+    getFederationRecordsFromIdsBulk(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunks = this.splitIntoChunksByLen(ids, this.CHUNK_SIZE);
+            const fedRecords = [];
+            const federatedPromises = [];
+            const entities = new sdk_1.Entities();
+            for (const chunk of chunks) {
+                const fedPromise = limit(() => __awaiter(this, void 0, void 0, function* () {
+                    const criteria = {
+                        references: chunk,
+                        appIdentifier: FED_CONFIG.appIdentifier,
+                        federationSchema: FED_CONFIG.federationSchema
+                    };
+                    const records = yield entities.get({
+                        entityName: 'federation',
+                        criteria
+                    });
+                    fedRecords.push(...records);
+                }));
+                federatedPromises.push(fedPromise);
+            }
+            yield Promise.all(federatedPromises);
+            return fedRecords;
+        });
+    }
+    splitIntoChunksByLen(arr, len) {
+        const chunks = [], n = arr === null || arr === void 0 ? void 0 : arr.length;
+        let i = 0;
+        while (i < n) {
+            chunks.push(arr.slice(i, i += len));
+        }
+        return chunks;
+    }
+}
+exports.Federation = Federation;

package/lib/util/flexplm-connect.d.ts

@@ -0,0 +1,16 @@
+import { FCConfig, FlexPLMResponseData, PayloadType } from './interfaces';
+export declare class FlexPLMConnect {
+    private config;
+    private vibeEventEndpoint;
+    payloadSendAsArray: boolean;
+    constructor(_config: FCConfig, endPoint?: any, payloadAsArray?: any);
+    private getRequestOptions;
+    getCSRF(): Promise<{
+        nonce_key: any;
+        nonce: any;
+    }>;
+    sendRequest(csrf: any, payload: any): Promise<Response>;
+    protected processRequest(payload: any): Promise<FlexPLMResponseData>;
+    sendToFlexPLM(payload: PayloadType): Promise<FlexPLMResponseData>;
+    sendMultipleToFlexPLM(payload: PayloadType[]): Promise<FlexPLMResponseData>;
+}