All Classes and Interfaces

Class
Description
Base class for imperative SDN configuration using JavaConfig.
Base class for reactive SDN configuration using JavaConfig.
A callback that can be used to modify an instance of a Neo4jPersistentEntity after it has been converted: That is, when a Neo4j record has been fully processed and the entity and all its associations have been processed.
Warning Internal API, might change without further notice, even in patch releases.
EntityCallback to populate auditing related fields on an entity about to be bound to a record.
Entity callback triggered before an Entity is bound to a record (represented by a java.util.Map<String, Object>).
This is a utility class that computes the bounding box of a polygon as a rectangle defined by the lower left and upper right point.
An internally used CDI Qualifier to mark all beans produced by our configuration support as built in.
 
 
This annotation indicates a persistent property that is composed of multiple properties on a node or relationship.
The default implementation, passing map properties through as they are on the way to the graph and possibly applying a post processor on the way out of the graph.
The default operation for transforming the keys.
Phase of the mapping currently taking place.
A pool of constants used in our Cypher generation.
This annotation can be used to define either custom conversions for single attributes by specifying a custom Neo4jPersistentPropertyConverter and if needed, a custom factory to create that converter or the annotation can be used to build custom meta-annotated annotations like @org.springframework.data.neo4j.core.support.DateLong.
Indicates an unset converter.
 
The CreateRelationshipStatementHolder holds the Cypher Statement to create a relationship as well as the optional properties that describe the relationship in case of more than a simple relationship.
Bridging between Spring Data domain Objects and Cypher constructs.
An interface that can be added to any repository so that queries can be enriched by conditions of the Cypher-DSL.
 
An interface that can be added to any imperative repository so that the repository exposes several methods taking in a Statement from the Cypher-DSL, that allows for full customization of the queries executed in a programmatic way in contrast to provide custom queries declaratively via @Query annotations.
A generator based on the schema defined by node and relationship descriptions.
A value holder indicating a database selection based on an optional name.
A provider interface that knows in which database repositories or either the reactive or imperative template should work.
Indicates SDN to store dates as long in the database.
Indicates SDN 6 to store dates as String in the database.
Converter to instantiate DTOs from fully equipped domain objects.
This annotation can be used on a field of type Collection<String>.
Annotation to enable auditing for SDN entities via annotation configuration.
Annotation to activate Neo4j repositories.
Annotation to enable auditing for SDN entities using reactive infrastructure via annotation configuration.
Annotation to activate reactive Neo4j repositories.
Converter to instantiate entity objects from DTOs
Used to keep the raw result around in case of a DTO based projection so that missing properties can be filled later on.
Utility class that orchestrates EntityCallbacks.
Specialized version of Query whose values is always used as exists projection.
FluentFindOperation allows creation and execution of Neo4j find operations in a fluent API style.
Entry point for creating executable find operations.
Result type override (Optional).
Terminating operations invoking the actual query execution.
Triggers find execution by calling one of the terminating methods.
Trigger find execution by calling one of the terminating methods from a state where no query is yet defined.
An additional interface accompanying the Neo4jOperations and adding a couple of fluent operations, especially around finding and projecting things.
FluentSaveOperation allows creation and execution of Neo4j save operations in a fluent API style.
After the domain type has been specified, related projections or instances of the domain type can be saved.
Indicates a generated id.
This IdGenerator does nothing.
This generator is automatically applied when a field of type UUID is annotated with @Id and @GeneratedValue.
 
 
Provides minimal information how to map class attributes to the properties of a node or a relationship.
This annotation is included here for completeness.
Description how to generate Ids for entities.
This class is not part of any public API and will be changed without further notice as needed.
Interface for generating ids for entities.
 
Class that defines a tuple of relationship with properties and the connected target entity.
A wrapper or marker for a Neo4j MapValue that needs to be unwrapped when used for properties.
 
Responsible for storing, updating and retrieving the bookmarks of Neo4j's transaction.
This event will be published after a Neo4j transaction manager physically committed a transaction without errors and received a new set of bookmarks from the cluster.
This CDI extension enables Spring Data Neo4j on a CDI 2.0 compatible CDI container.
Definition of a modern Neo4j client.
Contract for binding parameters to a query.
A builder for Neo4j clients.
Indicates an illegal database name and is not translated into a DataAccessException.
 
Ongoing bind specification.
A contract for an ongoing delegation in the selected database.
 
A runnable delegation.
Contract for a runnable query that can be either run returning its result, run without results or be parameterized.
Contract for a runnable query inside a dedicated database.
Contract for a runnable query bound to a user to be impersonated.
Contract for a runnable query specification which still can be bound to a specific database and an impersonated user.
 
This service orchestrates a standard Spring conversion service with Neo4jConversions registered.
This orchestrates the built-in store conversions and any additional Spring converters.
Neo4j specific contract for entity informations.
A utility class providing a way to discover an initial entity set for a Neo4jMappingContext.
This class registers the Neo4j SpEL Support it is registered by the appropriate repository factories as a root bean.
 
 
An implementation of both a Schema as well as a Neo4j version of Spring Data's MappingContext.
A builder for creating custom instances of a Neo4jMappingContext.
Specifies operations one can perform on a database, based on an Domain Type.
An interface for controlling query execution.
A PersistenceExceptionTranslator to get picked up by the Spring exception translation infrastructure.
A PersistentEntity interface with additional methods for metadata related to Neo4j.
A PersistentProperty interface with additional methods for metadata related to Neo4j.
This interface represents a pair of methods capable of converting values of type T to and from values.
This interface needs to be implemented to provide custom configuration for a Neo4jPersistentPropertyConverter.
You need to provide an implementation of this interface in case you want to store a property of an entity as separate properties on a node.
A dedicated Neo4j point, that is aware of its nature, either being geographic or cartesian.
Contains some useful transformers for adding additional, supported transformations to example matchers via ExampleMatcher.withTransformer(String, ExampleMatcher.PropertyValueTransformer).
A wrapper indicating a negated value (will be used as n.property != $parameter (in case of string properties all operators and not only the equality operator are supported, such as not (n.property contains 'x').
Lookup strategy for queries.
Neo4j specific Repository interface.
This dedicated Neo4j repository extension will be registered via Neo4jRepositoriesRegistrar and then provide all necessary beans to be registered in the application's context before the user's "business" beans gets registered.
Special adapter for Springs FactoryBean interface to allow easy setup of repository factories via Spring configuration.
The CDI pendant to the Neo4jRepositoryFactoryBean.
 
A list of Neo4j simple types: All attributes that can be mapped to a property.
This class provides a couple of extensions to the Spring Data Neo4j SpEL support.
 
Dedicated PlatformTransactionManager for native Neo4j transactions.
Internal use only.
Working on nested relationships happens in a certain algorithmic context.
This stores all processed nested relations and objects during save of objects so that the recursive descent can be stopped accordingly.
Valid processing states.
The annotation to configure the mapping from a node with a given set of labels to a class and vice versa.
Describes how a class is mapped to a node inside the database.
Throw when a query doesn't return a required result.
A NoRootNodeMappingException is thrown when the entity converter cannot find a node or map like structure that can be mapped.
The characteristics of a Neo4jPersistentProperty can diverge from what is by default derived from the annotated classes.
An instance of such a provider can be registered as a Spring bean and will be consulted by the Neo4jMappingContext prior to creating and populating persistent properties.
 
Informs SDN that the method annotated with this should be run once the object is loaded from the database and fully hydrated.
Typed preparation of a query that is used to create either an executable query.
 
 
The annotation to configure the mapping from a property to an attribute and vice versa.
Something that makes sense of propertyPaths by having an understanding of projection classes.
Wrapper class for property paths and information if they point to an entity.
A very loose coupling between a dot path and its (possible) owning type.
This class is responsible for creating a List of PropertyPath entries that contains all reachable properties (w/o circles).
Warning Internal API, might change without further notice, even in patch releases.
A strategy for traversing all properties (including association) once, without going in circles with cyclic mappings.
Annotation to provide Cypher statements that will be used for executing the method.
Querydsl specific fragment for extending SimpleNeo4jRepository with an implementation of QuerydslPredicateExecutor.
Collects the parts of a Cypher query to be handed over to the Cypher generator.
Combines the QueryFragments with parameters.
Reactive EntityCallback to populate auditing related fields on an entity about to be bound to a record.
Entity callback triggered before an Entity is bound to a record (represented by a java.util.Map<String, Object>).
An interface that can be added to any repository so that queries can be enriched by conditions of the Cypher-DSL.
 
An interface that can be added to any reactive repository so that the repository exposes several methods taking in a Statement from the Cypher-DSL, that allows for full customization of the queries executed in a programmatic way in contrast to provide custom queries declaratively via @Query annotations.
This is the reactive version of a the DatabaseSelectionProvider and it works in the same way but uses reactive return types containing the target database name.
Utility class that orchestrates EntityCallbacks.
ReactiveFluentFindOperation allows creation and execution of Neo4j find operations in a fluent API style.
Entry point for creating executable find operations.
Result type override (Optional).
Terminating operations invoking the actual query execution.
Trigger find execution by calling one of the terminating methods.
Trigger find execution by calling one of the terminating methods from a state where no query is yet defined.
An additional interface accompanying the ReactiveNeo4jOperations and adding a couple of fluent operations, especially around finding and projecting things.
ReactiveFluentSaveOperation allows creation and execution of Neo4j save operations in a fluent API style.
After the domain type has been specified, related projections or instances of the domain type can be saved.
Reactive Neo4j client.
A builder for reactive Neo4j clients.
 
A contract for an ongoing delegation in the selected database.
 
A runnable delegation.
Contract for a runnable query that can be either run returning its result, run without results or be parameterized.
Contract for a runnable query inside a dedicated database.
Contract for a runnable query bound to a user to be impersonated.
Contract for a runnable query specification which still can be bound to a specific database and an impersonated user.
Specifies reactive operations one can perform on a database, based on an Domain Type.
An interface for controlling query execution in a reactive fashion.
Lookup strategy for queries.
Neo4j specific Repository interface with reactive support.
This dedicated Neo4j repository extension will be registered via Neo4jRepositoriesRegistrar and then provide all necessary beans to be registered in the application's context before the user's "business" beans gets registered.
Special adapter for Springs FactoryBean interface to allow easy setup of repository factories via Spring configuration.
 
 
Bean post-processor that automatically applies persistence exception translation to all methods returning either Mono or Flux of any bean marked with Spring's @Repository annotation, adding a corresponding AbstractPointcutAdvisor to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).
Querydsl specific fragment for extending SimpleReactiveNeo4jRepository with an implementation of ReactiveQuerydslPredicateExecutor.
 
Annotation to configure mappings of relationship.
Enumeration of the direction a relationship can take.
Description of a relationship.
A combined annotation for id fields in RelationshipProperties classes.
This marker interface is used on classes to mark that they represent additional relationship properties.
A predicate indicating true for throwables that can be safely retried and false in any other case.
Contains the descriptions of all nodes, their properties and relationships known to SDN.
Repository base implementation for Neo4j.
A fragment for repositories providing "Query by example" functionality.
Repository base implementation for Neo4j.
A fragment for repositories providing "Query by example" functionality in a reactive way.
Supporting class for CypherDSL related customizations.
Marks an entity in a RelationshipProperties as the target node.
Utilities for templates.
Indicator for an empty collection
Thrown when required information about a class or primary label is requested from the Schema and that information is not available.
Representation of a user agent containing sensible information to identify queries generated by or executed via Spring Data Neo4j.
This is a value object for a Neo4j user, potentially different from the user owning the physical Neo4j connection.
 
A generator providing UUIDs.