spring-projects/spring-data-cassandra

This system is the Spring Data Cassandra module, a data access framework that provides repository-based and template-based access to Apache Cassandra databases. It supports both synchronous and reactive programming models, offering features such as fluent query building, batch operations, and schema management via CQL. The library also includes comprehensive integration for Kotlin coroutines, CDI, and Micrometer-based observability, along with Ahead-of-Time processing support for native image compilation.

23 changes.

This period focused on significantly expanding the Spring Data Cassandra module by introducing Java-based configuration, asynchronous and batch operations, and comprehensive repository interfaces for both imperative and reactive programming models. The work also established robust testing infrastructure, updated XML namespaces, and integrated CDI support to enhance usability and extensibility.

20 changes.

This period focused on introducing a comprehensive reactive API for Cassandra, including new session interfaces, asynchronous templates, and non-blocking query execution using Project Reactor. It also involved refactoring the conversion, mapping, and schema generation layers to support immutable domain objects and modular CQL generation, while adding extensive test coverage for these new components and the underlying Cassandra Java Driver 4 integration.

20 changes.

This period focused on enhancing the developer experience for Kotlin users through comprehensive extension functions, DSL query builders, and coroutine integration across synchronous, asynchronous, and reactive APIs. Concurrently, the project introduced Ahead-of-Time (AOT) processing support to enable optimized startup and reduced memory footprints for GraalVM Native Images, alongside new observability features via Micrometer and extensible CQL script initialization utilities.

4 changes.

This period focused on adding Ahead-of-Time (AOT) processing support for Cassandra repositories to enable native image compilation, including comprehensive integration tests. It also involved migrating the Maven build to Spring Develocity Conventions and expanding the documentation with new Java examples for Spring Data Cassandra configuration and usage.

This change introduces Ahead-of-Time (AOT) processing capabilities for Spring Data Cassandra, enabling optimized startup and reduced memory footprint in native images. It registers a managed types processor to correctly handle Cassandra-specific managed types and provides runtime hints that ensure reflection access to repository implementations (SimpleCassandraRepository, SimpleReactiveCassandraRepository) and entity callbacks (BeforeConvertCallback, BeforeSaveCallback, and their reactive counterparts). Additionally, when observability dependencies are present, it registers runtime hints for Cassandra driver statement interfaces and CqlSession proxies to support observability features in native execution.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/aot · high confidence

This release adds Ahead-of-Time (AOT) processing support for Spring Data Cassandra repositories. The new \org.springframework.data.cassandra.repository.aot\ package introduces a \CassandraRepositoryContributor\ that generates optimized repository implementations at build time. This includes support for derived query methods, custom \@Query\ annotations, and named queries, ensuring that query parsing and execution code is available for native image compilation without runtime reflection.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/aot · high confidence

This change introduces CDI (Contexts and Dependency Injection) support for Spring Data Cassandra repositories. It adds a portable CDI extension that automatically detects Spring Data repository interfaces and registers them as CDI beans. The extension resolves the required CassandraOperations bean by matching qualifiers, allowing developers to inject Cassandra repositories directly into CDI-managed beans. The implementation includes a custom repository bean factory and uses JSpecify annotations for nullability constraints.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/cdi · high confidence

Users can now run Spring Data Cassandra applications with Ahead-of-Time compilation (e.g., via GraalVM Native Image). This change adds an \aot.factories\ configuration file that registers \CassandraRuntimeHints\ for runtime reflection and a \CassandraManagedTypesBeanRegistrationAotProcessor\ to handle bean registration and type filtering during the AOT build phase, ensuring Cassandra repositories function correctly in native images.

spring-data-cassandra/src/main/resources/META-INF/spring · high confidence

The core module now exposes an asynchronous API via the new \AsyncCassandraOperations\ interface and \AsyncCassandraTemplate\ implementation, allowing users to execute queries and mutations using \CompletableFuture\ for non-blocking data access. Additionally, a new \CassandraBatchOperations\ interface and \CassandraBatchTemplate\ implementation have been added, enabling users to group multiple insert, update, and delete actions into atomic logged batches with configurable timestamps and query options.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core · high confidence

Adds a new set of asynchronous data access components to the CQL core package, including the \AsyncCqlTemplate\ and \AsyncCqlOperations\ interface for executing CQL statements via \CompletableFuture\. The update also introduces \BeanPropertyRowMapper\ for mapping result rows to Java bean properties, along with supporting interfaces like \AsyncResultSetExtractor\ and \AsyncSessionCallback\ to facilitate non-blocking data retrieval and processing.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql · high confidence

This location introduces a suite of new converters in the \org.springframework.data.cassandra.core.cql.converter\ package to support the Cassandra Java driver 4 API. The changes add \AbstractResultSetConverter\ and its subclasses (such as \ResultSetToBigDecimalConverter\, \ResultSetToStringConverter\, and \ResultSetToListOfStringConverter\) to handle conversion of \ResultSet\ objects into various target types. Additionally, it includes \RowToMapConverter\ and \RowToListConverter\ to transform individual \Row\ objects into Maps and Lists, respectively. These components enable Spring Data Cassandra to properly map raw driver result sets and rows to application-level types using the new driver interfaces.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/converter · high confidence

Added new utility classes in the \org.springframework.data.cassandra.core.cql.util\ package to support functional building of Cassandra CQL statements. This includes the \StatementBuilder\ for composing queries via builder functions and bind operations, the \Bindings\ interface for capturing bind markers, and the \TermFactory\ interface for creating terms that can be rendered inline or as bind markers. These utilities are designed to work together to simplify the creation of complex statements with flexible parameter binding.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/util · high confidence

Added a comprehensive set of Java example files to the Antora documentation source, demonstrating how to configure and use Spring Data Cassandra. These examples cover various configuration approaches (including \AbstractCassandraConfiguration\, factory beans, and CDI producers), template usage for both synchronous and reactive operations, custom value converters, keyspace management, and entity mapping.

src/main/antora/modules/ROOT/examples · high confidence

This release introduces the core repository interfaces for Apache Cassandra, including \CassandraRepository\ for standard CRUD operations with paging support, \ReactiveCassandraRepository\ for reactive data access, and \MapIdCassandraRepository\ for entities using map-based composite keys. It also adds new annotations to enhance query capabilities: \@Query\ now supports \allowFiltering\, \count\, \exists\, and idempotency settings; dedicated \@CountQuery\ and \@ExistsQuery\ annotations allow declaring these projections directly on methods; \@AllowFiltering\ provides a convenient shorthand for derived queries; and \@Consistency\ enables setting the consistency level for CQL queries.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository · high confidence

This release introduces a comprehensive set of new, specific exception classes for the Cassandra module—including CassandraAuthenticationException, CassandraConnectionFailureException, CassandraReadTimeoutException, and CassandraWriteTimeoutException—allowing users to catch and handle distinct failure scenarios (such as auth failures, insufficient replicas, or specific timeout types) rather than relying on generic data access exceptions. Additionally, the module adds the ReactiveSession and ReactiveSessionFactory interfaces, which provide a reactive API for executing CQL queries and managing sessions using Project Reactor's Mono and Flux types, enabling non-blocking interaction with Cassandra clusters.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra · high confidence

This change introduces a new set of configuration classes in the \org.springframework.data.cassandra.config\ package to support Java-based configuration for Spring Data Cassandra. Key additions include \AbstractCassandraConfiguration\ and \AbstractReactiveCassandraConfiguration\ for setting up the Cassandra session, mapping context, converter, and templates via JavaConfig. It also adds \CassandraAuditingRegistrar\ and \CassandraAuditingBeanDefinitionParser\ to enable auditing support through both Java annotations (\@EnableCassandraAuditing\) and XML. Furthermore, it provides XML namespace parsers (\CassandraMappingContextParser\, \CassandraMappingConverterParser\, \CassandraCqlTemplateParser\, etc.) and a \CassandraNamespaceHandler\ to maintain backward compatibility with XML-based configuration. The \CassandraEntityClassScanner\ is also included to handle entity scanning based on base packages or classes.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config · high confidence

Added Kotlin extension functions and classes to the Cassandra query API to improve the developer experience when writing queries in Kotlin. This includes \isEqualTo\ and \inValues\ aliases for \Criteria\ to work around Kotlin reserved keywords, infix \and\ operators for \CriteriaDefinition\ and \CriteriaDefinitions\ to enable more readable query composition, and global \where\ and \query\ factory functions for a cleaner DSL syntax.

spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/query · high confidence

Added Kotlin extension functions for CqlOperations, AsyncCqlOperations, ReactiveCqlOperations, and DataClassRowMapper that leverage reified type parameters. This allows Kotlin users to call query methods like queryForObject and queryForList without explicitly passing the target class (e.g., queryForObject\<MyData\>("...")), and provides convenient lambda-based variants for row mapping and result extraction across synchronous, asynchronous, and reactive execution models.

spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/cql · high confidence

This release adds Kotlin extension functions for the synchronous CassandraOperations, asynchronous AsyncCassandraOperations, and reactive ReactiveCassandraOperations APIs, as well as for the executable and reactive delete, insert, select, and update operations. These extensions leverage reified type parameters to allow callers to omit explicit class arguments (e.g., select\<T\>(cql) instead of select(cql, T::class.java)), and for reactive operations, provide Kotlin Coroutines variants (suspend functions and Flow) that bridge Reactor types to Kotlin's async model, enabling more idiomatic Kotlin code when interacting with Cassandra.

spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core · high confidence

Spring Data Cassandra now includes a new observability package that integrates Cassandra driver operations with Micrometer Observations. This adds automatic tracing for synchronous and reactive session methods (execute, prepare) via interceptors and factory beans, allowing users to configure custom observation conventions and track low/high cardinality metrics like keyspace, consistency level, and CQL statements.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/observability · high confidence

Spring Data Cassandra now provides a dedicated package for initializing and cleaning up Cassandra keyspaces via CQL scripts. This change introduces a \KeyspacePopulator\ strategy interface and a \SessionFactoryInitializer\ bean that executes these strategies during application startup and shutdown. It includes a \ResourceKeyspacePopulator\ for loading and executing CQL scripts from resources, a \CompositeKeyspacePopulator\ to chain multiple populators, and a suite of specific \ScriptException\ types (e.g., \ScriptParseException\, \ScriptStatementFailedException\) to provide detailed error reporting when script processing fails.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/session/init · high confidence

Spring Data Cassandra introduces a new set of fluent specification classes in the \org.springframework.data.cassandra.core.cql.keyspace\ package to define and render CQL schema changes. This includes \CreateKeyspaceSpecification\, \CreateTableSpecification\, \CreateIndexSpecification\, and \CreateUserTypeSpecification\ for defining new objects, as well as \AlterKeyspaceSpecification\, \AlterTableSpecification\, and \AlterUserTypeSpecification\ for modifying existing ones. The API uses \CqlIdentifier\ for object names and supports options like \IF NOT EXISTS\ and replication strategies, providing a type-safe, programmatic way to manage Cassandra schema definitions.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/keyspace · high confidence

The Cassandra query module introduces a new fluent API for building CQL queries and updates, replacing the previous approach. Users can now construct queries using the new \Query\ and \Update\ objects, which support column selection via \Columns\, filtering via \Criteria\, and sorting. A key addition is native support for Cassandra's paging mechanism through \CassandraPageRequest\ and \CassandraScrollPosition\, allowing applications to handle pagination using \PagingState\ from the DataStax Java Driver. The \Update\ object also provides a fluent interface for setting values and performing collection operations like \addTo\ and \set\. These changes are located in the \spring-data-cassandra/core/query\ package.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/query · high confidence

Spring Data Cassandra now exposes a comprehensive set of mapping events and entity callbacks for the reactive and imperative programming models. Developers can hook into the persistence lifecycle using new interfaces such as BeforeConvertCallback, BeforeSaveCallback, AfterLoadEvent, and their reactive counterparts (ReactiveBeforeConvertCallback, ReactiveBeforeSaveCallback). This allows you to inspect or modify domain objects before they are converted to CQL statements or saved, and to react after load, save, or delete operations. The package also includes AuditingEntityCallback and ReactiveAuditingEntityCallback to automatically populate auditing fields on entities before conversion.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/event · high confidence

This location introduces the core classes for multi-tenant and dynamic session routing in Spring Data Cassandra. It adds the \SessionFactoryLookup\ strategy interface and three implementations (\MapSessionFactoryLookup\, \BeanFactorySessionFactoryLookup\, \SingleSessionFactoryLookup\) that resolve \SessionFactory\ instances by name from a map, a Spring \BeanFactory\, or a single wrapper. It also adds \AbstractRoutingSessionFactory\, which routes \getSession()\ calls to the correct target factory based on a lookup key (typically derived from transaction context), and \SessionFactoryLookupFailureException\ to signal resolution errors. This provides the wiring and lookup mechanism for dynamic session selection.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/session/lookup · high confidence

The Spring Data Cassandra module now registers its CDI extension via a service provider file under the Jakarta namespace (jakarta.enterprise.inject.spi.Extension). This enables automatic discovery of the CassandraRepositoryExtension by Jakarta EE-compatible containers, aligning the module with the Jakarta EE 9 namespace migration.

spring-data-cassandra/src/main/resources/META-INF/services · high confidence

The Cassandra repository infrastructure in the \support\ package has been updated to improve performance and extensibility. A new \CachingExpressionParser\ is now used to cache parsed SpEL expressions, reducing overhead during query resolution. Additionally, both synchronous (\CassandraRepositoryFactory\) and reactive (\ReactiveCassandraRepositoryFactory\) factories now support \CassandraRepositoryFragmentsContributor\ and \ReactiveCassandraRepositoryFragmentsContributor\ interfaces, allowing users to customize or extend repository behavior via fragment composition. The factory beans (\CassandraRepositoryFactoryBean\ and \ReactiveCassandraRepositoryFactoryBean\) expose setters for these contributors, enabling configuration of built-in or custom fragment logic.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support · high confidence

The Maven build now uses the Spring Develocity Conventions extension (version 0.0.26) to connect to ge.spring.io, replacing previous CI properties and extensions. Additionally, the JVM configuration has been updated to include specific exports and opens for JDK compiler modules and base libraries, ensuring compatibility with the new build conventions.

.mvn · high confidence

The repository configuration package now introduces dedicated support for both synchronous and reactive Cassandra repositories. This includes new \EnableCassandraRepositories\ and \EnableReactiveCassandraRepositories\ annotations, along with their corresponding registrars and configuration extensions. The synchronous configuration allows users to scan for standard \CassandraRepository\ interfaces and configure a specific \CassandraTemplate\ bean, while the reactive configuration handles \ReactiveCassandraRepository\ interfaces and links them to a \ReactiveCassandraTemplate\. Additionally, Ahead-of-Time (AOT) support is provided for the synchronous repositories via a new \CassandraRepositoryContributor\, while reactive repositories are explicitly excluded from AOT code generation.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/config · high confidence

This change introduces the \DefaultSessionFactory\ and \DefaultReactiveSessionFactory\ classes, which provide singleton access to synchronous and reactive Cassandra sessions respectively. It also adds \DefaultBridgedReactiveSession\, a new implementation of \ReactiveSession\ that bridges the asynchronous Datastax \CqlSession\ API to Reactor \Mono\/\Flux\ types. The reactive session includes logic to unwrap \ObservationDecoratedProxy\ instances for proper reactive observability and defers execution until subscription, emitting results on Netty EventLoop threads.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/session · high confidence

The CQL generation logic for Cassandra schema objects (keyspaces, tables, user types, and indexes) has been restructured from a monolithic implementation into a set of specialized, single-responsibility generator classes. This change introduces a unified entry point, \CqlGenerator\, which dispatches to specific generators such as \CreateTableCqlGenerator\, \AlterTableCqlGenerator\, and \CreateIndexCqlGenerator\. This modular approach improves code maintainability and clarity for users relying on the schema generation API, as each DDL operation is now handled by a dedicated component with clear separation of concerns.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/generator · high confidence

The conversion layer in \spring-data-cassandra\ has been restructured to improve type handling and extensibility. A new \CassandraConversionContext\ now provides a dedicated context for value conversions, enabling more precise read/write operations against Cassandra rows. The \CassandraConverter\ interface has been updated to expose a \ColumnTypeResolver\, allowing for more granular resolution of column types based on properties, type information, and annotations. Additionally, the \CassandraValueConverter\ interface has been introduced to support property-level value conversions, and \CassandraVector\ has been added to handle vector data types, facilitating better integration with Cassandra's vector search capabilities.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/convert · high confidence

The Cassandra mapping subsystem has been refactored to introduce new property and entity implementations that enhance metadata handling and performance. The new \AnnotatedCassandraConstructorProperty\ and \CassandraConstructorProperty\ classes allow mapping annotations from constructor parameters, enabling better support for immutable domain objects. Additionally, \CachingCassandraPersistentProperty\ pre-computes and caches primary key and embedded flags to improve runtime performance, while \BasicCassandraPersistentEntity\ now utilizes \ConcurrentHashMap\ for thread-safe storage of constructor properties.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping · high confidence

The repository query execution engine has been rewritten to align with the Spring Data Commons 3.0 API changes. This update introduces a new execution model where query methods are dispatched through specific execution strategies (such as \SlicedExecution\, \WindowExecution\, \SearchExecution\, and \StreamExecution\) based on the return type and query characteristics. It also integrates support for Cassandra-specific features like vector search, scroll-based pagination, and query options, while adopting JSpecify annotations for nullability constraints.

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query · high confidence

The module now registers the CassandraRepositoryFactory via spring.factories, enabling automatic discovery of Cassandra repositories. It also defines the Spring XML namespace handlers and schema locations for both the legacy 'cql' namespace and the 'data/cassandra' namespace, supporting schema versions from 1.0 through 4.0 over both HTTP and HTTPS, along with IDE tooling metadata for namespace completion.

spring-data-cassandra/src/main/resources/META-INF · high confidence

The XML configuration schemas for Spring Data Cassandra (spring-cassandra and spring-cql) have been updated across versions 1.0 through 4.0. These changes introduce new configuration elements such as \<auditing\>, \<converter\>, \<cql-template\>, \<initialize-keyspace\>, and \<mapping\>, while also refining existing elements like \<cluster\> and \<session\> to support advanced driver features (e.g., address translators, auth info providers) and align with the latest DataStax Java Driver capabilities. Users relying on XML-based configuration will see new options for entity mapping, keyspace initialization, and auditing, alongside deprecated attributes in newer schema versions.

spring-data-cassandra/src/main/resources/org · high confidence

Add Cassandra domain model test fixtures; Added XML configuration test resources for Cassandra namespace integration; Added integration tests for Cassandra repository features; Added integration tests for MapId-based Cassandra repositories; Added integration tests for repository query parameter and return types; Added integration tests for repository query parameter conversion; Added test configuration files for Cassandra integration tests; Added test resources for Cassandra integration and driver configuration; Added test resources for external named queries; Added test suite for Cassandra repository support classes; Added tests for Cassandra AOT repository support; Added tests for Cassandra CQL core components; Added tests for Cassandra configuration and auditing support; Added tests for Cassandra core template operations; Added tests for Cassandra mapping events and auditing callbacks; Added tests for Cassandra observability integration; Added tests for Cassandra type mapping, conversion, and indexing; Added unit and integration tests for Cassandra CQL schema generators; Added unit tests for Cassandra AOT processing and runtime hints; Added unit tests for Cassandra keyspace initialization utilities; Added unit tests for Cassandra mapping core components; Added unit tests for Cassandra query and paging components; Added unit tests for Cassandra repository configuration and registration; Added unit tests for Cassandra session factory lookup components; Added unit tests for Kotlin CQL extensions and DataClassRowMapper; Added unit tests for Kotlin Cassandra operations extensions; Added unit tests for Kotlin Coroutine repository behavior; Added unit tests for Kotlin coroutine repository query methods; Added unit tests for Kotlin query extension functions; Added unit tests for StatementBuilder; New test infrastructure and unit tests for Cassandra repository fragments; New test infrastructure for Cassandra integration tests.

This change establishes the dependency configuration for the 5.2.0-SNAPSHOT release of Spring Data for Apache Cassandra. It sets the Cassandra server version to 5.0.3 and the DataStax Java Driver version to 4.19.3. The build also integrates Micrometer Observation and Tracing as optional dependencies for observability, includes RxJava 3 support, and configures Testcontainers for integration testing.

(dependencies) · high confidence

The Maven Wrapper configuration has been updated to use Apache Maven 3.9.16. This ensures that builds executed via the wrapper will consistently use this specific Maven version, aligning with the latest wrapper standards and potentially benefiting from associated bug fixes and performance improvements.

.mvn/wrapper · high confidence

The project has standardized its documentation and build setup by introducing a new README.adoc with comprehensive usage examples, adding CONTRIBUTING.adoc and SECURITY.adoc guidelines, and implementing a Maven Wrapper (mvnw/mvnw.cmd) to ensure consistent builds. Additionally, a .gitignore file was added to exclude build artifacts and IDE configurations, while the legacy README file was removed.

(repo-wide) · high confidence

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

• First survey — no prior run to compare against. CAI 57.

• Code Health 89
• Architecture 65
• Maturity 57
• Readiness 61
• Security 52

• 300 commits — 292 feature/other, 8 fixes

• (root) — 136 commits
• spring-data-cassandra/src — 104 commits
• src/main — 19 commits
• ci/pipeline.properties — 15 commits
• .github/workflows — 8 commits
• .mvn/wrapper — 6 commits
• .mvn/extensions.xml — 3 commits
• (repo) — 2 commits
• .github/README.template.adoc — 2 commits
• .github/dco.yml — 1 commit
• .mvn/jvm.config — 1 commit
• ci/openjdk21-8-cassandra-3.11 — 1 commit
• spring-data-cassandra-distribution/pom.xml — 1 commit
• spring-data-cassandra/pom.xml — 1 commit

• fix: Fix Antora reference warnings.
• fix: Fix ClassCastException in ObservationRequestTracker.
• fix: Fix example code highlighting for reactive examples.
• fix: Fix flaky test in BasicCassandraPersistentTupleEntityUnitTests.
• fix: Fix paging for query methods.
• fix: Fix prepared statement caching using observability.
• fix: Fix unpaged slice execution.
• fix: Fixed the URL for the Spring Data Commons documentation.
• change: Accept BatchableStatement in CassandraBatchOperations.
• change: Accept PagingState when creating CassandraScrollPosition and in Query.pagingState.
• change: Adapt tests to MappingException cause when entity creation fails.
• change: Adapt to AOT Infrastructure changes in Commons.
• change: Adapt to changed PersistentProperty interface.
• change: Adapt to changes in Spring Data Commons.
• change: Adapt to changes in Spring Framework.
• change: Add AOT support for Streamable wrapper support.
• change: Add Ahead of Time Repository support.
• change: Add CodeQL workflow.
• change: Add Contract annotations.
• change: Add GitHub actions CI.
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

spring-projects/spring-data-cassandra 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.