bpmn-client 1.0.1 → 1.2.0

package/src/BPMNClient.ts

@@ -0,0 +1,219 @@
+import { IInstanceData, IItemData , IDefinitionData} from './interfaces/DataObjects';
+
+
+const dotenv = require('dotenv');
+const res = dotenv.config();
+
+console.log("BPMNClient 1.2");
+
+const https = require('https');
+const http = require('http');
+
+class WebService {
+    statusCode;
+    result;
+    constructor() { }
+    async invoke(params, options) {
+
+        var driver = http;
+        var body = JSON.stringify(params);
+
+        console.log(options, params);
+        if (options.port == 443)
+            driver = https;
+
+        let data = '';
+        let self = this;
+        return new Promise(function (resolve, reject) {
+            try {
+
+                driver.request(options, function (res) {
+                    console.log('STATUS: ' + res.statusCode);
+                    //console.log(res);
+                    self.statusCode = res.statusCode;
+                    res.setEncoding('utf8');
+                    res.on('data', function (chunk) {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        self.result = JSON.parse(data);
+
+                        resolve(self.result);
+                    });
+
+
+                }).on("error", (err) => {
+                    console.log("Error: " + err.message);
+                    reject(err);
+                }).end(body);
+            }
+            catch (exc) {
+                console.log(exc);
+            }
+
+        });
+
+    }
+}
+class BPMNClient extends WebService {
+    host;
+    port;
+    apiKey;
+    engine: ClientEngine;
+    datastore: ClientDatastore;
+    constructor(host, port, apiKey) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.apiKey = apiKey;
+        this.engine = new ClientEngine(this);
+        this.datastore = new ClientDatastore(this);
+    }
+
+    async get(url, data = {}) {
+        return await this.request(url, 'GET', data);
+
+    }
+    async post(url, data = {}) {
+        return await this.request(url, 'POST', data);
+
+    }
+    async put(url, data = {}) {
+        return await this.request(url, 'PUT', data);
+
+    }
+    async del(url, data = {}) {
+        return await this.request(url, 'DELETE', data);
+
+    }
+    async request(url, method, params) {
+
+        var body = JSON.stringify(params);
+
+        var options;
+
+        if (params) {
+            options = {
+                host: this.host,
+                port: this.port,
+                path: '/api/' + url,
+                method: method,
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": this.apiKey,
+                    "Accept": "*/*",
+                    //                        "User-Agent": "PostmanRuntime/ 7.26.8",
+                    //                        "Accept-Encoding": "gzip, deflate, br",
+                    "Connection": "keep-alive",
+                    "Content-Length": Buffer.byteLength(body)
+                }
+            };
+        }
+        else {
+            options = {
+                host: this.host,
+                port: this.port,
+                path: '/api/' + url,
+                method: method
+            };
+        }
+
+
+        return await this.invoke(params, options);
+
+    }
+
+}
+
+class ClientEngine {
+    private client: BPMNClient;
+
+    constructor(client) {
+        this.client = client;
+    }
+    async start(name, data): Promise<IInstanceData> {
+        const ret = await this.client.post('engine/start', { name, data });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret as IInstanceData;
+        return instance;
+    }
+    async invoke(query, data): Promise<IInstanceData> {
+        const ret = await this.client.put('engine/invoke', { query, data });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'] as IInstanceData;
+        return instance;
+    }
+
+    async get(query): Promise<IInstanceData> {
+        const ret = await this.client.get('engine/get', query);
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'] as IInstanceData;
+        return instance;
+    }
+}
+class ClientDatastore {
+    private client: BPMNClient;
+
+    constructor(client) {
+        this.client = client;
+    }
+    async findItems(query): Promise<IItemData[]> {
+        var res = await this.client.get('datastore/findItems', query);
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        const items = res['items'] as IItemData[];
+        return items;
+
+    }
+    async findInstances(query): Promise<IInstanceData[]> {
+        const res = await this.client.get('datastore/findInstances', query);
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        const instances = res['instances'] as IInstanceData[];
+        return instances;
+    }
+    async deleteInstances(query) {
+        return await this.client.del('datastore/delete', query);
+    }
+}
+class ClientDefinitions {
+    private client: BPMNClient;
+
+    constructor(client) {
+        this.client = client;
+    }
+    async list(): Promise<string[]> {
+        var res = await this.client.get('definitions/list', []);
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        return res as string[];
+
+    }
+    async load(name): Promise<IDefinitionData> {
+        const res = await this.client.get(encodeURI('definitions/load/' + name), { name: name });
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        console.log(res);
+        return res as IDefinitionData;
+    }
+}
+
+
+export { BPMNClient , ClientEngine,ClientDatastore , ClientDefinitions}

package/src/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces/Enums"), exports);
+__exportStar(require("./interfaces/DataObjects"), exports);
+__exportStar(require("./BPMNClient"), exports);

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './interfaces/Enums';
+export * from './interfaces/DataObjects';
+export * from './BPMNClient';
+

package/src/interfaces/DataObjects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/DataObjects.ts

@@ -0,0 +1,97 @@
+import { ITEM_STATUS, } from './Enums';
+
+interface IItemData {
+    id: string;            // System generated unique Id
+    itemKey: string;        // application assigned key to call the item by
+    elementId: string;   // bpmn element
+    name: string;       // name of bpmn element
+    type: string;       // bpmn element type
+    tokenId: any;         // execution Token
+    userId: any;
+    startedAt: any;
+    endedAt: any;
+    seq: any;
+    timeDue: Date;
+    status: ITEM_STATUS;
+    data: any;
+    messageId;
+    signalId;
+    assignments;
+    authorizations;
+    notifications;
+}
+interface IInstanceData {
+    id;
+    name;
+    status;
+    startedAt;
+    endedAt;
+    saved;
+    data;
+    items;
+    source;
+    logs;
+    tokens;
+    loops;
+    parentItemId;   // used for subProcess Calls
+    involvements;
+    authorizations;
+}
+
+
+
+interface IDefinitionData {
+    name: any;
+    processes: Map<any, any>;
+    rootElements: any;
+    nodes: Map<any, any>;
+    flows: any[];
+    source: any;
+    logger: any;
+    accessRules: any[];
+}
+
+
+interface IElementData {
+    id: any;
+    type: any;
+    name: any;
+    behaviours: Map<any, any>;
+}
+
+interface IFlowData {
+
+}
+
+interface IEventData {
+    elementId: string;
+    processId: string;
+    type;
+    name;
+    subType;
+    signalId?: string;
+    messageId?: string;
+    // timer info
+    expression;
+    expressionFormat; // cron/iso
+    referenceDateTime; //        start time of event   or last time timer ran
+    maxRepeat;
+    repeatCount;
+    timeDue?: Date;
+
+}
+interface IBpmnModelData {
+    name;
+    source;
+    svg;
+    processes: IProcessData[];
+    events: IEventData[];
+    saved;
+    //    parse(definition: IDefinition);
+}
+interface IProcessData {
+    id;
+    name;
+    isExecutable;
+}
+export { IItemData, IInstanceData , IDefinitionData, IElementData, IFlowData , IBpmnModelData, IProcessData, IEventData }

package/src/interfaces/Enums.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_SUBTYPE = exports.EXECUTION_STATUS = exports.TOKEN_STATUS = exports.ITEM_STATUS = exports.FLOW_ACTION = exports.NODE_ACTION = exports.EXECUTION_EVENT = exports.BPMN_TYPE = void 0;
+var BPMN_TYPE;
+(function (BPMN_TYPE) {
+    BPMN_TYPE["UserTask"] = "bpmn:UserTask";
+    BPMN_TYPE["ScriptTask"] = "bpmn:ScriptTask";
+    BPMN_TYPE["ServiceTask"] = "bpmn:ServiceTask";
+    BPMN_TYPE["SendTask"] = "bpmn:SendTask";
+    BPMN_TYPE["ReceiveTask"] = "bpmn:ReceiveTask";
+    BPMN_TYPE["BusinessRuleTask"] = "bpmn:BusinessRuleTask";
+    BPMN_TYPE["SubProcess"] = "bpmn:SubProces";
+    BPMN_TYPE["ParallelGateway"] = "bpmn:ParallelGateway";
+    BPMN_TYPE["EventBasedGateway"] = "bpmn:EventBasedGateway";
+    BPMN_TYPE["InclusiveGateway"] = "bpmn:InclusiveGateway";
+    BPMN_TYPE["ExclusiveGateway"] = "bpmn:ExclusiveGateway";
+    BPMN_TYPE["BoundaryEvent"] = "bpmn:BoundaryEvent";
+    BPMN_TYPE["StartEvent"] = "bpmn:StartEvent";
+    BPMN_TYPE["IntermediateCatchEvent"] = "bpmn:IntermediateCatchEvent";
+    BPMN_TYPE["IntermediateThrowEvent"] = "bpmn:IntermediateThrowEvent";
+    BPMN_TYPE["EndEvent"] = "bpmn:EndEvent";
+    BPMN_TYPE["SequenceFlow"] = "bpmn:SequenceFlow";
+    BPMN_TYPE["MessageFlow"] = "bpmn:MessageFlow";
+    BPMN_TYPE["CallActivity"] = "bpmn:CallActivity";
+})(BPMN_TYPE || (BPMN_TYPE = {}));
+exports.BPMN_TYPE = BPMN_TYPE;
+var NODE_SUBTYPE;
+(function (NODE_SUBTYPE) {
+    NODE_SUBTYPE["timer"] = "timer";
+    NODE_SUBTYPE["message"] = "message";
+    NODE_SUBTYPE["signal"] = "signal";
+    NODE_SUBTYPE["error"] = "error";
+    NODE_SUBTYPE["escalation"] = "escalation";
+})(NODE_SUBTYPE || (NODE_SUBTYPE = {}));
+exports.NODE_SUBTYPE = NODE_SUBTYPE;
+/*
+ * ALL events
+ */
+var EXECUTION_EVENT;
+(function (EXECUTION_EVENT) {
+    EXECUTION_EVENT["node_enter"] = "enter";
+    EXECUTION_EVENT["node_start"] = "start";
+    EXECUTION_EVENT["node_wait"] = "wait";
+    EXECUTION_EVENT["node_end"] = "end";
+    EXECUTION_EVENT["node_terminated"] = "terminated";
+    EXECUTION_EVENT["transform_input"] = "transformInput";
+    EXECUTION_EVENT["transform_output"] = "transformOutput";
+    EXECUTION_EVENT["flow_take"] = "take";
+    EXECUTION_EVENT["flow_discard"] = "discard";
+    EXECUTION_EVENT["process_loaded"] = "process.loaded";
+    EXECUTION_EVENT["process_start"] = "process.start";
+    EXECUTION_EVENT["process_started"] = "process.started";
+    EXECUTION_EVENT["process_invoke"] = "process.invoke";
+    EXECUTION_EVENT["process_invoked"] = "process.invoked";
+    EXECUTION_EVENT["process_restored"] = "process.restored";
+    EXECUTION_EVENT["process_resumed"] = "process_resumed";
+    EXECUTION_EVENT["process_wait"] = "process.wait";
+    EXECUTION_EVENT["process_end"] = "process.end";
+    EXECUTION_EVENT["process_terminated"] = "executeion.terminate";
+    EXECUTION_EVENT["token_start"] = "token.start";
+    EXECUTION_EVENT["token_wait"] = "token.wait";
+    EXECUTION_EVENT["token_end"] = "token.end";
+    EXECUTION_EVENT["token_terminated"] = "token.terminated";
+})(EXECUTION_EVENT || (EXECUTION_EVENT = {}));
+exports.EXECUTION_EVENT = EXECUTION_EVENT;
+/*
+ *  possible actions by node
+ */
+//   must be same as above
+var NODE_ACTION;
+(function (NODE_ACTION) {
+    NODE_ACTION[NODE_ACTION["continue"] = 1] = "continue";
+    NODE_ACTION[NODE_ACTION["wait"] = 2] = "wait";
+    NODE_ACTION[NODE_ACTION["end"] = 3] = "end";
+    NODE_ACTION[NODE_ACTION["stop"] = 4] = "stop";
+    NODE_ACTION[NODE_ACTION["error"] = 5] = "error";
+    NODE_ACTION[NODE_ACTION["abort"] = 6] = "abort";
+})(NODE_ACTION || (NODE_ACTION = {}));
+exports.NODE_ACTION = NODE_ACTION;
+;
+var ITEM_STATUS;
+(function (ITEM_STATUS) {
+    ITEM_STATUS["enter"] = "enter";
+    ITEM_STATUS["start"] = "start";
+    ITEM_STATUS["wait"] = "wait";
+    ITEM_STATUS["end"] = "end";
+    ITEM_STATUS["terminated"] = "terminated";
+    ITEM_STATUS["discard"] = "discard";
+})(ITEM_STATUS || (ITEM_STATUS = {}));
+exports.ITEM_STATUS = ITEM_STATUS;
+//type ITEMSTATUS = 'enter' | 'start' | 'wait' | 'end' | 'terminated' | 'discard';
+var EXECUTION_STATUS;
+(function (EXECUTION_STATUS) {
+    EXECUTION_STATUS["running"] = "running";
+    EXECUTION_STATUS["wait"] = "wait";
+    EXECUTION_STATUS["end"] = "end";
+    EXECUTION_STATUS["terminated"] = "terminated";
+})(EXECUTION_STATUS || (EXECUTION_STATUS = {}));
+exports.EXECUTION_STATUS = EXECUTION_STATUS;
+var TOKEN_STATUS;
+(function (TOKEN_STATUS) {
+    TOKEN_STATUS["running"] = "running";
+    TOKEN_STATUS["wait"] = "wait";
+    TOKEN_STATUS["end"] = "end";
+    TOKEN_STATUS["terminated"] = "terminated";
+})(TOKEN_STATUS || (TOKEN_STATUS = {}));
+exports.TOKEN_STATUS = TOKEN_STATUS;
+/*
+ * possible actions by flow
+ */
+//   must be same as above
+var FLOW_ACTION;
+(function (FLOW_ACTION) {
+    FLOW_ACTION["take"] = "take";
+    FLOW_ACTION["discard"] = "discard";
+})(FLOW_ACTION || (FLOW_ACTION = {}));
+exports.FLOW_ACTION = FLOW_ACTION;

package/src/interfaces/Enums.ts

@@ -0,0 +1,71 @@
+
+enum BPMN_TYPE {
+    UserTask = 'bpmn:UserTask',
+    ScriptTask = 'bpmn:ScriptTask',
+    ServiceTask = 'bpmn:ServiceTask',
+    SendTask = 'bpmn:SendTask',
+    ReceiveTask = 'bpmn:ReceiveTask',
+    BusinessRuleTask = 'bpmn:BusinessRuleTask',
+    SubProcess = 'bpmn:SubProces',
+    ParallelGateway = 'bpmn:ParallelGateway',
+    EventBasedGateway = 'bpmn:EventBasedGateway',
+    InclusiveGateway = 'bpmn:InclusiveGateway',
+    ExclusiveGateway = 'bpmn:ExclusiveGateway',
+    BoundaryEvent = 'bpmn:BoundaryEvent',
+    StartEvent = 'bpmn:StartEvent',
+    IntermediateCatchEvent = 'bpmn:IntermediateCatchEvent',
+    IntermediateThrowEvent = 'bpmn:IntermediateThrowEvent',
+    EndEvent = 'bpmn:EndEvent',
+    SequenceFlow = 'bpmn:SequenceFlow',
+    MessageFlow = 'bpmn:MessageFlow',
+    CallActivity = 'bpmn:CallActivity'
+}
+
+enum NODE_SUBTYPE {
+    timer = 'timer',
+    message = 'message',
+    signal = 'signal',
+    error = 'error',
+    escalation = 'escalation'
+}
+/*
+ * ALL events 
+ */
+enum EXECUTION_EVENT {
+    node_enter = 'enter', node_start = 'start', node_wait = 'wait', node_end = 'end', node_terminated = 'terminated',
+    transform_input = 'transformInput', transform_output ='transformOutput',
+    flow_take = 'take', flow_discard = 'discard',
+    process_loaded ='process.loaded',
+    process_start = 'process.start',   process_started = 'process.started',
+    process_invoke = 'process.invoke',     process_invoked = 'process.invoked',
+    process_restored = 'process.restored', process_resumed = 'process_resumed',
+    process_wait = 'process.wait',
+    process_end = 'process.end', process_terminated = 'executeion.terminate' ,
+    token_start = 'token.start', token_wait = 'token.wait', token_end = 'token.end', token_terminated = 'token.terminated' 
+}
+/*
+ *  possible actions by node
+ */
+//   must be same as above
+enum NODE_ACTION { continue = 1, wait,  end , stop , error , abort  };
+
+enum ITEM_STATUS {  enter = 'enter', start = 'start', wait = 'wait', end = 'end', terminated = 'terminated' , discard= 'discard'}
+
+//type ITEMSTATUS = 'enter' | 'start' | 'wait' | 'end' | 'terminated' | 'discard';
+
+enum EXECUTION_STATUS { running='running',wait='wait', end = 'end' , terminated ='terminated' }
+
+enum TOKEN_STATUS { running = 'running', wait = 'wait', end = 'end', terminated = 'terminated' }
+/*
+ * possible actions by flow
+ */
+//   must be same as above
+
+enum FLOW_ACTION { take = 'take', discard = 'discard' }
+
+
+export {
+    BPMN_TYPE ,
+    EXECUTION_EVENT, NODE_ACTION, FLOW_ACTION,
+    ITEM_STATUS, TOKEN_STATUS, EXECUTION_STATUS , NODE_SUBTYPE
+}

package/test/.eslintrc.json

@@ -0,0 +1,20 @@
+{
+  "env": {
+    "mocha": true
+  },
+  "rules": {
+    "no-unused-expressions": 0,
+    "no-var": 1,
+    "prefer-arrow-callback": 1
+  },
+  "globals": {
+    "expect": false,
+    "Feature": false,
+    "Scenario": false,
+    "Given": false,
+    "When": false,
+    "Then": false,
+    "And": false,
+    "But": false
+  }
+}

package/test/feature/.env

@@ -0,0 +1,5 @@
+API_KEY=1234
+MONGO_DB_URL=mongodb://localhost:27017?retryWrites=true&w=majority
+MONGO_DB_NAME=bpmn
+SENDGRID_API_KEY=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
+

package/test/feature/carServer.js

@@ -0,0 +1,117 @@
+const {  BPMNClient } = require("../../src/");
+
+
+
+const API_KEY = '12345';
+//const HOST = 'localhost';
+//const PORT = '3000';
+const HOST = 'test.omniworkflow.com';
+const PORT = '443';
+
+const BASE_URL = 'api';
+
+
+console.log('-------- car.js -----------');
+
+const server = new BPMNClient(HOST, PORT, API_KEY);
+
+var caseId = Math.floor(Math.random() * 10000);
+
+let name = 'Buy Used Car';
+let process;
+let response;
+let instanceId;
+
+Feature('Buy Used Car- clean and repair', () => {
+    Scenario('Simple', () => {
+        Given('Start Buy Used Car Process', async () => {
+            response = await server.engine.start(name, { caseId: caseId });
+            instanceId = response.id;
+            console.log('**instanceId', response.id, instanceId);
+            console.log(' after start ', response.data.caseId);
+        });
+        Then('check for output', () => {
+            expect(response.data.caseId).equals(caseId);
+            expect(getItem('task_Buy').status).equals('wait');
+        });
+
+        When('a process defintion is executed', async () => {
+
+            const data = { needsCleaning: "Yes", needsRepairs: "Yes" };
+            const query = {
+                id: instanceId,
+                "items.elementId": 'task_Buy'
+            };
+            console.log(query);
+            response = await server.engine.invoke(query, data);
+        });
+
+        When('engine get', async () => {
+            const query = { id: instanceId };
+
+            response = await server.engine.get(query);
+
+            expect(response.id).equals(instanceId);
+
+        });
+
+
+        Then('check for output to have engine', () => {
+            expect(getItem('task_Buy').status).equals('end');
+        });
+
+        and('Clean it', async () => {
+
+            const query = {
+                "data.caseId": caseId,
+                "items.elementId": 'task_clean'
+            };
+            console.log(query);
+            await server.engine.invoke(query, {});
+        });
+
+        and('Repair it', async () => {
+            const query = { id: instanceId, "items.elementId": 'task_repair' };
+            response = await server.engine.invoke(query, {});
+        });
+        and('Drive it 1', async () => {
+            const query = {
+                id: instanceId,
+                "items.elementId": 'task_Drive'
+            };
+            response = await server.engine.invoke(query, {});
+        });
+
+        and('Case Complete', async () => {
+
+            console.log(response.status);
+            expect(getItem('task_Drive').status).equals('end');
+
+        });
+
+
+        // 
+        and('find instances', async () => {
+
+            var insts = await server.datastore.findInstances({ id: response.id });
+            expect(insts).to.have.lengthOf(1);
+
+        });
+
+        and('find items', async () => {
+
+            var items = await server.datastore.findItems({ id: response.id } );
+            expect(items).to.have.lengthOf(17);
+
+        });
+
+
+
+
+    });
+
+});
+
+function getItem(id) {
+    return response.items.filter(item => { return item.elementId == id; })[0];
+}

package/test/helpers/setup.js

@@ -0,0 +1,9 @@
+'use strict';
+
+process.env.NODE_ENV = 'test';
+Error.stackTraceLimit = 20;
+global.expect = require('chai').expect;
+global.assert = require('chai').assert;
+
+
+