Support for temporal types

This commit makes driver able to receive temporal types as query results and
send them as query parameters. All types are represented by custom date-time
classes because native `Date` type is quite limited. It can't represent
needed millisecond range and does not have support for things like timezone.

All temporal types expose understandable properties. For example `CypherDate`
has `year`, `month` and `day` properties. Driver uses code adapted from
https://github.com/ThreeTen/threetenbp to perform the conversions. Main
difference is that driver operates on `Integer` objects and not native
JavaScript numbers.

Author: lutovich

src/v1/integer.js

@@ -238,7 +238,9 @@ class Integer {
    * @returns {boolean}
    * @expose
    */
-  notEquals(other) { !this.equals(/* validates */ other); }
+  notEquals(other) {
+    return !this.equals(/* validates */ other);
+  }
 
   /**
    * Tests if this Integer's value is less than the specified's.

src/v1/internal/packstream-v2.js

@@ -19,14 +19,57 @@
 
 import * as v1 from './packstream-v1';
 import {isPoint, Point} from '../spatial-types';
+import {
+  CypherDate,
+  CypherDateTimeWithZoneId,
+  CypherDateTimeWithZoneOffset,
+  CypherDuration,
+  CypherTime,
+  isCypherDate,
+  isCypherDateTimeWithZoneId,
+  isCypherDateTimeWithZoneOffset,
+  isCypherDuration,
+  isCypherLocalDateTime,
+  isCypherLocalTime,
+  isCypherTime
+} from '../temporal-types';
 import {int} from '../integer';
+import {
+  cypherDateToEpochDay,
+  cypherLocalDateTimeToEpochSecond,
+  cypherLocalTimeToNanoOfDay,
+  epochDayToCypherDate,
+  epochSecondAndNanoToCypherLocalDateTime,
+  nanoOfDayToCypherLocalTime
+} from '../internal/temporal-util';
 
 const POINT_2D = 0x58;
 const POINT_2D_STRUCT_SIZE = 3;
 
 const POINT_3D = 0x59;
 const POINT_3D_STRUCT_SIZE = 4;
 
+const DURATION = 0x45;
+const DURATION_STRUCT_SIZE = 4;
+
+const LOCAL_TIME = 0x74;
+const LOCAL_TIME_STRUCT_SIZE = 1;
+
+const TIME = 0x54;
+const TIME_STRUCT_SIZE = 2;
+
+const DATE = 0x44;
+const DATE_STRUCT_SIZE = 1;
+
+const LOCAL_DATE_TIME = 0x64;
+const LOCAL_DATE_TIME_STRUCT_SIZE = 2;
+
+const DATE_TIME_WITH_ZONE_OFFSET = 0x46;
+const DATE_TIME_WITH_ZONE_OFFSET_STRUCT_SIZE = 3;
+
+const DATE_TIME_WITH_ZONE_ID = 0x66;
+const DATE_TIME_WITH_ZONE_ID_STRUCT_SIZE = 3;
+
 export class Packer extends v1.Packer {
 
   /**
@@ -44,6 +87,20 @@ export class Packer extends v1.Packer {
   packable(obj, onError) {
     if (isPoint(obj)) {
       return () => packPoint(obj, this, onError);
+    } else if (isCypherDuration(obj)) {
+      return () => packDuration(obj, this, onError);
+    } else if (isCypherLocalTime(obj)) {
+      return () => packLocalTime(obj, this, onError);
+    } else if (isCypherTime(obj)) {
+      return () => packTime(obj, this, onError);
+    } else if (isCypherDate(obj)) {
+      return () => packDate(obj, this, onError);
+    } else if (isCypherLocalDateTime(obj)) {
+      return () => packLocalDateTime(obj, this, onError);
+    } else if (isCypherDateTimeWithZoneOffset(obj)) {
+      return () => packDateTimeWithZoneOffset(obj, this, onError);
+    } else if (isCypherDateTimeWithZoneId(obj)) {
+      return () => packDateTimeWithZoneId(obj, this, onError);
     } else {
       return super.packable(obj, onError);
     }
@@ -66,6 +123,20 @@ export class Unpacker extends v1.Unpacker {
       return unpackPoint2D(this, structSize, buffer);
     } else if (signature == POINT_3D) {
       return unpackPoint3D(this, structSize, buffer);
+    } else if (signature == DURATION) {
+      return unpackDuration(this, structSize, buffer);
+    } else if (signature == LOCAL_TIME) {
+      return unpackLocalTime(this, structSize, buffer);
+    } else if (signature == TIME) {
+      return unpackTime(this, structSize, buffer);
+    } else if (signature == DATE) {
+      return unpackDate(this, structSize, buffer);
+    } else if (signature == LOCAL_DATE_TIME) {
+      return unpackLocalDateTime(this, structSize, buffer);
+    } else if (signature == DATE_TIME_WITH_ZONE_OFFSET) {
+      return unpackDateTimeWithZoneOffset(this, structSize, buffer);
+    } else if (signature == DATE_TIME_WITH_ZONE_ID) {
+      return unpackDateTimeWithZoneId(this, structSize, buffer);
     } else {
       return super._unpackUnknownStruct(signature, structSize, buffer);
     }
@@ -121,3 +192,215 @@ function unpackPoint3D(unpacker, structSize, buffer) {
     unpacker.unpack(buffer)  // z
   );
 }
+
+function packDuration(value, packer, onError) {
+  const months = int(value.months);
+  const days = int(value.days);
+  const seconds = int(value.seconds);
+  const nanoseconds = int(value.nanoseconds);
+
+  const packableStructFields = [
+    packer.packable(months, onError),
+    packer.packable(days, onError),
+    packer.packable(seconds, onError),
+    packer.packable(nanoseconds, onError),
+  ];
+  packer.packStruct(DURATION, packableStructFields, onError);
+}
+
+function unpackDuration(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('Duration', DURATION_STRUCT_SIZE, structSize);
+
+  const months = unpacker.unpack(buffer);
+  const days = unpacker.unpack(buffer);
+  const seconds = unpacker.unpack(buffer);
+  const nanoseconds = unpacker.unpack(buffer);
+
+  return new CypherDuration(months, days, seconds, nanoseconds);
+}
+
+function packLocalTime(value, packer, onError) {
+  const totalNanos = cypherLocalTimeToNanoOfDay(value);
+
+  const packableStructFields = [
+    packer.packable(totalNanos, onError)
+  ];
+  packer.packStruct(LOCAL_TIME, packableStructFields, onError);
+}
+
+function unpackLocalTime(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('LocalTime', LOCAL_TIME_STRUCT_SIZE, structSize);
+
+  const nanoOfDay = unpacker.unpack(buffer);
+  return nanoOfDayToCypherLocalTime(nanoOfDay);
+}
+
+/**
+ * Pack given cypher time.
+ * @param {CypherTime} value the time value to pack.
+ * @param {Packer} packer the packer to use.
+ * @param {function} onError the error callback.
+ */
+function packTime(value, packer, onError) {
+  const totalNanos = cypherLocalTimeToNanoOfDay(value.localTime);
+  const offsetSeconds = int(value.offsetSeconds);
+
+  const packableStructFields = [
+    packer.packable(totalNanos, onError),
+    packer.packable(offsetSeconds, onError)
+  ];
+  packer.packStruct(TIME, packableStructFields, onError);
+}
+
+/**
+ * Unpack cypher time value using the given unpacker.
+ * @param {Unpacker} unpacker the unpacker to use.
+ * @param {number} structSize the retrieved struct size.
+ * @param {BaseBuffer} buffer the buffer to unpack from.
+ * @return {CypherTime} the unpacked cypher time value.
+ */
+function unpackTime(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('Time', TIME_STRUCT_SIZE, structSize);
+
+  const nanoOfDay = unpacker.unpack(buffer);
+  const offsetSeconds = unpacker.unpack(buffer);
+
+  const localTime = nanoOfDayToCypherLocalTime(nanoOfDay);
+  return new CypherTime(localTime, offsetSeconds);
+}
+
+/**
+ * Pack given cypher date.
+ * @param {CypherDate} value the date value to pack.
+ * @param {Packer} packer the packer to use.
+ * @param {function} onError the error callback.
+ */
+function packDate(value, packer, onError) {
+  const epochDay = cypherDateToEpochDay(value);
+
+  const packableStructFields = [
+    packer.packable(epochDay, onError)
+  ];
+  packer.packStruct(DATE, packableStructFields, onError);
+}
+
+/**
+ * Unpack cypher date value using the given unpacker.
+ * @param {Unpacker} unpacker the unpacker to use.
+ * @param {number} structSize the retrieved struct size.
+ * @param {BaseBuffer} buffer the buffer to unpack from.
+ * @return {CypherDate} the unpacked cypher date value.
+ */
+function unpackDate(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('Date', DATE_STRUCT_SIZE, structSize);
+
+  const epochDay = unpacker.unpack(buffer);
+  return epochDayToCypherDate(epochDay);
+}
+
+/**
+ * Pack given cypher local date time.
+ * @param {CypherLocalDateTime} value the local date time value to pack.
+ * @param {Packer} packer the packer to use.
+ * @param {function} onError the error callback.
+ */
+function packLocalDateTime(value, packer, onError) {
+  const epochSecond = cypherLocalDateTimeToEpochSecond(value);
+  const nano = int(value.localTime.nanosecond);
+
+  const packableStructFields = [
+    packer.packable(epochSecond, onError),
+    packer.packable(nano, onError)
+  ];
+  packer.packStruct(LOCAL_DATE_TIME, packableStructFields, onError);
+}
+
+/**
+ * Unpack cypher local date time value using the given unpacker.
+ * @param {Unpacker} unpacker the unpacker to use.
+ * @param {number} structSize the retrieved struct size.
+ * @param {BaseBuffer} buffer the buffer to unpack from.
+ * @return {CypherLocalDateTime} the unpacked cypher local date time value.
+ */
+function unpackLocalDateTime(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('LocalDateTime', LOCAL_DATE_TIME_STRUCT_SIZE, structSize);
+
+  const epochSecond = unpacker.unpack(buffer);
+  const nano = unpacker.unpack(buffer);
+
+  return epochSecondAndNanoToCypherLocalDateTime(epochSecond, nano);
+}
+
+/**
+ * Pack given cypher date time with zone offset.
+ * @param {CypherDateTimeWithZoneOffset} value the date time value to pack.
+ * @param {Packer} packer the packer to use.
+ * @param {function} onError the error callback.
+ */
+function packDateTimeWithZoneOffset(value, packer, onError) {
+  const epochSecond = cypherLocalDateTimeToEpochSecond(value.localDateTime);
+  const nano = int(value.localDateTime.localTime.nanosecond);
+  const offsetSeconds = int(value.offsetSeconds);
+
+  const packableStructFields = [
+    packer.packable(epochSecond, onError),
+    packer.packable(nano, onError),
+    packer.packable(offsetSeconds, onError)
+  ];
+  packer.packStruct(DATE_TIME_WITH_ZONE_OFFSET, packableStructFields, onError);
+}
+
+/**
+ * Unpack cypher date time with zone offset value using the given unpacker.
+ * @param {Unpacker} unpacker the unpacker to use.
+ * @param {number} structSize the retrieved struct size.
+ * @param {BaseBuffer} buffer the buffer to unpack from.
+ * @return {CypherDateTimeWithZoneOffset} the unpacked cypher date time with zone offset value.
+ */
+function unpackDateTimeWithZoneOffset(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('DateTimeWithZoneOffset', DATE_TIME_WITH_ZONE_OFFSET_STRUCT_SIZE, structSize);
+
+  const epochSecond = unpacker.unpack(buffer);
+  const nano = unpacker.unpack(buffer);
+  const offsetSeconds = unpacker.unpack(buffer);
+
+  const localDateTime = epochSecondAndNanoToCypherLocalDateTime(epochSecond, nano);
+  return new CypherDateTimeWithZoneOffset(localDateTime, offsetSeconds);
+}
+
+/**
+ * Pack given cypher date time with zone id.
+ * @param {CypherDateTimeWithZoneId} value the date time value to pack.
+ * @param {Packer} packer the packer to use.
+ * @param {function} onError the error callback.
+ */
+function packDateTimeWithZoneId(value, packer, onError) {
+  const epochSecond = cypherLocalDateTimeToEpochSecond(value.localDateTime);
+  const nano = int(value.localDateTime.localTime.nanosecond);
+  const zoneId = value.zoneId;
+
+  const packableStructFields = [
+    packer.packable(epochSecond, onError),
+    packer.packable(nano, onError),
+    packer.packable(zoneId, onError)
+  ];
+  packer.packStruct(DATE_TIME_WITH_ZONE_ID, packableStructFields, onError);
+}
+
+/**
+ * Unpack cypher date time with zone id value using the given unpacker.
+ * @param {Unpacker} unpacker the unpacker to use.
+ * @param {number} structSize the retrieved struct size.
+ * @param {BaseBuffer} buffer the buffer to unpack from.
+ * @return {CypherDateTimeWithZoneId} the unpacked cypher date time with zone id value.
+ */
+function unpackDateTimeWithZoneId(unpacker, structSize, buffer) {
+  unpacker._verifyStructSize('DateTimeWithZoneId', DATE_TIME_WITH_ZONE_ID_STRUCT_SIZE, structSize);
+
+  const epochSecond = unpacker.unpack(buffer);
+  const nano = unpacker.unpack(buffer);
+  const zoneId = unpacker.unpack(buffer);
+
+  const localDateTime = epochSecondAndNanoToCypherLocalDateTime(epochSecond, nano);
+  return new CypherDateTimeWithZoneId(localDateTime, zoneId);
+}