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

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

@@ -46,80 +46,53 @@ export default class VertexSerializer {
         // {id}
         bufs.push(this.ioc.anySerializer.serialize(item.id));
         // {label}
-        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.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));
         // {properties}
         bufs.push(this.ioc.listSerializer.serialize([], true));
         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.VERTEX) {
-                    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 id, id_len;
-            try {
-                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
-                len += id_len;
-            }
-            catch (err) {
-                err.message = '{id}: ' + err.message;
-                throw err;
-            }
-            cursor = cursor.slice(id_len);
-            let label, label_len;
-            try {
-                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
-                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
-                len += label_len;
-            }
-            catch (err) {
-                err.message = '{label}: ' + err.message;
-                throw err;
-            }
-            cursor = cursor.slice(label_len);
-            let properties, properties_len;
-            try {
-                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
-                len += properties_len;
-            }
-            catch (err) {
-                err.message = '{properties}: ' + err.message;
-                throw err;
-            }
-            cursor = cursor.slice(properties_len);
-            // null properties are deserialized into empty lists
-            const vertex_props = properties ? properties : [];
-            const v = new Vertex(id, label, vertex_props);
-            return { v, len };
+    /**
+     * Async deserialization of vertex value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Vertex>}
+     */
+    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] : 'vertex';
+        // {properties} fully qualified
+        const properties = await this.ioc.anySerializer.deserialize(reader);
+        return new Vertex(id, label, properties || [], labels);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Vertex|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.VERTEX) {
+            throw new Error(`VertexSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`VertexSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/utils.d.ts

@@ -1,9 +1,67 @@
-export declare function toLong(value: number | string): Long;
+export declare const INT32_MIN = -2147483648;
+export declare const INT32_MAX = 2147483647;
+export declare function toLong(value: number | string | bigint): Long;
 export declare class Long {
-    value: number | string;
-    constructor(value: number | string);
+    readonly value: number | string | bigint;
+    readonly type = "long";
+    constructor(value: number | string | bigint);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): string | number;
 }
-export declare function getUuid(): string;
+export declare class Int {
+    readonly value: number;
+    readonly type = "int";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Float {
+    readonly value: number;
+    readonly type = "float";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Double {
+    readonly value: number;
+    readonly type = "double";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Short {
+    readonly value: number;
+    readonly type = "short";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Byte {
+    readonly value: number;
+    readonly type = "byte";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare function toInt(value: number): Int;
+export declare function toFloat(value: number): Float;
+export declare function toDouble(value: number): Double;
+export declare function toShort(value: number): Short;
+export declare function toByte(value: number): Byte;
+export declare function unwrap(value: Float): number;
+export declare function unwrap(value: Double): number;
+export declare function unwrap(value: Int): number;
+export declare function unwrap(value: Long): number | string | bigint;
+export declare function unwrap(value: Short): number;
+export declare function unwrap(value: Byte): number;
+export declare function unwrap<T>(value: T): T;
+export declare function getUuid(): `${string}-${string}-${string}-${string}-${string}`;
 export declare const emptyArray: any[];
 export declare class ImmutableMap<K, V> extends Map<K, V> implements ReadonlyMap<K, V> {
     constructor(iterable?: Iterable<[K, V]>);

package/build/esm/utils.js

@@ -20,23 +20,162 @@
  * A module containing any utility functions.
  * @author Jorge Bay Gondra
  */
-import * as uuid from 'uuid';
-const gremlinVersion = '4.0.0-beta.2'; // DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+const gremlinVersion = '4.0.0-beta.3'; // DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+const INT64_MIN = -9223372036854775808n;
+const INT64_MAX = 9223372036854775807n;
+export const INT32_MIN = -2147483648;
+export const INT32_MAX = 2147483647;
 export function toLong(value) {
     return new Long(value);
 }
 export class Long {
     value;
+    type = 'long';
     constructor(value) {
         this.value = value;
-        if (typeof value !== 'string' && typeof value !== 'number') {
-            throw new TypeError('The value must be a string or a number');
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'bigint') {
+            throw new TypeError('The value must be a string, a number, or a bigint');
         }
+        if (typeof value === 'string') {
+            if (!/^(?:0|-?[1-9]\d*)$/.test(value)) {
+                throw new TypeError('Long value must be a valid integer');
+            }
+            const n = BigInt(value);
+            if (n < INT64_MIN || n > INT64_MAX) {
+                throw new RangeError('Long value is outside int64 range');
+            }
+        }
+        if (typeof value === 'number') {
+            if (!Number.isInteger(value)) {
+                throw new TypeError('Long value must be an integer');
+            }
+            if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+                throw new RangeError('Long number values outside safe integer range lose precision; use string or bigint');
+            }
+        }
+        if (typeof value === 'bigint') {
+            if (value < INT64_MIN || value > INT64_MAX) {
+                throw new RangeError('Long value is outside int64 range');
+            }
+        }
+    }
+    valueOf() {
+        if (typeof this.value === 'number')
+            return this.value;
+        const big = typeof this.value === 'bigint' ? this.value : BigInt(this.value);
+        if (big > BigInt(Number.MAX_SAFE_INTEGER) || big < BigInt(Number.MIN_SAFE_INTEGER)) {
+            throw new RangeError('Long value is outside safe integer range');
+        }
+        return Number(big);
+    }
+    [Symbol.toPrimitive](hint) {
+        if (hint === 'string')
+            return String(this.value);
+        return this.valueOf();
+    }
+    toJSON() {
+        if (typeof this.value === 'bigint')
+            return this.value.toString();
+        return this.value;
+    }
+}
+export class Int {
+    value;
+    type = 'int';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Int value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Int value must be a finite integer');
+        }
+        if (value < INT32_MIN || value > INT32_MAX) {
+            throw new RangeError('Int value must be within int32 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+export class Float {
+    value;
+    type = 'float';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Float value must be a number');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+export class Double {
+    value;
+    type = 'double';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Double value must be a number');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+export class Short {
+    value;
+    type = 'short';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Short value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Short value must be a finite integer');
+        }
+        if (value < -32768 || value > 32767) {
+            throw new RangeError('Short value must be within int16 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+export class Byte {
+    value;
+    type = 'byte';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Byte value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Byte value must be a finite integer');
+        }
+        if (value < -128 || value > 127) {
+            throw new RangeError('Byte value must be within int8 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+export function toInt(value) { return new Int(value); }
+export function toFloat(value) { return new Float(value); }
+export function toDouble(value) { return new Double(value); }
+export function toShort(value) { return new Short(value); }
+export function toByte(value) { return new Byte(value); }
+export function unwrap(value) {
+    if (value instanceof Long || value instanceof Int || value instanceof Float ||
+        value instanceof Double || value instanceof Short || value instanceof Byte) {
+        return value.value;
     }
+    return value;
 }
 export function getUuid() {
-    // TODO: replace with `globalThis.crypto.randomUUID` once supported Node version is bump to >=19
-    return uuid.v4();
+    return globalThis.crypto.randomUUID();
 }
 export const emptyArray = Object.freeze([]);
 export class ImmutableMap extends Map {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gremlin",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.3",
   "description": "JavaScript Gremlin Language Variant",
   "author": {
     "name": "Apache TinkerPop team"
@@ -20,6 +20,10 @@
   "type": "module",
   "main": "./build/cjs/index.cjs",
   "types": "./build/esm/index.d.ts",
+  "browser": {
+    "./build/esm/driver/dispatcher.js": "./build/esm/driver/dispatcher.browser.js",
+    "./build/cjs/driver/dispatcher.cjs": "./build/cjs/driver/dispatcher.browser.cjs"
+  },
   "exports": {
     ".": {
       "import": "./build/esm/index.js",
@@ -29,11 +33,17 @@
     "./language": {
       "import": "./build/esm/language/index.js",
       "types": "./build/esm/language/index.d.ts"
+    },
+    "./io": {
+      "import": "./build/esm/structure/io/binary/GraphBinary.js",
+      "types": "./build/esm/structure/io/binary/GraphBinary.d.ts"
     }
   },
   "typesVersions": {
     "*": {
-      "language": ["./build/esm/language/index.d.ts"]
+      "language": [
+        "./build/esm/language/index.d.ts"
+      ]
     }
   },
   "files": [
@@ -43,8 +53,7 @@
     "antlr4ng": "3.0.16",
     "buffer": "^6.0.3",
     "eventemitter3": "^5.0.1",
-    "readable-stream": "^4.5.2",
-    "uuid": "^9.0.1"
+    "undici": "6.27.0"
   },
   "optionalDependencies": {
     "@aws-sdk/credential-providers": "^3.967.0",
@@ -52,27 +61,25 @@
     "@smithy/signature-v4": "^5.3.12"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "~12.7.0",
-    "@eslint/js": "^9.16.0",
-    "@knighted/duel": "^4.0.2",
+    "@cucumber/cucumber": "~13.0.0",
+    "@eslint/js": "^10.0.1",
+    "@knighted/duel": "^4.1.1",
     "@tsconfig/node18": "^18.2.2",
-    "@types/readable-stream": "^4.0.10",
-    "@types/uuid": "^9.0.8",
     "antlr-ng": "^1.0.10",
-    "chai": "~4.5.0",
-    "chai-string": "~1.5.0",
+    "chai": "^6.2.2",
+    "chai-string": "^2.0.0",
     "colors": "1.4.0",
     "cross-env": "^10.1.0",
-    "eslint": "^9.36.0",
+    "deep-eql": "^5.0.2",
+    "eslint": "^10.3.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.0.0",
-    "globals": "^15.14.0",
-    "js-yaml": "^3.14.2",
+    "globals": "^17.5.0",
     "mocha": "^11.7.5",
     "prettier": "^3.0.0",
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.18",
-    "typescript": "^5.4.2"
+    "typescript": "~6.0.3"
   },
   "repository": {
     "type": "git",
@@ -93,10 +100,12 @@
     "integration-test": "npm run integration-test-graphbinary",
     "integration-test-graphbinary": "cross-env TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' mocha test/integration -t 5000",
     "TODO": "# test other mime types like graphbinary stringd",
-    "features": "npm run features-graphbinary",
+    "features": "npm run features-graphbinary && npm run features-graphbinary-params",
     "features-graphbinary": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong and not @StepWrite\" --import test/cucumber ../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/",
-    "features-docker": "npm run features-graphbinary-docker",
-    "features-graphbinary-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong and not @StepWrite\" --import test/cucumber ../gremlin-test/",
+    "features-graphbinary-params": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' PARAMETERIZE=true cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong and not @StepWrite\" --import test/cucumber ../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/",
+    "features-docker": "npm run features-graphbinary-docker && npm run features-graphbinary-params-docker",
+    "features-graphbinary-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong and not @StepWrite\" --import test/cucumber /gremlin-test/",
+    "features-graphbinary-params-docker": "cross-env NODE_OPTIONS='--loader ts-node/esm' TS_NODE_PROJECT='tsconfig.test.json' CLIENT_MIMETYPE='application/vnd.graphbinary-v4.0' PARAMETERIZE=true cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong and not @StepWrite\" --import test/cucumber /gremlin-test/",
     "lint": "eslint --ext .js .",
     "doc": "typedoc --out doc --readme README.md --entryPointStrategy expand --entryPoints 'lib/**/*.ts' --tsconfig tsconfig.json --exclude 'lib/language/grammar/**'"
   },