gremlin 3.8.0 → 4.0.0-beta.2

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

@@ -0,0 +1,138 @@
+"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 SetSerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Set;
+    }
+    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.size;
+        if (length < 0) {
+            length = 0;
+        }
+        if (length > this.ioc.intSerializer.INT32_MAX) {
+            throw new Error(`Set 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 (const i of item) {
+            bufs.push(this.ioc.anySerializer.serialize(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 typeCode = cursor.readUInt8();
+                len++;
+                if (typeCode !== this.ID) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const valueFlag = cursor.readUInt8();
+                len++;
+                if (valueFlag === 1) {
+                    return { v: null, len };
+                }
+                if (valueFlag !== 0 && valueFlag !== 2) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                isBulked = valueFlag === 2;
+                cursor = cursor.slice(1);
+            }
+            let length, lengthLen;
+            try {
+                ({ v: length, len: lengthLen } = this.ioc.intSerializer.deserialize(cursor, false));
+                len += lengthLen;
+            }
+            catch (err) {
+                err.message = '{length}: ' + err.message;
+                throw err;
+            }
+            if (length < 0) {
+                throw new Error('{length} is less than zero');
+            }
+            cursor = cursor.slice(lengthLen);
+            const v = new Set();
+            for (let i = 0; i < length; i++) {
+                let value, valueLen;
+                try {
+                    ({ v: value, len: valueLen } = this.ioc.anySerializer.deserialize(cursor));
+                    len += valueLen;
+                }
+                catch (err) {
+                    err.message = `{item_${i}}: ` + err.message;
+                    throw err;
+                }
+                cursor = cursor.slice(valueLen);
+                if (isBulked) {
+                    if (cursor.length < 8) {
+                        throw new Error(`{item_${i}}: bulk count is missing`);
+                    }
+                    cursor.readBigInt64BE();
+                    len += 8;
+                    cursor = cursor.slice(8);
+                    // Set.add is idempotent; bulk count only affects cardinality, not Set membership
+                    v.add(value);
+                }
+                else {
+                    v.add(value);
+                }
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = SetSerializer;

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

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

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

@@ -0,0 +1,91 @@
+"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 ShortSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.SHORT] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used during serialization
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.SHORT, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.SHORT, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(2);
+        v.writeInt16BE(item); // TODO: what if item is not within int16 limits, for now writeInt16BE would error
+        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.SHORT) {
+                    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 < 2) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 2;
+            const v = cursor.readInt16BE();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = ShortSerializer;

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

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

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

@@ -0,0 +1,107 @@
+"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 StringSerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return typeof value === 'string';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ID, 0x01]);
+            }
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ID, 0x00]));
+        }
+        const v = buffer_1.Buffer.from(String(item), 'utf8');
+        bufs.push(this.ioc.intSerializer.serialize(v.length, false)); // TODO: what if len > INT32_MAX, for now it's backed by logic of IntSerializer.serialize itself
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
+        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.ID) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (fullyQualifiedFormat || nullable) {
+                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('unexpected {text_value} length');
+            }
+            len += length;
+            const v = cursor.toString('utf8', 0, length);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = StringSerializer;

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

@@ -0,0 +1,11 @@
+export default class StringSerializer {
+    constructor(ioc: any, ID: any);
+    ioc: any;
+    ID: any;
+    canBeUsedFor(value: any): value is string;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, nullable?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}

package/{lib/driver/auth/authenticator.js → build/cjs/structure/io/binary/internals/StubSerializer.cjs}

@@ -1,3 +1,4 @@
+"use strict";
 /*
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
@@ -7,7 +8,7 @@
  *  "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
+ *    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
@@ -16,23 +17,16 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
-'use strict';
-
-/** @abstract */
-class Authenticator {
-  constructor(options) {
-    this._options = options;
-  }
-
-  /**
-   * @abstract
-   * Evaluates the challenge from the server and returns appropriate response.
-   * @param {String} challenge Challenge string presented by the server.
-   */
-  evaluateChallenge(challenge) {
-    throw new Error('evaluateChallenge should be implemented');
-  }
+Object.defineProperty(exports, "__esModule", { value: true });
+class StubSerializer {
+    constructor(ioc, typeCode, typeName) {
+        this.ioc = ioc;
+        this.typeCode = typeCode;
+        this.typeName = typeName;
+        this.ioc.serializers[typeCode] = this;
+    }
+    deserialize() {
+        throw new Error(`${this.typeName} deserialization is not yet implemented`);
+    }
 }
-
-module.exports = Authenticator;
+exports.default = StubSerializer;

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

@@ -0,0 +1,7 @@
+export default class StubSerializer {
+    constructor(ioc: any, typeCode: any, typeName: any);
+    ioc: any;
+    typeCode: any;
+    typeName: any;
+    deserialize(): void;
+}

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

@@ -0,0 +1,70 @@
+"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 UnspecifiedNullSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.UNSPECIFIED_NULL] = this;
+    }
+    canBeUsedFor(value) {
+        return value === null || value === undefined;
+    }
+    serialize(item) {
+        // fullyQualifiedFormat always is true
+        return buffer_1.Buffer.from([this.ioc.DataType.UNSPECIFIED_NULL, 0x01]);
+    }
+    deserialize(buffer) {
+        // fullyQualifiedFormat always is 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');
+            }
+            const type_code = cursor.readUInt8();
+            len++;
+            if (type_code !== this.ioc.DataType.UNSPECIFIED_NULL) {
+                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) {
+                throw new Error('unexpected {value_flag}');
+            }
+            cursor = cursor.slice(1);
+            return { v: null, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = UnspecifiedNullSerializer;

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

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

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

@@ -0,0 +1,109 @@
+"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 UuidSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.UUID] = this;
+    }
+    canBeUsedFor(value) {
+        // TODO: any idea to support UUID automatic serialization via AnySerializer in future?
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.UUID, 0x01]);
+            }
+            return buffer_1.Buffer.from([
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]);
+        }
+        const uuid_str = String(item)
+            .replace(/^urn:uuid:/, '')
+            .replace(/[{}-]/g, '');
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.UUID, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(16, 0);
+        for (let i = 0; i < 16 && i * 2 < uuid_str.length; i++) {
+            v[i] = parseInt(uuid_str.slice(i * 2, i * 2 + 2), 16);
+        }
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
+        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.UUID) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (fullyQualifiedFormat || nullable) {
+                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 < 16) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 16;
+            // Example: 2075278D-F624-4B2B-960D-25D374D57C04
+            const v = cursor.slice(0, 4).toString('hex') +
+                '-' +
+                cursor.slice(4, 6).toString('hex') +
+                '-' +
+                cursor.slice(6, 8).toString('hex') +
+                '-' +
+                cursor.slice(8, 10).toString('hex') +
+                '-' +
+                cursor.slice(10, 16).toString('hex');
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = UuidSerializer;

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

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