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

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

@@ -0,0 +1,69 @@
+/**
+ * Async byte reader that provides a uniform interface over both a complete Buffer
+ * (for non-streaming submit()) and a ReadableStream (for streaming HTTP responses).
+ *
+ * Handles chunk boundaries transparently and blocks (awaits) until the requested bytes are available.
+ */
+export default class StreamReader {
+    /**
+     * Create a StreamReader backed by a complete Buffer.
+     * All reads are satisfied from the buffer; no async I/O occurs.
+     * @param {Buffer} buffer
+     * @returns {StreamReader}
+     */
+    static fromBuffer(buffer: Buffer): StreamReader;
+    /**
+     * Create a StreamReader backed by a ReadableStream (e.g. fetch response.body).
+     * Reads pull chunks from the stream as needed.
+     * @param {ReadableStream} readableStream
+     * @returns {StreamReader}
+     */
+    static fromReadableStream(readableStream: ReadableStream): StreamReader;
+    /**
+     * @param {Buffer} initialBuffer
+     * @param {ReadableStreamDefaultReader|null} reader
+     */
+    constructor(initialBuffer: Buffer, reader: ReadableStreamDefaultReader | null);
+    /**
+     * Total number of bytes consumed so far (monotonically increasing).
+     * Useful for error diagnostics.
+     * @returns {number}
+     */
+    get position(): number;
+    /**
+     * Read exactly `n` bytes and return them as a Buffer.
+     * @param {number} n
+     * @returns {Promise<Buffer>}
+     */
+    readBytes(n: number): Promise<Buffer>;
+    /**
+     * @returns {Promise<number>} unsigned 8-bit integer
+     */
+    readUInt8(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 8-bit integer
+     */
+    readByte(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 16-bit big-endian integer
+     */
+    readInt16BE(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 32-bit big-endian integer
+     */
+    readInt32BE(): Promise<number>;
+    /**
+     * @returns {Promise<bigint>} signed 64-bit big-endian integer
+     */
+    readBigInt64BE(): Promise<bigint>;
+    /**
+     * @returns {Promise<number>} 32-bit big-endian float
+     */
+    readFloatBE(): Promise<number>;
+    /**
+     * @returns {Promise<number>} 64-bit big-endian double
+     */
+    readDoubleBE(): Promise<number>;
+    #private;
+}
+import { Buffer } from 'buffer';

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

@@ -47,61 +47,42 @@ class StringSerializer {
         bufs.push(v);
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
-        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.ID) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (fullyQualifiedFormat || nullable) {
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            let length, length_len;
-            try {
-                ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
-                len += length_len;
-            }
-            catch (err) {
-                err.message = '{length}: ' + err.message;
-                throw err;
-            }
-            if (length < 0) {
-                throw new Error('{length} is less than zero');
-            }
-            cursor = cursor.slice(length_len);
-            if (cursor.length < length) {
-                throw new Error('unexpected {text_value} length');
-            }
-            len += length;
-            const v = cursor.toString('utf8', 0, length);
-            return { v, len };
+    /**
+     * Read the string value bytes from the StreamReader (length + text_value).
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`StringSerializer: {length}=${length} is less than zero`);
+        }
+        if (length === 0) {
+            return '';
+        }
+        const bytes = await reader.readBytes(length);
+        return bytes.toString('utf8');
+    }
+    /**
+     * Read a fully-qualified string from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ID) {
+            throw new Error(`StringSerializer: 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(`StringSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = StringSerializer;

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

@@ -4,8 +4,18 @@ export default class StringSerializer {
     ID: any;
     canBeUsedFor(value: any): value is string;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, nullable?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * Read the string value bytes from the StreamReader (length + text_value).
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<string>;
+    /**
+     * Read a fully-qualified string from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    deserialize(reader: StreamReader): Promise<string | null>;
 }

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

@@ -25,7 +25,8 @@ class StubSerializer {
         this.typeName = typeName;
         this.ioc.serializers[typeCode] = this;
     }
-    deserialize() {
+    // eslint-disable-next-line require-await
+    async deserializeValue(reader, valueFlag, typeCode) {
         throw new Error(`${this.typeName} deserialization is not yet implemented`);
     }
 }

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

@@ -3,5 +3,5 @@ export default class StubSerializer {
     ioc: any;
     typeCode: any;
     typeName: any;
-    deserialize(): void;
+    deserializeValue(reader: any, valueFlag: any, typeCode: any): Promise<void>;
 }

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

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_1 = require("node:buffer");
+const graph_js_1 = require("../../../graph.cjs");
+/**
+ * GraphBinary serializer for the Tree type (0x2b).
+ *
+ * Wire format (authoritative from Java TreeSerializer):
+ *   value = {int length} then length x ( {fully-qualified key} {bare child Tree} )
+ * A child Tree is written bare: just {int length}{entries...}, with no type-id
+ * and no value-flag, recursively. A leaf is length 0. The child is never null,
+ * but a key may be null.
+ */
+class TreeSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.TREE] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.Tree;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.TREE, 0x01]);
+            }
+            // bare null -> empty tree (length 0)
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.TREE, 0x00]));
+        }
+        bufs.push(this._serializeValue(item));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    /**
+     * Serializes the bare value of a Tree: {int length} then, for each root key, a
+     * fully-qualified key followed by a bare child Tree (recursive).
+     *
+     * Uses only the public read API ({@link Tree#rootNodes} / {@link Tree#childAt})
+     * so it never touches the Tree's private backing. Keys returned by rootNodes()
+     * are already deduped, so each is written exactly once.
+     * @param {Tree} tree
+     * @returns {Buffer}
+     */
+    _serializeValue(tree) {
+        const keys = tree.rootNodes();
+        let length = keys.length;
+        if (length < 0) {
+            length = 0;
+        }
+        else if (length > this.ioc.intSerializer.INT32_MAX) {
+            length = this.ioc.intSerializer.INT32_MAX;
+        }
+        const bufs = [this.ioc.intSerializer.serialize(length, false)];
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            // fully-qualified key
+            bufs.push(this.ioc.anySerializer.serialize(key));
+            // bare child tree (no type_code, no value_flag)
+            bufs.push(this._serializeValue(tree.childAt(key)));
+        }
+        return buffer_1.Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of tree value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Tree>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await this._readTreeValue(reader);
+    }
+    /**
+     * Reads a bare tree value: {int length} then length x ( fully-qualified key,
+     * bare child tree ). The child recursion reads bare values (no type_code,
+     * no value_flag).
+     *
+     * Duplicate sibling keys are collapsed via {@link Tree#getOrCreateChild} +
+     * {@link Tree#addTree} (a server emitting
+     * the same sibling key twice yields a single merged entry, not duplicates).
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree>}
+     */
+    async _readTreeValue(reader) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        const tree = new graph_js_1.Tree();
+        for (let i = 0; i < length; i++) {
+            // {fully-qualified key} - read with type_code + value_flag.
+            const key = await this.ioc.anySerializer.deserialize(reader);
+            // {bare child tree} - never null, no type_code / value_flag
+            const child = await this._readTreeValue(reader);
+            // Merge into any existing entry for this key so duplicate sibling keys
+            // collapse into a single entry.
+            tree.getOrCreateChild(key).addTree(child);
+        }
+        return tree;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.TREE) {
+            throw new Error(`TreeSerializer: 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(`TreeSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}
+exports.default = TreeSerializer;

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

@@ -0,0 +1,54 @@
+/**
+ * GraphBinary serializer for the Tree type (0x2b).
+ *
+ * Wire format (authoritative from Java TreeSerializer):
+ *   value = {int length} then length x ( {fully-qualified key} {bare child Tree} )
+ * A child Tree is written bare: just {int length}{entries...}, with no type-id
+ * and no value-flag, recursively. A leaf is length 0. The child is never null,
+ * but a key may be null.
+ */
+export default class TreeSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Tree;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    /**
+     * Serializes the bare value of a Tree: {int length} then, for each root key, a
+     * fully-qualified key followed by a bare child Tree (recursive).
+     *
+     * Uses only the public read API ({@link Tree#rootNodes} / {@link Tree#childAt})
+     * so it never touches the Tree's private backing. Keys returned by rootNodes()
+     * are already deduped, so each is written exactly once.
+     * @param {Tree} tree
+     * @returns {Buffer}
+     */
+    _serializeValue(tree: Tree): Buffer;
+    /**
+     * Async deserialization of tree value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Tree>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Tree>;
+    /**
+     * Reads a bare tree value: {int length} then length x ( fully-qualified key,
+     * bare child tree ). The child recursion reads bare values (no type_code,
+     * no value_flag).
+     *
+     * Duplicate sibling keys are collapsed via {@link Tree#getOrCreateChild} +
+     * {@link Tree#addTree} (a server emitting
+     * the same sibling key twice yields a single merged entry, not duplicates).
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree>}
+     */
+    _readTreeValue(reader: StreamReader): Promise<Tree>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Tree | null>;
+}
+import { Tree } from '../../../graph.cjs';
+import { Buffer } from 'buffer';

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

@@ -34,37 +34,14 @@ class UnspecifiedNullSerializer {
         // fullyQualifiedFormat always is true
         return buffer_1.Buffer.from([this.ioc.DataType.UNSPECIFIED_NULL, 0x01]);
     }
-    deserialize(buffer) {
-        // fullyQualifiedFormat always is true
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            const type_code = cursor.readUInt8();
-            len++;
-            if (type_code !== this.ioc.DataType.UNSPECIFIED_NULL) {
-                throw new Error('unexpected {type_code}');
-            }
-            cursor = cursor.slice(1);
-            if (cursor.length < 1) {
-                throw new Error('{value_flag} is missing');
-            }
-            const value_flag = cursor.readUInt8();
-            len++;
-            if (value_flag !== 1) {
-                throw new Error('unexpected {value_flag}');
-            }
-            cursor = cursor.slice(1);
-            return { v: null, len };
-        }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
-        }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer (always 0x01 for null)
+     * @returns {Promise<null>}
+     */
+    // eslint-disable-next-line require-await
+    async deserializeValue(reader, valueFlag) {
+        throw new Error('UnspecifiedNull should always have value_flag=0x01');
     }
 }
 exports.default = UnspecifiedNullSerializer;

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

@@ -3,9 +3,11 @@ export default class UnspecifiedNullSerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, ...args: any[]): {
-        v: null;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer (always 0x01 for null)
+     * @returns {Promise<null>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number): Promise<null>;
 }
 import { Buffer } from 'buffer';

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

@@ -53,57 +53,41 @@ class UuidSerializer {
         bufs.push(v);
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
-        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.UUID) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (fullyQualifiedFormat || nullable) {
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (cursor.length < 16) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 16;
-            // Example: 2075278D-F624-4B2B-960D-25D374D57C04
-            const v = cursor.slice(0, 4).toString('hex') +
-                '-' +
-                cursor.slice(4, 6).toString('hex') +
-                '-' +
-                cursor.slice(6, 8).toString('hex') +
-                '-' +
-                cursor.slice(8, 10).toString('hex') +
-                '-' +
-                cursor.slice(10, 16).toString('hex');
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const bytes = await reader.readBytes(16);
+        return (bytes.subarray(0, 4).toString('hex') +
+            '-' +
+            bytes.subarray(4, 6).toString('hex') +
+            '-' +
+            bytes.subarray(6, 8).toString('hex') +
+            '-' +
+            bytes.subarray(8, 10).toString('hex') +
+            '-' +
+            bytes.subarray(10, 16).toString('hex'));
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.UUID) {
+            throw new Error(`UuidSerializer: 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(`UuidSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = UuidSerializer;

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

@@ -3,12 +3,17 @@ export default class UuidSerializer {
     ioc: any;
     canBeUsedFor(value: any): void;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, nullable?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: string;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<string>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    deserialize(reader: StreamReader): Promise<string | null>;
 }
 import { Buffer } from 'buffer';