gremlin 3.5.3 → 3.5.4

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

@@ -0,0 +1,124 @@
+/*
+ *  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 BulkSetSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BULKSET] = this;
+  }
+
+  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.BULKSET) {
+          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 < 0) {
+        throw new Error('{length} is less than zero');
+      }
+      cursor = cursor.slice(length_len);
+
+      // Official GraphBinary 1.0 spec:
+      // If the implementing language does not have a BulkSet object to deserialize into,
+      // this format can be coerced to a List and still be considered compliant with Gremlin.
+      // Simply "expand the bulk" by adding the item to the List the number of times specified by the bulk.
+
+      // {item_0}...{item_n}
+      let v = new Array();
+      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}} value: ` + err.message;
+          throw err;
+        }
+        cursor = cursor.slice(value_len);
+
+        let bulk, bulk_len;
+        try {
+          ({ v: bulk, len: bulk_len } = this.ioc.longSerializer.deserialize(cursor, false));
+          len += bulk_len;
+        } catch (err) {
+          err.message = `{item_${i}} bulk: ` + err.message;
+          throw err;
+        }
+        if (bulk < 0) {
+          throw new Error(`{item_${i}}: bulk is less than zero`);
+        }
+        if (bulk > 4294967295) {
+          // arrayLength of Array() constructor is expected to be an integer between 0 and 2^32 - 1
+          throw new Error(`{item_${i}}: bulk is greater than 2^32-1`);
+        }
+        cursor = cursor.slice(bulk_len);
+
+        bulk = Number(bulk); // coersion to Number is required for BigInt if LongSerializerNg is used
+        const item = new Array(bulk).fill(value);
+        v = v.concat(item);
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,124 @@
+/*
+ *  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 ByteBufferSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BYTEBUFFER] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof Buffer;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.BYTEBUFFER, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.BYTEBUFFER, 0x00]));
+    }
+
+    // {length}
+    let length = item.length;
+    if (length < 0) {
+      length = 0; // TODO: test it
+    }
+    if (length > this.ioc.intSerializer.INT32_MAX) {
+      throw new Error(
+        `Buffer length=${length} is greater than supported max_length=${this.ioc.intSerializer.INT32_MAX}.`,
+      );
+    }
+    bufs.push(this.ioc.intSerializer.serialize(length, false));
+
+    // {value} sequence of bytes
+    bufs.push(item);
+
+    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.BYTEBUFFER) {
+          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);
+
+      if (length !== cursor.length) {
+        throw new Error(`{value}: unexpected actual {value} length=${cursor.length} when {length}=${length}`);
+      }
+      const v = cursor.slice(0, length);
+      len += length;
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

package/lib/structure/io/binary/internals/ByteSerializer.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 ByteSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BYTE] = this;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.BYTE, 0x01]);
+      }
+      return Buffer.from([0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.BYTE, 0x00]));
+    }
+    const v = Buffer.alloc(1);
+    v.writeUInt8(item); // if item is not within uint8 limits writeUInt8 will error
+    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.BYTE) {
+          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;
+
+      const v = cursor.readUInt8();
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,249 @@
+/*
+ *  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 Bytecode = require('../../../../process/bytecode');
+const t = require('../../../../process/traversal');
+
+module.exports = class BytecodeSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.BYTECODE] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof Bytecode || value instanceof t.Traversal;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.BYTECODE, 0x01]);
+      }
+      const steps_length = [0x00, 0x00, 0x00, 0x00]; // 0
+      const sources_length = [0x00, 0x00, 0x00, 0x00]; // 0
+      return Buffer.from([...steps_length, ...sources_length]);
+    }
+
+    if (item instanceof t.Traversal) {
+      item = item.getBytecode();
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.BYTECODE, 0x00]));
+    }
+
+    // {steps_length}{step_0}...{step_n}
+    bufs.push(this.ioc.intSerializer.serialize(item.stepInstructions.length, false)); // TODO: what if steps_length > INT32_MAX
+    for (let i = 0; i < item.stepInstructions.length; i++) {
+      // {step_i} is composed of {name}{values_length}{value_0}...{value_n}
+      const step = item.stepInstructions[i];
+      const name = step[0];
+      const values_length = step.length - 1;
+      bufs.push(this.ioc.stringSerializer.serialize(name, false));
+      bufs.push(this.ioc.intSerializer.serialize(values_length, false));
+      for (let j = 0; j < values_length; j++) {
+        bufs.push(this.ioc.anySerializer.serialize(step[1 + j], true));
+      }
+    }
+
+    // {sources_length}{source_0}...{source_n}
+    bufs.push(this.ioc.intSerializer.serialize(item.sourceInstructions.length, false)); // TODO: what if sources_length > INT32_MAX
+    for (let i = 0; i < item.sourceInstructions.length; i++) {
+      // {source_i} is composed of {name}{values_length}{value_0}...{value_n}
+      const source = item.sourceInstructions[i];
+      const name = source[0];
+      const values_length = source.length - 1;
+      bufs.push(this.ioc.stringSerializer.serialize(name, false));
+      bufs.push(this.ioc.intSerializer.serialize(values_length, false));
+      for (let j = 0; j < values_length; j++) {
+        bufs.push(this.ioc.anySerializer.serialize(source[1 + j], true));
+      }
+    }
+
+    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.BYTECODE) {
+          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);
+      }
+
+      const v = new Bytecode();
+
+      // steps
+
+      let steps_length, steps_length_len;
+      try {
+        ({ v: steps_length, len: steps_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+        len += steps_length_len;
+      } catch (err) {
+        err.message = '{steps_length}: ' + err.message;
+        throw err;
+      }
+      if (steps_length < 0) {
+        throw new Error('{steps_length} is less than zero');
+      }
+      cursor = cursor.slice(steps_length_len);
+
+      // {step_i} is composed of {name}{values_length}{value_0}...{value_n}
+      for (let i = 0; i < steps_length; i++) {
+        // {name} is a String
+        let name, name_len;
+        try {
+          ({ v: name, len: name_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+          len += name_len;
+        } catch (err) {
+          err.message = `{step_${i}} {name}: ` + err.message;
+          throw err;
+        }
+        cursor = cursor.slice(name_len);
+
+        // {values_length} is an Int describing the amount values
+        let values_length, values_length_len;
+        try {
+          ({ v: values_length, len: values_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+          len += values_length_len;
+        } catch (err) {
+          err.message = `{step_${i}} {values_length}: ` + err.message;
+          throw err;
+        }
+        if (values_length < 0) {
+          throw new Error(`{step_${i}} {values_length} is less than zero`);
+        }
+        cursor = cursor.slice(values_length_len);
+
+        // {value_i} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} describing the step argument
+        const values = [];
+        let value, value_len;
+        for (let j = 0; j < values_length; j++) {
+          try {
+            ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+            len += value_len;
+            values.push(value);
+          } catch (err) {
+            err.message = `{step_${i}} {value_${j}}: ` + err.message;
+            throw err;
+          }
+          cursor = cursor.slice(value_len);
+        }
+
+        v.addStep(name, values);
+      }
+
+      // sources
+
+      let sources_length, sources_length_len;
+      try {
+        ({ v: sources_length, len: sources_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+        len += sources_length_len;
+      } catch (err) {
+        err.message = '{sources_length}: ' + err.message;
+        throw err;
+      }
+      if (sources_length < 0) {
+        throw new Error('{sources_length} is less than zero');
+      }
+      cursor = cursor.slice(sources_length_len);
+
+      // {source_i} is composed of {name}{values_length}{value_0}...{value_n}
+      for (let i = 0; i < sources_length; i++) {
+        // {name} is a String
+        let name, name_len;
+        try {
+          ({ v: name, len: name_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+          len += name_len;
+        } catch (err) {
+          err.message = `{source_${i}} {name}: ` + err.message;
+          throw err;
+        }
+        cursor = cursor.slice(name_len);
+
+        // {values_length} is an Int describing the amount values
+        let values_length, values_length_len;
+        try {
+          ({ v: values_length, len: values_length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+          len += values_length_len;
+        } catch (err) {
+          err.message = `{source_${i}} {values_length}: ` + err.message;
+          throw err;
+        }
+        if (values_length < 0) {
+          throw new Error(`{source_${i}} {values_length} is less than zero`);
+        }
+        cursor = cursor.slice(values_length_len);
+
+        // {value_i} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+        const values = [];
+        let value, value_len;
+        for (let j = 0; j < values_length; j++) {
+          try {
+            ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+            len += value_len;
+            values.push(value);
+          } catch (err) {
+            err.message = `{source_${i}} {value_${j}}: ` + err.message;
+            throw err;
+          }
+          cursor = cursor.slice(value_len);
+        }
+
+        v.addSource(name, values);
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,97 @@
+/*
+ *  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';
+
+/**
+ * Represents a GraphBinary data type.
+ *
+ * See org.apache.tinkerpop.gremlin.structure.io.binary.DataType Java class.
+ */
+const DataType = {
+  INT: 0x01,
+  LONG: 0x02,
+  STRING: 0x03,
+  DATE: 0x04,
+  TIMESTAMP: 0x05,
+  CLASS: 0x06,
+  DOUBLE: 0x07,
+  FLOAT: 0x08,
+  LIST: 0x09,
+  MAP: 0x0a,
+  SET: 0x0b,
+  UUID: 0x0c,
+  EDGE: 0x0d,
+  PATH: 0x0e,
+  PROPERTY: 0x0f,
+  GRAPH: 0x10,
+  VERTEX: 0x11,
+  VERTEXPROPERTY: 0x12,
+  BARRIER: 0x13,
+  BINDING: 0x14,
+  BYTECODE: 0x15,
+  CARDINALITY: 0x16,
+  COLUMN: 0x17,
+  DIRECTION: 0x18,
+  OPERATOR: 0x19,
+  ORDER: 0x1a,
+  PICK: 0x1b,
+  POP: 0x1c,
+  LAMBDA: 0x1d,
+  P: 0x1e,
+  SCOPE: 0x1f,
+  T: 0x20,
+  TRAVERSER: 0x21,
+  BIGDECIMAL: 0x22,
+  BIGINTEGER: 0x23,
+  BYTE: 0x24,
+  BYTEBUFFER: 0x25,
+  SHORT: 0x26,
+  BOOLEAN: 0x27,
+  TEXTP: 0x28,
+  TRAVERSALSTRATEGY: 0x29,
+  BULKSET: 0x2a,
+  TREE: 0x2b,
+  METRICS: 0x2c,
+  TRAVERSALMETRICS: 0x2d,
+
+  CHAR: 0x80,
+  DURATION: 0x81,
+  INETADDRESS: 0x82,
+  INSTANT: 0x83,
+  LOCALDATE: 0x84,
+  LOCALDATETIME: 0x85,
+  LOCALTIME: 0x86,
+  MONTHDAY: 0x87,
+  OFFSETDATETIME: 0x88,
+  OFFSETTIME: 0x89,
+  PERIOD: 0x8a,
+  YEAR: 0x8b,
+  YEARMONTH: 0x8c,
+  ZONEDATETIME: 0x8d,
+  ZONEOFFSET: 0x8e,
+
+  CUSTOM: 0,
+  UNSPECIFIED_NULL: 0xfe,
+};
+
+module.exports = DataType;