apache/pekko-projection

This system is the Apache Pekko Projections library, which enables the reliable processing of event streams and durable state changes into external storage systems. It provides source providers for reading from Apache Kafka, Event Sourced entities, and Durable State entities, allowing applications to project data by tags or entity slices. The library supports multiple offset storage backends, including Cassandra, JDBC, Slick, and R2DBC, to manage processing state with exactly-once or at-least-once semantics. Additionally, it includes a gRPC module for distributed event replication and a test kit for validating projection logic in isolation.

38 changes.

The project was migrated from Akka to Apache Pekko, involving a comprehensive namespace update across core, JDBC, Kafka, Cassandra, and durable-state modules. This period also established the initial build infrastructure, added Java and Scala DSLs for testing and projections, and created extensive documentation examples and test coverage for the new ecosystem.

20 changes.

This period introduced a new gRPC module for distributed event replication and expanded R2DBC projection support to include MySQL, a Java DSL, and Scala 3. The work was accompanied by comprehensive integration tests for the new gRPC and R2DBC features, as well as existing Cassandra, JDBC, and Slick backends. Additionally, deprecated APIs for Cassandra, JDBC, and Slick projections were removed to clean up the public interface.

The R2DBC projection module now supports MySQL as a database backend, in addition to the existing PostgreSQL and Yugabyte support. This is implemented via a new \MySQLR2dbcOffsetStore\ that provides MySQL-specific SQL for offset storage and management, including handling MySQL's batch statement parameter binding requirements and SQL syntax differences for deleting old offsets.

r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/internal · high confidence

New DDL scripts have been added to the \r2dbc-int-test/ddl-scripts\ directory to support R2DBC-based projections on MySQL, PostgreSQL, and YugabyteDB. These scripts define the necessary tables (\event\_journal\, \snapshot\, \durable\_state\, \projection\_offset\_store\, \projection\_timestamp\_offset\_store\, and \projection\_management\) with dialect-specific data types and indexing strategies, enabling integration tests to run against these database backends.

r2dbc-int-test/ddl-scripts · high confidence

The project now includes a configuration file for the site-link-validator tool to check documentation links, mapping local Pekko API paths and ignoring specific external prefixes like GitHub and Datastax to prevent false positives. Additionally, a helper shell script was added to format and display build log files for easier debugging.

scripts · high confidence

Added a new reference configuration file for the Cassandra projection module, establishing default settings for the Pekko-based system. This includes configuration for the CQL session provider, service discovery, and the offset store keyspace and tables, as well as a Datastax Java driver profile with QUORUM consistency and default idempotence enabled.

cassandra/src/main/resources · high confidence

The build infrastructure for the project has been established, introducing the core sbt configuration files (build.properties, plugins.sbt) and custom build plugins. This includes the definition of dependency versions in Dependencies.scala, setting up the Apache license header management via CopyrightHeader.scala, and configuring the Protobuf generation process. The build is configured to target sbt 1.13.0 and supports cross-compilation for Scala 2.13 and Scala 3.

project · high confidence

Adds the new \pekko-projection-grpc\ module, providing the protocol definitions and configuration for distributed event replication via gRPC. This includes \consumer.proto\ and \event\_producer.proto\ which define the \EventProducerService\ for streaming events by slices, supporting runtime event filtering (by tags, entity IDs, or regex) and offset management. A \reference.conf\ is also added to configure the gRPC client, stream IDs, and serialization bindings for the consumer filter state, enabling users to set up Pekko Projection consumers that replicate events from a producer side over gRPC.

grpc/src/main/protobuf · high confidence

The \grpc/src/main/scala\ module now provides a complete gRPC-based consumer for Pekko Projections, including the \GrpcReadJournal\ (Scala and Java DSLs), \GrpcQuerySettings\, and the \GrpcReadJournalProvider\. This enables applications to consume events from a remote gRPC producer service. A key capability is the \ConsumerFilter\ extension, which allows subscribers to dynamically control which events are received using include/exclude criteria based on tags, entity IDs, and regular expressions. The filter state is persisted locally or, when Pekko Cluster Distributed Data is available, replicated across the cluster via \ConsumerFilterStore\ and \ConsumerFilterRegistry\, ensuring consistent filtering across multiple consumer instances.

grpc/src/main/scala · high confidence

A new KafkaOffsets object has been added to the Kafka projection module to handle the conversion and management of Kafka consumer offsets. This utility provides methods to transform ConsumerRecord instances into MergeableOffset objects, convert between TopicPartition and string keys, and extract the set of partitions from group offsets, facilitating the tracking of Kafka offset state within the projection system.

kafka/src/main/scala/org/apache/pekko/projection/kafka · high confidence

Added Java DSL classes for JDBC projections, including JdbcHandler, JdbcSession, JdbcHandlerLifecycle, and JdbcProjection. These classes provide a Java-friendly API for creating and managing JDBC-based projections with support for exactly-once and at-least-once processing semantics.

jdbc/src/main/scala/org/apache/pekko/projection/jdbc/javadsl · high confidence

Added Java DSL bindings for the Projection testkit, providing \ProjectionTestKit\ to run and assert projections, \TestProjection\ to isolate and test handler implementations without a database, \TestSourceProvider\ to supply arbitrary envelope streams, and \TestOffsetStore\ to manage offset state during tests.

testkit/src/main/scala/org/apache/pekko/projection/testkit/javadsl · high confidence

The durable-state module now includes a new \DurableStateSourceProvider\ object that enables creating source providers for durable state changes. Users can now project durable state changes by tag using \changesByTag\ or by entity type slices using \changesBySlices\. The provider correctly handles both updated and deleted durable states, extracting timestamps from \DeletedDurableState\ instances in addition to \UpdatedDurableState\. It also provides utility methods \sliceForPersistenceId\ and \sliceRanges\ to calculate slice assignments and ranges for durable state entities.

durable-state/src/main/scala/org/apache/pekko/projection/state/scaladsl · high confidence

The \testkit\ module now provides a Scala DSL (\scaladsl\) for testing Apache Pekko Projections. This includes \ProjectionTestKit\ to run and assert full projections with configurable timeouts and intervals, \TestProjection\ to isolate and test \Handler\ implementations without a database, and \TestSourceProvider\ to supply arbitrary envelope streams for controlled testing.

testkit/src/main/scala/org/apache/pekko/projection/testkit/scaladsl · high confidence

The R2DBC projection module now exposes a dedicated \R2dbcProjectionSettings\ configuration class, allowing users to explicitly manage R2DBC-specific projection parameters such as dialect, schema, offset tables, time windows, and batch sizes via the \pekko.projection.r2dbc\ configuration path or programmatic APIs.

r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc · high confidence

The repository has been set up as Apache Pekko Projections, including the standard Apache LICENSE and NOTICE files, a .asf.yaml configuration for GitHub integration (enabling discussions, issue tracking, and branch protection), and a .scalafmt.conf defining code formatting rules (version 3.11.5, Scala 2.13 source 3 dialect). The project also includes a .scala-steward.conf for automated dependency updates, AGENTS.md and CLAUDE.md for AI coding agent guidelines, and a docker-compose.yml for local Cassandra testing.

(repo-wide) · high confidence

The Cassandra projection implementation has been updated to use the Apache Pekko namespace (org.apache.pekko) instead of the previous Akka namespace. This change reflects the project's transition to Pekko, updating all internal imports, package declarations, and references to Pekko core components such as ActorSystem and projection interfaces. Users relying on this module will need to ensure their build environment is configured for Pekko dependencies.

cassandra/src/main/scala/org/apache/pekko/projection/cassandra/scaladsl, jdbc/src/main/scala/org/apache/pekko/projection/jdbc/scaladsl · high confidence

The Cassandra projection Java DSL has been migrated from the Akka ecosystem to Apache Pekko. This change updates the package namespace from \akka\ to \org.apache.pekko\ and adapts the implementation to the new Pekko APIs, ensuring compatibility with the Pekko Projection library. Users upgrading to Pekko must update their imports and configuration references to reflect the new package structure.

cassandra/src/main/scala/org/apache/pekko/projection/cassandra/javadsl · high confidence

The default configuration files for the JDBC, Kafka, and Slick projection modules have been updated to use the new \pekko.projection.\*\ namespace instead of the previous Akka-based keys. Users upgrading to this version must update their \application.conf\ or \reference.conf\ overrides to match the new \pekko\ prefix, as the old configuration paths will no longer be recognized.

jdbc/src/main/resources, kafka/src/main/resources, slick/src/main/resources · high confidence

The core module has been migrated from Akka to Apache Pekko, introducing new Scala 3 syntax and updating the internal Protobuf code generation to version 4.35.0. This includes new protobuf definitions for projection management messages (ProjectionId, GetOffset, SetOffset, etc.) and corresponding Java gencode, alongside updated backward-compatibility filters for the protoc upgrade. The core API now exposes Pekko-specific abstractions such as the Projection trait, ProjectionBehavior for actor-based management, HandlerRecoveryStrategy for error handling (fail, skip, retry-and-fail, retry-and-skip), and StatusObserver for tracking projection lifecycle events, all configured via the new pekko.projection reference.conf settings.

core · high confidence

A new reference configuration file has been introduced for the pekko-projection-r2dbc module, defining default settings for the R2DBC dialect, offset store tables (including projection\_offset\_store and projection\_management), memory eviction policies, batch sizes, and connection factory sharing. Users can now override these defaults in their application.conf to customize projection behavior, such as adjusting the time window for tracking persistence IDs or disabling database call logging.

r2dbc/src/main/resources · high confidence

The internal implementation classes for the Projection Testkit (including TestClock, TestInMemoryOffsetStoreImpl, TestOffsetStoreAdapter, TestProjectionImpl, and TestSourceProviderImpl) have been rewritten to use the org.apache.pekko package namespace and Scala 3 syntax. This change aligns the testkit's internal mechanics with the Apache Pekko project structure, ensuring that test utilities correctly reference the new Pekko core APIs while maintaining the same in-memory offset storage and clock control capabilities for users.

cassandra/src/main/scala/org/apache/pekko/projection/cassandra/internal, slick/src/main/scala/org/apache/pekko/projection/slick, testkit/src/main/scala/org/apache/pekko/projection/testkit/internal · high confidence

The internal JDBC offset store components (including dialect definitions, session utilities, settings, and projection implementation) have been migrated from the Akka ecosystem to Apache Pekko. This change updates the package namespace to org.apache.pekko.projection.jdbc.internal and adapts the internal API to use Pekko actor system and types, ensuring the JDBC projection module functions correctly within the Pekko runtime.

jdbc/src/main/scala/org/apache/pekko/projection/jdbc/internal, slick/src/main/scala/org/apache/pekko/projection/slick/internal · high confidence

The \DurableStateSourceProvider\ in the Java DSL now correctly extracts creation timestamps for \DeletedDurableState\ events in addition to updated ones. This ensures that projections consuming durable state changes receive accurate temporal metadata even when a state entry is deleted, preventing potential issues with ordering or filtering based on creation time.

durable-state/src/main/scala/org/apache/pekko/projection/state/javadsl · high confidence

The internal Kafka projection source provider components have been rewritten to target Apache Pekko instead of Akka. This change updates the package names, imports, and internal APIs (such as \KafkaSourceProviderImpl\, \KafkaSourceProviderSettings\, and \MetadataClientAdapter\) to use the \org.apache.pekko\ namespace and Pekko-specific types, ensuring compatibility with the Pekko ecosystem while preserving the existing projection behavior for users.

kafka/src/main/scala/org/apache/pekko/projection/kafka/internal · high confidence

The Kafka projection module has been migrated from the Akka ecosystem to Apache Pekko. This change updates the package names and imports from \akka.\\ to \org.apache.pekko.\\ in both the Java DSL (\KafkaSourceProvider.scala\ in \javadsl\) and Scala DSL (\KafkaSourceProvider.scala\ in \scaladsl\). Users must update their import statements and fully qualified class names to use the new Pekko namespace. The core functionality of creating a \SourceProvider\ for Kafka topics remains the same, but the underlying library references now point to the Pekko implementation.

kafka/src/main/scala/org/apache/pekko/projection/kafka/javadsl · high confidence

The R2DBC projection implementation has been migrated to Scala 3 syntax and updated to align with the Akka Projection 1.4.0 API. This change introduces a new Java DSL (including \R2dbcHandler\, \R2dbcProjection\, \R2dbcSession\, and \R2dbcReplication\) alongside the existing Scala API, providing Java-specific entry points such as \R2dbcProjection.exactlyOnce\ and \R2dbcReplication.create\. The underlying Scala implementation now uses Scala 3 idioms and exposes the \R2dbcSession\ and \R2dbcHandler\ interfaces for both languages, ensuring consistent envelope processing and transaction management across both APIs.

r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/scaladsl · high confidence

The \createOffsetTableIfNotExists\ method has been removed from both Cassandra and JDBC projections, and the \dropOffsetTableIfExists\ method has been removed from JDBC projections. Additionally, the \JdbcHandler.fromFunction\ factory method is no longer available. These changes clean up the public API by eliminating previously deprecated members, so users must update their code to use the current supported methods for offset table management and handler creation.

cassandra/src/main/mima-filters, jdbc/src/main/mima-filters · high confidence

The Java DSL for EventSourcedProvider now supports configuring persistence plugins at runtime. New overloads for eventsByTag, eventsBySlices, sliceForPersistenceId, and sliceRanges accept a Config parameter, allowing users to specify read journal settings dynamically without relying solely on default configuration. Additionally, query plugin instance overloads are exposed, enabling direct injection of query interfaces (such as EventsByTagQuery and EventsBySliceQuery) for more flexible provider setup.

eventsourced/src/main/scala/org/apache/pekko/projection/eventsourced/javadsl · high confidence

The EventSourcedProvider now supports configuring the persistence read journal plugin at runtime. New overloaded methods for eventsByTag, eventsBySlices, sliceForPersistenceId, and sliceRanges accept an additional Config parameter, allowing users to specify custom journal settings without relying on global configuration. This enables more flexible deployment scenarios where different projection sources can use distinct journal configurations dynamically.

eventsourced/src/main/scala/org/apache/pekko/projection/eventsourced/scaladsl · high confidence

This update adds and refreshes MiMa (Migration Manager) exclusion filters to accommodate internal API changes in the R2DBC projection module. Specifically, it suppresses warnings for \R2dbcProjectionSettings\ (converted from a case class to a class), \R2dbcSession\ (Java DSL signature changes), and internal \R2dbcOffsetStore\ components (including \RecordWithOffset\, \Record\, and \State\ classes). These filters ensure that the library's public API remains stable for users despite underlying structural adjustments and synchronization with upstream \akka-projection-r2dbc\ 1.4.0 changes.

r2dbc/src/main/mima-filters · high confidence

The MiMa (Migration Manager) exclusion filters have been updated to accommodate changes resulting from the upgrade to sbt-mima-plugin 1.2.0 and the removal of deprecated code. Specifically, internal API changes in \SlickOffsetStore\ (such as modifications to \db\, \dialect\, and constructors) are now excluded from binary compatibility checks, as these are marked as \@InternalApi\. Additionally, exclusions have been added for the removed deprecated methods \createOffsetTableIfNotExists\ and \dropOffsetTableIfExists\ in \SlickProjection\, ensuring that the removal of these legacy features does not trigger false-positive binary incompatibility errors.

slick/src/main/mima-filters · high confidence

Add test configuration for Cassandra timeout and logging; Added Cassandra integration tests for offset storage and projection handling; Added Hibernate integration tests and documentation examples for JDBC projections; Added JDBC integration tests for multiple database containers; Added Java API compile test for ProjectionBehavior; Added Java documentation example for Kafka projections; Added Java documentation example for Projection TestKit; Added Java documentation examples for Event Sourced Provider and ShoppingCart entity; Added Java documentation examples for the Pekko shopping-cart projection guide; Added JdbcProjectionTest for JDBC projection functionality; Added Kafka projection tests with Pekko configuration and logging; Added R2DBC projection documentation examples; Added R2DBC projection integration and unit tests; Added compile-time and unit tests for gRPC projection consumer, producer, and replication APIs; Added documentation example for integrating Akka Classic with Pekko Projections; Added documentation examples for durable state projection source providers; Added gRPC projection integration tests; Added integration tests for Slick offset store across multiple database containers; Added test coverage for Slick offset storage and projection handling; Added test resources for JDBC projection and shopping cart guide examples; Added test suite for Apache Pekko Projections; Added tests for Cassandra projection examples; Added tests for DurableStateSourceProvider; Added tests for EventSourcedProvider with runtime journal configuration; Added tests for JDBC offset store and settings validation; Added tests for Kafka source provider implementation; Added tests for ProjectionTestKit Java DSL; Added tests for ProjectionTestKit and TestProjection.

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

• CAI 58 → 61 (+3.5)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 98 → 91 (-6.6)
• Architecture 99 → 98 (-0.8)
• Maturity 51 → 51 (+0.2)
• Readiness 62 → 73 (+11.1)
• Security 47 → 60 (+12.8)
• Domain Modelling 100 → 74 (-25.6)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included
• The TestKit section describes both assert-function and probe-style testing but does not explain how to run the tests locally or what test runner is used. (docs/src/main/paradox/testing.md)
• complexity unreadable for .java, .scala — churn × complexity hotspots could not be measured

• Boundary-crossing change coupling: JdbcOffsetStore.scala ↔ SlickOffsetStore.scala (jdbc/src/main/scala/org/apache/pekko/projection/jdbc/internal/JdbcOffsetStore.scala)
• Boundary-crossing change coupling: JdbcProjection.scala ↔ SlickProjection.scala (jdbc/src/main/scala/org/apache/pekko/projection/jdbc/javadsl/JdbcProjection.scala)
• ConsumerFilter.createDiff (cognitive 25) (grpc/src/main/scala/org/apache/pekko/projection/grpc/consumer/ConsumerFilter.scala)
• ConsumerFilter.mergeFilter (cognitive 24) (grpc/src/main/scala/org/apache/pekko/projection/grpc/consumer/ConsumerFilter.scala)
• ConsumerFilterRegistry.behavior (cognitive 16) (grpc/src/main/scala/org/apache/pekko/projection/grpc/internal/ConsumerFilterRegistry.scala)
• ConsumerFilterRegistry.behavior (cyclomatic 18) (grpc/src/main/scala/org/apache/pekko/projection/grpc/internal/ConsumerFilterRegistry.scala)
• Documentation: no project overview (README.md)
• Documentation: written for insiders (docs/src/main/paradox/index.md)
• Duplicated block (10–11 lines × 2) (core/src/main/scala/org/apache/pekko/projection/internal/InternalProjectionState.scala)
• Duplicated block (11 lines × 2) (eventsourced/src/main/scala/org/apache/pekko/projection/eventsourced/javadsl/EventSourcedProvider.scala)
• Duplicated block (11 lines × 2) (r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/internal/R2dbcProjectionImpl.scala)
• Duplicated block (13 lines × 3) (r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/scaladsl/R2dbcProjection.scala)
• Duplicated block (14 lines × 2) (core/src/main/scala/org/apache/pekko/projection/ProjectionBehavior.scala)
• Duplicated block (20 lines × 2) (r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/internal/R2dbcProjectionImpl.scala)
• Duplicated block (28 lines × 2) (r2dbc/src/main/scala/org/apache/pekko/projection/r2dbc/internal/R2dbcProjectionImpl.scala)
• Duplicated block (33 lines × 2) (slick/src/main/scala/org/apache/pekko/projection/slick/SlickProjection.scala)
• Duplicated block (37–38 lines × 2) (grpc/src/main/scala/org/apache/pekko/projection/grpc/replication/javadsl/ReplicationSettings.scala)
• Duplicated block (5 lines × 2) (core/src/main/scala/org/apache/pekko/projection/internal/SourceProviderAdapter.scala)
• Duplicated block (6 lines × 2) (cassandra/src/main/scala/org/apache/pekko/projection/cassandra/internal/CassandraProjectionImpl.scala)
• Duplicated block (7 lines × 4) (cassandra/src/main/scala/org/apache/pekko/projection/cassandra/internal/CassandraProjectionImpl.scala)
• …and 63 more

• 27 commits — 27 feature/other, 0 fixes

• project/Dependencies.scala — 12 commits
• .github/workflows — 6 commits
• project/plugins.sbt — 4 commits
• project/build.properties — 2 commits
• core/src — 1 commit
• grpc/src — 1 commit
• project/PekkoCoreDependency.scala — 1 commit

• change: Bump actions/setup-java from 5.6.0 to 5.7.0 (#597)
• change: Bump actions/setup-java from 5.7.0 to 6.0.0 (#615)
• change: Bump coursier/setup-action from 3.0.0 to 3.0.2 (#603)
• change: Bump sbt/setup-sbt from 1.5.4 to 1.5.6 (#598)
• change: Bump sbt/setup-sbt from 1.5.6 to 1.5.8 (#613)
• change: Update Pekko core dependency version to 2.0.0-M4 (#611)
• change: Update h2 to 2.5.250 (#616)
• change: Update hibernate-core to 7.4.6.Final (#612)
• change: Update hibernate-core to 7.4.7.Final (#614)
• change: Update jackson-databind to 2.21.6 (#607)
• change: Update jackson-databind to 2.22.2 (#609)
• change: Update junit-jupiter-api, ... to 6.1.3 (#600)
• change: Update junit-platform-launcher to 6.1.3 (#601)
• change: Update logback-classic to 1.6.2 (#604)
• change: Update logback-classic to 1.6.3 (#606)
• change: Update mssql-jdbc to 13.6.0.jre11 (#623)
• change: Update mysql-connector-j to 26.7.0 (#594)
• change: Update sbt, scripted-plugin to 1.12.15 (#602)
• change: Update sbt, scripted-plugin to 1.13.0 (#610)
• change: Update sbt-bill-of-materials to 1.1.1 (#596)
• …and 7 more

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

apache/pekko-projection 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.