gremlin 3.8.1 → 4.0.0-beta.3

package/build/esm/process/traversal.js

@@ -0,0 +1,526 @@
+/*
+ *  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;
+    /** @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 GremlinLang()) {
+        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();
+    }
+}
+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);
+        }
+        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);
+    }
+}
+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 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/PDTRegistry.d.ts

@@ -0,0 +1,34 @@
+export interface PdtAdapter {
+    serialize: (obj: any) => Record<string, any>;
+    deserialize: (fields: Record<string, any>) => any;
+}
+export interface PrimitivePdtAdapter {
+    toValue: (obj: any) => string;
+    fromValue: (value: string) => any;
+}
+/**
+ * A standalone registry that allows users to register adapters for hydrating
+ * raw {@link CompositePDT} and {@link PrimitivePDT} instances
+ * into domain-specific objects.
+ */
+export declare class PDTRegistry {
+    private readonly _adapters;
+    private readonly _adaptersByClass;
+    private readonly _primitiveAdapters;
+    private readonly _primitiveAdaptersByClass;
+    register(typeName: string, adapter: PdtAdapter, targetClass?: Function): void;
+    registerPrimitive(typeName: string, adapter: PrimitivePdtAdapter, targetClass?: Function): void;
+    hydrate(pdt: any): any;
+    hydratePrimitive(pdt: any): any;
+    hasAdapter(typeName: string): boolean;
+    hasPrimitiveAdapter(typeName: string): boolean;
+    getSerializer(typeName: string): ((obj: any) => Record<string, any>) | null;
+    getAdapterByClass(cls: Function): {
+        typeName: string;
+        serialize: (obj: any) => Record<string, any>;
+    } | null;
+    getPrimitiveAdapterByClass(cls: Function): {
+        typeName: string;
+        toValue: (obj: any) => string;
+    } | null;
+}

package/build/esm/structure/PDTRegistry.js

@@ -0,0 +1,112 @@
+/*
+ *  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 { CompositePDT, PrimitivePDT } from './graph.js';
+/**
+ * A standalone registry that allows users to register adapters for hydrating
+ * raw {@link CompositePDT} and {@link PrimitivePDT} instances
+ * into domain-specific objects.
+ */
+export class PDTRegistry {
+    _adapters = new Map();
+    _adaptersByClass = new Map();
+    _primitiveAdapters = new Map();
+    _primitiveAdaptersByClass = new Map();
+    register(typeName, adapter, targetClass) {
+        this._adapters.set(typeName, adapter);
+        if (targetClass) {
+            this._adaptersByClass.set(targetClass, { typeName, adapter });
+        }
+    }
+    registerPrimitive(typeName, adapter, targetClass) {
+        this._primitiveAdapters.set(typeName, adapter);
+        if (targetClass) {
+            this._primitiveAdaptersByClass.set(targetClass, { typeName, adapter });
+        }
+    }
+    hydrate(pdt) {
+        if (!(pdt instanceof CompositePDT))
+            return pdt;
+        const adapter = this._adapters.get(pdt.name);
+        const hydratedFields = {};
+        let changed = false;
+        for (const [k, v] of Object.entries(pdt.fields)) {
+            if (v instanceof CompositePDT) {
+                const h = this.hydrate(v);
+                hydratedFields[k] = h;
+                if (h !== v)
+                    changed = true;
+            }
+            else if (v instanceof PrimitivePDT) {
+                const h = this.hydratePrimitive(v);
+                hydratedFields[k] = h;
+                if (h !== v)
+                    changed = true;
+            }
+            else {
+                hydratedFields[k] = v;
+            }
+        }
+        if (!adapter) {
+            return changed ? new CompositePDT(pdt.name, hydratedFields) : pdt;
+        }
+        try {
+            return adapter.deserialize(hydratedFields);
+        }
+        catch (e) {
+            console.warn(`PDT hydration failed for '${pdt.name}': ${e.message}`);
+            return pdt;
+        }
+    }
+    hydratePrimitive(pdt) {
+        if (!(pdt instanceof PrimitivePDT))
+            return pdt;
+        const adapter = this._primitiveAdapters.get(pdt.name);
+        if (!adapter)
+            return pdt;
+        try {
+            return adapter.fromValue(pdt.value);
+        }
+        catch (e) {
+            console.warn(`Primitive PDT hydration failed for '${pdt.name}': ${e.message}`);
+            return pdt;
+        }
+    }
+    hasAdapter(typeName) {
+        return this._adapters.has(typeName);
+    }
+    hasPrimitiveAdapter(typeName) {
+        return this._primitiveAdapters.has(typeName);
+    }
+    getSerializer(typeName) {
+        const adapter = this._adapters.get(typeName);
+        return adapter ? adapter.serialize : null;
+    }
+    getAdapterByClass(cls) {
+        const entry = this._adaptersByClass.get(cls);
+        if (!entry)
+            return null;
+        return { typeName: entry.typeName, serialize: entry.adapter.serialize };
+    }
+    getPrimitiveAdapterByClass(cls) {
+        const entry = this._primitiveAdaptersByClass.get(cls);
+        if (!entry)
+            return null;
+        return { typeName: entry.typeName, toValue: entry.adapter.toValue };
+    }
+}