gremlin 3.5.0 → 3.5.3

package/lib/process/transaction.js

@@ -0,0 +1,92 @@
+/*
+ *  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.
+ */
+'use strict';
+
+const remote = require('../driver/remote-connection');
+const Bytecode = require('./bytecode');
+const { TraversalStrategies } = require('./traversal-strategy');
+
+/**
+ * A controller for a remote transaction that is constructed from <code>g.tx()</code>. Calling <code>begin()</code>
+ * on this object will produce a new <code>GraphTraversalSource</code> that is bound to a remote transaction over which
+ * multiple traversals may be executed in that context. Calling <code>commit()</code> or <code>rollback()</code> will
+ * then close the transaction and thus, the session. This feature only works with transaction enabled graphs.
+ */
+class Transaction {
+  constructor(g) {
+    this._g = g;
+    this._sessionBasedConnection = undefined;
+  }
+
+  /**
+   * Spawns a <code>GraphTraversalSource</code> that is bound to a remote session which enables a transaction.
+   * @returns {*}
+   */
+  begin() {
+    if (this._sessionBasedConnection) {
+      throw new Error('Transaction already started on this object');
+    }
+
+    this._sessionBasedConnection = this._g.remoteConnection.createSession();
+    const traversalStrategy = new TraversalStrategies();
+    traversalStrategy.addStrategy(new remote.RemoteStrategy(this._sessionBasedConnection));
+    return new this._g.graphTraversalSourceClass(
+      this._g.graph,
+      traversalStrategy,
+      new Bytecode(this._g.bytecode),
+      this._g.graphTraversalSourceClass,
+      this._g.graphTraversalClass,
+    );
+  }
+
+  /**
+   * @returns {Promise}
+   */
+  commit() {
+    return this._sessionBasedConnection.commit().then(() => this.close());
+  }
+
+  /**
+   * @returns {Promise}
+   */
+  rollback() {
+    return this._sessionBasedConnection.rollback().then(() => this.close());
+  }
+
+  /**
+   * Returns true if transaction is open.
+   * @returns {Boolean}
+   */
+  get isOpen() {
+    return this._sessionBasedConnection.isOpen;
+  }
+
+  /**
+   * @returns {Promise}
+   */
+  close() {
+    if (this._sessionBasedConnection) {
+      this._sessionBasedConnection.close();
+    }
+  }
+}
+
+module.exports = {
+  Transaction,
+};

package/lib/process/translator.js

@@ -19,6 +19,7 @@
 'use strict';
 
 const Traversal = require('./traversal').Traversal;
+const Bytecode = require('./bytecode');
 
 /**
  * Class to translate glv bytecode steps into executable Gremlin-Groovy script
@@ -33,7 +34,7 @@ class Translator {
   }
 
   getTargetLanguage() {
-    return "gremlin-groovy";
+    return 'gremlin-groovy';
   }
 
   of(traversalSource) {
@@ -42,12 +43,15 @@ class Translator {
 
   /**
    * Returns a script representation of the given bytecode instructions.
-   * @param {Object} bytecode The bytecode object containing step instructions.
+   * @param {Object} bytecodeOrTraversal The traversal or bytecode of a traversal containing step instructions.
+   * @param {boolean} child Determines if a traversal object should be treated as an anonymous child or if it is a spawn from "g"
    * @returns {string} Gremlin-Groovy script
    */
-  translate(bytecode, child = false) {
-    let script = child ? "__" : this._traversalSource;
-    let instructions = bytecode.stepInstructions;
+  translate(bytecodeOrTraversal, child = false) {
+    let script = child ? '__' : this._traversalSource;
+    const bc = bytecodeOrTraversal instanceof Bytecode ? bytecodeOrTraversal : bytecodeOrTraversal.getBytecode();
+
+    const instructions = bc.stepInstructions;
 
     // build the script from the glv instructions.
     for (let i = 0; i < instructions.length; i++) {
@@ -60,44 +64,58 @@ class Translator {
             script += ', ';
           }
 
-          if (Object(params[k]) === params[k]) {
-            if (params[k] instanceof Traversal) {
-              script += this.translate(params[k].getBytecode(), true);
-            } else if (params[k].toString() === '[object Object]') {
-              Object.keys(params[k]).forEach(function (key, index) {
-                if (index > 0) script += ', ';
-                script += '(\'' + key + '\', ';
-                if (params[k][key] instanceof String || typeof params[k][key] === 'string') {
-                  script += '\'' + params[k][key] + '\'';
-                } else {
-                  script += params[k][key];
-                }
-                script += ')';
-              });
-            } else if (Array.isArray(params[k])) {
-              const parts = [];
-              for (const param of params[k]) {
-                parts.push(translate(param.getBytecode(), true));
-              }
-              script += parts.join(",");
-            } else {
-              script += params[k].toString();
-            }
-          } else if (params[k] === undefined) {
-            script += '';
-          } else if (typeof params[k] === 'number' || typeof params[k] === 'boolean') {
-            script += params[k];
-          } else {
-            script += '\'' + params[k] + '\'';
-          }
+          script += this.convert(params[k]);
         }
       }
 
       script += ')';
     }
-    
+
+    return script;
+  }
+
+  /**
+   * Converts an object to a Gremlin script representation.
+   * @param {Object} anyObject The object to convert to a script representation
+   * @returns {string} The Gremlin script representation
+   */
+  convert(anyObject) {
+    let script = '';
+    if (Object(anyObject) === anyObject) {
+      if (anyObject instanceof Traversal) {
+        script += this.translate(anyObject.getBytecode(), true);
+      } else if (anyObject.toString() === '[object Object]') {
+        Object.keys(anyObject).forEach(function (key, index) {
+          if (index > 0) {
+            script += ', ';
+          }
+          script += `('${key}', `;
+          if (anyObject[key] instanceof String || typeof anyObject[key] === 'string') {
+            script += `'${anyObject[key]}'`;
+          } else {
+            script += anyObject[key];
+          }
+          script += ')';
+        });
+      } else if (Array.isArray(anyObject)) {
+        const parts = [];
+        for (const item of anyObject) {
+          parts.push(this.convert(item));
+        }
+        script += '[' + parts.join(', ') + ']';
+      } else {
+        script += anyObject.toString();
+      }
+    } else if (anyObject === undefined) {
+      script += '';
+    } else if (typeof anyObject === 'number' || typeof anyObject === 'boolean') {
+      script += anyObject;
+    } else {
+      script += `'${anyObject}'`;
+    }
+
     return script;
   }
 }
 
-module.exports = Translator;
+module.exports = Translator;

package/lib/process/traversal-strategy.js

@@ -34,8 +34,7 @@ class TraversalStrategies {
     if (parent) {
       // Clone the strategies
       this.strategies = [...parent.strategies];
-    }
-    else {
+    } else {
       this.strategies = [];
     }
   }
@@ -45,21 +44,31 @@ class TraversalStrategies {
     this.strategies.push(strategy);
   }
 
+  /** @param {TraversalStrategy} strategy */
+  removeStrategy(strategy) {
+    const idx = this.strategies.findIndex((s) => s.fqcn === strategy.fqcn);
+    if (idx !== -1) {
+      return this.strategies.splice(idx, 1)[0];
+    }
+
+    return undefined;
+  }
+
   /**
    * @param {Traversal} traversal
    * @returns {Promise}
    */
   applyStrategies(traversal) {
     // Apply all strategies serially
-    return this.strategies.reduce((promise, strategy) => {
-      return promise.then(() => strategy.apply(traversal));
-    }, Promise.resolve());
+    return this.strategies.reduce(
+      (promise, strategy) => promise.then(() => strategy.apply(traversal)),
+      Promise.resolve(),
+    );
   }
 }
 
 /** @abstract */
 class TraversalStrategy {
-
   /**
    * @param {String} fqcn fully qualified class name in Java of the strategy
    * @param {Object} configuration for the strategy
@@ -74,38 +83,36 @@ class TraversalStrategy {
    * @param {Traversal} traversal
    * @returns {Promise}
    */
-  apply(traversal) {
-
-  }
+  apply(traversal) {}
 }
 
 class ConnectiveStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy');
   }
 }
 
 class ElementIdStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategy');
   }
 }
 
 class HaltedTraverserStrategy extends TraversalStrategy {
-
   /**
    * @param {String} haltedTraverserFactory full qualified class name in Java of a {@code HaltedTraverserFactory} implementation
    */
   constructor(haltedTraverserFactory) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.HaltedTraverserStrategy");
-    if (haltedTraverserFactory !== undefined)
-      this.configuration["haltedTraverserFactory"] = haltedTraverserFactory;
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.HaltedTraverserStrategy');
+    if (haltedTraverserFactory !== undefined) {
+      this.configuration['haltedTraverserFactory'] = haltedTraverserFactory;
+    }
   }
 }
 
 class OptionsStrategy extends TraversalStrategy {
   constructor(options) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy", options);
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy', options);
   }
 }
 
@@ -118,7 +125,7 @@ class PartitionStrategy extends TraversalStrategy {
    * @param {boolean} [options.includeMetaProperties] determines if meta-properties should be included in partitioning defaulting to false
    */
   constructor(options) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategy", options);
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategy', options);
   }
 }
 
@@ -131,20 +138,32 @@ class SubgraphStrategy extends TraversalStrategy {
    * @param {boolean} [options.checkAdjacentVertices] enables the strategy to apply the {@code vertices} filter to the adjacent vertices of an edge.
    */
   constructor(options) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy", options);
-    if (this.configuration.vertices instanceof Traversal)
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy', options);
+    if (this.configuration.vertices instanceof Traversal) {
       this.configuration.vertices = this.configuration.vertices.bytecode;
-    if (this.configuration.edges instanceof Traversal)
+    }
+    if (this.configuration.edges instanceof Traversal) {
       this.configuration.edges = this.configuration.edges.bytecode;
-    if (this.configuration.vertexProperties instanceof Traversal)
+    }
+    if (this.configuration.vertexProperties instanceof Traversal) {
       this.configuration.vertexProperties = this.configuration.vertexProperties.bytecode;
+    }
   }
 }
 
-class VertexProgramStrategy extends TraversalStrategy {
+class ProductiveByStrategy extends TraversalStrategy {
+  /**
+   * @param {Object} [options]
+   * @param {Array<String>} [options.productiveKeys] set of keys that will always be productive
+   */
+  constructor(options) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy', options);
+  }
+}
 
+class VertexProgramStrategy extends TraversalStrategy {
   constructor(options) {
-    super("org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy", options);
+    super('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy', options);
   }
 }
 
@@ -153,105 +172,106 @@ class MatchAlgorithmStrategy extends TraversalStrategy {
    * @param matchAlgorithm
    */
   constructor(matchAlgorithm) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy");
-    if (matchAlgorithm !== undefined)
-      this.configuration["matchAlgorithm"] = matchAlgorithm;
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy');
+    if (matchAlgorithm !== undefined) {
+      this.configuration['matchAlgorithm'] = matchAlgorithm;
+    }
   }
 }
 
 class AdjacentToIncidentStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy');
   }
 }
 
 class FilterRankingStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.FilterRankingStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.FilterRankingStrategy');
   }
 }
 
 class IdentityRemovalStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IdentityRemovalStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IdentityRemovalStrategy');
   }
 }
 
 class IncidentToAdjacentStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategy');
   }
 }
 
 class InlineFilterStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.InlineFilterStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.InlineFilterStrategy');
   }
 }
 
 class LazyBarrierStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy');
   }
 }
 
 class MatchPredicateStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.MatchPredicateStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.MatchPredicateStrategy');
   }
 }
 
 class OrderLimitStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.OrderLimitStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.OrderLimitStrategy');
   }
 }
 
 class PathProcessorStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathProcessorStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathProcessorStrategy');
   }
 }
 
 class PathRetractionStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy');
   }
 }
 
 class CountStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy');
   }
 }
 
 class RepeatUnrollStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy');
   }
 }
 
 class GraphFilterStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.GraphFilterStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.GraphFilterStrategy');
   }
 }
 
 class EarlyLimitStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategy');
   }
 }
 
 class LambdaRestrictionStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy');
   }
 }
 
 class ReadOnlyStrategy extends TraversalStrategy {
   constructor() {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy");
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy');
   }
 }
 
@@ -260,9 +280,11 @@ class EdgeLabelVerificationStrategy extends TraversalStrategy {
    * @param {boolean} logWarnings determines if warnings should be written to the logger when verification fails
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    */
-  constructor(logWarnings = false, throwException=false) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy",
-        {logWarnings: logWarnings, throwException: throwException});
+  constructor(logWarnings = false, throwException = false) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy', {
+      logWarnings: logWarnings,
+      throwException: throwException,
+    });
   }
 }
 
@@ -272,9 +294,12 @@ class ReservedKeysVerificationStrategy extends TraversalStrategy {
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    * @param {Array<String>} keys the list of reserved keys to verify
    */
-  constructor(logWarnings = false, throwException=false, keys=["id", "label"]) {
-    super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy",
-        {logWarnings: logWarnings, throwException: throwException, keys: keys});
+  constructor(logWarnings = false, throwException = false, keys = ['id', 'label']) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy', {
+      logWarnings: logWarnings,
+      throwException: throwException,
+      keys: keys,
+    });
   }
 }
 
@@ -302,6 +327,7 @@ module.exports = {
   OrderLimitStrategy: OrderLimitStrategy,
   PathProcessorStrategy: PathProcessorStrategy,
   PathRetractionStrategy: PathRetractionStrategy,
+  ProductiveByStrategy: ProductiveByStrategy,
   CountStrategy: CountStrategy,
   RepeatUnrollStrategy: RepeatUnrollStrategy,
   GraphFilterStrategy: GraphFilterStrategy,
@@ -310,5 +336,5 @@ module.exports = {
   EdgeLabelVerificationStrategy: EdgeLabelVerificationStrategy,
   LambdaRestrictionStrategy: LambdaRestrictionStrategy,
   ReadOnlyStrategy: ReadOnlyStrategy,
-  ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy
-};
+  ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy,
+};