gremlin 3.5.3 → 3.5.4

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

@@ -0,0 +1,153 @@
+/*
+ *  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 MapSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.MAP] = this;
+  }
+
+  canBeUsedFor(value) {
+    if (value === null || value === undefined) {
+      return false;
+    }
+    if (value instanceof Map) {
+      return true;
+    }
+    if (Array.isArray(value)) {
+      return false;
+    }
+
+    return typeof value === 'object';
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.MAP, 0x01]);
+      }
+      return this.ioc.intSerializer.serialize(0, false);
+    }
+
+    const isMap = item instanceof Map;
+
+    const keys = isMap ? Array.from(item.keys()) : Object.keys(item);
+    let map_length = keys.length;
+    if (map_length < 0) {
+      map_length = 0;
+    } else if (map_length > this.ioc.intSerializer.INT32_MAX) {
+      map_length = this.ioc.intSerializer.INT32_MAX; // TODO: is it expected to be silenced? or it's better to error instead?
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.MAP, 0x00]));
+    }
+    bufs.push(this.ioc.intSerializer.serialize(map_length, false));
+    for (let i = 0; i < map_length; i++) {
+      const key = keys[i];
+      const value = isMap ? item.get(key) : item[key];
+      bufs.push(this.ioc.anySerializer.serialize(key), this.ioc.anySerializer.serialize(value));
+    }
+    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.MAP) {
+          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 = new Map();
+      for (let i = 0; i < length; i++) {
+        let key, key_len;
+        try {
+          ({ v: key, len: key_len } = this.ioc.anySerializer.deserialize(cursor));
+          len += key_len;
+        } catch (err) {
+          err.message = `{item_${i}} key: ` + err.message;
+          throw err;
+        }
+        cursor = cursor.slice(key_len);
+
+        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);
+
+        v.set(key, value);
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,68 @@
+/*
+ *  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';
+
+// Based on GraphSON NumberSerializer.serialize().
+// It's tested by AnySerializer.serialize() tests.
+module.exports = class NumberSerializationStrategy {
+  constructor(ioc) {
+    this.ioc = ioc;
+  }
+
+  canBeUsedFor(value) {
+    if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
+      return true;
+    }
+    if (typeof value === 'number') {
+      return true;
+    }
+    if (typeof value === 'bigint') {
+      return true;
+    }
+
+    return false;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (typeof item === 'number') {
+      if (
+        Number.isNaN(item) ||
+        item === Number.POSITIVE_INFINITY ||
+        item === Number.NEGATIVE_INFINITY ||
+        !Number.isInteger(item)
+      ) {
+        return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
+      }
+
+      if (item >= -2147483648 && item <= 2147483647) {
+        // INT32_MIN/MAX
+        return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
+      }
+      return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+    }
+
+    if (typeof item === 'bigint') {
+      return this.ioc.bigIntegerSerializer.serialize(item, fullyQualifiedFormat);
+    }
+  }
+};

package/lib/structure/io/binary/internals/PSerializer.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';
+
+const t = require('../../../../process/traversal');
+
+module.exports = class PSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.P] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof t.P;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.P, 0x01]);
+      }
+      const name = [0x00, 0x00, 0x00, 0x00]; // ''
+      const values_length = [0x00, 0x00, 0x00, 0x00]; // 0
+      return Buffer.from([...name, ...values_length]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.P, 0x00]));
+    }
+
+    // {name}
+    bufs.push(this.ioc.stringSerializer.serialize(item.operator, false));
+
+    // {values_length}{value_0}...{value_n}
+    //
+    // This is a tricky part due to the nature of t.P.
+    // GraphBinary states that {name} is followed by list only,
+    // but t.P may be constructed such way that its item.value can be
+    // a usual string or something, that's why we should care here
+    // to get it wrapped into a list.
+    //
+    // It tries to resemble the same if-else structure as
+    // GraphSON.PSerializer.serialize() does.
+    let list;
+    if (item.other === undefined || item.other === null) {
+      if (Array.isArray(item.value)) {
+        list = item.value;
+      } else {
+        list = [item.value];
+      }
+    } else {
+      list = [item.value, item.other];
+    }
+    bufs.push(this.ioc.listSerializer.serialize(list, false));
+
+    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.P) {
+          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 name, name_len;
+      try {
+        ({ v: name, len: name_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+        len += name_len;
+      } catch (err) {
+        err.message = '{name}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(name_len);
+
+      let values, values_len;
+      try {
+        ({ v: values, len: values_len } = this.ioc.listSerializer.deserialize(cursor, false));
+        len += values_len;
+      } catch (err) {
+        err.message = '{values}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(values_len);
+
+      if (values.length < 1) {
+        return { v: new t.P(''), len };
+      }
+
+      let v;
+      const P_static = t.P[name];
+      if (typeof P_static === 'function') {
+        v = P_static(...values); // it's better to follow existing logic which may depend on an operator name
+      } else {
+        v = new t.P(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/PathSerializer.js

@@ -0,0 +1,123 @@
+/*
+ *  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 PathSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.PATH] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof g.Path;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.PATH, 0x01]);
+      }
+      return Buffer.concat([
+        this.ioc.listSerializer.serialize([]), // {labels}=[]
+        this.ioc.listSerializer.serialize([]), // {objects}=[]
+      ]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.PATH, 0x00]));
+    }
+
+    // {labels} is a List in which each item is a Set of String
+    bufs.push(this.ioc.listSerializer.serialize(item.labels));
+
+    // {objects} is a List of fully qualified typed values
+    bufs.push(this.ioc.listSerializer.serialize(item.objects));
+
+    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.PATH) {
+          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 labels, labels_len;
+      try {
+        ({ v: labels, len: labels_len } = this.ioc.listSerializer.deserialize(cursor));
+        len += labels_len;
+      } catch (err) {
+        err.message = '{labels}: ' + err.message;
+        throw err;
+      }
+      // TODO: should we check content of labels to make sure it's List< Set<String> > ?
+      cursor = cursor.slice(labels_len);
+
+      let objects, objects_len;
+      try {
+        ({ v: objects, len: objects_len } = this.ioc.listSerializer.deserialize(cursor));
+        len += objects_len;
+      } catch (err) {
+        err.message = '{objects}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(objects_len);
+
+      const v = new g.Path(labels, objects);
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,141 @@
+/*
+ *  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 PropertySerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.PROPERTY] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof g.Property;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.PROPERTY, 0x01]);
+      }
+      return Buffer.concat([
+        this.ioc.stringSerializer.serialize('', false), // {key}=''
+        this.ioc.unspecifiedNullSerializer.serialize(null), // {value}=null
+        this.ioc.unspecifiedNullSerializer.serialize(null), // {parent}=null
+      ]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.PROPERTY, 0x00]));
+    }
+
+    // {key}
+    bufs.push(this.ioc.stringSerializer.serialize(item.key, false));
+
+    // {value}
+    bufs.push(this.ioc.anySerializer.serialize(item.value));
+
+    // {parent}
+    bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+
+    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.PROPERTY) {
+          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);
+      }
+
+      // {key} is a String value
+      let key, key_len;
+      try {
+        ({ v: key, len: key_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+        len += key_len;
+      } catch (err) {
+        err.message = '{key}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(key_len);
+
+      // {value} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+      let value, value_len;
+      try {
+        ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += value_len;
+      } catch (err) {
+        err.message = '{value}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(value_len);
+
+      // {parent} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} which is either an Edge or VertexProperty.
+      // Note that as TinkerPop currently sends "references" only this value will always be null.
+      let parent_len;
+      try {
+        ({ len: parent_len } = this.ioc.unspecifiedNullSerializer.deserialize(cursor));
+        len += parent_len;
+      } catch (err) {
+        err.message = '{parent}: ' + err.message;
+        throw err;
+      }
+      // TODO: should we verify that parent is null?
+      cursor = cursor.slice(parent_len);
+
+      const v = new g.Property(key, value);
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};