Developer Center

Java
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.GraphDatabase;
import java.util.Map;

public class App {
    public static void main(String[] args) {
        try (var driver = GraphDatabase.driver(
                "neo4j+s://<instance-id>.databases.neo4j.io",
                AuthTokens.basic("neo4j", "<password>")
        )) {
            driver.verifyConnectivity();
            
            // Query that produces the visualization
            var result = driver.executableQuery("""
                MATCH (j:JavaVersion)-[:INCLUDES]->(f:Feature)
                      -[:BELONGS_TO]->(c:Category {name: $categoryName})
                WHERE toInteger(j.version) >= $minVersion
                WITH j, collect(f.title) as features, c.name as category
   	         RETURN j {.version, .status, .gaDate, .eolDate,
features: features,
category: category} as javaVersion;
                """)
                .withParameters(Map.of(
                    "categoryName", "lang",
                    "minVersion", 24
                ))
                .execute()
                .records()
                .stream()
                .map(record -> record.get("javaVersion").as(JavaVersion.class))
                .toList();
            for (var javaVersion : javaVersions) {
                System.out.println(javaVersion);
            }
        }
    }
    record JavaVersion(String version,
                    String status,
                    LocalDate gaDate,
        LocalDate eolDate,
        @Relationship("INCLUDES") List features) {
    }

    record Feature(String title,
        @Relationship("BELONGS_TO") Category category) {
    }

    record Category(String name) {
    }
}

JavaScript
const neo4j = require('neo4j-driver');

// Neo4j connection settings
const URI = process.env.NEO4J_URI || 'neo4j+s://<instance-id>.databases.neo4j.io';
const USERNAME = process.env.NEO4J_USERNAME || 'neo4j';
const PASSWORD = process.env.NEO4J_PASSWORD || '<password>';
const DATABASE = process.env.NEO4J_DATABASE || 'neo4j';

const AUTH = neo4j.auth.basic(USERNAME, PASSWORD);
const driver = neo4j.driver(URI, AUTH);

// Query that produces the visualization
async function main() {
    try {
        const result = await driver.executeQuery(
            `MATCH (lib:Library)-[:SUPPORTS]->(f:Feature), (lib)-[:BELONGS_TO]->(t:Trend {name: $frameworkName})
           RETURN lib.name AS library, f.name AS feature, t.name AS trend;`,
            { frameworkName: 'Vue.js' },
            { database: DATABASE }
        );
        
        for (const record of result.records) {
            console.log(record.toObject());
        }
    } catch (error) {
        console.error('Query failed:', error);
    } finally {
        await driver.close();
    }
}

main();

C#
using Neo4j.Driver;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Neo4j connection settings
        var uri = "neo4j+s://<instance-id>.databases.neo4j.io";
        var user = "neo4j";
        var password = "<password>";
          
        // Create driver instance
        using var driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
        
        await driver.VerifyConnectivityAsync();
        
        // Query that produces the visualization
        var result = await driver.ExecutableQuery(@"
            MATCH (m:Maintainer {name: $maintainerName})<-[:MAINTAINED_BY]-(pkg:Package)
                  -[:TESTS_WITH]->(tp:TestPackage)
                  -[:MAINTAINED_BY]->(tm:Maintainer)
            WHERE m.name <> tm.name
            RETURN m.name AS maintainer,
                   pkg.name AS package,
                   tp.name AS testPackage,
                   tm.name AS testMaintainer;
        ")
        .WithParameters(new { maintainerName = "Microsoft" })
        .WithConfig(new QueryConfig(database: "neo4j"))
        .ExecuteAsync();
        
        foreach (var record in result.Result)
        {
            Console.WriteLine(
                $"{record["maintainer"].As<string>()} maintains {record["package"].As<string>()} " +
                $"which tests with {record["testPackage"].As<string>()} " +
                $"(maintained by {record["testMaintainer"].As<string>()})"
            );
        }
    }
}