feat: finalize identity-free graph model

examples/Example0.BasicSerialization/DomainModel.cs

@@ -97,12 +97,5 @@ public class City
 [Relationship(Label = "FRIEND_OF")]
 public record Friend : Relationship
 {
-    public Friend() : base(string.Empty, string.Empty)
-    {
-    }
-
-    public Friend(string startNodeId, string endNodeId) : base(startNodeId, endNodeId)
-    {
-    }
     public DateTime Since { get; set; }
-}
+}

examples/Example0.BasicSerialization/Program.cs

@@ -211,8 +211,11 @@
 
     // Serialize a relationship
     Console.WriteLine("3. Creating a relationship between Alice and Bob...");
-    var aliceFriendBob = new Friend(alice.Id, bob.Id) { Since = new DateTime(2021, 1, 1) };
-    await graph.CreateRelationshipAsync(aliceFriendBob);
+    var aliceFriendBob = new Friend { Since = new DateTime(2021, 1, 1) };
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Email == alice.Email),
+        aliceFriendBob,
+        graph.Nodes<Person>().Where(person => person.Email == bob.Email));
 
     Console.WriteLine($"✓ Created relationship between {alice.Name} and {bob.Name}");
     Console.WriteLine($"  Since: {aliceFriendBob.Since}");
@@ -238,13 +241,16 @@
     Console.WriteLine($"✓ Created dynamic node: {person1.Properties["Name"]} with role {person1.Properties["Role"]}");
     Console.WriteLine($"✓ Created dynamic node: {person2.Properties["Name"]} with role {person2.Properties["Role"]}");
 
-    var managesRel = new DynamicRelationship(person1.Id, person2.Id, "MANAGES", new Dictionary<string, object?>
+    var managesRel = new DynamicRelationship("MANAGES", new Dictionary<string, object?>
     {
         { "Since", new DateTime(2023, 1, 1) },
         { "Notes", "Promising intern" }
     });
 
-    await graph.CreateRelationshipAsync(managesRel);
+    await graph.CreateRelationshipAsync(
+        graph.DynamicNodes().OfLabel("Manager"),
+        managesRel,
+        graph.DynamicNodes().OfLabel("Intern"));
     Console.WriteLine($"✓ Created dynamic relationship: {person1.Properties["Name"]} MANAGES {person2.Properties["Name"]} since {managesRel.Properties["Since"]}\n");
 
 

examples/Example1.BasicCRUD/DomainModel.cs

@@ -25,10 +25,6 @@ public record Company : Node
 [Relationship(Label = "WORKS_FOR")]
 public record WorksFor : Relationship
 {
-    public WorksFor() : base(string.Empty, string.Empty) { }
-
-    public WorksFor(string startNodeId, string endNodeId) : base(startNodeId, endNodeId) { }
-
     public string Position { get; set; } = string.Empty;
     public DateTime StartDate { get; set; }
     public decimal Salary { get; set; }

examples/Example1.BasicCRUD/Program.cs

@@ -76,22 +76,29 @@
     // Create relationships
     Console.WriteLine("2. Creating relationships...");
 
-    var aliceWorksFor = new WorksFor(alice.Id, techCorp.Id)
+    var aliceWorksFor = new WorksFor
     {
         Position = "Senior Software Engineer",
         StartDate = new DateTime(2022, 3, 15),
         Salary = 95000
     };
 
-    var bobWorksFor = new WorksFor(bob.Id, techCorp.Id)
+    var bobWorksFor = new WorksFor
     {
         Position = "Marketing Manager",
         StartDate = new DateTime(2021, 8, 1),
         Salary = 75000
     };
 
-    await graph.CreateRelationshipAsync(aliceWorksFor);
-    await graph.CreateRelationshipAsync(bobWorksFor);
+    var companySelection = graph.Nodes<Company>().Where(company => company.Name == techCorp.Name);
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Email == alice.Email),
+        aliceWorksFor,
+        companySelection);
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Email == bob.Email),
+        bobWorksFor,
+        companySelection);
 
     Console.WriteLine($"✓ Created relationship: {alice.Name} works for {techCorp.Name}");
     Console.WriteLine($"✓ Created relationship: {bob.Name} works for {techCorp.Name}\n");
@@ -143,24 +150,25 @@
     // Update Alice's age and department
     if (foundAlice != null)
     {
-        foundAlice.Age = 31; // Update age
-        foundAlice.Department = "Engineering"; // Update department
-        await graph.UpdateNodeAsync(foundAlice);
-        Console.WriteLine($"✓ Updated Alice's age to {foundAlice.Age} and department to {foundAlice.Department}");
+        await graph.Nodes<Person>()
+            .Where(person => person.Email == foundAlice.Email)
+            .UpdateAsync(setters => setters
+                .SetProperty(person => person.Age, 31)
+                .SetProperty(person => person.Department, "Engineering"));
+        Console.WriteLine("✓ Updated Alice's age to 31 and department to Engineering");
     }
 
     // Update Bob's salary
-    var bobRelationship = await graph.Nodes<Person>()
+    var bobRelationship = graph.Nodes<Person>()
         .PathSegments<Person, WorksFor, Company>()
         .Where(r => r.StartNode.Name == "Bob Smith")
-        .Select(r => r.Relationship)
-        .FirstOrDefaultAsync();
+        .Select(r => r.Relationship);
 
-    if (bobRelationship != null)
+    if (await bobRelationship.AnyAsync())
     {
-        bobRelationship.Salary = 80000; // Update salary
-        await graph.UpdateRelationshipAsync(bobRelationship);
-        Console.WriteLine($"✓ Updated Bob's salary to ${bobRelationship.Salary:N0}");
+        await bobRelationship.UpdateAsync(
+            setters => setters.SetProperty(relationship => relationship.Salary, 80000));
+        Console.WriteLine("✓ Updated Bob's salary to $80,000");
     }
 
     // ==== VERIFY UPDATES ====
@@ -191,7 +199,9 @@
     Console.WriteLine($"✓ Created temporary employee: {tempPerson.Name}");
 
     // Delete the temporary person
-    await graph.DeleteNodeAsync(tempPerson.Id);
+    await graph.Nodes<Person>()
+        .Where(person => person.Email == tempPerson.Email)
+        .DeleteAsync();
     Console.WriteLine($"✓ Deleted temporary employee: {tempPerson.Name}");
 
     // Verify deletion

examples/Example2.LINQAndTraversal/DomainModel.cs

@@ -18,11 +18,5 @@ public record Person : Node
 [Relationship(Label = "KNOWS")]
 public record Knows : Relationship
 {
-    public Knows() : base(string.Empty, string.Empty) { }
-
-    public Knows(string startNodeId, string endNodeId) : base(startNodeId, endNodeId)
-    {
-    }
-
     public DateTime Since { get; set; }
-}
+}

examples/Example2.LINQAndTraversal/Program.cs

@@ -56,11 +56,26 @@
     await graph.CreateNodeAsync(eve);
 
     // Create relationships
-    await graph.CreateRelationshipAsync(new Knows(alice.Id, bob.Id) { Since = DateTime.UtcNow.AddYears(-5) });
-    await graph.CreateRelationshipAsync(new Knows(alice.Id, charlie.Id) { Since = DateTime.UtcNow.AddYears(-3) });
-    await graph.CreateRelationshipAsync(new Knows(bob.Id, diana.Id) { Since = DateTime.UtcNow.AddYears(-2) });
-    await graph.CreateRelationshipAsync(new Knows(charlie.Id, eve.Id) { Since = DateTime.UtcNow.AddYears(-1) });
-    await graph.CreateRelationshipAsync(new Knows(diana.Id, eve.Id) { Since = DateTime.UtcNow.AddMonths(-6) });
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Name == alice.Name),
+        new Knows { Since = DateTime.UtcNow.AddYears(-5) },
+        graph.Nodes<Person>().Where(person => person.Name == bob.Name));
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Name == alice.Name),
+        new Knows { Since = DateTime.UtcNow.AddYears(-3) },
+        graph.Nodes<Person>().Where(person => person.Name == charlie.Name));
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Name == bob.Name),
+        new Knows { Since = DateTime.UtcNow.AddYears(-2) },
+        graph.Nodes<Person>().Where(person => person.Name == diana.Name));
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Name == charlie.Name),
+        new Knows { Since = DateTime.UtcNow.AddYears(-1) },
+        graph.Nodes<Person>().Where(person => person.Name == eve.Name));
+    await graph.CreateRelationshipAsync(
+        graph.Nodes<Person>().Where(person => person.Name == diana.Name),
+        new Knows { Since = DateTime.UtcNow.AddMonths(-6) },
+        graph.Nodes<Person>().Where(person => person.Name == eve.Name));
 
     Console.WriteLine("✓ Created 5 people and their relationships\n");
 
@@ -94,13 +109,13 @@
     Console.WriteLine("\n3. Graph Traversal Examples...");
 
     // Depth 0: Just the node
-    alice = await graph.GetNodeAsync<Person>(alice.Id);
+    alice = await graph.Nodes<Person>().Where(person => person.Name == alice.Name).SingleAsync();
     Console.WriteLine($"\nAlice with depth 0:");
     Console.WriteLine($"  - Name: {alice.Name}");
 
     // Depth 1: Node with immediate relationships
     var aliceKnowsDepth1 = await graph.Nodes<Person>()
-        .Where(p => p.Id == alice.Id)
+        .Where(p => p.Name == alice.Name)
         .Traverse<Knows, Person>()
         .ToListAsync();
 
@@ -110,7 +125,7 @@
 
     // Depth 2: Two levels of relationships
     var aliceKnowsDepth2 = await graph.Nodes<Person>()
-        .Where(p => p.Id == alice.Id)
+        .Where(p => p.Name == alice.Name)
         .Traverse<Knows, Person>(2)
         .ToListAsync();
 
@@ -149,23 +164,23 @@
 
     foreach (var person1 in allPeople)
     {
-        foreach (var person2 in allPeople.Where(p => p.Id != person1.Id && string.Compare(p.Id, person1.Id, StringComparison.Ordinal) > 0))
+        foreach (var person2 in allPeople.Where(p => string.Compare(p.Name, person1.Name, StringComparison.Ordinal) > 0))
         {
             // Get people that person1 knows
             var person1Knows = await graph.Nodes<Person>()
-                .Where(p => p.Id == person1.Id)
+                .Where(p => p.Name == person1.Name)
                 .Traverse<Knows, Person>()
                 .ToListAsync();
 
             // Get people that person2 knows
             var person2Knows = await graph.Nodes<Person>()
-                .Where(p => p.Id == person2.Id)
+                .Where(p => p.Name == person2.Name)
                 .Traverse<Knows, Person>()
                 .ToListAsync();
 
             // Find mutual connections
             var mutual = person1Knows
-                .Where(p1k => person2Knows.Any(p2k => p2k.Id == p1k.Id))
+                .Where(p1k => person2Knows.Any(p2k => p2k.Name == p1k.Name))
                 .ToList();
 
             if (mutual.Count > 0)
@@ -190,16 +205,16 @@
 
     // Get Alice's connections
     var aliceConnections = await graph.Nodes<Person>()
-        .Where(p => p.Id == alice.Id)
+        .Where(p => p.Name == alice.Name)
         .Traverse<Knows, Person>()
-        .Select(p => p.Id)
+        .Select(p => p.Name)
         .ToListAsync();
 
     // Find Bob's connections that are also in Alice's connections
     var mutualBetweenAliceAndBob = await graph.Nodes<Person>()
-        .Where(p => p.Id == bob.Id)
+        .Where(p => p.Name == bob.Name)
         .Traverse<Knows, Person>()
-        .Where(p => aliceConnections.Contains(p.Id))
+        .Where(p => aliceConnections.Contains(p.Name))
         .ToListAsync();
 
     if (mutualBetweenAliceAndBob.Count > 0)
@@ -221,21 +236,21 @@
 
     // Group by person to get their connections
     var connectionsByPerson = allConnections
-        .GroupBy(path => path.StartNode.Id)
+        .GroupBy(path => path.StartNode.Name)
         .ToDictionary(
             g => g.Key,
-            g => g.Select(path => path.EndNode.Id).ToHashSet()
+            g => g.Select(path => path.EndNode.Name).ToHashSet()
         );
 
     // Calculate mutual connection counts for each pair
     var mutualCounts = new List<(string person1, string person2, int count)>();
 
     foreach (var person1 in allPeople)
     {
-        foreach (var person2 in allPeople.Where(p => string.Compare(p.Id, person1.Id, StringComparison.Ordinal) > 0))
+        foreach (var person2 in allPeople.Where(p => string.Compare(p.Name, person1.Name, StringComparison.Ordinal) > 0))
         {
-            if (connectionsByPerson.TryGetValue(person1.Id, out var p1Connections) &&
-                connectionsByPerson.TryGetValue(person2.Id, out var p2Connections))
+            if (connectionsByPerson.TryGetValue(person1.Name, out var p1Connections) &&
+                connectionsByPerson.TryGetValue(person2.Name, out var p2Connections))
             {
                 var mutualCount = p1Connections.Intersect(p2Connections).Count();
                 if (mutualCount > 0)

examples/Example3.TransactionManagement/DomainModel.cs

@@ -23,39 +23,13 @@ public record Bank : Node
 [Relationship(Label = "HAS_ACCOUNT")]
 public record BankAccount : Relationship
 {
-    public BankAccount() : base(string.Empty, string.Empty) { }
-
-    public BankAccount(string startNodeId, string endNodeId, DateTime? openedOn = null, string accountType = "")
-        : base(startNodeId, endNodeId)
-    {
-        OpenedOn = openedOn ?? DateTime.UtcNow;
-        AccountType = accountType;
-    }
-
     public DateTime OpenedOn { get; set; } = DateTime.UtcNow;
     public string AccountType { get; set; } = string.Empty;
 }
 
 [Relationship(Label = "TRANSFER")]
 public record Transfer : Relationship
 {
-    public Transfer() : base(string.Empty, string.Empty)
-    {
-    }
-
-    public Transfer(
-        string startNodeId,
-        string endNodeId,
-        decimal amount = 0m,
-        DateTime? timestamp = null,
-        string description = ""
-    ) : base(startNodeId, endNodeId)
-    {
-        Amount = amount;
-        Timestamp = timestamp ?? DateTime.UtcNow;
-        Description = description;
-    }
-
     public decimal Amount { get; set; } = 0m;
     public DateTime Timestamp { get; set; } = DateTime.UtcNow;
     public string Description { get; set; } = string.Empty;