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

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

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

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

@@ -51,21 +51,37 @@ export default class EdgeSerializer {
         // {id}
         bufs.push(this.ioc.anySerializer.serialize(item.id));
         // {label}
-        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        const labels = item.labels instanceof Set
+            ? Array.from(item.labels)
+            : Array.isArray(item.label)
+                ? item.label
+                : item.label
+                    ? [item.label]
+                    : [];
         bufs.push(this.ioc.listSerializer.serialize(labels, false));
         // {inVId}
         const inVId = item.inV && item.inV.id;
         bufs.push(this.ioc.anySerializer.serialize(inVId));
         // {inVLabel}
-        const inVLabel = item.inV && item.inV.label;
-        const inVLabels = Array.isArray(inVLabel) ? inVLabel : inVLabel ? [inVLabel] : [];
+        const inVLabels = item.inV && item.inV.labels instanceof Set
+            ? Array.from(item.inV.labels)
+            : item.inV && Array.isArray(item.inV.label)
+                ? item.inV.label
+                : item.inV && item.inV.label
+                    ? [item.inV.label]
+                    : [];
         bufs.push(this.ioc.listSerializer.serialize(inVLabels, false));
         // {outVId}
         const outVId = item.outV && item.outV.id;
         bufs.push(this.ioc.anySerializer.serialize(outVId));
         // {outVLabel}
-        const outVLabel = item.outV && item.outV.label;
-        const outVLabels = Array.isArray(outVLabel) ? outVLabel : outVLabel ? [outVLabel] : [];
+        const outVLabels = item.outV && item.outV.labels instanceof Set
+            ? Array.from(item.outV.labels)
+            : item.outV && Array.isArray(item.outV.label)
+                ? item.outV.label
+                : item.outV && item.outV.label
+                    ? [item.outV.label]
+                    : [];
         bufs.push(this.ioc.listSerializer.serialize(outVLabels, false));
         // {parent}
         bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
@@ -73,126 +89,55 @@ export default class EdgeSerializer {
         bufs.push(this.ioc.listSerializer.serialize([], 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');
-            }
-            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.listSerializer.deserialize(cursor, false));
-                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
-                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.listSerializer.deserialize(cursor, false));
-                inVLabel = Array.isArray(inVLabel) && inVLabel.length > 0 ? inVLabel[0] : inVLabel;
-                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.listSerializer.deserialize(cursor, false));
-                outVLabel = Array.isArray(outVLabel) && outVLabel.length > 0 ? outVLabel[0] : outVLabel;
-                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);
-            // null properties are deserialized into empty lists
-            const edge_props = properties ? properties : [];
-            const v = new Edge(id, new Vertex(outVId, outVLabel, null), label, new Vertex(inVId, inVLabel, null), edge_props);
-            return { v, len };
+    /**
+     * Async deserialization of edge value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Edge>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {id} fully qualified
+        const id = await this.ioc.anySerializer.deserialize(reader);
+        // {label} bare list - full multi-label list
+        const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const labels = Array.isArray(labelList) ? labelList : labelList ? [labelList] : [];
+        const label = labels.length > 0 ? labels[0] : 'edge';
+        // {inVId} fully qualified
+        const inVId = await this.ioc.anySerializer.deserialize(reader);
+        // {inVLabel} bare list - full multi-label list
+        const inVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const inVLabels = Array.isArray(inVLabelList) ? inVLabelList : inVLabelList ? [inVLabelList] : [];
+        const inVLabel = inVLabels.length > 0 ? inVLabels[0] : 'vertex';
+        // {outVId} fully qualified
+        const outVId = await this.ioc.anySerializer.deserialize(reader);
+        // {outVLabel} bare list - full multi-label list
+        const outVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const outVLabels = Array.isArray(outVLabelList) ? outVLabelList : outVLabelList ? [outVLabelList] : [];
+        const outVLabel = outVLabels.length > 0 ? outVLabels[0] : 'vertex';
+        // {parent} fully qualified (always null in current TinkerPop)
+        await this.ioc.anySerializer.deserialize(reader);
+        // {properties} fully qualified
+        const properties = await this.ioc.anySerializer.deserialize(reader);
+        return new Edge(id, new Vertex(outVId, outVLabel, null, outVLabels), label, new Vertex(inVId, inVLabel, null, inVLabels), properties || [], labels);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Edge|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.EDGE) {
+            throw new Error(`EdgeSerializer: 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(`EdgeSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

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

@@ -17,8 +17,23 @@ export default class EnumSerializer {
     };
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * Resolve the type_code (already read by AnySerializer) to a typeName.
+     * Called by AnySerializer before dispatching.
+     */
+    _typeNameForCode(type_code: any): "Direction" | "Merge" | "T" | undefined;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode - the type_code byte already read by AnySerializer
+     * @returns {Promise<EnumValue>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<EnumValue>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<EnumValue|null>}
+     */
+    deserialize(reader: StreamReader): Promise<EnumValue | null>;
 }
+import { EnumValue } from '../../../../process/traversal.js';

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

@@ -59,66 +59,54 @@ export default class EnumSerializer {
         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 typeName;
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code === this.ioc.DataType.DIRECTION) {
-                    typeName = 'Direction';
-                }
-                else if (type_code === this.ioc.DataType.MERGE) {
-                    typeName = 'Merge';
-                }
-                else if (type_code === this.ioc.DataType.T) {
-                    typeName = 'T';
-                }
-                else {
-                    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;
-            }
-            let v;
-            if (typeName) {
-                v = this.types[typeName].enum[elementName];
-            }
-            else {
-                v = new EnumValue(undefined, elementName);
-            }
-            return { v, len };
+    /**
+     * Resolve the type_code (already read by AnySerializer) to a typeName.
+     * Called by AnySerializer before dispatching.
+     */
+    _typeNameForCode(type_code) {
+        if (type_code === this.ioc.DataType.DIRECTION) {
+            return 'Direction';
+        }
+        if (type_code === this.ioc.DataType.MERGE) {
+            return 'Merge';
+        }
+        if (type_code === this.ioc.DataType.T) {
+            return 'T';
+        }
+        return undefined;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode - the type_code byte already read by AnySerializer
+     * @returns {Promise<EnumValue>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const typeName = this._typeNameForCode(typeCode);
+        // elementName is a fully-qualified String (type_code + value_flag + length + text)
+        const elementName = await this.ioc.stringSerializer.deserialize(reader);
+        if (typeName) {
+            return this.types[typeName].enum[elementName];
+        }
+        return new EnumValue(undefined, elementName);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<EnumValue|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (!this._typeNameForCode(type_code)) {
+            throw new Error(`EnumSerializer: 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(`EnumSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

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

@@ -3,9 +3,17 @@ export default class FloatSerializer {
     ioc: any;
     canBeUsedFor(value: any): 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
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
 }
 import { Buffer } from 'buffer';

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

@@ -44,45 +44,31 @@ export default class FloatSerializer {
         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 };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readFloatBE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.FLOAT) {
+            throw new Error(`FloatSerializer: 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(`FloatSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

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

@@ -4,8 +4,15 @@
 export default class GraphBinaryReader {
     constructor(ioc: any);
     ioc: any;
+    pdtRegistry: any;
     get mimeType(): string;
-    readResponse(buffer: any): {
+    /**
+     * Read a complete response from a Buffer. Used by the non-streaming submit() path.
+     * Returns the full { status, result } object after reading all data.
+     * @param {Buffer} buffer
+     * @returns {Promise<{status: {code, message, exception}, result: {data: any[], bulked: boolean}}>}
+     */
+    readResponse(buffer: Buffer): Promise<{
         status: {
             code: any;
             message: any;
@@ -15,5 +22,22 @@ export default class GraphBinaryReader {
             data: any[];
             bulked: boolean;
         };
-    };
+    }>;
+    /**
+     * Stream results from a StreamReader, yielding each value as it's deserialized.
+     * Used by the streaming Connection.stream() path.
+     *
+     * Note: In the GraphBinary v4 streaming protocol, the status (including error codes)
+     * is sent *after* all result data. This means values are yielded to the consumer as
+     * they arrive, and a server error is only thrown after all values have been yielded.
+     * Consumers should be aware that partial results may have been processed before a
+     * ResponseError is thrown.
+     *
+     * @param {StreamReader} reader
+     * @returns {AsyncGenerator<any>}
+     */
+    readResponseStream(reader: StreamReader): AsyncGenerator<any>;
+    #private;
 }
+import { Buffer } from 'buffer';
+import StreamReader from './StreamReader.js';