Support for 2D and 3D points in Bolt V2

This commit makes driver able to send and receive 2D and 3D points.
Both are represented as custom `Point2D` and `Point3D` classes that
contain coordinates and coordinate reference system identifier. This
identifier comes as an integer from the database. It can thus be either
represented as `Integer` or native `number`, when
`disableLosslessIntegers` config option is set to true.

Author: lutovich

src/v1/index.js

@@ -29,6 +29,7 @@ import VERSION from '../version';
 import {assertString, isEmptyObjectOrNull} from './internal/util';
 import urlUtil from './internal/url-util';
 import HttpDriver from './internal/http/http-driver';
+import {Point2D, Point3D} from './spatial-types';
 
 /**
  * @property {function(username: string, password: string, realm: ?string)} basic the function to create a
@@ -205,7 +206,9 @@ const types = {
   Path,
   Result,
   ResultSummary,
-  Record
+  Record,
+  Point2D,
+  Point3D
 };
 
 /**

src/v1/internal/packstream-v2.js

@@ -18,6 +18,11 @@
  */
 
 import * as v1 from './packstream-v1';
+import {isPoint2D, isPoint3D, Point2D, Point3D} from '../spatial-types';
+import {int} from '../integer';
+
+const POINT_2D = 0x58;
+const POINT_3D = 0x59;
 
 export class Packer extends v1.Packer {
 
@@ -32,6 +37,16 @@ export class Packer extends v1.Packer {
   disableByteArrays() {
     throw new Error('Bolt V2 should always support byte arrays');
   }
+
+  packable(obj, onError) {
+    if (isPoint2D(obj)) {
+      return () => packPoint2D(obj, this, onError);
+    } else if (isPoint3D(obj)) {
+      return () => packPoint3D(obj, this, onError);
+    } else {
+      return super.packable(obj, onError);
+    }
+  }
 }
 
 export class Unpacker extends v1.Unpacker {
@@ -43,4 +58,51 @@ export class Unpacker extends v1.Unpacker {
   constructor(disableLosslessIntegers = false) {
     super(disableLosslessIntegers);
   }
+
+
+  _unpackUnknownStruct(signature, size, buffer) {
+    if (signature == POINT_2D) {
+      return unpackPoint2D(this, buffer);
+    } else if (signature == POINT_3D) {
+      return unpackPoint3D(this, buffer);
+    } else {
+      return super._unpackUnknownStruct(signature, size, buffer);
+    }
+  }
+}
+
+function packPoint2D(point, packer, onError) {
+  const packableStructFields = [
+    packer.packable(int(point.srid), onError),
+    packer.packable(point.x, onError),
+    packer.packable(point.y, onError)
+  ];
+  packer.packStruct(POINT_2D, packableStructFields, onError);
+}
+
+function packPoint3D(point, packer, onError) {
+  const packableStructFields = [
+    packer.packable(int(point.srid), onError),
+    packer.packable(point.x, onError),
+    packer.packable(point.y, onError),
+    packer.packable(point.z, onError)
+  ];
+  packer.packStruct(POINT_3D, packableStructFields, onError);
+}
+
+function unpackPoint2D(unpacker, buffer) {
+  return new Point2D(
+    unpacker.unpack(buffer), // srid
+    unpacker.unpack(buffer), // x
+    unpacker.unpack(buffer)  // y
+  );
+}
+
+function unpackPoint3D(unpacker, buffer) {
+  return new Point3D(
+    unpacker.unpack(buffer), // srid
+    unpacker.unpack(buffer), // x
+    unpacker.unpack(buffer), // y
+    unpacker.unpack(buffer)  // z
+  );
 }

src/v1/internal/server-version.js

@@ -111,12 +111,14 @@ function compareInts(x, y) {
 
 const VERSION_3_1_0 = new ServerVersion(3, 1, 0);
 const VERSION_3_2_0 = new ServerVersion(3, 2, 0);
+const VERSION_3_4_0 = new ServerVersion(3, 4, 0);
 const VERSION_IN_DEV = new ServerVersion(0, 0, 0);
 
 export {
   ServerVersion,
   VERSION_3_1_0,
   VERSION_3_2_0,
+  VERSION_3_4_0,
   VERSION_IN_DEV
 };
 

src/v1/spatial-types.js

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2002-2018 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {int} from './integer';
+
+const POINT_2D_IDENTIFIER_PROPERTY = '__isPoint2D__';
+const POINT_3D_IDENTIFIER_PROPERTY = '__isPoint3D__';
+
+/**
+ * Represents a single two-dimensional point in a particular coordinate reference system.
+ */
+export class Point2D {
+
+  /**
+   * @constructor
+   * @param {number|Integer} srid the coordinate reference system identifier.
+   * @param {number} x the <code>x</code> coordinate of the point.
+   * @param {number} y the <code>y</code> coordinate of the point.
+   */
+  constructor(srid, x, y) {
+    this.srid = int(srid);
+    this.x = x;
+    this.y = y;
+  }
+}
+
+Object.defineProperty(Point2D.prototype, POINT_2D_IDENTIFIER_PROPERTY, {
+  value: true,
+  enumerable: false,
+  configurable: false
+});
+
+/**
+ * Represents a single tree-dimensional point in a particular coordinate reference system.
+ */
+export class Point3D {
+
+  /**
+   * @constructor
+   * @param {number|Integer} srid the coordinate reference system identifier.
+   * @param {number} x the <code>x</code> coordinate of the point.
+   * @param {number} y the <code>y</code> coordinate of the point.
+   * @param {number} z the <code>z</code> coordinate of the point.
+   */
+  constructor(srid, x, y, z) {
+    this.srid = int(srid);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+}
+
+Object.defineProperty(Point3D.prototype, POINT_3D_IDENTIFIER_PROPERTY, {
+  value: true,
+  enumerable: false,
+  configurable: false
+});
+
+/**
+ * Test if given object is an instance of {@link Point2D} class.
+ * @param {object} obj the object to test.
+ * @return {boolean} <code>true</code> if given object is a {@link Point2D}, <code>false</code> otherwise.
+ */
+export function isPoint2D(obj) {
+  return hasProperty(obj, POINT_2D_IDENTIFIER_PROPERTY);
+}
+
+/**
+ * Test if given object is an instance of {@link Point3D} class.
+ * @param {object} obj the object to test.
+ * @return {boolean} <code>true</code> if given object is a {@link Point3D}, <code>false</code> otherwise.
+ */
+export function isPoint3D(obj) {
+  return hasProperty(obj, POINT_3D_IDENTIFIER_PROPERTY);
+}
+
+function hasProperty(obj, name) {
+  return (obj && obj[name]) === true;
+}

test/types/v1/spatial-types.test.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2002-2018 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Point2D, Point3D} from "../../../types/v1/spatial-types";
+import Integer, {int} from "../../../types/v1/integer";
+
+const point1: Point2D = new Point2D(int(1), 2, 3);
+const srid1: Integer = point1.srid;
+const x1: number = point1.x;
+const y1: number = point1.y;
+
+const point2: Point2D<number> = new Point2D(1, 2, 3);
+const srid2: number = point2.srid;
+const x2: number = point2.x;
+const y2: number = point2.y;
+
+const point3: Point3D = new Point3D(int(1), 2, 3, 4);
+const srid3: Integer = point3.srid;
+const x3: number = point3.x;
+const y3: number = point3.y;
+const z3: number = point3.z;
+
+const point4: Point3D<number> = new Point3D(1, 2, 3, 4);
+const srid4: number = point4.srid;
+const x4: number = point4.x;
+const y4: number = point4.y;
+const z4: number = point4.z;