notxcain/aecor

This system is a library for building event-sourced, distributed applications using functional programming abstractions. It provides a modular runtime that supports both Akka Cluster Sharding and Kafka-based distributed processing for managing state and long-running processes. The codebase includes utilities for serialization, scheduling, and in-memory testing, enabling developers to implement reliable, scalable event-driven architectures.

13 changes.

This period focused on stripping out the entire legacy Akka-based event sourcing and actor model, including associated configuration files, serialization logic, and example domain implementations. The codebase was refactored to remove these obsolete components, likely to support a new architectural approach using modern Scala libraries like Cats and Fs2.

15 changes.

This period focused on establishing the core abstractions for event sourcing and distributed processing within the Aecor library. Key developments included introducing generic Akka runtimes, Cassandra-backed persistence, and Kafka-based cluster-wide task distribution, alongside the necessary serialization and testing infrastructure to support these new capabilities.

The \akka-persistence-runtime\ module introduces a new runtime implementation for Akka Persistence, enabling event sourcing with Akka Cluster Sharding. This includes the \AkkaPersistenceRuntime\ for deploying entities, a \CassandraJournalAdapter\ for persistence, and read-side query support via \AkkaPersistenceEventJournalQuery\ and \CassandraOffsetStore\ for tracking consumer offsets. The module also provides serialization support through \MessageSerializer\ and \PersistentReprSerializer\, along with configuration in \reference.conf\ for Cassandra journal and snapshot store plugins.

modules/akka-persistence-runtime · high confidence

Introduces a new BoopickleWireProtocol implementation that enables serialization and deserialization of wire messages using the Boopickle library. This adds support for encoding and decoding algebraic data types via macro-generated codecs, allowing users to serialize their domain models into binary formats for network transmission.

modules/boopickle-wire-protocol · high confidence

Added a new test-kit module providing in-memory implementations of core runtime components to facilitate end-to-end testing. This includes a StateEventJournal for in-memory event storage, a StateKeyValueStore for in-memory key-value storage, a StateClock for time manipulation, and E2eSupport utilities to wire processes and manage state. These components allow developers to run integration tests against a fully functional, stateful runtime without external dependencies.

modules/test-kit · high confidence

The example module now includes a new application.conf file that configures HTTP, cluster, and Cassandra-based persistence (journal, snapshot store, and query journal) for the Aecor example. Additionally, the logback.xml file was moved to the new module path and updated to suppress specific loggers, including adding OFF-level logging for Akka persistence components and Aecor aggregate actors to reduce noise.

modules/example/src/main/resources · high confidence

The repository was initialized with essential build and configuration files, including .sbtopts for JVM memory settings, .scala-steward.conf to exclude specific Akka dependencies from automated updates, .scalafmt.conf for code formatting, and .travis.yml for CI. The project's version was updated from 0.1.0-SNAPSHOT to 0.20.0-SNAPSHOT.

(repo-wide) · high confidence

Added a new \CassandraScheduleEntryRepository\ implementation that persists scheduled entries to a Cassandra database, enabling durable, high-throughput storage of schedule state. This change introduces a new protobuf schema (\ScheduleEvents.proto\) and a corresponding Akka serializer (\ScheduleEventSerializer\ with ID 120) to handle serialization of schedule events, ensuring compatibility with existing systems while supporting the new storage backend.

modules/schedule · high confidence

Added a new \GenericAkkaRuntime\ implementation that enables running generic Akka Cluster Sharding actors. This includes the core runtime class, an actor implementation, settings configuration, and a Protobuf-based serialization layer (\MessageSerializer\) to handle message encoding and decoding across the cluster.

modules/akka-cluster-runtime/src/main · high confidence

A new module, Kafka-based Distributed Processing (KDP), is now available to distribute a list of processes across a cluster of nodes using Kafka's partition assignment machinery. Each application node receives a slice of the process list based on assigned partitions, ensuring that each process runs on only one node at a time and is automatically migrated if a node fails or is added. The module includes a \DistributedProcessing\ API to start processes, a \Supervision\ object for implementing restart strategies, and internal components for managing Kafka consumer rebalance events and channel-based coordination.

modules/kafka-distributed-processing · high confidence

The \aecor.data\ and \aecor.runtime\ packages now include foundational types for building event-sourced applications. This includes \ActionT\ for modeling stateful actions, \EventsourcedBehavior\ for defining entity behavior, and \Fold\ for processing events. The runtime layer introduces \EventJournal\ and \KeyValueStore\ traits to abstract persistence, along with \Snapshotting\ strategies and a \NoopKeyValueStore\ for testing. These components enable users to define and run event-sourced actors with support for snapshots and event replay.

modules/core/src/main/scala/aecor/data · high confidence

A new \distributed-processing\ module has been added, providing a \DistributedProcessing\ API that starts and manages long-running processes across an Akka cluster using Cluster Sharding. The implementation includes a \DistributedProcessingSupervisor\ to coordinate workers, a \DistributedProcessingWorker\ to execute individual process instances, and a \MessageSerializer\ for serializing \KeepRunning\ messages via Protobuf. Configuration for the Akka serialization bindings is also provided in \reference.conf\.

modules/distributed-processing · high confidence

Added a new example application in the \modules/example\ directory, featuring an \App\ entry point that wires up HTTP routes for account and transaction management. The change introduces domain models for accounts and transactions, including event-sourced algebras, repositories, and HTTP endpoints. It also includes supporting files for serialization, process management, and distributed processing.

modules/example/src/main/scala · high confidence

The core module introduces new type classes and protocols for encoding and decoding keys and wire data. This includes \KeyDecoder\ and \KeyEncoder\ type classes with instances for common types like String, Int, Long, and UUID, as well as support for AnyVal types. A new \WireProtocol\ trait and associated \Invocation\ type are added to define how data is encoded and decoded at the wire level, along with syntax helpers for lifting scodec \Attempt\ into effect types.

modules/core/src/main/scala/aecor/encoding · medium confidence

The core library introduces \Has\ and \MonadAction\ type classes to provide a structured way to access shared context (\Has\[T, A\]\ allows extracting a value of type \A\ from a context \T\) and to manage side-effecting actions that interact with state and events (\MonadAction\ provides \read\, \append\, and \reset\ operations). These abstractions enable more composable and testable implementations for event-sourced aggregates and generic runtimes by decoupling the effectful logic from specific runtime implementations.

modules/core/src/main/scala/aecor · high confidence

The core module now includes new utilities: a \Clock\ trait and \JavaTimeClock\ implementation for abstracting time operations, a \FunctionBuilder\ for generic function construction, and an \effect\ object providing an \unsafeToIO\ conversion for \F\[A\]\ to \IO\[A\]\.

modules/core/src/main/scala/aecor/util · high confidence

The generic FunctionBuilder utility in the aecor.util package has been removed. This component previously provided a type-safe way to construct functions from handlers using Shapeless, but it is no longer part of the library.

core/src/main/scala/aecor/util · high confidence

The example domain files for Account, CardAuthorization, CardAuthorizationProcess, and Counter have been deleted. This removes the previous implementations of these domain entities and their associated process logic from the example application.

example/src/main/scala/aecor/example/domain · high confidence

Removed the legacy Akka-based entity implementation, including the \EntityActor\ and \EntityRef\ abstractions, along with supporting types like \CommandHandler\, \CommandContract\, \EventProjector\, and \Deferred\. This eliminates the previous command/event processing and state management API in favor of a new model.

core/src/main/scala/aecor/core/entity · high confidence

The legacy process actor implementation has been removed from the core library. Specifically, the \ProcessActor\ class, which handled persistent actor logic, command delivery, and state transitions, has been deleted along with its associated support classes: \ProcessActorRegion\ for cluster sharding, \ProcessEventAdapter\ for Kafka message forwarding, and \CompoundConsumerSettings\ for topic schema composition. This change eliminates the old behavioral model in favor of a new architecture.

core/src/main/scala/aecor/core/process · high confidence

The \CallerDeliveryIdAtLeastOnceDelivery\, \EventBus\, and \OrderedAtLeastOnceDelivery\ classes have been removed from the core module. These components previously handled at-least-once delivery and event publishing via Akka actors and Kafka, but are no longer part of the codebase.

core/src/main/scala/aecor/core · high confidence

The default configuration file (reference.conf) has been removed from the core module. This eliminates the previous default settings, meaning users must now explicitly provide their own configuration or rely on other mechanisms to define system behavior.

core/src/main/resources · high confidence

The example application's configuration and protocol definitions have been removed. Specifically, the \Account.proto\ file defining the event schema and the \application.conf\ file containing Akka cluster, persistence (Cassandra journal), and serialization settings have been deleted. This indicates a shift away from the previous event-sourcing and cluster-based architecture, likely in favor of a different runtime or library (such as the mentioned Aecor/Free DSL approach) that does not rely on these specific Akka/Cassandra configurations.

example/src/main/resources · medium confidence

The main application entry point (App.scala) and its associated actor-based wiring have been removed. This includes the RootActor, the EventBus publisher, the EntityActorRegions for CardAuthorization and Account, and the ProcessActorRegion setup. The change eliminates the previous imperative setup of Kafka producers, Cassandra read journals, and process streams, indicating a shift away from the old actor-based initialization and event processing pipeline.

example/src/main/scala/aecor/example · medium confidence

The \Correlation\, \Deduplication\, \Message\, and \Passivation\ modules in the core message package have been removed. This eliminates the previous message envelope structure, correlation ID extraction logic, message deduplication tracking, and actor passivation handling, indicating a significant refactoring of how messages are defined and processed within the system.

core/src/main/scala/aecor/core/message · medium confidence

The generic serialization encoder trait and its Circe-based implementation have been removed from the core serialization module. This eliminates the previous mechanism for encoding arbitrary types into ByteBuffers, likely as part of a broader shift towards type-safe publishing and the adoption of eventsByTag for event persistence.

core/src/main/scala/aecor/core/serialization · medium confidence

The file core/src/main/protobuf/Messages.proto, which defined the DomainEvent and Timestamp protobuf messages, has been removed. This eliminates the legacy message structure in favor of the new event model.

core/src/main/protobuf · medium confidence

Added end-to-end test suite for the library; Added test infrastructure for Akka cluster runtime.

The project has been upgraded to support Scala 2.12.15 and 2.13.6, replacing the previous 2.11.8 target. Key libraries have been significantly updated: Cats is upgraded to 2.6.1 and Cats Effect to 3.2.9, while Fs2 is updated to 3.1.3. Other dependencies such as Circe (0.14.1), Http4s (0.23.4), and Akka (2.5.26) have also been bumped to newer versions.

(dependencies) · high confidence

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

• CAI 58 → 52 (-5.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 98 (-1.7)
• Architecture 100 → 92 (-7.9)
• Maturity 39 → 55 (+16.7)
• Readiness 45 → 28 (-16.4)
• Security 100 → 78 (-22.2)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Test reliability not included
• complexity unreadable for .scala — churn × complexity hotspots could not be measured
• dormant codebase — no living knowledge left to concentrate

• Duplicated block (21 lines × 2) (modules/akka-cluster-runtime/src/main/scala/aecor/runtime/akkageneric/GenericAkkaRuntime.scala)
• Duplicated block (5 lines × 2) (modules/core/src/main/scala/aecor/MonadAction.scala)
• Duplicated block (9 lines × 2) (modules/example/src/main/scala/aecor/example/account/deployment.scala)
• No ADRs found
• No SBOM
• No build provenance
• ScheduleProcess.apply (cognitive 33) (modules/schedule/src/main/scala/aecor/schedule/process/ScheduleProcess.scala)
• TodoComment (modules/boopickle-wire-protocol/src/main/scala/aecor/macros/boopickle/DeriveMacros.scala)

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

notxcain/aecor 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.