ZEN Engine Documentation

ZEN Engine is a cross-platform, Open-Source Business Rules Engine (BRE) written in Rust. It is designed to be embedded into applications to execute business logic defined via the JSON Decision Model (JDM).

Users provide the JDM logic as JSON content (from a file, database, or service), and the engine parses and executes it against provided inputs.

GoRules JDM is a modeling framework where decision models are represented as interconnected graphs in JSON format. These graphs capture relationships between decision points, conditions, and outcomes.

Graph Structure

• Input Node (Request): The entry point for all data relevant to the context.
• Output Node (Response): The final result of the decision-making process.
• Nodes & Edges: Nodes represent decision logic, while edges act as pathways moving information through the graph (typically from left to right).

Core Node Types

• Decision Table Node: Structured rules (spreadsheet-like).
• Switch Node: Dynamic branching based on conditions.
• Function Node: JavaScript-based data manipulation.
• Expression Node: Transformation using ZEN Expression Language.
• Decision Node: Reuses other decision models (modularization).

Loaders are responsible for retrieving DecisionContent (JSON Decision Models) based on a key. ZEN Engine provides several pre-made loaders:

• FilesystemLoader: Loads decisions from a filesystem path relative to a specified root.
• MemoryLoader: Uses a HashMap as a key-value store for decisions.
• ClosureLoader: Uses an async callback function that takes a key and returns an Arc<DecisionContent>.
• NoopLoader: The default loader; it fails to load decisions and is primarily used to allow the create_decision API to remain consistent across different language bindings.

The Expression node transforms input objects into alternative objects using the ZEN Expression Language.

To define the output, you must specify individual rows for each property. Each row requires:

1. Key: The qualified name of the output property.
2. Value: The value expressed through the ZEN Expression Language.

Warning: Any errors occurring within an Expression node will cause the entire graph execution to halt.

The Switch node provides a dynamic branching mechanism. It allows the decision graph to diverge into different paths based on conditions written in the ZEN Expression Language.

Key Characteristics

• Data Preservation: The Switch node does not modify incoming data; it forwards the entire context to the output branch(es).
• Hit Policies:
  • first: The graph branches to the initial matching condition (similar to a table).
  • collect: The graph extends to all branches where conditions hold true.

Note: If multiple edges originate from the same condition, there is no guaranteed order of execution.

Available from: Python 0.16.0, NodeJS 0.13.0, Rust 0.16.0, Go 0.1.0

Function nodes allow for quick data parsing, re-mapping, or modification using JavaScript snippets. These snippets are executed on top of the QuickJS Engine bundled with the ZEN Engine.

Implementation Details

• Arguments: The node's inputs are provided as arguments to the function.
• Timeout: Function execution is capped at 50ms.
• Built-in Libraries:
  • dayjs: For date manipulation.
  • big.js: For arbitrary-precision decimal arithmetic.

Example Usage

const handler = (input, {dayjs, Big}) => {
    return {
        ...input,
        someField: 'hello'
    };
};

The Switch node allows a decision model to diverge into different paths based on conditions written in the ZEN Expression Language. It preserves the incoming data without modification, forwarding the entire context to the output branches.

Hit Policies:

• first: The graph branches to the first matching condition.
• collect: The graph extends to all branches where conditions hold true (multiple paths).

Note: If multiple edges exist from the same condition, execution order is not guaranteed.

Supported Versions:

• Python 0.16.0+
• NodeJS 0.13.0+
• Rust 0.16.0+
• Go 0.1.0+

GoRules JDM is a modeling framework where decision models are represented as interconnected graphs in JSON format.

Graph Structure:

• Nodes: The building blocks of the graph (Decision Table, Switch, Function, Expression, and Decision nodes).
• Edges: Pathways that move information from one node to another, typically flowing from left to right.
• Input Node (Request): The entry point for all data relevant to the context.
• Output Node (Response): The final result of the decision-making process.

Data flows from the Input Node through the interconnected nodes, undergoing evaluation at each step, until it reaches the Output Node.