added path support

Author: DvirDukhan

package.json

@@ -9,6 +9,7 @@
 		"url": "git://github.com/redislabs/redisgraph.js.git"
 	},
 	"dependencies": {
+		"deep-equal": "^1.1.0",
 		"redis": "^2.8.0"
 	},
 	"devDependencies": {

src/path.js

@@ -0,0 +1,45 @@
+class Path {
+    constructor(nodes, edges){
+        this.nodes = nodes;
+        this.edges = edges;
+    }
+
+    getNodes(){
+        return this.nodes;
+    }
+
+    getEdges(){
+        return this.edges;
+    }
+
+    getNode(index){
+        return this.nodes[index];
+    }
+
+    getEdge(index){
+        return this.edges[index];
+    }
+
+    firstNode(){
+        return this.nodes[0];
+    }
+
+    lastNode(){
+        return this.nodes[this.nodes.length -1];
+    }
+
+    nodeCount(){
+        return this.nodes.length;
+    }
+
+    edgeCount(){
+        return this.edges.length;
+    }
+
+    toString() {
+        return JSON.stringify(this);
+    }
+
+}
+
+module.exports = Path;

src/resultSet.js

@@ -2,6 +2,7 @@ const Statistics = require("./statistics"),
     Record = require("./record");
     Node = require("./node");
     Edge = require("./edge");
+    Path = require("./path");
     ReplyError = require("redis").ReplyError
 
 const ResultSetColumnTypes = {
@@ -20,7 +21,8 @@ const ResultSetValueTypes = {
     VALUE_DOUBLE: 5,
     VALUE_ARRAY: 6,
     VALUE_EDGE: 7,
-    VALUE_NODE: 8
+    VALUE_NODE: 8,
+    VALUE_PATH: 9
 }
 
 /**
@@ -190,6 +192,12 @@ class ResultSet {
         return rawArray;
     }
 
+    async parsePath(rawPath) {
+        let nodes = await this.parseScalar(rawPath[0]);
+        let edges = await this.parseScalar(rawPath[1]);
+        return new Path(nodes, edges);
+    }
+
     async parseScalar(cell) {
         let scalar_type = cell[0];
         let value = cell[1];
@@ -224,6 +232,9 @@ class ResultSet {
             case ResultSetValueTypes.VALUE_EDGE:
                 scalar = await this.parseEdge(value);
                 break;
+            case ResultSetValueTypes.VALUE_PATH:
+                scalar = await this.parsePath(value);
+                break;
             case ResultSetValueTypes.VALUE_UNKNOWN:
                 console.log("Unknown scalar type\n");
                 break;

test/pathBuilder.js

@@ -0,0 +1,35 @@
+Node = require("../src/node");
+Edge = require("../src/edge");
+Path = require("../src/path");
+
+class PathBuilder {
+    constructor(nodeCount){
+        this.nodes = new Array();
+        this.edges = new Array();
+        this.currentAppendClass = Node;
+    }
+
+    append(obj){
+        if(! obj instanceof this.currentAppendClass) throw "Error in path build insertion order and types."
+        if(obj instanceof Node) return this._appendNode(obj);
+        else return this._appendEdge(obj);
+    }
+
+    build(){
+        return new Path(this.nodes, this.edges);
+    }
+
+    _appendNode(node){
+        this.nodes.push(node);
+        this.currentAppendClass = Edge;
+        return this;
+    }
+
+    _appendEdge(edge){
+        this.edges.push(edge);
+        this.currentAppendClass = Node;
+        return this;
+    }
+}
+
+module.exports = PathBuilder;

test/redisGraphAPITest.js

@@ -2,6 +2,8 @@ const assert = require("assert"),
     redis = require("redis"),
     Label = require("../src/label"),
     RedisGraph = require("../src/graph");
+    PathBuilder = require("./pathBuilder");
+    deepEqual = require('deep-equal');
 
 describe('RedisGraphAPI Test', function () {
     const api = new RedisGraph("social");
@@ -288,4 +290,44 @@ describe('RedisGraphAPI Test', function () {
         })
     })
 
+    it('testPath', (done)=>{
+        api.query("CREATE (:L1)-[:R1]->(:L1)-[:R1]->(:L1)").then(response => {
+            api.query("MATCH p = (:L1)-[:R1*]->(:L1) RETURN p").then(response =>{
+                let node0 = new Node("L1", {});
+                node0.setId(0);
+                let node1 = new Node("L1", {});
+                node1.setId(1);
+                let node2 = new Node("L1", {});
+                node2.setId(2);
+                let edge01 = new Edge(0, "R1", 1, {});
+                edge01.setId(0);
+                let edge12 = new Edge(1, "R1", 2, {});
+                edge12.setId(1);
+
+                let path01 = new PathBuilder().append(node0).append(edge01).append(node1).build();
+                let path12 = new PathBuilder().append(node1).append(edge12).append(node2).build();
+                let path02 = new PathBuilder().append(node0).append(edge01).append(node1).append(edge12).append(node2).build();
+
+                let paths = new Set([path01, path12, path02]);
+                while(response.hasNext()){
+                    let p = response.next().get("p");
+                    let pInPaths = false;
+                    let path = null;
+                    for( pathsIterator = paths.values(); path = pathsIterator.next().value;){
+                        if(deepEqual(p ,path)){
+                            pInPaths = true;
+                            break;
+                        }
+                    }
+                   assert(pInPaths);
+                   paths.delete(path);
+                }
+                assert.equal(0, paths.size);
+                done();
+            })
+        }).catch(error => {
+            console.log(error);
+        })
+    })
+
 });