JS driver v1.4.0-beta01: Checking in transpiled files for bower

Author: lutovich

lib/browser/neo4j-web.js

@@ -47,8 +47,24 @@ var _error = require('./error');
 
 var _connectionProviders = require('./internal/connection-providers');
 
+var _bookmark = require('./internal/bookmark');
+
+var _bookmark2 = _interopRequireDefault(_bookmark);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var READ = 'READ',
+    WRITE = 'WRITE';
+/**
+ * A driver maintains one or more {@link Session}s with a remote
+ * Neo4j instance. Through the {@link Session}s you can send statements
+ * and retrieve results from the database.
+ *
+ * Drivers are reasonably expensive to create - you should strive to keep one
+ * driver instance around per Neo4j Instance you connect to.
+ *
+ * @access public
+ */
 /**
  * Copyright (c) 2002-2017 "Neo Technology,","
  * Network Engine for Objects in Lund AB [http://neotechnology.com]
@@ -68,19 +84,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * limitations under the License.
  */
 
-var READ = 'READ',
-    WRITE = 'WRITE';
-/**
- * A driver maintains one or more {@link Session}s with a remote
- * Neo4j instance. Through the {@link Session}s you can send statements
- * and retrieve results from the database.
- *
- * Drivers are reasonably expensive to create - you should strive to keep one
- * driver instance around per Neo4j Instance you connect to.
- *
- * @access public
- */
-
 var Driver = function () {
   /**
    * You should not be calling this directly, instead use {@link driver}.
@@ -107,7 +110,7 @@ var Driver = function () {
     /**
      * Reference to the connection provider. Initialized lazily by {@link _getOrCreateConnectionProvider}.
      * @type {ConnectionProvider}
-     * @private
+     * @protected
      */
     this._connectionProvider = null;
   }
@@ -167,16 +170,17 @@ var Driver = function () {
      * made available for others to use.
      *
      * @param {string} [mode=WRITE] the access mode of this session, allowed values are {@link READ} and {@link WRITE}.
-     * @param {string} [bookmark=null] the initial reference to some previous transaction. Value is optional and
-     * absence indicates that that the bookmark does not exist or is unknown.
+     * @param {string|string[]} [bookmarkOrBookmarks=null] the initial reference or references to some previous
+     * transactions. Value is optional and absence indicates that that the bookmarks do not exist or are unknown.
      * @return {Session} new session.
      */
 
   }, {
     key: 'session',
-    value: function session(mode, bookmark) {
+    value: function session(mode, bookmarkOrBookmarks) {
       var sessionMode = Driver._validateSessionMode(mode);
       var connectionProvider = this._getOrCreateConnectionProvider();
+      var bookmark = new _bookmark2.default(bookmarkOrBookmarks);
       return this._createSession(sessionMode, connectionProvider, bookmark, this._config);
     }
   }, {

lib/browser/neo4j-web.min.js

@@ -21,26 +21,11 @@ var _createClass2 = require("babel-runtime/helpers/createClass");
 
 var _createClass3 = _interopRequireDefault(_createClass2);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _integer = require("./integer");
 
-/**
- * Copyright (c) 2002-2017 "Neo Technology,","
- * Network Engine for Objects in Lund AB [http://neotechnology.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 _integer2 = _interopRequireDefault(_integer);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
  * Class for Node Type.
@@ -86,7 +71,24 @@ var Node = function () {
 /**
  * Class for Relationship Type.
  */
-
+/**
+ * Copyright (c) 2002-2017 "Neo Technology,","
+ * Network Engine for Objects in Lund AB [http://neotechnology.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 Relationship = function () {
   /**

lib/browser/neo4j-web.test.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
+
+var _defineProperty3 = _interopRequireDefault(_defineProperty2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _util = require('./util');
+
+var util = _interopRequireWildcard(_util);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var BOOKMARK_KEY = 'bookmark'; /**
+                                * Copyright (c) 2002-2017 "Neo Technology,","
+                                * Network Engine for Objects in Lund AB [http://neotechnology.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 BOOKMARKS_KEY = 'bookmarks';
+var BOOKMARK_PREFIX = 'neo4j:bookmark:v1:tx';
+
+var UNKNOWN_BOOKMARK_VALUE = -1;
+
+var Bookmark = function () {
+
+  /**
+   * @constructor
+   * @param {string|string[]} values single bookmark as string or multiple bookmarks as a string array.
+   */
+  function Bookmark(values) {
+    (0, _classCallCheck3.default)(this, Bookmark);
+
+    this._values = asStringArray(values);
+    this._maxValue = maxBookmark(this._values);
+  }
+
+  /**
+   * Check if the given bookmark is meaningful and can be send to the database.
+   * @return {boolean} returns <code>true</code> bookmark has a value, <code>false</code> otherwise.
+   */
+
+
+  (0, _createClass3.default)(Bookmark, [{
+    key: 'isEmpty',
+    value: function isEmpty() {
+      return this._maxValue === null;
+    }
+
+    /**
+     * Get maximum value of this bookmark as string.
+     * @return {string|null} the maximum value or <code>null</code> if it is not defined.
+     */
+
+  }, {
+    key: 'maxBookmarkAsString',
+    value: function maxBookmarkAsString() {
+      return this._maxValue;
+    }
+
+    /**
+     * Get this bookmark as an object for begin transaction call.
+     * @return {object} the value of this bookmark as object.
+     */
+
+  }, {
+    key: 'asBeginTransactionParameters',
+    value: function asBeginTransactionParameters() {
+      var _ref;
+
+      if (this.isEmpty()) {
+        return {};
+      }
+
+      // Driver sends {bookmark: "max", bookmarks: ["one", "two", "max"]} instead of simple
+      // {bookmarks: ["one", "two", "max"]} for backwards compatibility reasons. Old servers can only accept single
+      // bookmark that is why driver has to parse and compare given list of bookmarks. This functionality will
+      // eventually be removed.
+      return _ref = {}, (0, _defineProperty3.default)(_ref, BOOKMARK_KEY, this._maxValue), (0, _defineProperty3.default)(_ref, BOOKMARKS_KEY, this._values), _ref;
+    }
+  }]);
+  return Bookmark;
+}();
+
+/**
+ * Converts given value to an array.
+ * @param {string|string[]} [value=undefined] argument to convert.
+ * @return {string[]} value converted to an array.
+ */
+
+
+exports.default = Bookmark;
+function asStringArray(value) {
+  if (!value) {
+    return [];
+  }
+
+  if (util.isString(value)) {
+    return [value];
+  }
+
+  if (Array.isArray(value)) {
+    var result = [];
+    for (var i = 0; i < value.length; i++) {
+      var element = value[i];
+      if (!util.isString(element)) {
+        throw new TypeError('Bookmark should be a string, given: \'' + element + '\'');
+      }
+      result.push(element);
+    }
+    return result;
+  }
+
+  throw new TypeError('Bookmark should either be a string or a string array, given: \'' + value + '\'');
+}
+
+/**
+ * Find latest bookmark in the given array of bookmarks.
+ * @param {string[]} bookmarks array of bookmarks.
+ * @return {string|null} latest bookmark value.
+ */
+function maxBookmark(bookmarks) {
+  if (!bookmarks || bookmarks.length === 0) {
+    return null;
+  }
+
+  var maxBookmark = bookmarks[0];
+  var maxValue = bookmarkValue(maxBookmark);
+
+  for (var i = 1; i < bookmarks.length; i++) {
+    var bookmark = bookmarks[i];
+    var value = bookmarkValue(bookmark);
+
+    if (value > maxValue) {
+      maxBookmark = bookmark;
+      maxValue = value;
+    }
+  }
+
+  return maxBookmark;
+}
+
+/**
+ * Calculate numeric value for the given bookmark.
+ * @param {string} bookmark argument to get numeric value for.
+ * @return {number} value of the bookmark.
+ */
+function bookmarkValue(bookmark) {
+  if (bookmark && bookmark.indexOf(BOOKMARK_PREFIX) === 0) {
+    var result = parseInt(bookmark.substring(BOOKMARK_PREFIX.length));
+    return result ? result : UNKNOWN_BOOKMARK_VALUE;
+  }
+  return UNKNOWN_BOOKMARK_VALUE;
+}

lib/v1/driver.js

@@ -78,6 +78,14 @@ var DummyChannel = function () {
     value: function toBuffer() {
       return new _buf.CombinedBuffer(this.written);
     }
+  }, {
+    key: "close",
+    value: function close(cb) {
+      this.written = [];
+      if (cb) {
+        return cb();
+      }
+    }
   }]);
   return DummyChannel;
 }();

lib/v1/graph-types.js

@@ -69,13 +69,17 @@ var ConnectionHolder = function () {
 
     /**
      * Get the current connection promise.
+     * @param {StreamObserver} streamObserver an observer for this connection.
      * @return {Promise<Connection>} promise resolved with the current connection.
      */
 
   }, {
     key: 'getConnection',
-    value: function getConnection() {
-      return this._connectionPromise;
+    value: function getConnection(streamObserver) {
+      return this._connectionPromise.then(function (connection) {
+        streamObserver.resolveConnection(connection);
+        return connection.initializationCompleted();
+      });
     }
 
     /**
@@ -178,7 +182,7 @@ var EmptyConnectionHolder = function (_ConnectionHolder) {
     }
   }, {
     key: 'getConnection',
-    value: function getConnection() {
+    value: function getConnection(streamObserver) {
       return _promise2.default.reject((0, _error.newError)('This connection holder does not serve connections'));
     }
   }, {