gremlin 3.8.0 → 4.0.0-beta.2

package/build/cjs/driver/driver-remote-connection.cjs

@@ -0,0 +1,141 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Jorge Bay Gondra
+ */
+const rcModule = __importStar(require("./remote-connection.cjs"));
+const RemoteConnection = rcModule.RemoteConnection;
+const RemoteTraversal = rcModule.RemoteTraversal;
+const client_js_1 = __importDefault(require("./client.cjs"));
+/**
+ * Represents the default `RemoteConnection` implementation.
+ */
+class DriverRemoteConnection extends RemoteConnection {
+    _client;
+    /**
+     * Creates a new instance of {@link DriverRemoteConnection}.
+     * @param {String} url The resource uri.
+     * @param {ConnectionOptions} [options] The connection options.
+     */
+    constructor(url, options = {}) {
+        super(url, options);
+        this._client = new client_js_1.default(url, options);
+    }
+    /** @override */
+    open() {
+        return this._client.open();
+    }
+    /** @override */
+    get isOpen() {
+        return this._client.isOpen;
+    }
+    /** @override */
+    submit(gremlinLang) {
+        gremlinLang.addG(this.options.traversalSource || 'g');
+        let requestOptions = undefined;
+        const strategies = gremlinLang.getOptionsStrategies();
+        if (strategies.length > 0) {
+            requestOptions = {};
+            const allowedKeys = [
+                'evaluationTimeout',
+                'scriptEvaluationTimeout',
+                'batchSize',
+                'requestId',
+                'userAgent',
+                'materializeProperties',
+                'bulkResults',
+            ];
+            for (const strategy of strategies) {
+                for (const key in strategy.configuration) {
+                    if (allowedKeys.indexOf(key) > -1) {
+                        requestOptions[key] = strategy.configuration[key];
+                    }
+                }
+            }
+        }
+        if (!requestOptions) {
+            requestOptions = {};
+        }
+        if (!('bulkResults' in requestOptions)) {
+            requestOptions.bulkResults = true;
+        }
+        const params = gremlinLang.getParameters();
+        if (params.size > 0) {
+            requestOptions.params = Object.fromEntries(params);
+        }
+        return this._client.submit(gremlinLang.getGremlin(), null, requestOptions)
+            .then((result) => new RemoteTraversal(result.toArray()));
+    }
+    commit() {
+        return this._client.submit('g.tx().commit()', null);
+    }
+    rollback() {
+        return this._client.submit('g.tx().rollback()', null);
+    }
+    close() {
+        return this._client.close();
+    }
+    /** @override */
+    addListener(event, handler) {
+        return this._client.addListener(event, handler);
+    }
+    /** @override */
+    removeListener(event, handler) {
+        return this._client.removeListener(event, handler);
+    }
+}
+exports.default = DriverRemoteConnection;

package/build/cjs/driver/driver-remote-connection.d.cts

@@ -0,0 +1,33 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import * as rcModule from './remote-connection.cjs';
+declare const RemoteConnection: typeof rcModule.RemoteConnection;
+import GremlinLang from '../process/gremlin-lang.cjs';
+import { ConnectionOptions } from './connection.cjs';
+/**
+ * Represents the default `RemoteConnection` implementation.
+ */
+export default class DriverRemoteConnection extends RemoteConnection {
+    private readonly _client;
+    /**
+     * Creates a new instance of {@link DriverRemoteConnection}.
+     * @param {String} url The resource uri.
+     * @param {ConnectionOptions} [options] The connection options.
+     */
+    constructor(url: string, options?: ConnectionOptions);
+    /** @override */
+    open(): Promise<void>;
+    /** @override */
+    get isOpen(): boolean;
+    /** @override */
+    submit(gremlinLang: GremlinLang): Promise<rcModule.RemoteTraversal>;
+    commit(): Promise<any>;
+    rollback(): Promise<any>;
+    close(): Promise<void>;
+    /** @override */
+    addListener(event: string, handler: (...args: any[]) => unknown): void;
+    /** @override */
+    removeListener(event: string, handler: (...args: any[]) => unknown): void;
+}
+export {};

package/build/cjs/driver/remote-connection.cjs

@@ -0,0 +1,75 @@
+"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 });
+exports.RemoteStrategy = exports.RemoteTraversal = exports.RemoteConnection = void 0;
+const traversal_strategy_js_1 = require("../process/traversal-strategy.cjs");
+const traversal_js_1 = require("../process/traversal.cjs");
+/**
+ * Represents an abstraction of a "connection" to a "server" that is capable of processing a traversal and
+ * returning results.
+ */
+class RemoteConnection {
+    url;
+    options;
+    /**
+     * @param {String} url The resource uri.
+     * @param {RemoteConnectionOptions} [options] The connection options.
+     */
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = options;
+    }
+}
+exports.RemoteConnection = RemoteConnection;
+/**
+ * Represents a traversal as a result of a {@link RemoteConnection} submission.
+ */
+class RemoteTraversal extends traversal_js_1.Traversal {
+    results;
+    sideEffects;
+    constructor(results, sideEffects) {
+        super(null, null);
+        this.results = results;
+        this.sideEffects = sideEffects;
+    }
+}
+exports.RemoteTraversal = RemoteTraversal;
+class RemoteStrategy extends traversal_strategy_js_1.TraversalStrategy {
+    connection;
+    /**
+     * Creates a new instance of RemoteStrategy.
+     * @param {RemoteConnection} connection
+     */
+    constructor(connection) {
+        super();
+        this.connection = connection;
+    }
+    /** @override */
+    apply(traversal) {
+        if (traversal.results) {
+            return Promise.resolve();
+        }
+        return this.connection.submit(traversal.getGremlinLang()).then(function (remoteTraversal) {
+            traversal.sideEffects = remoteTraversal.sideEffects;
+            traversal.results = remoteTraversal.results;
+        });
+    }
+}
+exports.RemoteStrategy = RemoteStrategy;

package/build/cjs/driver/remote-connection.d.cts

@@ -0,0 +1,72 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import GremlinLang from '../process/gremlin-lang.cjs';
+import { TraversalStrategy } from '../process/traversal-strategy.cjs';
+import { Traversal, Traverser } from '../process/traversal.cjs';
+import type { ConnectionOptions } from './connection.cjs';
+export type RemoteConnectionOptions = ConnectionOptions & {
+    session?: string;
+};
+/**
+ * Represents an abstraction of a "connection" to a "server" that is capable of processing a traversal and
+ * returning results.
+ */
+export declare abstract class RemoteConnection {
+    url: string;
+    protected readonly options: RemoteConnectionOptions;
+    /**
+     * @param {String} url The resource uri.
+     * @param {RemoteConnectionOptions} [options] The connection options.
+     */
+    constructor(url: string, options?: RemoteConnectionOptions);
+    /**
+     * Opens the connection, if its not already opened.
+     * @returns {Promise}
+     */
+    abstract open(): Promise<void>;
+    /**
+     * Returns true if connection is open
+     * @returns {Boolean}
+     */
+    abstract get isOpen(): boolean;
+    /**
+     * Submits the <code>GremlinLang</code> provided and returns a <code>RemoteTraversal</code>.
+     * @param {GremlinLang} gremlinLang
+     * @returns {Promise} Returns a <code>Promise</code> that resolves to a <code>RemoteTraversal</code>.
+     */
+    abstract submit(gremlinLang: GremlinLang): Promise<RemoteTraversal>;
+    /**
+     * Submits a commit operation to the server and closes the connection.
+     * @returns {Promise}
+     */
+    abstract commit(): Promise<void>;
+    /**
+     * Submits a rollback operation to the server and closes the connection.
+     * @returns {Promise}
+     */
+    abstract rollback(): Promise<void>;
+    /**
+     * Closes the connection where open transactions will close according to the features of the graph provider.
+     * @returns {Promise}
+     */
+    abstract close(): Promise<void>;
+}
+/**
+ * Represents a traversal as a result of a {@link RemoteConnection} submission.
+ */
+export declare class RemoteTraversal extends Traversal {
+    results: Traverser<any>[];
+    sideEffects?: any[] | undefined;
+    constructor(results: Traverser<any>[], sideEffects?: any[] | undefined);
+}
+export declare class RemoteStrategy extends TraversalStrategy {
+    connection: RemoteConnection;
+    /**
+     * Creates a new instance of RemoteStrategy.
+     * @param {RemoteConnection} connection
+     */
+    constructor(connection: RemoteConnection);
+    /** @override */
+    apply(traversal: Traversal): Promise<void>;
+}

package/build/cjs/driver/request-message.cjs

@@ -0,0 +1,157 @@
+"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 });
+exports.Builder = exports.RequestMessage = void 0;
+// Token constants
+const Tokens = {
+    ARGS_LANGUAGE: 'language',
+    ARGS_BINDINGS: 'bindings',
+    ARGS_G: 'g',
+    ARGS_MATERIALIZE_PROPERTIES: 'materializeProperties',
+    TIMEOUT_MS: 'timeoutMs',
+    BULK_RESULTS: 'bulkResults',
+    MATERIALIZE_PROPERTIES_TOKENS: 'tokens',
+    MATERIALIZE_PROPERTIES_ALL: 'all'
+};
+/**
+ * The model for a request message in the HTTP body that is sent to the server beginning in 4.0.0.
+ */
+class RequestMessage {
+    gremlin;
+    language;
+    timeoutMs;
+    bindings;
+    g;
+    materializeProperties;
+    bulkResults;
+    customFields;
+    constructor(gremlin, language, timeoutMs, bindings, g, materializeProperties, bulkResults, customFields) {
+        if (!gremlin) {
+            throw new Error('RequestMessage requires gremlin argument');
+        }
+        this.gremlin = gremlin;
+        this.language = language;
+        this.timeoutMs = timeoutMs;
+        this.bindings = bindings;
+        this.g = g;
+        this.materializeProperties = materializeProperties;
+        this.bulkResults = bulkResults;
+        this.customFields = customFields;
+    }
+    getGremlin() {
+        return this.gremlin;
+    }
+    getLanguage() {
+        return this.language;
+    }
+    getTimeoutMs() {
+        return this.timeoutMs;
+    }
+    getBindings() {
+        return this.bindings;
+    }
+    getG() {
+        return this.g;
+    }
+    getMaterializeProperties() {
+        return this.materializeProperties;
+    }
+    getBulkResults() {
+        return this.bulkResults;
+    }
+    getFields() {
+        return this.customFields;
+    }
+    static build(gremlin) {
+        return new Builder(gremlin);
+    }
+}
+exports.RequestMessage = RequestMessage;
+/**
+ * Builder class for RequestMessage.
+ */
+class Builder {
+    gremlin;
+    bindings = {};
+    language;
+    timeoutMs;
+    g;
+    materializeProperties;
+    bulkResults;
+    additionalFields = new Map();
+    constructor(gremlin) {
+        this.gremlin = gremlin;
+        this.language = "gremlin-lang";
+    }
+    addLanguage(language) {
+        if (!language)
+            throw new Error('language argument cannot be null.');
+        this.language = language;
+        return this;
+    }
+    addBinding(key, value) {
+        Object.assign(this.bindings, { [key]: value });
+        return this;
+    }
+    addBindings(otherBindings) {
+        if (!otherBindings)
+            throw new Error('bindings argument cannot be null.');
+        Object.assign(this.bindings, otherBindings);
+        return this;
+    }
+    addG(g) {
+        if (!g)
+            throw new Error('g argument cannot be null.');
+        this.g = g;
+        return this;
+    }
+    addMaterializeProperties(materializeProps) {
+        if (!materializeProps)
+            throw new Error('materializeProps argument cannot be null.');
+        if (materializeProps !== Tokens.MATERIALIZE_PROPERTIES_TOKENS &&
+            materializeProps !== Tokens.MATERIALIZE_PROPERTIES_ALL) {
+            throw new Error(`materializeProperties argument must be either "${Tokens.MATERIALIZE_PROPERTIES_TOKENS}" or "${Tokens.MATERIALIZE_PROPERTIES_ALL}".`);
+        }
+        this.materializeProperties = materializeProps;
+        return this;
+    }
+    addTimeoutMillis(timeout) {
+        if (timeout < 0)
+            throw new Error('timeout argument cannot be negative.');
+        this.timeoutMs = timeout;
+        return this;
+    }
+    addBulkResults(bulking) {
+        this.bulkResults = bulking;
+        return this;
+    }
+    addField(key, value) {
+        this.additionalFields.set(key, value);
+        return this;
+    }
+    /**
+     * Create the request message given the settings provided to the Builder.
+     */
+    create() {
+        // @ts-ignore - accessing private constructor from Builder
+        return new RequestMessage(this.gremlin, this.language || 'gremlin-lang', this.timeoutMs, Object.keys(this.bindings).length > 0 ? this.bindings : undefined, this.g, this.materializeProperties, this.bulkResults, this.additionalFields);
+    }
+}
+exports.Builder = Builder;

package/build/cjs/driver/request-message.d.cts

@@ -0,0 +1,49 @@
+/**
+ * The model for a request message in the HTTP body that is sent to the server beginning in 4.0.0.
+ */
+export declare class RequestMessage {
+    private gremlin;
+    private language;
+    private timeoutMs?;
+    private bindings?;
+    private g?;
+    private materializeProperties?;
+    private bulkResults?;
+    private customFields;
+    private constructor();
+    getGremlin(): string;
+    getLanguage(): string;
+    getTimeoutMs(): number | undefined;
+    getBindings(): object | undefined;
+    getG(): string | undefined;
+    getMaterializeProperties(): string | undefined;
+    getBulkResults(): boolean | undefined;
+    getFields(): ReadonlyMap<string, any>;
+    static build(gremlin: string): Builder;
+}
+/**
+ * Builder class for RequestMessage.
+ */
+export declare class Builder {
+    private readonly gremlin;
+    private readonly bindings;
+    language: string;
+    timeoutMs?: number;
+    g?: string;
+    materializeProperties?: string;
+    bulkResults?: boolean;
+    additionalFields: Map<string, any>;
+    constructor(gremlin: string);
+    addLanguage(language: string): Builder;
+    addBinding(key: string, value: any): Builder;
+    addBindings(otherBindings: object): Builder;
+    addG(g: string): Builder;
+    addMaterializeProperties(materializeProps: string): Builder;
+    addTimeoutMillis(timeout: number): Builder;
+    addBulkResults(bulking: boolean): Builder;
+    addField(key: string, value: any): Builder;
+    /**
+     * Create the request message given the settings provided to the Builder.
+     */
+    create(): RequestMessage;
+}

package/build/cjs/driver/response-error.cjs

@@ -0,0 +1,45 @@
+"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 });
+/**
+ * Represents an error obtained from the server.
+ */
+class ResponseError extends Error {
+    statusCode;
+    statusMessage;
+    statusAttributes;
+    constructor(message, responseStatus) {
+        super(message);
+        this.name = 'ResponseError';
+        /**
+         * Gets the server status code.
+         */
+        this.statusCode = responseStatus.code;
+        /**
+         * Gets the server status message.
+         */
+        this.statusMessage = responseStatus.message;
+        /**
+         * Gets the server status attributes as a Map (may contain provider specific status information).
+         */
+        this.statusAttributes = responseStatus.attributes || {};
+    }
+}
+exports.default = ResponseError;

package/build/cjs/driver/response-error.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Represents an error obtained from the server.
+ */
+export default class ResponseError extends Error {
+    statusCode: number;
+    statusMessage: string;
+    statusAttributes: Map<string, string>;
+    constructor(message: string, responseStatus: {
+        code: ResponseError['statusCode'];
+        message: ResponseError['statusMessage'];
+        attributes: ResponseError['statusAttributes'];
+    });
+}