@contrail/flexplm 1.2.1 → 1.3.0-alpha.3

package/.claude/settings.local.json

@@ -1,8 +1,7 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npx jest:*)",
-      "Bash(npx tsc:*)"
+      "Bash(npx jest:*)"
     ]
   }
 }

package/.github/pull_request_template.md

@@ -1,31 +1,31 @@
-## What
-- [ ] Bugfix
-- [ ] Feature
-- [ ] Enhancement
-
-Description: 
-<!--
-Describe the functional changes of the PR.
-
-If the mechanism of your change are complex, describe them in detail as you
-would if you were explaining them to a team mate.
-
-If the PR is simple, there is no need to repeat yourself. A small description
-is sufficient.
--->
-
-## Why
-<!-- 
-why is this change needed? Same rules as with #What
- -->
-
-
-## Testing added
-<!-- 
-Describe the testing you added to this PR
- -->
-
-
-## Link to Jira ticket(s)
-https://vibe-team.atlassian.net/browse/VIBE-TICKET_NUMBER_HERE
-
+## What
+- [ ] Bugfix
+- [ ] Feature
+- [ ] Enhancement
+
+Description: 
+<!--
+Describe the functional changes of the PR.
+
+If the mechanism of your change are complex, describe them in detail as you
+would if you were explaining them to a team mate.
+
+If the PR is simple, there is no need to repeat yourself. A small description
+is sufficient.
+-->
+
+## Why
+<!-- 
+why is this change needed? Same rules as with #What
+ -->
+
+
+## Testing added
+<!-- 
+Describe the testing you added to this PR
+ -->
+
+
+## Link to Jira ticket(s)
+https://vibe-team.atlassian.net/browse/VIBE-TICKET_NUMBER_HERE
+

package/.github/workflows/flexplm-lib.yml

@@ -1,27 +1,27 @@
-name: flexplm-lib-tests
-on:
-  pull_request:
-  workflow_dispatch: # allow running in github actions manually
-jobs:
-  test:
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        node-version: [22.14.0]
-    steps:
-      - name: Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - uses: actions/checkout@v3
-
-      - name: NPM Install
-        env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npm ci
-
-      - name: Unit Tests -
-        env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npm test
+name: flexplm-lib-tests
+on:
+  pull_request:
+  workflow_dispatch: # allow running in github actions manually
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        node-version: [22.14.0]
+    steps:
+      - name: Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - uses: actions/checkout@v3
+
+      - name: NPM Install
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm ci
+
+      - name: Unit Tests -
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm test

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

@@ -6,6 +6,7 @@ const flexplm_connect_1 = require("../util/flexplm-connect");
 const map_utils_1 = require("../util/map-utils");
 const sdk_1 = require("@contrail/sdk");
 const type_conversion_utils_1 = require("../util/type-conversion-utils");
+const thumbnail_util_1 = require("../util/thumbnail-util");
 const event_short_message_status_1 = require("../util/event-short-message-status");
 const UNSUPPORTED_TYPE = 'Unsupported eventType.';
 class IncomingEntityResponse {
@@ -68,6 +69,13 @@ class BaseEntityProcessor {
                 return createEntityResponse.earlyReturn;
             }
             const createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
+            const shouldSyncThumbnail = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(this.transformMapFile, this.mapFileUtil, event.data);
+            if (shouldSyncThumbnail) {
+                const thumbnailUpdates = await new thumbnail_util_1.ThumbnailUtil(this.config).syncThumbnailToVibeIQ({ entityId: createdEntity.id, primaryViewableId: createdEntity.primaryViewableId, event, entityName: this.baseType });
+                if (thumbnailUpdates) {
+                    await this.updateEntity(this.baseType, createdEntity, thumbnailUpdates);
+                }
+            }
             const statusMsg = this.getInboundStatusMessage({
                 status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
                 statusMessage: event_short_message_status_1.EventShortMessageStatus.CREATED,
@@ -79,7 +87,13 @@ class BaseEntityProcessor {
             return createdEntity;
         }
         const diffs = await this.getUpdatesForEntity(entity, inboundData);
-        if (Object.getOwnPropertyNames(diffs).length == 0) {
+        const shouldSyncThumbnail = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(this.transformMapFile, this.mapFileUtil, event.data);
+        let thumbnailUpdates;
+        if (shouldSyncThumbnail) {
+            thumbnailUpdates = await new thumbnail_util_1.ThumbnailUtil(this.config).syncThumbnailToVibeIQ({ entityId: entity.id, primaryViewableId: entity.primaryViewableId, event, entityName: this.baseType });
+        }
+        const allUpdates = { ...diffs, ...thumbnailUpdates };
+        if (Object.getOwnPropertyNames(allUpdates).length == 0) {
             const statusMsg = this.getInboundStatusMessage({
                 status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
                 statusMessage: event_short_message_status_1.EventShortMessageStatus.NO_CHANGES,
@@ -94,7 +108,7 @@ class BaseEntityProcessor {
                 data: { message }
             };
         }
-        const updatedEntity = await this.updateEntity(this.baseType, entity, diffs);
+        const updatedEntity = await this.updateEntity(this.baseType, entity, allUpdates);
         const statusMsg = this.getInboundStatusMessage({
             status: event_short_message_status_1.EventShortMessageStatus.SUCCESS,
             statusMessage: event_short_message_status_1.EventShortMessageStatus.UPDATED,

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

@@ -4,6 +4,8 @@ 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 type_conversion_utils_1 = require("../util/type-conversion-utils");
+const thumbnail_util_1 = require("../util/thumbnail-util");
 const mockRootType = {
     typeProperties: [
         { slug: 'rootText' }
@@ -299,4 +301,126 @@ describe('BaseEntityProcessor', () => {
             expect(keys).toEqual(['a', 'b']);
         });
     });
+    describe('handleIncomingUpsert - inbound image sync', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+        const mockEvent = { objectClass: 'TestClass', federatedId: 'fed-123', data: { name: 'test' }, entityReference: 'ref-1', eventType: 'PERSIST' };
+        const mockInboundData = { name: 'transformed-test' };
+        const mockCreatedEntity = { id: 'created-1', name: 'created', primaryViewableId: 'pv-created' };
+        const mockUpdatedEntity = { id: 'updated-1', name: 'updated', primaryViewableId: 'pv-updated' };
+        const mockExistingEntity = { id: 'existing-1', name: 'existing', typeId: 'type-1', roles: [] };
+        let btep;
+        let syncInboundImagesSpy;
+        let syncThumbnailSpy;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue(mockInboundData);
+            syncInboundImagesSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'syncInboundImages');
+            syncThumbnailSpy = jest.spyOn(thumbnail_util_1.ThumbnailUtil.prototype, 'syncThumbnailToVibeIQ').mockResolvedValue(undefined);
+        });
+        it('should call updateEntity with thumbnail updates after create when syncInboundImages returns true', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockCreatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new', primaryFileUrl: 'https://files/new.png' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'created-1', primaryViewableId: 'pv-created', event: mockEvent, entityName: 'test' });
+            expect(updateEntitySpy).toBeCalledWith('test', mockCreatedEntity, thumbnailUpdates);
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should not call updateEntity after create when syncThumbnailToVibeIQ returns undefined', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity');
+            syncInboundImagesSpy.mockResolvedValue(true);
+            syncThumbnailSpy.mockResolvedValue(undefined);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(updateEntitySpy).not.toHaveBeenCalled();
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should not sync images after create when syncInboundImages returns false', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({ entity: { name: 'new' } });
+            jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+            expect(result).toBe(mockCreatedEntity);
+        });
+        it('should merge thumbnail updates with property diffs on update', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncThumbnailSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'existing-1', primaryViewableId: undefined, event: mockEvent, entityName: 'test' });
+            expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { name: 'changed', primaryViewableId: 'pv-new' });
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should update entity with only thumbnail changes when no property diffs', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(true);
+            const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+            syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { primaryViewableId: 'pv-new' });
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should not sync images on update when syncInboundImages returns false', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+            jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(1);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+            expect(result).toBe(mockUpdatedEntity);
+        });
+        it('should not sync images on early return from getIncomingEntity', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({
+                earlyReturn: { status: 400, data: { message: 'error' }, shortStatusMessage: 'FAIL' }
+            });
+            await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(0);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+        });
+        it('should not sync images on early return from getCreateEntity', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').mockResolvedValue({
+                earlyReturn: { status: 400, data: { message: 'not creatable' }, shortStatusMessage: 'NOT_CREATABLE' }
+            });
+            await btep.handleIncomingUpsert(mockEvent);
+            expect(syncInboundImagesSpy).toBeCalledTimes(0);
+            expect(syncThumbnailSpy).toBeCalledTimes(0);
+        });
+        it('should return no changes when no property diffs and no thumbnail updates', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            syncInboundImagesSpy.mockResolvedValue(true);
+            syncThumbnailSpy.mockResolvedValue(undefined);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+        });
+        it('should return no changes when syncInboundImages is false and no property diffs', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: mockExistingEntity });
+            jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+            syncInboundImagesSpy.mockResolvedValue(false);
+            const result = await btep.handleIncomingUpsert(mockEvent);
+            expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+        });
+    });
 });

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

@@ -14,5 +14,9 @@ export declare class FlexPLMConnect {
     protected processRequest(payload: any): Promise<FlexPLMResponseData>;
     sendToFlexPLM(payload: PayloadType): Promise<FlexPLMResponseData>;
     sendMultipleToFlexPLM(payload: PayloadType[]): Promise<FlexPLMResponseData>;
-    getRequest(): Promise<any>;
+    getRequest(params?: {
+        urlPath?: string;
+        includeUrlContext?: boolean;
+        returnFullResponse?: boolean;
+    }): Promise<Response | unknown>;
 }

package/lib/util/flexplm-connect.js

@@ -145,9 +145,11 @@ class FlexPLMConnect {
     async sendMultipleToFlexPLM(payload) {
         return await this.processRequest(payload);
     }
-    async getRequest() {
-        const urlContext = this.config.urlContext;
-        const vibeEventsURL = this.config.apiHost + urlContext + '/servlet/rest' + this.vibeEventEndpoint;
+    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) {
@@ -156,6 +158,9 @@ class FlexPLMConnect {
             console.error(await response.text());
             throw new Error(message);
         }
+        if (returnFullResponse) {
+            return response;
+        }
         try {
             const data = await response.json();
             return data;

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/thumbnail-util.d.ts

@@ -16,4 +16,13 @@ export declare class ThumbnailUtil {
     getCustomSizes(): Promise<any[]>;
     getContentEntity(primaryViewableId: any, sizes: any[]): Promise<any>;
     logContentResults(content: any, relations: string[]): void;
+    syncThumbnailToVibeIQ({ entityId, primaryViewableId, event, entityName }: {
+        entityId: string;
+        primaryViewableId?: string;
+        event: any;
+        entityName: string;
+    }): Promise<any>;
+    private createContentFromFlexPLM;
+    private getPrimaryViewableUpdates;
+    private getClearPrimaryViewableUpdates;
 }

package/lib/util/thumbnail-util.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailUtil = void 0;
 const app_framework_1 = require("@contrail/app-framework");
 const sdk_1 = require("@contrail/sdk");
+const flexplm_connect_1 = require("./flexplm-connect");
 class ThumbnailUtil {
     constructor(config) {
         this.config = config;
@@ -106,6 +107,93 @@ class ThumbnailUtil {
             console.debug('content: ' + JSON.stringify(contentCopy));
         }
     }
+    async syncThumbnailToVibeIQ({ entityId, primaryViewableId, event, entityName }) {
+        const eventData = event.data || {};
+        const newThumbnailId = eventData[ThumbnailUtil.NEW_THUMBNAIL_ID];
+        const existingThumbnailId = eventData[ThumbnailUtil.EXISTING_THUMBNAIL_ID];
+        const thumbnailUrl = newThumbnailId || existingThumbnailId;
+        if (newThumbnailId === ThumbnailUtil.REMOVE_THUMBNAIL) {
+            if (primaryViewableId) {
+                await this.entities.delete({ entityName: 'content', id: primaryViewableId });
+            }
+            return await this.getClearPrimaryViewableUpdates();
+        }
+        if (!thumbnailUrl) {
+            return undefined;
+        }
+        if (!primaryViewableId) {
+            const content = await this.createContentFromFlexPLM(thumbnailUrl, entityId, entityName);
+            await this.entities.update({ entityName: 'content', id: content.id, object: { flexplmThumbnailUrl: thumbnailUrl } });
+            return await this.getPrimaryViewableUpdates(content);
+        }
+        const primaryViewable = await this.entities.get({ entityName: 'content', id: primaryViewableId });
+        if (primaryViewable?.flexplmThumbnailUrl === thumbnailUrl) {
+            return undefined;
+        }
+        const content = await this.createContentFromFlexPLM(thumbnailUrl, entityId, entityName);
+        await this.entities.update({ entityName: 'content', id: content.id, object: { flexplmThumbnailUrl: thumbnailUrl } });
+        const primaryUpdates = await this.getPrimaryViewableUpdates(content);
+        await this.entities.delete({ entityName: 'content', id: primaryViewableId });
+        return primaryUpdates;
+    }
+    async createContentFromFlexPLM(thumbnailUrl, entityId, entityName) {
+        const flexPLMConnect = new flexplm_connect_1.FlexPLMConnect(this.config);
+        const response = await flexPLMConnect.getRequest({
+            urlPath: thumbnailUrl,
+            includeUrlContext: false,
+            returnFullResponse: true,
+        });
+        const fileBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(fileBuffer);
+        const contentTypeHeader = response.headers.get('content-type');
+        const contentType = contentTypeHeader ? contentTypeHeader.split(';')[0] : 'application/octet-stream';
+        const urlParts = thumbnailUrl.split('/');
+        const fileName = urlParts[urlParts.length - 1] || 'thumbnail';
+        const contentHolderReference = `${entityName}:${entityId}`;
+        const content = await new sdk_1.Content().create({
+            fileBuffer: buffer,
+            fileName,
+            contentType,
+            contentHolderReference,
+        });
+        return content;
+    }
+    async getPrimaryViewableUpdates(content) {
+        const updates = {
+            primaryViewableId: content.id,
+            contentType: content.contentType,
+            fileName: content.fileName,
+            primaryFileUrl: content.primaryFileUrl,
+            largeViewableDownloadUrl: content.largeViewableUrl || content.primaryFileUrl,
+            mediumLargeViewableDownloadUrl: content.mediumLargeViewableUrl || content.primaryFileUrl,
+            mediumViewableDownloadUrl: content.mediumViewableUrl || content.primaryFileUrl,
+            smallViewableDownloadUrl: content.smallViewableUrl || content.primaryFileUrl,
+            tinyViewableDownloadUrl: content.tinyViewableUrl || content.primaryFileUrl,
+        };
+        const customSizes = await this.getCustomSizes();
+        for (const size of customSizes) {
+            updates[`${size.slug}DownloadUrl`] = content[`${size.slug}Url`] || content.primaryFileUrl;
+        }
+        return updates;
+    }
+    async getClearPrimaryViewableUpdates() {
+        const updates = {
+            primaryViewableId: null,
+            contentType: null,
+            fileName: null,
+            primaryFileUrl: null,
+            largeViewableDownloadUrl: null,
+            mediumLargeViewableDownloadUrl: null,
+            mediumViewableDownloadUrl: null,
+            smallViewableDownloadUrl: null,
+            tinyViewableDownloadUrl: null,
+        };
+        const customSizes = await this.getCustomSizes();
+        for (const size of customSizes) {
+            updates[`${size.slug}DownloadUrl`] = null;
+        }
+        return updates;
+    }
 }
 exports.ThumbnailUtil = ThumbnailUtil;
 ThumbnailUtil.NEW_THUMBNAIL_ID = 'NEW_THUMBNAIL_ID';