@contrail/flexplm 1.1.57 → 1.1.58

package/.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "program": "${workspaceFolder}\\lib\\index.js",
+      "outFiles": [
+        "${workspaceFolder}/**/*.js"
+      ]
+    }
+  ]
+}

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

@@ -19,6 +19,8 @@ export declare abstract class BaseEntityProcessor {
     inbound(event: EntityPayloadType): Promise<any>;
     handleIncomingUpsert(event: EntityPayloadType): Promise<any>;
     getInboundStatusMessage(statusObject: any): string;
+    queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>;
+    getRootTypePropertyKeys(rootType: any, propertyCriteria?: any): string[];
     handleIncomingDelete(event: any): Promise<void>;
     getTransformedData(event: any): Promise<any>;
     getUpdatesForEntity(entity: any, inboundData: any): Promise<object>;

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

@@ -114,6 +114,33 @@ class BaseEntityProcessor {
             + ', 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 rootType = await this.typeUtil.getByRootAndPath({ root: entityType });
+        const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
+        const rootTypeCriteria = { typePath: entityTypePath };
+        const subTypeCriteria = {};
+        for (const key in propertyCriteria) {
+            if (rootTypePropertyKeys.includes(key)) {
+                rootTypeCriteria[key] = propertyCriteria[key];
+            }
+            else {
+                subTypeCriteria[key] = propertyCriteria[key];
+            }
+        }
+        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+        return returnedEntities;
+    }
+    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);
     }

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

@@ -4,6 +4,26 @@ 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.");
@@ -72,4 +92,78 @@ describe('BaseEntityProcessor', () => {
             expect(updates).toBeUndefined();
         });
     });
+    describe('queryEntityWithSubType', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+        });
+        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'
+            };
+            const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+            const rootCriteriaResults = Object.assign({ typePath: entityTypePath }, 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('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/util/data-converter.d.ts

@@ -28,7 +28,7 @@ export declare class DataConverter {
     setEnumerationKeys(prop: any, nd: any, matchByDisplay: any): any;
     getPersistableChanges(entity: object, changes: object): object;
     setObjectReferenceValue(prop: any, nd: any): Promise<any>;
-    getAllObjectReferences(entityType: any, rootTypeCriteria: any): Promise<any[]>;
+    getAllObjectReferences(entityType: string, rootTypeCriteria: any, postProcessCriteria?: any): Promise<any[]>;
     checkKeysAndValues(criteria: any, arrayOfObjects: any, entityTypePath: any): any[];
     setUserListValue(prop: any, nd: any): Promise<any>;
     getUserByEmail(nd: any): Promise<any>;

package/lib/util/data-converter.js

@@ -398,22 +398,29 @@ class DataConverter {
         this.objRefCache[cacheKey] = objectReferenceId;
         return objectReferenceId;
     }
-    async getAllObjectReferences(entityType, rootTypeCriteria) {
+    async getAllObjectReferences(entityType, rootTypeCriteria, postProcessCriteria = null) {
         const entities = new sdk_1.Entities();
         let loads = [];
         let nextPageKey;
         let usedV2 = false;
         do {
+            const take = 1000;
             const loadPage = await entities.get({
                 entityName: entityType,
                 criteria: rootTypeCriteria,
                 apiVersion: sdk_1.API_VERSION.V2,
+                take,
                 nextPageKey,
             });
             nextPageKey = loadPage?.nextPageKey;
             if (Object.keys(loadPage).includes('results')) {
                 usedV2 = true;
-                loads.push(...loadPage.results);
+                let postProcessedResults = loadPage.results;
+                if (postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+                    const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+                    postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+                }
+                loads.push(...postProcessedResults);
             }
             else {
                 nextPageKey = null;
@@ -430,7 +437,12 @@ class DataConverter {
                     take,
                     skip,
                 });
-                loads.push(...loadPage);
+                let postProcessedResults = loadPage;
+                if (postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+                    const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+                    postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+                }
+                loads.push(...postProcessedResults);
                 if (loadPage.length !== take) {
                     done = true;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.1.57",
+  "version": "1.1.58",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -10,7 +10,8 @@
     "lint": "tslint -p tsconfig.json",
     "test": "jest",
     "test-watch": "jest --watch",
-    "test-debug": "jest --runInBand"
+    "test-debug": "jest --runInBand",
+    "test-coverage": "jest --coverage"
   },
   "keywords": [],
   "author": "",

package/src/entity-processor/base-entity-processor.spec.ts

@@ -1,9 +1,31 @@
-import { Entities } from "@contrail/sdk";
+import { Entities, TypeClientOptions } from "@contrail/sdk";
 import { MapFileUtil } from "@contrail/transform-data";
 import { EntityPayloadType, FCConfig } from "../interfaces/interfaces";
 import { DataConverter } from "../util/data-converter";
 import { BaseEntityProcessor, IncomingEntityResponse } from "./base-entity-processor";
 
+const mockRootType = {
+  typeProperties: [
+    { slug: 'rootText' }
+  ]
+};
+const mockTypeUtilGetByRootAndPath = jest.fn((options: TypeClientOptions) => {
+  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 BaseEntityProcessor {
   protected getIncomingEntity(event: any, inboundData: any): Promise<IncomingEntityResponse> {
     throw new Error("Method not implemented.");
@@ -77,4 +99,91 @@ describe('BaseEntityProcessor', () =>{
       expect(updates).toBeUndefined();
     });
   });
-});
+
+  describe('queryEntityWithSubType', () =>{
+    const config = {} as FCConfig;
+    const mapFileUtil = new MapFileUtil(new Entities());
+    beforeEach(() =>{
+      // jest.clearAllMocks();
+    });
+    it('entity parameter not set', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, '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({} as FCConfig, {} as DataConverter, {} as MapFileUtil, '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({} as FCConfig, {} as DataConverter, {} as MapFileUtil, '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 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'
+      };
+      const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+      const rootCriteriaResults = Object.assign({typePath: entityTypePath}, 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('getRootTypePropertyKeys', () =>{
+    it('rootType parameter not set', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
+      const rootType = '';
+      expect(async () => {await btep.getRootTypePropertyKeys(rootType)}).rejects.toThrow();
+    });
+
+    it('get keys from rootType.typeProperties', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, '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({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
+      const rootType = {
+        typeProperties: [{ slug: 'a'},{slug: 'b'}]
+      };
+      const keys = await btep.getRootTypePropertyKeys(rootType);
+      expect(keys).toEqual(['a', 'b']);
+    });
+
+  });
+
+});

package/src/entity-processor/base-entity-processor.ts

@@ -5,6 +5,7 @@ import { FlexPLMConnect,} from '../util/flexplm-connect';
 import { MapUtil } from '../util/map-utils';
 import { MapFileUtil } from '@contrail/transform-data';
 import { Entities } from '@contrail/sdk';
+import { TypeProperty } from '@contrail/types';
 import { TypeConversionUtils } from '../util/type-conversion-utils';
 import { EventShortMessageStatus } from '../util/event-short-message-status';
 
@@ -133,6 +134,60 @@ export abstract class BaseEntityProcessor {
     + ', orgSlug: ' + this.orgSlug;
   }
 
+  /**This will query for the entity, and handle post-processing
+   * of any critieria that is defined at the sub-type level.
+   * Because sub-type criteria can't be used in the search done
+   * on the server. This is expected to be called by getIncomingEntity().
+   *
+   * @param entityType: the root type of the entity
+   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+   * @param propertyCriteria: all the criteria to search for the entity
+   * @returns the entities that match the criteria
+   */
+  async queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>{
+    //allCriteria; identifierKeys; entityType; entityTypePath
+    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 = {typePath:entityTypePath};
+    const subTypeCriteria = {};
+    for(const key in propertyCriteria){
+      if(rootTypePropertyKeys.includes(key)){
+        rootTypeCriteria[key] = propertyCriteria[key];
+      }else{
+        subTypeCriteria[key] = propertyCriteria[key];
+      }
+    }
+
+    const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+
+    return returnedEntities;
+  }
+
+  /** This is to get the properties that are owned by the root type
+   * This needs to be overridded for multi-level types, such as item
+   * and project-item. And for those types, the propertyCriteria
+   * will be needed to determine the correct level.
+   *
+   * @param rootType: the full root type entity for the processed entity
+   * @param propertyCriteria: the criteria to determine the correct level (unused for single level types)
+   * @returns: string[] of the property keys
+   */
+  getRootTypePropertyKeys(rootType, propertyCriteria = null): string[] {
+    const props: TypeProperty[] = rootType['typeProperties'];
+    const rootTypePropertyKeys = props.map(prop => prop.slug);
+
+    return rootTypePropertyKeys;
+  }
+
+
   async handleIncomingDelete(event) {
     console.warn('delete is not configured', event);
   }

package/src/util/data-converter.spec.ts

@@ -29,205 +29,6 @@ import { FCConfig } from '../interfaces/interfaces';
 import { TypeConversionUtils } from './type-conversion-utils';
 import { MapUtil } from './map-utils';
 
-// describe('transformEntity', () =>{
-//   const config: FCConfig = {
-//     apiHost: 'host',
-//     userName: () => 'user',
-//     password: () => 'pass',
-//     urlContext: 'xxx',
-//     vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
-//     itemPreDevelopmentLifecycleStages: ['concept'],
-//     propertyMapping: {
-//       LCSSeason :{
-//         flexPLMSeasonName: 'seasonName'
-//       },
-//       LCSProduct: {
-//         name: 'productName'
-//       },
-//       LCSSKU: {
-//         optionName: 'skuName'
-//       }
-//     }
-//   };
-
-//   it('LCSSeason-flexPLMSeasonName', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const seasonEntity = {
-//       objectClass: 'LCSSeason',
-//       flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       name
-//     };
-
-//     const seasonObj = dc.transformEntity(seasonEntity);
-
-//     const objectKeys = Object.keys(seasonObj);
-//     expect(objectKeys.length).toEqual(5);
-//     expect(seasonObj['seasonName']).toEqual(flexPLMSeasonName);
-//     expect(seasonObj['numberAtt']).toEqual(numberAtt);
-//     expect(seasonObj['stringAtt']).toEqual(stringAtt);
-//     expect(seasonObj['name']).toEqual(name);
-
-//   });
-
-//   it('LCSProduct-name', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const productEntity = {
-//       objectClass: 'LCSProduct',
-//       flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       name
-//     };
-
-//     const productObj = dc.transformEntity(productEntity);
-
-//     const objectKeys = Object.keys(productObj);
-//     expect(objectKeys.length).toEqual(5);
-//     expect(productObj['flexPLMSeasonName']).toEqual(flexPLMSeasonName);
-//     expect(productObj['numberAtt']).toEqual(numberAtt);
-//     expect(productObj['stringAtt']).toEqual(stringAtt);
-//     expect(productObj['productName']).toEqual(name);
-
-//   });
-
-//   it('LCSSKU-name', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const optionName = 'sku name';
-//     const skuEntity = {
-//       objectClass: 'LCSSKU',
-//       flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       name,
-//       optionName
-//     };
-
-//     const skuObj = dc.transformEntity(skuEntity);
-
-//     const objectKeys = Object.keys(skuObj);
-//     expect(objectKeys.length).toEqual(6);
-//     expect(skuObj['flexPLMSeasonName']).toEqual(flexPLMSeasonName);
-//     expect(skuObj['numberAtt']).toEqual(numberAtt);
-//     expect(skuObj['stringAtt']).toEqual(stringAtt);
-//     expect(skuObj['name']).toEqual(name);
-//     expect(skuObj['skuName']).toEqual(optionName);
-
-//   });
-// });
-
-// describe('transformObject', () =>{
-//   const config: FCConfig = {
-//     apiHost: 'host',
-//     userName: () => 'user',
-//     password: () => 'pass',
-//     urlContext: 'xxx',
-//     vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
-//     itemPreDevelopmentLifecycleStages: ['concept'],
-//     propertyMapping: {
-//       LCSSeason :{
-//         flexPLMSeasonName: 'seasonName'
-//       },
-//       LCSProduct: {
-//         name: 'productName'
-//       },
-//       LCSSKU: {
-//         optionName: 'skuName'
-//       }
-//     }
-//   };
-
-//   it('LCSSeason-flexPLMSeasonName', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const seasonObj = {
-//       objectClass: 'LCSSeason',
-//       seasonName: flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       name
-//     };
-
-//     const seasonEntity = dc.transformObject(seasonObj);
-//     const objectKeys = Object.keys(seasonEntity);
-//     expect(objectKeys.length).toEqual(5);
-//     expect(seasonEntity['flexPLMSeasonName']).toEqual(flexPLMSeasonName);
-//     expect(seasonEntity['numberAtt']).toEqual(numberAtt);
-//     expect(seasonEntity['stringAtt']).toEqual(stringAtt);
-//     expect(seasonEntity['name']).toEqual(name);
-
-//   });
-
-//   it('LCSProduct-name', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const productObj = {
-//       objectClass: 'LCSProduct',
-//       flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       productName: name
-//     };
-
-//     const productEntity = dc.transformObject(productObj);
-
-//     const objectKeys = Object.keys(productEntity);
-//     expect(objectKeys.length).toEqual(5);
-//     expect(productEntity['flexPLMSeasonName']).toEqual(flexPLMSeasonName);
-//     expect(productEntity['numberAtt']).toEqual(numberAtt);
-//     expect(productEntity['stringAtt']).toEqual(stringAtt);
-//     expect(productEntity['name']).toEqual(name);
-
-//   });
-
-//   it('LCSSKU-name', () =>{
-//     const dc = new DataConverter(new Logger(config), config);
-//     const flexPLMSeasonName = 'Season Name';
-//     const stringAtt = 'some value';
-//     const numberAtt = 44;
-//     const name = 'productName';
-//     const optionName = 'sku name';
-//     const skuObj = {
-//       objectClass: 'LCSSKU',
-//       flexPLMSeasonName,
-//       stringAtt,
-//       numberAtt,
-//       name,
-//       skuName: optionName
-//     };
-
-//     const skuEntity = dc.transformObject(skuObj);
-
-//     const objectKeys = Object.keys(skuEntity);
-//     expect(objectKeys.length).toEqual(6);
-//     expect(skuEntity['flexPLMSeasonName']).toEqual(flexPLMSeasonName);
-//     expect(skuEntity['numberAtt']).toEqual(numberAtt);
-//     expect(skuEntity['stringAtt']).toEqual(stringAtt);
-//     expect(skuEntity['name']).toEqual(name);
-//     expect(skuEntity['optionName']).toEqual(optionName);
-
-//   });
-// });
-
 describe('getFlexPLMValue multi_select', () => {
   const config: FCConfig = {
     apiHost: 'host',
@@ -590,7 +391,7 @@ describe('getObjectReferenceValue cache', () =>{
     }
   });
 });
-  describe('getObjectReferenceValue bad value', () =>{
+describe('getObjectReferenceValue bad value', () =>{
     const config: FCConfig = {
       apiHost: 'host',
       userName: () => 'user',

package/src/util/data-converter.ts

@@ -495,22 +495,29 @@ export class DataConverter {
    * @param {object} rootTypeCriteria - The criteria used to filter object references.
    * @returns {Promise<Array>} A Promise that resolves to an array containing all object references.
    */
-  async getAllObjectReferences(entityType, rootTypeCriteria) {
+  async getAllObjectReferences(entityType: string, rootTypeCriteria, postProcessCriteria = null) {
     const entities = new Entities();
     let loads = [];
     let nextPageKey;
     let usedV2 = false;
     do {
+      const take = 1000;
       const loadPage = await entities.get({
         entityName: entityType,
         criteria: rootTypeCriteria,
         apiVersion: API_VERSION.V2,
+        take,
         nextPageKey,
       });
       nextPageKey = loadPage?.nextPageKey;
       if (Object.keys(loadPage).includes('results')) {
         usedV2 = true;
-        loads.push(...loadPage.results);
+        let postProcessedResults = loadPage.results;
+        if(postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+          const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+          postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+        }
+        loads.push(...postProcessedResults);
       } else {
         nextPageKey = null;
       }
@@ -527,7 +534,12 @@ export class DataConverter {
           take,
           skip,
         });
-        loads.push(...loadPage);
+        let postProcessedResults = loadPage;
+        if(postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+          const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+          postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+        }
+        loads.push(...postProcessedResults);
 
         if (loadPage.length !== take) {
           done = true;