gremlin 3.5.0 → 3.5.3

package/index.js

@@ -50,8 +50,8 @@ module.exports = {
     ResultSet,
     auth: {
       Authenticator,
-      PlainTextSaslAuthenticator
-    }
+      PlainTextSaslAuthenticator,
+    },
   },
   process: {
     Bytecode,
@@ -79,7 +79,7 @@ module.exports = {
     Translator,
     traversal: AnonymousTraversalSource.traversal,
     AnonymousTraversalSource,
-    withOptions: t.withOptions
+    withOptions: t.withOptions,
   },
   structure: {
     io: gs,
@@ -89,6 +89,6 @@ module.exports = {
     Property: graph.Property,
     Vertex: graph.Vertex,
     VertexProperty: graph.VertexProperty,
-    toLong: utils.toLong
-  }
+    toLong: utils.toLong,
+  },
 };

package/lib/driver/auth/authenticator.js

@@ -24,14 +24,14 @@ class Authenticator {
   constructor(options) {
     this._options = options;
   }
-  
+
   /**
    * @abstract
    * Evaluates the challenge from the server and returns appropriate response.
    * @param {String} challenge Challenge string presented by the server.
    */
   evaluateChallenge(challenge) {
-    throw new Error("evaluateChallenge should be implemented");
+    throw new Error('evaluateChallenge should be implemented');
   }
 }
 

package/lib/driver/auth/mechanisms/sasl-mechanism-base.js

@@ -45,7 +45,7 @@ class SaslMechanismBase {
    * @param {String} challenge Challenge string presented by the server
    */
   evaluateChallenge(challenge) {
-    throw new Error("evaluateChallenge should be implemented");
+    throw new Error('evaluateChallenge should be implemented');
   }
 }
 

package/lib/driver/auth/mechanisms/sasl-mechanism-plain.js

@@ -32,12 +32,13 @@ class SaslMechanismPlain extends SaslMechanismBase {
   constructor(options) {
     super(options);
 
-    if (this._options.username === undefined
-      || this._options.username === null
-      || this._options.username.length == 0
-      || this._options.password === undefined
-      || this._options.password === null
-      || this._options.password.length == 0
+    if (
+      this._options.username === undefined ||
+      this._options.username === null ||
+      this._options.username.length === 0 ||
+      this._options.password === undefined ||
+      this._options.password === null ||
+      this._options.password.length === 0
     ) {
       throw new Error('Missing credentials for SASL PLAIN mechanism');
     }
@@ -49,7 +50,7 @@ class SaslMechanismPlain extends SaslMechanismBase {
   get name() {
     return 'PLAIN';
   }
-  
+
   /**
    * Evaluates the challenge from the server and returns appropriate response.
    * @param {String} challenge Challenge string presented by the server.
@@ -58,12 +59,14 @@ class SaslMechanismPlain extends SaslMechanismBase {
   evaluateChallenge(challenge) {
     if (this._hasInitialResponse(challenge)) {
       return Promise.resolve({
-        'saslMechanism': this.name,
-        'sasl': this._saslArgument(this._options.authzid, this._options.username, this._options.password)
+        saslMechanism: this.name,
+        sasl: this._saslArgument(this._options.authzid, this._options.username, this._options.password),
       });
     }
-    
-    return Promise.resolve({ 'sasl': this._saslArgument(this._options.authzid, this._options.username, this._options.password) });
+
+    return Promise.resolve({
+      sasl: this._saslArgument(this._options.authzid, this._options.username, this._options.password),
+    });
   }
 
   /**
@@ -73,11 +76,17 @@ class SaslMechanismPlain extends SaslMechanismBase {
    * @param {String} password The password of user with access to server.
    */
   _saslArgument(authzid, username, password) {
-    if (authzid === undefined || authzid === null) authzid = '';
-    if (username === undefined || username === null) username = '';
-    if (password === undefined || password.length === null) password = '';
+    if (authzid === undefined || authzid === null) {
+      authzid = '';
+    }
+    if (username === undefined || username === null) {
+      username = '';
+    }
+    if (password === undefined || password.length === null) {
+      password = '';
+    }
 
-    return new Buffer(`${authzid}\0${username}\0${password}`).toString('base64');
+    return Buffer.from(`${authzid}\0${username}\0${password}`).toString('base64');
   }
 
   /**

package/lib/driver/auth/plain-text-sasl-authenticator.js

@@ -33,15 +33,15 @@ class PlainTextSaslAuthenticator extends Authenticator {
   constructor(username, password, authzid) {
     const options = {
       mechanism: new SaslMechanismPlain({
-        'username': username,
-        'password': password,
-        'authzid': authzid
-      })
+        username: username,
+        password: password,
+        authzid: authzid,
+      }),
     };
 
     super(options);
   }
-  
+
   /**
    * Evaluates the challenge from the server and returns appropriate response.
    * @param {String} challenge Challenge string presented by the server.

package/lib/driver/auth/sasl-authenticator.js

@@ -35,7 +35,7 @@ class SaslAuthenticator extends Authenticator {
       throw new Error('No Sasl Mechanism Specified');
     }
   }
-  
+
   /**
    * Evaluates the challenge from the server and returns appropriate response.
    * @param {String} challenge Challenge string presented by the server.

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.
@@ -48,7 +47,7 @@ class Client {
     this._options = options;
     if (this._options.processor === 'session') {
       // compatibility with old 'session' processor setting
-      this._options.session = options.session || utils.getUuid()
+      this._options.session = options.session || utils.getUuid();
     }
     if (this._options.session) {
       // re-assign processor to 'session' when in session mode
@@ -73,40 +72,91 @@ 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;
+    }
 
     if (message instanceof Bytecode) {
-      return this._connection.submit('traversal','bytecode', args, requestIdOverride);
+      if (this._options.session && this._options.processor === 'session') {
+        return this._connection.submit('session', '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') {
-        args['session'] = this._options.session;
+        return this._connection.stream('session', 'bytecode', args, requestIdOverride);
       }
-      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('traversal', 'bytecode', args, requestIdOverride);
+    } else if (typeof message === 'string') {
+      args['bindings'] = bindings;
+      args['language'] = 'gremlin-groovy';
+      args['accept'] = this._connection.mimeType;
+      return this._connection.stream(this._options.processor || '', 'eval', args, requestIdOverride);
     }
+    throw new TypeError('message must be of type Bytecode or string');
   }
 
   /**
@@ -116,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();
@@ -128,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);
   }
 
   /**
@@ -137,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();
       });