bpmn-client 1.0.2 → 1.2.1

package/src/BPMNClient.js

@@ -0,0 +1,235 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDefinitions = exports.ClientDatastore = exports.ClientEngine = exports.BPMNClient = void 0;
+console.log("BPMNClient 1.2");
+const https = require('https');
+const http = require('http');
+class WebService {
+    constructor() { }
+    invoke(params, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 {
+    constructor(host, port, apiKey) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.apiKey = apiKey;
+        this.engine = new ClientEngine(this);
+        this.datastore = new ClientDatastore(this);
+        this.definitions = new ClientDefinitions(this);
+    }
+    get(url, data = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.request(url, 'GET', data);
+        });
+    }
+    post(url, data = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.request(url, 'POST', data);
+        });
+    }
+    put(url, data = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.request(url, 'PUT', data);
+        });
+    }
+    del(url, data = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.request(url, 'DELETE', data);
+        });
+    }
+    request(url, method, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 yield this.invoke(params, options);
+        });
+    }
+}
+exports.BPMNClient = BPMNClient;
+class ClientEngine {
+    constructor(client) {
+        this.client = client;
+    }
+    start(name, data = {}, startNodeId = null, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.post('engine/start', { name, data, startNodeId, options });
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            const instance = ret;
+            return instance;
+        });
+    }
+    invoke(query, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.put('engine/invoke', { query, data });
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            const instance = ret['instance'];
+            return instance;
+        });
+    }
+    throwMessage(messageId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.put('engine/throwMessage', { "messageId": messageId, "data": data });
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            return ret;
+        });
+    }
+    throwSignal(signalId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.put('engine/throwSignal', { "signalId": signalId, "data": data });
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            return ret;
+        });
+    }
+    get(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = yield this.client.get('engine/get', query);
+            if (ret['errors']) {
+                console.log(ret['errors']);
+                throw new Error(ret['errors']);
+            }
+            const instance = ret['instance'];
+            return instance;
+        });
+    }
+}
+exports.ClientEngine = ClientEngine;
+class ClientDatastore {
+    constructor(client) {
+        this.client = client;
+    }
+    findItems(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var res = yield this.client.get('datastore/findItems', query);
+            if (res['errors']) {
+                console.log(res['errors']);
+                throw new Error(res['errors']);
+            }
+            const items = res['items'];
+            return items;
+        });
+    }
+    findInstances(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.get('datastore/findInstances', query);
+            if (res['errors']) {
+                console.log(res['errors']);
+                throw new Error(res['errors']);
+            }
+            const instances = res['instances'];
+            return instances;
+        });
+    }
+    deleteInstances(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.del('datastore/delete', query);
+        });
+    }
+}
+exports.ClientDatastore = ClientDatastore;
+class ClientDefinitions {
+    constructor(client) {
+        this.client = client;
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var res = yield this.client.get('definitions/list', []);
+            if (res['errors']) {
+                console.log(res['errors']);
+                throw new Error(res['errors']);
+            }
+            return res;
+        });
+    }
+    load(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield 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;
+        });
+    }
+}
+exports.ClientDefinitions = ClientDefinitions;

package/src/BPMNClient.ts

@@ -0,0 +1,236 @@
+import { IInstanceData, IItemData , IDefinitionData} from './interfaces/DataObjects';
+
+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;
+    definitions: ClientDefinitions;
+
+    constructor(host, port, apiKey) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.apiKey = apiKey;
+        this.engine = new ClientEngine(this);
+        this.datastore = new ClientDatastore(this);
+        this.definitions = new ClientDefinitions(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 = {} , startNodeId = null, options = {}): Promise<IInstanceData> {
+        const ret = await this.client.post('engine/start',
+            { name, data, startNodeId, options });
+        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 throwMessage(messageId, data) {
+        const ret = await this.client.put('engine/throwMessage', { "messageId": messageId , "data": data });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
+    }
+    async throwSignal(signalId, data) {
+        const ret = await this.client.put('engine/throwSignal', { "signalId": signalId, "data": data });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
+    }
+
+    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 }