@contrail/flexplm 1.3.0 → 1.3.1-alpha.585afc1

package/lib/cli/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const create_1 = require("./commands/create");
+const compile_1 = require("./commands/compile");
+const upload_1 = require("./commands/upload");
+const USAGE = `Usage: flexplm-mapping <command> [args]
+
+Commands:
+  create                  Scaffold a new mapping .ts file in the current directory
+  compile <path.ts>       Transpile a mapping .ts file to .js alongside it
+  upload  <path.js> [opts] Upload a compiled mapping .js file to VibeIQ
+
+Upload options:
+  -m <message>            Git commit message (prompted if omitted)
+  -b <branch>             Create a new git branch before committing
+  --skip-git              Skip the post-upload git commit (default: commit)
+
+Environment (upload):
+  CONTRAIL_CLI_EMAIL      VibeIQ user email
+  CONTRAIL_CLI_PASSWORD   VibeIQ user password
+`;
+async function main() {
+    const [, , command, ...rest] = process.argv;
+    switch (command) {
+        case 'create':
+            await (0, create_1.runCreate)();
+            return;
+        case 'compile':
+            if (!rest[0]) {
+                console.error('compile: missing <path.ts> argument');
+                console.error(USAGE);
+                process.exit(1);
+            }
+            await (0, compile_1.runCompile)(rest[0]);
+            return;
+        case 'upload':
+            if (!rest[0]) {
+                console.error('upload: missing <path.js> argument');
+                console.error(USAGE);
+                process.exit(1);
+            }
+            await (0, upload_1.runUpload)(rest);
+            return;
+        case undefined:
+        case '-h':
+        case '--help':
+        case 'help':
+            console.log(USAGE);
+            return;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error(USAGE);
+            process.exit(1);
+    }
+}
+exports.main = main;
+if (require.main === module) {
+    main().catch((err) => {
+        console.error(err && err.message ? err.message : err);
+        process.exit(1);
+    });
+}

package/lib/cli/index.spec.d.ts

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

package/lib/cli/index.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('./commands/create', () => ({ runCreate: jest.fn().mockResolvedValue(undefined) }));
+jest.mock('./commands/compile', () => ({ runCompile: jest.fn().mockResolvedValue(undefined) }));
+jest.mock('./commands/upload', () => ({ runUpload: jest.fn().mockResolvedValue(undefined) }));
+const create_1 = require("./commands/create");
+const compile_1 = require("./commands/compile");
+const upload_1 = require("./commands/upload");
+const index_1 = require("./index");
+describe('cli main dispatcher', () => {
+    let originalArgv;
+    let logSpy;
+    let errorSpy;
+    let exitSpy;
+    beforeEach(() => {
+        originalArgv = process.argv;
+        create_1.runCreate.mockClear();
+        compile_1.runCompile.mockClear();
+        upload_1.runUpload.mockClear();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`__EXIT__:${code}`);
+        }));
+    });
+    afterEach(() => {
+        process.argv = originalArgv;
+        logSpy.mockRestore();
+        errorSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    function setArgv(...args) {
+        process.argv = ['node', 'cli', ...args];
+    }
+    it('dispatches the create command', async () => {
+        setArgv('create');
+        await (0, index_1.main)();
+        expect(create_1.runCreate).toHaveBeenCalledTimes(1);
+        expect(compile_1.runCompile).not.toHaveBeenCalled();
+        expect(upload_1.runUpload).not.toHaveBeenCalled();
+    });
+    it('dispatches the compile command with its argument', async () => {
+        setArgv('compile', 'mapping.ts');
+        await (0, index_1.main)();
+        expect(compile_1.runCompile).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(compile_1.runCompile).not.toHaveBeenCalled();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.ts>/));
+    });
+    it('dispatches the upload command and forwards remaining args', async () => {
+        setArgv('upload', 'mapping.js', '-m', 'msg', '--skip-git');
+        await (0, index_1.main)();
+        expect(upload_1.runUpload).toHaveBeenCalledWith(['mapping.js', '-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(upload_1.runUpload).not.toHaveBeenCalled();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.js>/));
+    });
+    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/));
+    });
+    it('prints usage when no command is provided', async () => {
+        setArgv();
+        await (0, index_1.main)();
+        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-mapping/));
+    });
+    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/cli/template/mapping-template.ts.template

@@ -0,0 +1,18 @@
+import type { MappingFile } from '@contrail/flexplm';
+
+export const mapping: MappingFile = {
+  orgInfo: {
+    appIdentifier: '@vibeiq/flexplm-connector',
+    orgName: '<ORG_NAME>',
+  },
+  typeConversion: {
+    vibe2flex: {},
+    flex2vibe: {},
+  },
+  LCSSeason:            { vibe2flex: {}, flex2vibe: {} },
+  LCSProduct:           { vibe2flex: {}, flex2vibe: {} },
+  LCSSKU:               { vibe2flex: {}, flex2vibe: {} },
+  LCSProductSeasonLink: { vibe2flex: {}, flex2vibe: {} },
+  LCSSKUSeasonLink:     { vibe2flex: {}, flex2vibe: {} },
+  LCSColor:             { vibe2flex: {}, flex2vibe: {} },
+};

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

@@ -1,42 +1,89 @@
-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>;
-}
+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;
+    /**This will query for the entity, and handle post-processing
+     * of any critieria that is defined at the sub-type level.
+     * Because sub-type criteria can't be used in the search done
+     * on the server. This is expected to be called by getIncomingEntity().
+     *
+     * @param entityType: the root type of the entity
+     * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+     * @param propertyCriteria: all the criteria to search for the entity
+     * @returns the entities that match the criteria
+     */
+    queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>;
+    /** This is to get the criteria for the entity that is being processed.
+     * This is to be overridden for item & project-item because of the need for
+     * setting the roles criteria.
+     *
+     * @param entityType: the root type of the entity
+     * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+     * @param propertyCriteria: all the criteria to search for the entity
+     * @returns the criteria for the entity
+     */
+    getCriteriaForEntity(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any>;
+    /** This is to get the properties that are owned by the root type
+     * This needs to be overridded for multi-level types, such as item
+     * and project-item. And for those types, the propertyCriteria
+     * will be needed to determine the correct level.
+     *
+     * @param rootType: the full root type entity for the processed entity
+     * @param propertyCriteria: the criteria to determine the correct level (unused for single level types)
+     * @returns: string[] of the property keys
+     */
+    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>;
+    /** Create a new event-workflow-request to rerun sending the entity to FlexPLM
+     * The event must contain any information needed to ensure it is put in the correct queue for the entity
+     *
+     * @param triggerKey Ex: event.entityType + '|sendUpsertToFlexPLM'
+     * @param event
+     * @returns
+     */
+    protected triggerNewEvent(triggerKey: string, event: any): Promise<any>;
+    /** Sends the current state of the entity to FlexPLM.
+     * So any changes made in Vibe between the event being generated and the event being processed are sent to FlexPLM.
+     *
+     * @param event must contain entityType, id; which are used to query for the entity
+     * @returns results of sending the entity to FlexPLM
+     */
+    protected sendUpsertToFlexPLM(event: any): Promise<any>;
+    /** Generates the payload to send to FlexPLM, based on the current state of the entity.
+     * The current state of the entity are used as the newData and oldData; which is passed
+     * to getOutgoingUpsertPayload to generate the payload.
+     * @param event information about the item to send to FlexPLM
+     * @returns The payload to send to FlexPLM
+     */
+    protected getEntityCurrentStateUpsertPayload(event: any): Promise<EntityPayloadType>;
+}