bulletproof-ninja/delta

Delta is a Domain-Driven Design-centric event sourcing library for the JVM, primarily written in Scala with a dedicated Java API layer. It provides core abstractions for committing events, managing snapshots, and processing streams with monotonic ordering, while supporting pluggable persistence backends including JDBC (MySQL, PostgreSQL, H2), MongoDB, Cassandra, and Redis. The system also includes distributed processing capabilities via Hazelcast and offers multiple read-model strategies for both consistent and eventually consistent data access.

25 changes.

This period marks the initial release of Delta, a DDD-centric event-sourcing library for the JVM, establishing its core abstractions for event storage, stream processing, and state management. The work focused on implementing pluggable persistence backends, including JDBC (with H2 and MySQL dialects), MongoDB, Cassandra, Hazelcast, and Redis, alongside comprehensive test suites to validate these integrations and domain logic.

9 changes.

This period focused on expanding the framework's capabilities by introducing a dedicated Java API layer and a comprehensive read-model architecture with consistent and incremental strategies. Significant effort was also directed toward backend support, adding PostgreSQL dialects to the JDBC store and establishing robust test infrastructure for Redis, JDBC, and validation processes.

Users can now store event data in MySQL databases. The new MySQL dialect maps the generic 'schema' concept to MySQL's 'database' terminology and handles MySQL-specific index creation errors (error codes 1061 and 1146) to ensure robust schema initialization. Additionally, four new text column types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT) are available for storing string data, allowing for flexible handling of varying text sizes within the MySQL store.

delta-jdbc/src/main/scala/delta/jdbc/mysql · high confidence

Users can now use PostgreSQL as a backend for the JDBC stream process store. This change introduces the PostgreSQLDialect class, which configures the database schema and data types (such as SMALLINT for bytes), and provides factory methods for an optional timestamp column using the TIMESTAMPTZ SQL type to support stream processing workflows.

delta-jdbc/src/main/scala/delta/jdbc/postgresql · high confidence

Introduces a new delta-redis sub-project providing Redis implementations for snapshot storage, stream processing, and message transport. This includes BinaryRedisSnapshotStore and RedisSnapshotStore for storing state snapshots, BinaryRedisStreamProcessStore and RedisStreamProcessStore for managing process streams with tick-based consistency, and RedisMessageTransport for pub/sub messaging via Jedis. The implementation uses Scuff serializers for encoding and a Jedis connection pool for resource management.

delta-redis/src/main · high confidence

This change introduces the core JDBC storage components for the Delta event sourcing library, including \AbstractJdbcStore\ for base database operations, \JdbcEventStore\ for committing and replaying events, and \JdbcStreamProcessHistory\ for maintaining stream snapshots with optional timestamp columns. It also adds \ColumnType\ definitions for type-safe database mapping and provides an \H2Dialect\ implementation to handle H2-specific SQL syntax, such as concatenating stream IDs for index lookups.

delta-jdbc/src/main/scala/delta/jdbc · high confidence

Delta is introduced as a new Scala-based event sourcing library, providing core abstractions for event storage, stream processing, and state management. The release includes a Cassandra event store implementation, a Hazelcast-based stream process store, and a JDBC event store with support for indexed lookups and optional timestamp columns. A Java-compatible EntityRepository is also provided to facilitate integration with Java applications, while core components like EventFormat and EventSource define the foundational interfaces for event encoding, decoding, and querying.

repository · high confidence

This change introduces the Delta project, a non-blocking, Future-based event-sourcing library for the JVM that supports pluggable storage (JDBC, MongoDB, Cassandra) and messaging (Redis, Hazelcast). The repository is initialized with the project's core documentation, including a README detailing its design principles and capabilities, a Jekyll theme configuration for the site, and Gradle wrapper scripts to manage the build environment.

(repo-wide) · high confidence

This change introduces the foundational components of the Delta library, establishing the core abstractions for event sourcing. It defines the \EventStore\ and \TransactionPublishing\ traits for committing and publishing event transactions, alongside \MessageHub\ and \MessageTransport\ for decoupled message routing. The update includes \Projector\ for building read models from events, \SnapshotStore\ for state persistence, and \Ticker\ implementations (Lamport and System Clock) for logical and physical timekeeping. Additionally, it provides \StorageType\ converters for handling Java and Scala enums in storage.

src/main/scala/delta · high confidence

The Delta Cassandra integration now includes explicit type mappings for reading and writing Cassandra columns, supporting standard types such as UUID, Long, Int, String, BigInt, Blob, and InetAddress, as well as collections like Maps and Sequences. A notable behavioral addition is the support for the Scala Unit type, which maps to a Cassandra tinyint column, allowing entities with Unit fields to be persisted and retrieved correctly.

delta-cassandra/src/main · high confidence

This change adds a new set of components to the delta-hazelcast module that enable distributed event sourcing and read model updates using Hazelcast. It introduces \DistributedMonotonicProcessor\ and \HzMonotonicProcessor\ to process transactions with monotonic revision ordering directly on Hazelcast map entries, ensuring consistent state updates across the cluster. A new \IMapEntryStateReadModel\ provides a reactive read model backed by Hazelcast \IMap\ listeners, while \IMapSnapshotStore\ and \StreamProcessMapStore\ handle persistent snapshot and stream processing storage. The implementation includes custom serializers for transactions, snapshots, and entry states, along with a \TopicMessageTransport\ for event publishing via Hazelcast topics, effectively replacing or augmenting previous in-memory or non-distributed mechanisms with a robust, cluster-aware architecture.

delta-hazelcast · high confidence

This change adds the \MongoEventStore\ and \MongoSnapshotStore\ implementations, enabling the Delta framework to persist event streams and snapshots in MongoDB. To support this, the \package.scala\ file introduces a suite of implicit BSON codecs for common Scala types (including \UUID\, \ObjectId\, \BigDecimal\, and enums) and adds \BsonJsonCodec\ and \JsonBsonParser\ to handle JSON serialization of BsonValues. The \MongoEventStore\ manages event persistence with specific indexing on stream revision, tick, and channel, while \MongoSnapshotStore\ handles snapshot upserts with optimistic concurrency control.

delta-mongodb/src/main · high confidence

This change introduces a suite of new classes and traits in the \delta.util\ and \delta.write\ packages, establishing the foundational write-model infrastructure. Key additions include \ConcurrentMapRepository\ and \PublishingRepository\ for in-memory and event-publishing data access, \TransientEventStore\ for non-persistent event storage, and \LocalTransport\ for local message handling. The \delta.write\ package now defines core abstractions such as \Entity\, \State\, \Metadata\, and \EntityRepository\, alongside a comprehensive set of JSON codecs (\JsonEvent\, \JsonSnapshot\, \JsonTransaction\, etc.) in \delta.util.json\ for serializing domain events and snapshots.

src/main/scala/delta/util · high confidence

This release introduces a dedicated Java API for the Delta event-sourcing framework, providing Java-friendly wrappers and adapters for the underlying Scala implementation. Users can now interact with core concepts such as entities, event stores, and read models using standard Java types (e.g., \java.util.Map\, \java.util.List\, \java.util.Optional\) instead of Scala collections. The new package includes \Immutable\ for safe immutable collection operations, \MetadataBean\ for converting Java beans to/from metadata maps, and specific consumer/processor classes like \PersistentMonotonicConsumer\ and \MonotonicProcessor\ that bridge Scala execution contexts to Java executors. This enables Java applications to subscribe to event streams, process live events, and manage replay states without dealing with Scala-specific types.

delta-java · high confidence

The \delta.process\ and \delta.validation\ packages have been introduced to provide a comprehensive framework for consuming and processing event streams. This includes core abstractions for monotonic processing (\PersistentMonotonicProcessing\, \PersistentMonotonicJoinProcessing\) that handle replay and live consumption, state management via \StreamProcessStore\, and cross-stream state joins through \JoinState\. The framework also adds support for side-effect processing, secondary indexing, and consistency validation with compensating actions (\EntityCompensation\, \GlobalSetValidator\) to ensure data integrity during event sourcing.

src/main/scala/delta/process · high confidence

The \delta.read\ package introduces a new read-model architecture providing multiple strategies for accessing event-sourced state. Users can now choose between \StatefulReadModel\ and \StatelessReadModel\ for fully consistent, on-demand pull-based reads, or \IncrementalReadModel\ for eventually consistent, push-based updates. The package also includes \PrebuiltReadModel\ for externally managed state and support traits like \MessageHubSupport\ and \MessageTransportSupport\ to integrate with messaging infrastructure.

src/main/scala/delta/read · high confidence

Added JDBC integration tests for H2 and MySQL; Added JDBC stream process store tests for H2, MySQL, and PostgreSQL; Added MongoDB-backed test suite for College domain; Added PostgreSQL integration tests for the college JDBC module; Added comprehensive test suite for Delta event sourcing components; Added test fixtures for Semester entity and state management; Added test fixtures for the Student domain model; Added test infrastructure for MongoDB event store integration; Added test infrastructure for Redis-based event processing; Added test infrastructure for student email validation; Added test samples for employee and department aggregation logic; Added test suite for Cassandra event store repository; Added test suite for Employee and Department domain aggregates; Added test suite for MongoDB codec and event store integration; Added test suite for college domain logic; Added test suites for H2 and MySQL database integrations; Added tests for JDBC-based email validation process store.

The project introduces a new Gradle-based build structure (version 6.7.1) that supports Scala 2.11, 2.12, and 2.13, defaulting to 2.13. This setup configures multi-module subprojects for Cassandra, JDBC, MongoDB, Hazelcast, and Redis integrations, along with specific driver versions for each (e.g., Cassandra 3.8.0, MongoDB 3.12.1, Hazelcast 3.12.9). It also includes dependencies for testing (JUnit, Silencer plugin) and publishing artifacts to Bintray.

(dependencies) · high confidence

The Gradle wrapper configuration has been updated to use Gradle 6.7.1. This ensures that builds will consistently use this specific version of the Gradle build tool, providing access to its features and bug fixes while maintaining reproducible build environments across different machines.

gradle · high confidence

Added SQLPower Architect ERD diagram files (\event-store.architect\ and \snapshot-history.architect\) that define the database schema for the delta-jdbc module. The \event-store\ diagram models the \Stream\, \Transaction\, \Metadata\, and \Event\ tables with their primary keys, indices, and foreign key relationships. The \snapshot-history\ diagram defines the \snapshot\_current\ and \snapshot\_history\ tables, including their columns and primary keys.

delta-jdbc · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 50 (+8.1)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 94 → 96 (+1.4)
• Architecture 99 → 92 (-7.6)
• Maturity 38 → 50 (+12.3)
• Readiness 26 → 33 (+7.7)
• Security 56 → 68 (+11.5)

• Change coupling: SubscriptionSupport.scala ↔ IncrementalReadModel.scala (src/main/scala/delta/read/SubscriptionSupport.scala)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Test reliability not included
• complexity unreadable for .java, .scala — churn × complexity hotspots could not be measured
• single-maintainer — knowledge-concentration (bus factor) risk

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• DistributedMonotonicProcessor.processTransaction (cognitive 18) (delta-hazelcast/src/main/scala/delta/hazelcast/DistributedMonotonicProcessor.scala)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (22 lines × 2) (delta-jdbc/src/main/scala/delta/jdbc/JdbcStreamProcessStore.scala)
• Duplicated block (5 lines × 2) (delta-java/src/main/scala/delta/java/EventSourceConsumer.scala)
• Duplicated block (7 lines × 2) (delta-hazelcast/src/main/scala/delta/hazelcast/DistributedMonotonicProcessor.scala)
• Duplicated block (8 lines × 2) (delta-jdbc/src/main/scala/delta/jdbc/Dialect.scala)
• Duplicated block (9 lines × 2) (delta-cassandra/src/main/scala/delta/cassandra/CassandraEventStore.scala)
• Duplicated block (9 lines × 2) (src/main/scala/delta/process/PersistentMonotonicJoinProcessing.scala)
• FixmeComment (src/test/scala/college/TestCollege.scala)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• JdbcEventStore.processTransactions (cognitive 17) (delta-jdbc/src/main/scala/delta/jdbc/JdbcEventStore.scala)
• Low cohesion: BinaryRedisStreamProcessStore (LCOM4 6) (delta-redis/src/main/scala/delta/redis/BinaryRedisStreamProcessStore.scala)
• Low cohesion: CassandraEventStore (LCOM4 4) (delta-cassandra/src/main/scala/delta/cassandra/CassandraEventStore.scala)
• Low cohesion: Dialect (LCOM4 7) (delta-jdbc/src/main/scala/delta/jdbc/Dialect.scala)
• …and 15 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• repository

• .

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

bulletproof-ninja/delta was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.