Support points in HTTP driver

This commit makes experimental HTTP driver able to receive spatial
2D and 3D points and return them as `Point` objects in records. Note
that no metadata is returned by the REST endpoint for nested points
(in lists or maps) so they will not be converted to `Point` objects.

Author: lutovich

src/v1/internal/http/http-response-converter.js

@@ -19,7 +19,8 @@
 
 import {isInt} from '../../integer';
 import {Node, Path, PathSegment, Relationship} from '../../graph-types';
-import {Neo4jError} from '../../error';
+import {Neo4jError, PROTOCOL_ERROR} from '../../error';
+import {isPoint, Point} from '../../spatial-types';
 
 const CREDENTIALS_EXPIRED_CODE = 'Neo.ClientError.Security.CredentialsExpired';
 
@@ -137,11 +138,13 @@ function encodeQueryParameters(parameters) {
 
 function encodeQueryParameter(value) {
   if (value instanceof Node) {
-    throw new Neo4jError('It is not allowed to pass nodes in query parameters');
+    throw new Neo4jError('It is not allowed to pass nodes in query parameters', PROTOCOL_ERROR);
   } else if (value instanceof Relationship) {
-    throw new Neo4jError('It is not allowed to pass relationships in query parameters');
+    throw new Neo4jError('It is not allowed to pass relationships in query parameters', PROTOCOL_ERROR);
   } else if (value instanceof Path) {
-    throw new Neo4jError('It is not allowed to pass paths in query parameters');
+    throw new Neo4jError('It is not allowed to pass paths in query parameters', PROTOCOL_ERROR);
+  } else if (isPoint(value)) {
+    throw newUnsupportedParameterError('points');
   } else if (isInt(value)) {
     return value.toNumber();
   } else if (Array.isArray(value)) {
@@ -153,6 +156,11 @@ function encodeQueryParameter(value) {
   }
 }
 
+function newUnsupportedParameterError(name) {
+  return new Neo4jError(`It is not allowed to pass ${name} in query parameters when using HTTP endpoint. ` +
+    `Please consider using Cypher functions to create ${name} so that query parameters are plain objects.`, PROTOCOL_ERROR);
+}
+
 function extractResult(response) {
   const results = response.results;
   if (results) {
@@ -222,23 +230,25 @@ function extractRawRecordElement(index, data, nodesById, relationshipsById) {
   const elementMetadata = data.meta ? data.meta[index] : null;
 
   if (elementMetadata) {
-    // element is either a Node, Relationship or Path
-    return convertComplexValue(elementMetadata, nodesById, relationshipsById);
+    // element is either a graph, spatial or temporal type
+    return convertComplexValue(element, elementMetadata, nodesById, relationshipsById);
   } else {
     // element is a primitive, like number, string, array or object
     return convertPrimitiveValue(element);
   }
 }
 
-function convertComplexValue(elementMetadata, nodesById, relationshipsById) {
+function convertComplexValue(element, elementMetadata, nodesById, relationshipsById) {
   if (isNodeMetadata(elementMetadata)) {
     return nodesById[elementMetadata.id];
   } else if (isRelationshipMetadata(elementMetadata)) {
     return relationshipsById[elementMetadata.id];
   } else if (isPathMetadata(elementMetadata)) {
     return convertPath(elementMetadata, nodesById, relationshipsById);
+  } else if (isPointMetadata(elementMetadata)) {
+    return convertPoint(element);
   } else {
-    return null;
+    return element;
   }
 }
 
@@ -295,6 +305,42 @@ function createPath(pathSegments) {
   return new Path(pathStartNode, pathEndNode, pathSegments);
 }
 
+function convertPoint(element) {
+  const type = element.type;
+  if (type !== 'Point') {
+    throw new Neo4jError(`Unexpected Point type received: ${JSON.stringify(element)}`);
+  }
+
+  const coordinates = element.coordinates;
+  if (!Array.isArray(coordinates) && (coordinates.length !== 2 || coordinates.length !== 3)) {
+    throw new Neo4jError(`Unexpected Point coordinates received: ${JSON.stringify(element)}`);
+  }
+
+  const srid = convertCrsToId(element);
+
+  return new Point(srid, ...coordinates);
+}
+
+function convertCrsToId(element) {
+  const crs = element.crs;
+  if (!crs || !crs.name) {
+    throw new Neo4jError(`Unexpected Point crs received: ${JSON.stringify(element)}`);
+  }
+  const name = crs.name.toLowerCase();
+
+  if (name === 'wgs-84') {
+    return 4326;
+  } else if (name === 'wgs-84-3d') {
+    return 4979;
+  } else if (name === 'cartesian') {
+    return 7203;
+  } else if (name === 'cartesian-3d') {
+    return 9157;
+  } else {
+    throw new Neo4jError(`Unexpected Point crs received: ${JSON.stringify(element)}`);
+  }
+}
+
 function convertPrimitiveValue(element) {
   if (element == null || element === undefined) {
     return null;
@@ -317,11 +363,19 @@ function convertNumber(value) {
 }
 
 function isNodeMetadata(metadata) {
-  return !Array.isArray(metadata) && typeof metadata === 'object' && metadata.type === 'node';
+  return isMetadataForType('node', metadata);
 }
 
 function isRelationshipMetadata(metadata) {
-  return !Array.isArray(metadata) && typeof metadata === 'object' && metadata.type === 'relationship';
+  return isMetadataForType('relationship', metadata);
+}
+
+function isPointMetadata(metadata) {
+  return isMetadataForType('point', metadata);
+}
+
+function isMetadataForType(name, metadata) {
+  return !Array.isArray(metadata) && typeof metadata === 'object' && metadata.type === name;
 }
 
 function isPathMetadata(metadata) {

test/internal/http/http-driver.test.js

@@ -273,6 +273,29 @@ describe('http driver', () => {
     });
   }, 20000);
 
+  it('should fail to pass node as a query parameter', done => {
+    testUnsupportedQueryParameterWithHttpDriver(new neo4j.types.Node(neo4j.int(1), ['Person'], {name: 'Bob'}), done);
+  });
+
+  it('should fail to pass relationship as a query parameter', done => {
+    testUnsupportedQueryParameterWithHttpDriver(new neo4j.types.Relationship(neo4j.int(1), neo4j.int(2), neo4j.int(3), 'KNOWS', {since: 42}), done);
+  });
+
+  it('should fail to pass path as a query parameter', done => {
+    const node1 = new neo4j.types.Node(neo4j.int(1), ['Person'], {name: 'Alice'});
+    const node2 = new neo4j.types.Node(neo4j.int(2), ['Person'], {name: 'Bob'});
+    testUnsupportedQueryParameterWithHttpDriver(new neo4j.types.Path(node1, node2, []), done);
+  });
+
+  it('should receive points', done => {
+    testReceivingOfResults([
+      'RETURN point({x: 42.341, y: 125.0})',
+      'RETURN point({x: 13.2, y: 22.2, z: 33.3})',
+      'RETURN point({x: 92.3, y: 71.2, z: 2.12345, crs: "wgs-84-3d"})',
+      'RETURN point({longitude: 56.7, latitude: 12.78})',
+    ], done);
+  });
+
   function testSendAndReceiveWithReturnQuery(values, done) {
     const query = 'RETURN $value';
 
@@ -337,6 +360,19 @@ describe('http driver', () => {
     });
   }
 
+  function testUnsupportedQueryParameterWithHttpDriver(value, done) {
+    const session = httpDriver.session();
+    session.run('RETURN $value', {value: value}).then(() => {
+      done.fail('Should not be possible to send ' + value);
+    }).catch(error => {
+      expect(error.name).toEqual('Neo4jError');
+      expect(error.code).toEqual(neo4j.error.PROTOCOL_ERROR);
+      session.close(() => {
+        done();
+      });
+    });
+  }
+
   function databaseSupportsTransactionTerminationInLocks() {
     return serverVersion.compareTo(VERSION_3_1_0) >= 0;
   }