gremlin 3.8.0 → 4.0.0-beta.2

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

@@ -0,0 +1,13 @@
+export default class IntSerializer {
+    constructor(ioc: any);
+    get INT32_MIN(): number;
+    get INT32_MAX(): number;
+    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/esm/structure/io/binary/internals/IntSerializer.js

@@ -0,0 +1,100 @@
+/*
+ *  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 IntSerializer {
+    get INT32_MIN() {
+        return -2147483648;
+    }
+    get INT32_MAX() {
+        return 2147483647;
+    }
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.INT] = this;
+    }
+    canBeUsedFor(value) {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (value < this.INT32_MIN || value > this.INT32_MAX) {
+            return false;
+        }
+        return true;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.INT, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.INT, 0x00]));
+        }
+        const v = Buffer.alloc(4);
+        v.writeInt32BE(item); // if item is not within int32 limits writeInt32BE will error
+        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.INT) {
+                    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.readInt32BE();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+export default class LongSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(): 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/LongSerializer.js

@@ -0,0 +1,92 @@
+/*
+ *  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 LongSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.LONG] = this;
+    }
+    canBeUsedFor() {
+        // it's not expected to be used, see NumberSerializationStrategy
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.LONG, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.LONG, 0x00]));
+        }
+        const v = Buffer.alloc(8);
+        v.writeBigInt64BE(BigInt(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.LONG) {
+                    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 < 8) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 8;
+            let v = cursor.readBigInt64BE();
+            if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+                v = Number(v);
+            }
+            // Values outside safe integer range stay as BigInt to preserve precision.
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+export default class MapSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: Map<any, any>;
+        len: number;
+    };
+}

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

@@ -0,0 +1,141 @@
+/*
+ *  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 MapSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.MAP] = this;
+    }
+    canBeUsedFor(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (value instanceof Map) {
+            return true;
+        }
+        if (Array.isArray(value)) {
+            return false;
+        }
+        return typeof value === 'object';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.MAP, 0x01]);
+            }
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const isMap = item instanceof Map;
+        const keys = isMap ? Array.from(item.keys()) : Object.keys(item);
+        let map_length = keys.length;
+        if (map_length < 0) {
+            map_length = 0;
+        }
+        else if (map_length > this.ioc.intSerializer.INT32_MAX) {
+            map_length = this.ioc.intSerializer.INT32_MAX; // TODO: is it expected to be silenced? or it's better to error instead?
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.MAP, 0x00]));
+        }
+        bufs.push(this.ioc.intSerializer.serialize(map_length, false));
+        for (let i = 0; i < map_length; i++) {
+            const key = keys[i];
+            const value = isMap ? item.get(key) : item[key];
+            bufs.push(this.ioc.anySerializer.serialize(key), this.ioc.anySerializer.serialize(value));
+        }
+        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.MAP) {
+                    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 === 0x01) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0x00 && value_flag !== 0x02) {
+                    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);
+            const v = new Map();
+            for (let i = 0; i < length; i++) {
+                let key, key_len;
+                try {
+                    ({ v: key, len: key_len } = this.ioc.anySerializer.deserialize(cursor));
+                    len += key_len;
+                }
+                catch (err) {
+                    err.message = `{item_${i}} key: ` + err.message;
+                    throw err;
+                }
+                cursor = cursor.slice(key_len);
+                let value, value_len;
+                try {
+                    ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+                    len += value_len;
+                }
+                catch (err) {
+                    err.message = `{item_${i}} value: ` + err.message;
+                    throw err;
+                }
+                cursor = cursor.slice(value_len);
+                v.set(key, value);
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+export default class MarkerSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: string;
+        len: number;
+    };
+}

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

@@ -0,0 +1,60 @@
+/*
+ *  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.
+ */
+import { Buffer } from 'buffer';
+export default class MarkerSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.MARKER] = this;
+    }
+    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 < (fullyQualifiedFormat ? 3 : 1)) {
+                throw new Error('buffer is too short for marker');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.MARKER) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            const value = cursor.readUInt8();
+            len++;
+            if (value !== 0) {
+                throw new Error('unexpected marker value');
+            }
+            return { v: 'marker', len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @author Igor Ostapenko
+ */
+export default class NumberSerializationStrategy {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+}

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

@@ -0,0 +1,63 @@
+/*
+ *  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
+ */
+// Based on GraphSON NumberSerializer.serialize().
+// It's tested by AnySerializer.serialize() tests.
+export default class NumberSerializationStrategy {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    canBeUsedFor(value) {
+        if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
+            return true;
+        }
+        if (typeof value === 'number') {
+            return true;
+        }
+        if (typeof value === 'bigint') {
+            return true;
+        }
+        return false;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (typeof item === 'number') {
+            if (Number.isNaN(item) ||
+                item === Number.POSITIVE_INFINITY ||
+                item === Number.NEGATIVE_INFINITY ||
+                !Number.isInteger(item) ||
+                Object.is(item, -0)) {
+                return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            if (item >= -2147483648 && item <= 2147483647) {
+                // INT32_MIN/MAX
+                return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            if (item >= Number.MIN_SAFE_INTEGER && item <= Number.MAX_SAFE_INTEGER) {
+                return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            // Integers outside safe range are huge doubles that only appear integral due to IEEE 754 precision loss
+            return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
+        }
+        if (typeof item === 'bigint') {
+            return this.ioc.bigIntegerSerializer.serialize(item, fullyQualifiedFormat);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,110 @@
+/*
+ *  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 { Path } from '../../../graph.js';
+export default class PathSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.PATH] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Path;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.PATH, 0x01]);
+            }
+            return Buffer.concat([
+                this.ioc.listSerializer.serialize([]), // {labels}=[]
+                this.ioc.listSerializer.serialize([]), // {objects}=[]
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.PATH, 0x00]));
+        }
+        // {labels} is a List in which each item is a Set of String
+        bufs.push(this.ioc.listSerializer.serialize(item.labels));
+        // {objects} is a List of fully qualified typed values
+        bufs.push(this.ioc.listSerializer.serialize(item.objects));
+        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.PATH) {
+                    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 labels, labels_len;
+            try {
+                ({ v: labels, len: labels_len } = this.ioc.listSerializer.deserialize(cursor));
+                len += labels_len;
+            }
+            catch (err) {
+                err.message = '{labels}: ' + err.message;
+                throw err;
+            }
+            // TODO: should we check content of labels to make sure it's List< Set<String> > ?
+            cursor = cursor.slice(labels_len);
+            let objects, objects_len;
+            try {
+                ({ v: objects, len: objects_len } = this.ioc.listSerializer.deserialize(cursor));
+                len += objects_len;
+            }
+            catch (err) {
+                err.message = '{objects}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(objects_len);
+            const v = new Path(labels, objects);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

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