gremlin 3.8.1 → 4.0.0-beta.3

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

@@ -0,0 +1,74 @@
+/*
+ *  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 DoubleSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.DOUBLE] = this;
+    }
+    canBeUsedFor(value) {
+        return typeof value === 'number' && !Number.isInteger(value);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.DOUBLE, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.DOUBLE, 0x00]));
+        }
+        const v = Buffer.alloc(8);
+        v.writeDoubleBE(item);
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readDoubleBE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.DOUBLE) {
+            throw new Error(`DoubleSerializer: 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(`DoubleSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,22 @@
+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>;
+    /**
+     * Async deserialization of edge value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Edge>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Edge>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Edge|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Edge | null>;
+}
+import { Edge } from '../../../graph.js';
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,143 @@
+/*
+ *  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 = item.labels instanceof Set
+            ? Array.from(item.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 inVLabels = item.inV && item.inV.labels instanceof Set
+            ? Array.from(item.inV.labels)
+            : item.inV && Array.isArray(item.inV.label)
+                ? item.inV.label
+                : item.inV && item.inV.label
+                    ? [item.inV.label]
+                    : [];
+        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 outVLabels = item.outV && item.outV.labels instanceof Set
+            ? Array.from(item.outV.labels)
+            : item.outV && Array.isArray(item.outV.label)
+                ? item.outV.label
+                : item.outV && item.outV.label
+                    ? [item.outV.label]
+                    : [];
+        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);
+    }
+    /**
+     * Async deserialization of edge value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Edge>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {id} fully qualified
+        const id = await this.ioc.anySerializer.deserialize(reader);
+        // {label} bare list - full multi-label list
+        const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const labels = Array.isArray(labelList) ? labelList : labelList ? [labelList] : [];
+        const label = labels.length > 0 ? labels[0] : 'edge';
+        // {inVId} fully qualified
+        const inVId = await this.ioc.anySerializer.deserialize(reader);
+        // {inVLabel} bare list - full multi-label list
+        const inVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const inVLabels = Array.isArray(inVLabelList) ? inVLabelList : inVLabelList ? [inVLabelList] : [];
+        const inVLabel = inVLabels.length > 0 ? inVLabels[0] : 'vertex';
+        // {outVId} fully qualified
+        const outVId = await this.ioc.anySerializer.deserialize(reader);
+        // {outVLabel} bare list - full multi-label list
+        const outVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const outVLabels = Array.isArray(outVLabelList) ? outVLabelList : outVLabelList ? [outVLabelList] : [];
+        const outVLabel = outVLabels.length > 0 ? outVLabels[0] : 'vertex';
+        // {parent} fully qualified (always null in current TinkerPop)
+        await this.ioc.anySerializer.deserialize(reader);
+        // {properties} fully qualified
+        const properties = await this.ioc.anySerializer.deserialize(reader);
+        return new Edge(id, new Vertex(outVId, outVLabel, null, outVLabels), label, new Vertex(inVId, inVLabel, null, inVLabels), properties || [], labels);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Edge|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.EDGE) {
+            throw new Error(`EdgeSerializer: 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(`EdgeSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,39 @@
+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;
+    /**
+     * Resolve the type_code (already read by AnySerializer) to a typeName.
+     * Called by AnySerializer before dispatching.
+     */
+    _typeNameForCode(type_code: any): "Direction" | "Merge" | "T" | undefined;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode - the type_code byte already read by AnySerializer
+     * @returns {Promise<EnumValue>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<EnumValue>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<EnumValue|null>}
+     */
+    deserialize(reader: StreamReader): Promise<EnumValue | null>;
+}
+import { EnumValue } from '../../../../process/traversal.js';

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

@@ -0,0 +1,112 @@
+/*
+ *  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);
+    }
+    /**
+     * Resolve the type_code (already read by AnySerializer) to a typeName.
+     * Called by AnySerializer before dispatching.
+     */
+    _typeNameForCode(type_code) {
+        if (type_code === this.ioc.DataType.DIRECTION) {
+            return 'Direction';
+        }
+        if (type_code === this.ioc.DataType.MERGE) {
+            return 'Merge';
+        }
+        if (type_code === this.ioc.DataType.T) {
+            return 'T';
+        }
+        return undefined;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode - the type_code byte already read by AnySerializer
+     * @returns {Promise<EnumValue>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const typeName = this._typeNameForCode(typeCode);
+        // elementName is a fully-qualified String (type_code + value_flag + length + text)
+        const elementName = await this.ioc.stringSerializer.deserialize(reader);
+        if (typeName) {
+            return this.types[typeName].enum[elementName];
+        }
+        return new EnumValue(undefined, elementName);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<EnumValue|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (!this._typeNameForCode(type_code)) {
+            throw new Error(`EnumSerializer: 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(`EnumSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,19 @@
+export default class FloatSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @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/esm/structure/io/binary/internals/FloatSerializer.js

@@ -0,0 +1,74 @@
+/*
+ *  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);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readFloatBE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.FLOAT) {
+            throw new Error(`FloatSerializer: 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(`FloatSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * GraphBinary reader.
+ */
+export default class GraphBinaryReader {
+    constructor(ioc: any);
+    ioc: any;
+    pdtRegistry: any;
+    get mimeType(): string;
+    /**
+     * Read a complete response from a Buffer. Used by the non-streaming submit() path.
+     * Returns the full { status, result } object after reading all data.
+     * @param {Buffer} buffer
+     * @returns {Promise<{status: {code, message, exception}, result: {data: any[], bulked: boolean}}>}
+     */
+    readResponse(buffer: Buffer): Promise<{
+        status: {
+            code: any;
+            message: any;
+            exception: any;
+        };
+        result: {
+            data: any[];
+            bulked: boolean;
+        };
+    }>;
+    /**
+     * Stream results from a StreamReader, yielding each value as it's deserialized.
+     * Used by the streaming Connection.stream() path.
+     *
+     * Note: In the GraphBinary v4 streaming protocol, the status (including error codes)
+     * is sent *after* all result data. This means values are yielded to the consumer as
+     * they arrive, and a server error is only thrown after all values have been yielded.
+     * Consumers should be aware that partial results may have been processed before a
+     * ResponseError is thrown.
+     *
+     * @param {StreamReader} reader
+     * @returns {AsyncGenerator<any>}
+     */
+    readResponseStream(reader: StreamReader): AsyncGenerator<any>;
+    #private;
+}
+import { Buffer } from 'buffer';
+import StreamReader from './StreamReader.js';