spring-projects/spring-data-neo4j

This system is Spring Data Neo4j, a framework that provides object-graph mapping and repository abstractions for interacting with Neo4j graph databases. It supports both imperative and reactive programming models, enabling developers to define entities, manage relationships, and execute Cypher queries through standard Spring interfaces. The library includes comprehensive tooling for type conversion, transaction management, and native image compilation, along with dedicated support for Kotlin and CDI environments.

44 changes.

This period focused on the foundational development of Spring Data Neo4j 6.0, introducing a new core mapping infrastructure that replaced the previous OGM-based approach with explicit annotations and a Cypher-DSL query execution engine. The work established comprehensive support for imperative and reactive programming models, including Kotlin extensions, CDI integration, and GraalVM native image compatibility. Extensive integration and unit testing were added to validate the new conversion services, transaction management, and repository abstractions.

21 changes.

This period focused on introducing Ahead-of-Time (AOT) compilation support to improve native image performance and memory usage. It also involved a significant expansion of integration test coverage across complex mapping scenarios, transaction management, and issue resolution, alongside migrating documentation to the Antora system.

10 changes.

This period focused on significantly expanding test coverage across the Neo4j Spring Data project, introducing new integration and unit tests for cascading updates, Kotlin projections, and generic type handling. The work also included implementing architecture tests with ArchUnit to enforce coding standards and adding detailed unit tests for core components such as type conversion, repository factories, and retry logic.

The project now includes META-INF configuration files to support Spring Boot auto-configuration and IDE integration. A new spring.factories file registers the Neo4jRepositoryFactory, enabling automatic setup of Neo4j repositories without manual configuration. Additionally, a spring.tooling file provides metadata for the Neo4j XML namespace, improving code completion and validation in IDEs.

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

The application now includes Spring AOT (Ahead-of-Time) support by registering specific runtime hints and bean registration processors for Neo4j. This ensures that Neo4j-related types and beans are correctly handled during the build-time processing phase, improving startup performance and reducing memory footprint for native images.

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

This change introduces Ahead-of-Time (AOT) compilation support for Spring Data Neo4j, enabling better performance and lower memory usage in native images. The \src/main/java/org/springframework/data/neo4j/aot\ package now contains several new components: \Neo4jRuntimeHints\ registers reflection hints for key classes like repositories, callbacks, and executors; \Neo4jManagedTypesBeanRegistrationAotProcessor\ handles bean registration for managed types; \Neo4jTypeFilters\ and \Neo4jAotPredicates\ provide type filtering logic; and \package-info.java\ sets null-safety annotations. These additions ensure that necessary classes and members are retained and accessible during native image generation.

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

A new license template file has been added to standardize copyright headers across the project. Additionally, an OpenRewrite recipe configuration is now available to automatically migrate code from using the deprecated Neo4j \id()\ function to the new \elementId()\ function, helping users update their data model interactions.

etc · high confidence

The application now supports configuration within a CDI (Contexts and Dependency Injection) context by registering the Neo4j CDI extension. This is achieved by adding a new service provider file at src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension, which points to org.springframework.data.neo4j.config.Neo4jCdiExtension, allowing the framework to automatically discover and initialize CDI-specific beans.

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

Added native-image configuration files to enable GraalVM native compilation for Spring Data Neo4j. The new reflection-config.json registers org.neo4j.driver.QueryRunner for reflection access, and the accompanying native-image.properties file applies this configuration, allowing the DefaultNeo4jClient to function correctly in native images.

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

This change adds the foundational classes and interfaces for specifying target databases and users within the Neo4j core API. It introduces the \DatabaseSelection\ value object and \DatabaseSelectionProvider\ interface, allowing applications to explicitly configure which database a repository or template should interact with, which is essential for Neo4j 4.0+ clusters. Additionally, it provides \UserSelection\ and \UserSelectionProvider\ abstractions to support user impersonation (available in Neo4j 4.4+), enabling operations to run under specific user contexts. Default implementations are included to maintain backward compatibility by defaulting to the server's selected database and the connected user.

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

The \src/main/java/org/springframework/data/neo4j/core/mapping\ package now contains the foundational mapping classes for the SDN 6.0 core API. This includes \Constants\ for internal Cypher parameter names (such as \\_\elementId\\\ and \\\vectorProperty\\_\), \CypherGenerator\ for building Cypher statements, and entity/property descriptors (\DefaultNeo4jPersistentEntity\, \DefaultNeo4jPersistentProperty\) that handle schema mapping, vector property detection, and relationship properties. It also introduces \IdentitySupport\ to manage the transition from deprecated Neo4j \id()\ to \elementId()\, and \DefaultNeo4jIsNewStrategy\ to determine entity persistence state based on identifier types.

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

Added Kotlin extension functions for Neo4j operations and clients to improve idiomatic usage. These extensions leverage reified type parameters to allow callers to omit explicit class arguments in methods like \findAll\, \findById\, and \count\. They also provide Kotlin-friendly alternatives for Java-specific patterns, such as replacing \Optional\ with nullable types, offering \inDatabase\ aliases to avoid Kotlin's reserved \in\ keyword, and exposing Coroutines-based variants like \Flow\ and \suspend\ functions for reactive operations.

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

Added the Parameters.kt file in the core cypher package, introducing two extension functions (asParam) that allow developers to easily escape parameter names with a leading dollar sign ($) within Cypher queries, particularly useful for preventing interpolation issues in multiline strings.

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

This location introduces the core support classes that enable programmatic query construction using the Cypher-DSL and enhanced SpEL support. It adds the \CypherdslConditionExecutor\ and \CypherdslStatementExecutor\ interfaces for imperative repositories, and their reactive counterparts \ReactiveCypherdslConditionExecutor\ and \ReactiveCypherdslStatementExecutor\, allowing developers to build and execute custom Cypher queries using the DSL instead of declarative annotations. The \Neo4jEvaluationContextExtension\ registers SpEL functions (\orderBy\, \literal\, \anyOf\, \allOf\) for use in repository queries. Additionally, it provides the \Neo4jRepositoryFactory\ and \ReactiveNeo4jRepositoryFactory\ implementations that wire these new executors into the repository proxy, along with the \ReactivePersistenceExceptionTranslationInterceptor\ and \PostProcessor\ to ensure reactive exception translation is applied to repository methods.

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

This location introduces the core configuration infrastructure for Spring Data Neo4j 6.0, providing abstract base classes (\AbstractNeo4jConfig\, \AbstractReactiveNeo4jConfig\) for imperative and reactive Java-based setup, as well as a full CDI integration (\Neo4jCdiExtension\, \Neo4jCdiConfigurationSupport\) for non-Spring environments. It also adds auditing support via \EnableNeo4jAuditing\ and \EnableReactiveNeo4jAuditing\ annotations and their corresponding registrars, along with a \Builtin\ qualifier for CDI bean management.

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

This change introduces the core repository API for Spring Data Neo4j 6.0, adding the \Neo4jRepository\ interface for imperative access (extending \PagingAndSortingRepository\ and \CrudRepository\), the \ReactiveNeo4jRepository\ interface for reactive access (extending \ReactiveCrudRepository\ and \ReactiveSortingRepository\), and a new \NoResultException\ class to handle cases where queries do not return the expected results. These interfaces are marked with \@NoRepositoryBean\ and are part of the newly structured \org.springframework.data.neo4j.repository\ package, which is null-marked using JSpecify annotations.

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

This release introduces the \org.springframework.data.neo4j.repository.config\ package, providing the core configuration infrastructure for Spring Data Neo4j 6.0. It adds the \@EnableNeo4jRepositories\ and \@EnableReactiveNeo4jRepositories\ annotations to activate repository scanning for imperative and reactive modes respectively. These annotations wire up dedicated \RepositoryConfigurationExtension\ implementations (\Neo4jRepositoryConfigurationExtension\ and \ReactiveNeo4jRepositoryConfigurationExtension\) that register necessary beans such as \Neo4jTemplate\, \ReactiveNeo4jTemplate\, and \Neo4jEvaluationContextExtension\. A new \StartupLogger\ component provides debug-level logging of the bootstrapping process, including SDN, Spring Data Commons, and Neo4j Driver versions.

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

This location introduces the foundational conversion layer for Spring Data Neo4j 6.0, replacing the previous OGM-based approach. It adds the \@ConvertWith\ annotation, allowing users to specify custom \Neo4jPersistentPropertyConverter\ implementations or Spring bean references for entity attributes. The package includes the \Neo4jConversionService\ interface and \Neo4jConversions\ registry, which manage built-in mappings for Cypher types (such as \LocalDate\, \OffsetDateTime\, and spatial points) and support decomposition of properties into maps via \Neo4jPersistentPropertyToMapConverter\.

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

This location introduces the foundational schema annotations and supporting classes for the new Spring Data Neo4j core mapping model. Users can now use \@Node\ to define entity classes and their labels, \@Relationship\ to map connections with configurable \cascadeUpdates\ behavior, and \@Property\ to map fields, including a new \readOnly\ flag to prevent writing values to the graph. The package also adds \@Id\ and \@GeneratedValue\ for flexible ID management (supporting internal, UUID, and custom generators), \@RelationshipId\ as a shortcut for relationship property IDs, and \@DynamicLabels\ to handle runtime-managed node labels. Additionally, \@PostLoad\ allows executing logic after an entity is hydrated, \@CompositeProperty\ (with its factory) enables complex map-based property conversion, and \@RelationshipProperties\ with \persistTypeInfo\ supports persisting type information for relationship properties.

src/main/java/org/springframework/data/neo4j/core/schema · high confidence

The core support package now includes several new utilities to aid domain modeling and resilience. Users can annotate fields with @DateLong or @DateString to explicitly control whether dates are stored as longs or formatted strings in the database. A new RetryExceptionPredicate is provided to help applications determine if a transaction error is safe to retry, while a UUIDStringGenerator offers a standard way to generate UUID-based identifiers. Additionally, a BookmarkManagerReference simplifies the resolution of bookmark managers within the application context, and a UserAgent enum allows for better identification of queries by exposing driver and framework version information.

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

The repository has been initialized with essential project scaffolding, including the Apache 2.0 license, a Maven wrapper for consistent builds, and standard configuration files like \.gitignore\ and \.git-blame-ignore-revs\. Comprehensive documentation has been added, including a \README\ detailing usage with Spring Boot and plain Spring, contribution guidelines, a security policy, and support instructions. This establishes the foundational structure and developer experience for the Spring Data Neo4j project.

(repo-wide) · high confidence

This release adds Ahead-Of-Time (AOT) compilation support for Spring Framework, enabling better startup performance and reduced memory footprint in native images. The changes include new classes like Neo4jManagedTypes and Neo4jEntityScanner to facilitate entity scanning and type management in AOT environments, as well as updates to the Neo4jClient and ReactiveNeo4jClient to ensure compatibility with AOT constraints.

spring-data-neo4j · high confidence

The documentation examples have been migrated to the Antora documentation system. This change replaces the previous example structure with symbolic links pointing to the relevant source code directories (config, core, documentation, integration, and repository) within the Spring Data Neo4j project, ensuring that the documentation now references the actual implementation and test code directly.

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

The Maven build now uses the Spring Develocity Conventions extension (version 0.0.26) to connect to ge.spring.io, enabling centralized build performance improvements and caching. Additionally, the JVM configuration has been updated with specific module exports and opens for the JDK compiler and base libraries to support the new build tooling requirements.

.mvn · high confidence

The documentation source has been migrated to the Antora static site generator, restructuring the content into the \src/main/antora/modules/ROOT/pages/introduction-and-preface\ directory. This change introduces new pages covering the introduction, building blocks, and prefaces for Neo4j, Spring Data, and Spring Data Neo4j, while also updating the 'New & Noteworthy' section to link to the latest release notes for versions 7.0 through 7.2.

src/main/antora/modules/ROOT/pages/introduction-and-preface · high confidence

The transaction management layer in \org.springframework.data.neo4j.core.transaction\ has been restructured to improve thread safety and configurability. A new \Neo4jBookmarkManager\ sealed interface (with \DefaultBookmarkManager\, \ReactiveDefaultBookmarkManager\, and \NoopBookmarkManager\ implementations) centralizes bookmark handling, allowing users to seed initial bookmarks or disable management entirely. The \Neo4jTransactionManager\ and \ReactiveNeo4jTransactionManager\ now use a builder pattern and explicitly support this bookmark manager, while \Neo4jTransactionUtils\ ensures transaction timeouts and user impersonation are correctly propagated to the Neo4j driver.

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

The repository query execution layer has been completely rewritten for version 6.0, introducing a new class hierarchy to handle imperative and reactive query execution separately. The new \AbstractReactiveNeo4jQuery\ and \CypherdslBasedQuery\ classes manage the execution flow, while \CypherQueryCreator\ handles the generation of Cypher statements from derived queries. This change adds support for advanced query features including vector search (via \SearchResult\), geospatial queries (via \GeoResult\), and keyset-based scrolling (via \ScrollPosition\). It also introduces new SpEL functions like \anyOf\ and \allOf\ for dynamic label handling and improves projection handling through \FluentQuerySupport\.

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

Added Kotlin extension tests for Neo4j core APIs; Added Kotlin test fixtures for shared integration tests; Added architecture tests using ArchUnit; Added documentation domain model classes for Neo4j mapping examples; Added documentation test fixtures for Neo4j repository configuration and custom type conversion; Added documentation tests for Neo4j domain events and repository queries; Added imperative repository test fixtures; Added integration tests for CDI context support; Added integration tests for Kotlin coroutines interoperability with the reactive Neo4j client; Added integration tests for Kotlin entity persistence and primitive defaults; Added integration tests for Kotlin projection issues; Added integration tests for Neo4j Template examples; Added integration tests for advanced mapping scenarios; Added integration tests for cascading update behavior; Added integration tests for composite values as IDs; Added integration tests for custom repository fragments; Added integration tests for imperative Kotlin Neo4j features; Added integration tests for imperative Neo4j conversion and type handling; Added integration tests for imperative Neo4j repository operations; Added integration tests for lightweight DTO mapping scenarios; Added integration tests for multiple Neo4j contexts; Added integration tests for optimistic locking with versioned self-references; Added integration tests for property handling and relationship properties; Added integration tests for reactive advanced mapping and cyclic projections; Added integration tests for the NoopBookmarkManager; Added reactive integration tests for composite properties, custom types, and type conversion; Added reactive integration tests for custom base repositories, auditing, callbacks, and Cypher-DSL execution; Added shared test model classes for the movies integration tests; Added test fixtures for DATAGRAPH-1446 abstract relationship properties; Added test fixtures for DATAGRAPH-1448 schema mapping; Added test for @PostLoad on Kotlin interfaces; Added test for CI Docker image proxy substitution; Added test model for hierarchical node mapping; Added test resources for named queries, data migrations, and logging configuration; Added tests for ID deprecation warning suppression; Added tests for Neo4j transaction and bookmark management; Added tests for generic type handling in @RelationshipProperties; Added tests for mapping callbacks; Added tests for repository configuration and startup logging; Added unit tests for Neo4j configuration, retry logic, and geographic types; Added unit tests for Neo4j type conversion and spatial/temporal adapters; Added unit tests for Neo4j type filtering; Added unit tests for core Neo4j client and utility components; Added unit tests for core Neo4j mapping components; Added unit tests for repository factory identifier validation and derived query checks; Consolidated integration test suite for reported issues; Expanded integration tests for property conversion and composite types; New test infrastructure and utilities for Spring Data Neo4j; Shared test model classes added for integration testing.

This change introduces the foundational build configuration for Spring Data Neo4j version 8.2.0-SNAPSHOT. It adds a Maven pom.xml defining the project structure, including dependencies for the Neo4j Java Driver (6.2.1), Neo4j Server (5.26.21), Cypher DSL (2025.2.7), and ArchUnit (1.4.1). Additionally, it includes a package.json file to manage Node.js dependencies for the documentation build, specifically Antora (3.2.0-alpha.6) and related Spring extensions.

(dependencies) · high confidence

The project's Maven Wrapper has been upgraded to version 3.9.16. This update ensures that builds use the latest stable Maven distribution, providing users with improved build performance, bug fixes, and compatibility with the latest Maven features.

.mvn/wrapper · high confidence

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

• CAI 65 → 63 (-1.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 98 → 88 (-10.0)
• Architecture 100 → 66 (-34.5)
• Maturity 58 → 65 (+7.4)
• Readiness 57 → 60 (+3.1)
• Security 78 → 64 (-14.1)

• Concentrated knowledge decay
• Consequences are mostly an educated guess ('probably more network traffic') and do not address trade-offs such as the loss of implicit saves or the migration burden for existing models (etc/adr/adr-004.adoc)
• Coverage not included — suite not readable by the collector
• Decision is restated in context rather than being an explicit decision statement; the rationale for why relationship with properties is treated as a property instead of an association is missing (etc/adr/adr-005.adoc)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/neo4j/repository/query/ReactiveStringBasedNeo4jQuery.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jPersistentEntity.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/neo4j/repository/query/AbstractNeo4jQuery.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/neo4j/repository/query/QueryFragments.java)
• Duplicated block (15 lines × 2) (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• Duplicated block (5 lines × 2) (src/main/java/org/springframework/data/neo4j/core/mapping/DtoInstantiatingConverter.java)
• Duplicated block (5 lines × 2) (src/main/java/org/springframework/data/neo4j/repository/query/FetchableFluentQueryByExample.java)
• Duplicated block (5 lines × 2) (src/main/java/org/springframework/data/neo4j/repository/query/FluentQuerySupport.java)
• Duplicated block (5 lines × 4) (src/main/java/org/springframework/data/neo4j/repository/query/FetchableFluentQueryByPredicate.java)
• Duplicated block (6 lines × 2) (src/main/java/org/springframework/data/neo4j/core/DefaultNeo4jClient.java)
• Duplicated block (6 lines × 2) (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• Duplicated block (6 lines × 2) (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• …and 40 more

• AggregatingMappingFunction.aggregatePath (cognitive 17) (src/main/java/org/springframework/data/neo4j/core/PreparedQuery.java)
• Change coupling: IdDescription.java ↔ CypherAdapterUtils.java (src/main/java/org/springframework/data/neo4j/core/mapping/IdDescription.java)
• Change coupling: Neo4jRepositoryFactory.java ↔ ReactiveNeo4jRepositoryFactory.java (src/main/java/org/springframework/data/neo4j/repository/support/Neo4jRepositoryFactory.java)
• Change coupling: SimpleQueryByExampleExecutor.java ↔ SimpleReactiveQueryByExampleExecutor.java (src/main/java/org/springframework/data/neo4j/repository/query/SimpleQueryByExampleExecutor.java)
• ClassTooLong: CypherGenerator (src/main/java/org/springframework/data/neo4j/core/mapping/CypherGenerator.java)
• ClassTooLong: DefaultNeo4jEntityConverter (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java)
• ClassTooLong: Neo4jTemplate (src/main/java/org/springframework/data/neo4j/core/Neo4jTemplate.java)
• ClassTooLong: ReactiveNeo4jTemplate (src/main/java/org/springframework/data/neo4j/core/ReactiveNeo4jTemplate.java)
• CompositePropertyConverterFactory.getPropertyConverterFor (cognitive 27) (src/main/java/org/springframework/data/neo4j/core/schema/CompositePropertyConverterFactory.java)
• CompositePropertyConverterFactory.getPropertyConverterFor (cyclomatic 17) (src/main/java/org/springframework/data/neo4j/core/schema/CompositePropertyConverterFactory.java)
• Context is thin and the decision restates the rule without any rationale (why marking @API.INTERNAL final matters) while consequences are weak ('Potentially problems with some Spring proxies') (etc/adr/adr-003.adoc)
• CypherAdapterUtils.combineKeysetIntoCondition (cognitive 17) (src/main/java/org/springframework/data/neo4j/repository/query/CypherAdapterUtils.java)
• CypherAdapterUtils.sortAdapterFor (cognitive 20) (src/main/java/org/springframework/data/neo4j/repository/query/CypherAdapterUtils.java)
• CypherGenerator.createOrderByFragment (cognitive 24) (src/main/java/org/springframework/data/neo4j/core/mapping/CypherGenerator.java)
• CypherQueryCreator.createQueryFragments (cognitive 51) (src/main/java/org/springframework/data/neo4j/repository/query/CypherQueryCreator.java)
• CypherQueryCreator.createQueryFragments (cyclomatic 18) (src/main/java/org/springframework/data/neo4j/repository/query/CypherQueryCreator.java)
• Decision is restated in context rather than being an explicit decision statement; the rationale for why relationship-with-properties is treated as a property on the defining entity instead of an association is missing (etc/adr/adr-005.adoc)
• DefaultNeo4jEntityConverter.createInstanceOfRelationships (cognitive 128) (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java)
• DefaultNeo4jEntityConverter.createInstanceOfRelationships (cyclomatic 40) (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java)
• DefaultNeo4jEntityConverter.determineQueryRoot (cognitive 46) (src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java)
• …and 473 more

• 10 commits — 9 feature/other, 1 fixes

• (root) — 3 commits
• (repo) — 2 commits
• src/main — 2 commits
• .github/workflows — 1 commit
• .mvn/extensions.xml — 1 commit
• src/test — 1 commit

• fix: Fix @CompositeProperty converter matching for parameterized property types (#3122)
• change: Add release train automation.
• change: Add tests for one-to-one relationships on immutable types. (#3117)
• change: Enter rampdown phase for 8.2.0-M1.
• change: Enter rampdown phase for 8.2.0-M2.
• change: Prepare next development iteration.
• change: Release version 8.2.0-M1 (2026.1.0).
• change: Update Maven extensions.
• change: Update build config for correct notice and license.txt inclusion.
• change: Upgrade to Neo4j Driver 6.2.1.

• Unchanged — 0 containers · 1 contexts · 0 edges

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

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