gremlin 3.6.0 → 3.6.2

package/lib/driver/connection.js

@@ -28,6 +28,7 @@ const WebSocket = require('ws');
 const util = require('util');
 const utils = require('../utils');
 const serializer = require('../structure/io/graph-serializer');
+const { graphBinaryReader, graphBinaryWriter } = require('../structure/io/binary/GraphBinary');
 const ResultSet = require('./result-set');
 const ResponseError = require('./response-error');
 
@@ -40,6 +41,7 @@ const responseStatusCode = {
 
 const defaultMimeType = 'application/vnd.gremlin-v3.0+json';
 const graphSON2MimeType = 'application/vnd.gremlin-v2.0+json';
+const graphBinaryMimeType = 'application/vnd.graphbinary-v1.0';
 
 const pingIntervalDelay = 60 * 1000;
 const pongTimeoutDelay = 30 * 1000;
@@ -62,10 +64,11 @@ class Connection extends EventEmitter {
    * @param {GraphSONWriter} [options.writer] The writer to use.
    * @param {Authenticator} [options.authenticator] The authentication handler to use.
    * @param {Object} [options.headers] An associative array containing the additional header key/values for the initial request.
+   * @param {Boolean} [options.enableUserAgentOnConnect] Determines if a user agent will be sent during connection handshake. Defaults to: true
    * @param {Boolean} [options.pingEnabled] Setup ping interval. Defaults to: true.
    * @param {Number} [options.pingInterval] Ping request interval in ms if ping enabled. Defaults to: 60000.
    * @param {Number} [options.pongTimeout] Timeout of pong response in ms after sending a ping. Defaults to: 30000.
-   * @param {Boolean} [options.connectOnStartup] Open websocket on startup. Defaults to: true.
+   * @param {Boolean} [options.connectOnStartup] Deprecated and non-functional. Open websocket on startup.
    * @constructor
    */
   constructor(url, options) {
@@ -80,7 +83,7 @@ class Connection extends EventEmitter {
      */
     this.mimeType = options.mimeType || defaultMimeType;
 
-    // A map containing the request id and the handler
+    // A map containing the request id and the handler. The id should be in lower case to prevent string comparison issues.
     this._responseHandlers = {};
     this._reader = options.reader || this._getDefaultReader(this.mimeType);
     this._writer = options.writer || this._getDefaultWriter(this.mimeType);
@@ -96,13 +99,16 @@ class Connection extends EventEmitter {
     this.isOpen = false;
     this.traversalSource = options.traversalSource || 'g';
     this._authenticator = options.authenticator;
+    this._enableUserAgentOnConnect = options.enableUserAgentOnConnect !== false;
 
     this._pingEnabled = this.options.pingEnabled === false ? false : true;
     this._pingIntervalDelay = this.options.pingInterval || pingIntervalDelay;
     this._pongTimeoutDelay = this.options.pongTimeout || pongTimeoutDelay;
 
-    if (this.options.connectOnStartup !== false) {
-      this.open();
+    if (this.options.connectOnStartup) {
+      console.warn(
+        'connectOnStartup is now deprecated and non-functional. To open a connection, please call open() after instantiating connection object.',
+      );
     }
   }
 
@@ -119,9 +125,16 @@ class Connection extends EventEmitter {
     }
 
     this.emit('log', 'ws open');
+    let headers = this.options.headers;
+    if (this._enableUserAgentOnConnect) {
+      if (!headers) {
+        headers = [];
+      }
+      headers[utils.getUserAgentHeader()] = utils.getUserAgent();
+    }
 
     this._ws = new WebSocket(this.url, {
-      headers: this.options.headers,
+      headers: headers,
       ca: this.options.ca,
       cert: this.options.cert,
       pfx: this.options.pfx,
@@ -160,7 +173,8 @@ class Connection extends EventEmitter {
 
   /** @override */
   submit(processor, op, args, requestId) {
-    const rid = requestId || utils.getUuid();
+    // TINKERPOP-2847: Use lower case to prevent string comparison issues.
+    const rid = (requestId || utils.getUuid()).toLowerCase();
     return this.open().then(
       () =>
         new Promise((resolve, reject) => {
@@ -180,7 +194,7 @@ class Connection extends EventEmitter {
           };
 
           const request_buf = this._writer.writeRequest(request);
-          const message = Buffer.concat([this._header_buf, request_buf], this._header_buf.length + request_buf.length);
+          const message = Buffer.concat([this._header_buf, request_buf]);
           this._ws.send(message);
         }),
     );
@@ -188,7 +202,8 @@ class Connection extends EventEmitter {
 
   /** @override */
   stream(processor, op, args, requestId) {
-    const rid = requestId || utils.getUuid();
+    // TINKERPOP-2847: Use lower case to prevent string comparison issues.
+    const rid = (requestId || utils.getUuid()).toLowerCase();
 
     const readableStream = new Stream.Readable({
       objectMode: true,
@@ -211,7 +226,7 @@ class Connection extends EventEmitter {
         };
 
         const request_buf = this._writer.writeRequest(request);
-        const message = Buffer.concat([this._header_buf, request_buf], this._header_buf.length + request_buf.length);
+        const message = Buffer.concat([this._header_buf, request_buf]);
         this._ws.send(message);
       })
       .catch((err) => readableStream.destroy(err));
@@ -220,10 +235,18 @@ class Connection extends EventEmitter {
   }
 
   _getDefaultReader(mimeType) {
+    if (mimeType === graphBinaryMimeType) {
+      return graphBinaryReader;
+    }
+
     return mimeType === graphSON2MimeType ? new serializer.GraphSON2Reader() : new serializer.GraphSONReader();
   }
 
   _getDefaultWriter(mimeType) {
+    if (mimeType === graphBinaryMimeType) {
+      return graphBinaryWriter;
+    }
+
     return mimeType === graphSON2MimeType ? new serializer.GraphSON2Writer() : new serializer.GraphSONWriter();
   }
 
@@ -252,7 +275,7 @@ class Connection extends EventEmitter {
 
   _handleError(err) {
     this.emit('log', `ws error ${err}`);
-    this._cleanupWebsocket();
+    this._cleanupWebsocket(err);
     this.emit('socketError', err);
   }
 
@@ -294,6 +317,8 @@ class Connection extends EventEmitter {
       return;
     }
 
+    // TINKERPOP-2847: Use lower case to prevent string comparison issues.
+    response.requestId = response.requestId.toLowerCase();
     const handler = this._responseHandlers[response.requestId];
 
     if (!handler) {
@@ -356,7 +381,7 @@ class Connection extends EventEmitter {
   /**
    * clean websocket context
    */
-  _cleanupWebsocket() {
+  _cleanupWebsocket(err) {
     if (this._pingInterval) {
       clearInterval(this._pingInterval);
     }
@@ -366,6 +391,17 @@ class Connection extends EventEmitter {
     }
     this._pongTimeout = null;
 
+    // Invoke waiting callbacks to complete Promises when closing the websocket
+    Object.keys(this._responseHandlers).forEach((requestId) => {
+      const handler = this._responseHandlers[requestId];
+      const isStreamingResponse = handler.result instanceof Stream.Readable;
+      if (isStreamingResponse) {
+        handler.callback(null);
+      } else {
+        const cause = err ? err : new Error('Connection has been closed.');
+        handler.callback(cause);
+      }
+    });
     this._ws.removeAllListeners();
     this._openPromise = null;
     this._closePromise = null;

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

@@ -48,6 +48,10 @@ class DriverRemoteConnection extends RemoteConnection {
    * @param {GraphSONWriter} [options.writer] The writer to use.
    * @param {Authenticator} [options.authenticator] The authentication handler to use.
    * @param {Object} [options.headers] An associative array containing the additional header key/values for the initial request.
+   * @param {Boolean} [options.enableUserAgentOnConnect] Determines if a user agent will be sent during connection handshake. Defaults to: true
+   * @param {Boolean} [options.pingEnabled] Setup ping interval. Defaults to: true.
+   * @param {Number} [options.pingInterval] Ping request interval in ms if ping enabled. Defaults to: 60000.
+   * @param {Number} [options.pongTimeout] Timeout of pong response in ms after sending a ping. Defaults to: 30000.
    * @constructor
    */
   constructor(url, options = {}) {

package/lib/process/graph-traversal.js

@@ -94,17 +94,29 @@ class GraphTraversalSource {
    * @returns {GraphTraversalSource}
    */
   withComputer(graphComputer, workers, result, persist, vertices, edges, configuration) {
-    return this.withStrategies(
-      new VertexProgramStrategy({
-        graphComputer: graphComputer,
-        workers: workers,
-        result: result,
-        persist: persist,
-        vertices: vertices,
-        edges: edges,
-        configuration: configuration,
-      }),
-    );
+    const m = {};
+    if (graphComputer !== undefined) {
+      m.graphComputer = graphComputer;
+    }
+    if (workers !== undefined) {
+      m.workers = workers;
+    }
+    if (result !== undefined) {
+      m.result = result;
+    }
+    if (persist !== undefined) {
+      m.graphComputer = persist;
+    }
+    if (vertices !== undefined) {
+      m.vertices = vertices;
+    }
+    if (edges !== undefined) {
+      m.edges = edges;
+    }
+    if (configuration !== undefined) {
+      m.configuration = configuration;
+    }
+    return this.withStrategies(new VertexProgramStrategy(m));
   }
 
   /**

package/lib/process/traversal-strategy.js

@@ -295,7 +295,7 @@ class ReservedKeysVerificationStrategy extends TraversalStrategy {
    * @param {Array<String>} keys the list of reserved keys to verify
    */
   constructor(logWarnings = false, throwException = false, keys = ['id', 'label']) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy', {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReservedKeysVerificationStrategy', {
       logWarnings: logWarnings,
       throwException: throwException,
       keys: keys,

package/lib/process/traversal.js

@@ -496,10 +496,10 @@ module.exports = {
   barrier: toEnum('Barrier', 'normSack'),
   cardinality: toEnum('Cardinality', 'list set single'),
   column: toEnum('Column', 'keys values'),
-  direction: toEnum('Direction', 'BOTH IN OUT'),
+  direction: toEnum('Direction', 'BOTH IN OUT from_ to'),
   graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'),
   gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'),
-  merge: toEnum('Merge', 'onCreate onMatch'),
+  merge: toEnum('Merge', 'onCreate onMatch outV inV'),
   operator: toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'),
   order: toEnum('Order', 'asc desc shuffle'),
   pick: toEnum('Pick', 'any none'),

package/lib/structure/io/binary/GraphBinary.js

@@ -0,0 +1,109 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  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
+ *  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.
+ */
+
+/**
+ * GraphBinary 1.0 support implementation.
+ *
+ * The officially expected entrypoint is GraphBinaryReader/GraphBinaryWriter pair of classes,
+ * examine lib/driver/** for use cases.
+ *
+ * See AnySerializer.serialize() for the mechanism of serializer selection for a given JavaScript value,
+ * also consider AnySerializer.serialize() unit tests for real examples.
+ * See NumberSerializationStrategy to understand how it deals with JavaScript numbers' serialization.
+ *
+ * Consider AnySerializer.serialize()/deserialize() unit tests to see what is not implemented,
+ * what is ignored, what is not expected to be (de)serialized, etc.
+ *
+ * TODO: it has the following open topics:
+ * - [] Should we do anything for application/vnd.graphbinary-v1.0-stringd mime type support?
+ * Core Data Types support:
+ * - [] 0x22: BigDecimal
+ * - [] 0x2b: Tree
+ * - [] 0x2c: Metrics
+ * - [] 0x2d: TraversalMetrics
+ * - [] 0x00: Custom
+ * Extended Types support:
+ * - [] 0x80: Char
+ * - [] 0x81: Duration
+ * - [] 0x82: InetAddress
+ * - [] 0x83: Instant
+ * - [] 0x84: LocalDate
+ * - [] 0x85: LocalDateTime
+ * - [] 0x86: LocalTime
+ * - [] 0x87: MonthDay
+ * - [] 0x88: OffsetDateTime
+ * - [] 0x89: OffsetTime
+ * - [] 0x8a: Period
+ * - [] 0x8b: Year
+ * - [] 0x8c: YearMonth
+ * - [] 0x8d: ZonedDateTime
+ * - [] 0x8e: ZoneOffset
+ *
+ * @author Igor Ostapenko
+ */
+/*eslint-disable*/
+'use strict';
+
+const ioc = {};
+
+ioc.DataType = require('./internals/DataType');
+ioc.utils = require('./internals/utils');
+
+ioc.serializers = {};
+
+ioc.intSerializer               = new (require('./internals/IntSerializer'))(ioc);
+ioc.longSerializer              = new (require('./internals/LongSerializer'))(ioc);
+ioc.longSerializerNg            = new (require('./internals/LongSerializerNg'))(ioc);
+ioc.stringSerializer            = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.STRING);
+ioc.dateSerializer              = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.DATE);
+ioc.timestampSerializer         = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.TIMESTAMP);
+ioc.classSerializer             = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.CLASS);
+ioc.doubleSerializer            = new (require('./internals/DoubleSerializer'))(ioc);
+ioc.floatSerializer             = new (require('./internals/FloatSerializer'))(ioc);
+ioc.listSerializer              = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.LIST);
+ioc.mapSerializer               = new (require('./internals/MapSerializer'))(ioc);
+ioc.setSerializer               = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.SET);
+ioc.uuidSerializer              = new (require('./internals/UuidSerializer'))(ioc);
+ioc.edgeSerializer              = new (require('./internals/EdgeSerializer'))(ioc);
+ioc.pathSerializer              = new (require('./internals/PathSerializer'))(ioc);
+ioc.propertySerializer          = new (require('./internals/PropertySerializer'))(ioc);
+ioc.vertexSerializer            = new (require('./internals/VertexSerializer'))(ioc);
+ioc.vertexPropertySerializer    = new (require('./internals/VertexPropertySerializer'))(ioc);
+ioc.bytecodeSerializer          = new (require('./internals/BytecodeSerializer'))(ioc);
+ioc.pSerializer                 = new (require('./internals/PSerializer'))(ioc);
+ioc.traverserSerializer         = new (require('./internals/TraverserSerializer'))(ioc);
+ioc.enumSerializer              = new (require('./internals/EnumSerializer'))(ioc);
+ioc.lambdaSerializer            = new (require('./internals/LambdaSerializer'))(ioc);
+ioc.bigIntegerSerializer        = new (require('./internals/BigIntegerSerializer'))(ioc);
+ioc.byteSerializer              = new (require('./internals/ByteSerializer'))(ioc);
+ioc.byteBufferSerializer        = new (require('./internals/ByteBufferSerializer'))(ioc);
+ioc.shortSerializer             = new (require('./internals/ShortSerializer'))(ioc);
+ioc.booleanSerializer           = new (require('./internals/BooleanSerializer'))(ioc);
+ioc.textPSerializer             = new (require('./internals/TextPSerializer'))(ioc);
+ioc.traversalStrategySerializer = new (require('./internals/TraversalStrategySerializer'))(ioc);
+ioc.bulkSetSerializer           = new (require('./internals/BulkSetSerializer'))(ioc);
+ioc.unspecifiedNullSerializer   = new (require('./internals/UnspecifiedNullSerializer'))(ioc);
+
+ioc.numberSerializationStrategy = new (require('./internals/NumberSerializationStrategy'))(ioc);
+ioc.anySerializer               = new (require('./internals/AnySerializer'))(ioc);
+
+ioc.graphBinaryReader           = new (require('./internals/GraphBinaryReader.js'))(ioc);
+ioc.graphBinaryWriter           = new (require('./internals/GraphBinaryWriter'))(ioc);
+
+module.exports = ioc;

package/lib/structure/io/binary/internals/AnySerializer.js

@@ -0,0 +1,95 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  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
+ *  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.
+ */
+
+/**
+ * @author Igor Ostapenko
+ */
+'use strict';
+
+module.exports = class AnySerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+
+    // specifically ordered, the first canBeUsedFor=true wins
+    this.serializers = [
+      ioc.unspecifiedNullSerializer,
+
+      ioc.numberSerializationStrategy,
+
+      ioc.booleanSerializer,
+      ioc.dateSerializer,
+      ioc.bytecodeSerializer,
+      ioc.pSerializer,
+      ioc.traverserSerializer,
+      ioc.enumSerializer,
+      ioc.listSerializer,
+      ioc.uuidSerializer,
+      ioc.edgeSerializer,
+      ioc.pathSerializer,
+      ioc.propertySerializer,
+      ioc.vertexSerializer,
+      ioc.vertexPropertySerializer,
+      ioc.stringSerializer,
+      ioc.textPSerializer,
+      ioc.traversalStrategySerializer,
+
+      ioc.byteBufferSerializer, // Buffer instance
+      ioc.lambdaSerializer, // any function
+      ioc.mapSerializer, // Map or any Object
+    ];
+  }
+
+  getSerializerCanBeUsedFor(item) {
+    for (let i = 0; i < this.serializers.length; i++) {
+      if (this.serializers[i].canBeUsedFor(item)) {
+        return this.serializers[i];
+      }
+    }
+
+    throw new Error(
+      `No serializer found to support item where typeof(item)='${typeof item}' and String(item)='${String(item)}'.`,
+    );
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    return this.getSerializerCanBeUsedFor(item).serialize(item, fullyQualifiedFormat);
+  }
+
+  deserialize(buffer) {
+    // obviously, fullyQualifiedFormat always is true
+    try {
+      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+        throw new Error('buffer is missing');
+      }
+      if (buffer.length < 1) {
+        throw new Error('buffer is empty');
+      }
+
+      const type_code = buffer.readUInt8();
+      const serializer = this.ioc.serializers[type_code];
+      if (!serializer) {
+        throw new Error('unknown {type_code}');
+      }
+
+      return serializer.deserialize(buffer);
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, err });
+    }
+  }
+};

package/lib/structure/io/binary/internals/ArraySerializer.js

@@ -0,0 +1,135 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  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
+ *  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.
+ */
+
+/**
+ * @author Igor Ostapenko
+ */
+'use strict';
+
+module.exports = class ArraySerializer {
+  constructor(ioc, ID) {
+    this.ioc = ioc;
+    this.ID = ID;
+    this.ioc.serializers[ID] = this;
+  }
+
+  canBeUsedFor(value) {
+    return Array.isArray(value);
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ID, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ID, 0x00]));
+    }
+
+    // {length}
+    let length = item.length;
+    if (length < 0) {
+      length = 0; // TODO: test it
+    }
+    if (length > this.ioc.intSerializer.INT32_MAX) {
+      throw new Error(
+        `Array length=${length} is greater than supported max_length=${this.ioc.intSerializer.INT32_MAX}.`,
+      );
+    }
+    bufs.push(this.ioc.intSerializer.serialize(length, false));
+
+    // {item_0}...{item_n}
+    for (let i = 0; i < length; i++) {
+      bufs.push(this.ioc.anySerializer.serialize(item[i]));
+    }
+
+    return Buffer.concat(bufs);
+  }
+
+  deserialize(buffer, fullyQualifiedFormat = true) {
+    let len = 0;
+    let cursor = buffer;
+
+    try {
+      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+        throw new Error('buffer is missing');
+      }
+      if (buffer.length < 1) {
+        throw new Error('buffer is empty');
+      }
+
+      if (fullyQualifiedFormat) {
+        const type_code = cursor.readUInt8();
+        len++;
+        if (type_code !== this.ID) {
+          throw new Error('unexpected {type_code}');
+        }
+        cursor = cursor.slice(1);
+
+        if (cursor.length < 1) {
+          throw new Error('{value_flag} is missing');
+        }
+        const value_flag = cursor.readUInt8();
+        len++;
+        if (value_flag === 1) {
+          return { v: null, len };
+        }
+        if (value_flag !== 0) {
+          throw new Error('unexpected {value_flag}');
+        }
+        cursor = cursor.slice(1);
+      }
+
+      let length, length_len;
+      try {
+        ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+        len += length_len;
+      } catch (err) {
+        err.message = '{length}: ' + err.message;
+        throw err;
+      }
+      if (length < 0) {
+        throw new Error('{length} is less than zero');
+      }
+      cursor = cursor.slice(length_len);
+
+      const v = [];
+      for (let i = 0; i < length; i++) {
+        let value, value_len;
+        try {
+          ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+          len += value_len;
+        } catch (err) {
+          err.message = `{item_${i}}: ` + err.message;
+          throw err;
+        }
+        cursor = cursor.slice(value_len);
+        v.push(value);
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};