gremlin 3.5.3 → 3.5.4

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 });
+    }
+  }
+};

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

@@ -0,0 +1,151 @@
+/*
+ *  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';
+
+// TODO: it has room for performance improvements
+module.exports = class BigIntegerSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BIGINTEGER] = this;
+  }
+
+  canBeUsedFor(value) {
+    // it's not expected to be used directly, see NumberSerializationStrategy
+    return typeof value === 'bigint';
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.BIGINTEGER, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x01, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.BIGINTEGER, 0x00]));
+    }
+
+    let v;
+
+    // positive number
+    if (item >= 0) {
+      let hex_str = item.toString(16);
+      if (hex_str.length % 2 !== 0) {
+        hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+      }
+      if (Number.parseInt(hex_str[0], 16) > 7) {
+        hex_str = '00' + hex_str; // to keep sign bit unset for positive number
+      }
+      v = Buffer.from(hex_str, 'hex');
+    }
+
+    // negative number
+    else {
+      let hex_str = (-item).toString(16);
+
+      const bytes = (hex_str.length + (hex_str.length % 2)) / 2; // number's size in bytes
+      let N = BigInt(bytes) * BigInt(8); // number's size in bits
+      const INTN_MIN = -(BigInt(2) ** (N - BigInt(1))); // minimum negative number we can keep within N bits
+      if (item < INTN_MIN) {
+        N += BigInt(8); // to provide room for smaller negative number
+      }
+
+      const twos_complement = BigInt(2) ** N + item;
+      hex_str = twos_complement.toString(16);
+      if (hex_str.length % 2 !== 0) {
+        hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+      }
+
+      v = Buffer.from(hex_str, 'hex');
+    }
+
+    bufs.push(this.ioc.intSerializer.serialize(v.length, false));
+    bufs.push(v);
+
+    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.BIGINTEGER) {
+          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);
+      }
+
+      // {length}
+      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 < 1) {
+        throw new Error(`{length}=${length} is less than one`);
+      }
+      cursor = cursor.slice(length_len);
+
+      len += length;
+      cursor = cursor.slice(0, length);
+      let v = BigInt(`0x${cursor.toString('hex')}`);
+      const is_sign_bit_set = (cursor[0] & 0x80) === 0x80;
+      if (is_sign_bit_set) {
+        v = BigInt.asIntN(length * 8, v); // now we get expected negative number
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,103 @@
+/*
+ *  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 BooleanSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BOOLEAN] = this;
+  }
+
+  canBeUsedFor(value) {
+    return typeof value === 'boolean';
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.BOOLEAN, 0x01]);
+      }
+      return Buffer.from([0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.BOOLEAN, 0x00]));
+    }
+
+    bufs.push(Buffer.from([item ? 0x01 : 0x00]));
+
+    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.BOOLEAN) {
+          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);
+      }
+
+      if (cursor.length < 1) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 1;
+
+      let v = cursor.readUInt8();
+      if (v !== 0x00 && v !== 0x01) {
+        throw new Error(`unexpected boolean byte=${v}`);
+      }
+      v = v === 0x01;
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};