The Neo4j Cypher-DSL

var tom = Cypher.anyNode().named("tom").withProperties("name", Cypher.literalOf("Tom Hanks"));
var statement = Cypher
    .match(tom).returning(tom)
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo("MATCH (tom {name: 'Tom Hanks'}) RETURN tom");

var people = Cypher.node("Person").named("people");
statement = Cypher
    .match(people)
    .returning(people.property("name"))
    .limit(10)
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo("MATCH (people:`Person`) RETURN people.name LIMIT 10");

var nineties = Cypher.node("Movie").named("nineties");
var released = nineties.property("released");
statement = Cypher
    .match(nineties)
    .where(released.gte(Cypher.literalOf(1990)).and(released.lt(Cypher.literalOf(2000))))
    .returning(nineties.property("title"))
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo(
        "MATCH (nineties:`Movie`) WHERE (nineties.released >= 1990 AND nineties.released < 2000) RETURN nineties.title");

var tom = Cypher.node("Person").named("tom").withProperties("name", Cypher.literalOf("Tom Hanks"));
var tomHanksMovies = Cypher.anyNode("tomHanksMovies");
var statement = Cypher
    .match(tom.relationshipTo(tomHanksMovies, "ACTED_IN"))
    .returning(tom, tomHanksMovies)
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo(
        "MATCH (tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(tomHanksMovies) RETURN tom, tomHanksMovies");

var cloudAtlas = Cypher.anyNode("cloudAtlas").withProperties("title", Cypher.literalOf("Cloud Atlas"));
var directors = Cypher.anyNode("directors");
statement = Cypher
    .match(cloudAtlas.relationshipFrom(directors, "DIRECTED"))
    .returning(directors.property("name"))
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo("MATCH (cloudAtlas {title: 'Cloud Atlas'})<-[:`DIRECTED`]-(directors) RETURN directors.name");

tom = Cypher.node("Person").named("tom").withProperties("name", Cypher.literalOf("Tom Hanks"));
var movie = Cypher.anyNode("m");
var coActors = Cypher.anyNode("coActors");
var people = Cypher.node("Person").named("people");
statement = Cypher
    .match(tom.relationshipTo(movie, "ACTED_IN").relationshipFrom(coActors, "ACTED_IN"))
    .returning(coActors.property("name"))
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo(
        "MATCH (tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(m)<-[:`ACTED_IN`]-(coActors) RETURN coActors.name");

cloudAtlas = Cypher.node("Movie").withProperties("title", Cypher.literalOf("Cloud Atlas"));
people = Cypher.node("Person").named("people");
var relatedTo = people.relationshipBetween(cloudAtlas).named("relatedTo");
statement = Cypher
    .match(relatedTo)
    .returning(people.property("name"), Functions.type(relatedTo), relatedTo.getRequiredSymbolicName())
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo(
        "MATCH (people:`Person`)-[relatedTo]-(:`Movie` {title: 'Cloud Atlas'}) RETURN people.name, type(relatedTo), relatedTo");

var bacon = Cypher.node("Person").named("bacon").withProperties("name", Cypher.literalOf("Kevin Bacon"));
var hollywood = Cypher.anyNode("hollywood");
var statement = Cypher
    .match(bacon.relationshipBetween(hollywood).length(1, 4))
    .returningDistinct(hollywood)
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo("MATCH (bacon:`Person` {name: 'Kevin Bacon'})-[*1..4]-(hollywood) RETURN DISTINCT hollywood");

var tom = Cypher.node("Person").named("tom").withProperties("name", Cypher.literalOf("Tom Hanks"));
var coActors = Cypher.anyNode("coActors");
var cocoActors = Cypher.anyNode("cocoActors");
var strength = Functions.count(Cypher.asterisk()).as("Strength");
var statement = Cypher
    .match(
        tom.relationshipTo(Cypher.anyNode("m"), "ACTED_IN").relationshipFrom(coActors, "ACTED_IN"),
        coActors.relationshipTo(Cypher.anyNode("m2"), "ACTED_IN").relationshipFrom(cocoActors, "ACTED_IN")
    )
    .where(
        Conditions.not(tom.relationshipTo(Cypher.anyNode(), "ACTED_IN").relationshipFrom(cocoActors, "ACTED_IN")))
    .and(tom.isNotEqualTo(cocoActors))
    .returning(
        cocoActors.property("name").as("Recommended"),
        strength
    ).orderBy(strength.asName().descending())
    .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo(""
        + "MATCH "
        + "(tom:`Person` {name: 'Tom Hanks'})-[:`ACTED_IN`]->(m)<-[:`ACTED_IN`]-(coActors), "
        + "(coActors)-[:`ACTED_IN`]->(m2)<-[:`ACTED_IN`]-(cocoActors) "
        + "WHERE (NOT (tom)-[:`ACTED_IN`]->()<-[:`ACTED_IN`]-(cocoActors) AND tom <> cocoActors) "
        + "RETURN cocoActors.name AS Recommended, count(*) AS Strength ORDER BY Strength DESC");

var person = Cypher.node("Person").named("p");
var statement =
    Cypher
        .match(person)
        .where(person.property("nickname").isEqualTo(Cypher.parameter("nickname")))
        .set(
            person.property("firstName").to(Cypher.parameter("firstName").withValue("Thomas")),
            person.property("name").to(Cypher.parameter("name", "Anderson"))
        )
        .returning(person)
        .build();

assertThat(cypherRenderer.render(statement))
    .isEqualTo("MATCH (p:`Person`) WHERE p.nickname = $nickname SET p.firstName = $firstName, p.name = $name RETURN p");

Collection<String> parameterNames = statement.getParameterNames();
assertThat(parameterNames).containsExactlyInAnyOrder("nickname", "firstName", "name"); (1)

Map<String, Object> parameters = statement.getParameters();
assertThat(parameters).hasSize(2); (2)
assertThat(parameters).containsEntry("firstName", "Thomas");
assertThat(parameters).containsEntry("name", "Anderson");

var statement = Cypher.returning(literalTrue().as("t")).build();
var cypher = statement.getCypher();
assertThat(cypher).isEqualTo("RETURN true AS t");

var n = Cypher.anyNode("n");
var a = Cypher.node("A").named("a");
var b = Cypher.node("B").named("b");

var mergeStatement = Cypher.merge(n)
    .onCreate().set(n.property("prop").to(Cypher.literalOf(0)))
    .merge(a.relationshipBetween(b, "T"))
    .onCreate().set(a.property("name").to(Cypher.literalOf("me")))
    .onMatch().set(b.property("name").to(Cypher.literalOf("you")))
    .returning(a.property("prop")).build();

var renderer = Renderer.getRenderer(Configuration.prettyPrinting()); (1)
assertThat(renderer.render(mergeStatement))
    .isEqualTo(
        "MERGE (n)\n" +
        "  ON CREATE SET n.prop = 0\n" +
        "MERGE (a:A)-[:T]-(b:B)\n" +
        "  ON CREATE SET a.name = 'me'\n" +
        "  ON MATCH SET b.name = 'you'\n" +
        "RETURN a.prop"
    ); (2)

var key = Cypher.name("key");
var cypher = Cypher.call("apoc.meta.schema")
    .yield("value").with("value")
    .unwind(Functions.keys(Cypher.name("value"))).as(key)
    .returning(
        key,
        Cypher.raw("value[$E]", key).as("value") (1)
    )
    .build().getCypher();

assertThat(cypher).isEqualTo(
    "CALL apoc.meta.schema() YIELD value WITH value UNWIND keys(value) AS key RETURN key, value[key] AS value");

var call = Cypher.call("db", "labels").build(); (1)
assertThat(cypherRenderer.render(call)).isEqualTo("CALL db.labels()");

call = Cypher.call("db.labels").build();  (2)
assertThat(cypherRenderer.render(call)).isEqualTo("CALL db.labels()");

var call = Cypher
        .call("dbms.security.createUser")
        .withArgs(Cypher.literalOf("johnsmith"), Cypher.literalOf("h6u4%kr"), Cypher.literalFalse())
        .build();
assertThat(cypherRenderer.render(call))
        .isEqualTo("CALL dbms.security.createUser('johnsmith', 'h6u4%kr', false)");

var call = Cypher.call("dbms.procedures").yield("name", "signature").build(); (1)
assertThat(cypherRenderer.render(call)).isEqualTo("CALL dbms.procedures() YIELD name, signature");

call = Cypher.call("dbms.procedures").yield(Cypher.name("name"), Cypher.name("signature")).build(); (2)
assertThat(cypherRenderer.render(call)).isEqualTo("CALL dbms.procedures() YIELD name, signature");

var name = Cypher.name("name");
var call = Cypher
        .call("dbms.listConfig")
        .withArgs(Cypher.literalOf("browser"))
        .yield(name)
        .where(name.matches("browser\\.allow.*"))
        .returning(Cypher.asterisk())
        .build();
assertThat(cypherRenderer.render(call)).isEqualTo(
        "CALL dbms.listConfig('browser') YIELD name WHERE name =~ 'browser\\\\.allow.*' RETURN *");

var label = Cypher.name("label");
var statement = Cypher
        .match(Cypher.anyNode().named("n")).with("n")
        .call("db.labels").yield(label).with(label)
        .returning(Functions.count(label).as("numLabels"))
        .build();
assertThat(cypherRenderer.render(statement)).isEqualTo(
        "MATCH (n) WITH n CALL db.labels() YIELD label WITH label RETURN count(label) AS numLabels");

import java.util.List;

import org.neo4j.cypherdsl.core.MapExpression;
import org.neo4j.cypherdsl.core.NodeBase;
import org.neo4j.cypherdsl.core.NodeLabel;
import org.neo4j.cypherdsl.core.Properties;
import org.neo4j.cypherdsl.core.SymbolicName;

public final class Movie extends NodeBase<Movie> { (1)

    public static final Movie MOVIE = new Movie(); (2)

    public Movie() {
        super("Movie"); (3)
    }

    private Movie(SymbolicName symbolicName, List<NodeLabel> labels, Properties properties) { (4)
        super(symbolicName, labels, properties);
    }

    @Override
    public Movie named(SymbolicName newSymbolicName) { (5)

        return new Movie(newSymbolicName, getLabels(), getProperties());
    }

    @Override
    public Movie withProperties(MapExpression newProperties) { (6)

        return new Movie(getSymbolicName().orElse(null), getLabels(), Properties.create(newProperties));
    }
}

var cypher = Cypher.match(Movie.MOVIE)
    .returning(Movie.MOVIE)
    .build().getCypher();

var movie = Movie.MOVIE.named("m");
var cypher = Cypher.match(movie)
    .returning(movie)
    .build().getCypher();

import org.neo4j.cypherdsl.core.Property;

public final class Movie extends NodeBase<Movie> { (1)

    public final Property TITLE = this.property("title"); (2)
}

var movie = Movie.MOVIE.named("m");
var cypher = Cypher.match(movie)
    .where(movie.TITLE.isEqualTo(Cypher.literalOf("The Matrix"))) (1)
    .returning(movie)
    .build().getCypher();

Assertions.assertThat(cypher)
    .isEqualTo("MATCH (m:`Movie`) WHERE m.title = 'The Matrix' RETURN m");

public class RelationshipBase<S extends NodeBase<?>, E extends NodeBase<?>, SELF extends RelationshipBase<S, E, SELF>> {
}

import org.neo4j.cypherdsl.core.MapExpression;
import org.neo4j.cypherdsl.core.Node;
import org.neo4j.cypherdsl.core.Properties;
import org.neo4j.cypherdsl.core.Property;
import org.neo4j.cypherdsl.core.RelationshipBase;
import org.neo4j.cypherdsl.core.SymbolicName;

public final class ActedIn extends RelationshipBase<Person, Movie, ActedIn> { (1)

    public final Property ROLE = this.property("role"); (2)

    protected ActedIn(Person start, Movie end) {
        super(start, "ACTED_IN", end); (3)
    }

    private ActedIn(SymbolicName symbolicName, Node start, String type, Properties properties, Node end) { (4)
        super(symbolicName, start, type, properties, end);
    }

    @Override
    public ActedIn named(SymbolicName newSymbolicName) { (5)

        return new ActedIn(newSymbolicName, getLeft(), getRequiredType(), getDetails().getProperties(), getRight());
    }

    @Override
    public ActedIn withProperties(MapExpression newProperties) { (6)

        return new ActedIn(getSymbolicName().orElse(null), getLeft(), getRequiredType(), Properties.create(newProperties), getRight());
    }
}

public final class Person extends NodeBase<Person> {

    public static final Person PERSON = new Person();

    public final Directed<Movie> DIRECTED = new Directed<>(this, Movie.MOVIE);

    public final ActedIn ACTED_IN = new ActedIn(this, Movie.MOVIE); (1)

    public final Property NAME = this.property("name");

    public final Property FIRST_NAME = this.property("firstName");

    public final Property BORN = this.property("born");
}

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <annotationProcessorPaths>
                    <annotationProcessorPath>
                        <groupId>org.neo4j</groupId>
                        <artifactId>neo4j-cypher-dsl-codegen-sdn6</artifactId>
                        <version>{neo4j-cypher-dsl.version}</version>
                    </annotationProcessorPath>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>

dependencies {
    annotationProcessor 'org.neo4j:neo4j-cypher-dsl-codegen-sdn6:2021.1.1'
}

<dependency>
    <groupId>org.neo4j</groupId>
    <artifactId>neo4j-cypher-dsl-codegen-sdn6</artifactId>
    <version>{neo4j-cypher-dsl.version}</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-neo4j</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>com.querydsl</groupId>
    <artifactId>querydsl-core</artifactId>
    <version>4.4.0</version>
    <scope>provided</scope>
</dependency>

dependencies {
    implementation 'com.querydsl:query-dsl-core:4.4.0'
}

<dependencies>
    <dependency>
        <groupId>com.querydsl</groupId>
        <artifactId>querydsl-apt</artifactId>
        <version>4.4.0</version>
        <classifier>general</classifier>
    </dependency>
    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>javax.annotation-api</artifactId>
        <version>1.3.2</version>
    </dependency>
</dependencies>