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

package/build/cjs/driver/auth.cjs

@@ -24,13 +24,15 @@ const buffer_1 = require("node:buffer");
 function basic(username, password) {
     return (request) => {
         request.headers['authorization'] = 'Basic ' + buffer_1.Buffer.from(`${username}:${password}`).toString('base64');
-        return request;
     };
 }
 function sigv4(region, service, credentialsProvider) {
     let signer;
     let resolvedProvider;
     return async (request) => {
+        // Ensure body is serialized to JSON bytes before signing.
+        // serializeBody is idempotent: safe to call even if already serialized.
+        request.serializeBody();
         // Lazy-initialize signer and credentials provider on first use
         if (!signer) {
             const { SignatureV4 } = await import('@smithy/signature-v4');
@@ -51,6 +53,11 @@ function sigv4(region, service, credentialsProvider) {
             });
         }
         const url = new URL(request.url);
+        // Sign only the Host header; the signer itself adds (and signs) x-amz-date, the payload hash,
+        // and x-amz-security-token for session credentials. The request's own headers (accept,
+        // content-type, ...) are deliberately NOT fed into the signature: the HTTP stack may add or
+        // rewrite transport-managed headers such as accept-encoding after this interceptor runs, so a
+        // signature covering them would no longer match the bytes actually sent.
         const signed = await signer.sign({
             method: request.method,
             protocol: url.protocol,
@@ -58,12 +65,12 @@ function sigv4(region, service, credentialsProvider) {
             port: url.port ? Number(url.port) : undefined,
             path: url.pathname + url.search,
             headers: {
-                ...request.headers,
                 host: url.host,
             },
             body: request.body,
         });
-        request.headers = signed.headers;
-        return request;
+        // Merge the signed auth headers onto the request; the request's other headers (accept,
+        // content-type, ...) still reach the wire, they are simply not part of the signature.
+        request.headers = { ...request.headers, ...signed.headers };
     };
 }

package/build/cjs/driver/auth.d.cts

@@ -1,4 +1,4 @@
-import type { RequestInterceptor } from './connection.cjs';
+import type { RequestInterceptor } from './http-request.cjs';
 export declare function basic(username: string, password: string): RequestInterceptor;
 export interface AwsCredentials {
     accessKeyId: string;

package/build/cjs/driver/client.cjs

@@ -23,10 +23,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const connection_js_1 = __importDefault(require("./connection.cjs"));
 const request_message_js_1 = require("./request-message.cjs");
+const transaction_js_1 = require("../process/transaction.cjs");
 /**
  * A {@link Client} contains methods to send messages to a Gremlin Server.
  */
 class Client {
+    url;
     options;
     _connection;
     /**
@@ -34,7 +36,12 @@ class Client {
      * @param {String} url The resource uri.
      * @param {ClientOptions} [options] The connection options.
      */
+    // Tracks open transactions for cascade rollback on close. JS Set iteration
+    // is safe during concurrent modification (deleting the current element during
+    // for-of is spec-guaranteed to not affect remaining iterations).
+    _trackedTransactions = new Set();
     constructor(url, options = {}) {
+        this.url = url;
         this.options = options;
         this._connection = new connection_js_1.default(url, options);
     }
@@ -53,67 +60,104 @@ class Client {
         return this._connection.isOpen;
     }
     /**
-     * Configuration specific to the current request.
-     * @typedef {Object} RequestOptions
-     * @property {any} bindings - The parameter bindings to apply to the script.
-     * @property {String} language - The language of the script to execute. Defaults to 'gremlin-lang'.
-     * @property {String} accept - The MIME type expected in the response.
-     * @property {Boolean} bulkResults - Indicates whether results should be returned in bulk format.
-     * @property {Object} params - Additional parameters to include with the request.
-     * @property {Number} batchSize - The size in which the result of a request is to be 'batched' back to the client.
-     * @property {String} userAgent - The user agent string to send with the request.
-     * @property {Number} evaluationTimeout - The timeout for the evaluation of the request.
-     * @property {String} materializeProperties - Indicates whether element properties should be returned or not.
+     * Send a request to the Gremlin Server and buffer the entire response.
+     * @param {string} message The script to send
+     * @param {Object|null} [parameters] The query parameters, if any.
+     * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
+     * @returns {Promise<ResultSet>}
      */
+    submit(message, parameters, requestOptions) {
+        return this._connection.submit(this.#buildRequest(message, parameters, requestOptions));
+    }
     /**
-     * Send a request to the Gremlin Server.
+     * Send a request to the Gremlin Server and stream results incrementally.
+     * Returns an AsyncGenerator that yields individual result items as they are
+     * deserialized from the response. For bulked responses, yields Traverser objects.
      * @param {string} message The script to send
-     * @param {Object|null} [bindings] The script bindings, if any.
+     * @param {Object|null} [parameters] The query parameters, if any.
      * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
-     * @returns {Promise}
-     */ //TODO:: tighten return type to Promise<ResultSet>
-    submit(message, bindings, requestOptions) {
+     * @returns {AsyncGenerator<any>}
+     */
+    async *stream(message, parameters, requestOptions) {
+        return yield* this._connection.stream(this.#buildRequest(message, parameters, requestOptions));
+    }
+    #buildRequest(message, parameters, requestOptions) {
         const requestBuilder = request_message_js_1.RequestMessage.build(message)
             .addG(this.options.traversalSource || 'g');
         if (requestOptions?.language) {
             requestBuilder.addLanguage(requestOptions.language);
         }
-        if (requestOptions?.bindings) {
-            requestBuilder.addBindings(requestOptions.bindings);
+        if (requestOptions?.parameters) {
+            if (typeof requestOptions.parameters === 'string') {
+                requestBuilder.addParametersString(requestOptions.parameters);
+            }
+            else {
+                requestBuilder.addParameters(requestOptions.parameters);
+            }
         }
-        if (bindings) {
-            requestBuilder.addBindings(bindings);
+        if (parameters) {
+            if (typeof parameters === 'string') {
+                requestBuilder.addParametersString(parameters);
+            }
+            else {
+                requestBuilder.addParameters(parameters);
+            }
         }
         if (requestOptions?.materializeProperties) {
             requestBuilder.addMaterializeProperties(requestOptions.materializeProperties);
         }
-        if (requestOptions?.evaluationTimeout) {
-            requestBuilder.addTimeoutMillis(requestOptions.evaluationTimeout);
+        if (requestOptions?.timeoutMillis) {
+            requestBuilder.addTimeoutMillis(requestOptions.timeoutMillis);
         }
-        if (requestOptions?.bulkResults) {
+        // Per-request value wins (including an explicit `false`); otherwise apply the
+        // connection-level default only when it is true.
+        if (requestOptions?.bulkResults !== undefined) {
             requestBuilder.addBulkResults(requestOptions.bulkResults);
         }
-        return this._connection.submit(requestBuilder.create());
-    }
-    /**
-     * Send a request to the Gremlin Server and receive a stream for the results.
-     * @param {string} message The script to send
-     * @param {Object} [bindings] The script bindings, if any.
-     * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
-     * @returns {ReadableStream}
-     */
-    //TODO:: Update stream() to mirror submit()
-    stream(message, bindings, requestOptions) {
-        throw new Error("Stream not yet implemented");
+        else if (this._connection.bulkResults) {
+            requestBuilder.addBulkResults(true);
+        }
+        // Fill the per-request batchSize from the connection-level default when unset.
+        const batchSize = requestOptions?.batchSize ?? this._connection.batchSize;
+        if (batchSize !== undefined) {
+            requestBuilder.addBatchSize(batchSize);
+        }
+        if (requestOptions?.transactionId) {
+            requestBuilder.addField('transactionId', requestOptions.transactionId);
+        }
+        return requestBuilder.create();
     }
     /**
      * Closes the underlying connection
-     * send session close request before connection close if session mode
      * @returns {Promise}
      */
-    close() {
+    async close() {
+        // Best-effort rollback of any open transactions before closing connections
+        for (const tx of this._trackedTransactions) {
+            try {
+                await tx.close();
+            }
+            catch { }
+        }
+        this._trackedTransactions.clear();
         return this._connection.close();
     }
+    trackTransaction(tx) {
+        this._trackedTransactions.add(tx);
+    }
+    untrackTransaction(tx) {
+        this._trackedTransactions.delete(tx);
+    }
+    /**
+     * Creates a new Transaction for executing operations within an explicit transaction.
+     * Transactions are short-lived and single-use. After commit or rollback,
+     * create a new Transaction for the next unit of work.
+     * The traversal source (g alias) is inherited from this Client.
+     * @returns {Transaction}
+     */
+    transact() {
+        return new transaction_js_1.Transaction(this);
+    }
     /**
      * Adds an event listener to the connection
      * @param {String} event The event name that you want to listen to.
@@ -123,7 +167,7 @@ class Client {
         this._connection.on(event, handler);
     }
     /**
-     * Removes a previowsly added event listener to the connection
+     * Removes a previously added event listener to the connection
      * @param {String} event The event name that you want to listen to.
      * @param {Function} handler The event handler to be removed.
      */

package/build/cjs/driver/client.d.cts

@@ -1,15 +1,16 @@
 import { ConnectionOptions } from './connection.cjs';
-import { Readable } from 'stream';
+import { Transaction } from '../process/transaction.cjs';
 export type RequestOptions = {
-    bindings?: any;
+    parameters?: any;
     language?: string;
     accept?: string;
-    evaluationTimeout?: number;
+    timeoutMillis?: number;
     batchSize?: number;
     userAgent?: string;
     materializeProperties?: string;
     bulkResults?: boolean;
     params?: Record<string, any>;
+    transactionId?: string;
 };
 export type ClientOptions = ConnectionOptions & RequestOptions & {
     processor?: string;
@@ -18,13 +19,16 @@ export type ClientOptions = ConnectionOptions & RequestOptions & {
  * A {@link Client} contains methods to send messages to a Gremlin Server.
  */
 export default class Client {
-    private readonly options;
+    #private;
+    readonly url: string;
+    readonly options: ClientOptions;
     private readonly _connection;
     /**
      * Creates a new instance of {@link Client}.
      * @param {String} url The resource uri.
      * @param {ClientOptions} [options] The connection options.
      */
+    private readonly _trackedTransactions;
     constructor(url: string, options?: ClientOptions);
     /**
      * Opens the underlying connection to the Gremlin Server, if it's not already opened.
@@ -37,39 +41,38 @@ export default class Client {
      */
     get isOpen(): boolean;
     /**
-     * Configuration specific to the current request.
-     * @typedef {Object} RequestOptions
-     * @property {any} bindings - The parameter bindings to apply to the script.
-     * @property {String} language - The language of the script to execute. Defaults to 'gremlin-lang'.
-     * @property {String} accept - The MIME type expected in the response.
-     * @property {Boolean} bulkResults - Indicates whether results should be returned in bulk format.
-     * @property {Object} params - Additional parameters to include with the request.
-     * @property {Number} batchSize - The size in which the result of a request is to be 'batched' back to the client.
-     * @property {String} userAgent - The user agent string to send with the request.
-     * @property {Number} evaluationTimeout - The timeout for the evaluation of the request.
-     * @property {String} materializeProperties - Indicates whether element properties should be returned or not.
-     */
-    /**
-     * Send a request to the Gremlin Server.
+     * Send a request to the Gremlin Server and buffer the entire response.
      * @param {string} message The script to send
-     * @param {Object|null} [bindings] The script bindings, if any.
+     * @param {Object|null} [parameters] The query parameters, if any.
      * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
-     * @returns {Promise}
-     */ submit(message: string, bindings: any | null, requestOptions?: RequestOptions): Promise<any>;
+     * @returns {Promise<ResultSet>}
+     */
+    submit(message: string, parameters: any | null, requestOptions?: RequestOptions): Promise<any>;
     /**
-     * Send a request to the Gremlin Server and receive a stream for the results.
+     * Send a request to the Gremlin Server and stream results incrementally.
+     * Returns an AsyncGenerator that yields individual result items as they are
+     * deserialized from the response. For bulked responses, yields Traverser objects.
      * @param {string} message The script to send
-     * @param {Object} [bindings] The script bindings, if any.
+     * @param {Object|null} [parameters] The query parameters, if any.
      * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
-     * @returns {ReadableStream}
+     * @returns {AsyncGenerator<any>}
      */
-    stream(message: string, bindings: any, requestOptions?: RequestOptions): Readable;
+    stream(message: string, parameters: any | null, requestOptions?: RequestOptions): AsyncGenerator<any>;
     /**
      * Closes the underlying connection
-     * send session close request before connection close if session mode
      * @returns {Promise}
      */
     close(): Promise<void>;
+    trackTransaction(tx: any): void;
+    untrackTransaction(tx: any): void;
+    /**
+     * Creates a new Transaction for executing operations within an explicit transaction.
+     * Transactions are short-lived and single-use. After commit or rollback,
+     * create a new Transaction for the next unit of work.
+     * The traversal source (g alias) is inherited from this Client.
+     * @returns {Transaction}
+     */
+    transact(): Transaction;
     /**
      * Adds an event listener to the connection
      * @param {String} event The event name that you want to listen to.
@@ -77,7 +80,7 @@ export default class Client {
      */
     addListener(event: string, handler: (...args: any[]) => unknown): void;
     /**
-     * Removes a previowsly added event listener to the connection
+     * Removes a previously added event listener to the connection
      * @param {String} event The event name that you want to listen to.
      * @param {Function} handler The event handler to be removed.
      */