Developer Center

Java
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.GraphDatabase;

import java.time.LocalDate;
import java.util.List;
import java.util.Map;

public class App {

  public static void main(String[] args) {

    try (
      var driver =
        GraphDatabase.driver(
          "neo4j+s://.databases.neo4j.io",
          AuthTokens.basic(
            "neo4j", ""
          )
        )
    ) {

      driver.verifyConnectivity();

      // Query that produces the visualization
      var javaVersions =
        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(r ->
              r.get("javaVersion")
                .as(JavaVersion.class)
          )
          .toList();

      for (var javaVersion : javaVersions) {
        System.out.println(javaVersion);
      }
    }
  }

  record JavaVersion(
    String version,
    String status,
    LocalDate gaDate,
    LocalDate eolDate,
    List features
  ) {}

  record Feature(
    String title,
    Category category
  ) {}

  record Category(
    String name
  ) {}
}

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


// Neo4j connection settings
const URI =
  process.env.NEO4J_URI ||
  "neo4j+s://.databases.neo4j.io";

const USERNAME =
  process.env.NEO4J_USERNAME ||
  "neo4j";

const PASSWORD =
  process.env.NEO4J_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().catch(console.error);

C#
using Neo4j.Driver;

// Neo4j connection settings
var uri = "neo4j+s://.databases.neo4j.io";
var user = "neo4j";
var password = "";

using var driver =
    GraphDatabase.Driver(
        uri,
        AuthTokens.Basic(
            user,
            password
        )
    );

await driver.VerifyConnectivityAsync();

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)
{
    var maintainer =
        record["maintainer"]
            .As();

    var package =
        record["package"]
            .As();

    var testPackage =
        record["testPackage"]
            .As();

    var testMaintainer =
        record["testMaintainer"]
            .As();

    Console.WriteLine(
        maintainer +
        " maintains " +
        package +
        " which tests with " +
        testPackage +
        " (maintained by " +
        testMaintainer +
        ")"
    );
}