Expose single point type for both 2D and 3D

With optional `z` component. This is more consistent with Cypher, that
does not differentiate between 2D and 3D points. It has only a single
overloaded `point()` function.

Author: lutovich

src/v1/index.js

@@ -29,7 +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';
+import {Point} from './spatial-types';
 
 /**
  * @property {function(username: string, password: string, realm: ?string)} basic the function to create a
@@ -207,8 +207,7 @@ const types = {
   Result,
   ResultSummary,
   Record,
-  Point2D,
-  Point3D
+  Point
 };
 
 /**

src/v1/internal/packstream-v2.js

@@ -18,7 +18,7 @@
  */
 
 import * as v1 from './packstream-v1';
-import {isPoint2D, isPoint3D, Point2D, Point3D} from '../spatial-types';
+import {isPoint, Point} from '../spatial-types';
 import {int} from '../integer';
 
 const POINT_2D = 0x58;
@@ -39,10 +39,8 @@ export class Packer extends v1.Packer {
   }
 
   packable(obj, onError) {
-    if (isPoint2D(obj)) {
-      return () => packPoint2D(obj, this, onError);
-    } else if (isPoint3D(obj)) {
-      return () => packPoint3D(obj, this, onError);
+    if (isPoint(obj)) {
+      return () => packPoint(obj, this, onError);
     } else {
       return super.packable(obj, onError);
     }
@@ -71,6 +69,15 @@ export class Unpacker extends v1.Unpacker {
   }
 }
 
+function packPoint(point, packer, onError) {
+  const is2DPoint = point.z === null || point.z === undefined;
+  if (is2DPoint) {
+    packPoint2D(point, packer, onError);
+  } else {
+    packPoint3D(point, packer, onError);
+  }
+}
+
 function packPoint2D(point, packer, onError) {
   const packableStructFields = [
     packer.packable(int(point.srid), onError),
@@ -91,15 +98,16 @@ function packPoint3D(point, packer, onError) {
 }
 
 function unpackPoint2D(unpacker, buffer) {
-  return new Point2D(
+  return new Point(
     unpacker.unpack(buffer), // srid
     unpacker.unpack(buffer), // x
-    unpacker.unpack(buffer)  // y
+    unpacker.unpack(buffer), // y
+    undefined                // z
   );
 }
 
 function unpackPoint3D(unpacker, buffer) {
-  return new Point3D(
+  return new Point(
     unpacker.unpack(buffer), // srid
     unpacker.unpack(buffer), // x
     unpacker.unpack(buffer), // y

src/v1/spatial-types.js

@@ -19,44 +19,19 @@
 
 import {int} from './integer';
 
-const POINT_2D_IDENTIFIER_PROPERTY = '__isPoint2D__';
-const POINT_3D_IDENTIFIER_PROPERTY = '__isPoint3D__';
+const POINT_IDENTIFIER_PROPERTY = '__isPoint__';
 
 /**
- * Represents a single two-dimensional point in a particular coordinate reference system.
+ * Represents a single two or three-dimensional point in a particular coordinate reference system.
  */
-export class Point2D {
+export class Point {
 
   /**
    * @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.
+   * @param {number|undefined} z the <code>y</code> coordinate of the point or <code>undefined</code> if point has 2 dimensions.
    */
   constructor(srid, x, y, z) {
     this.srid = int(srid);
@@ -66,30 +41,17 @@ export class Point3D {
   }
 }
 
-Object.defineProperty(Point3D.prototype, POINT_3D_IDENTIFIER_PROPERTY, {
+Object.defineProperty(Point.prototype, POINT_IDENTIFIER_PROPERTY, {
   value: true,
   enumerable: false,
   configurable: false
 });
 
 /**
- * Test if given object is an instance of {@link Point2D} class.
+ * Test if given object is an instance of {@link Point} class.
  * @param {object} obj the object to test.
- * @return {boolean} <code>true</code> if given object is a {@link Point2D}, <code>false</code> otherwise.
+ * @return {boolean} <code>true</code> if given object is a {@link Point}, <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;
+export function isPoint(obj) {
+  return (obj && obj[POINT_IDENTIFIER_PROPERTY]) === true;
 }

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

@@ -17,27 +17,30 @@
  * limitations under the License.
  */
 
-import {Point2D, Point3D} from "../../../types/v1/spatial-types";
+import {isPoint, Point} from "../../../types/v1/spatial-types";
 import Integer, {int} from "../../../types/v1/integer";
 
-const point1: Point2D = new Point2D(int(1), 2, 3);
+const point1: Point = new Point(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 point2: Point<number> = new Point(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 point3: Point = new Point(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 point4: Point<number> = new Point(1, 2, 3, 4);
 const srid4: number = point4.srid;
 const x4: number = point4.x;
 const y4: number = point4.y;
 const z4: number = point4.z;
+
+const isPoint1: boolean = isPoint(point1);
+const isPoint2: boolean = isPoint(null);

test/v1/spatial-types.test.js

@@ -20,7 +20,7 @@
 import neo4j from '../../src/v1';
 import sharedNeo4j from '../internal/shared-neo4j';
 import {ServerVersion, VERSION_3_4_0} from '../../src/v1/internal/server-version';
-import {isPoint2D, isPoint3D, Point2D, Point3D} from '../../src/v1/spatial-types';
+import {isPoint, Point} from '../../src/v1/spatial-types';
 
 const WGS_84_2D_CRS_CODE = neo4j.int(4326);
 const CARTESIAN_2D_CRS_CODE = neo4j.int(7203);
@@ -67,25 +67,27 @@ describe('spatial-types', () => {
 
   it('should receive 2D points', done => {
     testReceivingOfPoints(done, 'RETURN point({x: 169.99, y: 12.1718})', point => {
-      expect(isPoint2D(point)).toBeTruthy();
+      expect(isPoint(point)).toBeTruthy();
       expect(point.srid).toEqual(CARTESIAN_2D_CRS_CODE);
       expect(point.x).toEqual(169.99);
       expect(point.y).toEqual(12.1718);
+      expect(point.z).toBeUndefined();
     });
   });
 
   it('should receive 2D points with crs', done => {
     testReceivingOfPoints(done, `RETURN point({x: 2.3, y: 4.5, crs: 'WGS-84'})`, point => {
-      expect(isPoint2D(point)).toBeTruthy();
+      expect(isPoint(point)).toBeTruthy();
       expect(point.srid).toEqual(WGS_84_2D_CRS_CODE);
       expect(point.x).toEqual(2.3);
       expect(point.y).toEqual(4.5);
+      expect(point.z).toBeUndefined();
     });
   });
 
   it('should receive 3D points', done => {
     testReceivingOfPoints(done, 'RETURN point({x: -19.9, y: 45.99, z: 8.88})', point => {
-      expect(isPoint3D(point)).toBeTruthy();
+      expect(isPoint(point)).toBeTruthy();
       expect(point.srid).toEqual(CARTESIAN_3D_CRS_CODE);
       expect(point.x).toEqual(-19.9);
       expect(point.y).toEqual(45.99);
@@ -95,7 +97,7 @@ describe('spatial-types', () => {
 
   it('should receive 3D points with crs', done => {
     testReceivingOfPoints(done, `RETURN point({x: 34.76, y: 11.9, z: -99.01, crs: 'WGS-84-3D'})`, point => {
-      expect(isPoint3D(point)).toBeTruthy();
+      expect(isPoint(point)).toBeTruthy();
       expect(point.srid).toEqual(WGS_84_3D_CRS_CODE);
       expect(point.x).toEqual(34.76);
       expect(point.y).toEqual(11.9);
@@ -104,33 +106,33 @@ describe('spatial-types', () => {
   });
 
   it('should send and receive 2D point', done => {
-    testSendingAndReceivingOfPoints(done, new Point2D(CARTESIAN_2D_CRS_CODE, 19.101, -88.21));
+    testSendingAndReceivingOfPoints(done, new Point(CARTESIAN_2D_CRS_CODE, 19.101, -88.21));
   });
 
   it('should send and receive 3D point', done => {
-    testSendingAndReceivingOfPoints(done, new Point3D(WGS_84_3D_CRS_CODE, 1.22, 9.8, -6.65));
+    testSendingAndReceivingOfPoints(done, new Point(WGS_84_3D_CRS_CODE, 1.22, 9.8, -6.65));
   });
 
   it('should send and receive array of 2D points', done => {
     const arrayOfPoints = [
-      new Point2D(WGS_84_2D_CRS_CODE, 12.3, 11.2),
-      new Point2D(WGS_84_2D_CRS_CODE, 2.45, 91.302),
-      new Point2D(WGS_84_2D_CRS_CODE, 0.12, -99.9),
-      new Point2D(WGS_84_2D_CRS_CODE, 93.75, 123.213),
-      new Point2D(WGS_84_2D_CRS_CODE, 111.13, -90.1),
-      new Point2D(WGS_84_2D_CRS_CODE, 43.99, -1)
+      new Point(WGS_84_2D_CRS_CODE, 12.3, 11.2),
+      new Point(WGS_84_2D_CRS_CODE, 2.45, 91.302),
+      new Point(WGS_84_2D_CRS_CODE, 0.12, -99.9),
+      new Point(WGS_84_2D_CRS_CODE, 93.75, 123.213),
+      new Point(WGS_84_2D_CRS_CODE, 111.13, -90.1),
+      new Point(WGS_84_2D_CRS_CODE, 43.99, -1)
     ];
 
     testSendingAndReceivingOfPoints(done, arrayOfPoints);
   });
 
   it('should send and receive array of 3D points', done => {
     const arrayOfPoints = [
-      new Point3D(CARTESIAN_3D_CRS_CODE, 83.38, 123.9, -19),
-      new Point3D(CARTESIAN_3D_CRS_CODE, 31, 39.1, -19.19),
-      new Point3D(CARTESIAN_3D_CRS_CODE, 0.845, -0.74, 3.48),
-      new Point3D(CARTESIAN_3D_CRS_CODE, 123.33, 93.3, 96.96),
-      new Point3D(CARTESIAN_3D_CRS_CODE, -54.9, 13.7893, -90.9)
+      new Point(CARTESIAN_3D_CRS_CODE, 83.38, 123.9, -19),
+      new Point(CARTESIAN_3D_CRS_CODE, 31, 39.1, -19.19),
+      new Point(CARTESIAN_3D_CRS_CODE, 0.845, -0.74, 3.48),
+      new Point(CARTESIAN_3D_CRS_CODE, 123.33, 93.3, 96.96),
+      new Point(CARTESIAN_3D_CRS_CODE, -54.9, 13.7893, -90.9)
     ];
 
     testSendingAndReceivingOfPoints(done, arrayOfPoints);

types/v1/spatial-types.d.ts

@@ -20,24 +20,18 @@
 import {NumberOrInteger} from './graph-types';
 import Integer from "./integer";
 
-declare class Point2D<T extends NumberOrInteger = Integer> {
+declare class Point<T extends NumberOrInteger = Integer> {
   srid: T;
   x: number;
   y: number;
+  z: number | undefined;
 
-  constructor(srid: T, x: number, y: number)
+  constructor(srid: T, x: number, y: number, z?: number | undefined)
 }
 
-declare class Point3D<T extends NumberOrInteger = Integer> {
-  srid: T;
-  x: number;
-  y: number;
-  z: number;
-
-  constructor(srid: T, x: number, y: number, z: number)
-}
+declare function isPoint(obj: object): boolean;
 
 export {
-  Point2D,
-  Point3D
+  Point,
+  isPoint
 }