Skip to content
CAI
Software that uses CAICheck a score

apache/pekko-projection

57.5

Adequate · 8 November 2026

17.4k

lines of production code

Scala

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Added database schema scripts for MySQL, PostgreSQL, and YugabyteDB

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

Initial Cassandra projection configuration for Pekko

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

Initial project scaffolding for Apache Pekko Projections

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

Internal Scala/Java DSL adapters and MySQL offset store support

This change introduces internal adapter classes (BySliceSourceProviderAdapter, R2dbcHandlerAdapter, R2dbcGroupedHandlerAdapter) that bridge the Java DSL and Scala DSL implementations for R2DBC projections, ensuring seamless interoperability between the two API styles. Additionally, it adds MySQL-specific support via MySQLR2dbcOffsetStore, which implements database-specific SQL dialects (such as ON DUPLICATE KEY UPDATE) and handles MySQL driver constraints for batch statement binding and timestamp offset deletion.

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

Introduce Apache Pekko Projection gRPC module

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

Introduce configurable handler recovery strategies for projection processing

Users can now explicitly control how projection handlers react to processing failures via the new \HandlerRecoveryStrategy\ API. This allows configuring whether a failed envelope causes the stream to fail immediately, skips the failed element and continues, or retries the handler a specified number of times with a configurable delay before failing or skipping. This change is supported by new internal offset and handler strategies (\ExactlyOnce\, \AtLeastOnce\, \AtMostOnce\) that accept these recovery configurations, enabling more resilient projection implementations without manual error handling in user code.

repository · high confidence

Introduce pekko-projection-grpc module for gRPC-based event streaming

Added the new \pekko-projection-grpc\ module, providing both producer and consumer APIs to stream events over gRPC. Consumers can use \GrpcReadJournal\ to subscribe to event streams via \eventsBySlices\, \timestampOf\, and \loadEnvelope\, configured through \GrpcQuerySettings\ with support for additional request metadata. Producers can expose events via \EventProducer.grpcServiceHandler\, defining \EventProducerSource\ instances with entity types, stream IDs, and event transformations, while supporting optional request interception for authentication or authorization.

grpc/src/main/scala · high confidence

Introduction of KafkaOffsets utility for offset management

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

Java DSL for JDBC Projections

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

Java DSL testkit for Projection testing

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

New DurableStateSourceProvider for tag and slice-based projections

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

New Scala DSL testkit for Projection and Handler testing

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

New internal test-kit implementation classes for Pekko Projections

The testkit module now includes a set of new internal classes (TestClock, TestInMemoryOffsetStoreImpl, TestOffsetStoreAdapter, TestProjectionImpl, TestSourceProviderImpl) that provide the underlying implementation for the Scala and Java test APIs. These classes enable users to run projection tests in-memory with a controllable clock, in-memory offset storage, and mock source providers, facilitating deterministic testing of projection handlers without requiring external infrastructure.

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

R2DBC projection settings configuration model introduced

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

Repository initialized with Apache Pekko Projections configuration and documentation

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

Behavioural changes

Cassandra projection Java DSL migrated to Apache Pekko

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

Cassandra projection implementation migrated to Apache Pekko

The Cassandra projection module has been migrated from the Akka ecosystem to Apache Pekko. This change updates the package names and internal imports to use the \org.apache.pekko\ namespace, ensuring compatibility with the new project identity. The public API for creating projections (at-least-once, at-most-once, grouped, and flow-based) remains functionally equivalent, allowing users to continue using the same factory methods while benefiting from the underlying framework transition.

(repo-wide) · high confidence

Configuration keys renamed from Akka to Pekko

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

Default configuration for Pekko Projection R2DBC added

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

JDBC Projection API migrated to Apache Pekko

The JDBC projection implementation has been migrated from the Akka codebase to Apache Pekko. This change updates the package structure and internal references from \akka\ to \org.apache.pekko\, ensuring that the \JdbcHandler\ and \JdbcProjection\ APIs now operate within the Pekko ecosystem. Users relying on this module will need to update their dependencies and imports to use the Pekko artifacts.

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

Java DSL for durable-state source providers now handles deleted state timestamps

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

Kafka projection source provider implementation migrated to Apache Pekko

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

Migrate Slick projection implementation to Apache Pekko

The Slick projection module has been migrated from the Akka namespace to Apache Pekko, updating all package declarations and internal imports to use org.apache.pekko.projection.slick. This change ensures the Slick offset store and projection factories (exactly-once and at-least-once) are compatible with the Pekko ecosystem while preserving the existing behavior of storing offsets in a relational database via Slick.

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

Migration of Kafka Source Provider to Apache Pekko

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

Migration to Apache Pekko and Protobuf 4.35.0

The core module has been migrated from Akka to Apache Pekko, updating all package names to org.apache.pekko and adopting the new project identity. Internally, the protobuf code generation has been upgraded to version 4.35.0, requiring corresponding changes to the serialization logic and backward-compatibility filters to handle API differences in the generated message classes.

core · high confidence

Pekko Projection R2DBC API migration to Scala 3 and Java DSL introduction

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

Removal of deprecated Cassandra and JDBC Projection APIs

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

Runtime persistence plugin configuration and query plugin overloads for EventSourcedProvider

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

Runtime persistence plugin configuration for EventSourcedProvider

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

Updated MiMa backward-compatibility filters for R2DBC projection changes

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

Updated MiMa configuration to handle internal API changes and removed deprecated methods

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

Test coverage

3 commits adding/updating tests in r2dbc/src/test; 65 commits adding/updating tests in examples/src/test/scala; Added Cassandra Projection documentation examples and tests; Added Hibernate session factory documentation example; Added JDBC integration tests for multiple database containers; Added Java API compile test for ProjectionBehavior; Added Java documentation example for Projection TestKit; Added Java documentation examples for Pekko Projections with Cassandra; Added Kafka projection tests with Pekko configuration and logging; 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 EventSourcedProvider slices and tags; 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 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 and TestProjection; Updated Cassandra test container and refined Scala 3 test syntax.

Dependencies

102 commits updating dependencies (1 manifest)

A dependency / build maintenance change in (dependencies) — 102 commits (4 fixs), 1 file: “use ASF header from LEGAL-626 (\#57)”; “remove remaining use of IntegrationTest scope (\#295)”; “update build (\#107)”; and 99 more (refs \#57, \#295, \#107, \#484, \#167, …).

(dependencies) · medium confidence · unverified

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

How this codebase got here

Score

  • CAI 61 → 57 (-3.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 63 → 63 (+0.2)
  • Architecture 92 → 91 (-1.0)
  • Maturity 49 → 47 (-2.2)
  • Readiness 70 → 70 (+0.0)
  • Security 73 → 60 (-13.3)
  • Performance 100 → 100 (+0.0)

Resolved (4)

  • 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)
  • Documentation: no installation or build instructions (README.md)
  • Off-boarding risk: anonymized user #1

New (1)

  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 13 commits — 13 feature/other, 0 fixes

By area

  • project/Dependencies.scala — 5 commits
  • .github/workflows — 2 commits
  • r2dbc-int-test/src — 2 commits
  • grpc-int-test/src — 1 commit
  • kafka/src — 1 commit
  • project/build.properties — 1 commit
  • r2dbc/src — 1 commit

Notable commits

  • change: Bump coursier/cache-action from 8.2.0 to 9.0.1 (#673)
  • change: Bump sbt/setup-sbt from 1.5.12 to 1.5.13 (#672)
  • change: Update Pekko core to 2.0.0 (#674)
  • change: Update hibernate-core to 7.4.14.Final (#667)
  • change: Update hibernate-core to 7.4.15.Final (#677)
  • change: Update logback-classic to 1.6.6 (#666)
  • change: Update mssql-jdbc to 13.6.2.jre11 (#675)
  • change: Update sbt, scripted-plugin to 1.13.1 (#670)
  • change: Update scala3-library to 3.3.9 (#669)
  • change: create the Kafka metadata client when the source is materialized (#621)
  • change: only run R2dbcOffsetStore delete task while the projection is running (#620)
  • change: r2dbc: add R2dbcSession.withSession (#664)
  • change: r2dbc: start from earliest slice when projection key changes (downscaling) (#665)

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 39b44ed5e65f314126585e6a802371107bf7235b — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.