gremlin 3.5.3 → 3.5.4

package/lib/structure/io/binary/internals/DateSerializer.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 DateSerializer {
+  constructor(ioc, ID) {
+    this.ioc = ioc;
+    this.ID = ID;
+    this.ioc.serializers[ID] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof Date;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ID, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ID, 0x00]));
+    }
+
+    const v = Buffer.alloc(8);
+    v.writeBigInt64BE(BigInt(item.getTime()));
+    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.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);
+      }
+
+      if (cursor.length < 8) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 8;
+
+      const ms = cursor.readBigInt64BE();
+      const v = new Date(Number(ms));
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

package/lib/structure/io/binary/internals/DoubleSerializer.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 DoubleSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.DOUBLE] = this;
+  }
+
+  canBeUsedFor(value) {
+    return typeof value === 'number' && !Number.isInteger(value);
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.DOUBLE, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.DOUBLE, 0x00]));
+    }
+    const v = Buffer.alloc(8);
+    v.writeDoubleBE(item);
+    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.DOUBLE) {
+          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 < 8) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 8;
+
+      const v = cursor.readDoubleBE();
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,215 @@
+/*
+ *  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 EdgeSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.EDGE] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof g.Edge;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.EDGE, 0x01]);
+      }
+      const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+      const label = [0x00, 0x00, 0x00, 0x00]; // ''
+      const inVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+      const inVLabel = [0x00, 0x00, 0x00, 0x00]; // ''
+      const outVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+      const outVLabel = [0x00, 0x00, 0x00, 0x00]; // ''
+      const parent = [0xfe, 0x01]; // null
+      const properties = [0xfe, 0x01]; // null
+      return Buffer.from([...id, ...label, ...inVId, ...inVLabel, ...outVId, ...outVLabel, ...parent, ...properties]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.EDGE, 0x00]));
+    }
+
+    // {id}
+    bufs.push(this.ioc.anySerializer.serialize(item.id));
+
+    // {label}
+    bufs.push(this.ioc.stringSerializer.serialize(item.label, false));
+
+    // {inVId}
+    const inVId = item.inV && item.inV.id;
+    bufs.push(this.ioc.anySerializer.serialize(inVId));
+
+    // {inVLabel}
+    const inVLabel = item.inV && item.inV.label;
+    bufs.push(this.ioc.stringSerializer.serialize(inVLabel, false));
+
+    // {outVId}
+    const outVId = item.outV && item.outV.id;
+    bufs.push(this.ioc.anySerializer.serialize(outVId));
+
+    // {outVLabel}
+    const outVLabel = item.outV && item.outV.label;
+    bufs.push(this.ioc.stringSerializer.serialize(outVLabel, false));
+
+    // {parent}
+    bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+
+    // {properties}
+    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.EDGE) {
+          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 inVId, inVId_len;
+      try {
+        ({ v: inVId, len: inVId_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += inVId_len;
+      } catch (err) {
+        err.message = '{inVId}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(inVId_len);
+
+      let inVLabel, inVLabel_len;
+      try {
+        ({ v: inVLabel, len: inVLabel_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+        len += inVLabel_len;
+      } catch (err) {
+        err.message = '{inVLabel}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(inVLabel_len);
+
+      let outVId, outVId_len;
+      try {
+        ({ v: outVId, len: outVId_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += outVId_len;
+      } catch (err) {
+        err.message = '{outVId}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(outVId_len);
+
+      let outVLabel, outVLabel_len;
+      try {
+        ({ v: outVLabel, len: outVLabel_len } = this.ioc.stringSerializer.deserialize(cursor, false));
+        len += outVLabel_len;
+      } catch (err) {
+        err.message = '{outVLabel}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(outVLabel_len);
+
+      let parent_len;
+      try {
+        ({ len: parent_len } = this.ioc.anySerializer.deserialize(cursor));
+        len += parent_len;
+      } catch (err) {
+        err.message = '{parent}: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(parent_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.Edge(
+        id,
+        new g.Vertex(outVId, outVLabel, null),
+        label,
+        new g.Vertex(inVId, inVLabel, null),
+        properties,
+      );
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

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

@@ -0,0 +1,148 @@
+/*
+ *  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 EnumSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+
+    const to_orig_enum = (obj) => {
+      // process/traversal.js:toEnum() changes original element name (e.g. OUT => out) for end users' convenience
+      // but we need original mapping as is w/o additional time spent on case-insensititive comparison
+      const r = {};
+      Object.values(obj).forEach((e) => (r[e.elementName] = e));
+      return r;
+    };
+    const DT = ioc.DataType;
+    this.types = [
+      { name: 'Barrier', code: DT.BARRIER, enum: to_orig_enum(t.barrier) },
+      { name: 'Cardinality', code: DT.CARDINALITY, enum: to_orig_enum(t.cardinality) },
+      { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(t.column) },
+      { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(t.direction) },
+      { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(t.operator) },
+      { name: 'Order', code: DT.ORDER, enum: to_orig_enum(t.order) },
+      { name: 'Pick', code: DT.PICK, enum: to_orig_enum(t.pick) },
+      { name: 'Pop', code: DT.POP, enum: to_orig_enum(t.pop) },
+      { name: 'Scope', code: DT.SCOPE, enum: to_orig_enum(t.scope) },
+      { name: 'T', code: DT.T, enum: to_orig_enum(t.t) },
+    ];
+    this.byname = {};
+    this.bycode = {};
+    for (const type of this.types) {
+      this.ioc.serializers[type.code] = this;
+      this.byname[type.name] = type;
+      this.bycode[type.code] = type;
+    }
+  }
+
+  canBeUsedFor(value) {
+    if (!(value instanceof t.EnumValue)) {
+      return false;
+    }
+    if (!this.byname[value.typeName]) {
+      throw new Error(`EnumSerializer.serialize: typeName=${value.typeName} is not supported.`);
+    }
+
+    return true;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    const type = this.byname[item.typeName];
+    if (item.elementName === undefined || item.elementName === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([type.code, 0x01]);
+      }
+      return Buffer.from([this.ioc.DataType.STRING, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([type.code, 0x00]));
+    }
+
+    bufs.push(this.ioc.stringSerializer.serialize(item.elementName, 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');
+      }
+
+      let type = undefined;
+      if (fullyQualifiedFormat) {
+        const type_code = cursor.readUInt8();
+        len++;
+        type = this.bycode[type_code];
+        if (!type) {
+          throw new Error(`unexpected {type_code}=${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 elementName, elementName_len;
+      try {
+        ({ v: elementName, len: elementName_len } = this.ioc.stringSerializer.deserialize(cursor, true));
+        len += elementName_len;
+      } catch (err) {
+        err.message = 'elementName: ' + err.message;
+        throw err;
+      }
+      cursor = cursor.slice(elementName_len);
+
+      let v;
+      if (!type) {
+        v = new t.EnumValue(undefined, elementName);
+      } else {
+        v = type.enum[elementName]; // users are expected to work with maps like Map.get(T.id), i.e. it must be exactly the same object
+      }
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};

package/lib/structure/io/binary/internals/FloatSerializer.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 FloatSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.FLOAT] = this;
+  }
+
+  canBeUsedFor(value) {
+    // it's not expected to be used
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.FLOAT, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.FLOAT, 0x00]));
+    }
+    const v = Buffer.alloc(4);
+    v.writeFloatBE(item);
+    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.FLOAT) {
+          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 < 4) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 4;
+
+      const v = cursor.readFloatBE();
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};