gremlin 3.8.1 → 4.0.0-beta.3

package/{lib → build/esm}/structure/io/binary/internals/utils.js

@@ -16,46 +16,34 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 /**
  * @author Igor Ostapenko
  */
-'use strict';
-
-const { Buffer } = require('buffer');
-
+import { Buffer } from 'buffer';
 /*
  * Deserialization error general constructor.
  */
-const des_error = ({ serializer, args, cursor, err }) => {
-  if (cursor === undefined) {
-    cursor = args[0]; // buffer
-  }
-  let cursor_tail = '';
-  if (cursor instanceof Buffer) {
-    if (cursor.length > 32) {
-      cursor_tail = '...';
+export const des_error = ({ serializer, args, cursor, err }) => {
+    if (cursor === undefined) {
+        cursor = args[0]; // buffer
     }
-    cursor = cursor.slice(0, 32).toString('hex');
-  }
-
-  const fullyQualifiedFormat = args[1];
-  const nullable = args[2];
-
-  let m = `${serializer.constructor.name}.deserialize(cursor=${cursor}${cursor_tail}`;
-  if (fullyQualifiedFormat !== undefined) {
-    m += `, fullyQualifiedFormat=${fullyQualifiedFormat}`;
-  }
-  if (nullable !== undefined) {
-    m += `, nullable=${nullable}`;
-  }
-  m += `): ${err.message.replace(/\.$/, '')}.`;
-
-  err.message = m;
-
-  return err;
-};
-
-module.exports = {
-  des_error,
+    let cursor_tail = '';
+    if (cursor instanceof Buffer) {
+        if (cursor.length > 32) {
+            cursor_tail = '...';
+        }
+        cursor = cursor.slice(0, 32).toString('hex');
+    }
+    const fullyQualifiedFormat = args[1];
+    const nullable = args[2];
+    let m = `${serializer.constructor.name}.deserialize(cursor=${cursor}${cursor_tail}`;
+    if (fullyQualifiedFormat !== undefined) {
+        m += `, fullyQualifiedFormat=${fullyQualifiedFormat}`;
+    }
+    if (nullable !== undefined) {
+        m += `, nullable=${nullable}`;
+    }
+    m += `): ${err.message.replace(/\.$/, '')}.`;
+    err.message = m;
+    return err;
 };

package/build/esm/utils.d.ts

@@ -0,0 +1,78 @@
+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 {
+    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 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]>);
+    set(): this;
+    ['delete'](): boolean;
+    clear(): void;
+}
+export declare function getUserAgentHeader(): string;
+export declare const getUserAgent: () => Promise<string | undefined>;
+export declare const toArrayBuffer: (buffer: Buffer) => ArrayBuffer | SharedArrayBuffer;
+export declare const DeferredPromise: <T>() => Promise<T> & {
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};

package/build/esm/utils.js

@@ -0,0 +1,237 @@
+/*
+ *  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.
+ */
+/**
+ * A module containing any utility functions.
+ * @author Jorge Bay Gondra
+ */
+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' && 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() {
+    return globalThis.crypto.randomUUID();
+}
+export const emptyArray = Object.freeze([]);
+export class ImmutableMap extends Map {
+    constructor(iterable) {
+        super(iterable);
+    }
+    set() {
+        return this;
+    }
+    ['delete']() {
+        return false;
+    }
+    clear() { }
+}
+async function generateNodeUserAgent() {
+    const os = await import('node:os');
+    const applicationName = (process?.env.npm_package_name ?? 'NotAvailable').replace('_', ' ');
+    let runtimeVersion;
+    let osName;
+    let osVersion;
+    let cpuArch;
+    runtimeVersion = osName = osVersion = cpuArch = 'NotAvailable';
+    if (process != null) {
+        if (process.version) {
+            runtimeVersion = process.version.replace(' ', '_');
+        }
+        if (process.arch) {
+            cpuArch = process.arch.replace(' ', '_');
+        }
+    }
+    if (os != null) {
+        osName = os.platform().replace(' ', '_');
+        osVersion = os.release().replace(' ', '_');
+    }
+    const userAgent = `${applicationName} Gremlin-Javascript.${gremlinVersion} ${runtimeVersion} ${osName}.${osVersion} ${cpuArch}`;
+    return userAgent;
+}
+export function getUserAgentHeader() {
+    return 'User-Agent';
+}
+export const getUserAgent = async () => {
+    if ('navigator' in globalThis) {
+        return globalThis.navigator.userAgent;
+    }
+    if (process?.versions?.node !== undefined) {
+        return await generateNodeUserAgent();
+    }
+    return undefined;
+};
+export const toArrayBuffer = (buffer) => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+export const DeferredPromise = () => {
+    let resolve = (value) => { };
+    let reject = (reason) => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return Object.assign(promise, { resolve, reject });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gremlin",
-  "version": "3.8.1",
+  "version": "4.0.0-beta.3",
   "description": "JavaScript Gremlin Language Variant",
   "author": {
     "name": "Apache TinkerPop team"
@@ -17,28 +17,69 @@
     "graphdb"
   ],
   "license": "Apache-2.0",
+  "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",
+      "require": "./build/cjs/index.cjs",
+      "types": "./build/esm/index.d.ts"
+    },
+    "./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"
+      ]
+    }
+  },
+  "files": [
+    "build"
+  ],
   "dependencies": {
+    "antlr4ng": "3.0.16",
     "buffer": "^6.0.3",
     "eventemitter3": "^5.0.1",
-    "readable-stream": "^4.5.2",
-    "uuid": "^9.0.1",
-    "ws": "^8.16.0"
+    "undici": "6.27.0"
+  },
+  "optionalDependencies": {
+    "@aws-sdk/credential-providers": "^3.967.0",
+    "@smithy/hash-node": "^4.2.12",
+    "@smithy/signature-v4": "^5.3.12"
   },
   "devDependencies": {
-    "chai": "~4.5.0",
-    "chai-string": "~1.5.0",
+    "@cucumber/cucumber": "~13.0.0",
+    "@eslint/js": "^10.0.1",
+    "@knighted/duel": "^4.1.1",
+    "@tsconfig/node18": "^18.2.2",
+    "antlr-ng": "^1.0.10",
+    "chai": "^6.2.2",
+    "chai-string": "^2.0.0",
     "colors": "1.4.0",
     "cross-env": "^10.1.0",
-    "@cucumber/cucumber": "~12.7.0",
-    "@eslint/js": "^9.16.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",
-    "jsdoc": "^4.0.5",
-    "js-yaml": "^3.14.2",
+    "globals": "^17.5.0",
     "mocha": "^11.7.5",
-    "prettier": "^3.0.0"
+    "prettier": "^3.0.0",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.18",
+    "typescript": "~6.0.3"
   },
   "repository": {
     "type": "git",
@@ -49,22 +90,26 @@
     "url": "https://issues.apache.org/jira/browse/TINKERPOP"
   },
   "scripts": {
+    "generate": "mkdir -p lib/language/grammar && antlr-ng -Dlanguage=TypeScript -visitor --generate-listener --exact-output-dir -o lib/language/grammar ../../gremlin-language/src/main/antlr4/Gremlin.g4",
+    "prebuild": "node scripts/patch-antlr4ng.js && npm run generate",
+    "_prebuild_note": "patch-antlr4ng.js is a build-time stop-gap for antlr4ng missing .d.cts CJS type declarations (antlr4ng issues #23/#26). antlr4ng is pinned to an exact version in dependencies. Before upgrading antlr4ng, verify the patch still applies or that upstream has fixed the issue.",
+    "build": "rm -rf build && duel --dirs",
+    "prepare": "npm run generate && npm run build",
     "test": "npm run unit-test && npm run integration-test",
-    "unit-test": "mocha test/unit/*",
-    "integration-test": "npm run integration-test-graphson30 && npm run integration-test-graphbinary",
-    "integration-test-graphson30": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' ./node_modules/mocha/bin/mocha.js test/integration -t 5000",
-    "integration-test-graphbinary": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' ./node_modules/mocha/bin/mocha.js test/integration -t 5000",
+    "unit-test": "cross-env TS_NODE_PROJECT='tsconfig.test.json' mocha 'test/unit/**/*.{js,ts}'",
+    "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-graphson30 && npm run features-graphbinary",
-    "features-graphson30": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --require test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/",
-    "features-graphbinary": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --require test/cucumber ../../../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/",
-    "features-docker": "npm run features-graphson30-docker && npm run features-graphbinary-docker",
-    "features-graphson30-docker": "cross-env CLIENT_MIMETYPE='application/vnd.gremlin-v3.0+json' cucumber-js --tags \"not @DataUUID and not @DataLong\" --require test/cucumber ../gremlin-test/",
-    "features-graphbinary-docker": "cross-env CLIENT_MIMETYPE='application/vnd.graphbinary-v1.0' cucumber-js --tags \"not @DataBigDecimal and not @DataBigInt and not @DataUUID and not @DataLong\" --require test/cucumber ../gremlin-test/",
-    "lint": "eslint .",
-    "doc": "jsdoc -r -d doc -R README.md lib/"
+    "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-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/**'"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   }
 }

package/.nvmrc

@@ -1 +0,0 @@
-18

package/NOTICE

@@ -1,5 +0,0 @@
-Apache TinkerPop
-Copyright 2015-2026 The Apache Software Foundation.
-
-This product includes software developed at
-The Apache Software Foundation (http://www.apache.org/).