Skip to content
CAI
Software that uses CAICheck a score

spring-projects/spring-data-commons

55.5

Adequate · 9 November 2026

79.6k

lines of production code

Java

primary language

9

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add findByIdOrNull extension for Kotlin repositories

A new Kotlin extension function \findByIdOrNull\ has been added to \CrudRepository\, allowing users to retrieve an entity by its ID and receive \null\ directly if the entity is not found, rather than handling an \Optional\.

src/main/kotlin/org/springframework/data/repository · high confidence

Add multi-manager transaction orchestration and synchronization support

This change introduces new classes to support coordinating transactions across multiple Spring \PlatformTransactionManager\ instances. \MultiTransactionStatus\ acts as a composite \TransactionStatus\ that delegates commit, rollback, and savepoint operations to a map of underlying transaction managers, enabling best-effort multi-resource transaction handling. A new \SynchronizationManager\ interface and its \SpringTransactionSynchronizationManager\ implementation provide a strategy for delegating transaction synchronization lifecycle events (init, active check, clear) to Spring's core \TransactionSynchronizationManager\. Additionally, the legacy \ChangedSetBackedTransactionSynchronization\ class has been removed, cleaning up obsolete change-set tracking logic.

src/main/java/org/springframework/data/transaction · high confidence

Added AOT runtime hints for Querydsl repositories

A new \QuerydslHints\ class has been introduced in the \org.springframework.data.querydsl.aot\ package to register reflection hints required for bootstrapping Querydsl repositories at build time. This ensures that \Predicate\, \QuerydslPredicateExecutor\, and \ReactiveQuerydslPredicateExecutor\ types are preserved for runtime reflection when using Ahead-of-Time compilation, with specific support for Project Reactor if present.

src/main/java/org/springframework/data/querydsl/aot · high confidence

Added JAXB schemas for Atom and Spring Data pagination

New XML Schema Definition (XSD) files have been added to the classpath to support JAXB marshalling and unmarshalling of Atom syndication formats and Spring Data pagination structures. The \atom.xsd\ file defines the structure for Atom feeds and entries (including elements like title, link, author, and content), while \spring-data-jaxb.xsd\ defines the schema for pagination objects such as page requests, page content, and sort orders. These resources enable applications to serialize and deserialize domain objects into standard Atom XML and Spring Data pagination XML formats.

src/main/resources/org/springframework/data/domain · high confidence

Added formatters for Point and Distance types

New formatters have been introduced to parse and print geo-spatial types. The DistanceFormatter converts strings in the format of a decimal followed by a metric abbreviation (e.g., '10.5 km') into Distance instances, while the PointFormatter parses comma-separated doubles (e.g., '52.5,13.4') into Point instances. These formatters are now available for use in Spring's conversion and formatting infrastructure.

src/main/java/org/springframework/data/geo/format · high confidence

Added native image runtime hints for web support

A new \WebRuntimeHints\ class has been introduced to provide reflection hints for Spring Data web components in native images. This ensures that \PagedModel\, \PageMetadata\, and related Jackson converters are correctly registered for both Jackson 2 and Jackson 3, preventing runtime failures when serializing paginated data in GraalVM native images.

src/main/java/org/springframework/data/web/aot · high confidence

Configure Spring AOT processing for native image support

Added src/main/resources/META-INF/spring/aot.factories to register AOT processors and runtime hints required for native image builds. This includes BeanFactoryInitializationAotProcessor for managed types, BeanRegistrationAotProcessor for auditing, and RuntimeHintsRegistrars for repository, Querydsl, and web components, ensuring these features work correctly in ahead-of-time compiled environments.

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

First-class type-safe Kotlin property path references

Spring Data Core now provides Kotlin-specific extensions for building type-safe property paths. Developers can use the \toPropertyPath()\ extension on \KProperty1\ references to create \TypedPropertyPath\ instances, and compose nested paths using the \/\ operator (e.g., \Book::author / Author::name\). The \PropertyReference\ class also gains a \then()\ extension to append \KProperty\ segments to existing paths, enabling more idiomatic and type-safe query construction in Kotlin applications.

src/main/kotlin/org/springframework/data/core · high confidence

Initial Spring XML namespace and extension configuration

This release introduces the core Spring configuration metadata files required for XML-based setup and IDE support. The \spring.schemas\ file now maps repository namespace XSDs (versions 1.0 through 2.1, including HTTPS variants) to their local resources, while \spring.handlers\ registers the namespace handlers for the \repository\ and \keyvalue\ schemas. Additionally, \spring.factories\ configures internal extension points, including Kotlin bean info, custom collection support for Vavr and Eclipse Collections, and Jackson module registrations for both standard and Jackson 3. The \spring.tooling\ file provides IDE hints for the repository namespace.

src/main/resources/META-INF · high confidence

Initial project scaffolding with documentation, license, and build tools

The repository has been initialized with the foundational structure for Spring Data Commons. This includes the Apache 2.0 license file, a comprehensive README with Maven configuration and build instructions, and a security policy for reporting vulnerabilities. To streamline development, Maven wrapper scripts (mvnw, mvnw.cmd) and a .gitignore file have been added, alongside contribution guidelines and a Sonargraph architecture description to enforce code structure.

(repo-wide) · high confidence

Introduce AOT repository generation infrastructure

This change adds the core infrastructure for generating Spring Data repository implementations at build time (Ahead-of-Time). It introduces a new set of classes in the \org.springframework.data.repository.aot.generate\ package, including builders for repository classes, constructors, and query methods, alongside support for fragment metadata and bean definition decoration. The implementation also bundles a lightweight, non-free-compatible JSON parser to handle repository JSON metadata serialization, and provides an \ExpressionMarker\ to assist with SpEL expression evaluation in generated code. This lays the groundwork for faster startup and reduced memory footprint by pre-generating repository proxies and query methods.

src/main/java/org/springframework/data/repository/aot/generate · high confidence

Introduce Entity Callback API for reactive and synchronous event handling

Adds a new \EntityCallback\ API in \org.springframework.data.mapping.callback\ that allows registering and invoking callbacks for domain entities. The package includes \EntityCallback\ as the base marker interface, \EntityCallbacks\ for synchronous invocation, and \ReactiveEntityCallbacks\ for reactive (Reactor \Mono\) invocation. Implementations (\DefaultEntityCallbacks\, \DefaultReactiveEntityCallbacks\) and the \EntityCallbackDiscoverer\ handle callback discovery, type matching, ordering, and invocation, enabling store-specific modules to hook into entity lifecycle events.

src/main/java/org/springframework/data/mapping/callback · high confidence

Introduce Kotlin Coroutines support for Spring Data repositories

This release adds a new Kotlin-specific repository API under the \org.springframework.data.repository.kotlin\ package, enabling developers to use Kotlin Coroutines for data access. The new \CoroutineCrudRepository\ interface provides standard CRUD operations (save, find, delete) as suspend functions or returning \Flow\ streams, while \CoroutineSortingRepository\ adds sorting capabilities. This allows Kotlin applications to leverage non-blocking, coroutine-based interactions with the persistence layer.

src/main/kotlin/org/springframework/data/repository/kotlin · high confidence

Introduce Value Expression evaluation infrastructure

The mapping model package now includes a caching factory for evaluating Value Expressions, allowing users to define and resolve dynamic expressions within their domain models. This addition provides a dedicated mechanism for expression evaluation that integrates with the existing property access and mapping context.

src/main/java/org/springframework/data/mapping/model · high confidence

Introduce new history API interfaces and value objects

This change introduces the core types for the Spring Data history API, including the \RevisionMetadata\ interface (with a \RevisionType\ enum for tracking insert/update/delete operations), the \Revision\ wrapper for entity snapshots, and the \Revisions\ collection for accessing revision history. It also adds \AnnotationRevisionMetadata\ to extract revision data via annotations, \RevisionSort\ for ordering revisions, and applies JSpecify nullability annotations across the package.

src/main/java/org/springframework/data/history · high confidence

Introduces FluentQuery API and refactors parameter handling infrastructure

Users can now construct repository queries using a new fluent interface via the \FluentQuery\ and \FetchableFluentQuery\ APIs, allowing method chaining for sorting, limiting, and projecting results. The \QueryByExampleExecutor\ and \ReactiveQueryByExampleExecutor\ have been extended to support this fluent query style through a new \findBy\ method. Additionally, the internal parameter handling has been refactored with the introduction of \ParametersSource\ and \DefaultParameters\, and the \QueryByExampleExecutor\ now includes a \ListQueryByExampleExecutor\ variant that returns \List\ results instead of \Iterable\ for more convenient collection handling.

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

Introduction of JavaConfig support for auditing

The auditing subsystem now supports configuration via Spring's JavaConfig model alongside existing XML parsing. A new \AuditingConfiguration\ interface and its \AnnotationAuditingConfiguration\ implementation allow users to define auditing settings (such as \AuditorAware\ and \DateTimeProvider\ references) directly through annotation metadata. This is backed by \AuditingBeanDefinitionRegistrarSupport\, which registers the necessary \AuditingHandler\ beans programmatically, enabling a more modern, type-safe configuration approach for Spring Data auditing.

src/main/java/org/springframework/data/auditing/config · high confidence

Introduction of List-based repository interfaces

The repository abstraction now includes \ListCrudRepository\ and \ListPagingAndSortingRepository\ interfaces that extend the existing \CrudRepository\ and \PagingAndSortingRepository\ respectively. These new interfaces return \List\ types instead of \Iterable\ for methods like \saveAll\, \findAll\, and \findAllById\, providing a more convenient and predictable collection type for users who prefer list semantics over generic iteration.

src/main/java/org/springframework/data/repository · high confidence

Introduction of RevisionRepository for entity history tracking

A new RevisionRepository interface has been added to the Spring Data repository API, enabling users to access and query historical revisions of entities. This interface extends the base Repository interface and provides methods to retrieve the last change revision, fetch all revisions for a specific entity ID, retrieve paged revisions with optional sorting, and find a specific entity state at a given revision number. Supporting classes include RevisionEntityInformation for managing revision metadata and package-level nullability annotations via JSpecify.

src/main/java/org/springframework/data/repository/history · high confidence

New AOT processing infrastructure for mapping context

Spring Data Commons introduces a new AOT (Ahead-of-Time) processing infrastructure to support native image builds and optimized startup. This change adds the \AotMappingContext\ class, which provides a specialized mapping context for processing AOT contributions by capturing entity instantiators and property accessors, and the \DefaultAotContext\ class, which serves as the default implementation of the \AotContext\ interface to manage type configurations and reflective runtime hints during AOT processing. Also in this area: 3 commits (1 fix) modifying src/main; Improved lambda unwrapping in PropertyPathUtil; Introduce type-safe property path references.

src/main/java/org/springframework/data/core · medium confidence · unverified

New AOT runtime hints for Spring Data repositories

A new \RepositoryRuntimeHints\ component has been added to the \org.springframework.data.repository.aot.hint\ package to provide the reflection and proxy hints required for bootstrapping Spring Data repositories in ahead-of-time (AOT) compiled environments. This change ensures that key repository infrastructure classes, such as factory beans, metadata, and query executors (including reactive variants when Project Reactor is present), are registered for reflection access, and that necessary JDK proxies are configured for repository method contexts.

src/main/java/org/springframework/data/repository/aot/hint · high confidence

New AOT-ready repository configuration infrastructure

Spring Data now includes a dedicated configuration layer for Ahead-of-Time (AOT) processing, introducing the \AotRepositoryContext\ and \AotRepositoryInformation\ interfaces and implementations to capture repository metadata at build time. This change adds the \BootstrapMode\ enumeration, allowing applications to explicitly control repository initialization timing (DEFAULT, DEFERRED, or LAZY) to optimize startup performance. The \CustomRepositoryImplementationDetector\ has been introduced to handle the detection of custom repository implementations and fragments with improved scanning and filtering capabilities. Additionally, new factory beans like \PropertiesBasedNamedQueriesFactoryBean\ and \PersistentEntitiesFactoryBean\ reduce bean indirections, while the \RepositoryBeanDefinitionReader\ and \RepositoryBeanNameGenerator\ provide the necessary wiring to support these AOT-specific requirements.

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

New JAXB adapters for Spring Data domain types

Added a new \org.springframework.data.domain.jaxb\ package containing \XmlAdapter\ implementations for \Page\, \Pageable\, \Sort\, and \Order\ domain types. This enables direct marshalling and unmarshalling of these objects to and from XML representations (DTOs) using the Jakarta EE 9 JAXB API, facilitating integration with XML-based web services.

src/main/java/org/springframework/data/domain/jaxb · high confidence

New MappingContext API for property path resolution and entity management

The mapping context package now exposes a refined API for resolving property paths and managing persistent entities. A new InvalidPersistentPropertyPath exception provides detailed context—including the unresolvable segment, resolved path, and potential matches—when a property path cannot be fully resolved. The MappingContext interface adds methods to retrieve persistent entities by TypeInformation or PersistentProperty, and to resolve property paths via dot notation or PropertyPath objects, throwing InvalidPersistentPropertyPath on failure. PersistentEntities serves as a value object to aggregate entities across multiple MappingContexts, supporting lazy creation and type inspection. PersistentPropertyPathFactory introduces caching via ConcurrentLruCache for improved performance when resolving property paths, and ReflectionFallbackPersistentPropertyAccessorFactory provides a fallback mechanism for property accessors when class generation is not supported.

src/main/java/org/springframework/data/mapping/context · high confidence

New Querydsl binding interfaces and factory infrastructure

The Querydsl binding package now exposes a set of new functional interfaces and factory components to customize how HTTP request parameters map to Querydsl predicates. Users can define custom logic via the new \MultiValueBinding\, \SingleValueBinding\, and \OptionalValueBinding\ interfaces, which allow fine-grained control over how collection, single, and optional values are bound to entity paths. The \QuerydslBindingsFactory\ centralizes the creation of \QuerydslBindings\ for domain types, supporting auto-detection of \QuerydslBinderCustomizer\ beans and a new \QuerydslBinderCustomizerDefaults\ interface for applying global customization rules across all entities. Additionally, the \QuerydslPredicateBuilder\ has been updated to leverage these new bindings and a thread-safe path cache, while the \QuerydslPredicate\ annotation now explicitly supports specifying a custom binder class.

src/main/java/org/springframework/data/querydsl/binding · high confidence

New Querydsl web argument resolvers for MVC and WebFlux

This change introduces two new classes, QuerydslPredicateArgumentResolver and ReactiveQuerydslPredicateArgumentResolver, which allow Spring MVC and Spring WebFlux controllers to directly inject Querydsl Predicates from HTTP request parameters. The MVC resolver implements HandlerMethodArgumentResolver to process query parameters into a Predicate, while the reactive resolver implements SyncHandlerMethodArgumentResolver for WebFlux. Both rely on QuerydslBindingsFactory for binding configuration and are part of the new org.springframework.data.web.querydsl package, which is marked as null-safe via JSpecify annotations.

src/main/java/org/springframework/data/web/querydsl · high confidence

New SPI package for SpEL evaluation context extensions

A new \org.springframework.data.spel.spi\ package has been introduced to allow users to extend the Spring Expression Language (SpEL) evaluation context. This package provides the \EvaluationContextExtension\ interface for exposing custom properties, functions, and root objects in standard evaluations, and the \ReactiveEvaluationContextExtension\ interface for doing the same in reactive contexts via \Mono\. These interfaces enable developers to register custom extensions that are accessible at the root of the evaluation context, with support for ordering and unique identification to resolve property name ambiguities.

src/main/java/org/springframework/data/spel/spi · high confidence

New SpEL evaluation context provider SPIs and reactive support

The \org.springframework.data.spel\ package now exposes a dedicated SPI for managing SpEL evaluation contexts, introducing the \EvaluationContextProvider\ and \ReactiveEvaluationContextProvider\ interfaces to allow centralized, configurable context creation. It also adds \ReactiveExtensionAwareEvaluationContextProvider\ to assemble contexts from reactive extensions and a \Functions\ utility to resolve SpEL function overloads by name and argument types, enabling more robust and reactive SpEL expression evaluation in Spring Data repositories.

src/main/java/org/springframework/data/spel · high confidence

New Spring Data AOT processing infrastructure for Ahead-of-Time compilation

This release introduces a new \org.springframework.data.aot\ package that provides the core infrastructure for processing Spring Data repositories and types ahead of time. It includes \AotContext\ and \AotTypeConfiguration\ to manage AOT settings and type hints, \ManagedTypesBeanFactoryInitializationAotProcessor\ to preprocess bean definitions, and specific processors like \AuditingBeanRegistrationAotProcessor\ to register runtime hints for auditing beans. This enables better compatibility with native image compilation by pre-registering reflection, proxy, and resource requirements.

src/main/java/org/springframework/data/aot · high confidence

New TypeNames utility for JavaPoet type resolution

A new TypeNames utility class has been added to the org.springframework.data.javapoet package to provide opinionated extensions for JavaPoet. This class offers static methods to convert Spring Data's ResolvableType and Class objects into JavaPoet TypeName instances, handling primitive wrappers, generic type resolution, and array types. This enables more robust type representation when generating code with JavaPoet within Spring Data contexts.

src/main/java/org/springframework/data/javapoet · high confidence

New Value Expression infrastructure for query methods

This release introduces a new expression evaluation infrastructure in the \org.springframework.data.expression\ package, providing the core abstractions for parsing and evaluating value expressions in query methods. The change adds the \ValueExpression\ interface for encapsulating parsed expression strings and evaluating them against a context, along with \ValueExpressionParser\ and \ValueParserConfiguration\ to handle the parsing of SpEL and property placeholder syntax. It also introduces \ValueEvaluationContext\ and \ValueEvaluationContextProvider\ to manage the environment and evaluation state, including a \ReactiveValueEvaluationContextProvider\ for reactive flows. These components work together to allow query methods to resolve dynamic values and dependencies during execution.

src/main/java/org/springframework/data/expression · high confidence

New XML namespace configuration utilities

The \org.springframework.data.config\ package now includes helper classes (\BeanComponentDefinitionBuilder\, \ParsingUtils\, \TypeFilterParser\) and a \ConfigurationUtils\ interface to simplify the creation of custom Spring XML namespaces and JavaConfig. These utilities handle bean definition building, property extraction from XML elements, and type filter parsing, enabling more robust and standardized configuration support for Spring Data modules.

src/main/java/org/springframework/data/config · high confidence

New and updated core mapping annotations

This release introduces several new annotations to enhance entity mapping and metadata control: @AccessType allows explicit control over whether fields or properties are accessed; @Immutable marks persistent entities as immutable; @ReadOnlyProperty prevents specific fields from being persisted; @Reference helps define target types for object references; and @PersistenceCreator designates preferred constructors or factory methods for object creation. Existing annotations have also been updated: @TypeAlias is now meta-annotated with @Persistent to ensure it is included in the persistent entity metamodel, and @Transient now supports RECORD\_COMPONENT for Java records. Additionally, audit-related annotations (@CreatedBy, @CreatedDate, @LastModifiedBy, @LastModifiedDate) are standardized, and the package is marked with @NullMarked for null-safety validation.

src/main/java/org/springframework/data/annotation · high confidence

New core repository metadata and context abstractions

The repository core package now exposes dedicated interfaces for entity and repository metadata, including \EntityInformation\ (with a new \getRequiredId\ method), \EntityMetadata\, \CrudMethods\ (standardizing access to save, find, and delete operations), \RepositoryInformation\, and \RepositoryMetadata\ (enhanced with full type information and fragment support). Additionally, \RepositoryMethodContext\ and \RepositoryMethodContextHolder\ are introduced to allow optional exposure of the current repository method's metadata during invocation, enabling advanced use cases like auditing or dynamic behavior based on the invoked method.

src/main/java/org/springframework/data/repository/core · high confidence

New domain abstractions for pagination, auditing, and vector search scoring

The \org.springframework.data.domain\ package introduces several new core types to support advanced data access patterns. For pagination, \AbstractPageRequest\ and \Chunk\ provide base implementations for \Pageable\ and \Slice\, while \PageRequest\ and \Pageable\ are expanded with methods like \previousOrFirst\ and \toLimit\. For domain-driven design, \DomainEvents\ and \AfterDomainEventPublication\ annotations allow aggregate roots to publish application events, supported by \Auditable\ and \AuditorAware\ interfaces for tracking entity lifecycle changes. Additionally, new \Score\, \Similarity\, and \ScoringFunction\ types are added to support vector search ranking and similarity calculations.

src/main/java/org/springframework/data/domain · high confidence

New geospatial value types and Jackson serialization modules

This release introduces a comprehensive set of value objects for geospatial data, including Point, Distance, Box, Circle, Polygon, Metric, and Metrics, along with GeoResult and GeoPage to carry distance information with query results. To support serialization, it adds GeoModule for Jackson 2 and GeoJacksonModule for Jackson 3, enabling the (de)serialization of these new geo-spatial types in JSON payloads.

src/main/java/org/springframework/data/geo · high confidence

New infrastructure for typed property paths and AOT processing

Spring Data Commons introduces a new typed property path API (including \TypedPropertyPath\, \PropertyReference\, and \SerializableLambdaReader\) that allows developers to reference domain properties using type-safe lambda expressions instead of string-based dot notation. This change also adds a new \DefaultAotContext\ and \TypedPropertyPathFeature\ to support GraalVM native image builds by automatically registering the necessary reflection and serialization hints for these lambda-based property references at build time.

spring-data-commons · high confidence

New mapping subsystem core interfaces and value objects

The mapping package now introduces a foundational set of interfaces and value objects to support entity mapping and property access. This includes the \PersistentEntity\ and \PersistentProperty\ interfaces for representing entity metadata, \PersistentPropertyAccessor\ and \PersistentPropertyPathAccessor\ for reading and writing property values (including support for immutable objects via wither methods), and \Association\/\AssociationHandler\ for modeling relationships. Additionally, \InstanceCreatorMetadata\, \PreferredConstructor\, and \FactoryMethod\ provide the infrastructure for creating entity instances via constructors or factory methods, while \IdentifierAccessor\ and \TargetAwareIdentifierAccessor\ standardize identifier retrieval.

src/main/java/org/springframework/data/mapping · high confidence

New projection infrastructure for repository queries

The projection subsystem has been expanded with new core components to support projections on repository queries. This includes the \EntityProjectionIntrospector\ for analyzing domain types and reachable properties, the \Accessor\ helper for abstracting property getters and setters, and the \MethodInterceptorFactory\ SPI for customizing proxy method handling. Additionally, \ProjectionInformation\ now exposes \getInputProperties()\ to distinguish between properties required for projection creation and those resolved dynamically, and \TargetAware\ provides access to the underlying proxy target instance.

src/main/java/org/springframework/data/projection · high confidence

New property-specific converters and fluent registration API

Spring Data now supports converters that apply to specific properties rather than just global type pairs. This change introduces the \PropertyValueConverter\ SPI, along with \PropertyValueConversionService\ and \PropertyValueConversions\ to manage these targeted conversions. A new \ConverterBuilder\ API allows users to register these converters fluently using Java 8 lambdas. Additionally, the \convert\ package now includes built-in converters for JSR-310 date/time types (via \Jsr310Converters\) and support for jMolecules domain types (via \JMoleculesConverters\).

src/main/java/org/springframework/data/convert · high confidence

New reactive repository interfaces for Project Reactor and RxJava 3

This location introduces the core reactive repository abstractions: ReactiveCrudRepository and ReactiveSortingRepository for Project Reactor (Mono/Flux), and RxJava3CrudRepository and RxJava3SortingRepository for RxJava 3 (Single/Maybe/Flowable/Completable). These interfaces provide standard CRUD and sorting operations using reactive streams, enabling developers to build non-blocking data access layers with their preferred reactive library.

src/main/java/org/springframework/data/repository/reactive · high confidence

New support utilities and removal of legacy ChangeSet APIs

This update introduces new support classes in the \org.springframework.data.support\ package: \IsNewStrategy\ and \PersistableIsNewStrategy\ for entity newness detection, \PageableExecutionUtils\ and \ReactivePageableExecutionUtils\ for optimized page construction, and \PlaceholderResolver\ for text resolution. Simultaneously, the legacy ChangeSet synchronization interfaces (\ChangeSetBacked\, \ChangeSetSynchronizer\) and the \SerializationStore\ annotation have been removed.

src/main/java/org/springframework/data/support · high confidence

New utility classes for annotation scanning, Kotlin introspection, and lazy evaluation

This release introduces several new utility classes in the \org.springframework.data.util\ package to enhance type scanning, Kotlin support, and resource management. \AnnotatedTypeScanner\ provides a configurable way to find types with specific annotations on the classpath, including support for interfaces. \KotlinBeanInfoFactory\ and \KotlinReflectionUtils\ improve Kotlin integration by using Kotlin reflection to determine bean properties, handle value classes, and detect suspend functions. \Lazy\ offers a simple value type for delayed object creation with \orElse\ and \or\ fallback methods. Additionally, \CloseableIterator\ serves as a bridging data structure for streaming results with proper resource cleanup, and \DirectFieldAccessFallbackBeanWrapper\ extends \BeanWrapperImpl\ to fall back to direct field access when accessor methods are unavailable.

src/main/java/org/springframework/data/util · high confidence

New utility classes for repository execution and reactive wrapper conversion

The repository utility package now includes QueryExecutionConverters, which provides conversion support for wrapping repository method return values into types such as Future, CompletableFuture, Vavr collections, and NullableWrappers. Additionally, ReactiveWrapperConverters has been introduced to handle conversion between reactive wrapper types (including RxJava 3, Project Reactor, Kotlin Coroutines, and Smallrye Mutiny) based on classpath availability, while TxUtils offers a constant for the default transaction manager name.

src/main/java/org/springframework/data/repository/util · high confidence

New web integration components for pagination, sorting, and projections

This release introduces several new handler method argument resolvers and supporting classes in the web package to enhance request binding. It adds support for offset-based scrolling via \OffsetScrollPositionHandlerMethodArgumentResolver\ and its reactive counterpart, allowing controllers to accept \OffsetScrollPosition\ parameters. Sorting and pagination capabilities are expanded with \HateoasSortHandlerMethodArgumentResolver\ for URI enhancement and updated \PageableHandlerMethodArgumentResolverSupport\ with new configuration options like \oneIndexedParameters\. Additionally, the framework now supports binding JSON payloads to projection interfaces using the new \@ProjectedPayload\ and \@JsonPath\ annotations, facilitated by \ProxyingHandlerMethodArgumentResolver\ and \ProjectingJackson2HttpMessageConverter\.

src/main/java/org/springframework/data/web · high confidence

Querydsl integration support classes

This change introduces the core Querydsl integration package for Spring Data, providing the foundational interfaces and utilities needed to execute Querydsl predicates against repositories. It adds the \QuerydslPredicateExecutor\ interface for synchronous queries (returning \Optional\<T\>\ for single results and \Iterable\<T\>\ for collections) and the \ReactiveQuerydslPredicateExecutor\ for reactive streams using \Mono\ and \Flux\. Additionally, it includes \ListQuerydslPredicateExecutor\ to allow returning \List\ results instead of \Iterable\, \QPageRequest\ for Querydsl-aware pagination, \EntityPathResolver\ for domain class to entity path translation, and \QuerydslRepositoryInvokerAdapter\ to bridge Querydsl execution with the repository invocation mechanism.

src/main/java/org/springframework/data/querydsl · high confidence

Web configuration now supports Jackson 3 and offers resolver customizers

The web configuration module now includes support for Jackson 3 alongside the existing Jackson 2 support, allowing applications using the newer Jackson version to benefit from Spring Data's serialization features. Additionally, the framework introduces customizer interfaces for Pageable, Sort, and OffsetScrollPosition argument resolvers, giving users finer control over how these web arguments are processed. The configuration also registers a ProxyingHandlerMethodArgumentResolver to enhance projection handling in Spring MVC controllers.

src/main/java/org/springframework/data/web/config · high confidence

Behavioural changes

Add TypedPropertyPathFeature to Spring Data Commons native-image metadata

A new native-image configuration file for spring-data-commons has been added, registering the TypedPropertyPathFeature. This ensures that the feature is included in the reflection and proxy metadata during native image compilation, which is necessary for correct runtime behavior of Spring Data Commons in GraalVM native images.

src/main/resources/META-INF/native-image · high confidence

Auditing subsystem refactored with new wrapper interfaces and mapping-based property access

The auditing infrastructure in \org.springframework.data.auditing\ has been restructured to use a new \AuditableBeanWrapper\ interface and \AuditableBeanWrapperFactory\ for setting auditing values, replacing the previous reflection-based approach. The \MappingAuditableBeanWrapperFactory\ now leverages \PersistentPropertyAccessor\ and \PersistentPropertyPathAccessor\ to detect and populate auditing fields (such as \@CreatedBy\ and \@LastModifiedDate\) via mapping metadata, enabling support for nested object paths and immutable entities. Additionally, the \AuditingHandler\ and \ReactiveAuditingHandler\ have been updated to use these new factories, and the \Auditor\ value object was introduced to encapsulate auditor information.

src/main/java/org/springframework/data/auditing · high confidence

CDI repository integration migrated to Jakarta EE 9

The CDI repository support has been updated to use the Jakarta EE 9 namespace (e.g., \jakarta.enterprise.\\ instead of \javax.enterprise.\\) and the JSpecify library for nullability annotations. This change ensures compatibility with modern Jakarta EE application servers and provides more robust type safety for null checks within the repository infrastructure.

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

Deprecation of Kotlin property path utilities in favor of core extensions

The Kotlin property path utilities in the \mapping\ module, including \KPropertyPath\, \KIterablePropertyPath\, and the \toDotPath\/\asString\ extension functions, are now deprecated. Users should migrate to the equivalent extensions provided in the \org.springframework.data.core\ package to ensure continued support and access to updated functionality.

src/main/kotlin/org/springframework/data/mapping · high confidence

Introduce dedicated RepositoryInvoker implementations for direct method execution

Spring Data now uses specialized invokers (CrudRepositoryInvoker and PagingAndSortingRepositoryInvoker) to execute CRUD methods directly on repository instances, bypassing reflection when the repository implements CrudRepository or PagingAndSortingRepository. This optimization reduces invocation overhead and improves performance for standard repository operations, while the DefaultRepositoryInvokerFactory automatically selects the most efficient invoker based on the repository's interface hierarchy.

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

Jackson 3 support for repository initialization with Jackson 2 deprecation

The repository initialization subsystem now supports Jackson 3 for JSON-based data loading, introducing new classes such as JacksonResourceReader and JacksonRepositoryPopulatorFactoryBean that use the tools.jackson.databind API. The previous Jackson 2 implementations (Jackson2ResourceReader and Jackson2RepositoryPopulatorFactoryBean) are now deprecated since version 4.0 and scheduled for removal, directing users to adopt the new Jackson 3-based components for initializing repositories from JSON resources.

src/main/java/org/springframework/data/repository/init · high confidence

New query parser components and nullability annotations

The query parser package now includes new helper classes \OrderBySource\ and \Part\ to handle sorting clauses and individual method-name parts for derived queries, alongside a \package-info.java\ that applies JSpecify \@NullMarked\ nullability constraints to the package.

src/main/java/org/springframework/data/repository/query/parser · high confidence

Repository core infrastructure refactored with new metadata and composition models

The repository core support package has been significantly restructured to introduce a new \RepositoryComposition\ and \RepositoryFragment\ model, allowing repositories to be composed of multiple implementation classes and custom method overrides. This change introduces new base classes like \AbstractRepositoryMetadata\ and \AbstractEntityInformation\, alongside specific implementations such as \DefaultRepositoryMetadata\ (for generic \Repository\ interfaces) and \AnnotationRepositoryMetadata\ (for \@RepositoryDefinition\ annotated interfaces). The diff also adds \DefaultRepositoryInformation\ to manage the composition of base classes and fragments, \MethodLookup\ strategies for resolving method implementations within composite repositories, and \QueryExecutionResultHandler\ for post-processing query results. Additionally, support for reactive repositories is formalized via \ReactiveRepositoryFactorySupport\, and new exception types like \FragmentNotImplementedException\ and \IncompleteRepositoryCompositionException\ are introduced to handle composition errors.

src/main/java/org/springframework/data/repository/core/support · high confidence

Updated repository namespace schemas with new configuration options

The Spring Data repository XML namespace schemas (XSDs) have been updated to support several new configuration capabilities. Users can now define a custom base class for repositories via the new \base-class\ attribute (replacing the deprecated \factory-class\), and control whether nested repository interfaces are scanned using the \consider-nested-repositories\ flag. JSON population is now supported via Jackson 2 (\jackson2-populator\), while the legacy Jackson 1 populator is deprecated. Additionally, auditing configuration has been expanded with a \modify-on-creation\ flag to control whether entities are marked as modified upon creation, and a \bootstrap-mode\ attribute has been introduced to manage repository initialization timing.

src/main/resources/org/springframework/data/repository · high confidence

Test coverage

Added ArchUnit tests for dependency cycles; Added HidingClassLoader test utility; Added JMH benchmarks for property path and lambda reader performance; Added Kotlin test fixtures for projection scenarios; Added Kotlin unit tests for query parameter handling; Added integration and unit tests for repository initialization; Added integration tests for ChainedTransactionManager; Added integration tests for Spring Data Web configuration; Added sample configurations for AOT repository processing tests; Added sample test fixtures for repository interfaces and configuration; Added test configuration for CDI extension and Spring factories; Added test fixture for Querydsl package suffix support; Added test fixtures for Kotlin mapping context tests; Added test fixtures for Spring Data AOT type processing; Added test fixtures for default package handling; Added test fixtures for repository and interface scenarios; Added test resources for JAXB integration and test configuration; Added test resources for Jackson 2 repository population; Added test utilities to exclude packages from the classpath; Added tests for AOT repository registration contributions; Added tests for CDI repository composition and fragment support; Added tests for Kotlin data class and value class mapping; Added tests for the findByIdOrNull extension; Added tests for the mapping context subsystem; Added unit and integration tests for Spring Data projection infrastructure; Added unit and integration tests for geo value objects and Jackson serialization; Added unit and integration tests for repository support components; Added unit tests for AOT repository generation infrastructure; Added unit tests for AuditingBeanDefinitionRegistrarSupport; Added unit tests for Distance and Point formatters; Added unit tests for JavaPoet code generation and type resolution; Added unit tests for KPropertyPath and its extensions; Added unit tests for Kotlin coroutine repository metadata; Added unit tests for Kotlin coroutine repository support; Added unit tests for Kotlin property path and reference utilities; Added unit tests for KotlinBeanInfoFactory; Added unit tests for OrderBySource and PartTree query parsing; Added unit tests for PropertyValueConversionService; Added unit tests for QueryExecutionConverters and ReactiveWrapperConverters; Added unit tests for Querydsl binding components; Added unit tests for Querydsl predicate argument resolvers; Added unit tests for SpEL evaluation context infrastructure; Added unit tests for SpEL function and parameter type detection; Added unit tests for Spring Data AOT infrastructure; Added unit tests for Spring Data History components; Added unit tests for Spring Data JAXB conversions; Added unit tests for Spring Data conversion subsystem components; Added unit tests for Spring Data domain types; Added unit tests for Spring Data mapping core components; Added unit tests for Spring Data utility classes; Added unit tests for Spring Data web argument resolvers and serialization; Added unit tests for TypeAlias annotation scanning; Added unit tests for ValueExpression parsing and evaluation; Added unit tests for WebRuntimeHints registration logic; Added unit tests for core type, property, and conversion utilities; Added unit tests for data support utilities; Added unit tests for entity callback discovery and dispatch; Added unit tests for repository configuration infrastructure; Added unit tests for repository core support components; Added unit tests for repository query parameter handling and projection logic; Added unit tests for the Spring Data Auditing subsystem; Expanded test coverage for Spring Data mapping model components.

Dependencies

Migrate build to Spring Develocity Conventions and update JVM configuration

The Maven build now integrates the Spring Develocity Conventions extension (version 0.0.26) to enhance build performance and analytics via ge.spring.io. Additionally, the JVM configuration has been updated with specific --add-exports and --add-opens flags for JDK compiler modules and base libraries to support the new extension and ensure compatibility with the current JDK version.

.mvn · high confidence

Spring Data Commons upgraded to version 4.2.0-SNAPSHOT with Jakarta EE migration

The project artifact has been renamed from 'common' to 'spring-data-commons' and the version bumped to 4.2.0-SNAPSHOT, reflecting the move to the new Spring Data Core module. The build now inherits from the 'spring-data-parent' 4.2.0-SNAPSHOT, and dependencies have been updated to use Jakarta EE namespaces (e.g., 'jakarta.servlet', 'jakarta.xml.bind-api') instead of the legacy 'javax' packages. Additionally, the dependency list now includes 'tools.jackson.core:jackson-databind' alongside the existing 'com.fasterxml.jackson.core:jackson-databind', and optional dependencies for Spring modules like 'spring-oxm', 'spring-web', and 'spring-webflux' are explicitly declared.

(dependencies) · high confidence

Updated Maven Wrapper to version 3.9.16

The Maven Wrapper configuration has been updated to use Apache Maven 3.9.16. This ensures that the project builds with a consistent, specific version of Maven, improving build reproducibility across different development environments.

.mvn/wrapper · high confidence

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

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 55 → 55 (+0.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 86 → 86 (-0.0)
  • Architecture 75 → 75 (-0.0)
  • Maturity 46 → 46 (+0.0)
  • Readiness 63 → 64 (+0.6)
  • Security 51 → 51 (+0.0)
  • Domain Modelling 100 → 100 (+0.0)
  • Performance 78 → 91 (+13.2)

Resolved (164)

  • Change coupling: OrderBySource.java ↔ Part.java (src/main/java/org/springframework/data/repository/query/parser/OrderBySource.java)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • No assertions: abbreviatesToCamelCase (src/test/java/org/springframework/data/mapping/model/CamelCaseAbbreviatingFieldNamingStrategyUnitTests.java)
  • No assertions: appendsTemplateVariablesCorrectly (src/test/java/org/springframework/data/web/HateoasPageableHandlerMethodArgumentResolverUnitTests.java)
  • No assertions: buildsPartTreeForNotContainingCorrectly (src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java)
  • No assertions: buildsUpRequestParameters (src/test/java/org/springframework/data/web/HateoasPageableHandlerMethodArgumentResolverUnitTests.java)
  • No assertions: buildsUpRequestParameters (src/test/java/org/springframework/data/web/HateoasSortHandlerMethodArgumentResolverUnitTests.java)
  • No assertions: compileInstance (src/test/java/org/springframework/data/repository/aot/generate/RepositoryBuilderUnitTests.java)
  • No assertions: considersRepeatableAnnotation (src/test/java/org/springframework/data/web/ReactiveSortHandlerMethodArgumentResolverUnitTests.java)
  • No assertions: considersRepeatableAnnotation (src/test/java/org/springframework/data/web/SortDefaultUnitTests.java)
  • No assertions: detectsCustomSaveMethod (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsFindAllWithSortParameterOnSortingRepository (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsIgnoreAllCase (src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java)
  • No assertions: detectsMethodsOnCrudRepository (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsMethodsOnCustomRepository (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsMethodsOnPagingAndSortingRepository (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsOverloadedMethodsCorrectly (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: detectsOverriddenDeleteMethodForEntity (src/test/java/org/springframework/data/repository/core/support/DefaultCrudMethodsUnitTests.java)
  • No assertions: disablesFindFirstKImplicitIfNotPresent (src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java)
  • …and 144 more

New (7)

  • High interface indirection
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • No assertions (empty test): compileInstance (src/test/java/org/springframework/data/repository/aot/generate/RepositoryBuilderUnitTests.java)
  • No assertions (empty test): isNotEqualIfFieldsDiffer (src/test/java/org/springframework/data/core/TypeDiscovererUnitTests.java)
  • No assertions (empty test): testname (src/test/java/org/springframework/data/geo/format/PointFormatterUnitTests.java)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 15 commits — 13 feature/other, 2 fixes

By area

  • src/main — 10 commits
  • (root) — 3 commits
  • .github/workflows — 2 commits

Notable commits

  • fix: Fix FetchableFluentQuery.project(…) return type.
  • fix: Fix null assertion in TypedExampleMatcher.withStringMatcher(…).
  • change: Avoid Kotlin reflection for non-delegate properties.
  • change: Fix Javadoc typos.
  • change: Polishing.
  • change: Polishing.
  • change: Polishing.
  • change: Polishing.
  • change: Prepare next development iteration.
  • change: Refine documentation.
  • change: Reformat code.
  • change: Update portfolio train workflow (v0.0.8).
  • change: Upgrade dependencies.
  • change: Upgrade to Apache Groovy 6.0.0.
  • change: Upgrade to Graal Sdk 25.5.5.0.3.

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

spring-projects/spring-data-commons 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 9 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 0d270c2f856094ba35b1355b9d15389e69aad9ae — 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-b921b700395b.