gremlin 3.5.1 → 3.5.4

package/lib/structure/io/binary/internals/VertexSerializer.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';
+
+const g = require('../../../graph');
+
+module.exports = class VertexSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.VERTEX] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof g.Vertex;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.VERTEX, 0x01]);
+      }
+      const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+      const label = [0x00, 0x00, 0x00, 0x00]; // ''
+      const properties = [0xfe, 0x01]; // null
+      return Buffer.from([...id, ...label, ...properties]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.VERTEX, 0x00]));
+    }
+
+    // {id}
+    bufs.push(this.ioc.anySerializer.serialize(item.id));
+
+    // {label}
+    bufs.push(this.ioc.stringSerializer.serialize(item.label, false));
+
+    // {properties}
+    bufs.push(this.ioc.anySerializer.serialize(item.properties));
+
+    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.ioc.DataType.VERTEX) {
+          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 id, id_len;
+      try {
+        ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += id_len;
+      } catch (err) {
+        err.message = '{id}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(id_len);
+
+      let label, label_len;
+      try {
+        ({ v: label, len: label_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+        len += label_len;
+      } catch (err) {
+        err.message = '{label}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(label_len);
+
+      let properties, properties_len;
+      try {
+        ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += properties_len;
+      } catch (err) {
+        err.message = '{properties}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(properties_len);
+
+      const v = new g.Vertex(id, label, properties);
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,59 @@
+/*
+ *  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';
+
+/*
+ * Deserialization error general constructor.
+ */
+const des_error = ({ serializer, args, cursor, err }) => {
+  if (cursor === undefined) {
+    cursor = args[0]; // buffer
+  }
+  let cursor_tail = '';
+  if (cursor instanceof Buffer) {
+    if (cursor.length > 32) {
+      cursor_tail = '...';
+    }
+    cursor = cursor.slice(0, 32).toString('hex');
+  }
+
+  const fullyQualifiedFormat = args[1];
+  const nullable = args[2];
+
+  let m = `${serializer.constructor.name}.deserialize(cursor=${cursor}${cursor_tail}`;
+  if (fullyQualifiedFormat !== undefined) {
+    m += `, fullyQualifiedFormat=${fullyQualifiedFormat}`;
+  }
+  if (nullable !== undefined) {
+    m += `, nullable=${nullable}`;
+  }
+  m += `): ${err.message.replace(/\.$/, '')}.`;
+
+  err.message = m;
+
+  return err;
+};
+
+module.exports = {
+  des_error,
+};

package/lib/structure/io/graph-serializer.js

@@ -23,12 +23,12 @@
 'use strict';
 
 const typeSerializers = require('./type-serializers');
+const Bytecode = require('../../process/bytecode');
 
 /**
  * GraphSON2 writer.
  */
 class GraphSON2Writer {
-
   /**
    * @param {Object} [options]
    * @param {Object} [options.serializers] An object used as an associative array with GraphSON 2 type name as keys and
@@ -38,7 +38,7 @@ class GraphSON2Writer {
   constructor(options) {
     this._options = options || {};
     // Create instance of the default serializers
-    this._serializers = this.getDefaultSerializers().map(serializerConstructor => {
+    this._serializers = this.getDefaultSerializers().map((serializerConstructor) => {
       const s = new serializerConstructor();
       s.writer = this;
       return s;
@@ -46,7 +46,7 @@ class GraphSON2Writer {
 
     const customSerializers = this._options.serializers || {};
 
-    Object.keys(customSerializers).forEach(key => {
+    Object.keys(customSerializers).forEach((key) => {
       const s = customSerializers[key];
       if (!s.serialize) {
         return;
@@ -83,7 +83,7 @@ class GraphSON2Writer {
     if (Array.isArray(value)) {
       // We need to handle arrays when there is no serializer
       // for older versions of GraphSON
-      return value.map(item => this.adaptObject(item));
+      return value.map((item) => this.adaptObject(item));
     }
 
     // Default (strings / objects / ...)
@@ -98,6 +98,48 @@ class GraphSON2Writer {
   write(obj) {
     return JSON.stringify(this.adaptObject(obj));
   }
+
+  writeRequest({ requestId, op, processor, args }) {
+    const req = {
+      requestId: { '@type': 'g:UUID', '@value': requestId },
+      op,
+      processor,
+      args: this._adaptArgs(args, true),
+    };
+
+    if (req.args['gremlin'] instanceof Bytecode) {
+      req.args['gremlin'] = this.adaptObject(req.args['gremlin']);
+    }
+
+    return Buffer.from(JSON.stringify(req));
+  }
+
+  /**
+   * Takes the given args map and ensures all arguments are passed through to 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) {
+      const 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.adaptObject(args[key]);
+        }
+      });
+
+      return newObj;
+    }
+
+    return args;
+  }
 }
 
 /**
@@ -125,7 +167,7 @@ class GraphSON2Reader {
     this._deserializers = {};
 
     const defaultDeserializers = this.getDefaultDeserializers();
-    Object.keys(defaultDeserializers).forEach(typeName => {
+    Object.keys(defaultDeserializers).forEach((typeName) => {
       const serializerConstructor = defaultDeserializers[typeName];
       const s = new serializerConstructor();
       s.reader = this;
@@ -134,7 +176,7 @@ class GraphSON2Reader {
 
     if (this._options.serializers) {
       const customSerializers = this._options.serializers || {};
-      Object.keys(customSerializers).forEach(key => {
+      Object.keys(customSerializers).forEach((key) => {
         const s = customSerializers[key];
         if (!s.deserialize) {
           return;
@@ -161,7 +203,7 @@ class GraphSON2Reader {
       return null;
     }
     if (Array.isArray(obj)) {
-      return obj.map(item => this.read(item));
+      return obj.map((item) => this.read(item));
     }
     const type = obj[typeSerializers.typeKey];
     if (type) {
@@ -179,6 +221,10 @@ class GraphSON2Reader {
     return obj;
   }
 
+  readResponse(buffer) {
+    return this.read(JSON.parse(buffer.toString()));
+  }
+
   _deserializeObject(obj) {
     const keys = Object.keys(obj);
     const result = {};
@@ -201,9 +247,9 @@ class GraphSON3Reader extends GraphSON2Reader {
 const graphSON2Deserializers = {
   'g:Traverser': typeSerializers.TraverserSerializer,
   'g:TraversalStrategy': typeSerializers.TraversalStrategySerializer,
-  'g:Int32':  typeSerializers.NumberSerializer,
-  'g:Int64':  typeSerializers.NumberSerializer,
-  'g:Float':  typeSerializers.NumberSerializer,
+  'g:Int32': typeSerializers.NumberSerializer,
+  'g:Int64': typeSerializers.NumberSerializer,
+  'g:Float': typeSerializers.NumberSerializer,
   'g:Double': typeSerializers.NumberSerializer,
   'g:Date': typeSerializers.DateSerializer,
   'g:Direction': typeSerializers.DirectionSerializer,
@@ -214,13 +260,13 @@ const graphSON2Deserializers = {
   'g:Path': typeSerializers.Path3Serializer,
   'g:TextP': typeSerializers.TextPSerializer,
   'g:T': typeSerializers.TSerializer,
-  'g:BulkSet': typeSerializers.BulkSetSerializer
+  'g:BulkSet': typeSerializers.BulkSetSerializer,
 };
 
 const graphSON3Deserializers = Object.assign({}, graphSON2Deserializers, {
   'g:List': typeSerializers.ListSerializer,
   'g:Set': typeSerializers.SetSerializer,
-  'g:Map': typeSerializers.MapSerializer
+  'g:Map': typeSerializers.MapSerializer,
 });
 
 const graphSON2Serializers = [
@@ -235,13 +281,13 @@ const graphSON2Serializers = [
   typeSerializers.EnumSerializer,
   typeSerializers.VertexSerializer,
   typeSerializers.EdgeSerializer,
-  typeSerializers.LongSerializer
+  typeSerializers.LongSerializer,
 ];
 
 const graphSON3Serializers = graphSON2Serializers.concat([
   typeSerializers.ListSerializer,
   typeSerializers.SetSerializer,
-  typeSerializers.MapSerializer
+  typeSerializers.MapSerializer,
 ]);
 
 module.exports = {
@@ -250,5 +296,5 @@ module.exports = {
   GraphSON2Writer,
   GraphSON2Reader,
   GraphSONWriter: GraphSON3Writer,
-  GraphSONReader: GraphSON3Reader
-};
+  GraphSONReader: GraphSON3Reader,
+};