gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/process/traversal.cjs

@@ -0,0 +1,539 @@
+"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.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;
+    /** @internal Async results stream set by RemoteStrategy */
+    _resultsStream = null;
+    /** @internal Buffered traverser for bulk expansion and hasNext peek */
+    _currentTraverser = null;
+    /** Trailing response status from the server, populated after iteration completes. */
+    _status = null;
+    sideEffects = null;
+    _traversalStrategiesPromise = null;
+    _done = false;
+    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;
+    }
+    /**
+     * Gets the trailing response status from the server.
+     * Available after the traversal has been fully iterated (via toList(), iterate(), or manual iteration).
+     * Returns null if the traversal has not completed.
+     * @returns {{ code: number, message: string | null, exception: string | null } | null}
+     */
+    getStatus() {
+        return this._status;
+    }
+    /**
+     * Returns an Array containing the traverser objects.
+     * @returns {Promise.<Array>}
+     */
+    async toList() {
+        await this._applyStrategies();
+        const result = [];
+        while (true) {
+            const it = await this._getNext();
+            if (it.done)
+                break;
+            result.push(it.value);
+        }
+        return result;
+    }
+    /**
+     * Determines if there are any more items to iterate from the traversal.
+     * @returns {Promise.<boolean>}
+     */
+    async hasNext() {
+        await this._applyStrategies();
+        // If we have a current traverser with remaining bulk, there's more
+        if (this._currentTraverser && this._currentTraverser.bulk > 0) {
+            return true;
+        }
+        if (this._done)
+            return false;
+        // Try to pull the next item from the source to check
+        if (this._resultsStream) {
+            const { value, done } = await this._resultsStream.next();
+            if (done) {
+                this._done = true;
+                return false;
+            }
+            // Buffer it as a traverser for the next _getNext() call
+            this._currentTraverser = value instanceof Traverser ? value : new Traverser(value, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Iterates all Traverser instances in the traversal.
+     * @returns {Promise}
+     */
+    async iterate() {
+        this.gremlinLang.addStep('discard');
+        await this._applyStrategies();
+        while (true) {
+            const it = await this._getNext();
+            if (it.done)
+                break;
+        }
+    }
+    async next(amount) {
+        await this._applyStrategies();
+        if (amount === undefined || amount === null) {
+            return this._getNext();
+        }
+        const result = [];
+        for (let i = 0; i < amount; i++) {
+            const it = await this._getNext();
+            if (it.done) {
+                break;
+            }
+            result.push(it.value);
+        }
+        return result;
+    }
+    /**
+     * Pull the next value, handling Traverser bulk expansion.
+     * @private
+     */
+    async _getNext() {
+        // Drain current traverser's bulk first
+        if (this._currentTraverser) {
+            if (this._currentTraverser.bulk > 0) {
+                this._currentTraverser.bulk--;
+                const value = this._currentTraverser.object;
+                if (this._currentTraverser.bulk <= 0) {
+                    this._currentTraverser = null;
+                }
+                return { value, done: false };
+            }
+            this._currentTraverser = null;
+        }
+        // Streaming source path
+        if (this._resultsStream) {
+            if (this._done)
+                return itemDone;
+            const { value, done } = await this._resultsStream.next();
+            if (done) {
+                this._done = true;
+                this._status = value ?? null;
+                return itemDone;
+            }
+            if (value instanceof Traverser) {
+                if (value.bulk > 0) {
+                    value.bulk--;
+                    const result = value.object;
+                    if (value.bulk > 0) {
+                        this._currentTraverser = value;
+                    }
+                    return { value: result, done: false };
+                }
+                return itemDone;
+            }
+            return { value, 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);
+        }
+        if (args.length === 1 && args[0] != null && typeof args[0].getGremlinLang === 'function') {
+            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);
+        }
+        if (args.length === 1 && args[0] != null && typeof args[0].getGremlinLang === 'function') {
+            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.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');