29 Jan 23:23

bashizip

aab0b1c

Abada Engine v0.8.4-alpha Release Notes Latest

Latest

Abada Engine v0.8.4-alpha Release Notes

Release Date: January 30, 2026
Status: Alpha Release
Focus: Tenda MVP & Platform Integration

Overview

Version 0.8.4-alpha marks a significant milestone in the Abada Platform roadmap: the transition from a "headless" engine to an integrated platform. This release introduces the first version of Abada Tenda (Tasklist UI) and provides a much-improved development experience for building full-stack workflow applications.

Roadmap Context: This release fulfills the second milestone in the Roadmap to Beta, focusing on the end-user task lifecycle.

What's New

🖥️ Abada Tenda Integration (MVP)

The engine now supports the initial release of Abada Tenda, our specialized Tasklist UI.

Task Lifecycle: Full support for claiming, completing, and managing user tasks via the UI.
Variable Handling: Users can now view input variables and submit output variables directly through Tenda.
Seamless Setup: Docker Compose now includes Tenda as a first-class service, pre-configured to communicate with the engine.

🛠️ Enhanced Process Management

We've expanded the Engine API to provide better control over running processes:

New Statuses: Introduced CANCELLED and SUSPENDED states for process instances.
Management Endpoints: Added dedicated API endpoints for instance management and job control.
External Task Failures: Improved reporting for external task failures, including error messages and retry logic.

🏗️ Improved Developer Experience (DX)

Flexible Docker Strategy: New dedicated Dockerfile.prod and streamlined dev/prod configurations.
Sibling Project Integration: The build-and-run-dev.sh script now automatically detects and builds sibling projects (abada-tenda, abada-orun) if they are present in the workspace.
Sample Data Generation: A new utility to populate the engine with realistic sample processes, tasks, and history for testing and demos.

🧪 Advanced Instrumentation

Process Starter Tracking: Track who started a process and identify candidate starter groups.
PostgreSQL Support: Added production-ready PostgreSQL driver and configuration for containerized deployments.

Technical Implementation

Core Changes

Refactored JobController to move management endpoints to /v1/jobs.
Moved cockpit-specific endpoints to a dedicated controller for better separation of concerns.
Implemented process instance suspension and cancellation logic in the core engine.

Infrastructure Update

Updated docker-compose.yml to include abada-tenda and abada-orun services.
Added data-local directory for persistent local development data.
Optimized OTLP span exporters for better Jaeger integration.

Getting Started

Quick Start with Tenda

Pull the latest version:
```
./scripts/build-and-run-dev.sh
```
Access the Tasklist:
- Abada Tenda: http://localhost:5602
- Login with default dev credentials.
Generate Sample Data:
```
./scripts/generate-sample-data.sh
```

Documentation

Updated guides:

Roadmap to Beta: Updated progress and next steps.
API Documentation: documenting new management and job control endpoints.

Bug Fixes

Fixed duplicate container name issues in development scripts.
Resolved suspended status flag confusion in the process engine logic.
Fixed process starter tracking for anonymous starts.
Corrected Grafana dashboard datasource UIDs to be case-insensitive.

What's Next

According to the Roadmap to Beta, the next major focus will be:

v0.8.5-alpha: Orun MVP (Cockpit UI) - Focus on history APIs and process monitoring.
v0.9.0-alpha: End-to-End Validation - Hardening the platform with complex, real-world business scenarios.

Full Changelog: v0.8.3-alpha...v0.8.4-alpha

Assets 2

21 Nov 13:31

bashizip

0.8.3-alpha

0ebe0c7

[v0.8.3-alpha] Full Observability Stack

Release Date: November 21, 2025
Status: Alpha Release
Focus: Observability & Insights

Overview

Version 0.8.3-alpha introduces a comprehensive observability stack to the Abada Engine, providing deep visibility into runtime behavior and enabling effective production diagnostics. This release implements the three pillars of observability using industry-standard OpenTelemetry protocols and tools.

Roadmap Context: This release completes the first milestone in the Roadmap to Beta, establishing the observability foundation required for production-ready deployments.

What's New

🔍 Distributed Tracing

Full distributed tracing implementation using OpenTelemetry and Jaeger for end-to-end request tracking:

Automatic Instrumentation: HTTP requests are automatically traced via Spring Boot integration
Manual Instrumentation: Custom spans for all core engine operations:
- Process deployment and execution
- Task lifecycle (create, claim, complete, fail)
- Event correlation (messages, signals)
- Job scheduling and execution
Trace Context Propagation: Seamless context propagation across all operations
Rich Span Attributes: Detailed metadata including process IDs, task keys, user names, and correlation keys

Key Spans:

abada.process.deploy - Process definition deployment
abada.process.start - Process instance creation
abada.task.create/claim/complete - Task lifecycle operations
abada.event.correlate.message - Message event correlation
abada.event.broadcast.signal - Signal event broadcasting
abada.job.schedule/execute - Job operations

📊 Metrics Collection

Comprehensive metrics using Micrometer and Prometheus for performance monitoring:

Process Metrics

abada.process.instances.started - Total process instances started
abada.process.instances.completed - Total process instances completed
abada.process.instances.failed - Total process instances failed
abada.process.duration - Process execution duration histogram
abada.process.instances.active - Currently active process instances

Task Metrics

abada.tasks.created/claimed/completed/failed - Task lifecycle counters
abada.task.waiting_time - Time from creation to claim (SLA tracking)
abada.task.processing_time - Time from claim to completion
abada.tasks.active - Currently active tasks

Event Metrics

abada.events.published/consumed/correlated - Event processing counters

Job Metrics

abada.jobs.executed/failed - Job execution counters
abada.job.execution_time - Job execution duration

All metrics include appropriate labels for filtering and aggregation (e.g., process.definition.id, task.definition.key, event.type).

📝 Centralized Log Aggregation

Structured logging with Loki and Promtail for centralized log management:

File-Based Collection: Promtail tails application log files and forwards to Loki
Trace Correlation: Automatic inclusion of traceId and spanId in all log entries
Structured Logging: JSON-formatted logs with rich metadata
Efficient Storage: Label-based indexing for fast queries and lower storage costs
Retention Policy: 14-day log retention with configurable limits
High Volume Support: Configured for 50MB/s ingestion rate

Log Format:

2024-01-15 10:30:45.123 [thread] INFO [traceId,spanId] logger - message

📈 Grafana Dashboards

Two pre-built Grafana dashboards for real-time monitoring:

1. Abada Engine Overview Dashboard

Located at monitoring/grafana/dashboards/abada-engine-overview.json

Provides high-level system health metrics:

Process execution rates and completion statistics
Task throughput and performance
Event processing metrics
System health indicators

2. Task Details Dashboard

Located at monitoring/grafana/dashboards/abada-task-details.json

Offers detailed task-level insights:

Task waiting and processing time distributions (p50, p95, p99)
Task creation and completion rates by type
Success/failure ratios with visual indicators
Completion rate gauges with threshold alerts

🏗️ Infrastructure Components

Complete observability stack deployment via Docker Compose:

OpenTelemetry Collector: Central telemetry data collection and routing
Jaeger: Distributed tracing backend and UI (port 16686)
Prometheus: Metrics storage and querying (port 9090)
Loki: Log aggregation and storage (port 3100)
Promtail: Log collection agent
Grafana: Unified visualization platform (port 3000)

All components are pre-configured and ready to use with docker compose up.

Technical Implementation

Dependencies Added

<!-- OpenTelemetry -->
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-spring-boot-starter</artifactId>
    <version>2.21.0</version>
</dependency>

<!-- Micrometer OTLP Registry -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-otlp</artifactId>
    <version>1.15.4</version>
</dependency>

<!-- OpenTelemetry Logback Appender -->
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-logback-appender-1.0</artifactId>
    <version>2.10.0-alpha</version>
</dependency>

<!-- Logstash Logback Encoder -->
<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>8.0</version>
</dependency>

Configuration Files

logback-spring.xml: Logging configuration with file appender and trace correlation
docker/otel-collector-config.yml: OpenTelemetry Collector pipeline configuration
docker/loki-config-dev.yaml: Loki storage and ingestion configuration
docker/promtail-config.yaml: Promtail log collection configuration

Core Components

ObservabilityConfig: Central OpenTelemetry SDK configuration
EngineMetrics: Centralized metrics management for all engine operations
Manual Instrumentation: Custom spans and metrics in core engine components

Getting Started

Quick Start

Start the observability stack:
```
docker compose up -d
```
Access the dashboards:
- Grafana: http://localhost:3000 (admin/admin)
- Jaeger: http://localhost:16686
- Prometheus: http://localhost:9090
Import Grafana dashboards:
- Navigate to Grafana → Dashboards → Import
- Upload monitoring/grafana/dashboards/abada-engine-overview.json
- Upload monitoring/grafana/dashboards/abada-task-details.json
Configure data sources (if not auto-provisioned):
- Prometheus: http://prometheus:9090
- Jaeger: http://jaeger:16686
- Loki: http://loki:3100

Querying Logs

Use LogQL in Grafana Explore:

# All logs from abada-engine
{service_name="abada-engine"}

# Filter by log level
{service_name="abada-engine"} | json | level="ERROR"

# Logs for a specific trace
{service_name="abada-engine"} | json | traceId="abc123def456"

# Search for specific text
{service_name="abada-engine"} |= "process instance"

Trace-to-Logs Workflow

Find a trace in Jaeger (http://localhost:16686)
Copy the trace ID

In Grafana Explore, query Loki:

{service_name="abada-engine"} | json | traceId="<paste-trace-id>"

View all logs associated with that specific request

Documentation

New and updated documentation:

observability-implementation.md: Implementation overview and testing guide
observability-reference-guide.md: Comprehensive reference for all observability features
loki-integration-walkthrough.md: Step-by-step Loki integration guide

Breaking Changes

None. This release is fully backward compatible with v0.8.2-alpha.

Bug Fixes

Fixed Loki permission denied errors in Docker containers
Resolved file appender conflicts in test environments (logs now only write to files in non-test profiles)
Fixed Grafana dashboard provisioning configuration

Known Issues

Loki ingestion rate limits may need tuning for very high-volume deployments (currently set to 50MB/s)
Some log queries in Grafana may be slow for large time ranges (use smaller time windows for better performance)

Performance Impact

The observability stack has minimal performance overhead:

Memory: ~1MB per 1000 active spans
CPU: <1% overhead with default sampling (100% in development)
Network: Batch exports minimize bandwidth usage
Storage: Logs retained for 14 days, metrics for 15 days (configurable)

For production deployments, consider:

Reducing trace sampling to 1-10% for high-traffic scenarios
Adjusting log retention based on compliance requirements
Tuning batch export settings for optimal performance

Upgrade Instructions

From v0.8.2-alpha

Update dependencies:
```
mvn clean install
```
Update Docker Compose:
```
docker compose pull
doc...
```

Assets 3

19 Oct 00:48

bashizip

0.8.2-alpha

1875156

abada-engine-0.8.2-alpha

Release Notes: Version 0.8.2-alpha

This release introduces several significant enhancements to the Abada Engine, focusing on observability, status management, and API robustness.

✨ Features

User Statistics Endpoint: A new endpoint has been added to provide comprehensive statistics about user activities, such as the number of completed tasks.
Explicit Status Models: The engine now uses explicit status models for processes and tasks, providing clearer and more consistent state management.
Date Tracking for Tasks: The task lifecycle now includes startDate and endDate attributes, allowing for better tracking and auditing of task execution times.
Improved API Error Handling: The REST API now includes more specific error handling for invalid IDs and other common issues, improving the developer experience.
Global Exception Handling: A global exception handler has been implemented to ensure that all engine errors are consistently reported through the API.
Standardized API Responses: API responses have been standardized to provide a more consistent and predictable interface.

🐞 Fixes

Null Pointer Exception: Fixed a critical null pointer exception that could occur during process execution.

⚠️ Known Issues

There are no known issues in this release.

What's Changed

Dev by @bashizip in #59
Service External Tasks by @bashizip in #60
Dev by @bashizip in #61
Dev by @bashizip in #62
dev by @bashizip in #64
Dev by @bashizip in #65

Full Changelog: v.0.7.0-alpha...0.8.2-alpha

Contributors

bashizip

Assets 2

18 Sep 03:20

bashizip

v.0.7.0-alpha

2546c1c

abada-engine-0.7.0-alpha

Abada Engine Release Notes - Version 0.7.0-alpha

This is a major feature release for the Abada Engine, introducing comprehensive support for advanced BPMN 2.0 constructs, including multiple gateway types and a new event-driven architecture. This release significantly enhances the engine's ability to model and execute complex, real-world business processes.

✨ Major Features

1. Parallel Gateway Support (`<parallelGateway>`)

The engine now fully supports BPMN Parallel Gateways for both forking and joining execution paths.

Forking: A splitting parallel gateway will unconditionally create a new, concurrent path of execution for every outgoing sequence flow.
Joining: A joining parallel gateway will wait until a token has arrived from every incoming sequence flow before the process continues.

2. Inclusive Gateway Support (`<inclusiveGateway>`)

The engine now supports BPMN Inclusive Gateways, allowing for conditional parallel execution.

Forking: A splitting inclusive gateway evaluates the conditions on its outgoing flows. It will create a new, concurrent path for each flow whose condition evaluates to true. If no conditions match, the default flow is taken.
Joining: A joining inclusive gateway will wait for all tokens that were created by the corresponding splitting gateway to arrive before proceeding.

3. Event-Based Gateway Foundation

A new, extensible event-driven architecture has been implemented to allow processes to pause and wait for external stimuli. This includes:

A new EventManager service responsible for registering waiting process instances and correlating incoming events.
A new JobScheduler service, backed by a persistent database table (jobs), for handling time-based events.

4. Message Event Support (`<intermediateCatchEvent>`)

Processes can now wait for a specific, named message correlated to that instance.

Point-to-Point Communication: A process instance can pause its execution until an external system delivers a message with a matching correlationKey.
API: The EventManager.correlateMessage() method provides the entry point for external systems to deliver these messages.

5. Timer Event Support (`<intermediateCatchEvent>`)

Processes can now include time-based delays.

Persistent Scheduling: When a process reaches a timer event, a persistent job is created in the database.
Automatic Resumption: The JobScheduler runs periodically in the background, automatically resuming processes when their timers are due.
ISO 8601 Durations: Timer durations are specified using the standard ISO 8601 format (e.g., PT10S for 10 seconds, PT5M for 5 minutes).

6. Signal Event Support (`<intermediateCatchEvent>`)

The engine now supports broadcast-style communication using signals.

One-to-Many Broadcast: A single signal, when broadcast, will be received by all process instances currently waiting for that signal name.
API: The EventManager.broadcastSignal() method provides the entry point for broadcasting signals.

🐛 Fixes & Improvements

Core Engine Refactoring: The ProcessInstance model was fundamentally refactored to support multiple concurrent execution paths (activeTokens), providing the foundation for all parallel and inclusive gateway logic.
Corrected Parallel Execution Logic: Fixed a critical bug where completing a task on one parallel branch would incorrectly cause duplicate tasks to be created on other waiting branches. The engine now correctly isolates execution paths.
Parser Improvements: The BpmnParser has been enhanced to correctly recognize and parse generic <task> elements, treating them as user tasks. It was also updated to parse <messageEventDefinition>, <timerEventDefinition>, and <signalEventDefinition>.
Circular Dependency Resolution: Resolved a complex circular dependency between the AbadaEngine and the new JobScheduler by correctly applying lazy initialization (@Lazy), allowing the application context to load successfully.
Test Suite Regressions: Fixed multiple compilation errors and regressions in the existing test suite (ProcessInstanceAdvanceTest, ProcessDefinitionTest) that were caused by data model updates.
Bug Fix: Corrected a bug in ParsedProcessDefinition where helper methods for retrieving candidate users and groups were missing a variable declaration.

📚 Documentation

Event-Based Gateway Design: A new architectural document (docs/event-based-gateways-design.md) has been created, outlining the design and implementation plan for all event types.
Process Variable Behavior: A new document (docs/process-variables.md) has been added to clarify the lifecycle of process variables and explain the "Initial User Task Pattern" best practice.
Configuration Review: A formal review of the project's configuration (docs/project-configuration-review.md) was conducted and documented, identifying potential security and maintainability improvements for future releases.

⚠️ Scope for This Release

Conditional Events: As per a strategic decision, the Conditional Event type was not implemented in this release and is deferred to a future version.
Configuration Issues: The issues identified in the configuration review (e.g., empty database password in dev, running as root in Docker) have been acknowledged but are deferred for a future hardening phase.

Assets 2

15 Sep 20:03

bashizip

v.0.6.3-alpha

6d09fc7

abada-engine 0.6.3-alpha

This release brings full support of Inclusive gateways.

What's Changed

Inclusive GW full implementation by @bashizip in #53

Full Changelog: v.0.6.2-alpha...v.0.6.3-alpha

Contributors

bashizip

Assets 2

22 Aug 03:13

bashizip

v.0.6.2-alpha

e66588c

abada-engine 0.6.2-alpha — Release Notes

A medium, focused release that introduces Exclusive Gateway (XOR) routing and tightens the process advancement model. This is an early alpha intended for feedback and iteration.

✨ Highlights

Exclusive Gateway (XOR) execution with expression conditions and default flow.
Robust condition evaluation: Camunda-style ${...} expressions normalized and evaluated (JS/Nashorn) against process variables.
Deterministic routing: first true condition wins; if none match, the gateway’s default flow is taken; otherwise the engine fails fast.

🔧 Changes & Improvements

Engine

ProcessInstance.advance(...)
- Default mode stops at the next User Task (for process start).
- New overload: advance(boolean skipCurrentIfUserTask); when true, the engine steps past the current user task (used right after completion) so conditions/gateways evaluate correctly.
- End-of-process now sets currentActivityId = null; isCompleted() reflects completion reliably.
Gateway selection (GatewaySelector)
- Evaluates sequence flow conditions in model order.
- Chooses the first condition that returns true; otherwise uses defaultFlowId.
Condition evaluation (ConditionEvaluator)
- Normalizes <![CDATA[...]]> and ${ ... } wrappers, translates and/or/eq/ne to JS, binds variables, and evaluates safely.
Variable timing
- Variables provided with task completion are merged before advancing, so gateways can see them (e.g., { "goodOne": true }).

API

POST /v1/tasks/complete?taskId=... now accepts an optional JSON body (map of variables) used during the immediate advance.
GET /v1/processes/instance/{id} returns a lean DTO (id, currentActivityId, variables, waiting/completed flags) to improve client compatibility and avoid heavy graph serialization.

Tests & Samples

EngineIntegrationTest verifies start → first user task → gateway routing on completion with variables.
TaskApiTest posts variables on completion to exercise gateway paths.
Added a focused ProcessInstanceAdvanceTest to validate in-memory models without full deployment.

Documentation

New doc: docs/exclusive-gateway.md (design & implementation notes: semantics, model, parsing, evaluator, selection, testing).
README simplified and aligned with current state; minimal quick start.

🛠️ Migration Notes

Task completion: if your process branches on a gateway after a user task, send variables in the complete call:
```
POST /abada/api/v1/tasks/complete?taskId=<id>
Content-Type: application/json
{
  "goodOne": true
}
```
Process instance API: clients reading /v1/processes/instance/{id} should map to the new DTO shape. If you relied on the domain ProcessInstance, use the new fields (id, currentActivityId, variables, waitingForUserTask, completed).
Start & complete semantics: engine start uses advance(false) (stop at first user task); completion uses advance(true) (step past current user task). If you wrote custom drivers around the core, mirror this pattern.

🐞 Fixes

Correctly updates currentActivityId on end and pass‑through nodes.
Fixed inverted conditions in the sample recipe-cook.bpmn and ensured gateway evaluation consumes variables merged on completion.
Resolved getter mismatch for SequenceFlow (getTargetRef() used consistently).

⚠️ Known Limitations (Alpha)

Inclusive and Parallel gateways are not implemented.
Condition evaluation uses Nashorn per-evaluation engine; fine for small loads but not optimized for hot paths. Future plan: pluggable expression engine.
Service Tasks remain a stub.

📦 Artifacts

Docker image: ghcr.io/bashizip/abada-engine:0.6.2-alpha
JAR: build from source (mvn -DskipTests=false clean package).

✅ Verification checklist

Deploy recipe-cook.bpmn, start processId=recipe-cook.
List tasks → first user task assigned to alice.
Complete with { "goodOne": true } → next task appears on the "good" branch (e.g., Bob’s).
Repeat with { "goodOne": false } → default branch taken.

🗺️ Roadmap (next)

Inclusive Gateway (OR) semantics (fork/join accounting).
Service Task SPI and execution.
History/audit trail.
Packaging to Maven Central & a minimal web console.

🙌 Thanks

Thanks to everyone testing and filing issues. Feedback on the XOR gateway and the advance(...) model is especially welcome in this alpha.

Assets 2

14 May 01:29

bashizip

v.0.6.1-alpha

12127de

BPMN-IO models full compatibility and validation

feat: add BPMN validation using Camunda model API (#issue-id)

Summary

This pre-release introduces BPMN schema validation and refactors the engine's parsing logic to align with Camunda's BPMN model structure.

✅ Implemented

Camunda-based validation
- Introduced CamundaSchemaValidator using Bpmn.readModelFromStream
- Validates structure (process, startEvent, userTasks, flows) before parsing
Refactored BpmnParser
- Migrated from DOM to Camunda Model API
- Extracts process metadata, tasks, flows with camunda:* support
Model class updates
- ParsedProcessDefinition with flow graph and runtime helpers
- TaskMeta now includes formKey, dueDate, priority, documentation (future use)
- SequenceFlow supports name and conditionExpression
Tests
- BpmnSchemaValidatorTest: verifies valid Camunda-modeled XML
- BpmnParserTest: confirms structure parsing
- EngineIntegrationTest: end-to-end task routing with assignee/group logic
- AbadaEnginePersistenceReloadTest: ensures task visibility survives memory wipe

✅ Compatibility

Supports Camunda Modeler and bpmn.io-style diagrams
Handles camunda:assignee, candidateUsers, candidateGroups
Compatible with future schema extensions

Assets 2

30 Apr 14:19

bashizip

v.0.5.0-alpha

de7adf7

v.0.5.0-alpha: Merge pull request #28 from bashizip/dev

🚀 Abada Engine 0.5.0-alpha is out!

This release introduces true state persistence and runtime recovery — processes and tasks now survive restarts, with automatic reload at startup.

🆕 Highlights:

🧠 Clean process orchestration using advance() and UserTaskPayload
💾 Persistent storage for process instances and tasks (H2/JDBC)
🔁 State reload after reboot via StateReloadService
👀 Completed tasks are automatically excluded from visibility queries
🧪 Integration-tested flow: Alice → Bob → process completion
🔁 Auto-deploy simple-two-task.bpmn in dev profile

🌐 New API Endpoints

GET /engine/processes – List deployed processes
GET /engine/processes/{id} – View process metadata and BPMN
GET /engine/processes/{id}/diagram – Raw BPMN XML for rendering (bpmn-js)

📚 New Internal Documentation

/docs/persistence.md explains how:
- Process and task state is stored
- BPMN XML is reloaded at startup
- Recovery works after crashes or restarts
- Current limitations and roadmap

Next up: embedded engine support, BPMN editing via UI, and support for service tasks ✨

🔗 Project: github.com/bashizip/abada-engine

Assets 2

18 Apr 22:58

bashizip

v0.3.0-alpha

8dff528

🚀 Alpha 0.3.0 – Core Engine Ready for Action

🎯 Highlights

✅ Core BPMN engine implementation
✅ Task lifecycle logic (create, claim, complete)
✅ Embedded architecture ready
✅ First full test suite passing

This PR marks the completion of Milestone 0.3.0-alpha – the very first iteration of the Abada Engine.

✅ What's inside:

Lightweight and embeddable BPMN engine core
BPMN parsing support for user tasks, assignees, candidate users, and groups
In-memory runtime with process deployment and execution
Task visibility, claiming, and completion logic
Clean REST API with no dependency on security frameworks
Hardcoded user context provider for simplified testing
Full test coverage and passing integration tests

🔥 Why it matters:
We now have a functioning MVP of the engine — clean, extendable, and built for the future.

Next stop: History tracking, advanced BPMN elements, and multi-tenant prep.

Let’s ship it. 💥

Assets 2

26 Apr 02:30

bashizip

v.0.4.0-alpha

713bfa5

Release: v0.4.0-alpha - Persistence Layer

📦 Release: v0.4.0-alpha - Persistence Layer

Summary

This release introduces the Persistence Layer to the Abada Engine, enabling reliable storage and reloading of BPMN processes, process instances, and tasks across application restarts.
It marks a foundational step towards a production-grade workflow engine.

✨ Features

H2 Database Integration
- Embedded H2 database configured for persistent, file-based storage.
- Automatic schema creation for process definitions, process instances, and tasks.
Persistence Services
- PersistenceService interface created to abstract persistence operations.
- H2PersistenceServiceImpl implementation based on Spring Data JPA repositories.
Entity Management
- Entities added:
  - ProcessDefinitionEntity
  - ProcessInstanceEntity
  - TaskEntity
- Mapped cleanly with JPA annotations for robust database mapping.
Process Deployment Flow
- New DeployProcessService:
  - Persist parsed process definitions automatically at deploy time.
  - Register them in runtime memory through ProcessRegistry.
Runtime Registry
- ProcessRegistry created as a Spring @Component.
- Manages deployed process definitions in-memory for fast access.
Database Preloading
- DatabaseInitializer (CommandLineRunner) preloads sample process definitions, instances, and tasks on startup for demo/testing purposes.
API for Persistence Verification
- /demo REST Controller added:
  - GET /demo/process-definitions
  - GET /demo/process-instances
  - GET /demo/tasks
- Enables simple verification of stored data through HTTP requests.
Test Coverage
- PersistenceServiceTest created to validate persistence and retrieval of process definitions, instances, and tasks.
- Context automatically resets between tests to ensure isolation.
Basic BPMN Validation
- Validation rules added during BPMN parsing:
  - Must contain a startEvent.
  - Must contain at least one userTask.
  - Must contain at least one sequenceFlow.
- Improves robustness by rejecting invalid BPMN models early.

🛠️ Internal Improvements

Improved BpmnParser to:
- Handle InputStreams safely without premature exhaustion.
- Read and preserve raw BPMN XML.
- Centralize attribute access and validation.
Consolidated ParsedProcessDefinition structure to support future execution engine features (e.g., assignee and candidate retrieval).

🔥 Impact

The Abada Engine now officially persists its business objects.
It can safely survive restarts without losing deployed processes, process instances, or tasks.
This paves the way for the next major milestone: automatic reloading of active instances at boot.

🛣️ Next Milestone: [v0.5.0-alpha] - Engine Runtime Reload on Startup

Restore active process instances into runtime memory on engine reboot.
Reconnect instances and tasks to their in-memory handlers.
Prepare for future support of running timers and signals.

🚀 Abada Engine: Building the Future of Lightweight BPMN Execution.

Assets 2

Releases: bashizip/abada-engine