gremlin 3.5.1 → 3.5.4

package/lib/process/transaction.js

@@ -40,14 +40,19 @@ class Transaction {
    */
   begin() {
     if (this._sessionBasedConnection) {
-      throw new Error("Transaction already started on this object");
+      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);
+    return new this._g.graphTraversalSourceClass(
+      this._g.graph,
+      traversalStrategy,
+      new Bytecode(this._g.bytecode),
+      this._g.graphTraversalSourceClass,
+      this._g.graphTraversalClass,
+    );
   }
 
   /**
@@ -69,18 +74,19 @@ class Transaction {
    * @returns {Boolean}
    */
   get isOpen() {
-    this._sessionBasedConnection.isOpen;
+    return this._sessionBasedConnection.isOpen;
   }
 
   /**
    * @returns {Promise}
    */
   close() {
-    if (this._sessionBasedConnection)
+    if (this._sessionBasedConnection) {
       this._sessionBasedConnection.close();
+    }
   }
 }
 
 module.exports = {
-  Transaction
-};
+  Transaction,
+};

package/lib/process/translator.js

@@ -34,7 +34,7 @@ class Translator {
   }
 
   getTargetLanguage() {
-    return "gremlin-groovy";
+    return 'gremlin-groovy';
   }
 
   of(traversalSource) {
@@ -44,13 +44,14 @@ class Translator {
   /**
    * Returns a script representation of the given bytecode 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(bytecodeOrTraversal, child = false) {
-    let script = child ? "__" : this._traversalSource;
+    let script = child ? '__' : this._traversalSource;
     const bc = bytecodeOrTraversal instanceof Bytecode ? bytecodeOrTraversal : bytecodeOrTraversal.getBytecode();
 
-    let instructions = bc.stepInstructions;
+    const instructions = bc.stepInstructions;
 
     // build the script from the glv instructions.
     for (let i = 0; i < instructions.length; i++) {
@@ -63,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 = [];
     }
   }
@@ -47,7 +46,7 @@ class TraversalStrategies {
 
   /** @param {TraversalStrategy} strategy */
   removeStrategy(strategy) {
-    const idx = this.strategies.findIndex(s => s.fqcn === strategy.fqcn);
+    const idx = this.strategies.findIndex((s) => s.fqcn === strategy.fqcn);
     if (idx !== -1) {
       return this.strategies.splice(idx, 1)[0];
     }
@@ -61,15 +60,15 @@ class TraversalStrategies {
    */
   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
@@ -84,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);
   }
 }
 
@@ -128,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);
   }
 }
 
@@ -141,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);
   }
 }
 
@@ -163,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');
   }
 }
 
@@ -270,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,
+    });
   }
 }
 
@@ -282,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.ReservedKeysVerificationStrategy', {
+      logWarnings: logWarnings,
+      throwException: throwException,
+      keys: keys,
+    });
   }
 }
 
@@ -312,6 +327,7 @@ module.exports = {
   OrderLimitStrategy: OrderLimitStrategy,
   PathProcessorStrategy: PathProcessorStrategy,
   PathRetractionStrategy: PathRetractionStrategy,
+  ProductiveByStrategy: ProductiveByStrategy,
   CountStrategy: CountStrategy,
   RepeatUnrollStrategy: RepeatUnrollStrategy,
   GraphFilterStrategy: GraphFilterStrategy,
@@ -320,5 +336,5 @@ module.exports = {
   EdgeLabelVerificationStrategy: EdgeLabelVerificationStrategy,
   LambdaRestrictionStrategy: LambdaRestrictionStrategy,
   ReadOnlyStrategy: ReadOnlyStrategy,
-  ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy
-};
+  ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy,
+};