@5minds/processcube_engine_client 4.3.1 → 4.4.0-develop-7c4bcb-lj4agef5

package/README.md

@@ -1,227 +1,165 @@
 # Engine Client.ts
 
-A client for communicating with the `Engine`.
+Ein NodeJS basierter Client zur Kommunikation mit der ProcessCube Engine.
 
-It is written in TypeScript and implemented in NodeJS.
+Codebeispiele zur Verwendung des Clients und der External Task Worker [finden sich hier](./samples).
 
-## Quick example
+## Schnelleinstieg
 
 ```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
+import { EngineClient } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  const processInstances = await client.processInstances.query({});
+const processInstancesInCorrelation = await client.processInstances.query({
+  correlationid: 'my-correlation-id',
+});
+```
 
-  console.log(processInstances);
-}
+## Wie kann ich den Client verwenden?
 
-run();
-```
+Man benötigt lediglich die URL der anzusteuernden Engine.
+Mit dieser lässt sich eine Instanz des Clients anlegen, die direkt verwendbar ist.
 
-## How to use the client
+Es gibt verschiedene Wege sich Clients anzulegen.
 
-You only need to provide an url to the `Engine` you want to access.
-After that, the client is ready to use.
+### EngineClient
 
-You can either create a single EngineClient, which exposes references to all other clients,
+Man kann eine Instanz des `EngineClients` direkt anlegen, welche die API der ProcessCube Engine vollständig abdeckt.
 
 ```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
+import { EngineClient } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  const processInstances = await client.processInstances.query({}, null, 0, 100);
+const processInstancesInCorrelation = await client.processInstances.query({
+  correlationid: 'my-correlation-id',
+});
+```
 
-  console.log(processInstances);
-}
+### Client Factory
 
-run();
-```
+Oder man kann sich über die Client Factory einen feature-spezifischen Client anlegen, der nur einen besimmten fachlichen Aspekt der ProcessCube Engine abdeckt.
 
-or create multiple specific clients with the ClientFactory:
+Beispiel:
 
 ```ts
-import {ClientFactory} from '@5minds/processcube_engine_client';
+import { ClientFactory } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const processInstanceClient = ClientFactory.createProcessInstanceClient(engineUri);
-
-  const processInstances = await processInstanceClient.query({}, null, 0, 100);
+const processInstanceClient = ClientFactory.createProcessInstanceClient(engineUri);
 
-  console.log(processInstances);
-}
-
-run();
+const processInstances = await processInstanceClient.query({
+  correlationid: 'my-correlation-id',
+});
 ```
 
-### Starting Process Instances
-
-You can start new Process Instances through `processDefinitionsClient.startProcessInstance(parameters)` -
-Resolves right after the Process Instance was started
-
-Where `parameters` is an object that collects all startup parameters.
-
-The following parameters are required:
-- `processModelId`: The ID of the Process Model to execute
-- `startEventId`: The ID of the Start Event by which to start the Process Model. Optional, if the Process Model only has one Start Event.
-
-In addition, the following optional parameters are available:
-- `correlationId`: The ID of the correlation to which this Process Instance belongs. If not provided, it will be auto-generated
-- `initialToken`: The initial process token with which to start the Process Instance
-- `parentProcessInstanceId`: When the Process Instance is supposed to be the Subprocess of another Process Instance,
-this contains the ID of the parent Process Instance
+Hier wird eine Client Instanz angelegt, welche lediglich die Interaktion mit Prozessinstanzen abdeckt.
 
-or through
+## Anwendungsbeispiele
 
-`processDefinitionsClient.startProcessInstanceAndAwaitEndEvent(parameters)` -
-Resolves when the Process Instance has finished with any End Event
+Nachfolgend werden ein paar der am häufigsten verwendeten Use Cases demonstriert.
 
-or through
+### Prozesse starten
 
-`processDefinitionsClient.startProcessInstanceAndAwaitSpecificEndEvent(parameters, endEventId)` -
-Resolves after the ProcessInstance has reached a specific End Event
-and has additionally the required endEventId parameter:
-- `endEventId`: The ID of the End Event to wait for
+Das Starten von Prozessinstanzen kann über die `EngineClient.processModels` Fachlichkeit realisiert werden.
 
-Examples:
+Prozesse lassen sich auf mehrere Arten starten.
 
-#### Start Process Instance and wait for it to start
+#### Einfacher Prozessstart
 
 ```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
+import { EngineClient } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  await client.processDefinitions.startProcessInstance({processModelId: 'myProcessModelId'});
-}
-
-run();
+await client.processModels.startProcessInstance({processModelId: 'myProcessModelId'});
 ```
 
-#### Start Process Instance and wait for it to finish
-
-```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
-
-const engineUri = 'http://localhost:10560';
-
-async function run() {
-  const client = new EngineClient(engineUri);
+Die `processModelId` ist der einzige erforderliche Parameter für diesen Request.
 
-  await client.processDefinitions.startProcessInstanceAndAwaitEndEvent({processModelId: 'myProcessModelId'});
-}
+Der Client wartet in diesem Szenario nur, bis die Engine den _Start_ des Prozesses bestätigt hat.
 
-run();
-```
+#### Konfigurierter Prozessstart
 
-#### Start Process Instance and wait for an End Event
+Neben der `processModelId` können folgende Paramter mitgegeben werden:
+- `startEventId`: Die ID des Start Events von welchem aus der Prozess losgehen soll
+    - **Hinweis:** Bei Prozessen mit mehreren Start Events ist dieser Parameter ebenfalls erforderlich!
+- `correlationId`: Gibt an, in welcher Correlation die Prozessinstanz laufen soll
+- `initialToken`: Der JSON-formatierte Prozess-Token, den die Prozessinstanz zu beginn besitzen soll
 
 ```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
+import { EngineClient } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  await client.processDefinitions.startProcessInstanceAndAwaitSpecificEndEvent({processModelId: 'myProcessModelId'}, 'My_End_Event_1');
-}
-
-run();
+await client.processModels.startProcessInstance({
+  processModelId: 'myProcessModelId',
+  startEventId: 'StartEvent_1',
+  correlationId: 'MyCorrelatioNid',
+  initialToken: {
+    hello: 'world',
+  },
+});
 ```
 
-#### Start Process Instance with custom payload and correlation ID
+#### Prozess starten und auf dessen Ende warten
 
 ```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
+import { EngineClient } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  await client.processDefinitions.startProcessInstance({
-    processModelId: 'myProcessModelId',
-    correlationId: 'my_custom_correlation_id',
-    initialToken: {
-      hello: 'world',
-    },
-  });
-}
-
-run();
-```
-
-#### Start Process Instance as a sub process
-
-```ts
-import {EngineClient} from '@5minds/processcube_engine_client';
-
-const engineUri = 'http://localhost:10560';
-
-async function run() {
-  const client = new EngineClient(engineUri);
-
-  await client.processDefinitions.startProcessInstance({
-    processModelId: 'myProcessModelId',
-    parentProcessInstanceId: 'Some-Other-Process-Instance-Id',
-  });
-}
-
-run();
+await client.processModels.startProcessInstanceAndAwaitEndEvent({processModelId: 'myProcessModelId'});
 ```
 
-### Code Samples
+Hier wartet der Client, bis die Engine den Prozess bis zum Ende ausgeführt hat.
 
-You can find [executable code samples here](./samples/client) and [here](https://github.com/atlas-engine/ClientSamples/tree/develop/Client.ts).
+Die Methode akzeptiert dieselben Parameter wie `processModels.startProcessInstance`.
 
 ## Query UserTasks
 
+Abfragen aller User Tasks eines bestimmten Prozesses, die sich in einem "suspended" State befinden:
+
 ```ts
-import {EngineClient, DataModels} from '@5minds/processcube_engine_client';
+import { EngineClient, DataModels } from '@5minds/processcube_engine_client';
 
 const engineUri = 'http://localhost:10560';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const client = new EngineClient(engineUri);
 
-  const userTasks = await client.userTasks.query({
-    processModelId: 'myProcessModelId',
-    state: DataModels.FlowNodeInstances.FlowNodeInstanceState.suspended,
-  });
+const userTasks = await client.userTasks.query({
+  processModelId: 'myProcessModelId',
+  state: DataModels.FlowNodeInstances.FlowNodeInstanceState.suspended,
+});
 
-  console.log(userTasks);
-}
-
-run();
+console.log(userTasks);
 ```
 
-## How to use External Task Workers
-
-An External Task worker is designed to process External Tasks associated with a BPMN ServiceTask.
+## External Task Worker
 
-### Basic
+External Task Worker werden dazu benutzt, um die an einer Prozessinstanz anfallenden `External Service Tasks` zu verarbeiten.
 
-You need to provide three arguments to a worker:
+Ein Worker benötigt minimal die folgenden 3 Einstellungen
+- Die URL der Ziel-Engine
+- Das Topic der abzuarbeitenden External Tasks
+- Eine Handler Funktion zum Verarbeiten der External Tasks
 
-- The url of the Engine where the worker should connect to
-- The topic by which to poll External Tasks
-- A handler function for processing the External Tasks
+Beispiel:
 
 ```ts
-import {EngineClient, DataModels} from '@5minds/processcube_engine_client';
+import { ExternalTaskWorker } from '@5minds/processcube_engine_client';
 
 interface AddPayload {
   number1: number;
@@ -235,49 +173,33 @@ interface AddResult {
 const engineUri = 'http://localhost:10560';
 const topic = 'sum_numbers';
 
-async function run() {
-  const client = new EngineClient(engineUri);
+const externalTaskWorker = new ExternalTaskWorker<AddPayload, AddResult>(url, topic, doAdd, config);
 
-  const externalTaskWorker = await client.externalTasks.subscribeToExternalTaskTopic(topic, doAdd);
-
-  externalTaskWorker.start();
-}
+externalTaskWorker.start();
 
 async function doAdd(
   payload: AddPayload,
   externalTask: DataModels.ExternalTasks.ExternalTask<AddPayload>,
 ): Promise<AddResult> {
-
   const result: AddResult = {
     sum: payload.number1 + payload.number2,
   };
 
-  console.log('Receive payload from process instance');
-  console.log(JSON.stringify(payload));
-
-  return Promise.resolve(result);
+  return result;
 }
 
-run();
-
 ```
 
-Note that by subscribing to a single topic, you create a specific worker for this topic.
-
-### Starting and stopping
-
-Start the worker with:
+Der Worker lässt sich mit folgendem Befehl starten:
 
 ```ts
 externalTaskWorker.start();
 ```
 
-And stop it with:
+und mit folgendem Befehl stoppen:
 
 ```ts
 externalTaskWorker.stop();
 ```
 
-### Code Samples
-
-You can find [executable code samples here](./samples/external_task_worker) and [here](https://github.com/atlas-engine/ClientSamples/tree/develop/Client.ts).
+Ein ausführbares Code-Beispiel [findet sich hier](./samples/external_task_worker/).

package/dist/amd/Types/index.js

@@ -22,7 +22,7 @@ define(["require", "exports", "@5minds/processcube_engine_sdk", "./CallbackTypes
         Messages.BpmnEvents = processcube_engine_sdk_1.Messages.BpmnEvents;
         Messages.SystemEvents = processcube_engine_sdk_1.Messages.SystemEvents;
         Messages.CallbackTypes = callbackTypes;
-    })(Messages = exports.Messages || (exports.Messages = {}));
+    })(Messages || (exports.Messages = Messages = {}));
     __exportStar(IExternalTaskWorker_1, exports);
     __exportStar(RestSettings_1, exports);
     __exportStar(SocketSettings_1, exports);

package/dist/amd/Types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;IAIA,uFAAuF;IACvF,IAAiB,QAAQ,CAMxB;IAND,WAAiB,QAAQ;QAGT,mBAAU,GAAG,iCAAW,CAAC,UAAU,CAAC;QACpC,qBAAY,GAAG,iCAAW,CAAC,YAAY,CAAC;QACxC,sBAAa,GAAG,aAAa,CAAC;IAC9C,CAAC,EANgB,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAMxB;IAMD,6CAAsC;IACtC,sCAA+B;IAC/B,wCAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;IAIA,uFAAuF;IACvF,IAAiB,QAAQ,CAMxB;IAND,WAAiB,QAAQ;QAGT,mBAAU,GAAG,iCAAW,CAAC,UAAU,CAAC;QACpC,qBAAY,GAAG,iCAAW,CAAC,YAAY,CAAC;QACxC,sBAAa,GAAG,aAAa,CAAC;IAC9C,CAAC,EANgB,QAAQ,wBAAR,QAAQ,QAMxB;IAMD,6CAAsC;IACtC,sCAA+B;IAC/B,wCAAiC"}

package/dist/commonjs/Types/index.js

@@ -23,7 +23,7 @@ var Messages;
     Messages.BpmnEvents = processcube_engine_sdk_1.Messages.BpmnEvents;
     Messages.SystemEvents = processcube_engine_sdk_1.Messages.SystemEvents;
     Messages.CallbackTypes = callbackTypes;
-})(Messages = exports.Messages || (exports.Messages = {}));
+})(Messages || (exports.Messages = Messages = {}));
 __exportStar(require("./IExternalTaskWorker"), exports);
 __exportStar(require("./RestSettings"), exports);
 __exportStar(require("./SocketSettings"), exports);

package/dist/commonjs/Types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2EAAyE;AAEzE,iDAAiD;AAEjD,uFAAuF;AACvF,IAAiB,QAAQ,CAMxB;AAND,WAAiB,QAAQ;IAGT,mBAAU,GAAG,iCAAW,CAAC,UAAU,CAAC;IACpC,qBAAY,GAAG,iCAAW,CAAC,YAAY,CAAC;IACxC,sBAAa,GAAG,aAAa,CAAC;AAC9C,CAAC,EANgB,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAMxB;AAMD,wDAAsC;AACtC,iDAA+B;AAC/B,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2EAAyE;AAEzE,iDAAiD;AAEjD,uFAAuF;AACvF,IAAiB,QAAQ,CAMxB;AAND,WAAiB,QAAQ;IAGT,mBAAU,GAAG,iCAAW,CAAC,UAAU,CAAC;IACpC,qBAAY,GAAG,iCAAW,CAAC,YAAY,CAAC;IACxC,sBAAa,GAAG,aAAa,CAAC;AAC9C,CAAC,EANgB,QAAQ,wBAAR,QAAQ,QAMxB;AAMD,wDAAsC;AACtC,iDAA+B;AAC/B,mDAAiC"}

package/package.json

@@ -1,43 +1,46 @@
 {
   "name": "@5minds/processcube_engine_client",
-  "version": "4.3.1",
+  "version": "4.4.0-develop-7c4bcb-lj4agef5",
   "description": "Contains a typescript based client for accessing the Engine.",
   "main": "dist/commonjs/index.js",
-  "typings": "dist/index.d.ts",
+  "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/atlas-engine/Client.ts.git"
   },
-  "author": "5Minds IT-Solutions GmbH & Co. KG",
+  "author": {
+    "name": "5Minds IT-Solutions GmbH & Co. KG",
+    "email": "info@5minds.de",
+    "url": "https://5minds.de/"
+  },
   "maintainers": [
     "Alexander Kasten <alexander.kasten@5minds.de>",
     "Christian Werner <christian.werner@5minds.de>",
-    "René Föhring <rene.foehring@5minds.de>",
-    "Steffen Knaup <steffen.knaup@5minds.de>"
+    "Sebastian Griesa <sebastian.griesa@5minds.de>"
   ],
   "license": "MIT",
+  "homepage": "https://github.com/atlas-engine/Client.ts#readme",
   "bugs": {
     "url": "https://github.com/atlas-engine/Client.ts/issues"
   },
-  "homepage": "https://github.com/atlas-engine/Client.ts#readme",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "clean-build": "npm run clean && npm run build",
+    "build": "npm run build-commonjs && npm run build-amd",
+    "build-commonjs": "tsc",
+    "build-amd": "tsc --module amd --outDir ./dist/amd",
+    "prepare": "npm run build",
+    "test": ":"
+  },
   "dependencies": {
     "@5minds/processcube_engine_sdk": "3.3.0",
     "@types/socket.io": "^2.1.13",
     "@types/socket.io-client": "^1.4.36",
-    "cross-fetch": "3.1.5",
+    "cross-fetch": "3.1.6",
     "socket.io-client": "2.5.0",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.4"
-  },
-  "scripts": {
-    "reinstall": "./reinstall.sh",
-    "clean": "rm -rf dist",
-    "build": "npm run clean && npm run build-commonjs && npm run build-amd",
-    "build-commonjs": "tsc",
-    "build-amd": "tsc --module amd --outDir ./dist/amd",
-    "prepare": "npm run build",
-    "test": ":"
+    "typescript": "^5.1.3"
   }
 }