GraphBridge.EntityFrameworkCore 0.1.0-preview.3

GraphBridge for Entity Framework Core

GraphBridge is a real, non-relational Entity Framework Core 10 provider for Neo4j. EF Core owns your model, entity identity and change tracking; the official Neo4j .NET driver owns the connection; GraphBridge stores entities as nodes and relationships and translates queries into parameterized Cypher. No second ORM, no client-side query fallback, no hidden schema change.

Developer preview, not production-supported. APIs and mappings may change between previews: pin the exact version. Use the async methods; synchronous SaveChanges() and ToList() are refused.

Install

dotnet add package GraphBridge.EntityFrameworkCore --prerelease

Pin the EF Core and driver versions GraphBridge is tested with:

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="[10.0.13]" />
<PackageReference Include="Neo4j.Driver" Version="[6.3.0]" />

Quick start

Map an ordinary entity to a node and lend EF a driver your application owns:

public sealed class Person
{
    public Guid Id { get; set; }
    public string Name { get; set; } = "";
    public int? Born { get; set; }
    public string? Nickname { get; set; }
    public long Version { get; set; }
}

public sealed class PeopleContext(IDriver driver, string database) : DbContext
{
    public DbSet<Person> People => Set<Person>();

    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseNeo4j(driver, database);

    protected override void OnModelCreating(ModelBuilder model)
        => model.Entity<Person>(person =>
        {
            person.ToGraphNode("Person");
            person.Property(p => p.Id).ValueGeneratedNever().HasGraphPropertyName("id");
            person.Property(p => p.Name).HasGraphPropertyName("name");
            person.Property(p => p.Born).HasGraphPropertyName("born");
            person.Property(p => p.Nickname).HasGraphPropertyName("nickname");
            person.Property(p => p.Version).HasGraphPropertyName("version").IsRowVersion();
        });
}

GraphBridge never creates schema: create the key constraint it proposes once, then save and query.

await using (var db = new PeopleContext(driver, "neo4j"))
{
    db.People.Add(new Person { Id = Guid.NewGuid(), Name = "Keanu Reeves", Born = 1964 });
    await db.SaveChangesAsync();                  // one CREATE in one transaction; Version becomes 1
}

await using (var db = new PeopleContext(driver, "neo4j"))
{
    var name = "Keanu Reeves";
    var query = db.People.Where(p => p.Name == name).OrderBy(p => p.Name).Take(5);
    Console.WriteLine(query.ToQueryString());     // the Cypher, without running it
    var people = await query.ToListAsync();
}

MATCH (n:`Person`)
WHERE coalesce(n.`name` = $p0, (n.`name` IS NULL AND $p0 IS NULL))
RETURN n.`id` AS `c0`, n.`born` AS `c1`, n.`name` AS `c2`, n.`nickname` AS `c3`, n.`version` AS `c4`
ORDER BY n.`name` IS NULL DESC, n.`name` ASC
LIMIT $p1

Values are always parameters, and C# null semantics are kept. The full walkthrough, including the key constraint, is in Getting started.

Every EF concept has a native graph shape

model.Entity<Person>().ToGraphNode("Person");
model.Entity<Review>().HasOne(r => r.Movie).WithMany(m => m.Reviews)
    .HasForeignKey(r => r.MovieId).ToGraphReference("HAS_REVIEW");   // (:Movie)-[:HAS_REVIEW]->(:Review)

Nodes · references · associations · identified relationships

Three ways to query

A query that cannot be translated faithfully is refused before it reaches the database, with a code (GBQ for LINQ, GBFC for Fluent Cypher) and a supported alternative. See known limitations.

Tested with

Other versions, Enterprise schema deployment and clustering are not verified yet. Details: compatibility.

Companion packages

None of them is needed at runtime.

Learn more

• Visual introduction and documentation
• Workshop: 31 runnable lessons
• Samples: code-first, ontology-first and database-first applications
• Changelog and verification summary

Questions, bugs and failing query shapes are welcome in GitHub issues. MIT licensed.