Split Node and browser components into separate modules

This makes it easier to override Node modules in browser environment.

Author: lutovich

package.json

@@ -22,6 +22,7 @@
   },
   "main": "lib/index.js",
   "browser": {
+    "./lib/v1/internal/utf8.js": "./lib/v1/internal/browser/browser-utf8.js",
     "dns": false,
     "buffer": false,
     "net": false,

src/v1/internal/browser/browser-buf.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 {BaseBuffer} from '../buf';
+
+export default class HeapBuffer extends BaseBuffer {
+
+  constructor(arg) {
+    const buffer = arg instanceof ArrayBuffer ? arg : new ArrayBuffer(arg);
+    super(buffer.byteLength);
+    this._buffer = buffer;
+    this._view = new DataView(this._buffer);
+  }
+
+  putUInt8(position, val) {
+    this._view.setUint8(position, val);
+  }
+
+  getUInt8(position) {
+    return this._view.getUint8(position);
+  }
+
+  putInt8(position, val) {
+    this._view.setInt8(position, val);
+  }
+
+  getInt8(position) {
+    return this._view.getInt8(position);
+  }
+
+  getFloat64(position) {
+    return this._view.getFloat64(position);
+  }
+
+  putFloat64(position, val) {
+    this._view.setFloat64(position, val);
+  }
+
+  getSlice(start, length) {
+    if (this._buffer.slice) {
+      return new HeapBuffer(this._buffer.slice(start, start + length));
+    } else {
+      // Some platforms (eg. phantomjs) don't support slice, so fall back to a copy
+      // We do this rather than return a SliceBuffer, because sliceBuffer cannot
+      // be passed to native network write ops etc - we need ArrayBuffer for that
+      const copy = new HeapBuffer(length);
+      for (let i = 0; i < length; i++) {
+        copy.putUInt8(i, this.getUInt8(i + start));
+      }
+      return copy;
+    }
+  }
+
+  /**
+   * Specific to HeapBuffer, this gets a DataView from the
+   * current position and of the specified length.
+   */
+  readView(length) {
+    return new DataView(this._buffer, this._updatePos(length), length);
+  }
+}

src/v1/internal/ch-websocket.js renamed to src/v1/internal/browser/browser-channel.js

@@ -17,15 +17,15 @@
  * limitations under the License.
  */
 
-import {HeapBuffer} from './buf';
-import {newError} from './../error';
-import {ENCRYPTION_OFF, ENCRYPTION_ON} from './util';
+import HeapBuffer from './browser-buf';
+import {newError} from '../../error';
+import {ENCRYPTION_OFF, ENCRYPTION_ON} from '../util';
 
 /**
  * Create a new WebSocketChannel to be used in web browsers.
  * @access private
  */
-class WebSocketChannel {
+export default class WebSocketChannel {
 
   /**
    * Create new instance
@@ -169,9 +169,6 @@ class WebSocketChannel {
   }
 }
 
-let available = typeof WebSocket !== 'undefined';
-let _websocketChannelModule = {channel: WebSocketChannel, available: available};
-
 function createWebSocket(scheme, parsedUrl) {
   const url = scheme + '://' + parsedUrl.hostAndPort;
 
@@ -305,5 +302,3 @@ function verifyEncryptionSettings(encryptionOn, encryptionOff, secureProtocol) {
 function detectWebPageProtocol() {
   return window && window.location ? window.location.protocol : null;
 }
-
-export default _websocketChannelModule

src/v1/internal/browser/browser-host-name-resolver.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 {HostNameResolver} from '../host-name-resolver';
+
+export default class BrowserHostNameResolver extends HostNameResolver {
+
+  resolve(address) {
+    return this._resolveToItself(address);
+  }
+}

src/v1/internal/browser/browser-utf8.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2002-2018 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.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 HeapBuffer from '../browser/browser-buf';
+import textEncoding from 'text-encoding';
+
+const encoder = new textEncoding.TextEncoder('utf-8');
+const decoder = new textEncoding.TextDecoder('utf-8');
+
+function encode(str) {
+  return new HeapBuffer(encoder.encode(str).buffer);
+}
+
+function decode(buffer, length) {
+  if (buffer instanceof HeapBuffer) {
+    return decoder.decode(buffer.readView(Math.min(length, buffer.length - buffer.position)));
+  } else {
+    // Copy the given buffer into a regular buffer and decode that
+    const tmpBuf = new HeapBuffer(length);
+    for (let i = 0; i < length; i++) {
+      tmpBuf.writeUInt8(buffer.readUInt8());
+    }
+    tmpBuf.reset();
+    return decoder.decode(tmpBuf.readView(length));
+  }
+}
+
+export default {
+  encode,
+  decode
+};

src/v1/internal/buf.js

@@ -17,8 +17,9 @@
  * limitations under the License.
  */
 
-import Platform from './platform';
-import node from 'buffer';
+import Feature from './feature';
+import NodeBuffer from './node/node-buf';
+import HeapBuffer from './browser/browser-buf';
 
 /**
  * This module defines a common API for dealing with binary data that
@@ -365,66 +366,6 @@ class BaseBuffer
   }
 }
 
-/**
- * Basic buffer implementation that should work in most any modern JS env.
- * @access private
- */
-class HeapBuffer extends BaseBuffer {
-  constructor (arg) {
-    let buffer = arg instanceof ArrayBuffer ? arg : new ArrayBuffer(arg)
-    super(buffer.byteLength );
-    this._buffer = buffer;
-    this._view = new DataView( this._buffer );
-  }
-
-  putUInt8 ( position, val ) {
-    this._view.setUint8(position, val);
-  }
-
-  getUInt8 ( position ) {
-    return this._view.getUint8(position);
-  }
-
-  putInt8 ( position, val ) {
-    this._view.setInt8(position, val);
-  }
-
-  getInt8 ( position ) {
-    return this._view.getInt8(position);
-  }
-
-  getFloat64 ( position ) {
-    return this._view.getFloat64(position);
-  }
-
-  putFloat64 ( position, val ) {
-    this._view.setFloat64( position, val );
-  }
-
-  getSlice ( start, length ) {
-    if( this._buffer.slice ) {
-      return new HeapBuffer( this._buffer.slice( start, start + length ) );
-    } else {
-      // Some platforms (eg. phantomjs) don't support slice, so fall back to a copy
-      // We do this rather than return a SliceBuffer, because sliceBuffer cannot
-      // be passed to native network write ops etc - we need ArrayBuffer for that
-      let copy = new HeapBuffer(length);
-      for (var i = 0; i < length; i++) {
-        copy.putUInt8( i, this.getUInt8( i + start ) );
-      }
-      return copy;
-    }
-  }
-
-  /** 
-   * Specific to HeapBuffer, this gets a DataView from the
-   * current position and of the specified length. 
-   */
-  readView ( length ) {
-    return new DataView( this._buffer, this._updatePos(length), length );
-  }
-}
-
 /**
  * Represents a view as slice of another buffer.
  * @access private
@@ -510,73 +451,7 @@ class CombinedBuffer extends BaseBuffer {
   }
 }
 
-/**
- * Buffer used in a Node.js environment
- * @access private
- */
-class NodeBuffer extends BaseBuffer {
-  constructor(arg) {
-    const buffer = newNodeJSBuffer(arg);
-    super(buffer.length);
-    this._buffer = buffer;
-  }
-
-  getUInt8 (position) {
-    return this._buffer.readUInt8( position );
-  }
-
-  getInt8 (position) {
-    return this._buffer.readInt8( position );
-  }
-
-  getFloat64 (position) {
-    return this._buffer.readDoubleBE(position);
-  }
-
-  putUInt8 (position, val) {
-    this._buffer.writeUInt8( val, position );
-  }
-
-  putInt8 (position, val) {
-    this._buffer.writeInt8( val, position );
-  }
-
-  putFloat64 ( position, val ) {
-    this._buffer.writeDoubleBE( val, position );
-  }
-
-  putBytes ( position, val ) {
-    if( val instanceof NodeBuffer ) {
-      let bytesToCopy = Math.min( val.length - val.position, this.length - position );
-      val._buffer.copy(
-        this._buffer,
-        position,
-        val.position,
-        val.position + bytesToCopy );
-      val.position += bytesToCopy;
-    } else {
-      super.putBytes(position, val);
-    }
-  };
-
-  getSlice ( start, length ) {
-    return new NodeBuffer( this._buffer.slice( start, start + length ) );
-  }
-}
-
-function newNodeJSBuffer(arg) {
-  if (arg instanceof node.Buffer) {
-    return arg;
-  } else if (typeof arg === 'number' && typeof node.Buffer.alloc === 'function') {
-    // use static factory function present in newer NodeJS versions to allocate new buffer with specified size
-    return node.Buffer.alloc(arg);
-  } else {
-    // fallback to the old, potentially deprecated constructor
-    return new node.Buffer(arg);
-  }
-}
-
-const _DefaultBuffer = Platform.nodeBufferAvailable() ? NodeBuffer : HeapBuffer;
+const DefaultBuffer = Feature.nodeBufferAvailable() ? NodeBuffer : HeapBuffer;
 
 /**
  * Allocate a new buffer using whatever mechanism is most sensible for the current platform.
@@ -585,14 +460,12 @@ const _DefaultBuffer = Platform.nodeBufferAvailable() ? NodeBuffer : HeapBuffer;
  * @return {BaseBuffer} new buffer
  */
 function alloc (size) {
-  return new _DefaultBuffer(size);
+  return new DefaultBuffer(size);
 }
 
 export {
   BaseBuffer,
-  HeapBuffer,
   SliceBuffer,
   CombinedBuffer,
-  NodeBuffer,
   alloc
 }