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

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

@@ -75,62 +75,42 @@ class BigIntegerSerializer {
         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.BIGINTEGER) {
-                    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);
-            }
-            // {length}
-            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 < 1) {
-                throw new Error(`{length}=${length} is less than one`);
-            }
-            cursor = cursor.slice(length_len);
-            len += length;
-            cursor = cursor.slice(0, length);
-            let v = BigInt(`0x${cursor.toString('hex')}`);
-            const is_sign_bit_set = (cursor[0] & 0x80) === 0x80;
-            if (is_sign_bit_set) {
-                v = BigInt.asIntN(length * 8, v); // now we get expected negative number
-            }
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<bigint>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 1) {
+            throw new Error(`BigIntegerSerializer: {length}=${length} is less than one`);
+        }
+        const bytes = await reader.readBytes(length);
+        let v = BigInt(`0x${bytes.toString('hex')}`);
+        const is_sign_bit_set = (bytes[0] & 0x80) === 0x80;
+        if (is_sign_bit_set) {
+            v = BigInt.asIntN(length * 8, v);
+        }
+        return v;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<bigint|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.BIGINTEGER) {
+            throw new Error(`BigIntegerSerializer: 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(`BigIntegerSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = BigIntegerSerializer;

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

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

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

@@ -54,59 +54,39 @@ class BinarySerializer {
         bufs.push(item);
         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.BINARY) {
-                    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 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(`{value}: unexpected actual {value} length=${cursor.length} when {length}=${length}`);
-            }
-            const v = cursor.slice(0, length);
-            len += length;
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Buffer>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`BinarySerializer: {length}=${length} is less than zero`);
+        }
+        if (length === 0) {
+            return buffer_1.Buffer.alloc(0);
+        }
+        return reader.readBytes(length);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<Buffer|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.BINARY) {
+            throw new Error(`BinarySerializer: 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(`BinarySerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = BinarySerializer;

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

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

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

@@ -44,50 +44,36 @@ class BooleanSerializer {
         bufs.push(buffer_1.Buffer.from([item ? 0x01 : 0x00]));
         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.BOOLEAN) {
-                    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 < 1) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 1;
-            let v = cursor.readUInt8();
-            if (v !== 0x00 && v !== 0x01) {
-                throw new Error(`unexpected boolean byte=${v}`);
-            }
-            v = v === 0x01;
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<boolean>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const v = await reader.readUInt8();
+        if (v !== 0x00 && v !== 0x01) {
+            throw new Error(`BooleanSerializer: unexpected boolean byte=0x${v.toString(16)}`);
+        }
+        return v === 0x01;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<boolean|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.BOOLEAN) {
+            throw new Error(`BooleanSerializer: 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(`BooleanSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = BooleanSerializer;

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

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

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

@@ -43,46 +43,32 @@ class ByteSerializer {
         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.BYTE) {
-                    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 < 1) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 1;
-            const v = cursor.readInt8();
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readByte();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.BYTE) {
+            throw new Error(`ByteSerializer: 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(`ByteSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = ByteSerializer;

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

@@ -2,9 +2,17 @@ export default class ByteSerializer {
     constructor(ioc: any);
     ioc: any;
     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/cjs/structure/io/binary/internals/CompositePDTSerializer.cjs

@@ -0,0 +1,81 @@
+"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");
+class CompositePDTSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.COMPOSITEPDT] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.CompositePDT;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.COMPOSITEPDT, 0x01]);
+            }
+            const bufs = [];
+            bufs.push(this.ioc.stringSerializer.serialize('', false));
+            bufs.push(this.ioc.mapSerializer.serialize({}, false));
+            return buffer_1.Buffer.concat(bufs);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.COMPOSITEPDT, 0x00]));
+        }
+        bufs.push(this.ioc.stringSerializer.serialize(item.name, true));
+        bufs.push(this.ioc.mapSerializer.serialize(item.fields, true));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const name = await this.ioc.anySerializer.deserialize(reader);
+        if (!name) {
+            throw new Error('CompositePDTSerializer: name cannot be null or empty');
+        }
+        const fieldsRaw = await this.ioc.anySerializer.deserialize(reader);
+        const fields = fieldsRaw instanceof Map ? Object.fromEntries(fieldsRaw) : fieldsRaw || {};
+        const pdt = new graph_js_1.CompositePDT(name, fields);
+        const pdtRegistry = reader.pdtRegistry;
+        if (pdtRegistry) {
+            const hydrated = pdtRegistry.hydrate(pdt);
+            if (!(hydrated instanceof graph_js_1.CompositePDT)) {
+                return hydrated;
+            }
+        }
+        return pdt;
+    }
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.COMPOSITEPDT) {
+            throw new Error(`CompositePDTSerializer: 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(`CompositePDTSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}
+exports.default = CompositePDTSerializer;

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

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