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

package/build/cjs/structure/io/binary/internals/IntSerializer.cjs

@@ -58,46 +58,41 @@ class IntSerializer {
         bufs.push(v);
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.INT) {
-                    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.readInt32BE();
-            return { v, len };
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    async deserializeBare(reader) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.INT) {
+            throw new Error(`IntSerializer: 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(`IntSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = IntSerializer;

package/build/cjs/structure/io/binary/internals/IntSerializer.d.cts

@@ -5,9 +5,24 @@ export default class IntSerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    deserializeBare(reader: StreamReader): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
 }
 import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/LongSerializer.cjs

@@ -46,50 +46,37 @@ class LongSerializer {
         bufs.push(v);
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.LONG) {
-                    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;
-            let v = cursor.readBigInt64BE();
-            if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
-                v = Number(v);
-            }
-            // Values outside safe integer range stay as BigInt to preserve precision.
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        let v = await reader.readBigInt64BE();
+        if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+            v = Number(v);
+        }
+        return v;
+    }
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.LONG) {
+            throw new Error(`LongSerializer: 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(`LongSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = LongSerializer;

package/build/cjs/structure/io/binary/internals/LongSerializer.d.cts

@@ -3,9 +3,18 @@ export default class LongSerializer {
     ioc: any;
     canBeUsedFor(): void;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number | bigint>;
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | bigint | null>;
 }
 import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/MapSerializer.cjs

@@ -67,78 +67,44 @@ class MapSerializer {
         }
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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);
     }
 }
 exports.default = MapSerializer;

package/build/cjs/structure/io/binary/internals/MapSerializer.d.cts

@@ -3,11 +3,18 @@ export default class MapSerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: Map<any, any>;
-        len: number;
-    };
+    /**
+     * Async deserialization of map value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Map>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Map<any, any>>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Map|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Map<any, any> | null>;
 }

package/build/cjs/structure/io/binary/internals/MarkerSerializer.cjs

@@ -18,46 +18,43 @@
  *  under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const buffer_1 = require("node:buffer");
+exports.END_OF_STREAM = void 0;
+exports.END_OF_STREAM = Symbol('EndOfStream');
 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_1.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 exports.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);
     }
 }
 exports.default = MarkerSerializer;

package/build/cjs/structure/io/binary/internals/MarkerSerializer.d.cts

@@ -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/cjs/structure/io/binary/internals/NumberSerializationStrategy.cjs

@@ -21,6 +21,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @author Igor Ostapenko
  */
+const utils_js_1 = require("../../../../utils.cjs");
 // Based on GraphSON NumberSerializer.serialize().
 // It's tested by AnySerializer.serialize() tests.
 class NumberSerializationStrategy {
@@ -28,6 +29,14 @@ class NumberSerializationStrategy {
         this.ioc = ioc;
     }
     canBeUsedFor(value) {
+        if (value instanceof utils_js_1.Long ||
+            value instanceof utils_js_1.Int ||
+            value instanceof utils_js_1.Float ||
+            value instanceof utils_js_1.Double ||
+            value instanceof utils_js_1.Short ||
+            value instanceof utils_js_1.Byte) {
+            return true;
+        }
         if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
             return true;
         }
@@ -40,6 +49,24 @@ class NumberSerializationStrategy {
         return false;
     }
     serialize(item, fullyQualifiedFormat = true) {
+        if (item instanceof utils_js_1.Float) {
+            return this.ioc.floatSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof utils_js_1.Double) {
+            return this.ioc.doubleSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof utils_js_1.Int) {
+            return this.ioc.intSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof utils_js_1.Long) {
+            return this.ioc.longSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof utils_js_1.Short) {
+            return this.ioc.shortSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof utils_js_1.Byte) {
+            return this.ioc.byteSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
         if (typeof item === 'number') {
             if (Number.isNaN(item) ||
                 item === Number.POSITIVE_INFINITY ||
@@ -48,8 +75,7 @@ class NumberSerializationStrategy {
                 Object.is(item, -0)) {
                 return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
             }
-            if (item >= -2147483648 && item <= 2147483647) {
-                // INT32_MIN/MAX
+            if (item >= utils_js_1.INT32_MIN && item <= utils_js_1.INT32_MAX) {
                 return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
             }
             if (item >= Number.MIN_SAFE_INTEGER && item <= Number.MAX_SAFE_INTEGER) {

package/build/cjs/structure/io/binary/internals/NumberSerializationStrategy.d.cts

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

package/build/cjs/structure/io/binary/internals/PathSerializer.cjs

@@ -51,63 +51,38 @@ class PathSerializer {
         bufs.push(this.ioc.listSerializer.serialize(item.objects));
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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 graph_js_1.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 graph_js_1.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);
     }
 }
 exports.default = PathSerializer;

package/build/cjs/structure/io/binary/internals/PathSerializer.d.cts

@@ -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.cjs';
 import { Buffer } from 'buffer';