gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/esm/structure/io/binary/internals/MapSerializer.js

@@ -65,77 +65,43 @@ export default class MapSerializer {
         }
         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 === 0x01) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0x00 && value_flag !== 0x02) {
-                    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 };
+    /**
+     * Async deserialization of map value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Map>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`MapSerializer: {length}=${length} is less than zero`);
+        }
+        const v = new Map();
+        for (let i = 0; i < length; i++) {
+            const key = await this.ioc.anySerializer.deserialize(reader);
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            v.set(key, value);
+        }
+        return v;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Map|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.MAP) {
+            throw new Error(`MapSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00 && value_flag !== 0x02) {
+            throw new Error(`MapSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/MarkerSerializer.d.ts

@@ -1,8 +1,17 @@
+export const END_OF_STREAM: unique symbol;
 export default class MarkerSerializer {
     constructor(ioc: any);
     ioc: any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: string;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @returns {Promise<symbol>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number): Promise<symbol>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<symbol|null>}
+     */
+    deserialize(reader: StreamReader): Promise<symbol | null>;
 }

package/build/esm/structure/io/binary/internals/MarkerSerializer.js

@@ -16,45 +16,41 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-import { Buffer } from 'buffer';
+export const END_OF_STREAM = Symbol('EndOfStream');
 export default class MarkerSerializer {
     constructor(ioc) {
         this.ioc = ioc;
         this.ioc.serializers[ioc.DataType.MARKER] = 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 < (fullyQualifiedFormat ? 3 : 1)) {
-                throw new Error('buffer is too short for marker');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ioc.DataType.MARKER) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            const value = cursor.readUInt8();
-            len++;
-            if (value !== 0) {
-                throw new Error('unexpected marker value');
-            }
-            return { v: 'marker', len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @returns {Promise<symbol>}
+     */
+    async deserializeValue(reader, valueFlag) {
+        const value = await reader.readUInt8();
+        if (value !== 0) {
+            throw new Error(`unexpected marker value: ${value}`);
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        return END_OF_STREAM;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<symbol|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.MARKER) {
+            throw new Error(`MarkerSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00) {
+            throw new Error(`MarkerSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag);
     }
 }

package/build/esm/structure/io/binary/internals/NumberSerializationStrategy.d.ts

@@ -1,6 +1,3 @@
-/**
- * @author Igor Ostapenko
- */
 export default class NumberSerializationStrategy {
     constructor(ioc: any);
     ioc: any;

package/build/esm/structure/io/binary/internals/NumberSerializationStrategy.js

@@ -19,6 +19,7 @@
 /**
  * @author Igor Ostapenko
  */
+import { Long, Int, Float, Double, Short, Byte, INT32_MIN, INT32_MAX } from '../../../../utils.js';
 // Based on GraphSON NumberSerializer.serialize().
 // It's tested by AnySerializer.serialize() tests.
 export default class NumberSerializationStrategy {
@@ -26,6 +27,14 @@ export default class NumberSerializationStrategy {
         this.ioc = ioc;
     }
     canBeUsedFor(value) {
+        if (value instanceof Long ||
+            value instanceof Int ||
+            value instanceof Float ||
+            value instanceof Double ||
+            value instanceof Short ||
+            value instanceof Byte) {
+            return true;
+        }
         if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
             return true;
         }
@@ -38,6 +47,24 @@ export default class NumberSerializationStrategy {
         return false;
     }
     serialize(item, fullyQualifiedFormat = true) {
+        if (item instanceof Float) {
+            return this.ioc.floatSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Double) {
+            return this.ioc.doubleSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Int) {
+            return this.ioc.intSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Long) {
+            return this.ioc.longSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Short) {
+            return this.ioc.shortSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Byte) {
+            return this.ioc.byteSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
         if (typeof item === 'number') {
             if (Number.isNaN(item) ||
                 item === Number.POSITIVE_INFINITY ||
@@ -46,8 +73,7 @@ export default class NumberSerializationStrategy {
                 Object.is(item, -0)) {
                 return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
             }
-            if (item >= -2147483648 && item <= 2147483647) {
-                // INT32_MIN/MAX
+            if (item >= INT32_MIN && item <= INT32_MAX) {
                 return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
             }
             if (item >= Number.MIN_SAFE_INTEGER && item <= Number.MAX_SAFE_INTEGER) {

package/build/esm/structure/io/binary/internals/PathSerializer.d.ts

@@ -3,13 +3,20 @@ export default class PathSerializer {
     ioc: any;
     canBeUsedFor(value: any): value is Path;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: Path;
-        len: number;
-    };
+    /**
+     * Async deserialization of path value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Path>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Path>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Path|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Path | null>;
 }
 import { Path } from '../../../graph.js';
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/PathSerializer.js

@@ -49,62 +49,37 @@ export default class PathSerializer {
         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 Path(labels, objects);
-            return { v, len };
+    /**
+     * Async deserialization of path value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Path>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {labels} fully qualified list
+        const labels = await this.ioc.anySerializer.deserialize(reader);
+        // {objects} fully qualified list
+        const objects = await this.ioc.anySerializer.deserialize(reader);
+        return new Path(labels, objects);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Path|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PATH) {
+            throw new Error(`PathSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`PathSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/PrimitivePDTSerializer.d.ts

@@ -0,0 +1,10 @@
+export default class PrimitivePDTSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is PrimitivePDT;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserializeValue(reader: any, valueFlag: any, typeCode: any): Promise<any>;
+    deserialize(reader: any): Promise<any>;
+}
+import { PrimitivePDT } from '../../../graph.js';
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/PrimitivePDTSerializer.js

@@ -0,0 +1,77 @@
+/*
+ *  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.
+ */
+import { Buffer } from 'buffer';
+import { PrimitivePDT } from '../../../graph.js';
+export default class PrimitivePDTSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.PRIMITIVEPDT] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof PrimitivePDT;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.PRIMITIVEPDT, 0x01]);
+            }
+            const bufs = [];
+            bufs.push(this.ioc.stringSerializer.serialize('', false));
+            bufs.push(this.ioc.stringSerializer.serialize('', false));
+            return Buffer.concat(bufs);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.PRIMITIVEPDT, 0x00]));
+        }
+        bufs.push(this.ioc.stringSerializer.serialize(item.name, true));
+        bufs.push(this.ioc.stringSerializer.serialize(item.value, true));
+        return Buffer.concat(bufs);
+    }
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const name = await this.ioc.anySerializer.deserialize(reader);
+        if (!name) {
+            throw new Error('PrimitivePDTSerializer: name cannot be null or empty');
+        }
+        const value = await this.ioc.anySerializer.deserialize(reader);
+        const pdt = new PrimitivePDT(name, value != null ? String(value) : '');
+        const pdtRegistry = reader.pdtRegistry;
+        if (pdtRegistry) {
+            const hydrated = pdtRegistry.hydratePrimitive(pdt);
+            if (!(hydrated instanceof PrimitivePDT)) {
+                return hydrated;
+            }
+        }
+        return pdt;
+    }
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PRIMITIVEPDT) {
+            throw new Error(`PrimitivePDTSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00) {
+            throw new Error(`PrimitivePDTSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

package/build/esm/structure/io/binary/internals/PropertySerializer.d.ts

@@ -3,13 +3,20 @@ export default class PropertySerializer {
     ioc: any;
     canBeUsedFor(value: any): value is Property<any>;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: Property<any>;
-        len: number;
-    };
+    /**
+     * Async deserialization of property value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Property>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Property>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Property|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Property | null>;
 }
 import { Property } from '../../../graph.js';
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/PropertySerializer.js

@@ -52,76 +52,39 @@ export default class PropertySerializer {
         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 Property(key, value);
-            return { v, len };
+    /**
+     * Async deserialization of property value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Property>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {key} bare string (length + text_value)
+        const key = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, typeCode);
+        // {value} fully qualified
+        const value = await this.ioc.anySerializer.deserialize(reader);
+        // {parent} fully qualified (always null in current TinkerPop)
+        await this.ioc.anySerializer.deserialize(reader);
+        return new Property(key, value);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Property|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PROPERTY) {
+            throw new Error(`PropertySerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`PropertySerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }