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

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/CHANGELOG.md

@@ -7,7 +7,7 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
-## [1.1.67] - 2026-xx-xx
+## [1.2.1] - 2026-04-08
 
 ### Added
 - Added EventShortMessageStatus status values for adding items to projects functionality.

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

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

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

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntityProcessor = exports.IncomingEntityResponse = void 0;
+const type_utils_1 = require("../util/type-utils");
+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 {
+}
+exports.IncomingEntityResponse = IncomingEntityResponse;
+class BaseEntityProcessor {
+    constructor(config, dc, mapFileUtil, baseType) {
+        this.config = config;
+        this.dc = dc;
+        this.mapFileUtil = mapFileUtil;
+        this.baseType = baseType;
+        this.typeUtil = new type_utils_1.TypeUtils();
+        this.transformMapFile = this.config?.transformMapFile;
+        this.entities = new sdk_1.Entities();
+        this.orgSlug = this.config?.orgSlug || 'unset-orgSlug';
+    }
+    async inbound(event) {
+        const eventType = event.eventType;
+        console.log(`inbound entity: ${eventType}:${event.objectClass}`);
+        switch (eventType) {
+            case 'PERSIST':
+                return await this.handleIncomingUpsert(event);
+            case 'DELETE':
+                return await this.handleIncomingDelete(event);
+            default:
+                console.error(UNSUPPORTED_TYPE);
+                return {
+                    status: 500,
+                    data: { UNSUPPORTED_TYPE }
+                };
+        }
+    }
+    async handleIncomingUpsert(event) {
+        const inboundData = await this.getTransformedData(event);
+        const incomingEntityResponse = await this.getIncomingEntity(event, inboundData);
+        if (incomingEntityResponse.earlyReturn) {
+            const statusMsg = this.getInboundStatusMessage({
+                status: event_short_message_status_1.EventShortMessageStatus.FAILURE,
+                statusMessage: incomingEntityResponse.earlyReturn.shortStatusMessage || '',
+                objectClass: event.objectClass,
+                federatedId: event.federatedId
+            });
+            console.log(statusMsg);
+            return incomingEntityResponse.earlyReturn;
+        }
+        const entity = incomingEntityResponse.entity;
+        if (!entity) {
+            const createEntityResponse = await this.getCreateEntity(inboundData);
+            if (createEntityResponse.earlyReturn) {
+                const status = (createEntityResponse.earlyReturn.shortStatusMessage === event_short_message_status_1.EventShortMessageStatus.NOT_CREATABLE)
+                    ? event_short_message_status_1.EventShortMessageStatus.SUCCESS
+                    : event_short_message_status_1.EventShortMessageStatus.FAILURE;
+                const statusMsg = this.getInboundStatusMessage({
+                    status,
+                    statusMessage: createEntityResponse.earlyReturn.shortStatusMessage || '',
+                    objectClass: event.objectClass,
+                    federatedId: event.federatedId
+                });
+                console.log(statusMsg);
+                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,
+                objectClass: event.objectClass,
+                entityId: 'id',
+                federatedId: event.federatedId
+            });
+            console.log(statusMsg);
+            return createdEntity;
+        }
+        const diffs = await this.getUpdatesForEntity(entity, inboundData);
+        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,
+                objectClass: event.objectClass,
+                entityId: entity.id,
+                federatedId: event.federatedId
+            });
+            console.log(statusMsg);
+            const message = 'No Changes to persist for entity: ' + entity.id;
+            return {
+                status: 200,
+                data: { message }
+            };
+        }
+        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,
+            objectClass: event.objectClass,
+            entityId: entity.id,
+            federatedId: event.federatedId
+        });
+        console.log(statusMsg);
+        return updatedEntity;
+    }
+    getInboundStatusMessage(statusObject) {
+        return 'BaseEntityProcessor: inbound: status: ' + statusObject.status
+            + ', statusMessage: ' + statusObject.statusMessage
+            + ', entityType: ' + this.baseType
+            + ', entityId: ' + statusObject.entityId
+            + ', objectClass: ' + statusObject.objectClass
+            + ', federatedId: ' + statusObject.federatedId
+            + ', orgSlug: ' + this.orgSlug;
+    }
+    async queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria) {
+        if (!entityType || !entityTypePath) {
+            throw new Error('type and entityTypePath must be defined');
+        }
+        if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
+            throw new Error('propertyCriteria must be defined and have at least one property');
+        }
+        const { rootTypeCriteria, subTypeCriteria } = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+        return returnedEntities;
+    }
+    async getCriteriaForEntity(entityType, entityTypePath, propertyCriteria) {
+        if (!entityType || !entityTypePath) {
+            throw new Error('type and entityTypePath must be defined');
+        }
+        if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
+            throw new Error('propertyCriteria must be defined and have at least one property');
+        }
+        const rootType = await this.typeUtil.getByRootAndPath({ root: entityType });
+        const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
+        const rootTypeCriteria = {};
+        const subTypeCriteria = {};
+        if (entityType !== entityTypePath) {
+            subTypeCriteria['typePath'] = entityTypePath;
+        }
+        for (const key in propertyCriteria) {
+            if (rootTypePropertyKeys.includes(key)) {
+                rootTypeCriteria[key] = propertyCriteria[key];
+            }
+            else {
+                subTypeCriteria[key] = propertyCriteria[key];
+            }
+        }
+        return { rootTypeCriteria, subTypeCriteria };
+    }
+    getRootTypePropertyKeys(rootType, propertyCriteria = null) {
+        const props = rootType['typeProperties'];
+        const rootTypePropertyKeys = props.map(prop => prop.slug);
+        return rootTypePropertyKeys;
+    }
+    async handleIncomingDelete(event) {
+        console.warn('delete is not configured', event);
+    }
+    async getTransformedData(event) {
+        let inboundData = event.data;
+        console.debug('inboundData: ' + JSON.stringify(inboundData));
+        const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, inboundData, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        inboundData = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, inboundData, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        console.debug('Transformed-inboundData: ' + JSON.stringify(inboundData));
+        return inboundData;
+    }
+    async getUpdatesForEntity(entity, inboundData) {
+        const vibeOwningKeys = await this.getVibeOwningKeys(entity);
+        let updates = {
+            typeId: entity.typeId,
+            roles: entity.roles,
+            id: entity.id,
+        };
+        updates = await this.dc.setEntityValues(updates, inboundData, vibeOwningKeys);
+        for (const prop of ['typeId', 'roles', 'id']) {
+            delete updates[prop];
+        }
+        return this.dc.getPersistableChanges(entity, updates);
+    }
+    async getVibeOwningKeys(entity) {
+        let vibeOwningKeys = [];
+        if (this.transformMapFile && entity) {
+            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, entity, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            const mapSection = await map_utils_1.MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
+            vibeOwningKeys = mapSection?.vibeOwningKeys || [];
+        }
+        console.debug('vibeOwningKeys: ' + vibeOwningKeys);
+        return vibeOwningKeys;
+    }
+    async getVibeOwningKeysFromInbound(entity) {
+        let vibeOwningKeys = [];
+        if (this.transformMapFile && entity) {
+            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, entity, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapSection = await map_utils_1.MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
+            vibeOwningKeys = mapSection?.vibeOwningKeys || [];
+        }
+        console.debug('vibeOwningKeys: ' + vibeOwningKeys);
+        return vibeOwningKeys;
+    }
+    async createEntity(entityName, changes) {
+        const options = {
+            entityName: entityName,
+            object: changes,
+        };
+        console.log("createEntity: " + JSON.stringify(options));
+        return await new sdk_1.Entities().create(options);
+    }
+    async updateEntity(entityName, entity, diffs) {
+        const options = {
+            entityName: entityName,
+            id: entity['id'],
+            object: diffs
+        };
+        console.log('updateEntity: ' + JSON.stringify(options));
+        return await new sdk_1.Entities().update(options);
+    }
+    async outbound(event) {
+        const entityType = event.entityType;
+        const eventType = event.eventType;
+        const entityId = event.id;
+        console.log(`outbound: ${entityType}:${entityId}`);
+        switch (eventType) {
+            case 'update':
+            case 'create':
+                return await this.handleOutgoingUpsert(entityType, event);
+            case 'delete':
+                return await this.handleOutgoingDelete(entityType, event);
+            case 'sendUpsertToFlexPLM':
+                return await this.sendUpsertToFlexPLM(event);
+            default:
+                console.log(UNSUPPORTED_TYPE);
+                return {
+                    status: 500,
+                    data: { UNSUPPORTED_TYPE }
+                };
+        }
+    }
+    async handleOutgoingUpsert(entityType, event) {
+        const objectClass = await type_conversion_utils_1.TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
+        if (!objectClass) {
+            const message = 'ObjectClass must have a value.';
+            console.log(message);
+            return {
+                status: 500,
+                data: { message }
+            };
+        }
+        try {
+            const payload = await this.getOutgoingUpsertPayload(entityType, event);
+            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+            if (outboundEntityUpdates) {
+                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+            }
+            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
+                + ', statusMessage: ' + flexResponse.status
+                + ', entityType: ' + this.baseType
+                + ', entityId: ' + event.id
+                + ', objectClass: ' + payload.objectClass
+                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
+                + ', orgSlug: ' + this.orgSlug;
+            console.log(statusMsg);
+            return flexResponse;
+        }
+        catch (e) {
+            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
+                + ', statusMessage: ' + e.httpResponseStatus
+                + ', entityType: ' + this.baseType
+                + ', entityId: ' + event.id
+                + ', objectClass: ' + objectClass
+                + ', updateFromResponse: ' + 'false'
+                + ', orgSlug: ' + this.orgSlug;
+            console.log(statusMsg);
+            throw e;
+        }
+    }
+    async getOutboundEntityUpdates(event, flexResponse) {
+        const payload = flexResponse?.data?.payload;
+        const flexPayload = (payload) ? payload[0] : undefined;
+        let outboundEntityUpdates = undefined;
+        if (flexPayload && 'OK' === flexPayload.status) {
+            if (flexPayload.data && !flexPayload.data?.flexPLMObjectClass) {
+                flexPayload.data.flexPLMObjectClass = flexPayload.objectClass;
+            }
+            const inboundData = await this.getTransformedData(flexPayload);
+            outboundEntityUpdates = await this.getUpdatesForEntity(event.newData, inboundData);
+        }
+        return outboundEntityUpdates;
+    }
+    async handleOutgoingDelete(entityType, event) {
+        console.warn('delete is not configured', entityType, event.oldData);
+    }
+    async triggerNewEvent(triggerKey, event) {
+        const newEvent = {
+            entityName: 'event-workflow-request',
+            object: {
+                triggerKey,
+                event
+            }
+        };
+        const response = await this.entities.create(newEvent);
+        return response;
+    }
+    async sendUpsertToFlexPLM(event) {
+        const payload = await this.getEntityCurrentStateUpsertPayload(event);
+        if (!payload) {
+            const message = 'No payload to send to FlexPLM';
+            console.log(message);
+            return {
+                status: 500,
+                data: { message }
+            };
+        }
+        ;
+        let objectClass = payload.objectClass;
+        try {
+            const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+            const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+            if (outboundEntityUpdates) {
+                flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+            }
+            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.SUCCESS
+                + ', statusMessage: ' + flexResponse.status
+                + ', entityType: ' + this.baseType
+                + ', entityId: ' + event.id
+                + ', objectClass: ' + objectClass
+                + ', updateFromResponse: ' + ((outboundEntityUpdates && Object.keys(outboundEntityUpdates).length > 0) ? 'true' : 'false')
+                + ', orgSlug: ' + this.orgSlug;
+            console.log(statusMsg);
+            return flexResponse;
+        }
+        catch (e) {
+            const statusMsg = 'BaseEntityProcessor: outbound: status: ' + event_short_message_status_1.EventShortMessageStatus.FAILURE
+                + ', statusMessage: ' + e.httpResponseStatus
+                + ', entityType: ' + this.baseType
+                + ', entityId: ' + event.id
+                + ', objectClass: ' + objectClass
+                + ', updateFromResponse: ' + 'false'
+                + ', orgSlug: ' + this.orgSlug;
+            console.log(statusMsg);
+            throw e;
+        }
+    }
+    async getEntityCurrentStateUpsertPayload(event) {
+        const id = event.id;
+        if (!id) {
+            return undefined;
+        }
+        const entity = await this.entities.get({
+            entityName: this.baseType,
+            id
+        });
+        if (!entity) {
+            return undefined;
+        }
+        event.newData = entity;
+        event.oldData = entity;
+        const payload = await this.getOutgoingUpsertPayload(this.baseType, event);
+        return payload;
+    }
+}
+exports.BaseEntityProcessor = BaseEntityProcessor;

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

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