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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.2.0-alpha.0",
+  "version": "1.3.0-alpha.0",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/scripts/test-get-request.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { FlexPLMConnect } from '../src/util/flexplm-connect';
+import { FCConfig } from '../src/interfaces/interfaces';
+
+const config: FCConfig = {
+  apiHost: 'http://windchill.archergrey.com',
+  urlContext: '',
+  vibeEventEndpoint: '',
+  csrfEndpoint: '',
+  plmEnviornment: '',
+  userName: () => '',  // fill in manually
+  password: () => '',  // fill in manually
+  itemPreDevelopmentLifecycleStages: [],
+  payloadDefaultAsArray: true,
+};
+
+async function main() {
+  const connect = new FlexPLMConnect(config);
+  const response = await connect.getRequest({
+    urlPath: '/Windchill/images/000001/000001/000001/cavkingcharlessmalldogs_medium_large-.-2965893984400.png',
+    includeUrlContext: false,
+    returnFullResponse: true,
+  }) as Response;
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const outputPath = path.resolve(__dirname, 'output.png');
+  fs.writeFileSync(outputPath, buffer);
+  console.log(`Saved response to ${outputPath}`);
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/src/util/flexplm-connect.spec.ts

@@ -0,0 +1,132 @@
+
+import { FlexPLMConnect } from './flexplm-connect';
+import { FCConfig } from '../interfaces/interfaces';
+
+const mockJsonData = { items: [{ id: '123', name: 'test' }] };
+
+const mockResponse = (status: number, json = mockJsonData) => ({
+  status,
+  json: jest.fn().mockResolvedValue(json),
+  text: jest.fn().mockResolvedValue('error text'),
+});
+
+const globalFetch = global.fetch;
+
+beforeEach(() => {
+  global.fetch = jest.fn().mockResolvedValue(mockResponse(200));
+});
+
+afterAll(() => {
+  global.fetch = globalFetch;
+});
+
+const createConfig = (overrides?: Partial<FCConfig>): FCConfig => ({
+  apiHost: 'https://flexplm.example.com',
+  urlContext: '/FlexPLM',
+  vibeEventEndpoint: '/api/events',
+  csrfEndpoint: '/csrf',
+  plmEnviornment: 'test',
+  userName: () => 'user',
+  password: () => 'pass',
+  itemPreDevelopmentLifecycleStages: [],
+  payloadDefaultAsArray: true,
+  ...overrides,
+});
+
+describe('FlexPLMConnect.getRequest', () => {
+
+  it('should call default URL with urlContext when no params provided', async () => {
+    const connect = new FlexPLMConnect(createConfig());
+    await connect.getRequest();
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://flexplm.example.com/FlexPLM/servlet/rest/api/events',
+      expect.objectContaining({ method: 'GET' }),
+    );
+  });
+
+  it('should use the constructor endpoint in the default URL', async () => {
+    const connect = new FlexPLMConnect(createConfig(), '/custom/endpoint');
+    await connect.getRequest();
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://flexplm.example.com/FlexPLM/servlet/rest/custom/endpoint',
+      expect.any(Object),
+    );
+  });
+
+  it('should return parsed JSON by default', async () => {
+    const connect = new FlexPLMConnect(createConfig());
+    const result = await connect.getRequest();
+    expect(result).toEqual(mockJsonData);
+  });
+
+  it('should use urlPath when provided', async () => {
+    const connect = new FlexPLMConnect(createConfig());
+    await connect.getRequest({ urlPath: '/custom/path' });
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://flexplm.example.com/FlexPLM/custom/path',
+      expect.any(Object),
+    );
+  });
+
+  it('should exclude urlContext when includeUrlContext is false', async () => {
+    const connect = new FlexPLMConnect(createConfig());
+    await connect.getRequest({ includeUrlContext: false });
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://flexplm.example.com/servlet/rest/api/events',
+      expect.any(Object),
+    );
+  });
+
+  it('should exclude urlContext with custom urlPath', async () => {
+    const connect = new FlexPLMConnect(createConfig());
+    await connect.getRequest({ urlPath: '/custom/path', includeUrlContext: false });
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://flexplm.example.com/custom/path',
+      expect.any(Object),
+    );
+  });
+
+  it('should return full response when returnFullResponse is true', async () => {
+    const rawResponse = mockResponse(200);
+    (global.fetch as jest.Mock).mockResolvedValue(rawResponse);
+
+    const connect = new FlexPLMConnect(createConfig());
+    const result = await connect.getRequest({ returnFullResponse: true });
+
+    expect(result).toBe(rawResponse);
+    expect(rawResponse.json).not.toHaveBeenCalled();
+  });
+
+  it('should throw on status >= 300', async () => {
+    (global.fetch as jest.Mock).mockResolvedValue(mockResponse(404));
+
+    const connect = new FlexPLMConnect(createConfig());
+    await expect(connect.getRequest()).rejects.toThrow('Error connecting to FlexPLM:status: 404');
+  });
+
+  it('should throw on status >= 300 even with returnFullResponse', async () => {
+    (global.fetch as jest.Mock).mockResolvedValue(mockResponse(500));
+
+    const connect = new FlexPLMConnect(createConfig());
+    await expect(connect.getRequest({ returnFullResponse: true })).rejects.toThrow(
+      'Error connecting to FlexPLM:status: 500',
+    );
+  });
+
+  it('should throw when response.json() fails', async () => {
+    const badResponse = {
+      status: 200,
+      json: jest.fn().mockRejectedValue(new Error('Invalid JSON')),
+      text: jest.fn().mockResolvedValue('not json'),
+    };
+    (global.fetch as jest.Mock).mockResolvedValue(badResponse);
+
+    const connect = new FlexPLMConnect(createConfig());
+    await expect(connect.getRequest()).rejects.toThrow('Error getting json data from FlexPLM: Invalid JSON');
+  });
+});

package/src/util/flexplm-connect.ts

@@ -171,12 +171,18 @@ export class FlexPLMConnect {
     return await this.processRequest(payload);
   }
 
-  /** Runs a get request to FlexPLM using the endpoint provided in the constructor
-   * 
+  /** Runs a GET request to FlexPLM.
+   * @param params - Optional configuration for the request.
+   * @param params.urlPath - Custom URL path to use instead of the default `/servlet/rest` + endpoint.
+   * @param params.includeUrlContext - Whether to include the urlContext in the URL. Defaults to `true`.
+   * @param params.returnFullResponse - If `true`, returns the raw `Response` object instead of parsed JSON. Defaults to `false`.
+   * @returns The parsed JSON response body, or the raw `Response` object if `returnFullResponse` is `true`.
    */
-  async getRequest(){
-    const urlContext = this.config.urlContext;
-    const vibeEventsURL: string = this.config.apiHost + urlContext + '/servlet/rest' + this.vibeEventEndpoint;
+  async getRequest(params?: { urlPath?: string; includeUrlContext?: boolean; returnFullResponse?: boolean }): Promise<Response | unknown>{
+    const { urlPath, includeUrlContext = true, returnFullResponse = false } = params || {};
+    const urlContext = includeUrlContext ? this.config.urlContext : '';
+    const path = urlPath || ('/servlet/rest' + this.vibeEventEndpoint);
+    const vibeEventsURL: string = this.config.apiHost + urlContext + path;
     const csrfOptions = this.getRequestOptions('GET');
     const response = await fetch(vibeEventsURL, csrfOptions);
 
@@ -186,6 +192,9 @@ export class FlexPLMConnect {
       console.error(await response.text());
       throw new Error(message);
     }
+    if(returnFullResponse){
+      return response;
+    }
     try {
       const data = await response.json();
       return data;

package/src/util/type-conversion-utils-spec-mockData.ts

@@ -142,6 +142,12 @@ exports.mapping = {
     isOutboundCreatable: (entity, context) => {
       return false;
     },
+    syncInboundImages: (entity, context) => {
+      return true;
+    },
+    syncOutboundImages: (entity, context) => {
+      return false;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {
@@ -175,6 +181,18 @@ exports.mapping = {
       }
       return true;
     },
+    syncInboundImages: (entity, context) => {
+      if (context && context.skipImages) {
+        return false;
+      }
+      return true;
+    },
+    syncOutboundImages: (entity, context) => {
+      if (context && context.skipImages) {
+        return false;
+      }
+      return true;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {

package/src/util/type-conversion-utils.spec.ts

@@ -781,4 +781,188 @@ describe('conversion-utils', () => {
     });
 
   });
+
+  describe('syncInboundImages', () =>{
+    const mapFileUtil = new MapFileUtil(new Entities());
+
+    it('should return true for custom-entity:pack', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should return true for custom-entity:prefix', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should pass context to syncInboundImages function', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+      const context = { skipImages: true };
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to false when no mapping exists', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:catName'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to false when no fileId', async () =>{
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      const results = await TypeConversionUtils.syncInboundImages(null, mapFileUtil, entity);
+      expect(results).toBeFalsy();
+    });
+
+  });
+
+  describe('syncOutboundImages', () =>{
+    const mapFileUtil = new MapFileUtil(new Entities());
+
+    it('should return false for custom-entity:pack', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should return true for custom-entity:prefix', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should pass context to syncOutboundImages function', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+      const context = { skipImages: true };
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to true when no mapping exists', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:catName'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to true when no fileId', async () =>{
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      const results = await TypeConversionUtils.syncOutboundImages(null, mapFileUtil, entity);
+      expect(results).toBeTruthy();
+    });
+
+  });
 });

package/src/util/type-conversion-utils.ts

@@ -377,6 +377,80 @@ export class TypeConversionUtils {
     return isOutboundCreatable;
   }
 
+  /** Takes in a VibeIQ entity object and determines whether inbound
+   * images should be synced. The creation owning system is expected
+   * to also control image syncing. Defaults to false if no mapping exists.
+   * Map file entry in '<mapKey>:syncInboundImages()'
+   *
+   * @param fileId id for mapFile
+   * @param mapFileUtil class to get mapfile
+   * @param entity VibeIQ entity
+   * @param context optional context object
+   * @returns Promise<boolean>
+   */
+  static async syncInboundImages(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean> {
+
+    let syncImages = false;
+
+    if (!fileId) {
+      return syncImages;
+    }
+
+    let mapKey: string | undefined;
+    try {
+      mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+    } catch {
+      return syncImages;
+    }
+
+    if (!mapKey) {
+      return syncImages;
+    }
+
+    const mapData = await MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+    if (mapData && mapData['syncInboundImages']) {
+      syncImages = await mapData['syncInboundImages'](entity, context);
+    }
+    return syncImages;
+  }
+
+  /** Takes in a VibeIQ entity object and determines whether outbound
+   * images should be synced. The creation owning system is expected
+   * to also control image syncing. Defaults to true if no mapping exists.
+   * Map file entry in '<mapKey>:syncOutboundImages()'
+   *
+   * @param fileId id for mapFile
+   * @param mapFileUtil class to get mapfile
+   * @param entity VibeIQ entity
+   * @param context optional context object
+   * @returns Promise<boolean>
+   */
+  static async syncOutboundImages(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean> {
+
+    let syncImages = true;
+
+    if (!fileId) {
+      return syncImages;
+    }
+
+    let mapKey: string | undefined;
+    try {
+      mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+    } catch {
+      return syncImages;
+    }
+
+    if (!mapKey) {
+      return syncImages;
+    }
+
+    const mapData = await MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+    if (mapData && mapData['syncOutboundImages']) {
+      syncImages = await mapData['syncOutboundImages'](entity, context);
+    }
+    return syncImages;
+  }
+
   static getObjectType(object:any) {
     let objectType = object['flexPLMObjectClass'];
     return objectType;

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

@@ -1,42 +0,0 @@
-import { FCConfig, EntityPayloadType } from '../interfaces/interfaces';
-import { DataConverter } from '../util/data-converter';
-import { TypeUtils } from '../util/type-utils';
-import { MapFileUtil } from '@contrail/transform-data';
-export declare class IncomingEntityResponse {
-    entity: any;
-    earlyReturn: any;
-}
-export declare abstract class BaseEntityProcessor {
-    protected config: FCConfig;
-    protected dc: DataConverter;
-    protected mapFileUtil: MapFileUtil;
-    protected baseType: string;
-    protected typeUtil: TypeUtils;
-    protected transformMapFile: string;
-    protected entities: any;
-    protected orgSlug: string;
-    constructor(config: FCConfig, dc: DataConverter, mapFileUtil: MapFileUtil, baseType: string);
-    inbound(event: EntityPayloadType): Promise<any>;
-    handleIncomingUpsert(event: EntityPayloadType): Promise<any>;
-    getInboundStatusMessage(statusObject: any): string;
-    queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>;
-    getCriteriaForEntity(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>;
-    getVibeOwningKeys(entity: any): Promise<any[]>;
-    getVibeOwningKeysFromInbound(entity: any): Promise<any[]>;
-    createEntity(entityName: any, changes: any): Promise<any>;
-    updateEntity(entityName: any, entity: any, diffs: any): Promise<any>;
-    protected abstract getIncomingEntity(event: any, inboundData: any): Promise<IncomingEntityResponse>;
-    protected abstract getCreateEntity(inboundData: any): Promise<IncomingEntityResponse>;
-    outbound(event: any): Promise<any>;
-    handleOutgoingUpsert(entityType: any, event: any): Promise<any>;
-    getOutboundEntityUpdates(event: any, flexResponse: any): Promise<any>;
-    handleOutgoingDelete(entityType: any, event: any): Promise<void>;
-    protected abstract getOutgoingUpsertPayload(entityType: any, event: any): Promise<EntityPayloadType>;
-    protected triggerNewEvent(triggerKey: string, event: any): Promise<any>;
-    protected sendUpsertToFlexPLM(event: any): Promise<any>;
-    protected getEntityCurrentStateUpsertPayload(event: any): Promise<EntityPayloadType>;
-}