@contrail/flexplm 1.7.0-alpha.71b4d30 → 1.7.0

package/lib/cli/index.spec.js

@@ -1,24 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const mappingCreateRun = jest.fn().mockResolvedValue(undefined);
-const mappingCompileRun = jest.fn().mockResolvedValue(undefined);
-const mappingUploadRun = jest.fn().mockResolvedValue(undefined);
-const configCreateRun = jest.fn().mockResolvedValue(undefined);
-const configUploadRun = jest.fn().mockResolvedValue(undefined);
-jest.mock('./commands/mapping-file/create', () => ({
-    CreateCommand: jest.fn().mockImplementation(() => ({ run: mappingCreateRun })),
+const createRunMock = jest.fn().mockResolvedValue(undefined);
+const compileRunMock = jest.fn().mockResolvedValue(undefined);
+const uploadRunMock = jest.fn().mockResolvedValue(undefined);
+jest.mock('./commands/create', () => ({
+    CreateCommand: jest.fn().mockImplementation(() => ({ run: createRunMock })),
 }));
-jest.mock('./commands/mapping-file/compile', () => ({
-    CompileCommand: jest.fn().mockImplementation(() => ({ run: mappingCompileRun })),
+jest.mock('./commands/compile', () => ({
+    CompileCommand: jest.fn().mockImplementation(() => ({ run: compileRunMock })),
 }));
-jest.mock('./commands/mapping-file/upload', () => ({
-    UploadCommand: jest.fn().mockImplementation(() => ({ run: mappingUploadRun })),
-}));
-jest.mock('./commands/config-file/create', () => ({
-    CreateCommand: jest.fn().mockImplementation(() => ({ run: configCreateRun })),
-}));
-jest.mock('./commands/config-file/upload', () => ({
-    UploadCommand: jest.fn().mockImplementation(() => ({ run: configUploadRun })),
+jest.mock('./commands/upload', () => ({
+    UploadCommand: jest.fn().mockImplementation(() => ({ run: uploadRunMock })),
 }));
 const index_1 = require("./index");
 describe('cli main dispatcher', () => {
@@ -28,11 +20,9 @@ describe('cli main dispatcher', () => {
     let exitSpy;
     beforeEach(() => {
         originalArgv = process.argv;
-        mappingCreateRun.mockClear();
-        mappingCompileRun.mockClear();
-        mappingUploadRun.mockClear();
-        configCreateRun.mockClear();
-        configUploadRun.mockClear();
+        createRunMock.mockClear();
+        compileRunMock.mockClear();
+        uploadRunMock.mockClear();
         logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
         errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
         exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code) => {
@@ -48,96 +38,48 @@ describe('cli main dispatcher', () => {
     function setArgv(...args) {
         process.argv = ['node', 'cli', ...args];
     }
-    describe('mapping-file topic', () => {
-        it('dispatches mapping-file create', async () => {
-            setArgv('mapping-file', 'create');
-            await (0, index_1.main)();
-            expect(mappingCreateRun).toHaveBeenCalledTimes(1);
-            expect(mappingCompileRun).not.toHaveBeenCalled();
-            expect(mappingUploadRun).not.toHaveBeenCalled();
-        });
-        it('dispatches mapping-file compile with its argument', async () => {
-            setArgv('mapping-file', 'compile', 'mapping.ts');
-            await (0, index_1.main)();
-            expect(mappingCompileRun).toHaveBeenCalledWith('mapping.ts');
-        });
-        it('exits when mapping-file compile is missing its argument', async () => {
-            setArgv('mapping-file', 'compile');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(mappingCompileRun).not.toHaveBeenCalled();
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
-        });
-        it('dispatches mapping-file upload and forwards remaining args', async () => {
-            setArgv('mapping-file', 'upload', 'mapping.ts', '-m', 'msg', '--skip-git');
-            await (0, index_1.main)();
-            expect(mappingUploadRun).toHaveBeenCalledWith(['mapping.ts', '-m', 'msg', '--skip-git']);
-        });
-        it('exits when mapping-file upload is missing its argument', async () => {
-            setArgv('mapping-file', 'upload');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(mappingUploadRun).not.toHaveBeenCalled();
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
-        });
-        it.each(['help', '-h', '--help'])('prints mapping-file usage on %s', async (helpFlag) => {
-            setArgv('mapping-file', helpFlag);
-            await (0, index_1.main)();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm mapping-file/));
-        });
-        it('prints mapping-file usage when no subcommand is provided', async () => {
-            setArgv('mapping-file');
-            await (0, index_1.main)();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm mapping-file/));
-        });
-        it('exits on an unknown mapping-file subcommand', async () => {
-            setArgv('mapping-file', 'bogus');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown mapping-file subcommand: bogus/));
-        });
+    it('dispatches the create command', async () => {
+        setArgv('create');
+        await (0, index_1.main)();
+        expect(createRunMock).toHaveBeenCalledTimes(1);
+        expect(compileRunMock).not.toHaveBeenCalled();
+        expect(uploadRunMock).not.toHaveBeenCalled();
+    });
+    it('dispatches the compile command with its argument', async () => {
+        setArgv('compile', 'mapping.ts');
+        await (0, index_1.main)();
+        expect(compileRunMock).toHaveBeenCalledWith('mapping.ts');
+    });
+    it('exits when compile is missing its argument', async () => {
+        setArgv('compile');
+        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+        expect(compileRunMock).not.toHaveBeenCalled();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
+    });
+    it('dispatches the upload command and forwards remaining args', async () => {
+        setArgv('upload', 'mapping.ts', '-m', 'msg', '--skip-git');
+        await (0, index_1.main)();
+        expect(uploadRunMock).toHaveBeenCalledWith(['mapping.ts', '-m', 'msg', '--skip-git']);
+    });
+    it('exits when upload is missing its argument', async () => {
+        setArgv('upload');
+        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+        expect(uploadRunMock).not.toHaveBeenCalled();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
+    });
+    it.each(['help', '-h', '--help'])('prints usage for %s', async (helpFlag) => {
+        setArgv(helpFlag);
+        await (0, index_1.main)();
+        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-mapping/));
     });
-    describe('config-file topic', () => {
-        it('dispatches config-file create', async () => {
-            setArgv('config-file', 'create');
-            await (0, index_1.main)();
-            expect(configCreateRun).toHaveBeenCalledTimes(1);
-            expect(configUploadRun).not.toHaveBeenCalled();
-        });
-        it('dispatches config-file upload and forwards remaining args', async () => {
-            setArgv('config-file', 'upload', 'cfg.json', '--update-config', '--skip-git');
-            await (0, index_1.main)();
-            expect(configUploadRun).toHaveBeenCalledWith(['cfg.json', '--update-config', '--skip-git']);
-        });
-        it('exits when config-file upload is missing its argument', async () => {
-            setArgv('config-file', 'upload');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(configUploadRun).not.toHaveBeenCalled();
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.json>/));
-        });
-        it('prints config-file usage when no subcommand is provided', async () => {
-            setArgv('config-file');
-            await (0, index_1.main)();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm config-file/));
-        });
-        it('exits on an unknown config-file subcommand', async () => {
-            setArgv('config-file', 'bogus');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown config-file subcommand: bogus/));
-        });
+    it('prints usage when no command is provided', async () => {
+        setArgv();
+        await (0, index_1.main)();
+        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-mapping/));
     });
-    describe('top-level dispatcher', () => {
-        it.each(['help', '-h', '--help'])('prints top-level usage on %s', async (helpFlag) => {
-            setArgv(helpFlag);
-            await (0, index_1.main)();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm <topic>/));
-        });
-        it('prints top-level usage when no topic is provided', async () => {
-            setArgv();
-            await (0, index_1.main)();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm <topic>/));
-        });
-        it('exits on an unknown topic', async () => {
-            setArgv('bogus');
-            await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown topic: bogus/));
-        });
+    it('exits on an unknown command', async () => {
+        setArgv('bogus');
+        await expect((0, index_1.main)()).rejects.toThrow('__EXIT__:1');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown command: bogus/));
     });
 });

package/lib/publish/base-process-publish-assortment.d.ts

@@ -86,8 +86,10 @@ export declare class BaseProcessPublishAssortment {
     getResultsCount(events: any): any;
     private sendEvents;
     private sendToFlexPLM;
+    private sendAndRecordPublishEvent;
     private saveToLocalFile;
     private handleVibeIQFile;
+    private sendPublishPayloadEvent;
     private getCurrentDateString;
     getItemFamilyChanges(pcd: PublishChangeData, changeDetail: any, assortmentItemFullChangeMap: Map<string, any>, assortmentItemDeleteMap: Map<string, any>): Map<string, ItemFamilyChanges>;
     getEventsForPublishChangeData(publishChangeData: PublishChangeData): Promise<SeasonalPayload[]>;

package/lib/publish/base-process-publish-assortment.js

@@ -595,14 +595,41 @@ class BaseProcessPublishAssortment {
         }
     }
     async sendToFlexPLM(events, eventType) {
-        const asyncEvent = {
+        const outboundPublishEvent = {
             taskId: this.config.taskId,
             eventType,
             objectClass: 'LCSSeason',
             events
         };
         const flexPLMConnect = new flexplm_connect_1.FlexPLMConnect(this.config);
-        return await flexPLMConnect.sendToFlexPLM(asyncEvent);
+        const result = await this.sendAndRecordPublishEvent(flexPLMConnect, outboundPublishEvent);
+        const isResultObject = typeof result === 'object' && result !== null;
+        return isResultObject
+            ? { ...result, outboundPublishEvent }
+            : { result, outboundPublishEvent };
+    }
+    async sendAndRecordPublishEvent(flexPLMConnect, outboundPublishEvent) {
+        let sendResult;
+        try {
+            sendResult = await flexPLMConnect.sendToFlexPLM(outboundPublishEvent);
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            error.outboundPublishEvent = outboundPublishEvent;
+            error.sendToFlexPLMResult = { error: e?.message ?? String(e) };
+            throw error;
+        }
+        try {
+            await this.sendPublishPayloadEvent(outboundPublishEvent);
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            error.outboundPublishEvent = outboundPublishEvent;
+            error.sendToFlexPLMResult = sendResult;
+            error.sendPublishPayloadEventResult = { error: e?.message ?? String(e) };
+            throw error;
+        }
+        return sendResult;
     }
     async saveToLocalFile(events, eventType) {
         let results = {};
@@ -614,15 +641,16 @@ class BaseProcessPublishAssortment {
             const eventDirName = 'events-output';
             const fileName = `${path.sep}${eventDirName}${path.sep}events-${dateString}.json`;
             fileHandle = await fsPromise.open('.' + fileName, 'a');
-            const asyncEvent = {
+            const outboundPublishEvent = {
                 taskId: this.config.taskId,
                 eventType,
                 objectClass: 'LCSSeason',
                 events
             };
-            await fileHandle.writeFile(JSON.stringify(asyncEvent));
+            await fileHandle.writeFile(JSON.stringify(outboundPublishEvent));
             results = {
                 message: 'Successfully Saved File',
+                outboundPublishEvent,
                 fileLocation: dirName + fileName
             };
         }
@@ -638,7 +666,7 @@ class BaseProcessPublishAssortment {
         const eventBuffer = Buffer.from(JSON.stringify(events), 'utf-8');
         const fileName = 'ASYNC_PUBLISH_SEASON-events.json';
         const uploadFile = await new sdk_1.Files().createAndUploadFileFromBuffer(eventBuffer, 'application/json', fileName, null, this.TTL);
-        const asyncEvent = {
+        const outboundPublishEvent = {
             taskId: this.config.taskId,
             eventType,
             objectClass: 'LCSSeason',
@@ -648,15 +676,39 @@ class BaseProcessPublishAssortment {
         };
         if (sendMode === 'vibeiqfile') {
             const flexPLMConnect = new flexplm_connect_1.FlexPLMConnect(this.config);
-            return await flexPLMConnect.sendToFlexPLM(asyncEvent);
+            const result = await this.sendAndRecordPublishEvent(flexPLMConnect, outboundPublishEvent);
+            const isResultObject = typeof result === 'object' && result !== null;
+            return isResultObject
+                ? { ...result, outboundPublishEvent }
+                : { result, outboundPublishEvent };
         }
         else {
+            await this.sendPublishPayloadEvent(outboundPublishEvent);
             return {
                 message: 'Successfully Uploaded File.',
-                asyncEvent
+                outboundPublishEvent
             };
         }
     }
+    async sendPublishPayloadEvent(outboundPublishEvent) {
+        console.info('sendPublishPayloadEvent()');
+        let initialEvent = {};
+        if (this.config?.event) {
+            initialEvent = (typeof this.config?.event === 'string')
+                ? JSON.parse(this.config?.event)
+                : this.config?.event;
+        }
+        const eventBody = {
+            originSystemType: 'VibeIQ',
+            objectClass: 'AssortmentPublishedToFlexPLM',
+            outboundPublishEvent,
+            initialEvent
+        };
+        await new sdk_1.Entities().create({
+            entityName: 'external-event',
+            object: eventBody
+        });
+    }
     getCurrentDateString() {
         const d = new Date();
         return '' + d.getUTCFullYear()

package/lib/publish/base-process-publish-assortment.spec.js

@@ -9,6 +9,7 @@ const sdk_1 = require("@contrail/sdk");
 const type_conversion_utils_1 = require("../util/type-conversion-utils");
 const map_utils_1 = require("../util/map-utils");
 const item_family_changes_1 = require("../interfaces/item-family-changes");
+const flexplm_connect_1 = require("../util/flexplm-connect");
 let federatedId = '';
 jest.mock('../util/data-converter', () => {
     return {
@@ -31,6 +32,13 @@ jest.mock('../util/federation', () => {
 });
 let entityObject = {};
 let getOptionsObject = {};
+let createCallArg = undefined;
+let fileUploadCalls = [];
+let fileUploadResult = {
+    id: 'file-123',
+    downloadUrl: 'https://download.url',
+    adminDownloadUrl: 'https://admin.download.url'
+};
 jest.mock('@contrail/sdk', () => {
     return {
         Entities: class {
@@ -38,6 +46,18 @@ jest.mock('@contrail/sdk', () => {
                 getOptionsObject = _getOtionsObject;
                 return entityObject;
             }
+            create(arg) {
+                createCallArg = arg;
+                return Promise.resolve({});
+            }
+        },
+        Files: class {
+            createAndUploadFileFromBuffer(buffer, mimeType, fileName, _x, ttl) {
+                fileUploadCalls.push({ buffer, mimeType, fileName, ttl });
+                return Promise.resolve(fileUploadResult);
+            }
+        },
+        Request: class {
         }
     };
 });
@@ -1686,3 +1706,171 @@ describe('getEventsForItemFamilyChanges - conditional eventType', () => {
         expect(type_conversion_utils_1.TypeConversionUtils.isOutboundCreatableFromEntity).toHaveBeenNthCalledWith(2, undefined, mapFileUtil, colorProjectItem, { item: itemData, assortment });
     });
 });
+describe('sendToFlexPLM / handleVibeIQFile / sendPublishPayloadEvent', () => {
+    const config = {
+        taskId: 'task-abc',
+        event: '{"sourceEventId":"src-1"}'
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const events = [{ objectClass: 'LCSProductSeasonLink' }];
+    const eventType = 'ASYNC_PUBLISH_SEASON';
+    beforeEach(() => {
+        createCallArg = undefined;
+        fileUploadCalls = [];
+        fileUploadResult = {
+            id: 'file-123',
+            downloadUrl: 'https://download.url',
+            adminDownloadUrl: 'https://admin.download.url'
+        };
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should merge outboundPublishEvent into result and call sendPublishPayloadEvent after sendToFlexPLM succeeds', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexResponse = { status: 200, data: { ok: true } };
+        const callOrder = [];
+        const spyFlex = jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM')
+            .mockImplementation(async () => {
+            await new Promise(r => setTimeout(r, 5));
+            callOrder.push('flex');
+            return flexResponse;
+        });
+        const spyEvent = jest.spyOn(bppa, 'sendPublishPayloadEvent')
+            .mockImplementation(async () => {
+            callOrder.push('event');
+        });
+        const result = await bppa.sendToFlexPLM(events, eventType);
+        expect(spyFlex).toHaveBeenCalledTimes(1);
+        expect(spyEvent).toHaveBeenCalledTimes(1);
+        expect(callOrder).toEqual(['flex', 'event']);
+        const passedOutboundPublishEvent = spyFlex.mock.calls[0][0];
+        expect(passedOutboundPublishEvent.taskId).toBe('task-abc');
+        expect(passedOutboundPublishEvent.eventType).toBe(eventType);
+        expect(passedOutboundPublishEvent.objectClass).toBe('LCSSeason');
+        expect(passedOutboundPublishEvent.events).toBe(events);
+        expect(spyEvent).toHaveBeenCalledWith(passedOutboundPublishEvent);
+        expect(result).toEqual({ ...flexResponse, outboundPublishEvent: passedOutboundPublishEvent });
+    });
+    it('should have sendToFlexPLM throw when flexPLMConnect.sendToFlexPLM fails, without calling sendPublishPayloadEvent', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexError = new Error('flex failed');
+        jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM').mockRejectedValue(flexError);
+        const spyEvent = jest.spyOn(bppa, 'sendPublishPayloadEvent').mockResolvedValue(undefined);
+        await expect(bppa.sendToFlexPLM(events, eventType)).rejects.toMatchObject({
+            message: 'flex failed',
+            outboundPublishEvent: expect.objectContaining({ taskId: 'task-abc', eventType, objectClass: 'LCSSeason', events }),
+            sendToFlexPLMResult: { error: 'flex failed' }
+        });
+        expect(spyEvent).not.toHaveBeenCalled();
+        expect(flexError.sendPublishPayloadEventResult).toBeUndefined();
+    });
+    it('should have sendToFlexPLM throw when sendPublishPayloadEvent fails, with flex result attached', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexResponse = { status: 200 };
+        const eventError = new Error('event failed');
+        jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM').mockResolvedValue(flexResponse);
+        jest.spyOn(bppa, 'sendPublishPayloadEvent').mockRejectedValue(eventError);
+        await expect(bppa.sendToFlexPLM(events, eventType)).rejects.toMatchObject({
+            message: 'event failed',
+            outboundPublishEvent: expect.objectContaining({ taskId: 'task-abc', eventType }),
+            sendToFlexPLMResult: flexResponse,
+            sendPublishPayloadEventResult: { error: 'event failed' }
+        });
+    });
+    it('should have handleVibeIQFile (vibeiqfile) throw when flexPLMConnect.sendToFlexPLM fails, without calling sendPublishPayloadEvent', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexError = new Error('flex failed');
+        jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM').mockRejectedValue(flexError);
+        const spyEvent = jest.spyOn(bppa, 'sendPublishPayloadEvent').mockResolvedValue(undefined);
+        await expect(bppa.handleVibeIQFile(events, eventType, 'vibeiqfile')).rejects.toMatchObject({
+            message: 'flex failed',
+            outboundPublishEvent: expect.objectContaining({ eventsFileId: 'file-123' }),
+            sendToFlexPLMResult: { error: 'flex failed' }
+        });
+        expect(spyEvent).not.toHaveBeenCalled();
+        expect(flexError.sendPublishPayloadEventResult).toBeUndefined();
+    });
+    it('should have handleVibeIQFile (vibeiqfile) throw when sendPublishPayloadEvent fails, with flex result attached', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexResponse = { status: 200 };
+        const eventError = new Error('event failed');
+        jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM').mockResolvedValue(flexResponse);
+        jest.spyOn(bppa, 'sendPublishPayloadEvent').mockRejectedValue(eventError);
+        await expect(bppa.handleVibeIQFile(events, eventType, 'vibeiqfile')).rejects.toMatchObject({
+            message: 'event failed',
+            outboundPublishEvent: expect.objectContaining({ eventsFileId: 'file-123' }),
+            sendToFlexPLMResult: flexResponse,
+            sendPublishPayloadEventResult: { error: 'event failed' }
+        });
+    });
+    it('should merge outboundPublishEvent into FlexPLM result and call sendPublishPayloadEvent when mode is vibeiqfile', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const flexResponse = { status: 200, data: { ok: true } };
+        const spyFlex = jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM')
+            .mockResolvedValue(flexResponse);
+        const spyEvent = jest.spyOn(bppa, 'sendPublishPayloadEvent')
+            .mockResolvedValue(undefined);
+        const result = await bppa.handleVibeIQFile(events, eventType, 'vibeiqfile');
+        expect(fileUploadCalls).toHaveLength(1);
+        expect(fileUploadCalls[0].fileName).toBe('ASYNC_PUBLISH_SEASON-events.json');
+        expect(fileUploadCalls[0].mimeType).toBe('application/json');
+        const passedOutboundPublishEvent = spyFlex.mock.calls[0][0];
+        expect(passedOutboundPublishEvent.taskId).toBe('task-abc');
+        expect(passedOutboundPublishEvent.eventType).toBe(eventType);
+        expect(passedOutboundPublishEvent.objectClass).toBe('LCSSeason');
+        expect(passedOutboundPublishEvent.eventsFileId).toBe('file-123');
+        expect(passedOutboundPublishEvent.eventsDownloadLink).toBe('https://download.url');
+        expect(passedOutboundPublishEvent.eventsAdminDownloadLink).toBe('https://admin.download.url');
+        expect(spyFlex).toHaveBeenCalledTimes(1);
+        expect(spyEvent).toHaveBeenCalledTimes(1);
+        expect(spyEvent).toHaveBeenCalledWith(passedOutboundPublishEvent);
+        expect(result).toEqual({ ...flexResponse, outboundPublishEvent: passedOutboundPublishEvent });
+    });
+    it('should skip FlexPLM but still call sendPublishPayloadEvent when mode is vibeiqfile-dontsendtoflexplm', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const spyFlex = jest.spyOn(flexplm_connect_1.FlexPLMConnect.prototype, 'sendToFlexPLM')
+            .mockResolvedValue({});
+        const spyEvent = jest.spyOn(bppa, 'sendPublishPayloadEvent')
+            .mockResolvedValue(undefined);
+        const result = await bppa.handleVibeIQFile(events, eventType, 'vibeiqfile-dontsendtoflexplm');
+        expect(spyFlex).not.toHaveBeenCalled();
+        expect(spyEvent).toHaveBeenCalledTimes(1);
+        const passedOutboundPublishEvent = spyEvent.mock.calls[0][0];
+        expect(passedOutboundPublishEvent.eventsFileId).toBe('file-123');
+        expect(result).toEqual({
+            message: 'Successfully Uploaded File.',
+            outboundPublishEvent: passedOutboundPublishEvent
+        });
+    });
+    it('should create an external-event with initialEvent parsed from config', async () => {
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(config, dc, mapFileUtil);
+        const outboundPublishEvent = { foo: 'bar' };
+        await bppa.sendPublishPayloadEvent(outboundPublishEvent);
+        expect(createCallArg).toEqual({
+            entityName: 'external-event',
+            object: {
+                originSystemType: 'VibeIQ',
+                objectClass: 'AssortmentPublishedToFlexPLM',
+                outboundPublishEvent,
+                initialEvent: { sourceEventId: 'src-1' }
+            }
+        });
+    });
+    it('should default initialEvent to {} when config has no event', async () => {
+        const bareConfig = { taskId: 'task-x' };
+        const bppa = new base_process_publish_assortment_1.BaseProcessPublishAssortment(bareConfig, dc, mapFileUtil);
+        const outboundPublishEvent = { hello: 'world' };
+        await bppa.sendPublishPayloadEvent(outboundPublishEvent);
+        expect(createCallArg).toEqual({
+            entityName: 'external-event',
+            object: {
+                originSystemType: 'VibeIQ',
+                objectClass: 'AssortmentPublishedToFlexPLM',
+                outboundPublishEvent,
+                initialEvent: {}
+            }
+        });
+    });
+});

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.0-alpha.71b4d30",
+  "version": "1.7.0",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "bin": {
-    "flexplm": "lib/cli/index.js"
+    "flexplm-mapping": "lib/cli/index.js"
   },
   "files": [
     "lib/**/*",

package/scripts/copy-template.js

@@ -2,20 +2,9 @@
 const fs = require('fs');
 const path = require('path');
 
-const SRC_DIR = path.join('src', 'cli', 'template');
-const DST_DIR = path.join('lib', 'cli', 'template');
+const SRC = path.join('src', 'cli', 'template', 'mapping-template.ts.template');
+const DST = path.join('lib', 'cli', 'template', 'mapping-template.ts.template');
 
-fs.mkdirSync(DST_DIR, { recursive: true });
-
-const entries = fs.readdirSync(SRC_DIR).filter((name) => name.endsWith('.template'));
-if (entries.length === 0) {
-  console.warn(`No .template files found in ${SRC_DIR}`);
-  process.exit(0);
-}
-
-for (const name of entries) {
-  const src = path.join(SRC_DIR, name);
-  const dst = path.join(DST_DIR, name);
-  fs.copyFileSync(src, dst);
-  console.log(`Copied ${src} -> ${dst}`);
-}
+fs.mkdirSync(path.dirname(DST), { recursive: true });
+fs.copyFileSync(SRC, DST);
+console.log(`Copied ${SRC} -> ${DST}`);

package/lib/cli/commands/config-file/create.js

@@ -1,61 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateCommand = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const prompts_1 = require("../shared/prompts");
-const TEMPLATE_FILENAME = 'config-template.json.template';
-const PLACEHOLDER = '<ORG_NAME>';
-class CreateCommand {
-    findTemplate() {
-        const candidates = [
-            path.join(__dirname, '..', '..', 'template', TEMPLATE_FILENAME),
-            path.join(__dirname, '..', '..', '..', '..', 'src', 'cli', 'template', TEMPLATE_FILENAME),
-        ];
-        for (const candidate of candidates) {
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        throw new Error(`Could not locate ${TEMPLATE_FILENAME}. Tried:\n  ${candidates.join('\n  ')}`);
-    }
-    async run() {
-        const orgName = (await (0, prompts_1.prompt)('orgName: ')).trim();
-        if (!orgName) {
-            throw new Error('orgName is required');
-        }
-        const templatePath = this.findTemplate();
-        const templateBody = fs.readFileSync(templatePath, 'utf8');
-        const rendered = templateBody.split(PLACEHOLDER).join(orgName);
-        const outPath = path.resolve(process.cwd(), `${orgName}-config.json`);
-        if (fs.existsSync(outPath)) {
-            throw new Error(`Refusing to overwrite existing file: ${outPath}`);
-        }
-        fs.writeFileSync(outPath, rendered, 'utf8');
-        console.log(`Created ${outPath}`);
-    }
-}
-exports.CreateCommand = CreateCommand;