gremlin 3.8.0 → 4.0.0-beta.2

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

@@ -0,0 +1,20 @@
+export default class EdgeSerializer {
+    constructor(ioc: any);
+    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;
+    };
+}
+import { Edge } from '../../../graph.js';
+import { Buffer } from 'buffer';
+import { Vertex } from '../../../graph.js';

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

@@ -0,0 +1,198 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { Edge, Vertex } from '../../../graph.js';
+export default class EdgeSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.EDGE] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Edge;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.EDGE, 0x01]);
+            }
+            const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const label = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const inVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const inVLabel = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const outVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const outVLabel = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const parent = [0xfe, 0x01]; // null
+            const properties = [0x09, 0x00, 0x00, 0x00, 0x00, 0x00]; // empty list
+            return Buffer.from([...id, ...label, ...inVId, ...inVLabel, ...outVId, ...outVLabel, ...parent, ...properties]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.EDGE, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const 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] : [];
+        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] : [];
+        bufs.push(this.ioc.listSerializer.serialize(outVLabels, false));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        // {properties}
+        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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+export default class EnumSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    types: {
+        Direction: {
+            code: any;
+            enum: {};
+        };
+        Merge: {
+            code: any;
+            enum: {};
+        };
+        T: {
+            code: any;
+            enum: {};
+        };
+    };
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}

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

@@ -0,0 +1,124 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { direction, t as _t, merge as _merge, EnumValue } from '../../../../process/traversal.js';
+export default class EnumSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        // process/traversal.js:toEnum() lowercases element names (e.g. OUT => out) for end users' convenience
+        // but we need original mapping as is for wire format lookup
+        const to_orig_enum = (obj) => {
+            const r = {};
+            Object.values(obj).forEach((e) => (r[e.elementName] = e));
+            return r;
+        };
+        this.types = {
+            Direction: { code: ioc.DataType.DIRECTION, enum: to_orig_enum(direction) },
+            Merge: { code: ioc.DataType.MERGE, enum: to_orig_enum(_merge) },
+            T: { code: ioc.DataType.T, enum: to_orig_enum(_t) },
+        };
+        this.ioc.serializers[ioc.DataType.DIRECTION] = this;
+        this.ioc.serializers[ioc.DataType.MERGE] = this;
+        this.ioc.serializers[ioc.DataType.T] = this;
+    }
+    canBeUsedFor(value) {
+        return (value instanceof EnumValue &&
+            (value.typeName === 'Direction' || value.typeName === 'Merge' || value.typeName === 'T'));
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        const type = this.types[item.typeName];
+        if (item.elementName === undefined || item.elementName === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([type.code, 0x01]);
+            }
+            return this.ioc.stringSerializer.serialize(null, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([type.code, 0x00]));
+        }
+        bufs.push(this.ioc.stringSerializer.serialize(item.elementName, true));
+        return Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            let 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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+export default class FloatSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,88 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class FloatSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.FLOAT] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.FLOAT, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.FLOAT, 0x00]));
+        }
+        const v = Buffer.alloc(4);
+        v.writeFloatBE(item);
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.FLOAT) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (cursor.length < 4) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 4;
+            const v = cursor.readFloatBE();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * GraphBinary reader.
+ */
+export default class GraphBinaryReader {
+    constructor(ioc: any);
+    ioc: any;
+    get mimeType(): string;
+    readResponse(buffer: any): {
+        status: {
+            code: any;
+            message: any;
+            exception: any;
+        };
+        result: {
+            data: any[];
+            bulked: boolean;
+        };
+    };
+}

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

@@ -0,0 +1,94 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+/**
+ * GraphBinary reader.
+ */
+export default class GraphBinaryReader {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    readResponse(buffer) {
+        if (buffer === undefined || buffer === null) {
+            throw new Error('Buffer is missing.');
+        }
+        if (!(buffer instanceof Buffer)) {
+            throw new Error('Not an instance of Buffer.');
+        }
+        if (buffer.length < 1) {
+            throw new Error('Buffer is empty.');
+        }
+        let cursor = buffer;
+        let len;
+        // {version} is a Byte representing the protocol version
+        const version = cursor[0];
+        if (version !== 0x84) {
+            throw new Error(`Unsupported version '${version}'.`);
+        }
+        cursor = cursor.slice(1); // skip version
+        // {bulked} is a Byte: 0x00 = not bulked, 0x01 = bulked
+        const bulked = cursor[0] === 0x01;
+        cursor = cursor.slice(1);
+        // {result_data} stream - read values until marker
+        const data = [];
+        while (cursor[0] !== 0xfd) {
+            const { v, len: valueLen } = this.ioc.anySerializer.deserialize(cursor);
+            cursor = cursor.slice(valueLen);
+            if (bulked) {
+                const { v: bulk, len: bulkLen } = this.ioc.longSerializer.deserialize(cursor, true);
+                cursor = cursor.slice(bulkLen);
+                data.push({ v, bulk: Number(bulk) });
+            }
+            else {
+                data.push(v);
+            }
+        }
+        // Skip marker [0xFD, 0x00, 0x00]
+        cursor = cursor.slice(3);
+        // {status_code} is an Int bare
+        const { v: code, len: codeLen } = this.ioc.intSerializer.deserialize(cursor, false);
+        cursor = cursor.slice(codeLen);
+        // {status_message} is nullable
+        let message = null;
+        if (cursor[0] === 0x00) {
+            cursor = cursor.slice(1);
+            ({ v: message, len } = this.ioc.stringSerializer.deserialize(cursor, false));
+            cursor = cursor.slice(len);
+        }
+        else {
+            cursor = cursor.slice(1); // skip 0x01 null flag
+        }
+        // {exception} is nullable
+        let exception = null;
+        if (cursor[0] === 0x00) {
+            cursor = cursor.slice(1);
+            ({ v: exception } = this.ioc.stringSerializer.deserialize(cursor, false));
+        }
+        return {
+            status: { code, message, exception },
+            result: { data, bulked },
+        };
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * GraphBinary writer.
+ */
+export default class GraphBinaryWriter {
+    constructor(ioc: any);
+    ioc: any;
+    get mimeType(): string;
+    writeRequest(requestMessage: any): Uint8Array<ArrayBuffer>;
+}

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

@@ -0,0 +1,82 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+/**
+ * GraphBinary writer.
+ */
+export default class GraphBinaryWriter {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    writeRequest(requestMessage) {
+        const fields = new Map();
+        // Extract fields from RequestMessage if it has getter methods
+        if (typeof requestMessage.getLanguage === 'function') {
+            const language = requestMessage.getLanguage();
+            if (language) {
+                fields.set('language', language);
+            }
+            const g = requestMessage.getG();
+            if (g) {
+                fields.set('g', g);
+            }
+            const bindings = requestMessage.getBindings();
+            if (bindings && Object.keys(bindings).length > 0) {
+                fields.set('bindings', bindings);
+            }
+            const timeoutMs = requestMessage.getTimeoutMs();
+            if (timeoutMs !== undefined) {
+                fields.set('timeoutMs', timeoutMs);
+            }
+            const materializeProperties = requestMessage.getMaterializeProperties();
+            if (materializeProperties) {
+                fields.set('materializeProperties', materializeProperties);
+            }
+            const bulkResults = requestMessage.getBulkResults();
+            if (bulkResults !== undefined) {
+                fields.set('bulkResults', bulkResults);
+            }
+            // Add any custom fields
+            const customFields = requestMessage.getFields();
+            if (customFields) {
+                customFields.forEach((v, k) => fields.set(k, v));
+            }
+            const gremlin = requestMessage.getGremlin();
+            const bufs = [
+                Buffer.from([0x84]),
+                this.ioc.mapSerializer.serialize(fields, false),
+                this.ioc.stringSerializer.serialize(gremlin, false),
+            ];
+            return new Uint8Array(Buffer.concat(bufs));
+        }
+        // Legacy path: plain object with { gremlin, fields }
+        const bufs = [
+            Buffer.from([0x84]),
+            this.ioc.mapSerializer.serialize(requestMessage.fields || new Map(), false),
+            this.ioc.stringSerializer.serialize(requestMessage.gremlin, false),
+        ];
+        return new Uint8Array(Buffer.concat(bufs));
+    }
+}