gremlin 3.5.2 → 3.5.3

package/lib/driver/client.js

@@ -4,14 +4,14 @@
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you under the Apache License, Version 2.0 (the
- *  "License"); you may not use this file except in compliance
+ *  '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
+ *  '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.
@@ -26,7 +26,6 @@ const Bytecode = require('../process/bytecode');
  * A {@link Client} contains methods to send messages to a Gremlin Server.
  */
 class Client {
-
   /**
    * Creates a new instance of {@link Client}.
    * @param {String} url The resource uri.
@@ -73,25 +72,35 @@ class Client {
     return this._connection.isOpen;
   }
 
+  /**
+   * Configuration specific to the current request.
+   * @typedef {Object} RequestOptions
+   * @property {String} requestId - User specified request identifier which must be a UUID.
+   * @property {Number} batchSize - Indicates whether the Power component is present.
+   * @property {String} userAgent - The size in which the result of a request is to be 'batched' back to the client
+   * @property {Number} evaluationTimeout - The timeout for the evaluation of the request.
+   */
+
   /**
    * Send a request to the Gremlin Server, can send a script or bytecode steps.
    * @param {Bytecode|string} message The bytecode or script to send
    * @param {Object} [bindings] The script bindings, if any.
-   * @param {Object} [requestOptions] Configuration specific to the current request.
-   * @param {String} [requestOptions.requestId] User specified request identifier which must be a UUID.
-   * @param {Number} [requestOptions.batchSize] The size in which the result of a request is to be "batched" back to the client
-   * @param {String} [requestOptions.userAgent] A custom string that specifies to the server where the request came from.
-   * @param {Number} [requestOptions.evaluationTimeout] The timeout for the evaluation of the request.
+   * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
    * @returns {Promise}
    */
   submit(message, bindings, requestOptions) {
-    const requestIdOverride = requestOptions && requestOptions.requestId
-    if (requestIdOverride) delete requestOptions['requestId'];
+    const requestIdOverride = requestOptions && requestOptions.requestId;
+    if (requestIdOverride) {
+      delete requestOptions['requestId'];
+    }
 
-    const args = Object.assign({
-      gremlin: message,
-      aliases: { 'g': this._options.traversalSource || 'g' }
-    }, requestOptions)
+    const args = Object.assign(
+      {
+        gremlin: message,
+        aliases: { g: this._options.traversalSource || 'g' },
+      },
+      requestOptions,
+    );
 
     if (this._options.session && this._options.processor === 'session') {
       args['session'] = this._options.session;
@@ -100,17 +109,54 @@ class Client {
     if (message instanceof Bytecode) {
       if (this._options.session && this._options.processor === 'session') {
         return this._connection.submit('session', 'bytecode', args, requestIdOverride);
-      } else {
-        return this._connection.submit('traversal', 'bytecode', args, requestIdOverride);
       }
+      return this._connection.submit('traversal', 'bytecode', args, requestIdOverride);
+    } else if (typeof message === 'string') {
+      args['bindings'] = bindings;
+      args['language'] = 'gremlin-groovy';
+      args['accept'] = this._connection.mimeType;
+      return this._connection.submit(this._options.processor || '', 'eval', args, requestIdOverride);
+    }
+    throw new TypeError('message must be of type Bytecode or string');
+  }
+
+  /**
+   * Send a request to the Gremlin Server and receive a stream for the results, can send a script or bytecode steps.
+   * @param {Bytecode|string} message The bytecode or script to send
+   * @param {Object} [bindings] The script bindings, if any.
+   * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
+   * @returns {ReadableStream}
+   */
+  stream(message, bindings, requestOptions) {
+    const requestIdOverride = requestOptions && requestOptions.requestId;
+    if (requestIdOverride) {
+      delete requestOptions['requestId'];
+    }
+
+    const args = Object.assign(
+      {
+        gremlin: message,
+        aliases: { g: this._options.traversalSource || 'g' },
+      },
+      requestOptions,
+    );
+
+    if (this._options.session && this._options.processor === 'session') {
+      args['session'] = this._options.session;
+    }
+
+    if (message instanceof Bytecode) {
+      if (this._options.session && this._options.processor === 'session') {
+        return this._connection.stream('session', 'bytecode', args, requestIdOverride);
+      }
+      return this._connection.stream('traversal', 'bytecode', args, requestIdOverride);
     } else if (typeof message === 'string') {
       args['bindings'] = bindings;
       args['language'] = 'gremlin-groovy';
       args['accept'] = this._connection.mimeType;
-      return this._connection.submit(this._options.processor || '','eval', args, requestIdOverride);
-    } else {
-      throw new TypeError("message must be of type Bytecode or string");
+      return this._connection.stream(this._options.processor || '', 'eval', args, requestIdOverride);
     }
+    throw new TypeError('message must be of type Bytecode or string');
   }
 
   /**
@@ -120,7 +166,7 @@ class Client {
    */
   close() {
     if (this._options.session && this._options.processor === 'session') {
-      const args = {'session': this._options.session};
+      const args = { session: this._options.session };
       return this._connection.submit(this._options.processor, 'close', args, null).then(() => this._connection.close());
     }
     return this._connection.close();
@@ -132,7 +178,7 @@ class Client {
    * @param {Function} handler The callback to be called when the event occurs.
    */
   addListener(event, handler) {
-    this._connection.on(event, handler)
+    this._connection.on(event, handler);
   }
 
   /**
@@ -141,7 +187,7 @@ class Client {
    * @param {Function} handler The event handler to be removed.
    */
   removeListener(event, handler) {
-    this._connection.removeListener(event, handler)
+    this._connection.removeListener(event, handler);
   }
 }
 

package/lib/driver/connection.js

@@ -23,19 +23,19 @@
 'use strict';
 
 const EventEmitter = require('events');
+const Stream = require('stream');
 const WebSocket = require('ws');
 const util = require('util');
 const utils = require('../utils');
 const serializer = require('../structure/io/graph-serializer');
 const ResultSet = require('./result-set');
 const ResponseError = require('./response-error');
-const Bytecode = require('../process/bytecode');
 
 const responseStatusCode = {
   success: 200,
   noContent: 204,
   partialContent: 206,
-  authenticationChallenge:  407,
+  authenticationChallenge: 407,
 };
 
 const defaultMimeType = 'application/vnd.gremlin-v3.0+json';
@@ -48,7 +48,6 @@ const pongTimeoutDelay = 30 * 1000;
  * Represents a single connection to a Gremlin Server.
  */
 class Connection extends EventEmitter {
-
   /**
    * Creates a new instance of {@link Connection}.
    * @param {String} url The resource uri.
@@ -92,7 +91,8 @@ class Connection extends EventEmitter {
     this._pingInterval = null;
     this._pongTimeout = null;
 
-    this._header = String.fromCharCode(this.mimeType.length) + this.mimeType;
+    this._header = String.fromCharCode(this.mimeType.length) + this.mimeType; // TODO: what if mimeType.length > 255
+    this._header_buf = Buffer.from(this._header);
     this.isOpen = false;
     this.traversalSource = options.traversalSource || 'g';
     this._authenticator = options.authenticator;
@@ -118,14 +118,14 @@ class Connection extends EventEmitter {
       return this._openPromise;
     }
 
-    this.emit('log', `ws open`);
+    this.emit('log', 'ws open');
 
     this._ws = new WebSocket(this.url, {
       headers: this.options.headers,
       ca: this.options.ca,
       cert: this.options.cert,
       pfx: this.options.pfx,
-      rejectUnauthorized: this.options.rejectUnauthorized
+      rejectUnauthorized: this.options.rejectUnauthorized,
     });
 
     this._ws.on('message', (data) => this._handleMessage(data));
@@ -143,7 +143,7 @@ class Connection extends EventEmitter {
       this._ws.pong();
     });
 
-    return this._openPromise = new Promise((resolve, reject) => {
+    return (this._openPromise = new Promise((resolve, reject) => {
       this._ws.on('open', () => {
         this.isOpen = true;
         if (this._pingEnabled) {
@@ -155,59 +155,79 @@ class Connection extends EventEmitter {
         this._handleError(err);
         reject(err);
       });
-    });
+    }));
   }
 
   /** @override */
   submit(processor, op, args, requestId) {
     const rid = requestId || utils.getUuid();
-    return this.open().then(() => new Promise((resolve, reject) => {
-      if (op !== 'authentication') {
-        this._responseHandlers[rid] = {
-          callback: (err, result) => err ? reject(err) : resolve(result),
-          result: null
+    return this.open().then(
+      () =>
+        new Promise((resolve, reject) => {
+          if (op !== 'authentication') {
+            this._responseHandlers[rid] = {
+              callback: (err, result) => (err ? reject(err) : resolve(result)),
+              result: null,
+            };
+          }
+
+          const request = {
+            requestId: rid,
+            op: op || 'bytecode',
+            // if using op eval need to ensure processor stays unset if caller didn't set it.
+            processor: !processor && op !== 'eval' ? 'traversal' : processor,
+            args: args || {},
+          };
+
+          const request_buf = this._writer.writeRequest(request);
+          const message = Buffer.concat([this._header_buf, request_buf], this._header_buf.length + request_buf.length);
+          this._ws.send(message);
+        }),
+    );
+  }
+
+  /** @override */
+  stream(processor, op, args, requestId) {
+    const rid = requestId || utils.getUuid();
+
+    const readableStream = new Stream.Readable({
+      objectMode: true,
+      read() {},
+    });
+
+    this._responseHandlers[rid] = {
+      callback: (err) => (err ? readableStream.destroy(err) : readableStream.push(null)),
+      result: readableStream,
+    };
+
+    this.open()
+      .then(() => {
+        const request = {
+          requestId: rid,
+          op: op || 'bytecode',
+          // if using op eval need to ensure processor stays unset if caller didn't set it.
+          processor: !processor && op !== 'eval' ? 'traversal' : processor,
+          args: args || {},
         };
-      }
 
-      const message = Buffer.from(this._header + JSON.stringify(this._getRequest(rid, op, args, processor)));
-      this._ws.send(message);
-    }));
+        const request_buf = this._writer.writeRequest(request);
+        const message = Buffer.concat([this._header_buf, request_buf], this._header_buf.length + request_buf.length);
+        this._ws.send(message);
+      })
+      .catch((err) => readableStream.destroy(err));
+
+    return readableStream;
   }
 
   _getDefaultReader(mimeType) {
-    return mimeType === graphSON2MimeType
-      ? new serializer.GraphSON2Reader()
-      : new serializer.GraphSONReader();
+    return mimeType === graphSON2MimeType ? new serializer.GraphSON2Reader() : new serializer.GraphSONReader();
   }
 
   _getDefaultWriter(mimeType) {
-    return mimeType === graphSON2MimeType
-      ? new serializer.GraphSON2Writer()
-      : new serializer.GraphSONWriter();
-  }
-
-  _getRequest(id, op, args, processor) {
-    if (args) {
-      args = this._adaptArgs(args, true);
-    } else {
-      args = {};
-    }
-
-    if (args['gremlin'] instanceof Bytecode) {
-      args['gremlin'] = this._writer.adaptObject(args['gremlin']);
-    }
-
-    return ({
-      'requestId': { '@type': 'g:UUID', '@value': id },
-      'op': op || 'bytecode',
-      // if using op eval need to ensure processor stays unset if caller didn't set it.
-      'processor': (!processor && op !== 'eval') ? 'traversal' : processor,
-      'args': args
-    });
+    return mimeType === graphSON2MimeType ? new serializer.GraphSON2Writer() : new serializer.GraphSONWriter();
   }
 
   _pingHeartbeat() {
-
     if (this._pingInterval) {
       clearInterval(this._pingInterval);
       this._pingInterval = null;
@@ -227,7 +247,6 @@ class Connection extends EventEmitter {
       }, this._pongTimeoutDelay);
 
       this._ws.ping();
-
     }, this._pingIntervalDelay);
   }
 
@@ -247,22 +266,30 @@ class Connection extends EventEmitter {
   }
 
   _handleMessage(data) {
-    const response = this._reader.read(JSON.parse(data.toString()));
+    const response = this._reader.readResponse(data);
     if (response.requestId === null || response.requestId === undefined) {
       // There was a serialization issue on the server that prevented the parsing of the request id
       // We invoke any of the pending handlers with an error
-      Object.keys(this._responseHandlers).forEach(requestId => {
+      Object.keys(this._responseHandlers).forEach((requestId) => {
         const handler = this._responseHandlers[requestId];
         this._clearHandler(requestId);
         if (response.status !== undefined && response.status.message) {
           return handler.callback(
             // TINKERPOP-2285: keep the old server error message in case folks are parsing that - fix in a future breaking version
-            new ResponseError(util.format(
-              'Server error (no request information): %s (%d)', response.status.message, response.status.code), response.status));
-        } else {
-           // TINKERPOP-2285: keep the old server error message in case folks are parsing that - fix in a future breaking version
-          return handler.callback(new ResponseError(util.format('Server error (no request information): %j', response), response.status));
+            new ResponseError(
+              util.format(
+                'Server error (no request information): %s (%d)',
+                response.status.message,
+                response.status.code,
+              ),
+              response.status,
+            ),
+          );
         }
+        // TINKERPOP-2285: keep the old server error message in case folks are parsing that - fix in a future breaking version
+        return handler.callback(
+          new ResponseError(util.format('Server error (no request information): %j', response), response.status),
+        );
       });
       return;
     }
@@ -276,31 +303,49 @@ class Connection extends EventEmitter {
     }
 
     if (response.status.code === responseStatusCode.authenticationChallenge && this._authenticator) {
-      this._authenticator.evaluateChallenge(response.result.data).then(res => {
-        return this.submit(undefined, 'authentication', res, response.requestId);
-      }).catch(handler.callback);
+      this._authenticator
+        .evaluateChallenge(response.result.data)
+        .then((res) => this.submit(undefined, 'authentication', res, response.requestId))
+        .catch(handler.callback);
 
       return;
-    }
-    else if (response.status.code >= 400) {
+    } else if (response.status.code >= 400) {
       // callback in error
       return handler.callback(
         // TINKERPOP-2285: keep the old server error message in case folks are parsing that - fix in a future breaking version
-        new ResponseError(util.format('Server error: %s (%d)', response.status.message, response.status.code), response.status));
+        new ResponseError(
+          util.format('Server error: %s (%d)', response.status.message, response.status.code),
+          response.status,
+        ),
+      );
     }
+
+    const isStreamingResponse = handler.result instanceof Stream.Readable;
+
     switch (response.status.code) {
       case responseStatusCode.noContent:
         this._clearHandler(response.requestId);
+        if (isStreamingResponse) {
+          handler.result.push(new ResultSet(utils.emptyArray, response.status.attributes));
+          return handler.callback(null);
+        }
         return handler.callback(null, new ResultSet(utils.emptyArray, response.status.attributes));
       case responseStatusCode.partialContent:
+        if (isStreamingResponse) {
+          handler.result.push(new ResultSet(response.result.data, response.status.attributes));
+          break;
+        }
         handler.result = handler.result || [];
         handler.result.push.apply(handler.result, response.result.data);
         break;
       default:
+        if (isStreamingResponse) {
+          handler.result.push(new ResultSet(response.result.data, response.status.attributes));
+          return handler.callback(null);
+        }
         if (handler.result) {
           handler.result.push.apply(handler.result, response.result.data);
-        }
-        else {
+        } else {
           handler.result = response.result.data;
         }
         this._clearHandler(response.requestId);
@@ -336,32 +381,6 @@ class Connection extends EventEmitter {
     delete this._responseHandlers[requestId];
   }
 
-  /**
-   * Takes the given args map and ensures all arguments are passed through to _write.adaptObject
-   * @param {Object} args Map of arguments to process.
-   * @param {Boolean} protocolLevel Determines whether it's a protocol level binding.
-   * @returns {Object}
-   * @private
-   */
-  _adaptArgs(args, protocolLevel) {
-    if (args instanceof Object) {
-      let newObj = {};
-      Object.keys(args).forEach((key) => {
-        // bindings key (at the protocol-level needs special handling. without this, it wraps the generated Map
-        // in another map for types like EnumValue. Could be a nicer way to do this but for now it's solving the
-        // problem with script submission of non JSON native types
-        if (protocolLevel && key === 'bindings')
-          newObj[key] = this._adaptArgs(args[key], false);
-        else
-          newObj[key] = this._writer.adaptObject(args[key]);
-      });
-
-      return newObj;
-    }
-
-    return args;
-  }
-
   /**
    * Closes the Connection.
    * @return {Promise}
@@ -371,7 +390,7 @@ class Connection extends EventEmitter {
       return Promise.resolve();
     }
     if (!this._closePromise) {
-      this._closePromise = new Promise(resolve => {
+      this._closePromise = new Promise((resolve) => {
         this._closeCallback = resolve;
         this._ws.close();
       });

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

@@ -34,7 +34,6 @@ 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.
@@ -68,28 +67,30 @@ class DriverRemoteConnection extends RemoteConnection {
 
   /** @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");
+    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);
@@ -104,12 +105,12 @@ class DriverRemoteConnection extends RemoteConnection {
 
   /** @override */
   commit() {
-    return this._client.submit(Bytecode.GraphOp.commit, null)
+    return this._client.submit(Bytecode.GraphOp.commit, null);
   }
 
   /** @override */
   rollback() {
-    return this._client.submit(Bytecode.GraphOp.rollback, null)
+    return this._client.submit(Bytecode.GraphOp.rollback, null);
   }
 
   /** @override */

package/lib/driver/remote-connection.js

@@ -30,7 +30,6 @@ const TraversalStrategy = require('../process/traversal-strategy').TraversalStra
  * returning results.
  */
 class RemoteConnection {
-
   /**
    * @param {String} url The resource uri.
    * @param {Object} [options] The connection options.
@@ -73,7 +72,7 @@ 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.
@@ -128,7 +127,7 @@ class RemoteStrategy extends TraversalStrategy {
     // 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");
+    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.
@@ -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;
@@ -113,8 +115,8 @@ class Bytecode {
    */
   static get GraphOp() {
     return {
-      commit: Bytecode._createGraphOp("tx", ["commit"]),
-      rollback: Bytecode._createGraphOp("tx", ["rollback"])
+      commit: Bytecode._createGraphOp('tx', ['commit']),
+      rollback: Bytecode._createGraphOp('tx', ['rollback']),
     };
   }
 }