gremlin 3.5.3 → 3.5.4

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

@@ -0,0 +1,99 @@
+/*
+ *  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 ShortSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.SHORT] = this;
+  }
+
+  canBeUsedFor(value) {
+    // it's not expected to be used during serialization
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.SHORT, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.SHORT, 0x00]));
+    }
+    const v = Buffer.alloc(2);
+    v.writeInt16BE(item); // TODO: what if item is not within int16 limits, for now writeInt16BE would 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.SHORT) {
+          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 < 2) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 2;
+
+      const v = cursor.readInt16BE();
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,114 @@
+/*
+ *  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 StringSerializer {
+  constructor(ioc, ID) {
+    this.ioc = ioc;
+    this.ID = ID;
+    this.ioc.serializers[ID] = this;
+  }
+
+  canBeUsedFor(value) {
+    return typeof value === 'string';
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ID, 0x01]);
+      }
+      return this.ioc.intSerializer.serialize(0, false);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ID, 0x00]));
+    }
+    const v = Buffer.from(String(item), 'utf8');
+    bufs.push(this.ioc.intSerializer.serialize(v.length, false)); // TODO: what if len > INT32_MAX, for now it's backed by logic of IntSerializer.serialize itself
+    bufs.push(v);
+
+    return Buffer.concat(bufs);
+  }
+
+  deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
+    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 (fullyQualifiedFormat || nullable) {
+        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 (cursor.length < length) {
+        throw new Error('unexpected {text_value} length');
+      }
+      len += length;
+
+      const v = cursor.toString('utf8', 0, length);
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,145 @@
+/*
+ *  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 TextPSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.TEXTP] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof t.TextP;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.TEXTP, 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.TEXTP, 0x00]));
+    }
+
+    // {name} is a String
+    bufs.push(this.ioc.stringSerializer.serialize(item.operator, false));
+
+    // {values_length}{value_0}...{value_n}
+    // It tries to resemble the same if-else structure as
+    // GraphSON.TextPSerializer.serialize() does.
+    let list;
+    if (item.other === undefined || item.other === null) {
+      // follows the same idea as for t.P
+      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.TEXTP) {
+          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.TextP(''), len };
+      }
+
+      let v;
+      const TextP_static = t.TextP[name];
+      if (typeof TextP_static === 'function') {
+        v = TextP_static(...values); // it's better to follow existing logic which may depend on an operator name
+      } else {
+        v = new t.TextP(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/TraversalStrategySerializer.js

@@ -0,0 +1,72 @@
+/*
+ *  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 { TraversalStrategySerializer: GraphsonTraversalStrategySerializer } = require('../../type-serializers');
+
+module.exports = class TraversalStrategySerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    // this.ioc.serializers[ioc.DataType.TRAVERSALSTRATEGY] = this; // TODO: it's not expected to be deserialized
+    this.graphsonTraversalStrategySerializer = new GraphsonTraversalStrategySerializer();
+  }
+
+  canBeUsedFor(value) {
+    return this.graphsonTraversalStrategySerializer.canBeUsedFor(value);
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.TRAVERSALSTRATEGY, 0x01]);
+      }
+      const strategy_class = [0x00, 0x00, 0x00, 0x00]; // ''
+      const configuration = [0x00, 0x00, 0x00, 0x00]; // {}
+      return Buffer.from([...strategy_class, ...configuration]);
+      // TODO: should we delegate these to respective serializers like classSerializer.serialize(undefined, false) ?
+      // Consider to make it the same way for all other serializers
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.TRAVERSALSTRATEGY, 0x00]));
+    }
+
+    // let's repeat the logic of Graphson's TraversalStrategySerializer:
+    const strategy_class = item.fqcn;
+    const conf = {};
+    for (const k in item.configuration) {
+      if (item.configuration.hasOwnProperty(k)) {
+        conf[k] = item.configuration[k];
+      }
+    }
+
+    // {strategy_class}
+    bufs.push(this.ioc.classSerializer.serialize(strategy_class, false));
+
+    // {configuration}
+    bufs.push(this.ioc.mapSerializer.serialize(conf, false));
+
+    return Buffer.concat(bufs);
+  }
+};

package/lib/structure/io/binary/internals/TraverserSerializer.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 t = require('../../../../process/traversal');
+
+module.exports = class TraverserSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.TRAVERSER] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof t.Traverser;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.TRAVERSER, 0x01]);
+      }
+      const bulk = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]; // 1
+      const value = [0xfe, 0x01]; // null
+      return Buffer.from([...bulk, ...value]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.TRAVERSER, 0x00]));
+    }
+
+    // {bulk}
+    bufs.push(this.ioc.longSerializer.serialize(item.bulk, false));
+    // {value}
+    bufs.push(this.ioc.anySerializer.serialize(item.object));
+
+    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.TRAVERSER) {
+          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 bulk, bulk_len;
+      try {
+        ({ v: bulk, len: bulk_len } = this.ioc.longSerializer.deserialize(cursor, false));
+        len += bulk_len;
+      } catch (err) {
+        err.message = '{bulk}: ' + err.message;
+        throw err;
+      }
+      if (bulk < 0) {
+        throw new Error('{bulk} is less than zero');
+      }
+      cursor = cursor.slice(bulk_len);
+
+      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);
+
+      const v = new t.Traverser(value, bulk);
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,75 @@
+/*
+ *  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 UnspecifiedNullSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.UNSPECIFIED_NULL] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value === null || value === undefined;
+  }
+
+  serialize(item) {
+    // fullyQualifiedFormat always is true
+    return Buffer.from([this.ioc.DataType.UNSPECIFIED_NULL, 0x01]);
+  }
+
+  deserialize(buffer) {
+    // fullyQualifiedFormat always is 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');
+      }
+
+      const type_code = cursor.readUInt8();
+      len++;
+      if (type_code !== this.ioc.DataType.UNSPECIFIED_NULL) {
+        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) {
+        throw new Error('unexpected {value_flag}');
+      }
+      cursor = cursor.slice(1);
+
+      return { v: null, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};