gremlin 3.8.0 → 4.0.0-beta.2

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

package/build/cjs/process/traversal.cjs

@@ -0,0 +1,482 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.n = exports.t = exports.scope = exports.pop = exports.pick = exports.order = exports.operator = exports.merge = exports.gryoVersion = exports.graphSONVersion = exports.gType = exports.dt = exports.direction = exports.column = exports.cardinality = exports.barrier = exports.EnumValue = exports.withOptions = exports.TraversalSideEffects = exports.Traverser = exports.TextP = exports.P = exports.IO = exports.Traversal = void 0;
+const gremlin_lang_js_1 = __importDefault(require("./gremlin-lang.cjs"));
+const itemDone = Object.freeze({ value: null, done: true });
+const asyncIteratorSymbol = Symbol.asyncIterator || Symbol('@@asyncIterator');
+class Traversal {
+    graph;
+    traversalStrategies;
+    gremlinLang;
+    results = null;
+    sideEffects = null;
+    _traversalStrategiesPromise = null;
+    _resultsIteratorIndex = 0;
+    constructor(graph, traversalStrategies, gremlinLang = new gremlin_lang_js_1.default()) {
+        this.graph = graph;
+        this.traversalStrategies = traversalStrategies;
+        this.gremlinLang = gremlinLang;
+    }
+    /**
+     * Async iterable method implementation.
+     */
+    [asyncIteratorSymbol]() {
+        return this;
+    }
+    /** @returns {GremlinLang} */
+    getGremlinLang() {
+        return this.gremlinLang;
+    }
+    /**
+     * Returns an Array containing the traverser objects.
+     * @returns {Promise.<Array>}
+     */
+    toList() {
+        return this._applyStrategies().then(() => {
+            const result = [];
+            let it;
+            while ((it = this._getNext()) && !it.done) {
+                result.push(it.value);
+            }
+            return result;
+        });
+    }
+    /**
+     * Determines if there are any more items to iterate from the traversal.
+     * @returns {Promise.<boolean>}
+     */
+    hasNext() {
+        return this._applyStrategies().then(() => {
+            if (!this.results || this.results.length <= 0 || this._resultsIteratorIndex >= this.results.length) {
+                return false;
+            }
+            if (this.results[this._resultsIteratorIndex] instanceof Traverser) {
+                return this.results[this._resultsIteratorIndex].bulk > 0 || this._resultsIteratorIndex + 1 < this.results.length;
+            }
+            else {
+                return true;
+            }
+        });
+    }
+    /**
+     * Iterates all Traverser instances in the traversal.
+     * @returns {Promise}
+     */
+    iterate() {
+        this.gremlinLang.addStep('discard');
+        return this._applyStrategies().then(() => {
+            let it;
+            while ((it = this._getNext()) && !it.done) {
+                //
+            }
+        });
+    }
+    /**
+     * Async iterator method implementation.
+     * Returns a promise containing an iterator item.
+     * @returns {Promise.<{value, done}>}
+     */
+    next() {
+        return this._applyStrategies().then(() => this._getNext());
+    }
+    /**
+     * Synchronous iterator of traversers including
+     * @private
+     */
+    _getNext() {
+        while (this.results && this._resultsIteratorIndex < this.results.length) {
+            const next = this.results[this._resultsIteratorIndex];
+            if (next instanceof Traverser) {
+                if (next.bulk > 0) {
+                    next.bulk--;
+                    return { value: next.object, done: false };
+                }
+            }
+            this._resultsIteratorIndex++;
+            if (!(next instanceof Traverser)) {
+                return { value: next, done: false };
+            }
+        }
+        return itemDone;
+    }
+    _applyStrategies() {
+        if (this._traversalStrategiesPromise) {
+            // Apply strategies only once
+            return this._traversalStrategiesPromise;
+        }
+        return (this._traversalStrategiesPromise = this.traversalStrategies?.applyStrategies(this) ?? Promise.resolve());
+    }
+    /**
+     * Returns step instructions during JSON serialization
+     * @returns {Array}
+     */
+    toJSON() {
+        return this.gremlinLang.getGremlin();
+    }
+    /**
+     * Returns the GremlinLang representation of the traversal
+     * @returns {String}
+     */
+    toString() {
+        return this.gremlinLang.getGremlin();
+    }
+}
+exports.Traversal = Traversal;
+class IO {
+    static get graphml() {
+        return 'graphml';
+    }
+    static get graphson() {
+        return 'graphson';
+    }
+    static get gryo() {
+        return 'gryo';
+    }
+    static get reader() {
+        return '~tinkerpop.io.reader';
+    }
+    static get registry() {
+        return '~tinkerpop.io.registry';
+    }
+    static get writer() {
+        return '~tinkerpop.io.writer';
+    }
+}
+exports.IO = IO;
+// eslint-disable-next-line no-unused-vars
+class ConnectedComponent {
+    static get component() {
+        return 'gremlin.connectedComponentVertexProgram.component';
+    }
+    static get edges() {
+        return '~tinkerpop.connectedComponent.edges';
+    }
+    static get propertyName() {
+        return '~tinkerpop.connectedComponent.propertyName';
+    }
+}
+// eslint-disable-next-line no-unused-vars
+class ShortestPath {
+    static get distance() {
+        return '~tinkerpop.shortestPath.distance';
+    }
+    static get edges() {
+        return '~tinkerpop.shortestPath.edges';
+    }
+    static get includeEdges() {
+        return '~tinkerpop.shortestPath.includeEdges';
+    }
+    static get maxDistance() {
+        return '~tinkerpop.shortestPath.maxDistance';
+    }
+    static get target() {
+        return '~tinkerpop.shortestPath.target';
+    }
+}
+// eslint-disable-next-line no-unused-vars
+class PageRank {
+    static get edges() {
+        return '~tinkerpop.pageRank.edges';
+    }
+    static get propertyName() {
+        return '~tinkerpop.pageRank.propertyName';
+    }
+    static get times() {
+        return '~tinkerpop.pageRank.times';
+    }
+}
+// eslint-disable-next-line no-unused-vars
+class PeerPressure {
+    static get edges() {
+        return '~tinkerpop.peerPressure.edges';
+    }
+    static get propertyName() {
+        return '~tinkerpop.peerPressure.propertyName';
+    }
+    static get times() {
+        return '~tinkerpop.peerPressure.times';
+    }
+}
+class P {
+    operator;
+    value;
+    other;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator, value, other) {
+        this.operator = operator;
+        this.value = value;
+        this.other = other;
+    }
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString() {
+        function formatValue(value) {
+            if (Array.isArray(value)) {
+                const acc = [];
+                for (const item of value) {
+                    acc.push(formatValue(item));
+                }
+                return '[' + acc.join(', ') + ']';
+            }
+            if (value && typeof value === 'string') {
+                return `'${value}'`;
+            }
+            return String(value);
+        }
+        if (this.other === undefined || this.other === null) {
+            return this.operator + '(' + formatValue(this.value) + ')';
+        }
+        return this.operator + '(' + formatValue(this.value) + ', ' + formatValue(this.other) + ')';
+    }
+    and(arg) {
+        return new P('and', this, arg);
+    }
+    or(arg) {
+        return new P('or', this, arg);
+    }
+    static within(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            return new P('within', args[0], null);
+        }
+        return new P('within', args, null);
+    }
+    static without(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            return new P('without', args[0], null);
+        }
+        return new P('without', args, null);
+    }
+    /** @param {...Object} args */
+    static between(...args) {
+        return createP('between', args);
+    }
+    /** @param {...Object} args */
+    static eq(...args) {
+        return createP('eq', args);
+    }
+    /** @param {...Object} args */
+    static gt(...args) {
+        return createP('gt', args);
+    }
+    /** @param {...Object} args */
+    static gte(...args) {
+        return createP('gte', args);
+    }
+    /** @param {...Object} args */
+    static inside(...args) {
+        return createP('inside', args);
+    }
+    /** @param {...Object} args */
+    static lt(...args) {
+        return createP('lt', args);
+    }
+    /** @param {...Object} args */
+    static lte(...args) {
+        return createP('lte', args);
+    }
+    /** @param {...Object} args */
+    static neq(...args) {
+        return createP('neq', args);
+    }
+    /** @param {...Object} args */
+    static not(...args) {
+        return createP('not', args);
+    }
+    /** @param {...Object} args */
+    static outside(...args) {
+        return createP('outside', args);
+    }
+    /** @param {...Object} args */
+    static typeOf(...args) {
+        return createP('typeOf', args);
+    }
+    /** @param {...Object} args */
+    static test(...args) {
+        return createP('test', args);
+    }
+}
+exports.P = P;
+function createP(operator, args) {
+    args.unshift(null, operator);
+    return new (Function.prototype.bind.apply(P, args))();
+}
+class TextP {
+    operator;
+    value;
+    other;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator, value, other) {
+        this.operator = operator;
+        this.value = value;
+        this.other = other;
+    }
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString() {
+        function formatValue(value) {
+            if (value && typeof value === 'string') {
+                return `'${value}'`;
+            }
+            return value;
+        }
+        if (this.other === undefined) {
+            return this.operator + '(' + formatValue(this.value) + ')';
+        }
+        return this.operator + '(' + formatValue(this.value) + ', ' + formatValue(this.other) + ')';
+    }
+    and(arg) {
+        return new P('and', this, arg);
+    }
+    or(arg) {
+        return new P('or', this, arg);
+    }
+    /** @param {...Object} args */
+    static containing(...args) {
+        return createTextP('containing', args);
+    }
+    /** @param {...Object} args */
+    static endingWith(...args) {
+        return createTextP('endingWith', args);
+    }
+    /** @param {...Object} args */
+    static notContaining(...args) {
+        return createTextP('notContaining', args);
+    }
+    /** @param {...Object} args */
+    static notEndingWith(...args) {
+        return createTextP('notEndingWith', args);
+    }
+    /** @param {...Object} args */
+    static notStartingWith(...args) {
+        return createTextP('notStartingWith', args);
+    }
+    /** @param {...Object} args */
+    static startingWith(...args) {
+        return createTextP('startingWith', args);
+    }
+    /** @param {...Object} args */
+    static regex(...args) {
+        return createTextP('regex', args);
+    }
+    /** @param {...Object} args */
+    static notRegex(...args) {
+        return createTextP('notRegex', args);
+    }
+}
+exports.TextP = TextP;
+function createTextP(operator, args) {
+    args.unshift(null, operator);
+    return new (Function.prototype.bind.apply(TextP, args))();
+}
+class Traverser {
+    object;
+    bulk;
+    constructor(object, bulk) {
+        this.object = object;
+        this.bulk = bulk;
+        this.bulk = bulk || 1;
+    }
+}
+exports.Traverser = Traverser;
+class TraversalSideEffects {
+}
+exports.TraversalSideEffects = TraversalSideEffects;
+exports.withOptions = {
+    tokens: '~tinkerpop.valueMap.tokens',
+    none: 0,
+    ids: 1,
+    labels: 2,
+    keys: 4,
+    values: 8,
+    all: 15,
+    indexer: '~tinkerpop.index.indexer',
+    list: 0,
+    map: 1,
+};
+function toEnum(typeName, keys) {
+    const result = {};
+    keys.split(' ').forEach((k) => {
+        let jsKey = k;
+        if (jsKey === jsKey.toUpperCase()) {
+            jsKey = jsKey.toLowerCase();
+        }
+        result[jsKey] = new EnumValue(typeName, k);
+    });
+    return result;
+}
+const directionAlias = {
+    from_: 'out',
+    to: 'in',
+};
+// for direction enums, maps the same EnumValue object to the enum aliases after creating them
+function toDirectionEnum(typeName, keys) {
+    const result = toEnum(typeName, keys);
+    Object.keys(directionAlias).forEach((k) => {
+        result[k] = result[directionAlias[k]];
+    });
+    return result;
+}
+function toGTypeEnum(typeName, keys) {
+    const result = {};
+    keys.split(' ').forEach((k) => {
+        result[k] = new EnumValue(typeName, k.toUpperCase());
+    });
+    return result;
+}
+class EnumValue {
+    typeName;
+    elementName;
+    constructor(typeName, elementName) {
+        this.typeName = typeName;
+        this.elementName = elementName;
+    }
+    toString() {
+        return this.typeName + '.' + this.elementName;
+    }
+}
+exports.EnumValue = EnumValue;
+exports.barrier = toEnum('Barrier', 'normSack');
+exports.cardinality = toEnum('Cardinality', 'list set single');
+exports.column = toEnum('Column', 'keys values');
+exports.direction = toDirectionEnum('Direction', 'BOTH IN OUT from_ to');
+exports.dt = toEnum('DT', 'second minute hour day');
+exports.gType = toGTypeEnum('GType', 'bigDecimal bigInt binary boolean byte char datetime double duration edge float graph int list long map null number path property set short string tree uuid vertex vproperty');
+exports.graphSONVersion = toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0');
+exports.gryoVersion = toEnum('GryoVersion', 'V1_0 V3_0');
+exports.merge = toEnum('Merge', 'onCreate onMatch outV inV');
+exports.operator = toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong');
+exports.order = toEnum('Order', 'asc desc shuffle');
+exports.pick = toEnum('Pick', 'any none unproductive');
+exports.pop = toEnum('Pop', 'all first last mixed');
+exports.scope = toEnum('Scope', 'global local');
+exports.t = toEnum('T', 'id key label value');
+exports.n = toEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal');