What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

Camunda is a versatile platform for business process automation. Learn how to seamlessly integrate decision tables with Camunda 8 and Node.js, enabling efficient workflow management with DMN.

What is Camunda?

Camunda is an open-source software company that provides a platform for workflow and decision automation. The Camunda platform is built on top of BPMN (Business Process Model and Notation), DMN (Decision Model and Notation), and CMMN (Case Management Model and Notation) standards, making it suitable for modeling, executing, monitoring, and optimizing business processes and decisions.
Camunda offers several products and tools, including:

Camunda BPM:

This is the core product that allows users to model, deploy, and manage business processes using BPMN 2.0. It provides features for process automation, such as task assignment, workflow management, and process monitoring.

Camunda DMN Engine:

This component enables the modeling and execution of decision tables using the DMN standard. It allows businesses to define and automate decision-making processes within their applications.

Camunda CMMN Engine:

CMMN (Case Management Model and Notation) is used for defining and automating case management processes. Camunda provides an engine to execute CMMN models, allowing for dynamic case handling and ad-hoc task management.

Camunda Optimize:

This is an analytics and monitoring tool that helps organizations gain insights into their business processes. It provides dashboards and reports to visualize process performance, identify bottlenecks, and optimize processes for better efficiency.

Camunda Cloud:

Camunda also offers a cloud-based platform for deploying and managing Camunda BPM and related services. It provides scalability, reliability, and ease of deployment for organizations looking to leverage Camunda's capabilities without managing infrastructure themselves.
Overall, Camunda aims to empower businesses to automate their workflows, improve decision-making processes, and optimize their operations for better efficiency and agility. Being open-source, it also fosters a vibrant community of developers and contributors who extend and enhance its capabilities.

Introduction to Components of Camunda 8

This section provides comprehensive product manual content for each component within Camunda 8, including detailed conceptual explanations. Together, these components deliver the complete Camunda 8 SaaS experience.

Concepts:

Explore a diverse range of topics related to Camunda 8, including clusters, processes, job workers, workflow patterns, and more, through this conceptual documentation.

Console:

Utilize this management application to efficiently administer the included products, enabling tasks such as creating and deleting clusters, managing API clients and alerts, and more.

Modeler:

Harness Camunda's modeling tools, including Web Modeler and Desktop Modeler, to design and implement diagrams seamlessly.

Connectors:

Seamlessly integrate with external systems using these reusable building blocks, facilitating smooth interoperability.

Zeebe:

Leverage this powerful process automation engine to graphically define processes in BPMN 2.0, implement workers in any gRPC-supported programming language, and build processes that respond to events from Apache Kafka, among other functionalities.

Operate:

Monitor and troubleshoot process instances running in Zeebe, enabling essential operations such as incident resolution and updating process instance variables.

Tasklist:

Drive business processes alongside user tasks in Zeebe, orchestrating critical human workflows to expedite time-to-value for process orchestration projects through this intuitive interface for manual work.

Optimize:

Tailored for business stakeholders, Optimize provides business intelligence tooling for Camunda enterprise customers. By leveraging data collected during process execution, users can collaboratively analyze areas within business processes for enhancement.

Camunda components and architecture

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

In this article

In this article we will do following things

Create a Zeebe docker container

Create a test DMN to evaluate with Nodejs

Write code to get the data from Camunda 8 and test DMN

Create a Zeebe docker container

Zeebe is the singular component often deployed independently as a standalone unit. In this configuration, it operates autonomously, requiring only a simple Docker run command to initiate.

docker run --name zeebe -p 26500-26502:26500-26502 camunda/zeebe:latest

This command sets up a single broker node with specific ports exposed:
26500: Gateway API (utilized by clients)
26501: Command API (internal, gateway-to-broker)
26502: Internal API (internal, broker-to-broker)
Upon execution, your Docker client will automatically fetch the appropriate image for your platform.
For further insights, refer to the following link: https://docs.camunda.io/docs/self-managed/platform-deployment/docker/
Let's run the above docker command

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

Create a test DMN to evaluate with Nodejs

Decision Model and Notation (DMN) is a modeling methodology established by the Object Management Group (OMG), the same institution behind BPMN global standards. DMN facilitates the modeling and execution of decisions in a language comprehensible to both business analysts and developers.
Let's create a file with name "test.dmn" and following codes:
test.dmn

                        <?xml version="1.0" encoding="UTF-8"?>
                        <definitions xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/"
                          xmlns:dmndi="https://www.omg.org/spec/DMN/20191111/DMNDI/" xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/"
                          xmlns:modeler="http://camunda.org/schema/modeler/1.0" id="Definitions_0aa9d4b" name="DRD"
                          namespace="http://camunda.org/schema/1.0/dmn" exporter="Camunda Modeler" exporterVersion="5.12.1"
                          modeler:executionPlatform="Camunda Cloud" modeler:executionPlatformVersion="8.2.0">
                          <decision id="Decision_108bhbw" name="Test">
                            <decisionTable id="DecisionTable_0uuyuh7" hitPolicy="FIRST">
                              <input id="Input_1" label="test">
                              <inputExpression id="InputExpression_1" typeRef="string">
                                <text>test</text>
                              </inputExpression>
                              </input>
                              <output id="Output_1" label="test" name="test" typeRef="string" />
                              <rule id="DecisionRule_05q9ft7">
                                <inputEntry id="UnaryTests_0a2ca7i">
                                  <text>"test"</text>
                                </inputEntry>
                                <outputEntry id="LiteralExpression_0hg1xso">
                                  <text>"test"</text>
                                </outputEntry>
                              </rule>
                            </decisionTable>
                          </decision>
                          <dmndi:DMNDI>
                            <dmndi:DMNDiagram>
                              <dmndi:DMNShape dmnElementRef="Decision_108bhbw">
                                <dc:Bounds height="80" width="180" x="160" y="100" />
                              </dmndi:DMNShape>
                            </dmndi:DMNDiagram>
                          </dmndi:DMNDI>
                        </definitions>
                        

This is how it look like in camunda modeler

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

What this DMN does?

Overall, this DMN file defines a simple decision model with one input variable ("test"), one output variable ("test"), and one decision rule that returns "test" when the input value is "test."

Write code to get the data from Camunda 8 and test DMN

Let's create a file with name "index.js" and following codes:
index.js

                          const ZB = require('zeebe-node');
                          
                          void (async () => {
                            const zbc = new ZB.ZBClient('localhost:26500'); // localhost:26500 || ZEEBE_GATEWAY_ADDRESS
                            const result = await zbc.deployResource({
                              decisionFilename: 'test.dmn',
                            });
                            console.log("result:",JSON.stringify(result));
                            
                            const outcome = await zbc.evaluateDecision({
                              decisionId: 'Decision_108bhbw',
                              variables: {
                                test: 'test',
                              },
                            });
                            console.log('Process outcome', outcome);
                          })();
                    
                        

Let's understand the codes:

This code is written in JavaScript and utilizes the zeebe-node library to interact with the Zeebe workflow engine.
Here's what each part of the code does:

const ZB = require('zeebe-node');

This line imports the zeebe-node module, which allows interaction with Zeebe from a Node.js environment.

void (async () => { ... })();

This line defines an immediately invoked async function. This construct is used to create an asynchronous context for executing the code inside. The void keyword is used to explicitly discard any return value from the function, ensuring that it does not affect the surrounding code execution.

const zbc = new ZB.ZBClient('localhost:26500');

This line creates a new ZBClient instance, which establishes a connection to the Zeebe gateway running at localhost:26500. The Zeebe gateway is the entry point for client applications to communicate with the Zeebe cluster.

const result = await zbc.deployResource({ decisionFilename: 'test.dmn' });

This line deploys a DMN (Decision Model and Notation) file named 'test.dmn' to the Zeebe cluster using the ZBClient's deployResource method. It returns a result object containing information about the deployment.

const outcome = await zbc.evaluateDecision({ ... });

This line evaluates a decision with the specified decision ID ('Decision_108bhbw') using the ZBClient's evaluateDecision method. It provides input variables ({ test: 'test' }) for the decision evaluation.
In summary, this code demonstrates how to deploy a DMN file and evaluate a decision using the Zeebe workflow engine from a Node.js application.

Run the index.js

node index.js

Output:

What is Camunda and DMN? Integrate decision table with Camunda 8 and Nodejs

                        result:
                        {
                        "deployments": [
                            {
                                "decision": {
                                    "dmnDecisionId": "Decision_108bhbw",
                                    "dmnDecisionName": "Test",
                                    "version": 1,
                                    "decisionKey": "2251799813685250",
                                    "dmnDecisionRequirementsId": "Definitions_0aa9d4b",
                                    "decisionRequirementsKey": "2251799813685249",
                                    "tenantId": "<default>"
                                },
                                "Metadata": "decision"
                            },
                            {
                                "decisionRequirements": {
                                    "dmnDecisionRequirementsId": "Definitions_0aa9d4b",
                                    "dmnDecisionRequirementsName": "DRD",
                                    "version": 1,
                                    "decisionRequirementsKey": "2251799813685249",
                                    "resourceName": "test.dmn",
                                    "tenantId": "<default>"
                                },
                                "Metadata": "decisionRequirements"
                            }
                        ],
                        "key": "2251799813685255",
                        "tenantId": "<default>"
                    }
                    

The above output is for deployment on Zeebe. The DMN has deployed with dmnDecisionId "Decision_108bhbw".

Output for DMN input and output:

                    Process outcome {
                        "evaluatedDecisions": [
                            {
                                "matchedRules": [
                                    {
                                        "evaluatedOutputs": [
                                            {
                                                "outputId": "Output_1",
                                                "outputName": "test",
                                                "outputValue": "\"test\""
                                            }
                                        ],
                                        "ruleId": "DecisionRule_05q9ft7",
                                        "ruleIndex": 1
                                    }
                                ],
                                "evaluatedInputs": [
                                    {
                                        "inputId": "Input_1",
                                        "inputName": "test",
                                        "inputValue": "\"test\""
                                    }
                                ],
                                "decisionKey": "2251799813685250",
                                "decisionId": "Decision_108bhbw",
                                "decisionName": "Test",
                                "decisionVersion": 1,
                                "decisionType": "DECISION_TABLE",
                                "decisionOutput": "\"test\"",
                                "tenantId": "<default>"
                            }
                        ],
                        "decisionKey": "2251799813685250",
                        "decisionId": "Decision_108bhbw",
                        "decisionName": "Test",
                        "decisionVersion": 1,
                        "decisionRequirementsId": "Definitions_0aa9d4b",
                        "decisionRequirementsKey": "2251799813685249",
                        "decisionOutput": "\"test\"",
                        "failedDecisionId": "",
                        "failureMessage": "",
                        "tenantId": "<default>"
                    }
                    

The out is correct, this is what we were expecting

---

Conclusion:

In conclusion, Camunda and DMN (Decision Model and Notation) provide powerful tools for businesses seeking to streamline workflow management and decision-making processes. By integrating decision tables with Camunda 8 and Node.js, organizations can harness the capabilities of DMN to create efficient and scalable solutions. This integration empowers both business analysts and developers to collaborate effectively, ultimately driving improved operational efficiency and better-informed decision-making. As businesses continue to prioritize agility and automation, leveraging technologies like Camunda and DMN offers a strategic advantage in navigating complex and dynamic environments.

Related Keywords:

What is Camunda and DMN?

Integrate decision table with Camunda 8 and Nodejs

Workflow management with Camunda 8 and DMN

Introduction to Components of Camunda 8

Camunda components and architecture

Create a Zeebe docker container