egetman/jes

This system is an event sourcing framework that provides the core infrastructure for building stateful, event-driven applications. It manages the persistence and retrieval of event streams, handles command dispatching, and supports reactive processing through projectors and stateful sagas. The architecture includes pluggable storage backends for events, snapshots, and distributed locks, along with flexible serialization and upcasting capabilities.

A new Stock demo application is introduced to showcase basic Jes components. The demo includes a README with usage instructions and two shell scripts: run-demo.sh, which starts a Postgres container, builds the write-part and read-part applications, and launches them; and stop-demo.sh, which terminates the running applications and the Postgres container. The demo allows users to interact with stock items via a web interface at http://localhost:8080/stock.

demo · high confidence

Introduced new lock and offset management components to support clustered/distributed environments. The lock package adds an abstract base for read-write locks with concrete implementations for in-memory, JDBC, and Redis (via Redisson). The offset package provides similar abstractions for tracking and managing state offsets, with in-memory, JDBC, and Redis implementations. These changes enable the framework to coordinate access and track offsets across multiple service instances, preventing duplicate processing in distributed deployments.

src/main/java/store/jesframework/lock · high confidence

A new demo application is introduced in the read-part module, providing a complete read-model implementation using Spring Boot and Vaadin. The demo includes a Stock UI for managing items, a StockProjector that updates the read model based on domain events, and REST controllers to expose item data. Configuration is handled via application.properties and schema.sql for the PostgreSQL database, with JPA repositories and event serialization options defined in the Spring context.

demo/read-part · high confidence

Introduced new storage backends for the event store: an in-memory provider for testing, JDBC and JPA providers for persistent storage, and a clustered JDBC provider that distributes read queries across replicas while ensuring read-your-own-writes consistency via a write-tracking cache. The \StoreProvider\ interface was also added to define the core event store operations.

src/main/java/store/jesframework/provider · high confidence

The framework now includes a command bus implementation (interface and sync/noop variants) for dispatching commands, alongside JPA entity classes (StoreEntry and its binary/string subtypes) and a factory for creating event store entries. This introduces the core messaging and persistence structures for the application.

src/main/java/store/jesframework/bus, src/main/java/store/jesframework/provider/jpa · high confidence

The framework now includes a set of common system events to improve observability and handle edge cases in event sourcing. New event types include Failure, ProjectionFailure, and SagaFailure to explicitly track handling errors, alongside ContextUpdated for generic updates. Additionally, new events StreamMergedTo, StreamMovedTo, and StreamSplittedTo are introduced to represent stream lifecycle changes, while UnknownTypeResolved handles deserialization of unregistered types.

src/main/java/store/jesframework/common · high confidence

New DDL scripts have been added to support MySQL, PostgreSQL (versions 9 and 10), and H2 databases. These scripts define the necessary tables and indexes for the event store, snapshot store, offsets, and distributed locks, enabling the application to operate on these database platforms.

src/main/resources/ddl · high confidence

New utility classes have been introduced to the framework: Check provides validation methods for collections, arrays, and maps; PropsReader handles property resolution from system, environment, and jes.properties files with caching; JdbcUtils offers helpers for schema management, database metadata, and SQL type mapping; DaemonThreadFactory creates daemon threads with uncaught exception logging; and Pair is a simple key-value container.

src/main/java/store/jesframework/util · high confidence

The framework now includes the foundational classes for event sourcing: an Aggregate base class that manages event appliers and stream versioning, an AggregateStore for reading and writing events with snapshot support, a JEventStore interface for low-level event stream operations, and an UnsafeOps utility for advanced stream manipulation like merge, split, and replace. These additions provide the core building blocks for implementing event-sourced aggregates and managing event streams.

src/main/java/store/jesframework · high confidence

The framework now includes a comprehensive set of custom exceptions in the 'store.jesframework.ex' package, including 'AggregateCreationException', 'BrokenHandlerException', 'BrokenReactorException', 'BrokenStoreException', 'EmptyEventStreamException', 'EventStreamRewriteUnsupportedException', 'EventStreamSplitUnsupportedException', 'PropertyNotFoundException', 'SerializationException', and 'VersionMismatchException'. Additionally, the 'store.jesframework.handler' package introduces a new 'CommandHandler' abstract class and supporting utilities ('HandlerUtils', 'Handle' annotation) that enable automatic registration of command handlers via reflection, validating method signatures and invoking them through the command bus.

src/main/java/store/jesframework/ex, src/main/java/store/jesframework/handler · high confidence

The framework now includes a new reactor subsystem in the \store.jesframework.reactors\ package, introducing \Reactor\, \Projector\, and \Saga\ components that process events via a polling trigger mechanism. The \Saga\ class adds support for stateful event-sourced sagas, allowing them to maintain and update internal context through an \AggregateStore\. This enables developers to build complex, stateful workflows that react to domain events while managing their own internal state.

src/main/java/store/jesframework/reactors · high confidence

The framework now provides a complete snapshotting subsystem. A new \SnapshotStrategy\ interface and implementations (\AlwaysSnapshotStrategy\, \SizeBasedSnapshotStrategy\, \TimeBasedSnapshotStrategy\) allow users to control when snapshots are taken based on event count or time intervals. A \SnapshotProvider\ interface and its implementations (\DefaultSnapshotProvider\, \InMemorySnapshotProvider\, \JdbcSnapshotProvider\, \RedisSnapshotProvider\) enable persisting and retrieving aggregate states in memory, via JDBC, or via Redis. The \DefaultSnapshotProvider\ also introduces a customizable aggregate creation mechanism, allowing users to supply custom constructors or reflection-based instantiation rules.

src/main/java/store/jesframework/snapshot · high confidence

A new demo application has been added to the write-part module, providing a complete example of an event-sourced system. This includes Spring Boot configuration, REST controllers for creating items and placing orders, command handlers, domain models, and stateful sagas that react to domain events. The demo is configured to connect to a PostgreSQL database and uses JDBC-based providers for locking and offset tracking.

demo/write-part · high confidence

The JDBC provider now uses a new DDLFactory to generate database schema scripts dynamically based on the underlying database vendor (MySQL, PostgreSQL, H2) and version. This enables support for MySQL in lock, offset, and event store providers, while also maintaining legacy PostgreSQL (v9) and H2 support. The factory handles schema name replacement and content type mapping, ensuring correct DDL generation for each supported database.

src/main/java/store/jesframework/provider/jdbc · medium confidence

All JDBC SQL statements for the event store, aggregate store, offsets, and locks are now defined in the new \jes.properties\ file. This change moves the SQL queries out of the Java codebase, allowing for easier maintenance and potential database-specific adjustments without recompiling the application.

src/main/resources · high confidence

The serialization module has been refactored to replace the previous TypeRegistry and UpcasterRegistry with a unified Context component that holds all serialization metadata. This introduces new API interfaces including Serializer, Upcaster, and SerializationOption, alongside concrete implementations for Jackson (JSON), Kryo (Binary), and XStream (XML). The Context class now manages format selection, aliasing strategies (FULL\_CLASS\_NAME or SHORT\_CLASS\_NAME), and upcasting rules, enabling more flexible and extensible serialization behavior for events and aggregates.

src/main/java/store/jesframework/serializer · medium confidence

The legacy JES core interfaces—BatchLink, Event, JEventStore, Link, SingleLink, and VersionMismatchException—have been removed from the codebase. This change eliminates the previous abstraction layer for event storage and linking, likely as part of a broader refactoring to simplify the event store architecture.

src/main/java/io · high confidence

Added JMH benchmark for store provider read performance; Added JUnit parallel execution and test logging configuration; Added test coverage for command bus and handler components; Added test coverage for core reactor components; Added test coverage for failure handling and common utilities; Added test infrastructure for clustered PostgreSQL and multi-database support; Added tests for clustered JDBC store provider; Added tests for lock implementations; Added tests for snapshot provider and strategy implementations; Added tests for the Offset abstraction; Added unit tests for JDBC DDL generation and JPA store entry factory; Added unit tests for core event-sourcing components; Added unit tests for serializer components; Added unit tests for utility classes.

The project's root \pom.xml\ has been updated to version 1.2.0, with significant dependency upgrades including Jackson to 2.11.0, XStream to 1.4.15, and JUnit to 5.6.2. Additionally, two new demo modules (\demo/read-part\ and \demo/write-part\) were added, each configured with Spring Boot 2.1.6 and specific JDBC/JPA starters.

(dependencies) · high confidence

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

• CAI 57 → 57 (-0.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 99 (-0.4)
• Architecture 100 → 97 (-2.7)
• Maturity 50 → 50 (+0.0)
• Readiness 53 → 58 (+4.7)
• Security 60 → 62 (+1.4)
• Domain Modelling 74 → 59 (-15.5)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (11 lines × 2) (demo/read-part/src/main/java/store/jesframework/readmodel/view/ItemEditor.java)
• Duplicated block (5 lines × 2) (demo/read-part/src/main/java/store/jesframework/readmodel/Config.java)
• Duplicated block (6 lines × 2) (src/main/java/store/jesframework/snapshot/JdbcSnapshotProvider.java)
• Duplicated block (9 lines × 2) (src/main/java/store/jesframework/offset/JdbcOffset.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Scanner failed to run — not a clean result
• Test reliability not included
• dormant codebase — no living knowledge left to concentrate

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (12 lines × 2) (demo/read-part/src/main/java/store/jesframework/readmodel/view/ItemEditor.java)
• Duplicated block (13 lines × 2) (src/main/java/store/jesframework/offset/JdbcOffset.java)
• Duplicated block (15 lines × 2) (demo/read-part/src/main/java/store/jesframework/readmodel/view/ItemEditor.java)
• Duplicated block (5 lines × 2) (demo/read-part/src/main/java/store/jesframework/readmodel/Config.java)
• Duplicated block (5 lines × 2) (src/main/java/store/jesframework/snapshot/JdbcSnapshotProvider.java)
• Duplicated block (7 lines × 3) (src/main/java/store/jesframework/common/StreamMergedTo.java)
• Duplicated block (8 lines × 2) (src/main/java/store/jesframework/snapshot/InMemorySnapshotProvider.java)
• Duplicated block (8 lines × 4) (src/main/java/store/jesframework/lock/JdbcLock.java)
• 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)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No assertions: traverseAndMergeShouldMergeTwoStreamsInToOne (src/test/java/store/jesframework/UnsafeOpsTest.java)
• No assertions: traverseAndSplitShouldProduceTwoStreamsFromOne (src/test/java/store/jesframework/UnsafeOpsTest.java)
• …and 8 more

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

egetman/jes 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.