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

package/lib/util/error-response-object.d.ts

@@ -0,0 +1,4 @@
+import { AppActionCallBack } from "@contrail/app-framework";
+export declare class ErrorResponseObject {
+    static getResponse(e: any): AppActionCallBack;
+}

package/lib/util/error-response-object.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorResponseObject = void 0;
+const app_framework_1 = require("@contrail/app-framework");
+class ErrorResponseObject {
+    static getResponse(e) {
+        if (!e) {
+            const response = {
+                status: app_framework_1.AppActionCallbackStatus.FAILURE,
+                output: {
+                    message: 'No error provided.'
+                }
+            };
+            return response;
+        }
+        const response = {
+            status: app_framework_1.AppActionCallbackStatus.FAILURE,
+            output: {
+                message: e.message
+            }
+        };
+        const output = response.output;
+        if (e.details)
+            output.errorDetails = e.details;
+        if (e.code)
+            output.code = e.code;
+        if (e.errno)
+            output.errno = e.errno;
+        if (e.type)
+            output.type = e.type;
+        if (e.name)
+            output.errorName = e.name;
+        if (e.cause) {
+            output.cause = {};
+            const cause = output.cause;
+            if (e.cause.code)
+                cause.code = e.cause.code;
+            if (e.cause.message)
+                cause.message = e.cause.message;
+        }
+        if (e.stack) {
+            console.log('ErrorResponseObject.getResponse stack: ' + e.stack);
+        }
+        return response;
+    }
+}
+exports.ErrorResponseObject = ErrorResponseObject;

package/lib/util/error-response-object.spec.d.ts

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

package/lib/util/error-response-object.spec.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_framework_1 = require("@contrail/app-framework");
+const error_response_object_1 = require("./error-response-object");
+describe('getResponse() Tests', () => {
+    it('no error provided', () => {
+        const e = undefined;
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('No error provided');
+    });
+    it('error with message', () => {
+        const e = {
+            message: 'Test'
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+    });
+    it('error with details', () => {
+        const details = {
+            message: 'Detail Message',
+            itemType: [
+                {
+                    message: "Type 'item:product:newBalance:apparel' cannot be assigned to a property with type 'item'."
+                }
+            ]
+        };
+        const e = {
+            message: 'Test',
+            details
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response).toBeTruthy();
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response.output.message).toMatch('Test');
+        const errorDetails = response.output.errorDetails;
+        expect(errorDetails).toBeTruthy();
+        expect(errorDetails.message).toMatch('Detail Message');
+        expect(errorDetails).toHaveProperty('itemType');
+    });
+    it('error with cause', () => {
+        const cause = {
+            code: 401,
+            message: 'cause message'
+        };
+        const e = {
+            message: 'Test',
+            cause
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+        const resCause = response.output.cause;
+        expect(resCause).toBeTruthy();
+        expect(resCause.code).toBe(401);
+        expect(resCause.message).toMatch('cause message');
+    });
+    it('error with code', () => {
+        const e = {
+            message: 'Test',
+            code: 404
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+        expect(response.output.code).toBe(404);
+    });
+    it('error with code', () => {
+        const e = {
+            message: 'Test',
+            name: 'Error'
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+        expect(response.output.errorName).toMatch('Error');
+    });
+    it('error with errno', () => {
+        const e = {
+            message: 'Test',
+            errno: 500
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+        expect(response.output.errno).toBe(500);
+    });
+    it('error with type', () => {
+        const e = {
+            message: 'Test',
+            type: 'system'
+        };
+        const response = error_response_object_1.ErrorResponseObject.getResponse(e);
+        expect(response.status).toMatch(app_framework_1.AppActionCallbackStatus.FAILURE);
+        expect(response?.output?.message).toMatch('Test');
+        expect(response.output.type).toMatch('system');
+    });
+});

package/lib/util/event-short-message-status.d.ts

@@ -0,0 +1,18 @@
+export declare enum EventShortMessageStatus {
+    SUCCESS = "Success",
+    FAILURE = "Failure",
+    CREATED = "Created",
+    ITEM_FAMILY_ID_MISSING = "Item_family_id_missing",
+    ITEM_FAMILY_NOT_FOUND = "Item_family_not_found",
+    PROJECT_ITEM_NOT_FOUND = "Project_item_not_found",
+    MISSING_IDENTIFIER_PROPERTIES = "Missing_identifier_properties",
+    MISSING_INPUT = "Missing_input",
+    NOT_CREATABLE = "Not_creatable",
+    NO_CHANGES = "No_Changes",
+    TOO_MANY_ENTITIES_FOUND = "Too_Many_Entities_Found",
+    UPDATED = "Updated",
+    NOT_PUBLISHABLE = "Not_Publishable",
+    NO_FEDERATION_INFO = "No_Federation_Information",
+    NO_EVENTS_TO_SEND = "No_Events_to_Send",
+    SENDING_EVENTS = "Sending_Events"
+}

package/lib/util/event-short-message-status.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventShortMessageStatus = void 0;
+var EventShortMessageStatus;
+(function (EventShortMessageStatus) {
+    EventShortMessageStatus["SUCCESS"] = "Success";
+    EventShortMessageStatus["FAILURE"] = "Failure";
+    EventShortMessageStatus["CREATED"] = "Created";
+    EventShortMessageStatus["ITEM_FAMILY_ID_MISSING"] = "Item_family_id_missing";
+    EventShortMessageStatus["ITEM_FAMILY_NOT_FOUND"] = "Item_family_not_found";
+    EventShortMessageStatus["PROJECT_ITEM_NOT_FOUND"] = "Project_item_not_found";
+    EventShortMessageStatus["MISSING_IDENTIFIER_PROPERTIES"] = "Missing_identifier_properties";
+    EventShortMessageStatus["MISSING_INPUT"] = "Missing_input";
+    EventShortMessageStatus["NOT_CREATABLE"] = "Not_creatable";
+    EventShortMessageStatus["NO_CHANGES"] = "No_Changes";
+    EventShortMessageStatus["TOO_MANY_ENTITIES_FOUND"] = "Too_Many_Entities_Found";
+    EventShortMessageStatus["UPDATED"] = "Updated";
+    EventShortMessageStatus["NOT_PUBLISHABLE"] = "Not_Publishable";
+    EventShortMessageStatus["NO_FEDERATION_INFO"] = "No_Federation_Information";
+    EventShortMessageStatus["NO_EVENTS_TO_SEND"] = "No_Events_to_Send";
+    EventShortMessageStatus["SENDING_EVENTS"] = "Sending_Events";
+})(EventShortMessageStatus = exports.EventShortMessageStatus || (exports.EventShortMessageStatus = {}));

package/lib/util/federation.d.ts

@@ -0,0 +1,15 @@
+import { FederationRecord } from '../interfaces/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,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Federation = void 0;
+const sdk_1 = require("@contrail/sdk");
+const p_limit_1 = __importDefault(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;
+    }
+    async getFederatedMappedRefId(entityType, entityId) {
+        const criteria = {
+            reference: entityType + ':' + entityId,
+            appIdentifier: FED_CONFIG.appIdentifier,
+            federationSchema: FED_CONFIG.federationSchema
+        };
+        console.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+        const fedRecords = await new sdk_1.Entities().get({
+            entityName: 'federation',
+            criteria
+        });
+        const federatedId = (fedRecords[0])
+            ? fedRecords[0]['mappedReference']
+            : '';
+        return federatedId;
+    }
+    async createFederatedRecord(eventBody) {
+        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 = await 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);
+            }
+        }
+    }
+    async getFederationRecordFromMappedRefId(mappedRefId) {
+        const criteria = {
+            appIdentifier: FED_CONFIG.appIdentifier,
+            mappedReference: mappedRefId,
+            federationSchema: FED_CONFIG.federationSchema
+        };
+        try {
+            const fedRecords = await 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 };
+    }
+    async getEntityFromMappedRefId(mappedRefId) {
+        const fedRecord = await 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 = await new sdk_1.Entities().get({
+            entityName: entityType,
+            criteria
+        });
+        const entity = (entities && entities[0]) ? entities[0] : undefined;
+        return entity;
+    }
+    async getFederationRecordsFromIds(ids) {
+        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 = await new sdk_1.Entities().get({
+                entityName: 'federation',
+                criteria
+            });
+            if (recs[0]) {
+                fedRecords.push(recs[0]);
+            }
+        }
+        return fedRecords;
+    }
+    async getFederationRecordsFromIdsBulk(ids) {
+        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(async () => {
+                const criteria = {
+                    references: chunk,
+                    appIdentifier: FED_CONFIG.appIdentifier,
+                    federationSchema: FED_CONFIG.federationSchema
+                };
+                const records = await entities.get({
+                    entityName: 'federation',
+                    criteria
+                });
+                fedRecords.push(...records);
+            });
+            federatedPromises.push(fedPromise);
+        }
+        await Promise.all(federatedPromises);
+        return fedRecords;
+    }
+    splitIntoChunksByLen(arr, len) {
+        const chunks = [], n = 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,22 @@
+import { FCConfig, FlexPLMResponseData, PayloadType } from '../interfaces/interfaces';
+export declare class FlexPLMConnect {
+    private config;
+    private vibeEventEndpoint;
+    private staticHeaders;
+    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>;
+    getRequest(params?: {
+        urlPath?: string;
+        includeUrlContext?: boolean;
+        returnFullResponse?: boolean;
+    }): Promise<Response | unknown>;
+}

package/lib/util/flexplm-connect.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMConnect = void 0;
+const app_framework_1 = require("@contrail/app-framework");
+class FlexPLMConnect {
+    constructor(_config, endPoint = undefined, payloadAsArray = undefined) {
+        this.vibeEventEndpoint = '';
+        this.staticHeaders = undefined;
+        this.payloadSendAsArray = true;
+        this.config = _config;
+        this.vibeEventEndpoint = (endPoint)
+            ? endPoint
+            : this.config.vibeEventEndpoint;
+        this.payloadSendAsArray = (payloadAsArray != undefined)
+            ? payloadAsArray
+            : this.config['payloadDefaultAsArray'];
+        if (this.config?.flexplmConnect?.staticHeaders) {
+            this.staticHeaders = this.config?.flexplmConnect?.staticHeaders;
+        }
+    }
+    getRequestOptions(method) {
+        const csrfOptions = {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                PLM_ENV: this.config.plmEnviornment,
+                Authorization: 'Basic ' + Buffer.from(`${this.config.userName()}:${this.config.password()}`, 'binary').toString('base64')
+            }
+        };
+        if (this.staticHeaders) {
+            Object.assign(csrfOptions.headers, this.staticHeaders);
+        }
+        if (app_framework_1.Logger.isInfoOn()) {
+            const logOptions = JSON.parse(JSON.stringify(csrfOptions));
+            logOptions['headers']['Authorization'] = logOptions?.headers?.Authorization.substring(0, 9);
+            console.info('csrfOptions: ' + JSON.stringify(logOptions));
+        }
+        return csrfOptions;
+    }
+    async getCSRF() {
+        const urlContext = this.config.urlContext;
+        const csrfEndpoint = this.config.csrfEndpoint;
+        const csrfURL = this.config.apiHost + urlContext + csrfEndpoint;
+        console.info('csrfURL: ' + csrfURL);
+        const csrfOptions = this.getRequestOptions('GET');
+        const response = await fetch(csrfURL, csrfOptions);
+        if (response.status >= 300) {
+            const message = 'Error connecting to FlexPLM:status: ' + response.status;
+            console.error(message);
+            console.error(await response.text());
+            const e = new Error(message);
+            e['httpResponseStatus'] = response.status;
+            throw e;
+        }
+        try {
+            const body = await response.json();
+            const nonce_key = body.items[0].attributes.nonce_key;
+            const nonce = body.items[0].attributes.nonce;
+            console.info('nonce_key: ' + nonce_key);
+            console.info('nonce: ' + nonce);
+            return {
+                nonce_key,
+                nonce
+            };
+        }
+        catch (e) {
+            const message = 'Error connecting to FlexPLM: ' + e.message;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+    }
+    async sendRequest(csrf, payload) {
+        if (this.payloadSendAsArray && !Array.isArray(payload)) {
+            payload = [payload];
+        }
+        const xferOptions = this.getRequestOptions('POST');
+        xferOptions['body'] = JSON.stringify(payload);
+        xferOptions.headers[csrf.nonce_key] = csrf.nonce;
+        const urlContext = this.config.urlContext;
+        const vibeEventsURL = this.config.apiHost + urlContext + '/servlet/rest' + this.vibeEventEndpoint;
+        if (app_framework_1.Logger.isInfoOn()) {
+            console.info('Request:');
+            console.info('vibeEventsURL: ' + vibeEventsURL);
+            const logOptions = JSON.parse(JSON.stringify(xferOptions));
+            logOptions['headers']['Authorization'] = logOptions?.headers?.Authorization.substring(0, 9);
+            console.info('csrfOptions: ' + JSON.stringify(logOptions));
+            console.info('Making call to xfer data to FlexPLM');
+        }
+        const eventResponse = await fetch(vibeEventsURL, xferOptions);
+        return eventResponse;
+    }
+    async processRequest(payload) {
+        if (!payload) {
+            const message = 'No payload to send to FlexPLM';
+            console.error(message);
+            throw new Error(message);
+        }
+        if (app_framework_1.Logger.isInfoOn()) {
+            console.info('payload: ' + JSON.stringify(payload));
+        }
+        const csrf = await this.getCSRF();
+        if (!csrf) {
+            const message = 'Failed to get CSRF nonce';
+            console.error(message);
+            throw new Error(message);
+        }
+        const response = await this.sendRequest(csrf, payload);
+        const status = response.status;
+        if (status >= 300) {
+            const message = 'Error sending data to FlexPLM:status: ' + response.status;
+            console.error(message);
+            console.error(await response.text());
+            const e = new Error(message);
+            e['httpResponseStatus'] = status;
+            throw e;
+        }
+        try {
+            const res = {
+                status,
+            };
+            if (![204, 205].includes(status)) {
+                try {
+                    const data = await response.json();
+                    res.data = data;
+                }
+                catch (e) {
+                    console.error('Error getting response body. Setting {} body: ' + e);
+                    res.data = {};
+                }
+            }
+            console.log('eventResponse.status: ' + status);
+            return res;
+        }
+        catch (e) {
+            const message = 'Error getting json data from FlexPLM: ' + e.message;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+    }
+    async sendToFlexPLM(payload) {
+        return await this.processRequest(payload);
+    }
+    async sendMultipleToFlexPLM(payload) {
+        return await this.processRequest(payload);
+    }
+    async getRequest(params) {
+        const { urlPath, includeUrlContext = true, returnFullResponse = false } = params || {};
+        const urlContext = includeUrlContext ? this.config.urlContext : '';
+        const path = urlPath || ('/servlet/rest' + this.vibeEventEndpoint);
+        const vibeEventsURL = this.config.apiHost + urlContext + path;
+        const csrfOptions = this.getRequestOptions('GET');
+        const response = await fetch(vibeEventsURL, csrfOptions);
+        if (response.status >= 300) {
+            const message = 'Error connecting to FlexPLM:status: ' + response.status;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+        if (returnFullResponse) {
+            return response;
+        }
+        try {
+            const data = await response.json();
+            return data;
+        }
+        catch (e) {
+            const message = 'Error getting json data from FlexPLM: ' + e.message;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+    }
+}
+exports.FlexPLMConnect = FlexPLMConnect;

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

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

package/lib/util/flexplm-connect.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flexplm_connect_1 = require("./flexplm-connect");
+const mockJsonData = { items: [{ id: '123', name: 'test' }] };
+const mockResponse = (status, 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) => ({
+    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 flexplm_connect_1.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 flexplm_connect_1.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 flexplm_connect_1.FlexPLMConnect(createConfig());
+        const result = await connect.getRequest();
+        expect(result).toEqual(mockJsonData);
+    });
+    it('should use urlPath when provided', async () => {
+        const connect = new flexplm_connect_1.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 flexplm_connect_1.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 flexplm_connect_1.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.mockResolvedValue(rawResponse);
+        const connect = new flexplm_connect_1.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.mockResolvedValue(mockResponse(404));
+        const connect = new flexplm_connect_1.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.mockResolvedValue(mockResponse(500));
+        const connect = new flexplm_connect_1.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.mockResolvedValue(badResponse);
+        const connect = new flexplm_connect_1.FlexPLMConnect(createConfig());
+        await expect(connect.getRequest()).rejects.toThrow('Error getting json data from FlexPLM: Invalid JSON');
+    });
+});

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

@@ -0,0 +1 @@
+export declare function setLoggerConfig(appConfig: any): Promise<void>;