gremlin 3.8.1 → 4.0.0-beta.2

package/build/esm/driver/remote-connection.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import GremlinLang from '../process/gremlin-lang.js';
+import { TraversalStrategy } from '../process/traversal-strategy.js';
+import { Traversal, Traverser } from '../process/traversal.js';
+import type { ConnectionOptions } from './connection.js';
+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/esm/driver/remote-connection.js

@@ -0,0 +1,69 @@
+/*
+ *  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.
+ */
+import { TraversalStrategy } from '../process/traversal-strategy.js';
+import { Traversal } from '../process/traversal.js';
+/**
+ * Represents an abstraction of a "connection" to a "server" that is capable of processing a traversal and
+ * returning results.
+ */
+export 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;
+    }
+}
+/**
+ * Represents a traversal as a result of a {@link RemoteConnection} submission.
+ */
+export class RemoteTraversal extends Traversal {
+    results;
+    sideEffects;
+    constructor(results, sideEffects) {
+        super(null, null);
+        this.results = results;
+        this.sideEffects = sideEffects;
+    }
+}
+export class RemoteStrategy extends 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;
+        });
+    }
+}

package/build/esm/driver/request-message.d.ts

@@ -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/esm/driver/request-message.js

@@ -0,0 +1,152 @@
+/*
+ * 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.
+ */
+// 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.
+ */
+export 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);
+    }
+}
+/**
+ * Builder class for RequestMessage.
+ */
+export 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);
+    }
+}

package/build/esm/driver/response-error.d.ts

@@ -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'];
+    });
+}

package/{lib → build/esm}/driver/response-error.js

@@ -7,7 +7,7 @@
  *  "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
+ *    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
@@ -16,32 +16,27 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
-'use strict';
-
 /**
  * Represents an error obtained from the server.
  */
-class ResponseError extends Error {
-  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 || {};
-  }
+export default 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 || {};
+    }
 }
-
-module.exports = ResponseError;

package/build/esm/driver/result-set.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents the response returned from the execution of a Gremlin traversal or script.
+ */
+export default class ResultSet {
+    private readonly items;
+    private readonly attributes;
+    readonly length: number;
+    /**
+     * Creates a new instance of {@link ResultSet}.
+     * @param {Array} items
+     * @param {Map} [attributes]
+     */
+    constructor(items: any[], attributes: Map<string, any>);
+    /**
+     * Gets the iterator associated with this instance.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): ArrayIterator<any>;
+    /**
+     * Gets an array of result items.
+     * @returns {Array}
+     */
+    toArray(): Array<any>;
+    /**
+     * Returns the first item.
+     * @returns {Object|null}
+     */
+    first(): any | null;
+}

package/build/esm/driver/result-set.js

@@ -0,0 +1,75 @@
+/*
+ *  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.
+ */
+/**
+ * @author Jorge Bay Gondra
+ */
+import * as utils from '../utils.js';
+const emptyMap = Object.freeze(new utils.ImmutableMap());
+/**
+ * Represents the response returned from the execution of a Gremlin traversal or script.
+ */
+export default class ResultSet {
+    items;
+    attributes;
+    length;
+    /**
+     * Creates a new instance of {@link ResultSet}.
+     * @param {Array} items
+     * @param {Map} [attributes]
+     */
+    constructor(items, attributes) {
+        this.items = items;
+        if (!Array.isArray(items)) {
+            throw new TypeError('items must be an Array instance');
+        }
+        this.items = items;
+        /**
+         * Gets a Map representing the attributes of the response.
+         * @type {Map}
+         */
+        this.attributes = attributes || emptyMap;
+        /**
+         * Gets the amount of items in the result.
+         * @type {Number}
+         */
+        this.length = items.length;
+    }
+    /**
+     * Gets the iterator associated with this instance.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
+    /**
+     * Gets an array of result items.
+     * @returns {Array}
+     */
+    toArray() {
+        return this.items;
+    }
+    /**
+     * Returns the first item.
+     * @returns {Object|null}
+     */
+    first() {
+        const item = this.items[0];
+        return item !== undefined ? item : null;
+    }
+}