gremlin 3.5.0 → 3.5.3

package/lib/driver/driver-remote-connection.js

@@ -25,14 +25,15 @@
 const rcModule = require('./remote-connection');
 const RemoteConnection = rcModule.RemoteConnection;
 const RemoteTraversal = rcModule.RemoteTraversal;
+const utils = require('../utils');
 const Client = require('./client');
+const Bytecode = require('../process/bytecode');
 const OptionsStrategy = require('../process/traversal-strategy').OptionsStrategy;
 
 /**
  * Represents the default {@link RemoteConnection} implementation.
  */
 class DriverRemoteConnection extends RemoteConnection {
-
   /**
    * Creates a new instance of {@link DriverRemoteConnection}.
    * @param {String} url The resource uri.
@@ -49,8 +50,8 @@ class DriverRemoteConnection extends RemoteConnection {
    * @param {Object} [options.headers] An associative array containing the additional header key/values for the initial request.
    * @constructor
    */
-  constructor(url, options) {
-    super(url);
+  constructor(url, options = {}) {
+    super(url, options);
     this._client = new Client(url, options);
   }
 
@@ -59,27 +60,57 @@ class DriverRemoteConnection extends RemoteConnection {
     return this._client.open();
   }
 
+  /** @override */
   get isOpen() {
     return this._client.isOpen;
   }
 
   /** @override */
   submit(bytecode) {
-    let optionsStrategy = bytecode.sourceInstructions.find(
-        i => i[0] === "withStrategies" && i[1] instanceof OptionsStrategy);
+    const optionsStrategy = bytecode.sourceInstructions.find(
+      (i) => i[0] === 'withStrategies' && i[1] instanceof OptionsStrategy,
+    );
     const allowedKeys = ['evaluationTimeout', 'scriptEvaluationTimeout', 'batchSize', 'requestId', 'userAgent'];
 
     let requestOptions = undefined;
     if (optionsStrategy !== undefined) {
       requestOptions = {};
       const conf = optionsStrategy[1].configuration;
-      for (let key in conf) {
+      for (const key in conf) {
         if (conf.hasOwnProperty(key) && allowedKeys.indexOf(key) > -1) {
           requestOptions[key] = conf[key];
         }
       }
     }
-    return this._client.submit(bytecode, null, requestOptions).then(result => new RemoteTraversal(result.toArray()));
+
+    return this._client.submit(bytecode, null, requestOptions).then((result) => new RemoteTraversal(result.toArray()));
+  }
+
+  /** @override */
+  createSession() {
+    if (this.isSessionBound) {
+      throw new Error('Connection is already bound to a session - child sessions are not allowed');
+    }
+
+    // make sure a fresh session is used when starting a new transaction
+    const copiedOptions = Object.assign({}, this.options);
+    copiedOptions.session = utils.getUuid();
+    return new DriverRemoteConnection(this.url, copiedOptions);
+  }
+
+  /** @override */
+  get isSessionBound() {
+    return this.options.session;
+  }
+
+  /** @override */
+  commit() {
+    return this._client.submit(Bytecode.GraphOp.commit, null);
+  }
+
+  /** @override */
+  rollback() {
+    return this._client.submit(Bytecode.GraphOp.rollback, null);
   }
 
   /** @override */

package/lib/driver/remote-connection.js

@@ -30,8 +30,13 @@ const TraversalStrategy = require('../process/traversal-strategy').TraversalStra
  * returning results.
  */
 class RemoteConnection {
-  constructor(url) {
+  /**
+   * @param {String} url The resource uri.
+   * @param {Object} [options] The connection options.
+   */
+  constructor(url, options = {}) {
     this.url = url;
+    this.options = options;
   }
 
   /**
@@ -50,6 +55,15 @@ class RemoteConnection {
     throw new Error('isOpen() must be implemented');
   }
 
+  /**
+   * Determines if the connection is already bound to a session. If so, this indicates that the
+   * <code>#createSession()</code> cannot be called so as to produce child sessions.
+   * @returns {boolean}
+   */
+  get isSessionBound() {
+    return false;
+  }
+
   /**
    * Submits the <code>Bytecode</code> provided and returns a <code>RemoteTraversal</code>.
    * @abstract
@@ -58,10 +72,34 @@ class RemoteConnection {
    */
   submit(bytecode) {
     throw new Error('submit() must be implemented');
-  };
+  }
+
+  /**
+   * Create a new <code>RemoteConnection</code> that is bound to a session using the configuration from this one.
+   * If the connection is already session bound then this function should throw an exception.
+   * @returns {RemoteConnection}
+   */
+  createSession() {
+    throw new Error('createSession() must be implemented');
+  }
+
+  /**
+   * Submits a <code>Bytecode.GraphOp.commit</code> to the server and closes the connection.
+   * @returns {Promise}
+   */
+  commit() {
+    throw new Error('commit() must be implemented');
+  }
+  /**
+   * Submits a <code>Bytecode.GraphOp.rollback</code> to the server and closes the connection.
+   * @returns {Promise}
+   */
+  rollback() {
+    throw new Error('rollback() must be implemented');
+  }
 
   /**
-   * Closes the connection, if its not already opened.
+   * Closes the connection where open transactions will close according to the features of the graph provider.
    * @returns {Promise}
    */
   close() {
@@ -86,7 +124,10 @@ class RemoteStrategy extends TraversalStrategy {
    * @param {RemoteConnection} connection
    */
   constructor(connection) {
-    super();
+    // gave this a fqcn that has a local "js:" prefix since this strategy isn't sent as bytecode to the server.
+    // this is a sort of local-only strategy that actually executes client side. not sure if this prefix is the
+    // right way to name this or not, but it should have a name to identify it.
+    super('js:RemoteStrategy');
     this.connection = connection;
   }
 

package/lib/driver/response-error.js

@@ -25,7 +25,7 @@
 class ResponseError extends Error {
   constructor(message, responseStatus) {
     super(message);
-    this.name = "ResponseError";
+    this.name = 'ResponseError';
 
     /**
      * Gets the server status code.
@@ -44,4 +44,4 @@ class ResponseError extends Error {
   }
 }
 
-module.exports = ResponseError;
+module.exports = ResponseError;

package/lib/driver/result-set.js

@@ -31,7 +31,6 @@ const emptyMap = Object.freeze(new utils.ImmutableMap());
  * Represents the response returned from the execution of a Gremlin traversal or script.
  */
 class ResultSet {
-
   /**
    * Creates a new instance of {@link ResultSet}.
    * @param {Array} items
@@ -90,4 +89,4 @@ class ResultSet {
   }
 }
 
-module.exports = ResultSet;
+module.exports = ResultSet;

package/lib/process/anonymous-traversal.js

@@ -30,7 +30,6 @@ const Graph = require('../structure/graph').Graph;
  * instance or a <code>RemoteConnection</code>.
  */
 class AnonymousTraversalSource {
-
   /**
    * Creates a new instance of {@code AnonymousTraversalSource}.
    * @param {Function} [traversalSourceClass] Optional {@code GraphTraversalSource} constructor.
@@ -52,7 +51,7 @@ class AnonymousTraversalSource {
   /**
    * Creates a {@link GraphTraversalSource} binding a {@link RemoteConnection} to a remote {@link Graph} instances as its
    * reference so that traversals spawned from it will execute over that reference.
-   * @param {GraphTraversalSource} remoteConnection
+   * @param {RemoteConnection} remoteConnection
    * @return {GraphTraversalSource}
    */
   withRemote(remoteConnection) {
@@ -75,4 +74,4 @@ class AnonymousTraversalSource {
   }
 }
 
-module.exports = AnonymousTraversalSource;
+module.exports = AnonymousTraversalSource;

package/lib/process/bytecode.js

@@ -33,8 +33,7 @@ class Bytecode {
     if (!toClone) {
       this.sourceInstructions = [];
       this.stepInstructions = [];
-    }
-    else {
+    } else {
       this.sourceInstructions = [...toClone.sourceInstructions];
       this.stepInstructions = [...toClone.stepInstructions];
     }
@@ -79,9 +78,12 @@ class Bytecode {
     instruction[0] = name;
     for (let i = 1; i < length; i++) {
       const val = values[i - 1];
-      if (val instanceof Traversal && val.graph != null)
-        throw new Error("The child traversal of ${val} was not spawned anonymously - use " +
-            "the __ class rather than a TraversalSource to construct the child traversal");
+      if (val instanceof Traversal && val.graph != null) {
+        throw new Error(
+          `The child traversal of ${val} was not spawned anonymously - use ` +
+            'the __ class rather than a TraversalSource to construct the child traversal',
+        );
+      }
       instruction[i] = val;
     }
     return instruction;
@@ -94,6 +96,29 @@ class Bytecode {
   toString() {
     return JSON.stringify([this.sourceInstructions, this.stepInstructions]);
   }
+
+  /**
+   * Adds a new source instructions
+   * @param {String} name
+   * @param {Array} values
+   * @returns {Bytecode}
+   */
+  static _createGraphOp(name, values) {
+    const bc = new Bytecode();
+    bc.addSource(name, values);
+    return bc;
+  }
+
+  /**
+   * Gets the <code>Bytecode</code> that is meant to be sent as "graph operations" to the server.
+   * @returns {{rollback: Bytecode, commit: Bytecode}}
+   */
+  static get GraphOp() {
+    return {
+      commit: Bytecode._createGraphOp('tx', ['commit']),
+      rollback: Bytecode._createGraphOp('tx', ['rollback']),
+    };
+  }
 }
 
 module.exports = Bytecode;