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

package/lib/util/thumbnail-util.js

@@ -0,0 +1,211 @@
+"use strict";
+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;
+        this.max_thumbnail_size = 5 * 1024 * 1024;
+        this.entities = new sdk_1.Entities();
+        if (this.config['max_thumbnail_size']) {
+            this.max_thumbnail_size = this.config['max_thumbnail_size'];
+        }
+    }
+    async setOutboundThumbnail(data, event) {
+        if (event?.newData?.primaryViewableId && event?.newData?.largeViewableDownloadUrl) {
+            const primaryViewableId = event.newData.primaryViewableId;
+            const fileId = await this.getFileId(primaryViewableId);
+            if (fileId) {
+                const customSizes = await this.getCustomSizes();
+                const key = (this.isThumbnailNew(event, customSizes))
+                    ? ThumbnailUtil.NEW_THUMBNAIL_ID
+                    : ThumbnailUtil.EXISTING_THUMBNAIL_ID;
+                data[key] = fileId;
+            }
+        }
+        else if (event?.propertyDiffs?.largeViewableDownloadUrl?.oldValue && !event?.propertyDiffs?.largeViewableDownloadUrl?.newValue) {
+            data[ThumbnailUtil.NEW_THUMBNAIL_ID] = ThumbnailUtil.REMOVE_THUMBNAIL;
+        }
+        return data;
+    }
+    isThumbnailNew(event, customSizes) {
+        const propertyDiffs = event?.propertyDiffs;
+        if (propertyDiffs) {
+            const diffKeys = Object.keys(propertyDiffs);
+            const sizeKeys = ThumbnailUtil.OOB_SIZES.map(s => s.slug + 'DownloadUrl');
+            if (customSizes) {
+                sizeKeys.push(...customSizes.map(s => s.slug + 'Url'));
+            }
+            sizeKeys.push('primaryFileUrl');
+            console.info('diffKeys: ' + JSON.stringify(diffKeys));
+            console.info('sizeKeys: ' + JSON.stringify(sizeKeys));
+            return diffKeys.some(s => sizeKeys.includes(s));
+        }
+        return false;
+    }
+    async getFileId(primaryViewableId) {
+        console.info('ThumbnailUtil.getFileId()-' + primaryViewableId);
+        const sizes = await this.getCustomSizes();
+        const OOBSizes = JSON.parse(JSON.stringify(ThumbnailUtil.OOB_SIZES));
+        sizes.push(...OOBSizes);
+        console.info('sizes: ' + JSON.stringify(sizes));
+        const content = await this.getContentEntity(primaryViewableId, sizes);
+        if (!content) {
+            return undefined;
+        }
+        const contentKeys = Object.getOwnPropertyNames(content);
+        const isDebugOn = app_framework_1.Logger.isDebugOn();
+        let fileId = undefined;
+        let tempFileSize = 0;
+        for (const size of sizes) {
+            const slug = size?.slug;
+            if (contentKeys.includes(slug)) {
+                const file = content[slug];
+                if (isDebugOn) {
+                    console.debug('size: ' + slug);
+                    console.debug('fileId: ' + file['id']);
+                }
+                if (file && file['size'] > tempFileSize && file['size'] < this.max_thumbnail_size) {
+                    tempFileSize = file['size'];
+                    fileId = file['id'];
+                    if (isDebugOn) {
+                        console.debug('fileId: ' + fileId);
+                    }
+                }
+            }
+        }
+        console.info('ThumbnailUtil.getFileId(): returning-' + fileId);
+        return fileId;
+    }
+    async getCustomSizes() {
+        const customSizes = await this.entities.get({
+            entityName: 'content-custom-size'
+        });
+        const sizes = [];
+        sizes.push(...customSizes);
+        return sizes;
+    }
+    async getContentEntity(primaryViewableId, sizes) {
+        const relations = sizes.map(s => s.slug);
+        relations.push('primaryFile');
+        const content = await this.entities.get({
+            entityName: 'content',
+            id: primaryViewableId,
+            relations
+        });
+        this.logContentResults(content, relations);
+        return content;
+    }
+    logContentResults(content, relations) {
+        if (app_framework_1.Logger.isDebugOn() && content && relations) {
+            const contentCopy = JSON.parse(JSON.stringify(content));
+            relations.forEach(r => {
+                delete contentCopy[r];
+            });
+            console.debug('content: ' + JSON.stringify(contentCopy));
+        }
+    }
+    async syncThumbnailToVibeIQ({ entityId, primaryViewableId, event, entityName }) {
+        console.debug(`syncThumbnailToVibeIQ: entityId=${entityId}, primaryViewableId=${primaryViewableId}, entityName=${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 });
+            }
+            const clearUpdates = await this.getClearPrimaryViewableUpdates();
+            console.debug(`syncThumbnailToVibeIQ: returning clear updates for entityId=${entityId}`);
+            return clearUpdates;
+        }
+        if (!thumbnailUrl) {
+            console.debug(`syncThumbnailToVibeIQ: no thumbnail URL for entityId=${entityId}`);
+            return undefined;
+        }
+        if (!primaryViewableId) {
+            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);
+            console.debug(`syncThumbnailToVibeIQ: created new content ${content.id} for entityId=${entityId}`);
+            return primaryUpdates;
+        }
+        const primaryViewable = await this.entities.get({ entityName: 'content', id: primaryViewableId });
+        if (primaryViewable?.flexplmThumbnailUrl === thumbnailUrl) {
+            console.debug(`syncThumbnailToVibeIQ: thumbnail already synced for entityId=${entityId}`);
+            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 });
+        console.debug(`syncThumbnailToVibeIQ: replaced content ${primaryViewableId} with ${content.id} for entityId=${entityId}`);
+        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';
+ThumbnailUtil.EXISTING_THUMBNAIL_ID = 'EXISTING_THUMBNAIL_ID';
+ThumbnailUtil.REMOVE_THUMBNAIL = 'REMOVE_THUMBNAIL';
+ThumbnailUtil.OOB_SIZES = [{ slug: 'largeViewable' }, { slug: 'mediumLargeViewable' }, { slug: 'mediumViewable' }, { slug: 'smallViewable' }, { slug: 'tinyViewable' }];

package/lib/util/thumbnail-util.spec.d.ts

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

package/lib/util/thumbnail-util.spec.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const thumbnail_util_1 = require("./thumbnail-util");
+const mockData_1 = require("./mockData");
+const mockEntitiesGet = jest.fn();
+const mockEntitiesUpdate = jest.fn();
+const mockEntitiesDelete = jest.fn();
+const mockContentCreate = jest.fn();
+jest.mock('@contrail/sdk', () => {
+    return {
+        Entities: jest.fn().mockImplementation(() => ({
+            get: mockEntitiesGet,
+            update: mockEntitiesUpdate,
+            delete: mockEntitiesDelete,
+        })),
+        Content: jest.fn().mockImplementation(() => ({
+            create: mockContentCreate,
+        })),
+    };
+});
+const mockGetRequest = jest.fn();
+jest.mock('./flexplm-connect', () => {
+    return {
+        FlexPLMConnect: jest.fn().mockImplementation(() => ({
+            getRequest: mockGetRequest,
+        })),
+    };
+});
+describe('ThumbnailUtil Tests', () => {
+    const config = {};
+    describe('setOutboundThumbnail()', () => {
+        const tu = new thumbnail_util_1.ThumbnailUtil(config);
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('no data', async () => {
+            const data = {};
+            const event = {};
+            const results = await tu.setOutboundThumbnail(data, event);
+            const keys = Object.keys(results);
+            expect(results).toEqual(data);
+            expect(keys.length).toEqual(0);
+        });
+        it('remove thumbnail', async () => {
+            const data = {};
+            const event = {
+                propertyDiffs: {
+                    largeViewableDownloadUrl: {
+                        oldValue: '123',
+                        newValue: null
+                    }
+                }
+            };
+            const results = await tu.setOutboundThumbnail(data, event);
+            const keys = Object.keys(results);
+            expect(keys.length).toEqual(1);
+            expect(keys[0]).toEqual(thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID);
+            expect(results[thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]).toEqual(thumbnail_util_1.ThumbnailUtil.REMOVE_THUMBNAIL);
+        });
+        it('calling getFileId - new thumbnail', async () => {
+            const data = {};
+            const newDownloadUrl = 'https://api.vibeiq.com/dev/api/files/downloadUrl/w3ckfeGAD8ViOZj-%2Fcontent:E1iBQuWbr74lcdcw%2F9e30ds9o-d34b-451e-ae59-b4km36018d5a.png';
+            const oldDownloadUrl = 'xxx';
+            const thumbnailId = 'Eey3ZOiqdrUA84F8';
+            const event = {
+                newData: {
+                    primaryViewableId: 'm5bJa4RtTLUtKBP5',
+                    largeViewableDownloadUrl: newDownloadUrl
+                },
+                propertyDiffs: {
+                    largeViewableDownloadUrl: {
+                        newValue: newDownloadUrl,
+                        oldValue: oldDownloadUrl
+                    }
+                }
+            };
+            const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+            spyCustomSizes.mockReturnValue(Promise.resolve(mockData_1.empty_custom_sizes));
+            const spyGetFileId = jest.spyOn(tu, 'getFileId');
+            spyGetFileId.mockReturnValue(Promise.resolve(thumbnailId));
+            const results = await tu.setOutboundThumbnail(data, event);
+            const keys = Object.keys(results);
+            expect(keys.length).toEqual(1);
+            expect(keys[0]).toEqual(thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID);
+            const thumbnailValue = results[thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID];
+            expect(thumbnailValue).toEqual(thumbnailId);
+        });
+        it('calling getFileId - existing thumbnail', async () => {
+            const data = {};
+            const newDownloadUrl = 'https://api.vibeiq.com/dev/api/files/downloadUrl/w3ckfeGAD8ViOZj-%2Fcontent:E1iBQuWbr74lcdcw%2F9e30ds9o-d34b-451e-ae59-b4km36018d5a.png';
+            const thumbnailId = 'Eey3ZOiqdrUA84F8';
+            const event = {
+                newData: {
+                    primaryViewableId: 'm5bJa4RtTLUtKBP5',
+                    largeViewableDownloadUrl: newDownloadUrl
+                },
+                propertyDiffs: {}
+            };
+            const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+            spyCustomSizes.mockReturnValue(Promise.resolve(mockData_1.empty_custom_sizes));
+            const spyGetFileId = jest.spyOn(tu, 'getFileId');
+            spyGetFileId.mockReturnValue(Promise.resolve(thumbnailId));
+            const results = await tu.setOutboundThumbnail(data, event);
+            const keys = Object.keys(results);
+            expect(keys.length).toEqual(1);
+            expect(keys[0]).toEqual(thumbnail_util_1.ThumbnailUtil.EXISTING_THUMBNAIL_ID);
+            const thumbnailValue = results[thumbnail_util_1.ThumbnailUtil.EXISTING_THUMBNAIL_ID];
+            expect(thumbnailValue).toEqual(thumbnailId);
+        });
+    });
+    describe('getFileId', () => {
+        const primaryFileId = 'yn2d5oHD4rXHRzyB';
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('no custom sizes, default max_thumbnail_size - result large', async () => {
+            const tu = new thumbnail_util_1.ThumbnailUtil(config);
+            const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+            spyCustomSizes.mockReturnValue(Promise.resolve(mockData_1.empty_custom_sizes));
+            const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+            const content = JSON.parse(JSON.stringify(mockData_1.thumbnail_content_entity));
+            spyContentEntity.mockReturnValue(Promise.resolve(content));
+            const results = await tu.getFileId(primaryFileId);
+            expect(results).toEqual('vo4N4mCd-tFrw101');
+        });
+        it('no custom sizes, 750 * 1_024 max_thumbnail_size - result medium', async () => {
+            const config1 = {
+                max_thumbnail_size: 750 * 1024
+            };
+            const tu = new thumbnail_util_1.ThumbnailUtil(config1);
+            const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+            spyCustomSizes.mockReturnValue(Promise.resolve(mockData_1.empty_custom_sizes));
+            const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+            const content = mockData_1.thumbnail_content_entity;
+            spyContentEntity.mockReturnValue(Promise.resolve(content));
+            const results = await tu.getFileId(primaryFileId);
+            expect(results).toEqual('AsRvJenpeqxksUNW');
+        });
+        it('custom sizes, 750 * 1_024 max_thumbnail_size - result CS_500Id', async () => {
+            const config1 = {
+                max_thumbnail_size: 750 * 1024
+            };
+            const tu = new thumbnail_util_1.ThumbnailUtil(config1);
+            const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+            spyCustomSizes.mockReturnValue(Promise.resolve(mockData_1.four_custom_sizes));
+            const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+            const content = mockData_1.thumbnail_content_entity;
+            spyContentEntity.mockReturnValue(Promise.resolve(content));
+            const results = await tu.getFileId(primaryFileId);
+            expect(results).toEqual('rBaHc1J2xdOWdbhI');
+        });
+    });
+    describe('Test isThumbnailNew', () => {
+        const tu = new thumbnail_util_1.ThumbnailUtil(config);
+        it('no propertyDiffs', () => {
+            const event = {
+                newData: {
+                    name: 'Test'
+                },
+                oldData: {
+                    name: 'Test'
+                }
+            };
+            const results = tu.isThumbnailNew(event, undefined);
+            expect(results).toBeFalsy();
+        });
+        it('empty propertyDiffs', () => {
+            const event = {
+                newData: {
+                    name: 'Test'
+                },
+                oldData: {
+                    name: 'Test'
+                },
+                propertyDiffs: {}
+            };
+            const results = tu.isThumbnailNew(event, undefined);
+            expect(results).toBeFalsy();
+        });
+        it('propertyDiffs diff property', () => {
+            const event = {
+                newData: {
+                    name: 'Test1'
+                },
+                oldData: {
+                    name: 'Test'
+                },
+                propertyDiffs: {
+                    name: {
+                        propertyName: 'name',
+                        oldValue: 'Test',
+                        newValue: 'Test1'
+                    }
+                }
+            };
+            const results = tu.isThumbnailNew(event, undefined);
+            expect(results).toBeFalsy();
+        });
+        it('propertyDiffs OOB property', () => {
+            const event = {
+                newData: {
+                    name: 'Test1'
+                },
+                oldData: {
+                    name: 'Test'
+                },
+                propertyDiffs: {
+                    mediumLargeViewableDownloadUrl: {
+                        propertyName: 'mediumLargeViewableDownloadUrl',
+                        oldValue: '',
+                        newValue: 'Test1'
+                    }
+                }
+            };
+            const results = tu.isThumbnailNew(event, undefined);
+            expect(results).toBeTruthy();
+        });
+        it('propertyDiffs custom property', () => {
+            const event = {
+                newData: {
+                    name: 'Test1'
+                },
+                oldData: {
+                    name: 'Test'
+                },
+                propertyDiffs: {
+                    RL_1000Url: {
+                        propertyName: 'RL_1000Url',
+                        oldValue: '',
+                        newValue: 'Test1'
+                    }
+                }
+            };
+            const results = tu.isThumbnailNew(event, [{ slug: 'RL_1000' }]);
+            expect(results).toBeTruthy();
+        });
+    });
+    describe('logContentResults', () => {
+        it('no content - doesnt error', () => {
+            const tu = new thumbnail_util_1.ThumbnailUtil(config);
+            const content = undefined;
+            const relations = [];
+            tu.logContentResults(content, relations);
+        });
+        it('no relations - doesnt error', () => {
+            const tu = new thumbnail_util_1.ThumbnailUtil(config);
+            const content = undefined;
+            const relations = undefined;
+            tu.logContentResults(content, relations);
+        });
+        it('content and relations - logs', () => {
+            const tu = new thumbnail_util_1.ThumbnailUtil(config);
+            const content = {
+                id: '123',
+                name: 'Test',
+                primaryFile: { id: 'file123' }
+            };
+            const relations = ['primaryFile'];
+            tu.logContentResults(content, relations);
+            expect(Object.keys(content)).toHaveLength(3);
+            expect(content).toHaveProperty('primaryFile');
+            expect(content.primaryFile).toHaveProperty('id');
+            expect(content.primaryFile.id).toEqual('file123');
+        });
+    });
+    describe('syncThumbnailToVibeIQ', () => {
+        let tu;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            tu = new thumbnail_util_1.ThumbnailUtil(config);
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                return Promise.resolve({});
+            });
+            mockEntitiesUpdate.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+            mockEntitiesDelete.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+        });
+        it('returns undefined when no thumbnail IDs in event data', async () => {
+            const event = { data: {} };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+            expect(mockContentCreate).not.toHaveBeenCalled();
+        });
+        it('returns undefined when event.data is undefined', async () => {
+            const event = {};
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+        });
+        it('REMOVE_THUMBNAIL with existing primaryViewableId deletes content and returns clear updates', async () => {
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: thumbnail_util_1.ThumbnailUtil.REMOVE_THUMBNAIL } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+            expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'pv1' });
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: null, primaryFileUrl: null }));
+        });
+        it('REMOVE_THUMBNAIL with no primaryViewableId returns clear updates without deleting', async () => {
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: thumbnail_util_1.ThumbnailUtil.REMOVE_THUMBNAIL } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'item' });
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: null }));
+        });
+        it('creates new content when no primaryViewableId exists and returns primary viewable updates', async () => {
+            const mockResponse = {
+                arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+                headers: { get: jest.fn().mockReturnValue('image/png') },
+            };
+            mockGetRequest.mockResolvedValue(mockResponse);
+            const createdContent = {
+                id: 'newContent1',
+                contentType: 'image/png',
+                fileName: 'thumb.png',
+                primaryFileUrl: 'https://files/primary.png',
+                largeViewableUrl: 'https://files/large.png',
+                mediumLargeViewableUrl: null,
+                mediumViewableUrl: null,
+                smallViewableUrl: null,
+                tinyViewableUrl: null,
+            };
+            mockContentCreate.mockResolvedValue(createdContent);
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/thumb.png' } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(mockGetRequest).toHaveBeenCalledWith({ urlPath: '/rest/thumbnail/thumb.png', includeUrlContext: false, returnFullResponse: true });
+            expect(mockContentCreate).toHaveBeenCalledWith(expect.objectContaining({
+                fileName: 'thumb.png',
+                contentType: 'image/png',
+                contentHolderReference: 'color:entity1',
+            }));
+            expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({
+                entityName: 'content',
+                id: 'newContent1',
+                object: { flexplmThumbnailUrl: '/rest/thumbnail/thumb.png' },
+            }));
+            expect(result).toEqual(expect.objectContaining({
+                primaryViewableId: 'newContent1',
+                primaryFileUrl: 'https://files/primary.png',
+                largeViewableDownloadUrl: 'https://files/large.png',
+            }));
+        });
+        it('replaces content when primaryViewable.flexplmThumbnailUrl differs and returns updates', async () => {
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                if (opts.entityName === 'content' && opts.id === 'oldPv') {
+                    return Promise.resolve({ id: 'oldPv', flexplmThumbnailUrl: '/rest/thumbnail/old.png' });
+                }
+                return Promise.resolve({});
+            });
+            const mockResponse = {
+                arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+                headers: { get: jest.fn().mockReturnValue('image/jpeg') },
+            };
+            mockGetRequest.mockResolvedValue(mockResponse);
+            const createdContent = {
+                id: 'newContent2',
+                contentType: 'image/jpeg',
+                fileName: 'new.jpg',
+                primaryFileUrl: 'https://files/new-primary.jpg',
+                largeViewableUrl: null,
+                mediumLargeViewableUrl: null,
+                mediumViewableUrl: null,
+                smallViewableUrl: null,
+                tinyViewableUrl: null,
+            };
+            mockContentCreate.mockResolvedValue(createdContent);
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/new.jpg' } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'oldPv', event, entityName: 'item' });
+            expect(mockContentCreate).toHaveBeenCalled();
+            expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({
+                entityName: 'content',
+                id: 'newContent2',
+                object: { flexplmThumbnailUrl: '/rest/thumbnail/new.jpg' },
+            }));
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: 'newContent2' }));
+            expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'oldPv' });
+        });
+        it('returns undefined when primaryViewable.flexplmThumbnailUrl matches', async () => {
+            const thumbnailUrl = '/rest/thumbnail/same.png';
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                if (opts.entityName === 'content' && opts.id === 'pv1') {
+                    return Promise.resolve({ id: 'pv1', flexplmThumbnailUrl: thumbnailUrl });
+                }
+                return Promise.resolve({});
+            });
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.EXISTING_THUMBNAIL_ID]: thumbnailUrl } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockContentCreate).not.toHaveBeenCalled();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+        });
+    });
+});