bpmn-client 2.3.2 → 3.0.0

package/README.md

@@ -1,32 +1,32 @@
-cbpmn-client
-===========
-
-[![Project Status: Active - The project has reached a stable, usable state and is being actively developed.](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
-
-This is a light-weight package to allow remote access to [bpmn-server](https://github.com/bpmnServer/bpmn-server)
-
-# Installation
-
-This installs bpmn-client-sample application along with `bpmn-client`
-
-```sh
-
-git clone https://github.com/bpmnServer/bpmn-client-sample.git
-
-cd bpmn-client-sample
-
-npm install
-
-npm run setup
-
-npm run cli
-
-```
-the above setup command will copy .env 
-You can edit .env file to point to your implementation of `bpmn-server`
-
-### to update to latest release
-
-```
-$ npm update bpmn-client
-```
+cbpmn-client
+===========
+
+[![Project Status: Active - The project has reached a stable, usable state and is being actively developed.](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
+
+This is a light-weight package to allow remote access to [bpmn-server](https://github.com/bpmnServer/bpmn-server)
+
+# Installation
+
+This installs bpmn-client-sample application along with `bpmn-client`
+
+```sh
+
+git clone https://github.com/bpmnServer/bpmn-client-sample.git
+
+cd bpmn-client-sample
+
+npm install
+
+npm run setup
+
+npm run cli
+
+```
+the above setup command will copy .env 
+You can edit .env file to point to your implementation of `bpmn-server`
+
+### to update to latest release
+
+```
+$ npm update bpmn-client
+```

package/dist/BPMNClient.d.ts

@@ -0,0 +1,62 @@
+import { IInstanceData, IItemData, IDefinitionData } from './interfaces/DataObjects.js';
+import { WebService } from './WebService.js';
+declare class BPMNClient extends WebService {
+    host: any;
+    port: any;
+    apiKey: any;
+    engine: ClientEngine;
+    datastore: ClientDatastore;
+    definitions: ClientDefinitions;
+    constructor(host: any, port: any, apiKey: any);
+    get(url: any, data?: {}): Promise<any>;
+    post(url: any, data?: {}): Promise<any>;
+    put(url: any, data?: {}): Promise<any>;
+    del(url: any, data?: {}): Promise<any>;
+    request(url: any, method: any, params: any): Promise<any>;
+}
+declare class ClientEngine {
+    private client;
+    constructor(client: any);
+    start(name: any, data?: {}, startNodeId?: any, userId?: any, options?: {}): Promise<IInstanceData>;
+    invoke(query: any, data: any, userId?: any, options?: {}): Promise<IInstanceData>;
+    assign(query: any, data: any, userId: any, assignment: any): Promise<IInstanceData>;
+    restart(query: any, data: any, userId?: any, options?: {}): Promise<IInstanceData>;
+    throwMessage(messageId: any, data?: {}, messageMatchingKey?: {}): Promise<any>;
+    throwSignal(signalId: any, data?: {}, messageMatchingKey?: {}): Promise<any>;
+    startEvent(instanceId: any, startNodeId: any, data?: {}, userId?: any, options?: {}): Promise<IInstanceData>;
+    get(query: any): Promise<IInstanceData>;
+    status(): Promise<any>;
+}
+declare class ClientDatastore {
+    private client;
+    constructor(client: any);
+    find({ filter, sort, limit, after, projection, lastItem, latestItem, getTotalCount }: {
+        filter?: Record<string, any>;
+        after?: string;
+        limit?: number;
+        sort?: Record<string, 1 | -1>;
+        projection?: Record<string, 0 | 1 | any>;
+        lastItem?: Record<string, any>;
+        latestItem?: Record<string, any>;
+        getTotalCount?: boolean;
+    }): Promise<{
+        data?: any[];
+        nextCursor?: string | null;
+        totalCount?: number;
+        error?: string;
+    }>;
+    findItems(query: any): Promise<IItemData[]>;
+    findInstances(query: any, projection?: {}): Promise<IInstanceData[]>;
+    deleteInstances(query: any): Promise<any>;
+}
+declare class ClientDefinitions {
+    private client;
+    constructor(client: any);
+    import(name: any, pathToBPMN: any, pathToSVG?: any): Promise<any>;
+    list(): Promise<string[]>;
+    delete(name: any): Promise<IDefinitionData>;
+    rename(name: any, newName: any): Promise<IDefinitionData>;
+    load(name: any): Promise<IDefinitionData>;
+    checkErrors(res: any): void;
+}
+export { BPMNClient, ClientEngine, ClientDatastore, ClientDefinitions };

package/dist/BPMNClient.js

@@ -1,17 +1,11 @@
-"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;
-const WebService_1 = require("./WebService");
-class BPMNClient extends WebService_1.WebService {
+import { WebService } from './WebService.js';
+class BPMNClient extends WebService {
+    host;
+    port;
+    apiKey;
+    engine;
+    datastore;
+    definitions;
     constructor(host, port, apiKey) {
         super();
         this.host = host;
@@ -21,280 +15,234 @@ class BPMNClient extends WebService_1.WebService {
         this.datastore = new ClientDatastore(this);
         this.definitions = new ClientDefinitions(this);
     }
-    get(url_1) {
-        return __awaiter(this, arguments, void 0, function* (url, data = {}) {
-            return yield this.request(url, 'GET', data);
-        });
+    async get(url, data = {}) {
+        return await this.request(url, 'GET', data);
     }
-    post(url_1) {
-        return __awaiter(this, arguments, void 0, function* (url, data = {}) {
-            return yield this.request(url, 'POST', data);
-        });
+    async post(url, data = {}) {
+        return await this.request(url, 'POST', data);
     }
-    put(url_1) {
-        return __awaiter(this, arguments, void 0, function* (url, data = {}) {
-            return yield this.request(url, 'PUT', data);
-        });
+    async put(url, data = {}) {
+        return await this.request(url, 'PUT', data);
     }
-    del(url_1) {
-        return __awaiter(this, arguments, void 0, function* (url, data = {}) {
-            return yield this.request(url, 'DELETE', data);
-        });
+    async del(url, data = {}) {
+        return await this.request(url, 'DELETE', data);
     }
-    request(url, method, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var body = JSON.stringify(params);
-            var size = Buffer.byteLength(body);
-            var contentType = "application/json";
-            if (method == 'UPLOAD') {
-                contentType = 'multipart/form-data; boundary = ----WebKitFormBoundary7MA4YWxkTrZu0gW';
-                method = 'POST';
-            }
-            var headers = {
-                "Content-Type": contentType,
-                "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)
+    async request(url, method, params) {
+        var body = JSON.stringify(params);
+        var size = Buffer.byteLength(body);
+        var contentType = "application/json";
+        if (method == 'UPLOAD') {
+            contentType = 'multipart/form-data; boundary = ----WebKitFormBoundary7MA4YWxkTrZu0gW';
+            method = 'POST';
+        }
+        var headers = {
+            "Content-Type": contentType,
+            "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)
+        };
+        var options;
+        if (params) {
+            options = {
+                host: this.host,
+                port: this.port,
+                path: '/api/' + url,
+                method: method,
+                headers: headers
+            };
+        }
+        else {
+            options = {
+                host: this.host,
+                port: this.port,
+                path: '/api/' + url,
+                method: method
             };
-            var options;
-            if (params) {
-                options = {
-                    host: this.host,
-                    port: this.port,
-                    path: '/api/' + url,
-                    method: method,
-                    headers: headers
-                };
-            }
-            else {
-                options = {
-                    host: this.host,
-                    port: this.port,
-                    path: '/api/' + url,
-                    method: method
-                };
-            }
-            return yield this.invoke(params, options);
-        });
+        }
+        return await this.invoke(params, options);
     }
 }
-exports.BPMNClient = BPMNClient;
 class ClientEngine {
+    client;
     constructor(client) {
         this.client = client;
     }
-    start(name_1) {
-        return __awaiter(this, arguments, void 0, function* (name, data = {}, startNodeId = null, userId = null, options = {}) {
-            const ret = yield this.client.post('engine/start', { name, data, startNodeId, userId, options });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            const instance = ret;
-            return instance;
-        });
-    }
-    invoke(query_1, data_1) {
-        return __awaiter(this, arguments, void 0, function* (query, data, userId = null, options = {}) {
-            console.log('invoke', options);
-            const ret = yield this.client.put('engine/invoke', { query, data, userId, options });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            const instance = ret['instance'];
-            return instance;
-        });
-    }
-    assign(query_1, data_1) {
-        return __awaiter(this, arguments, void 0, function* (query, data, userId = null, assignment) {
-            const ret = yield this.client.put('engine/assign', { query, data, userId, assignment });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            const instance = ret['instance'];
-            return instance;
-        });
-    }
-    restart(query_1, data_1) {
-        return __awaiter(this, arguments, void 0, function* (query, data, userId = null, options = {}) {
-            console.log('invoke', options);
-            const ret = yield this.client.put('engine/restart', { query, data, userId, options });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            const instance = ret['instance'];
-            return instance;
-        });
-    }
-    throwMessage(messageId_1) {
-        return __awaiter(this, arguments, void 0, function* (messageId, data = {}, messageMatchingKey = {}) {
-            const ret = yield this.client.post('engine/throwMessage', { "messageId": messageId, "data": data, messageMatchingKey });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            return ret;
-        });
-    }
-    throwSignal(signalId_1) {
-        return __awaiter(this, arguments, void 0, function* (signalId, data = {}, messageMatchingKey = {}) {
-            const ret = yield this.client.post('engine/throwSignal', { "signalId": signalId, "data": data, messageMatchingKey });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            return ret;
-        });
+    async start(name, data = {}, startNodeId = null, userId = null, options = {}) {
+        const ret = await this.client.post('engine/start', { name, data, startNodeId, userId, options });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret;
+        return instance;
+    }
+    async invoke(query, data, userId = null, options = {}) {
+        console.log('invoke', options);
+        const ret = await this.client.put('engine/invoke', { query, data, userId, options });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'];
+        return instance;
+    }
+    async assign(query, data, userId = null, assignment) {
+        const ret = await this.client.put('engine/assign', { query, data, userId, assignment });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'];
+        return instance;
+    }
+    async restart(query, data, userId = null, options = {}) {
+        console.log('invoke', options);
+        const ret = await this.client.put('engine/restart', { query, data, userId, options });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        const instance = ret['instance'];
+        return instance;
+    }
+    async throwMessage(messageId, data = {}, messageMatchingKey = {}) {
+        const ret = await this.client.post('engine/throwMessage', { "messageId": messageId, "data": data, messageMatchingKey });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
     }
-    startEvent(instanceId_1, startNodeId_1) {
-        return __awaiter(this, arguments, void 0, function* (instanceId, startNodeId, data = {}, userId = null, options = {}) {
-            const ret = yield this.client.put('engine/startEvent', { "instanceId": instanceId, "startNodeId": startNodeId, "data": data, "userName": userId, "options": options });
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            return ret;
-        });
+    async throwSignal(signalId, data = {}, messageMatchingKey = {}) {
+        const ret = await this.client.post('engine/throwSignal', { "signalId": signalId, "data": data, messageMatchingKey });
+        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;
-        });
+    async startEvent(instanceId, startNodeId, data = {}, userId = null, options = {}) {
+        const ret = await this.client.put('engine/startEvent', { "instanceId": instanceId, "startNodeId": startNodeId, "data": data, "userName": userId, "options": options });
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
     }
-    status() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield this.client.get('engine/status', {});
-            if (ret['errors']) {
-                console.log(ret['errors']);
-                throw new Error(ret['errors']);
-            }
-            return ret;
-        });
+    async get(query) {
+        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'];
+        return instance;
+    }
+    async status() {
+        const ret = await this.client.get('engine/status', {});
+        if (ret['errors']) {
+            console.log(ret['errors']);
+            throw new Error(ret['errors']);
+        }
+        return ret;
     }
 }
-exports.ClientEngine = ClientEngine;
 class ClientDatastore {
+    client;
     constructor(client) {
         this.client = client;
     }
-    find(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ filter, sort, limit, after, projection, getTotalCount }) {
-            var res = yield this.client.get('datastore/find', { filter, after, limit, sort, projection, getTotalCount });
-            if (res.error) {
-                console.log(res.error);
-                throw new Error(res.error);
-                throw new Error(res['errors']);
-            }
-            return res;
-        });
+    async find({ filter, sort, limit, after, projection, lastItem, latestItem, getTotalCount }) {
+        var res = await this.client.get('datastore/find', { filter, after, limit, sort, projection, lastItem, latestItem, getTotalCount });
+        if (res.error) {
+            console.log(res.error);
+            throw new Error(res.error);
+            throw new Error(res['errors']);
+        }
+        return res;
     }
-    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;
-        });
+    async findItems(query) {
+        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'];
+        return items;
     }
-    findInstances(query_1) {
-        return __awaiter(this, arguments, void 0, function* (query, projection = {}) {
-            const res = yield this.client.get('datastore/findInstances', { query, projection });
-            if (res['errors']) {
-                console.log(res['errors']);
-                throw new Error(res['errors']);
-            }
-            const instances = res['instances'];
-            return instances;
-        });
+    async findInstances(query, projection = {}) {
+        const res = await this.client.get('datastore/findInstances', { query, projection });
+        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/deleteInstances', query);
-        });
+    async deleteInstances(query) {
+        return await this.client.del('datastore/deleteInstances', query);
     }
 }
-exports.ClientDatastore = ClientDatastore;
 class ClientDefinitions {
+    client;
     constructor(client) {
         this.client = client;
     }
-    import(name_1, pathToBPMN_1) {
-        return __awaiter(this, arguments, void 0, function* (name, pathToBPMN, pathToSVG = null) {
-            var options = {
-                'method': 'POST',
-                'host': this.client.host,
-                'port': this.client.port,
-                'path': '/api/definitions/import/' + name,
-                'headers': {
-                    'x-api-key': this.client.apiKey
-                },
-                'maxRedirects': 20
-            };
-            console.log('import ', name, pathToBPMN, pathToSVG);
-            var res = yield this.client.upload(name, pathToBPMN, pathToSVG, options);
-            console.log('import done ', res);
-            this.checkErrors(res);
-            return res;
-        });
-    }
-    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;
-        });
+    async import(name, pathToBPMN, pathToSVG = null) {
+        var options = {
+            'method': 'POST',
+            'host': this.client.host,
+            'port': this.client.port,
+            'path': '/api/definitions/import/' + name,
+            'headers': {
+                'x-api-key': this.client.apiKey
+            },
+            'maxRedirects': 20
+        };
+        console.log('import ', name, pathToBPMN, pathToSVG);
+        var res = await this.client.upload(name, pathToBPMN, pathToSVG, options);
+        console.log('import done ', res);
+        this.checkErrors(res);
+        return res;
+    }
+    async list() {
+        var res = await this.client.get('definitions/list', []);
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        return res;
     }
-    delete(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.post('definitions/delete/', { name });
-            if (res['errors']) {
-                console.log(res['errors']);
-                throw new Error(res['errors']);
-            }
-            console.log(res);
-            return res;
-        });
+    async delete(name) {
+        const res = await this.client.post('definitions/delete/', { name });
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        console.log(res);
+        return res;
     }
-    rename(name, newName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.post('definitions/rename/', { name, newName });
-            if (res['errors']) {
-                console.log(res['errors']);
-                throw new Error(res['errors']);
-            }
-            console.log(res);
-            return res;
-        });
+    async rename(name, newName) {
+        const res = await this.client.post('definitions/rename/', { name, newName });
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        console.log(res);
+        return res;
     }
-    load(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.get(encodeURI('definitions/load/' + name), { name });
-            if (res['errors']) {
-                console.log(res['errors']);
-                throw new Error(res['errors']);
-            }
-            console.log(res);
-            return res;
-        });
+    async load(name) {
+        const res = await this.client.get(encodeURI('definitions/load/' + name), { name });
+        if (res['errors']) {
+            console.log(res['errors']);
+            throw new Error(res['errors']);
+        }
+        console.log(res);
+        return res;
     }
     checkErrors(res) {
         if (res['errors']) {
@@ -303,4 +251,5 @@ class ClientDefinitions {
         }
     }
 }
-exports.ClientDefinitions = ClientDefinitions;
+export { BPMNClient, ClientEngine, ClientDatastore, ClientDefinitions };
+//# sourceMappingURL=BPMNClient.js.map