Make driver package work with Webpack

Improved feature detection and tweaked package.json in order to make
Webpack not load NodeJS modules. Feature detection is also changed to
account for possibly empty Node modules, like net ot dns. Previous
packaging was the same for Node and browser and feature detection
happened at runtime. Webpack, however, tried to resolve modules at
compile time and failed. New "browser" entry in package.json tells
bundlers to return empty objects for Node modules.

Author: lutovich

package.json

@@ -21,6 +21,14 @@
     "browser": "gulp browser && gulp test-browser"
   },
   "main": "lib/index.js",
+  "browser": {
+    "dns": false,
+    "buffer": false,
+    "net": false,
+    "readline": false,
+    "crypto": false,
+    "tls": false
+  },
   "unpkg": "lib/browser/neo4j-web.js",
   "jsdelivr": "lib/browser/neo4j-web.js",
   "types": "types/index.d.ts",

src/v1/internal/buf.js

@@ -16,13 +16,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
- 
-/** This module defines a common API for dealing with binary data that
-  * works for both browsers (via ArrayBuffer/DataView) and for NodeJS
-  *(via Buffer API).
-  */
 
-let _node = require("buffer");
+import Platform from './platform';
+import node from 'buffer';
+
+/**
+ * This module defines a common API for dealing with binary data that
+ * works for both browsers (via ArrayBuffer/DataView) and for NodeJS
+ *(via Buffer API).
+ */
+
 /**
   * Common base with default implementation for most buffer methods.
   * Buffers are stateful - they track a current "position", this helps greatly
@@ -513,7 +516,7 @@ class CombinedBuffer extends BaseBuffer {
  */
 class NodeBuffer extends BaseBuffer {
   constructor(arg) {
-    const buffer = arg instanceof _node.Buffer ? arg : newNodeJSBuffer(arg);
+    const buffer = newNodeJSBuffer(arg);
     super(buffer.length);
     this._buffer = buffer;
   }
@@ -562,22 +565,18 @@ class NodeBuffer extends BaseBuffer {
 }
 
 function newNodeJSBuffer(arg) {
-  if (typeof arg === 'number' && typeof _node.Buffer.alloc === 'function') {
+  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);
+    return node.Buffer.alloc(arg);
   } else {
     // fallback to the old, potentially deprecated constructor
-    return new _node.Buffer(arg);
+    return new node.Buffer(arg);
   }
 }
 
-// Use HeapBuffer by default, unless Buffer API is available, see below
-let _DefaultBuffer = HeapBuffer;
-try {
-  // This will throw an exception if we're not running on NodeJS or equivalent
-  require.resolve("buffer");
-  _DefaultBuffer = NodeBuffer;
-} catch(e) {}
+const _DefaultBuffer = Platform.nodeBufferAvailable() ? NodeBuffer : HeapBuffer;
 
 /**
  * Allocate a new buffer using whatever mechanism is most sensible for the current platform.

src/v1/internal/ch-config.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 
-import hasFeature from './features';
+import Platform from './platform';
 import {SERVICE_UNAVAILABLE} from '../error';
 
 const DEFAULT_CONNECTION_TIMEOUT_MILLIS = 5000; // 5 seconds by default
@@ -45,7 +45,7 @@ function extractEncrypted(driverConfig) {
   // check if encryption was configured by the user, use explicit null check because we permit boolean value
   const encryptionNotConfigured = driverConfig.encrypted == null;
   // default to using encryption if trust-all-certificates is available
-  if (encryptionNotConfigured && hasFeature('trust_all_certificates')) {
+  if (encryptionNotConfigured && Platform.trustAllCertificatesAvailable()) {
     return true;
   }
   return driverConfig.encrypted;
@@ -56,7 +56,7 @@ function extractTrust(driverConfig) {
     return driverConfig.trust;
   }
   // default to using TRUST_ALL_CERTIFICATES if it is available
-  return hasFeature('trust_all_certificates') ? 'TRUST_ALL_CERTIFICATES' : 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES';
+  return Platform.trustAllCertificatesAvailable() ? 'TRUST_ALL_CERTIFICATES' : 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES';
 }
 
 function extractTrustedCertificates(driverConfig) {

src/v1/internal/ch-node.js

@@ -26,6 +26,7 @@ import {EOL} from 'os';
 import {NodeBuffer} from './buf';
 import {ENCRYPTION_OFF, isEmptyObjectOrNull} from './util';
 import {newError} from './../error';
+import Platform from './platform';
 
 let _CONNECTION_IDGEN = 0;
 
@@ -392,13 +393,9 @@ class NodeChannel {
     }
   }
 }
-let _nodeChannelModule = {channel: NodeChannel, available: true};
 
-try {
-  // Only define this module if 'net' is available
-  require.resolve("net");
-} catch(e) {
-  _nodeChannelModule = { available : false };
-}
+const _nodeChannelModule = Platform.nodeSocketAvailable()
+  ? {channel: NodeChannel, available: true}
+  : {available: false};
 
-export default _nodeChannelModule
+export default _nodeChannelModule;

src/v1/internal/connection-providers.js

@@ -22,8 +22,6 @@ import {READ, WRITE} from '../driver';
 import Session from '../session';
 import RoutingTable from './routing-table';
 import Rediscovery from './rediscovery';
-import hasFeature from './features';
-import {DnsHostNameResolver, DummyHostNameResolver} from './host-name-resolvers';
 import RoutingUtil from './routing-util';
 
 const UNAUTHORIZED_ERROR_CODE = 'Neo.ClientError.Security.Unauthorized';
@@ -261,13 +259,6 @@ export class LoadBalancer extends ConnectionProvider {
       routingTable.forgetRouter(address);
     }
   }
-
-  static _createHostNameResolver() {
-    if (hasFeature('dns_lookup')) {
-      return new DnsHostNameResolver();
-    }
-    return new DummyHostNameResolver();
-  }
 }
 
 export class SingleConnectionProvider extends ConnectionProvider {

src/v1/internal/features.js

@@ -18,6 +18,7 @@
  */
 
 import urlUtil from './url-util';
+import nodeDns from 'dns';
 
 class HostNameResolver {
 
@@ -54,16 +55,11 @@ export class ConfiguredHostNameResolver extends HostNameResolver {
 
 export class DnsHostNameResolver extends HostNameResolver {
 
-  constructor() {
-    super();
-    this._dns = require('dns');
-  }
-
   resolve(seedRouter) {
     const parsedAddress = urlUtil.parseDatabaseUrl(seedRouter);
 
     return new Promise((resolve) => {
-      this._dns.lookup(parsedAddress.host, {all: true}, (error, addresses) => {
+      nodeDns.lookup(parsedAddress.host, {all: true}, (error, addresses) => {
         if (error) {
           resolve(resolveToItself(seedRouter));
         } else {

src/v1/internal/host-name-resolvers.js

@@ -0,0 +1,98 @@
+/**
+ * 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 {isEmptyObjectOrNull} from './util';
+
+let _trustOnFirstUseAvailable = null;
+let _trustAllCertificatesAvailable = null;
+let _dnsLookupAvailable = null;
+let _nodeSocketAvailable = null;
+let _nodeBufferAvailable = null;
+
+export default class Platform {
+
+  static trustOnFirstUseAvailable() {
+    if (_trustOnFirstUseAvailable == null) {
+      try {
+        // We are verifying that we have a version of getPeerCertificate
+        // that supports reading the whole certificate, eg this commit:
+        // https://github.com/nodejs/node/commit/345c40b6
+        require.resolve('tls');
+        const getPeerCertificateFunction = require('tls').TLSSocket.prototype.getPeerCertificate;
+        const numberOfParameters = getPeerCertificateFunction.length;
+        _trustOnFirstUseAvailable = numberOfParameters >= 1;
+      } catch (e) {
+        _trustOnFirstUseAvailable = false;
+      }
+    }
+    return _trustOnFirstUseAvailable;
+  }
+
+  static trustAllCertificatesAvailable() {
+    if (_trustAllCertificatesAvailable == null) {
+      try {
+        require.resolve('tls');
+        const getPeerCertificateFunction = require('tls').TLSSocket.prototype.getPeerCertificate;
+        _trustAllCertificatesAvailable = getPeerCertificateFunction && typeof getPeerCertificateFunction === 'function';
+      } catch (e) {
+        _trustAllCertificatesAvailable = false;
+      }
+    }
+    return _trustAllCertificatesAvailable;
+  }
+
+  static dnsLookupAvailable() {
+    if (_dnsLookupAvailable == null) {
+      try {
+        require.resolve('dns');
+        const lookupFunction = require('dns').lookup;
+        _dnsLookupAvailable = lookupFunction && typeof lookupFunction === 'function';
+      } catch (e) {
+        _dnsLookupAvailable = false;
+      }
+    }
+    return _dnsLookupAvailable;
+  }
+
+  static nodeSocketAvailable() {
+    if (_nodeSocketAvailable == null) {
+      try {
+        require.resolve('net');
+        const netModule = require('net');
+        _nodeSocketAvailable = !isEmptyObjectOrNull(netModule);
+      } catch (e) {
+        _nodeSocketAvailable = false;
+      }
+    }
+    return _nodeSocketAvailable;
+  }
+
+  static nodeBufferAvailable() {
+    if (_nodeBufferAvailable == null) {
+      try {
+        require.resolve('buffer');
+        const bufferModule = require('buffer');
+        _nodeBufferAvailable = !isEmptyObjectOrNull(bufferModule);
+      } catch (e) {
+        _nodeBufferAvailable = false;
+      }
+    }
+    return _nodeBufferAvailable;
+  }
+}

src/v1/internal/platform.js

@@ -23,15 +23,15 @@
 import {alloc, CombinedBuffer, HeapBuffer, NodeBuffer} from './buf';
 import {StringDecoder} from 'string_decoder';
 import {newError} from './../error';
+import textEncoding from 'text-encoding';
+import Platform from './platform';
+import node from 'buffer';
 
 let platformObj = {};
 
+if (Platform.nodeBufferAvailable()) {
 
-try {
-  // This will throw an exception is 'buffer' is not available
-  require.resolve("buffer");
   const decoder = new StringDecoder('utf8');
-  const node = require('buffer');
 
   // use static factory function present in newer NodeJS versions to create a buffer containing the given string
   // or fallback to the old, potentially deprecated constructor
@@ -67,10 +67,8 @@ try {
     }
   }
 
-} catch (e) {
+} else {
 
-  // Not on NodeJS, add shim for WebAPI TextEncoder/TextDecoder
-  var textEncoding = require('text-encoding');
   let encoder = new textEncoding.TextEncoder("utf-8");
   let decoder = new textEncoding.TextDecoder("utf-8");
 
@@ -83,7 +81,7 @@ try {
         return decoder.decode(buffer.readView(Math.min(length, buffer.length - buffer.position)));
       }
       else {
-        // Decoding combined buffer is complicated. For simplicity, for now, 
+        // Decoding combined buffer is complicated. For simplicity, for now,
         // we simply copy the combined buffer into a regular buffer and decode that.
         var tmpBuf = alloc(length);
         for (var i = 0; i < length; i++) {
@@ -94,6 +92,7 @@ try {
       }
     }
   }
+
 }
 
 let streamDecodeCombinedBuffer = (combinedBuffers, length, decodeFn, endFn) => {