Initial commit

node_modules/neo4j-driver/lib/v1/internal/http/http-driver.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _driver = require('../../driver');
+
+var _driver2 = _interopRequireDefault(_driver);
+
+var _httpSession = require('./http-session');
+
+var _httpSession2 = _interopRequireDefault(_httpSession);
+
+var _httpSessionTracker = require('./http-session-tracker');
+
+var _httpSessionTracker2 = _interopRequireDefault(_httpSessionTracker);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var HttpDriver = function (_Driver) {
+  (0, _inherits3.default)(HttpDriver, _Driver);
+
+  function HttpDriver(hostPort, userAgent, token, config) {
+    (0, _classCallCheck3.default)(this, HttpDriver);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (HttpDriver.__proto__ || (0, _getPrototypeOf2.default)(HttpDriver)).call(this, hostPort, userAgent, token, config));
+
+    _this._sessionTracker = new _httpSessionTracker2.default();
+    return _this;
+  }
+
+  (0, _createClass3.default)(HttpDriver, [{
+    key: 'session',
+    value: function session() {
+      return new _httpSession2.default(this._hostPort, this._token, this._config, this._sessionTracker);
+    }
+  }, {
+    key: 'close',
+    value: function close() {
+      return this._sessionTracker.close();
+    }
+  }]);
+  return HttpDriver;
+}(_driver2.default); /**
+                      * 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.
+                      */
+
+exports.default = HttpDriver;

node_modules/neo4j-driver/lib/v1/internal/http/http-request-runner.js

@@ -0,0 +1,254 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _streamObserver = require('../stream-observer');
+
+var _streamObserver2 = _interopRequireDefault(_streamObserver);
+
+var _httpResponseConverter = require('./http-response-converter');
+
+var _httpResponseConverter2 = _interopRequireDefault(_httpResponseConverter);
+
+var _error = require('../../error');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var HttpRequestRunner = function () {
+  function HttpRequestRunner(url, authToken) {
+    (0, _classCallCheck3.default)(this, HttpRequestRunner);
+
+    this._url = url;
+    this._authToken = authToken;
+    this._converter = new _httpResponseConverter2.default();
+  }
+
+  /**
+   * Send a HTTP request to begin a transaction.
+   * @return {Promise<number>} promise resolved with the transaction id or rejected with an error.
+   */
+
+
+  (0, _createClass3.default)(HttpRequestRunner, [{
+    key: 'beginTransaction',
+    value: function beginTransaction() {
+      var _this = this;
+
+      var url = beginTransactionUrl(this._url);
+      return sendRequest('POST', url, null, this._authToken).then(function (responseJson) {
+        var neo4jError = _this._converter.extractError(responseJson);
+        if (neo4jError) {
+          throw neo4jError;
+        }
+        return _this._converter.extractTransactionId(responseJson);
+      });
+    }
+
+    /**
+     * Send a HTTP request to commit a transaction.
+     * @param {number} transactionId id of the transaction to commit.
+     * @return {Promise<void>} promise resolved if transaction got committed or rejected when commit failed.
+     */
+
+  }, {
+    key: 'commitTransaction',
+    value: function commitTransaction(transactionId) {
+      var _this2 = this;
+
+      var url = commitTransactionUrl(this._url, transactionId);
+      return sendRequest('POST', url, null, this._authToken).then(function (responseJson) {
+        var neo4jError = _this2._converter.extractError(responseJson);
+        if (neo4jError) {
+          throw neo4jError;
+        }
+      });
+    }
+
+    /**
+     * Send a HTTP request to rollback a transaction.
+     * @param {number} transactionId id of the transaction to rollback.
+     * @return {Promise<void>} promise resolved if transaction got rolled back or rejected when rollback failed.
+     */
+
+  }, {
+    key: 'rollbackTransaction',
+    value: function rollbackTransaction(transactionId) {
+      var _this3 = this;
+
+      var url = transactionUrl(this._url, transactionId);
+      return sendRequest('DELETE', url, null, this._authToken).then(function (responseJson) {
+        var neo4jError = _this3._converter.extractError(responseJson);
+        if (neo4jError) {
+          throw neo4jError;
+        }
+      });
+    }
+
+    /**
+     * Send a HTTP request to execute a query in a transaction with the given id.
+     * @param {number} transactionId the transaction id.
+     * @param {string} statement the cypher query.
+     * @param {object} parameters the cypher query parameters.
+     * @return {Promise<StreamObserver>} a promise resolved with {@link StreamObserver} containing either records or error.
+     */
+
+  }, {
+    key: 'runQuery',
+    value: function runQuery(transactionId, statement, parameters) {
+      var _this4 = this;
+
+      var streamObserver = new _streamObserver2.default();
+      var url = transactionUrl(this._url, transactionId);
+      var body = createStatementJson(statement, parameters, this._converter, streamObserver);
+      if (!body) {
+        // unable to encode given statement and parameters, return a failed stream observer
+        return _promise2.default.resolve(streamObserver);
+      }
+
+      return sendRequest('POST', url, body, this._authToken).then(function (responseJson) {
+        processResponseJson(responseJson, _this4._converter, streamObserver);
+      }).catch(function (error) {
+        streamObserver.onError(error);
+      }).then(function () {
+        return streamObserver;
+      });
+    }
+  }]);
+  return HttpRequestRunner;
+}(); /**
+      * 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.
+      */
+
+exports.default = HttpRequestRunner;
+
+
+function sendRequest(method, url, bodyString, authToken) {
+  try {
+    var options = {
+      method: method,
+      headers: createHttpHeaders(authToken),
+      body: bodyString
+    };
+
+    return new _promise2.default(function (resolve, reject) {
+      fetch(url, options).then(function (response) {
+        return response.json();
+      }).then(function (responseJson) {
+        return resolve(responseJson);
+      }).catch(function (error) {
+        return reject(new _error.Neo4jError(error.message, _error.SERVICE_UNAVAILABLE));
+      });
+    });
+  } catch (e) {
+    return _promise2.default.reject(e);
+  }
+}
+
+function createHttpHeaders(authToken) {
+  var headers = new Headers();
+  headers.append('Accept', 'application/json; charset=UTF-8');
+  headers.append('Content-Type', 'application/json');
+  headers.append('Authorization', 'Basic ' + btoa(authToken.principal + ':' + authToken.credentials));
+  return headers;
+}
+
+function createStatementJson(statement, parameters, converter, streamObserver) {
+  try {
+    return createStatementJsonOrThrow(statement, parameters, converter);
+  } catch (e) {
+    streamObserver.onError(e);
+    return null;
+  }
+}
+
+function createStatementJsonOrThrow(statement, parameters, converter) {
+  var encodedParameters = converter.encodeStatementParameters(parameters);
+  return (0, _stringify2.default)({
+    statements: [{
+      statement: statement,
+      parameters: encodedParameters,
+      resultDataContents: ['row', 'graph'],
+      includeStats: true
+    }]
+  });
+}
+
+function processResponseJson(responseJson, converter, streamObserver) {
+  if (!responseJson) {
+    // request failed and there is no response
+    return;
+  }
+
+  try {
+    processResponseJsonOrThrow(responseJson, converter, streamObserver);
+  } catch (e) {
+    streamObserver.onError(e);
+  }
+}
+
+function processResponseJsonOrThrow(responseJson, converter, streamObserver) {
+  var neo4jError = converter.extractError(responseJson);
+  if (neo4jError) {
+    streamObserver.onError(neo4jError);
+  } else {
+    var recordMetadata = converter.extractRecordMetadata(responseJson);
+    streamObserver.onCompleted(recordMetadata);
+
+    var rawRecords = converter.extractRawRecords(responseJson);
+    rawRecords.forEach(function (rawRecord) {
+      return streamObserver.onNext(rawRecord);
+    });
+
+    var statementMetadata = converter.extractStatementMetadata(responseJson);
+    streamObserver.onCompleted(statementMetadata);
+  }
+}
+
+function beginTransactionUrl(baseUrl) {
+  return createUrl(baseUrl, '/db/data/transaction');
+}
+
+function commitTransactionUrl(baseUrl, transactionId) {
+  return transactionUrl(baseUrl, transactionId) + '/commit';
+}
+
+function transactionUrl(baseUrl, transactionId) {
+  return beginTransactionUrl(baseUrl) + '/' + transactionId;
+}
+
+function createUrl(baseUrl, path) {
+  return baseUrl.scheme + '://' + baseUrl.host + ':' + baseUrl.port + path;
+}

node_modules/neo4j-driver/lib/v1/internal/http/http-response-converter.js

@@ -0,0 +1,461 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _integer = require('../../integer');
+
+var _graphTypes = require('../../graph-types');
+
+var _error = require('../../error');
+
+var _spatialTypes = require('../../spatial-types');
+
+var _temporalTypes = require('../../temporal-types');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var CREDENTIALS_EXPIRED_CODE = 'Neo.ClientError.Security.CredentialsExpired'; /**
+                                                                               * 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.
+                                                                               */
+
+var HttpResponseConverter = function () {
+  function HttpResponseConverter() {
+    (0, _classCallCheck3.default)(this, HttpResponseConverter);
+  }
+
+  (0, _createClass3.default)(HttpResponseConverter, [{
+    key: 'encodeStatementParameters',
+    value: function encodeStatementParameters(parameters) {
+      return encodeQueryParameters(parameters);
+    }
+
+    /**
+     * Attempts to extract error from transactional cypher endpoint response and convert it to {@link Neo4jError}.
+     * @param {object} response the response.
+     * @return {Neo4jError|null} new driver friendly error, if exists.
+     */
+
+  }, {
+    key: 'extractError',
+    value: function extractError(response) {
+      var errors = response.errors;
+      if (errors) {
+        var error = errors[0];
+        if (error) {
+          // endpoint returns 'Neo.ClientError.Security.Forbidden' code and 'password_change' that points to another endpoint
+          // this is different from code returned via Bolt and less descriptive
+          // make code same as in Bolt, if password change is required
+          var code = response.password_change ? CREDENTIALS_EXPIRED_CODE : error.code;
+          var message = error.message;
+          return new _error.Neo4jError(message, code);
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Extracts transaction id from the db/data/transaction endpoint response.
+     * @param {object} response the response.
+     * @return {number} the transaction id.
+     */
+
+  }, {
+    key: 'extractTransactionId',
+    value: function extractTransactionId(response) {
+      var commitUrl = response.commit;
+      if (commitUrl) {
+        // extract id 42 from commit url like 'http://localhost:7474/db/data/transaction/42/commit'
+        var url = commitUrl.replace('/commit', '');
+        var transactionIdString = url.substring(url.lastIndexOf('/') + 1);
+        var transactionId = parseInt(transactionIdString, 10);
+        if (transactionId || transactionId === 0) {
+          return transactionId;
+        }
+      }
+      throw new _error.Neo4jError('Unable to extract transaction id from the response JSON: ' + (0, _stringify2.default)(response));
+    }
+
+    /**
+     * Extracts record metadata (array of column names) from transactional cypher endpoint response.
+     * @param {object} response the response.
+     * @return {object} new metadata object.
+     */
+
+  }, {
+    key: 'extractRecordMetadata',
+    value: function extractRecordMetadata(response) {
+      var result = extractResult(response);
+      var fields = result ? result.columns : [];
+      return { fields: fields };
+    }
+
+    /**
+     * Extracts raw records (each raw record is just an array of value) from transactional cypher endpoint response.
+     * @param {object} response the response.
+     * @return {object[][]} raw records from the response.
+     */
+
+  }, {
+    key: 'extractRawRecords',
+    value: function extractRawRecords(response) {
+      var result = extractResult(response);
+      if (result) {
+        var data = result.data;
+        if (data) {
+          return data.map(function (element) {
+            return extractRawRecord(element);
+          });
+        }
+      }
+      return [];
+    }
+
+    /**
+     * Extracts metadata for a completed statement.
+     * @param {object} response the response.
+     * @return {object} metadata as object.
+     */
+
+  }, {
+    key: 'extractStatementMetadata',
+    value: function extractStatementMetadata(response) {
+      var result = extractResult(response);
+      if (result) {
+        var stats = result.stats;
+        if (stats) {
+          var convertedStats = (0, _keys2.default)(stats).reduce(function (newStats, key) {
+            if (key === 'contains_updates') {
+              // skip because such key does not exist in bolt
+              return newStats;
+            }
+
+            // fix key name for future parsing by StatementStatistics class
+            var newKey = (key === 'relationship_deleted' ? 'relationships_deleted' : key).replace('_', '-');
+            newStats[newKey] = stats[key];
+            return newStats;
+          }, {});
+
+          return { stats: convertedStats };
+        }
+      }
+      return {};
+    }
+  }]);
+  return HttpResponseConverter;
+}();
+
+exports.default = HttpResponseConverter;
+
+
+function encodeQueryParameters(parameters) {
+  if (parameters && (typeof parameters === 'undefined' ? 'undefined' : (0, _typeof3.default)(parameters)) === 'object') {
+    return (0, _keys2.default)(parameters).reduce(function (result, key) {
+      result[key] = encodeQueryParameter(parameters[key]);
+      return result;
+    }, {});
+  }
+  return parameters;
+}
+
+function encodeQueryParameter(value) {
+  if (value instanceof _graphTypes.Node) {
+    throw new _error.Neo4jError('It is not allowed to pass nodes in query parameters', _error.PROTOCOL_ERROR);
+  } else if (value instanceof _graphTypes.Relationship) {
+    throw new _error.Neo4jError('It is not allowed to pass relationships in query parameters', _error.PROTOCOL_ERROR);
+  } else if (value instanceof _graphTypes.Path) {
+    throw new _error.Neo4jError('It is not allowed to pass paths in query parameters', _error.PROTOCOL_ERROR);
+  } else if ((0, _spatialTypes.isPoint)(value)) {
+    throw newUnsupportedParameterError('points');
+  } else if ((0, _temporalTypes.isDate)(value)) {
+    throw newUnsupportedParameterError('dates');
+  } else if ((0, _temporalTypes.isDateTime)(value)) {
+    throw newUnsupportedParameterError('date-time');
+  } else if ((0, _temporalTypes.isDuration)(value)) {
+    throw newUnsupportedParameterError('durations');
+  } else if ((0, _temporalTypes.isLocalDateTime)(value)) {
+    throw newUnsupportedParameterError('local date-time');
+  } else if ((0, _temporalTypes.isLocalTime)(value)) {
+    throw newUnsupportedParameterError('local time');
+  } else if ((0, _temporalTypes.isTime)(value)) {
+    throw newUnsupportedParameterError('time');
+  } else if ((0, _integer.isInt)(value)) {
+    return value.toNumber();
+  } else if (Array.isArray(value)) {
+    return value.map(function (element) {
+      return encodeQueryParameter(element);
+    });
+  } else if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object') {
+    return encodeQueryParameters(value);
+  } else {
+    return value;
+  }
+}
+
+function newUnsupportedParameterError(name) {
+  return new _error.Neo4jError('It is not allowed to pass ' + name + ' in query parameters when using HTTP endpoint. ' + ('Please consider using Cypher functions to create ' + name + ' so that query parameters are plain objects.'), _error.PROTOCOL_ERROR);
+}
+
+function extractResult(response) {
+  var results = response.results;
+  if (results) {
+    var result = results[0];
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
+
+function extractRawRecord(data) {
+  var row = data.row;
+
+  var nodesById = indexNodesById(data);
+  var relationshipsById = indexRelationshipsById(data);
+
+  if (row) {
+    return row.map(function (ignore, index) {
+      return extractRawRecordElement(index, data, nodesById, relationshipsById);
+    });
+  }
+  return [];
+}
+
+function indexNodesById(data) {
+  var graph = data.graph;
+  if (graph) {
+    var nodes = graph.nodes;
+    if (nodes) {
+      return nodes.reduce(function (result, node) {
+
+        var identity = convertNumber(node.id);
+        var labels = node.labels;
+        var properties = convertPrimitiveValue(node.properties);
+        result[node.id] = new _graphTypes.Node(identity, labels, properties);
+
+        return result;
+      }, {});
+    }
+  }
+  return {};
+}
+
+function indexRelationshipsById(data) {
+  var graph = data.graph;
+  if (graph) {
+    var relationships = graph.relationships;
+    if (relationships) {
+      return relationships.reduce(function (result, relationship) {
+
+        var identity = convertNumber(relationship.id);
+        var startNode = convertNumber(relationship.startNode);
+        var endNode = convertNumber(relationship.endNode);
+        var type = relationship.type;
+        var properties = convertPrimitiveValue(relationship.properties);
+        result[relationship.id] = new _graphTypes.Relationship(identity, startNode, endNode, type, properties);
+
+        return result;
+      }, {});
+    }
+  }
+  return {};
+}
+
+function extractRawRecordElement(index, data, nodesById, relationshipsById) {
+  var element = data.row ? data.row[index] : null;
+  var elementMetadata = data.meta ? data.meta[index] : null;
+
+  if (elementMetadata) {
+    // element is either a graph, spatial or temporal type
+    return convertComplexValue(element, elementMetadata, nodesById, relationshipsById);
+  } else {
+    // element is a primitive, like number, string, array or object
+    return convertPrimitiveValue(element);
+  }
+}
+
+function convertComplexValue(element, elementMetadata, nodesById, relationshipsById) {
+  if (isNodeMetadata(elementMetadata)) {
+    return nodesById[elementMetadata.id];
+  } else if (isRelationshipMetadata(elementMetadata)) {
+    return relationshipsById[elementMetadata.id];
+  } else if (isPathMetadata(elementMetadata)) {
+    return convertPath(elementMetadata, nodesById, relationshipsById);
+  } else if (isPointMetadata(elementMetadata)) {
+    return convertPoint(element);
+  } else {
+    return element;
+  }
+}
+
+function convertPath(metadata, nodesById, relationshipsById) {
+  var startNode = null;
+  var relationship = null;
+  var pathSegments = [];
+
+  for (var i = 0; i < metadata.length; i++) {
+    var element = metadata[i];
+    var elementId = element.id;
+    var elementType = element.type;
+
+    var nodeExpected = startNode === null && relationship === null || startNode !== null && relationship !== null;
+    if (nodeExpected && elementType !== 'node') {
+      throw new _error.Neo4jError('Unable to parse path, node expected but got: ' + (0, _stringify2.default)(element) + ' in ' + (0, _stringify2.default)(metadata));
+    }
+    if (!nodeExpected && elementType === 'node') {
+      throw new _error.Neo4jError('Unable to parse path, relationship expected but got: ' + (0, _stringify2.default)(element) + ' in ' + (0, _stringify2.default)(metadata));
+    }
+
+    if (nodeExpected) {
+      var node = nodesById[elementId];
+      if (startNode === null) {
+        startNode = node;
+      } else if (startNode !== null && relationship !== null) {
+        var pathSegment = new _graphTypes.PathSegment(startNode, relationship, node);
+        pathSegments.push(pathSegment);
+        startNode = node;
+        relationship = null;
+      } else {
+        throw new _error.Neo4jError('Unable to parse path, illegal node configuration: ' + (0, _stringify2.default)(metadata));
+      }
+    } else {
+      if (relationship === null) {
+        relationship = relationshipsById[elementId];
+      } else {
+        throw new _error.Neo4jError('Unable to parse path, illegal relationship configuration: ' + (0, _stringify2.default)(metadata));
+      }
+    }
+  }
+
+  var lastPathSegment = pathSegments[pathSegments.length - 1];
+  if (lastPathSegment && lastPathSegment.end !== startNode || relationship !== null) {
+    throw new _error.Neo4jError('Unable to parse path: ' + (0, _stringify2.default)(metadata));
+  }
+
+  return createPath(pathSegments);
+}
+
+function createPath(pathSegments) {
+  var pathStartNode = pathSegments[0].start;
+  var pathEndNode = pathSegments[pathSegments.length - 1].end;
+  return new _graphTypes.Path(pathStartNode, pathEndNode, pathSegments);
+}
+
+function convertPoint(element) {
+  var type = element.type;
+  if (type !== 'Point') {
+    throw new _error.Neo4jError('Unexpected Point type received: ' + (0, _stringify2.default)(element));
+  }
+
+  var coordinates = element.coordinates;
+  if (!Array.isArray(coordinates) && (coordinates.length !== 2 || coordinates.length !== 3)) {
+    throw new _error.Neo4jError('Unexpected Point coordinates received: ' + (0, _stringify2.default)(element));
+  }
+
+  var srid = convertCrsToId(element);
+
+  return new (Function.prototype.bind.apply(_spatialTypes.Point, [null].concat([srid], (0, _toConsumableArray3.default)(coordinates))))();
+}
+
+function convertCrsToId(element) {
+  var crs = element.crs;
+  if (!crs || !crs.name) {
+    throw new _error.Neo4jError('Unexpected Point crs received: ' + (0, _stringify2.default)(element));
+  }
+  var name = crs.name.toLowerCase();
+
+  if (name === 'wgs-84') {
+    return 4326;
+  } else if (name === 'wgs-84-3d') {
+    return 4979;
+  } else if (name === 'cartesian') {
+    return 7203;
+  } else if (name === 'cartesian-3d') {
+    return 9157;
+  } else {
+    throw new _error.Neo4jError('Unexpected Point crs received: ' + (0, _stringify2.default)(element));
+  }
+}
+
+function convertPrimitiveValue(element) {
+  if (element == null || element === undefined) {
+    return null;
+  } else if (typeof element === 'number') {
+    return convertNumber(element);
+  } else if (Array.isArray(element)) {
+    return element.map(function (element) {
+      return convertPrimitiveValue(element);
+    });
+  } else if ((typeof element === 'undefined' ? 'undefined' : (0, _typeof3.default)(element)) === 'object') {
+    return (0, _keys2.default)(element).reduce(function (result, key) {
+      result[key] = convertPrimitiveValue(element[key]);
+      return result;
+    }, {});
+  } else {
+    return element;
+  }
+}
+
+function convertNumber(value) {
+  return typeof value === 'number' ? value : Number(value);
+}
+
+function isNodeMetadata(metadata) {
+  return isMetadataForType('node', metadata);
+}
+
+function isRelationshipMetadata(metadata) {
+  return isMetadataForType('relationship', metadata);
+}
+
+function isPointMetadata(metadata) {
+  return isMetadataForType('point', metadata);
+}
+
+function isMetadataForType(name, metadata) {
+  return !Array.isArray(metadata) && (typeof metadata === 'undefined' ? 'undefined' : (0, _typeof3.default)(metadata)) === 'object' && metadata.type === name;
+}
+
+function isPathMetadata(metadata) {
+  return Array.isArray(metadata);
+}

node_modules/neo4j-driver/lib/v1/internal/http/http-session-tracker.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _promise = require("babel-runtime/core-js/promise");
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _from = require("babel-runtime/core-js/array/from");
+
+var _from2 = _interopRequireDefault(_from);
+
+var _set = require("babel-runtime/core-js/set");
+
+var _set2 = _interopRequireDefault(_set);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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.
+ */
+
+var HttpSessionTracker = function () {
+  function HttpSessionTracker() {
+    (0, _classCallCheck3.default)(this, HttpSessionTracker);
+
+    this._openSessions = new _set2.default();
+  }
+
+  /**
+   * Record given session as open.
+   * @param {HttpSession} session the newly open session.
+   */
+
+
+  (0, _createClass3.default)(HttpSessionTracker, [{
+    key: "sessionOpened",
+    value: function sessionOpened(session) {
+      this._openSessions.add(session);
+    }
+
+    /**
+     * Record given session as close.
+     * @param {HttpSession} session the just closed session.
+     */
+
+  }, {
+    key: "sessionClosed",
+    value: function sessionClosed(session) {
+      this._openSessions.delete(session);
+    }
+
+    /**
+     * Close this tracker and all open sessions.
+     */
+
+  }, {
+    key: "close",
+    value: function close() {
+      var sessions = (0, _from2.default)(this._openSessions);
+      this._openSessions.clear();
+      return _promise2.default.all(sessions.map(function (session) {
+        return closeSession(session);
+      }));
+    }
+  }]);
+  return HttpSessionTracker;
+}();
+
+/**
+ * Close given session and get a promise back.
+ * @param {HttpSession} session the session to close.
+ * @return {Promise<void>} promise resolved when session is closed.
+ */
+
+
+exports.default = HttpSessionTracker;
+function closeSession(session) {
+  return new _promise2.default(function (resolve) {
+    session.close(function () {
+      resolve();
+    });
+  });
+}

node_modules/neo4j-driver/lib/v1/internal/http/http-session.js

@@ -0,0 +1,188 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _driver = require('../../driver');
+
+var _session = require('../../session');
+
+var _session2 = _interopRequireDefault(_session);
+
+var _util = require('../util');
+
+var _error = require('../../error');
+
+var _httpRequestRunner = require('./http-request-runner');
+
+var _httpRequestRunner2 = _interopRequireDefault(_httpRequestRunner);
+
+var _connectionHolder = require('../connection-holder');
+
+var _result = require('../../result');
+
+var _result2 = _interopRequireDefault(_result);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var HttpSession = function (_Session) {
+  (0, _inherits3.default)(HttpSession, _Session);
+
+  function HttpSession(url, authToken, config, sessionTracker) {
+    (0, _classCallCheck3.default)(this, HttpSession);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (HttpSession.__proto__ || (0, _getPrototypeOf2.default)(HttpSession)).call(this, _driver.WRITE, null, null, config));
+
+    _this._ongoingTransactionIds = [];
+    _this._serverInfoSupplier = createServerInfoSupplier(url);
+    _this._requestRunner = new _httpRequestRunner2.default(url, authToken);
+    _this._sessionTracker = sessionTracker;
+    _this._sessionTracker.sessionOpened(_this);
+    return _this;
+  }
+
+  (0, _createClass3.default)(HttpSession, [{
+    key: 'run',
+    value: function run(statement) {
+      var _this2 = this;
+
+      var parameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      var _validateStatementAnd = (0, _util.validateStatementAndParameters)(statement, parameters),
+          query = _validateStatementAnd.query,
+          params = _validateStatementAnd.params;
+
+      return this._requestRunner.beginTransaction().then(function (transactionId) {
+        _this2._ongoingTransactionIds.push(transactionId);
+        var queryPromise = _this2._requestRunner.runQuery(transactionId, query, params);
+
+        return queryPromise.then(function (streamObserver) {
+          if (streamObserver.hasFailed()) {
+            return rollbackTransactionAfterQueryFailure(transactionId, streamObserver, _this2._requestRunner);
+          } else {
+            return commitTransactionAfterQuerySuccess(transactionId, streamObserver, _this2._requestRunner);
+          }
+        }).then(function (streamObserver) {
+          _this2._ongoingTransactionIds = _this2._ongoingTransactionIds.filter(function (id) {
+            return id !== transactionId;
+          });
+          return new _result2.default(streamObserver, query, params, _this2._serverInfoSupplier, _connectionHolder.EMPTY_CONNECTION_HOLDER);
+        });
+      });
+    }
+  }, {
+    key: 'beginTransaction',
+    value: function beginTransaction() {
+      throwTransactionsNotSupported();
+    }
+  }, {
+    key: 'readTransaction',
+    value: function readTransaction() {
+      throwTransactionsNotSupported();
+    }
+  }, {
+    key: 'writeTransaction',
+    value: function writeTransaction() {
+      throwTransactionsNotSupported();
+    }
+  }, {
+    key: 'lastBookmark',
+    value: function lastBookmark() {
+      throw new _error.Neo4jError('Experimental HTTP driver does not support bookmarks and routing');
+    }
+  }, {
+    key: 'close',
+    value: function close() {
+      var _this3 = this;
+
+      var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {
+        return null;
+      };
+
+      var rollbackAllOngoingTransactions = this._ongoingTransactionIds.map(function (transactionId) {
+        return rollbackTransactionSilently(transactionId, _this3._requestRunner);
+      });
+
+      _promise2.default.all(rollbackAllOngoingTransactions).then(function () {
+        _this3._sessionTracker.sessionClosed(_this3);
+        callback();
+      });
+    }
+  }]);
+  return HttpSession;
+}(_session2.default); /**
+                       * 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.
+                       */
+
+exports.default = HttpSession;
+
+
+function rollbackTransactionAfterQueryFailure(transactionId, streamObserver, requestRunner) {
+  return rollbackTransactionSilently(transactionId, requestRunner).then(function () {
+    return streamObserver;
+  });
+}
+
+function commitTransactionAfterQuerySuccess(transactionId, streamObserver, requestRunner) {
+  return requestRunner.commitTransaction(transactionId).catch(function (error) {
+    streamObserver.onError(error);
+  }).then(function () {
+    return streamObserver;
+  });
+}
+
+function rollbackTransactionSilently(transactionId, requestRunner) {
+  return requestRunner.rollbackTransaction(transactionId).catch(function (error) {
+    // ignore all rollback errors
+  });
+}
+
+function createServerInfoSupplier(url) {
+  return function () {
+    return { server: { address: url.hostAndPort } };
+  };
+}
+
+function throwTransactionsNotSupported() {
+  throw new _error.Neo4jError('Experimental HTTP driver does not support transactions');
+}