Deprecate exposing Integer

It does not make sense to expose the `Integer` type to users. Users should
use a framework of their liking instead and we only expose `inSafeRange`, `toNumber` and
`toString` functions.

Author: pontusmelke

README.md

@@ -138,8 +138,8 @@ While there is no need to grab admin right if you are running tests against an e
 ## A note on numbers and the Integer type
 The Neo4j type system includes 64-bit integer values.
 However, Javascript can only safely represent integers between `-(2`<sup>`53`</sup>` - 1)` and `(2`<sup>`53`</sup>` - 1)`.
-In order to support the full Neo4j type system, the driver includes an explicit Integer types.
-Any time the driver recieves an Integer value from Neo4j, it will be represented with the Integer type by the driver.
+In order to support the full Neo4j type system, the driver will not automatically convert to javascript integers.
+Any time the driver receives an integer value from Neo4j, it will be represented with an internal integer type by the driver.
 
 ### Write integers
 Number written directly e.g. `session.run("CREATE (n:Node {age: {age}})", {age: 22})` will be of type `Float` in Neo4j.
@@ -158,19 +158,22 @@ session.run("CREATE (n {age: {myIntParam}})", {myIntParam: neo4j.int("9223372036
 ```
 
 ### Read integers
-Since Integers can be larger than can be represented as JavaScript numbers, it is only safe to convert Integer instances to JavaScript numbers if you know that they will not exceed `(2`<sup>`53`</sup>` - 1)` in size:
+Since Integers can be larger than can be represented as JavaScript numbers, it is only safe to convert to JavaScript numbers if you know that they will not exceed `(2`<sup>`53`</sup>` - 1)` in size.
+In order to facilitate working with integers the driver include `neo4j.isInt`, `neo4j.integer.inSafeRange`, `neo4j.integer.toNumber`, and `neo4j.integer.toString`.
 
 ```javascript
 var aSmallInteger = neo4j.int(123);
-var aNumber = aSmallInteger.toNumber();
+if (neo4j.integer.inSafeRange(aSmallInteger)) {
+    var aNumber = aSmallInteger.toNumber();
+}
 ```
 
-If you will be handling integers larger than that, you can use the Integer instances directly, or convert them to strings:
+If you will be handling integers larger than that, you can should convert them to strings:
 
 ```javascript
 var aLargerInteger = neo4j.int("9223372036854775807");
-var integerAsString = aLargerInteger.toString();
+if (!neo4j.integer.inSafeRange(aSmallInteger)) {
+    var integerAsString = aLargerInteger.toString();
+}
 ```
 
-To help you work with Integers, the Integer class exposes a large set of arithmetic methods.
-Refer to the [Integer API docs](http://neo4j.com/docs/api/javascript-driver/current/class/src/v1/integer.js~Integer.html) for details.

src/v1/integer.js

@@ -32,6 +32,8 @@ import {newError} from "./error";
  * @param {number} low The low (signed) 32 bits of the long
  * @param {number} high The high (signed) 32 bits of the long
  * @constructor
+ *
+ * @deprecated This class will be removed or made internal in a future version of the driver.
  */
 class Integer {
   constructor(low, high) {
@@ -841,16 +843,16 @@ Integer.MIN_VALUE = Integer.fromBits(0, 0x80000000|0, false);
 /**
  * Minimum safe value.
  * @type {!Integer}
- * @private
+ * @expose
  */
-Integer.MIN_SAFE_VALUE = Integer.fromNumber(Number.MIN_SAFE_INTEGER);
+Integer.MIN_SAFE_VALUE = Integer.fromBits(0x1|0, 0xFFFFFFFFFFE00000|0);
 
 /**
 * Maximum safe value.
 * @type {!Integer}
-* @private
+* @expose
 */
-Integer.MAX_SAFE_VALUE = Integer.fromNumber(Number.MAX_SAFE_INTEGER);
+Integer.MAX_SAFE_VALUE = Integer.fromBits(0xFFFFFFFF|0,0x1FFFFF|0);
 
 /**
  * Cast value to Integer type.

test/v1/integer.test.js

@@ -40,5 +40,4 @@ describe('Pool', function() {
     expect(integer.toString(int("-9007199254740991"))).toEqual("-9007199254740991");
     expect(integer.toString(int("-9007199254740992"))).toEqual("-9007199254740992");
   });
-
 });