gremlin 3.8.1 → 4.0.0-beta.2

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

@@ -0,0 +1,80 @@
+"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 });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class AnySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        // specifically ordered, the first canBeUsedFor=true wins
+        this.serializers = [
+            ioc.unspecifiedNullSerializer,
+            ioc.numberSerializationStrategy,
+            ioc.booleanSerializer,
+            ioc.dateTimeSerializer,
+            ioc.setSerializer,
+            ioc.listSerializer,
+            ioc.uuidSerializer,
+            ioc.edgeSerializer,
+            ioc.pathSerializer,
+            ioc.propertySerializer,
+            ioc.vertexSerializer,
+            ioc.vertexPropertySerializer,
+            ioc.enumSerializer,
+            ioc.stringSerializer,
+            ioc.binarySerializer,
+            ioc.mapSerializer,
+        ];
+    }
+    getSerializerCanBeUsedFor(item) {
+        for (let i = 0; i < this.serializers.length; i++) {
+            if (this.serializers[i].canBeUsedFor(item)) {
+                return this.serializers[i];
+            }
+        }
+        throw new Error(`No serializer found to support item where typeof(item)='${typeof item}' and String(item)='${String(item)}'.`);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        return this.getSerializerCanBeUsedFor(item).serialize(item, fullyQualifiedFormat);
+    }
+    deserialize(buffer) {
+        // obviously, fullyQualifiedFormat always is true
+        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 = buffer.readUInt8();
+            const serializer = this.ioc.serializers[type_code];
+            if (!serializer) {
+                throw new Error('unknown {type_code}');
+            }
+            return serializer.deserialize(buffer);
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, err });
+        }
+    }
+}
+exports.default = AnySerializer;

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

@@ -0,0 +1,8 @@
+export default class AnySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    serializers: any[];
+    getSerializerCanBeUsedFor(item: any): any;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, ...args: any[]): any;
+}

package/build/cjs/structure/io/binary/internals/ArraySerializer.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 });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class ArraySerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return Array.isArray(value);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ID, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ID, 0x00]));
+        }
+        // {length}
+        let length = item.length;
+        if (length < 0) {
+            length = 0; // TODO: test it
+        }
+        if (length > this.ioc.intSerializer.INT32_MAX) {
+            throw new Error(`Array length=${length} is greater than supported max_length=${this.ioc.intSerializer.INT32_MAX}.`);
+        }
+        bufs.push(this.ioc.intSerializer.serialize(length, false));
+        // {item_0}...{item_n}
+        for (let i = 0; i < length; i++) {
+            bufs.push(this.ioc.anySerializer.serialize(item[i]));
+        }
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        let isBulked = false;
+        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 (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 && value_flag !== 2) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                isBulked = value_flag === 2;
+                cursor = cursor.slice(1);
+            }
+            let length, length_len;
+            try {
+                ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
+                len += length_len;
+            }
+            catch (err) {
+                err.message = '{length}: ' + err.message;
+                throw err;
+            }
+            if (length < 0) {
+                throw new Error('{length} is less than zero');
+            }
+            cursor = cursor.slice(length_len);
+            const v = [];
+            for (let i = 0; i < length; i++) {
+                let value, value_len;
+                try {
+                    ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+                    len += value_len;
+                }
+                catch (err) {
+                    err.message = `{item_${i}}: ` + err.message;
+                    throw err;
+                }
+                cursor = cursor.slice(value_len);
+                if (isBulked) {
+                    if (cursor.length < 8) {
+                        throw new Error(`{item_${i}}: bulk count is missing`);
+                    }
+                    const bulkCount = cursor.readBigInt64BE();
+                    len += 8;
+                    cursor = cursor.slice(8);
+                    for (let j = 0n; j < bulkCount; j++) {
+                        v.push(value);
+                    }
+                }
+                else {
+                    v.push(value);
+                }
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = ArraySerializer;

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

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

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

@@ -0,0 +1,136 @@
+"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 });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+// TODO: it has room for performance improvements
+class BigIntegerSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.BIGINTEGER] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used directly, see NumberSerializationStrategy
+        return typeof value === 'bigint';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.BIGINTEGER, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x01, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.BIGINTEGER, 0x00]));
+        }
+        let v;
+        // positive number
+        if (item >= 0) {
+            let hex_str = item.toString(16);
+            if (hex_str.length % 2 !== 0) {
+                hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+            }
+            if (Number.parseInt(hex_str[0], 16) > 7) {
+                hex_str = '00' + hex_str; // to keep sign bit unset for positive number
+            }
+            v = buffer_1.Buffer.from(hex_str, 'hex');
+        }
+        // negative number
+        else {
+            let hex_str = (-item).toString(16);
+            const bytes = (hex_str.length + (hex_str.length % 2)) / 2; // number's size in bytes
+            let N = BigInt(bytes) * BigInt(8); // number's size in bits
+            const INTN_MIN = -(BigInt(2) ** (N - BigInt(1))); // minimum negative number we can keep within N bits
+            if (item < INTN_MIN) {
+                N += BigInt(8); // to provide room for smaller negative number
+            }
+            const twos_complement = BigInt(2) ** N + item;
+            hex_str = twos_complement.toString(16);
+            if (hex_str.length % 2 !== 0) {
+                hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+            }
+            v = buffer_1.Buffer.from(hex_str, 'hex');
+        }
+        bufs.push(this.ioc.intSerializer.serialize(v.length, false));
+        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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = BigIntegerSerializer;

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

@@ -0,0 +1,14 @@
+export default class BigIntegerSerializer {
+    constructor(ioc: any);
+    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;
+    };
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,112 @@
+"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 });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class BinarySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.BINARY] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof buffer_1.Buffer;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.BINARY, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.BINARY, 0x00]));
+        }
+        // {length}
+        let length = item.length;
+        if (length < 0) {
+            length = 0; // TODO: test it
+        }
+        if (length > this.ioc.intSerializer.INT32_MAX) {
+            throw new Error(`Buffer length=${length} is greater than supported max_length=${this.ioc.intSerializer.INT32_MAX}.`);
+        }
+        bufs.push(this.ioc.intSerializer.serialize(length, false));
+        // {value} sequence of bytes
+        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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = BinarySerializer;

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

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

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

@@ -0,0 +1,93 @@
+"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 });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class BooleanSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.BOOLEAN] = this;
+    }
+    canBeUsedFor(value) {
+        return typeof value === 'boolean';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.BOOLEAN, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.BOOLEAN, 0x00]));
+        }
+        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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = BooleanSerializer;

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

@@ -0,0 +1,11 @@
+export default class BooleanSerializer {
+    constructor(ioc: any);
+    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;
+    };
+}
+import { Buffer } from 'buffer';