gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/process/traversal-strategy.cjs

@@ -0,0 +1,360 @@
+"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.SeedStrategy = exports.StandardVerificationStrategy = exports.VertexProgramRestrictionStrategy = exports.ReservedKeysVerificationStrategy = exports.EdgeLabelVerificationStrategy = exports.ReadOnlyStrategy = exports.LambdaRestrictionStrategy = exports.ComputerVerificationStrategy = exports.EarlyLimitStrategy = exports.GraphFilterStrategy = exports.RepeatUnrollStrategy = exports.CountStrategy = exports.PathRetractionStrategy = exports.PathProcessorStrategy = exports.OrderLimitStrategy = exports.MatchPredicateStrategy = exports.LazyBarrierStrategy = exports.InlineFilterStrategy = exports.IncidentToAdjacentStrategy = exports.IdentityRemovalStrategy = exports.ByModulatorOptimizationStrategy = exports.FilterRankingStrategy = exports.AdjacentToIncidentStrategy = exports.ComputerFinalizationStrategy = exports.MatchAlgorithmStrategy = exports.VertexProgramStrategy = exports.ReferenceElementStrategy = exports.ProductiveByStrategy = exports.SubgraphStrategy = exports.ProfileStrategy = exports.PartitionStrategy = exports.OptionsStrategy = exports.MessagePassingReductionStrategy = exports.HaltedTraverserStrategy = exports.ElementIdStrategy = exports.ConnectiveStrategy = exports.TraversalStrategy = exports.TraversalStrategies = void 0;
+const traversal_js_1 = require("./traversal.cjs");
+class TraversalStrategies {
+    strategies;
+    /**
+     * Creates a new instance of TraversalStrategies.
+     * @param {TraversalStrategies} [parent] The parent strategies from where to clone the values from.
+     */
+    constructor(parent) {
+        if (parent) {
+            // Clone the strategies
+            this.strategies = [...parent.strategies];
+        }
+        else {
+            this.strategies = [];
+        }
+    }
+    /** @param {TraversalStrategy} strategy */
+    addStrategy(strategy) {
+        this.strategies.push(strategy);
+    }
+    /** @param {TraversalStrategy} strategy */
+    removeStrategy(strategy) {
+        const idx = this.strategies.findIndex((s) => s.strategyName === strategy.strategyName);
+        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) => promise.then(() => strategy.apply(traversal)), Promise.resolve());
+    }
+}
+exports.TraversalStrategies = TraversalStrategies;
+class TraversalStrategy {
+    configuration;
+    connection;
+    strategyName;
+    /**
+     * @param {TraversalStrategyConfiguration} configuration for the strategy
+     */
+    constructor(configuration = {}) {
+        this.configuration = configuration;
+        this.strategyName = this.constructor.name;
+    }
+    /**
+     * @abstract
+     * @param {Traversal} traversal
+     * @returns {Promise}
+     */
+    async apply(traversal) { }
+}
+exports.TraversalStrategy = TraversalStrategy;
+class ConnectiveStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ConnectiveStrategy = ConnectiveStrategy;
+class ElementIdStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ElementIdStrategy = ElementIdStrategy;
+class HaltedTraverserStrategy extends TraversalStrategy {
+    /**
+     * @param {String} haltedTraverserFactory full qualified class name in Java of a `HaltedTraverserFactory` implementation
+     */
+    constructor({ haltedTraverserFactory = "" }) {
+        super({ haltedTraverserFactory: haltedTraverserFactory });
+    }
+}
+exports.HaltedTraverserStrategy = HaltedTraverserStrategy;
+class MessagePassingReductionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.MessagePassingReductionStrategy = MessagePassingReductionStrategy;
+class OptionsStrategy extends TraversalStrategy {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.OptionsStrategy = OptionsStrategy;
+class PartitionStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.partitionKey - name of the property key to partition by
+     * @param options.writePartition - the value of the currently write partition
+     * @param options.readPartitions - list of strings representing the partitions to include for reads
+     * @param options.includeMetaProperties - determines if meta-properties should be included in partitioning defaulting to false
+     */
+    constructor({ partitionKey, writePartition, readPartitions, includeMetaProperties } = {}) {
+        const config = {};
+        if (partitionKey !== undefined)
+            config.partitionKey = partitionKey;
+        if (writePartition !== undefined)
+            config.writePartition = writePartition;
+        if (readPartitions !== undefined)
+            config.readPartitions = readPartitions;
+        if (includeMetaProperties !== undefined)
+            config.includeMetaProperties = includeMetaProperties;
+        super(config);
+    }
+}
+exports.PartitionStrategy = PartitionStrategy;
+class ProfileStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ProfileStrategy = ProfileStrategy;
+class SubgraphStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.vertices - traversal to filter vertices
+     * @param options.edges - traversal to filter edges
+     * @param options.vertexProperties - traversal to filter vertex properties
+     * @param options.checkAdjacentVertices - enables the strategy to apply the `vertices` filter to the adjacent vertices of an edge.
+     */
+    constructor({ vertices, edges, vertexProperties, checkAdjacentVertices } = {}) {
+        const config = {};
+        if (vertices !== undefined)
+            config.vertices = vertices instanceof traversal_js_1.Traversal ? vertices.gremlinLang : vertices;
+        if (edges !== undefined)
+            config.edges = edges instanceof traversal_js_1.Traversal ? edges.gremlinLang : edges;
+        if (vertexProperties !== undefined)
+            config.vertexProperties = vertexProperties instanceof traversal_js_1.Traversal ? vertexProperties.gremlinLang : vertexProperties;
+        if (checkAdjacentVertices !== undefined)
+            config.checkAdjacentVertices = checkAdjacentVertices;
+        super(config);
+    }
+}
+exports.SubgraphStrategy = SubgraphStrategy;
+class ProductiveByStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.productiveKeys - set of keys that will always be productive
+     */
+    constructor({ productiveKeys = [] } = {}) {
+        super({ productiveKeys });
+    }
+}
+exports.ProductiveByStrategy = ProductiveByStrategy;
+class ReferenceElementStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ReferenceElementStrategy = ReferenceElementStrategy;
+class VertexProgramStrategy extends TraversalStrategy {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.VertexProgramStrategy = VertexProgramStrategy;
+class MatchAlgorithmStrategy extends TraversalStrategy {
+    /**
+     * @param matchAlgorithm
+     */
+    constructor({ matchAlgorithm = "" }) {
+        super({ matchAlgorithm: matchAlgorithm });
+    }
+}
+exports.MatchAlgorithmStrategy = MatchAlgorithmStrategy;
+class ComputerFinalizationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ComputerFinalizationStrategy = ComputerFinalizationStrategy;
+class AdjacentToIncidentStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.AdjacentToIncidentStrategy = AdjacentToIncidentStrategy;
+class FilterRankingStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.FilterRankingStrategy = FilterRankingStrategy;
+class ByModulatorOptimizationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ByModulatorOptimizationStrategy = ByModulatorOptimizationStrategy;
+class IdentityRemovalStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.IdentityRemovalStrategy = IdentityRemovalStrategy;
+class IncidentToAdjacentStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.IncidentToAdjacentStrategy = IncidentToAdjacentStrategy;
+class InlineFilterStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.InlineFilterStrategy = InlineFilterStrategy;
+class LazyBarrierStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.LazyBarrierStrategy = LazyBarrierStrategy;
+class MatchPredicateStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.MatchPredicateStrategy = MatchPredicateStrategy;
+class OrderLimitStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.OrderLimitStrategy = OrderLimitStrategy;
+class PathProcessorStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.PathProcessorStrategy = PathProcessorStrategy;
+class PathRetractionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.PathRetractionStrategy = PathRetractionStrategy;
+class CountStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.CountStrategy = CountStrategy;
+class RepeatUnrollStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.RepeatUnrollStrategy = RepeatUnrollStrategy;
+class GraphFilterStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.GraphFilterStrategy = GraphFilterStrategy;
+class EarlyLimitStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.EarlyLimitStrategy = EarlyLimitStrategy;
+class ComputerVerificationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ComputerVerificationStrategy = ComputerVerificationStrategy;
+class LambdaRestrictionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.LambdaRestrictionStrategy = LambdaRestrictionStrategy;
+class ReadOnlyStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.ReadOnlyStrategy = ReadOnlyStrategy;
+class EdgeLabelVerificationStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.logWarnings - determines if warnings should be written to the logger when verification fails
+     * @param options.throwException - determines if exceptions should be thrown when verifications fails
+     */
+    constructor({ logWarnings = false, throwException = false } = {}) {
+        super({
+            logWarnings: logWarnings,
+            throwException: throwException,
+        });
+    }
+}
+exports.EdgeLabelVerificationStrategy = EdgeLabelVerificationStrategy;
+class ReservedKeysVerificationStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.logWarnings - determines if warnings should be written to the logger when verification fails
+     * @param options.throwException - determines if exceptions should be thrown when verifications fails
+     * @param options.keys - the list of reserved keys to verify
+     */
+    constructor({ logWarnings = false, throwException = false, keys = ['id', 'label'] } = {}) {
+        super({
+            logWarnings: logWarnings,
+            throwException: throwException,
+            keys: keys,
+        });
+    }
+}
+exports.ReservedKeysVerificationStrategy = ReservedKeysVerificationStrategy;
+class VertexProgramRestrictionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.VertexProgramRestrictionStrategy = VertexProgramRestrictionStrategy;
+class StandardVerificationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+exports.StandardVerificationStrategy = StandardVerificationStrategy;
+class SeedStrategy extends TraversalStrategy {
+    /**
+     * @param {SeedStrategyOptions} [options]
+     * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
+     */
+    constructor(options) {
+        super({
+            seed: options.seed,
+        });
+    }
+}
+exports.SeedStrategy = SeedStrategy;

package/build/cjs/process/traversal-strategy.d.cts

@@ -0,0 +1,211 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import type { RemoteConnection } from '../driver/remote-connection.cjs';
+import { Traversal } from './traversal.cjs';
+export declare class TraversalStrategies {
+    readonly strategies: TraversalStrategy[];
+    /**
+     * Creates a new instance of TraversalStrategies.
+     * @param {TraversalStrategies} [parent] The parent strategies from where to clone the values from.
+     */
+    constructor(parent?: TraversalStrategies);
+    /** @param {TraversalStrategy} strategy */
+    addStrategy(strategy: TraversalStrategy): void;
+    /** @param {TraversalStrategy} strategy */
+    removeStrategy(strategy: TraversalStrategy): TraversalStrategy | undefined;
+    /**
+     * @param {Traversal} traversal
+     * @returns {Promise}
+     */
+    applyStrategies(traversal: Traversal): Promise<void>;
+}
+export type TraversalStrategyConfiguration = any;
+export declare abstract class TraversalStrategy {
+    configuration: TraversalStrategyConfiguration;
+    connection?: RemoteConnection;
+    strategyName: string;
+    /**
+     * @param {TraversalStrategyConfiguration} configuration for the strategy
+     */
+    constructor(configuration?: TraversalStrategyConfiguration);
+    /**
+     * @abstract
+     * @param {Traversal} traversal
+     * @returns {Promise}
+     */
+    apply(traversal: Traversal): Promise<void>;
+}
+export declare class ConnectiveStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class ElementIdStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class HaltedTraverserStrategy extends TraversalStrategy {
+    /**
+     * @param {String} haltedTraverserFactory full qualified class name in Java of a `HaltedTraverserFactory` implementation
+     */
+    constructor({ haltedTraverserFactory }: {
+        haltedTraverserFactory?: string | undefined;
+    });
+}
+export declare class MessagePassingReductionStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class OptionsStrategy extends TraversalStrategy {
+    constructor(options: TraversalStrategyConfiguration);
+}
+export declare class PartitionStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.partitionKey - name of the property key to partition by
+     * @param options.writePartition - the value of the currently write partition
+     * @param options.readPartitions - list of strings representing the partitions to include for reads
+     * @param options.includeMetaProperties - determines if meta-properties should be included in partitioning defaulting to false
+     */
+    constructor({ partitionKey, writePartition, readPartitions, includeMetaProperties }?: {
+        partitionKey?: string;
+        writePartition?: string;
+        readPartitions?: string[];
+        includeMetaProperties?: boolean;
+    });
+}
+export declare class ProfileStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class SubgraphStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.vertices - traversal to filter vertices
+     * @param options.edges - traversal to filter edges
+     * @param options.vertexProperties - traversal to filter vertex properties
+     * @param options.checkAdjacentVertices - enables the strategy to apply the `vertices` filter to the adjacent vertices of an edge.
+     */
+    constructor({ vertices, edges, vertexProperties, checkAdjacentVertices }?: {
+        vertices?: any;
+        edges?: any;
+        vertexProperties?: any;
+        checkAdjacentVertices?: boolean;
+    });
+}
+export declare class ProductiveByStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.productiveKeys - set of keys that will always be productive
+     */
+    constructor({ productiveKeys }?: {
+        productiveKeys?: never[] | undefined;
+    });
+}
+export declare class ReferenceElementStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class VertexProgramStrategy extends TraversalStrategy {
+    constructor(options: TraversalStrategyConfiguration);
+}
+export declare class MatchAlgorithmStrategy extends TraversalStrategy {
+    /**
+     * @param matchAlgorithm
+     */
+    constructor({ matchAlgorithm }: {
+        matchAlgorithm?: string | undefined;
+    });
+}
+export declare class ComputerFinalizationStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class AdjacentToIncidentStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class FilterRankingStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class ByModulatorOptimizationStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class IdentityRemovalStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class IncidentToAdjacentStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class InlineFilterStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class LazyBarrierStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class MatchPredicateStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class OrderLimitStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class PathProcessorStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class PathRetractionStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class CountStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class RepeatUnrollStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class GraphFilterStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class EarlyLimitStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class ComputerVerificationStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class LambdaRestrictionStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class ReadOnlyStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class EdgeLabelVerificationStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.logWarnings - determines if warnings should be written to the logger when verification fails
+     * @param options.throwException - determines if exceptions should be thrown when verifications fails
+     */
+    constructor({ logWarnings, throwException }?: {
+        logWarnings?: boolean | undefined;
+        throwException?: boolean | undefined;
+    });
+}
+export declare class ReservedKeysVerificationStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.logWarnings - determines if warnings should be written to the logger when verification fails
+     * @param options.throwException - determines if exceptions should be thrown when verifications fails
+     * @param options.keys - the list of reserved keys to verify
+     */
+    constructor({ logWarnings, throwException, keys }?: {
+        logWarnings?: boolean | undefined;
+        throwException?: boolean | undefined;
+        keys?: string[] | undefined;
+    });
+}
+export declare class VertexProgramRestrictionStrategy extends TraversalStrategy {
+    constructor();
+}
+export declare class StandardVerificationStrategy extends TraversalStrategy {
+    constructor();
+}
+export type SeedStrategyOptions = {
+    seed: number;
+};
+export declare class SeedStrategy extends TraversalStrategy {
+    /**
+     * @param {SeedStrategyOptions} [options]
+     * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
+     */
+    constructor(options: SeedStrategyOptions);
+}