Add Redis Graph Commands

src/NRedisStack/Graph/DataTypes/Edge.cs

@@ -0,0 +1,96 @@
+using System.Text;
+
+namespace NRedisStack.Graph.DataTypes
+{
+    /// <summary>
+    /// A class reprenting an edge (graph entity). In addition to the base class properties, an edge shows its source,
+    /// destination, and relationship type.
+    /// </summary>
+    public class Edge : GraphEntity
+    {
+        /// <summary>
+        /// The relationship type.
+        /// </summary>
+        /// <value></value>
+        public string RelationshipType { get; set; }
+
+        /// <summary>
+        /// The ID of the source node.
+        /// </summary>
+        /// <value></value>
+        public long Source { get; set; }
+
+        /// <summary>
+        /// The ID of the desination node.
+        /// </summary>
+        /// <value></value>
+        public long Destination { get; set; }
+
+        /// <summary>
+        /// Overriden from the base `Equals` implementation. In addition to the expected behavior of checking
+        /// reference equality, we'll also fall back and check to see if the: Source, Destination, and RelationshipType
+        /// are equal.
+        /// </summary>
+        /// <param name="obj">Another `Edge` object to compare to.</param>
+        /// <returns>True if the two instances are equal, false if not.</returns>
+        public override bool Equals(object? obj)
+        {
+            if (obj == null) return this == null;
+
+            if (this == obj)
+            {
+                return true;
+            }
+
+            if (!(obj is Edge that))
+            {
+                return false;
+            }
+
+            if (!base.Equals(obj))
+            {
+                return false;
+            }
+
+            return Source == that.Source && Destination == that.Destination && RelationshipType == that.RelationshipType;
+        }
+
+        /// <summary>
+        /// Overriden from base to compute a deterministic hashcode based on RelationshipType, Source, and Destination.
+        /// </summary>
+        /// <returns>An integer representing the hash code for this instance.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+
+                hash = hash * 31 + base.GetHashCode();
+                hash = hash * 31 + RelationshipType.GetHashCode();
+                hash = hash * 31 + Source.GetHashCode();
+                hash = hash * 31 + Destination.GetHashCode();
+
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Override from base to emit a string that contains: RelationshipType, Source, Destination, Id, and PropertyMap.
+        /// </summary>
+        /// <returns>A string containing a description of the Edge containing a RelationshipType, Source, Destination, Id, and PropertyMap.</returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("Edge{");
+            sb.Append($"relationshipType='{RelationshipType}'");
+            sb.Append($", source={Source}");
+            sb.Append($", destination={Destination}");
+            sb.Append($", id={Id}");
+            sb.Append($", {PropertyMapToString()}");
+            sb.Append("}");
+
+            return sb.ToString();
+        }
+    }
+}

src/NRedisStack/Graph/DataTypes/GraphEntity.cs

@@ -0,0 +1,89 @@
+using System.Text;
+
+namespace NRedisStack.Graph.DataTypes
+{
+    /// <summary>
+    /// An abstract representation of a graph entity.
+    /// A graph entity has an ID and a set of properties. The properties are mapped and accessed by their names.
+    /// </summary>
+    public abstract class GraphEntity
+    {
+        public long Id { get; set; }
+
+        public IDictionary<string, object> PropertyMap = new Dictionary<string, object>();
+
+        /// <summary>
+        /// Overriden Equals that considers the equality of the entity ID as well as the equality of the
+        /// properties that each entity has.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(object? obj)
+        {
+            if (obj == null) return this == null;
+
+            if (this == obj)
+            {
+                return true;
+            }
+
+            if (!(obj is GraphEntity that))
+            {
+                return false;
+            }
+
+            return Id == that.Id && (PropertyMap.SequenceEqual(that.PropertyMap));
+        }
+
+        /// <summary>
+        /// Overriden GetHashCode that computes a deterministic hash code based on the value of the ID
+        /// and the name/value of each of the associated properties.
+        /// </summary>
+        /// <returns></returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+
+                hash = hash * 31 + Id.GetHashCode();
+
+                foreach(var prop in PropertyMap)
+                {
+                    hash = hash * 31 + prop.Key.GetHashCode();
+                    hash = hash * 31 + prop.Value.GetHashCode();
+                }
+
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Overriden ToString that emits a string containing the ID and property map of the entity.
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("GraphEntity{id=");
+            sb.Append(Id);
+            sb.Append(", propertyMap=");
+            sb.Append(PropertyMap);
+            sb.Append('}');
+
+            return sb.ToString();
+        }
+
+        public string PropertyMapToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("propertyMap={");
+            sb.Append(string.Join(", ", PropertyMap.Select(pm => $"{pm.Key}={pm.Value}")));
+            sb.Append("}");
+
+            return sb.ToString();
+        }
+    }
+}

src/NRedisStack/Graph/DataTypes/Node.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NRedisStack.Graph.DataTypes
+{
+    /// <summary>
+    /// A class representing a node (graph entity). In addition to the base class ID and properties, a node has labels.
+    /// </summary>
+    public sealed class Node : GraphEntity
+    {
+        public List<string> Labels { get; }
+
+        public Node()
+        {
+            Labels = new List<string>();
+        }
+
+        /// <summary>
+        /// Overriden member that checks to see if the names of the labels of a node are equal
+        /// (in addition to base `Equals` functionality).
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(object? obj)
+        {
+            if (obj == null) return this == null;
+
+            if (this == obj)
+            {
+                return true;
+            }
+
+            if (!(obj is Node that))
+            {
+                return false;
+            }
+
+            if (!base.Equals(obj))
+            {
+                return false;
+            }
+
+            return Enumerable.SequenceEqual(Labels, that.Labels);
+        }
+
+        /// <summary>
+        /// Overridden member that computes a hash code based on the base `GetHashCode` implementation
+        /// as well as the hash codes of all labels.
+        /// </summary>
+        /// <returns></returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+
+                foreach(var label in Labels)
+                {
+                    hash = hash * 31 + label.GetHashCode();
+                }
+
+                hash = hash * 31 + base.GetHashCode();
+
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Overridden member that emits a string containing the labels, ID, and property map of a node.
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("Node{labels=");
+            sb.Append($"[{string.Join(", ", Labels)}]");
+            sb.Append($", id={Id}");
+            sb.Append($", {PropertyMapToString()}");
+            sb.Append("}");
+
+            return sb.ToString();
+        }
+    }
+}

src/NRedisStack/Graph/DataTypes/Path.cs

@@ -0,0 +1,93 @@
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+[assembly: InternalsVisibleTo("NRedisStack.Tests.Graph")]
+
+namespace NRedisStack.Graph.DataTypes
+{
+    /// <summary>
+    /// This class represents a path in the graph.
+    /// </summary>
+    public class Path
+    {
+        public ReadOnlyCollection<Node> Nodes { get;}
+        public ReadOnlyCollection<Edge> Edges { get;}
+
+        public Path(IList<Node> nodes, IList<Edge> edges)
+        {
+            Nodes = new ReadOnlyCollection<Node>(nodes);
+            Edges = new ReadOnlyCollection<Edge>(edges);
+        }
+
+
+        /// <summary>
+        /// How many edges exist on this path.
+        /// </summary>
+        public int Length => Edges.Count;
+
+        /// <summary>
+        /// Overriden `Equals` method that will consider the equality of the Nodes and Edges between two paths.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(object? obj)
+        {
+            if (obj == null) return this == null;
+
+            if (this == obj)
+            {
+                return true;
+            }
+
+            if (!(obj is Path path))
+            {
+                return false;
+            }
+
+            return Enumerable.SequenceEqual(Nodes, path.Nodes) && Enumerable.SequenceEqual(Edges, path.Edges);
+        }
+
+        /// <summary>
+        /// Overridden `GetHashCode` method that will compute a hash code using the hash code of each node and edge on
+        /// the path.
+        /// </summary>
+        /// <returns></returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+
+                foreach (var node in Nodes)
+                {
+                    hash = hash * 31 + node.GetHashCode();
+                }
+
+                foreach (var edge in Edges)
+                {
+                    hash = hash * 31 + edge.GetHashCode();
+                }
+
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Overridden `ToString` method that will emit a string based on the string values of the nodes and edges
+        /// on the path.
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("Path{");
+            sb.Append($"nodes={Nodes}");
+            sb.Append($", edges={Edges}");
+            sb.Append("}");
+
+            return sb.ToString();
+        }
+    }
+}

src/NRedisStack/Graph/GraphCache.cs

@@ -0,0 +1,23 @@
+namespace NRedisStack.Graph
+{
+    internal sealed class GraphCache
+    {
+        public GraphCacheList Labels { get; set; }
+        public GraphCacheList PropertyNames { get; set; }
+        public GraphCacheList RelationshipTypes { get; set; }
+
+        public GraphCache(string graphName, GraphCommands redisGraph)
+        {
+            Labels = new GraphCacheList(graphName, "db.labels", redisGraph);
+            PropertyNames = new GraphCacheList(graphName, "db.propertyKeys", redisGraph);
+            RelationshipTypes = new GraphCacheList(graphName, "db.relationshipTypes", redisGraph);
+        }
+
+        public string GetLabel(int index) => Labels.GetCachedData(index);
+
+        public string GetRelationshipType(int index) => RelationshipTypes.GetCachedData(index);
+
+        public string GetPropertyName(int index) => PropertyNames.GetCachedData(index);
+
+    }
+}