Renamed 'useNativeNumbers' to 'disableLosslessIntegers'

New name seems more descriptive and emphasizes that numbers returned
from driver with this setting set to `true` might result in loss
of precision.

Author: lutovich

src/v1/index.js

@@ -158,16 +158,17 @@ const USER_AGENT = "neo4j-javascript/" + VERSION;
  *       // on the operating system level. Default value is 5000, which is 5 seconds.
  *       connectionTimeout: 5000, // 5 seconds
  *
- *       // Make this driver always return and accept native JavaScript number for integer values, instead of the
+ *       // Make this driver always return native JavaScript numbers for integer values, instead of the
  *       // dedicated {@link Integer} class. Values that do not fit in native number bit range will be represented as
- *       // <code>Number.NEGATIVE_INFINITY</code> or <code>Number.POSITIVE_INFINITY</code>. Driver will fail to encode
- *       // {@link Integer} values passed as query parameters when this setting is set to <code>true</code>.
- *       // <b>Warning:</b> It is not safe to enable this setting when JavaScript applications are not the only ones
+ *       // <code>Number.NEGATIVE_INFINITY</code> or <code>Number.POSITIVE_INFINITY</code>.
+ *       // <b>Warning:</b> It is not always safe to enable this setting when JavaScript applications are not the only ones
  *       // interacting with the database. Stored numbers might in such case be not representable by native
- *       // {@link Number} type and thus driver will return lossy values. For example, this might happen when data was
+ *       // {@link Number} type and thus driver will return lossy values. This might also happen when data was
  *       // initially imported using neo4j import tool and contained numbers larger than
  *       // <code>Number.MAX_SAFE_INTEGER</code>. Driver will then return positive infinity, which is lossy.
- *       useNativeNumbers: false,
+ *       // Default value for this option is <code>false</code> because native JavaScript numbers might result
+ *       // in loss of precision in the general case.
+ *       disableLosslessIntegers: false,
  *     }
  *
  * @param {string} url The URL for the Neo4j database, for instance "bolt://localhost"

src/v1/internal/connector.js

@@ -164,10 +164,10 @@ class Connection {
    * @constructor
    * @param {NodeChannel|WebSocketChannel} channel - channel with a 'write' function and a 'onmessage' callback property.
    * @param {string} url - the hostname and port to connect to.
-   * @param {boolean} useNativeNumbers if this connection should treat/convert all received numbers
+   * @param {boolean} disableLosslessIntegers if this connection should convert all received integers to native JS numbers
    * (including native {@link Number} type or our own {@link Integer}) as native {@link Number}.
    */
-  constructor(channel, url, useNativeNumbers = false) {
+  constructor(channel, url, disableLosslessIntegers = false) {
     /**
      * An ordered queue of observers, each exchange response (zero or more
      * RECORD messages followed by a SUCCESS message) we recieve will be routed
@@ -181,8 +181,8 @@ class Connection {
     this._ch = channel;
     this._dechunker = new Dechunker();
     this._chunker = new Chunker( channel );
-    this._packer = new Packer(this._chunker, useNativeNumbers);
-    this._unpacker = new Unpacker(useNativeNumbers);
+    this._packer = new Packer(this._chunker, disableLosslessIntegers);
+    this._unpacker = new Unpacker(disableLosslessIntegers);
 
     this._isHandlingFailure = false;
     this._currentFailure = null;
@@ -589,7 +589,7 @@ function connect(url, config = {}, connectionErrorCode = null) {
   const Ch = config.channel || Channel;
   const parsedUrl = urlUtil.parseBoltUrl(url);
   const channelConfig = new ChannelConfig(parsedUrl, config, connectionErrorCode);
-  return new Connection(new Ch(channelConfig), parsedUrl.hostAndPort, config.useNativeNumbers);
+  return new Connection(new Ch(channelConfig), parsedUrl.hostAndPort, config.disableLosslessIntegers);
 }
 
 export {

src/v1/internal/packstream.js

@@ -80,13 +80,13 @@ class Packer {
   /**
    * @constructor
    * @param {Chunker} channel the chunker backed by a network channel.
-   * @param {boolean} useNativeNumbers if this packer should treat/convert all received numbers
+   * @param {boolean} disableLosslessIntegers if this packer should convert all received integers to native JS numbers
    * (including native {@link Number} type or our own {@link Integer}) as native {@link Number}.
    */
-  constructor(channel, useNativeNumbers = false) {
+  constructor(channel, disableLosslessIntegers = false) {
     this._ch = channel;
     this._byteArraysSupported = true;
-    this._useNativeNumbers = useNativeNumbers;
+    this._disableLosslessIntegers = disableLosslessIntegers;
   }
 
   /**
@@ -158,7 +158,7 @@ class Packer {
    * @private
    */
   _packableInteger(x, onError) {
-    if (this._useNativeNumbers) {
+    if (this._disableLosslessIntegers) {
       // pack Integer objects only when native numbers are not used, fail otherwise
       // Integer can't represent special values like Number.NEGATIVE_INFINITY
       // and should not be used at all when native numbers are enabled
@@ -343,15 +343,15 @@ class Unpacker {
 
   /**
    * @constructor
-   * @param {boolean} useNativeNumbers if this unpacker should treat/convert all received numbers
+   * @param {boolean} disableLosslessIntegers if this unpacker should convert all received integers to native JS numbers
    * (including native {@link Number} type or our own {@link Integer}) as native {@link Number}.
    */
-  constructor(useNativeNumbers = false) {
+  constructor(disableLosslessIntegers = false) {
     // Higher level layers can specify how to map structs to higher-level objects.
     // If we receive a struct that has a signature that does not have a mapper,
     // we simply return a Structure object.
     this.structMappers = {};
-    this._useNativeNumbers = useNativeNumbers;
+    this._disableLosslessIntegers = disableLosslessIntegers;
   }
 
   unpack(buffer) {
@@ -429,7 +429,7 @@ class Unpacker {
       const high = buffer.readInt32();
       const low = buffer.readInt32();
       const integer = new Integer(low, high);
-      return this._useNativeNumbers ? integer.toNumberOrInfinity() : integer;
+      return this._disableLosslessIntegers ? integer.toNumberOrInfinity() : integer;
     } else {
       return null;
     }

test/types/v1/driver.test.ts

@@ -17,16 +17,7 @@
  * limitations under the License.
  */
 
-import Driver, {
-  AuthToken,
-  Config,
-  EncryptionLevel,
-  LoadBalancingStrategy,
-  READ,
-  SessionMode,
-  TrustStrategy,
-  WRITE
-} from "../../../types/v1/driver";
+import Driver, {AuthToken, Config, EncryptionLevel, LoadBalancingStrategy, READ, SessionMode, TrustStrategy, WRITE} from "../../../types/v1/driver";
 import {Parameters} from "../../../types/v1/statement-runner";
 import Session from "../../../types/v1/session";
 import {Neo4jError} from "../../../types/v1/error";
@@ -61,7 +52,7 @@ const loadBalancingStrategy1: undefined | LoadBalancingStrategy = config.loadBal
 const loadBalancingStrategy2: undefined | string = config.loadBalancingStrategy;
 const maxConnectionLifetime: undefined | number = config.maxConnectionLifetime;
 const connectionTimeout: undefined | number = config.connectionTimeout;
-const useNativeNumbers: undefined | boolean = config.useNativeNumbers;
+const disableLosslessIntegers: undefined | boolean = config.disableLosslessIntegers;
 
 const sessionMode: SessionMode = dummy;
 const sessionModeStr: string = sessionMode;

test/v1/driver.test.js

@@ -338,14 +338,14 @@ describe('driver', () => {
 
   nativeNumbers.forEach(number => {
 
-    it(`should return native number ${number} when useNativeNumbers=true`, done => {
+    it(`should return native number ${number} when disableLosslessIntegers=true`, done => {
       testNativeNumberInReturnedRecord(number, done);
     });
 
   });
 
-  it('should fail to pack Integer when useNativeNumbers=true', done => {
-    driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken, {useNativeNumbers: true});
+  it('should fail to pack Integer when disableLosslessIntegers=true', done => {
+    driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken, {disableLosslessIntegers: true});
     const session = driver.session();
 
     session.run('RETURN $number', {number: neo4j.int(42)})
@@ -379,7 +379,7 @@ describe('driver', () => {
   }
 
   function testNativeNumberInReturnedRecord(number, done) {
-    driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken, {useNativeNumbers: true});
+    driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken, {disableLosslessIntegers: true});
 
     const session = driver.session();
     session.run('RETURN $number AS n0, $number AS n1', {number: number}).then(result => {

types/v1/driver.d.ts

@@ -54,7 +54,7 @@ declare interface Config {
   loadBalancingStrategy?: LoadBalancingStrategy;
   maxConnectionLifetime?: number;
   connectionTimeout?: number;
-  useNativeNumbers?: boolean;
+  disableLosslessIntegers?: boolean;
 }
 
 declare type SessionMode = "READ" | "WRITE";