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

package/build/esm/process/graph-traversal.d.ts

@@ -17,6 +17,8 @@ export declare class GraphTraversalSource {
     graphTraversalSourceClass: typeof GraphTraversalSource;
     graphTraversalClass: typeof GraphTraversal;
     remoteConnection?: RemoteConnection;
+    /** @internal - set by Transaction.begin() for gtx.tx() to return the owning transaction */
+    _boundTransaction?: Transaction;
     /**
      * Creates a new instance of {@link GraphTraversalSource}.
      * @param {Graph} graph
@@ -31,6 +33,37 @@ export declare class GraphTraversalSource {
      * @returns {Transaction}
      */
     tx(): Transaction;
+    /**
+     * Runs a unit of work inside a transaction, owning the full lifecycle.
+     *
+     * The transaction is begun automatically and the resulting transaction-bound
+     * <code>GraphTraversalSource</code> (<code>gtx</code>) is passed to the
+     * callback as its sole argument. Only <code>gtx</code> is in scope inside the
+     * callback, which avoids accidentally issuing traversals against the
+     * non-transactional <code>g</code>.
+     *
+     * On normal completion of the callback the transaction is committed; on any
+     * abnormal exit (a thrown error or a rejected promise) the transaction is
+     * rolled back. This is a single-shot operation: there is exactly one attempt
+     * (begin -> run -> commit/rollback) and no retry. A second transaction may not
+     * be opened from inside the callback (calling <code>gtx.tx().begin()</code>
+     * throws via the existing double-begin guard).
+     *
+     * The callback may be synchronous or asynchronous; its return value (or the
+     * value its promise resolves to) is awaited and returned from
+     * <code>executeInTx</code>. If the callback returns nothing the result is
+     * <code>undefined</code>.
+     *
+     * Error handling: if the callback throws/rejects, the original error is
+     * re-raised unchanged after rollback is attempted. If the commit itself fails,
+     * the commit error propagates and a rollback is still attempted afterward for
+     * server-side hygiene. In both cases a failed rollback during cleanup is logged
+     * as a warning and never replaces the primary error.
+     *
+     * @param txWork callback that receives the transaction-bound GraphTraversalSource
+     * @returns {Promise<T>} resolves to the callback's value (undefined if none)
+     */
+    executeInTx<T>(txWork: (gtx: GraphTraversalSource) => T | Promise<T>): Promise<T>;
     /**
      * @param graphComputer
      * @param workers
@@ -150,6 +183,13 @@ export declare class GraphTraversalSource {
      * @returns {GraphTraversal}
      */
     union(...args: any[]): GraphTraversal;
+    /**
+     * Spawns a {@link GraphTraversal} by executing a declarative pattern match query.
+     * @param {string} matchQuery - the declarative query string
+     * @param {Record<string, any>} [params] - optional query parameters
+     * @returns {GraphTraversal}
+     */
+    match(matchQuery: string, params?: Record<string, any>): GraphTraversal;
 }
 /**
  * Represents a graph traversal.
@@ -184,6 +224,12 @@ export declare class GraphTraversal extends Traversal {
      * @returns {GraphTraversal}
      */
     addV(...args: any[]): this;
+    /**
+     * Graph traversal addLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addLabel(...args: any[]): this;
     /**
      * Graph traversal aggregate method.
      * @param {...Object} args
@@ -388,6 +434,18 @@ export declare class GraphTraversal extends Traversal {
      * @returns {GraphTraversal}
      */
     drop(...args: any[]): this;
+    /**
+     * Graph traversal dropLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabel(...args: any[]): this;
+    /**
+     * Graph traversal dropLabels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabels(...args: any[]): this;
     /**
      * Graph traversal element method.
      * @param {...Object} args
@@ -556,6 +614,12 @@ export declare class GraphTraversal extends Traversal {
      * @returns {GraphTraversal}
      */
     label(...args: any[]): this;
+    /**
+     * Graph traversal labels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    labels(...args: any[]): this;
     /**
      * Graph traversal length method.
      * @param {...Object} args
@@ -593,11 +657,24 @@ export declare class GraphTraversal extends Traversal {
      */
     map(...args: any[]): this;
     /**
-     * Graph traversal match method.
-     * @param {...Object} args
+     * Graph traversal match method. Accepts either traversal-based match patterns
+     * (deprecated) or a declarative query string.
+     * @param {string} matchQuery - declarative query string
+     * @returns {GraphTraversal}
+     */
+    match(matchQuery: string): this;
+    /**
+     * @param {string} matchQuery - declarative query string
+     * @param {Record<string, any>} params - query parameters
+     * @returns {GraphTraversal}
+     */
+    match(matchQuery: string, params: Record<string, any>): this;
+    /**
+     * @deprecated Use match(String) for declarative pattern matching.
+     * @param {...any} matchTraversals - traversal-based match patterns
      * @returns {GraphTraversal}
      */
-    match(...args: any[]): this;
+    match(...matchTraversals: any[]): this;
     /**
      * Graph traversal math method.
      * @param {...Object} args
@@ -1011,6 +1088,7 @@ export declare const statics: {
     V: (...args: any[]) => any;
     addE: (...args: any[]) => any;
     addV: (...args: any[]) => any;
+    addLabel: (...args: any[]) => any;
     aggregate: (...args: any[]) => any;
     all: (...args: any[]) => any;
     and: (...args: any[]) => any;
@@ -1043,6 +1121,8 @@ export declare const statics: {
     discard: (...args: any[]) => any;
     disjunct: (...args: any[]) => any;
     drop: (...args: any[]) => any;
+    dropLabel: (...args: any[]) => any;
+    dropLabels: (...args: any[]) => any;
     element: (...args: any[]) => any;
     elementMap: (...args: any[]) => any;
     emit: (...args: any[]) => any;
@@ -1070,6 +1150,7 @@ export declare const statics: {
     is: (...args: any[]) => any;
     key: (...args: any[]) => any;
     label: (...args: any[]) => any;
+    labels: (...args: any[]) => any;
     length: (...args: any[]) => any;
     limit: (...args: any[]) => any;
     local: (...args: any[]) => any;

package/build/esm/process/graph-traversal.js

@@ -23,6 +23,7 @@ import { Traversal, cardinality } from './traversal.js';
 import { Transaction } from './transaction.js';
 import { TraversalStrategies, VertexProgramStrategy, OptionsStrategy } from './traversal-strategy.js';
 import { Vertex } from '../structure/graph.js';
+import DriverRemoteConnection from '../driver/driver-remote-connection.js';
 import GremlinLang from './gremlin-lang.js';
 /**
  * Represents the primary DSL of the Gremlin traversal machine.
@@ -34,6 +35,8 @@ export class GraphTraversalSource {
     graphTraversalSourceClass;
     graphTraversalClass;
     remoteConnection;
+    /** @internal - set by Transaction.begin() for gtx.tx() to return the owning transaction */
+    _boundTransaction;
     /**
      * Creates a new instance of {@link GraphTraversalSource}.
      * @param {Graph} graph
@@ -56,11 +59,89 @@ export class GraphTraversalSource {
      * @returns {Transaction}
      */
     tx() {
-        // you can't do g.tx().begin().tx() - no child transactions
-        if (this.remoteConnection) {
+        // If this GTS is already bound to a transaction, return that transaction.
+        if (this._boundTransaction) {
+            return this._boundTransaction;
+        }
+        if (!this.remoteConnection) {
+            throw new Error('Remote connection is required for transactions');
+        }
+        // If the DRC has a transactionId, it was created by a Transaction.begin().
+        // But we don't have the Transaction reference here (only _boundTransaction above).
+        if (this.remoteConnection instanceof DriverRemoteConnection && this.remoteConnection.transactionId) {
             throw new Error('This TraversalSource is already bound to a transaction - child transactions are not supported');
         }
-        return new Transaction(this);
+        // Extract the Client from the DriverRemoteConnection.
+        const client = this.remoteConnection._client;
+        return new Transaction(client);
+    }
+    /**
+     * Runs a unit of work inside a transaction, owning the full lifecycle.
+     *
+     * The transaction is begun automatically and the resulting transaction-bound
+     * <code>GraphTraversalSource</code> (<code>gtx</code>) is passed to the
+     * callback as its sole argument. Only <code>gtx</code> is in scope inside the
+     * callback, which avoids accidentally issuing traversals against the
+     * non-transactional <code>g</code>.
+     *
+     * On normal completion of the callback the transaction is committed; on any
+     * abnormal exit (a thrown error or a rejected promise) the transaction is
+     * rolled back. This is a single-shot operation: there is exactly one attempt
+     * (begin -> run -> commit/rollback) and no retry. A second transaction may not
+     * be opened from inside the callback (calling <code>gtx.tx().begin()</code>
+     * throws via the existing double-begin guard).
+     *
+     * The callback may be synchronous or asynchronous; its return value (or the
+     * value its promise resolves to) is awaited and returned from
+     * <code>executeInTx</code>. If the callback returns nothing the result is
+     * <code>undefined</code>.
+     *
+     * Error handling: if the callback throws/rejects, the original error is
+     * re-raised unchanged after rollback is attempted. If the commit itself fails,
+     * the commit error propagates and a rollback is still attempted afterward for
+     * server-side hygiene. In both cases a failed rollback during cleanup is logged
+     * as a warning and never replaces the primary error.
+     *
+     * @param txWork callback that receives the transaction-bound GraphTraversalSource
+     * @returns {Promise<T>} resolves to the callback's value (undefined if none)
+     */
+    async executeInTx(txWork) {
+        const tx = this.tx();
+        const gtx = await tx.begin();
+        let result;
+        // Phase 1: run the user's work. If it throws, roll back and rethrow the body error - the
+        // throw below exits the method, so a failed body never reaches the commit in phase 2.
+        try {
+            result = await txWork(gtx);
+        }
+        catch (bodyError) {
+            try {
+                await tx.rollback();
+            }
+            catch (rollbackError) {
+                console.warn('Rollback failed after transaction body error', rollbackError);
+            }
+            // Re-raise the exact original error; rollback failures never replace it.
+            throw bodyError;
+        }
+        // Phase 2: the body succeeded, so commit. A separate try because this failure mode is
+        // distinct (commit, not body): we still roll back for server hygiene, then rethrow the
+        // commit error as the primary error.
+        try {
+            await tx.commit();
+        }
+        catch (commitError) {
+            try {
+                // Attempt rollback so the server does not keep the transaction around.
+                await tx.rollback();
+            }
+            catch (rollbackError) {
+                console.warn('Rollback failed after commit failure', rollbackError);
+            }
+            // The commit error stays primary; rollback was only for server hygiene.
+            throw commitError;
+        }
+        return result;
     }
     /**
      * @param graphComputer
@@ -111,6 +192,10 @@ export class GraphTraversalSource {
         }
         glStrategies[glStrategies.length - 1].configuration[key] = val;
         const gl = new GremlinLang(this.gremlinLang);
+        // Render multilabel/singlelabel in gremlin text (temporary until these options are removed)
+        if (key === 'multilabel' || key === 'singlelabel') {
+            gl.appendGremlin(`.with("${key}")`);
+        }
         return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
     }
     /**
@@ -269,6 +354,17 @@ export class GraphTraversalSource {
         const gl = new GremlinLang(this.gremlinLang).addStep('union', args);
         return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
     }
+    /**
+     * Spawns a {@link GraphTraversal} by executing a declarative pattern match query.
+     * @param {string} matchQuery - the declarative query string
+     * @param {Record<string, any>} [params] - optional query parameters
+     * @returns {GraphTraversal}
+     */
+    match(matchQuery, params) {
+        const args = params !== undefined ? [matchQuery, params] : [matchQuery];
+        const gl = new GremlinLang(this.gremlinLang).addStep('match', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
 }
 /**
  * Represents a graph traversal.
@@ -324,6 +420,15 @@ export class GraphTraversal extends Traversal {
         this.gremlinLang.addStep('addV', args);
         return this;
     }
+    /**
+     * Graph traversal addLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addLabel(...args) {
+        this.gremlinLang.addStep('addLabel', args);
+        return this;
+    }
     /**
      * Graph traversal aggregate method.
      * @param {...Object} args
@@ -630,6 +735,24 @@ export class GraphTraversal extends Traversal {
         this.gremlinLang.addStep('drop', args);
         return this;
     }
+    /**
+     * Graph traversal dropLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabel(...args) {
+        this.gremlinLang.addStep('dropLabel', args);
+        return this;
+    }
+    /**
+     * Graph traversal dropLabels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabels(...args) {
+        this.gremlinLang.addStep('dropLabels', args);
+        return this;
+    }
     /**
      * Graph traversal element method.
      * @param {...Object} args
@@ -887,6 +1010,15 @@ export class GraphTraversal extends Traversal {
         this.gremlinLang.addStep('label', args);
         return this;
     }
+    /**
+     * Graph traversal labels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    labels(...args) {
+        this.gremlinLang.addStep('labels', args);
+        return this;
+    }
     /**
      * Graph traversal length method.
      * @param {...Object} args
@@ -941,11 +1073,6 @@ export class GraphTraversal extends Traversal {
         this.gremlinLang.addStep('map', args);
         return this;
     }
-    /**
-     * Graph traversal match method.
-     * @param {...Object} args
-     * @returns {GraphTraversal}
-     */
     match(...args) {
         this.gremlinLang.addStep('match', args);
         return this;
@@ -1570,6 +1697,7 @@ export const statics = {
     V: (...args) => callOnEmptyTraversal('V', args),
     addE: (...args) => callOnEmptyTraversal('addE', args),
     addV: (...args) => callOnEmptyTraversal('addV', args),
+    addLabel: (...args) => callOnEmptyTraversal('addLabel', args),
     aggregate: (...args) => callOnEmptyTraversal('aggregate', args),
     all: (...args) => callOnEmptyTraversal('all', args),
     and: (...args) => callOnEmptyTraversal('and', args),
@@ -1602,6 +1730,8 @@ export const statics = {
     discard: (...args) => callOnEmptyTraversal('discard', args),
     disjunct: (...args) => callOnEmptyTraversal('disjunct', args),
     drop: (...args) => callOnEmptyTraversal('drop', args),
+    dropLabel: (...args) => callOnEmptyTraversal('dropLabel', args),
+    dropLabels: (...args) => callOnEmptyTraversal('dropLabels', args),
     element: (...args) => callOnEmptyTraversal('element', args),
     elementMap: (...args) => callOnEmptyTraversal('elementMap', args),
     emit: (...args) => callOnEmptyTraversal('emit', args),
@@ -1629,6 +1759,7 @@ export const statics = {
     is: (...args) => callOnEmptyTraversal('is', args),
     key: (...args) => callOnEmptyTraversal('key', args),
     label: (...args) => callOnEmptyTraversal('label', args),
+    labels: (...args) => callOnEmptyTraversal('labels', args),
     length: (...args) => callOnEmptyTraversal('length', args),
     limit: (...args) => callOnEmptyTraversal('limit', args),
     local: (...args) => callOnEmptyTraversal('local', args),

package/build/esm/process/gremlin-lang.d.ts

@@ -1,15 +1,20 @@
 import { OptionsStrategy } from './traversal-strategy.js';
+import { PDTRegistry } from '../structure/PDTRegistry.js';
 export default class GremlinLang {
     private gremlin;
     private optionsStrategies;
     private parameters;
+    pdtRegistry: PDTRegistry | null;
     constructor(toClone?: GremlinLang);
     getOptionsStrategies(): OptionsStrategy[];
-    addG(g: string): void;
+    appendGremlin(text: string): void;
     getParameters(): Map<string, any>;
     private _predicateAsString;
     private _argAsString;
     addStep(name: string, args?: any[]): GremlinLang;
     addSource(name: string, args?: any[]): GremlinLang;
+    private static _fpAsString;
     getGremlin(prefix?: string): string;
+    getParametersAsString(): string;
+    static convertParametersToString(params: Map<string, any> | null): string;
 }

package/build/esm/process/gremlin-lang.js

@@ -18,24 +18,30 @@
  */
 import { P, TextP, EnumValue } from './traversal.js';
 import { OptionsStrategy, TraversalStrategy } from './traversal-strategy.js';
-import { Long } from '../utils.js';
-import { Vertex } from '../structure/graph.js';
+import { Long, Int, Float, Double, Short, Byte, INT32_MIN, INT32_MAX } from '../utils.js';
+import { Vertex, CompositePDT, PrimitivePDT } from '../structure/graph.js';
+import { GValue } from './gvalue.js';
+import { isDeepStrictEqual } from 'node:util';
+import { Buffer } from 'buffer';
+const PARAM_NAME_PATTERN = /^[\p{L}_$][\p{L}\p{Nd}_$]*$/u;
 export default class GremlinLang {
     gremlin = '';
     optionsStrategies = [];
     parameters = new Map();
+    pdtRegistry = null;
     constructor(toClone) {
         if (toClone) {
             this.gremlin = toClone.gremlin;
             this.optionsStrategies = [...toClone.optionsStrategies];
             this.parameters = new Map(toClone.parameters);
+            this.pdtRegistry = toClone.pdtRegistry;
         }
     }
     getOptionsStrategies() {
         return this.optionsStrategies;
     }
-    addG(g) {
-        this.parameters.set('g', g);
+    appendGremlin(text) {
+        this.gremlin += text;
     }
     getParameters() {
         return this.parameters;
@@ -46,7 +52,15 @@ export default class GremlinLang {
         }
         let result = p.operator + '(';
         if (Array.isArray(p.value)) {
-            result += '[' + p.value.map(v => this._argAsString(v)).join(',') + ']';
+            // If all elements are traversals, serialize as comma-separated args (no brackets)
+            // This matches the server grammar: within(trav1, trav2) via genericArgumentVarargs
+            const allTraversals = p.value.length > 0 && p.value.every((v) => v != null && typeof v.getGremlinLang === 'function');
+            if (allTraversals) {
+                result += p.value.map((v) => this._argAsString(v)).join(',');
+            }
+            else {
+                result += '[' + p.value.map((v) => this._argAsString(v)).join(',') + ']';
+            }
         }
         else {
             result += this._argAsString(p.value);
@@ -65,6 +79,21 @@ export default class GremlinLang {
         if (arg instanceof Long) {
             return String(arg.value) + 'L';
         }
+        if (arg instanceof Float) {
+            return GremlinLang._fpAsString(arg.value, 'F');
+        }
+        if (arg instanceof Double) {
+            return GremlinLang._fpAsString(arg.value, 'D');
+        }
+        if (arg instanceof Short) {
+            return String(arg.value) + 'S';
+        }
+        if (arg instanceof Byte) {
+            return String(arg.value) + 'B';
+        }
+        if (arg instanceof Int) {
+            return String(arg.value);
+        }
         if (typeof arg === 'bigint') {
             return String(arg) + 'N';
         }
@@ -77,9 +106,9 @@ export default class GremlinLang {
                 return '-Infinity';
             if (!Number.isInteger(arg))
                 return String(arg) + 'D';
-            if (arg >= -2147483648 && arg <= 2147483647)
+            if (arg >= INT32_MIN && arg <= INT32_MAX)
                 return String(arg);
-            // Outside safe integer range, values have lost precision and may exceed Java Long — emit as Double.
+            // Outside safe integer range, values have lost precision and may exceed Java Long - emit as Double.
             if (arg > Number.MAX_SAFE_INTEGER || arg < -Number.MAX_SAFE_INTEGER)
                 return String(arg) + 'D';
             return String(arg) + 'L';
@@ -94,6 +123,21 @@ export default class GremlinLang {
             const escaped = JSON.stringify(arg).slice(1, -1).replace(/'/g, "\\'");
             return `'${escaped}'`;
         }
+        if (arg instanceof GValue) {
+            const key = arg.name;
+            if (!PARAM_NAME_PATTERN.test(key)) {
+                throw new Error(`Invalid parameter name [${key}].`);
+            }
+            if (this.parameters.has(key)) {
+                if (!isDeepStrictEqual(this.parameters.get(key), arg.value)) {
+                    throw new Error(`Parameter with name ${key} already exists.`);
+                }
+            }
+            else {
+                this.parameters.set(key, arg.value);
+            }
+            return key;
+        }
         if (arg instanceof P || arg instanceof TextP) {
             return this._predicateAsString(arg);
         }
@@ -112,10 +156,29 @@ export default class GremlinLang {
         if (typeof arg === 'function' && arg.prototype instanceof TraversalStrategy) {
             return arg.name;
         }
+        if (arg instanceof PrimitivePDT) {
+            // PDT literals use double-quoted strings (consistent with the composite PDT form below);
+            // JSON.stringify handles special-character escaping, then the outer quotes are stripped.
+            const escapedName = JSON.stringify(arg.name).slice(1, -1);
+            const escapedValue = JSON.stringify(arg.value).slice(1, -1);
+            return `PDT("${escapedName}","${escapedValue}")`;
+        }
+        if (arg instanceof CompositePDT) {
+            const fields = arg.fields;
+            const keys = Object.keys(fields);
+            const escapedName = JSON.stringify(arg.name).slice(1, -1);
+            if (keys.length === 0)
+                return `PDT("${escapedName}",[:])`;
+            const entries = keys.map(k => `${this._argAsString(k)}:${this._argAsString(fields[k])}`);
+            return `PDT("${escapedName}",[${entries.join(',')}])`;
+        }
         if (arg instanceof Vertex) {
             return this._argAsString(arg.id);
         }
         if (arg instanceof GremlinLang) {
+            // Merge the child's parameters so GValue bindings nested inside a child
+            // traversal are still sent to the server alongside the rendered query.
+            arg.parameters.forEach((v, k) => this.parameters.set(k, v));
             return arg.getGremlin('__');
         }
         if (typeof arg.getGremlinLang === 'function') {
@@ -123,7 +186,14 @@ export default class GremlinLang {
             if (arg.graph != null) {
                 throw new Error('Child traversal must be anonymous - use __ not g');
             }
-            return arg.getGremlinLang().getGremlin('__');
+            const childLang = arg.getGremlinLang();
+            // Merge the child's parameters so GValue bindings nested inside a child
+            // traversal are still sent to the server alongside the rendered query.
+            childLang.parameters.forEach((v, k) => this.parameters.set(k, v));
+            return childLang.getGremlin('__');
+        }
+        if (arg instanceof Uint8Array) {
+            return `Binary("${Buffer.from(arg.buffer, arg.byteOffset, arg.byteLength).toString('base64')}")`;
         }
         if (arg instanceof Set) {
             const items = [...arg];
@@ -151,7 +221,20 @@ export default class GremlinLang {
                 return '[:]';
             return '[' + entries.map(([k, v]) => `${this._argAsString(k)}:${this._argAsString(v)}`).join(',') + ']';
         }
-        return String(arg);
+        // Registry-based dehydration
+        if (this.pdtRegistry && typeof arg === 'object' && arg.constructor) {
+            const primitiveEntry = this.pdtRegistry.getPrimitiveAdapterByClass(arg.constructor);
+            if (primitiveEntry) {
+                const value = primitiveEntry.toValue(arg);
+                return this._argAsString(new PrimitivePDT(primitiveEntry.typeName, value));
+            }
+            const entry = this.pdtRegistry.getAdapterByClass(arg.constructor);
+            if (entry) {
+                const fields = entry.serialize(arg);
+                return this._argAsString(new CompositePDT(entry.typeName, fields));
+            }
+        }
+        throw new TypeError(`GremlinLang contains at least one type [${arg?.constructor?.name ?? typeof arg}] that cannot be represented as text.`);
     }
     addStep(name, args) {
         const argsStr = args?.length ? args.map(a => this._argAsString(a)).join(',') : '';
@@ -169,6 +252,13 @@ export default class GremlinLang {
             for (const strategy of args) {
                 if (strategy instanceof OptionsStrategy) {
                     this.optionsStrategies.push(strategy);
+                    // Render multilabel/singlelabel in gremlin text (temporary until these options are removed)
+                    if (strategy.configuration['multilabel'] !== undefined) {
+                        this.gremlin += '.with("multilabel")';
+                    }
+                    if (strategy.configuration['singlelabel'] !== undefined) {
+                        this.gremlin += '.with("singlelabel")';
+                    }
                 }
                 else {
                     nonOptionsStrategies.push(strategy);
@@ -184,10 +274,32 @@ export default class GremlinLang {
         this.gremlin += `.${name}(${argsStr})`;
         return this;
     }
+    static _fpAsString(v, suffix) {
+        if (v === Infinity)
+            return '+Infinity';
+        if (v === -Infinity)
+            return '-Infinity';
+        if (Number.isNaN(v))
+            return 'NaN';
+        return Number.isInteger(v) ? `${v}.0${suffix}` : `${v}${suffix}`;
+    }
     getGremlin(prefix = 'g') {
         if (this.gremlin.length > 0 && this.gremlin[0] !== '.') {
             return this.gremlin;
         }
         return prefix + this.gremlin;
     }
+    getParametersAsString() {
+        return GremlinLang.convertParametersToString(this.parameters);
+    }
+    static convertParametersToString(params) {
+        if (params == null || params.size === 0)
+            return '[:]';
+        const helper = new GremlinLang();
+        const parts = [];
+        params.forEach((v, k) => {
+            parts.push(`${helper._argAsString(k)}:${helper._argAsString(v)}`);
+        });
+        return '[' + parts.join(',') + ']';
+    }
 }

package/build/esm/process/gvalue.d.ts

@@ -0,0 +1,7 @@
+export declare class GValue<T = any> {
+    readonly name: string;
+    readonly value: T;
+    constructor(name: string, value: T);
+    isNull(): boolean;
+    toString(): string;
+}

package/build/esm/process/gvalue.js

@@ -0,0 +1,38 @@
+/*
+ *  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.
+ */
+export class GValue {
+    name;
+    value;
+    constructor(name, value) {
+        if (value instanceof GValue) {
+            throw new Error('GValues cannot be nested');
+        }
+        if (name == null) {
+            throw new Error('GValue name cannot be null.');
+        }
+        this.name = name;
+        this.value = value;
+    }
+    isNull() {
+        return this.value == null;
+    }
+    toString() {
+        return `${this.name}=${this.value}`;
+    }
+}