gremlin 3.8.0 → 4.0.0-beta.2

package/build/esm/process/traversal.js

@@ -0,0 +1,469 @@
+/*
+ *  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.
+ */
+import GremlinLang from './gremlin-lang.js';
+const itemDone = Object.freeze({ value: null, done: true });
+const asyncIteratorSymbol = Symbol.asyncIterator || Symbol('@@asyncIterator');
+export class Traversal {
+    graph;
+    traversalStrategies;
+    gremlinLang;
+    results = null;
+    sideEffects = null;
+    _traversalStrategiesPromise = null;
+    _resultsIteratorIndex = 0;
+    constructor(graph, traversalStrategies, gremlinLang = new GremlinLang()) {
+        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();
+    }
+}
+export 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';
+    }
+}
+// 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';
+    }
+}
+export 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);
+    }
+}
+function createP(operator, args) {
+    args.unshift(null, operator);
+    return new (Function.prototype.bind.apply(P, args))();
+}
+export 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);
+    }
+}
+function createTextP(operator, args) {
+    args.unshift(null, operator);
+    return new (Function.prototype.bind.apply(TextP, args))();
+}
+export class Traverser {
+    object;
+    bulk;
+    constructor(object, bulk) {
+        this.object = object;
+        this.bulk = bulk;
+        this.bulk = bulk || 1;
+    }
+}
+export class TraversalSideEffects {
+}
+export const 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;
+}
+export class EnumValue {
+    typeName;
+    elementName;
+    constructor(typeName, elementName) {
+        this.typeName = typeName;
+        this.elementName = elementName;
+    }
+    toString() {
+        return this.typeName + '.' + this.elementName;
+    }
+}
+export const barrier = toEnum('Barrier', 'normSack');
+export const cardinality = toEnum('Cardinality', 'list set single');
+export const column = toEnum('Column', 'keys values');
+export const direction = toDirectionEnum('Direction', 'BOTH IN OUT from_ to');
+export const dt = toEnum('DT', 'second minute hour day');
+export const 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');
+export const graphSONVersion = toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0');
+export const gryoVersion = toEnum('GryoVersion', 'V1_0 V3_0');
+export const merge = toEnum('Merge', 'onCreate onMatch outV inV');
+export const operator = toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong');
+export const order = toEnum('Order', 'asc desc shuffle');
+export const pick = toEnum('Pick', 'any none unproductive');
+export const pop = toEnum('Pop', 'all first last mixed');
+export const scope = toEnum('Scope', 'global local');
+export const t = toEnum('T', 'id key label value');
+export const n = toEnum('N', 'byte_ short_ int_ long_ float_ double_ bigInt bigDecimal');

package/build/esm/structure/graph.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+/**
+ * An "empty" graph object to server only as a reference.
+ */
+export declare class Graph {
+    toString(): string;
+}
+declare class Element<TLabel extends string = string, TId = any> {
+    readonly id: TId;
+    readonly label: TLabel;
+    readonly properties: Property[];
+    constructor(id: TId, label: TLabel, properties?: Property[]);
+    /**
+     * Compares this instance to another and determines if they can be considered as equal.
+     */
+    equals(other: any): boolean;
+}
+export declare class Vertex<TLabel extends string = string, TProperties extends Record<string, any> = Record<string, any>, TId = number, TVertexProperties = {
+    [P in keyof TProperties]: P extends string ? VertexProperties<P, TProperties[P]> : never;
+}> extends Element<TLabel, TId> {
+    constructor(id: TId, label: TLabel, properties?: Property[] | null);
+    toString(): string;
+}
+export declare class Edge<TOutVertex extends Vertex = Vertex, TLabel extends string = string, TInVertex extends Vertex = Vertex, TProperties extends Record<string, any> = Record<string, any>, TId = number> extends Element<TLabel, TId> {
+    readonly outV: TOutVertex;
+    readonly label: TLabel;
+    readonly inV: TInVertex;
+    constructor(id: TId, outV: TOutVertex, label: TLabel, inV: TInVertex, properties?: Property[] | null);
+    toString(): string;
+}
+export declare class VertexProperty<TLabel extends string = string, TValue = any, TProperties extends Record<string, any> | null | undefined = Record<string, any>, TId = any> extends Element<TLabel, TId> {
+    readonly value: TValue;
+    readonly key: string;
+    constructor(id: TId, label: TLabel, value: TValue, properties?: Property[] | null);
+    toString(): string;
+}
+export type VertexProperties<TLabel extends string = string, TValue = any, TProperties extends Record<string, any> = Record<string, any>, TId = any> = [VertexProperty<TLabel, TValue, TProperties, TId>, ...Array<VertexProperty<TLabel, TValue, TProperties, TId>>];
+export declare class Property<T = any> {
+    readonly key: string;
+    readonly value: T;
+    constructor(key: string, value: T);
+    toString(): string;
+    equals(other: any): boolean;
+}
+/**
+ * Represents a walk through a graph as defined by a traversal.
+ */
+export declare class Path {
+    readonly labels: string[][];
+    readonly objects: any[];
+    constructor(labels: string[][], objects: any[]);
+    toString(): string;
+    equals(other: any): any;
+}
+export {};

package/build/esm/structure/graph.js

@@ -0,0 +1,148 @@
+/*
+ *  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.
+ */
+/**
+ * @author Jorge Bay Gondra
+ */
+/**
+ * An "empty" graph object to server only as a reference.
+ */
+export class Graph {
+    toString() {
+        return 'graph[]';
+    }
+}
+class Element {
+    id;
+    label;
+    properties;
+    // properties are stored as list of property objects
+    constructor(id, label, properties = []) {
+        this.id = id;
+        this.label = label;
+        this.properties = properties;
+        this.properties = properties ?? [];
+    }
+    /**
+     * Compares this instance to another and determines if they can be considered as equal.
+     */
+    equals(other) {
+        return other instanceof Element && this.id === other.id;
+    }
+}
+export class Vertex extends Element {
+    constructor(id, label, properties = []) {
+        super(id, label, properties ?? []);
+    }
+    toString() {
+        return `v[${this.id}]`;
+    }
+}
+export class Edge extends Element {
+    outV;
+    label;
+    inV;
+    constructor(id, outV, label, inV, properties = []) {
+        super(id, label, properties ?? []);
+        this.outV = outV;
+        this.label = label;
+        this.inV = inV;
+    }
+    toString() {
+        const outVId = this.outV ? this.outV.id : '?';
+        const inVId = this.inV ? this.inV.id : '?';
+        return `e[${this.id}][${outVId}-${this.label}->${inVId}]`;
+    }
+}
+export class VertexProperty extends Element {
+    value;
+    key;
+    constructor(id, label, value, properties = []) {
+        super(id, label, properties ?? []);
+        this.value = value;
+        this.value = value;
+        this.key = this.label;
+    }
+    toString() {
+        return `vp[${this.label}->${summarize(this.value)}]`;
+    }
+}
+export class Property {
+    key;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+    toString() {
+        return `p[${this.key}->${summarize(this.value)}]`;
+    }
+    equals(other) {
+        return other instanceof Property && this.key === other.key && this.value === other.value;
+    }
+}
+/**
+ * Represents a walk through a graph as defined by a traversal.
+ */
+export class Path {
+    labels;
+    objects;
+    constructor(labels, objects) {
+        this.labels = labels;
+        this.objects = objects;
+    }
+    toString() {
+        return `path[${(this.objects || []).join(', ')}]`;
+    }
+    equals(other) {
+        if (!(other instanceof Path)) {
+            return false;
+        }
+        if (other === this) {
+            return true;
+        }
+        return areEqual(this.objects, other.objects) && areEqual(this.labels, other.labels);
+    }
+}
+function areEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (typeof obj1.equals === 'function') {
+        return obj1.equals(obj2);
+    }
+    if (Array.isArray(obj1) && Array.isArray(obj2)) {
+        if (obj1.length !== obj2.length) {
+            return false;
+        }
+        for (let i = 0; i < obj1.length; i++) {
+            if (!areEqual(obj1[i], obj2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function summarize(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const strValue = value.toString();
+    return strValue.length > 20 ? strValue.substr(0, 20) : strValue;
+}