gremlin 3.8.0 → 4.0.0-beta.2

package/build/esm/process/gremlin-lang.d.ts

@@ -0,0 +1,15 @@
+import { OptionsStrategy } from './traversal-strategy.js';
+export default class GremlinLang {
+    private gremlin;
+    private optionsStrategies;
+    private parameters;
+    constructor(toClone?: GremlinLang);
+    getOptionsStrategies(): OptionsStrategy[];
+    addG(g: string): void;
+    getParameters(): Map<string, any>;
+    private _predicateAsString;
+    private _argAsString;
+    addStep(name: string, args?: any[]): GremlinLang;
+    addSource(name: string, args?: any[]): GremlinLang;
+    getGremlin(prefix?: string): string;
+}

package/build/esm/process/gremlin-lang.js

@@ -0,0 +1,193 @@
+/*
+ *  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 { P, TextP, EnumValue } from './traversal.js';
+import { OptionsStrategy, TraversalStrategy } from './traversal-strategy.js';
+import { Long } from '../utils.js';
+import { Vertex } from '../structure/graph.js';
+export default class GremlinLang {
+    gremlin = '';
+    optionsStrategies = [];
+    parameters = new Map();
+    constructor(toClone) {
+        if (toClone) {
+            this.gremlin = toClone.gremlin;
+            this.optionsStrategies = [...toClone.optionsStrategies];
+            this.parameters = new Map(toClone.parameters);
+        }
+    }
+    getOptionsStrategies() {
+        return this.optionsStrategies;
+    }
+    addG(g) {
+        this.parameters.set('g', g);
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    _predicateAsString(p) {
+        if (p.operator === 'and' || p.operator === 'or') {
+            return `${this._predicateAsString(p.value)}.${p.operator}(${this._predicateAsString(p.other)})`;
+        }
+        let result = p.operator + '(';
+        if (Array.isArray(p.value)) {
+            result += '[' + p.value.map(v => this._argAsString(v)).join(',') + ']';
+        }
+        else {
+            result += this._argAsString(p.value);
+            if (p.other !== undefined && p.other !== null) {
+                result += ',' + this._argAsString(p.other);
+            }
+        }
+        result += ')';
+        return result;
+    }
+    _argAsString(arg) {
+        if (arg === null || arg === undefined)
+            return 'null';
+        if (typeof arg === 'boolean')
+            return arg ? 'true' : 'false';
+        if (arg instanceof Long) {
+            return String(arg.value) + 'L';
+        }
+        if (typeof arg === 'bigint') {
+            return String(arg) + 'N';
+        }
+        if (typeof arg === 'number') {
+            if (Number.isNaN(arg))
+                return 'NaN';
+            if (arg === Infinity)
+                return '+Infinity';
+            if (arg === -Infinity)
+                return '-Infinity';
+            if (!Number.isInteger(arg))
+                return String(arg) + 'D';
+            if (arg >= -2147483648 && arg <= 2147483647)
+                return String(arg);
+            // Outside safe integer range, values have lost precision and may exceed Java Long — emit as Double.
+            if (arg > Number.MAX_SAFE_INTEGER || arg < -Number.MAX_SAFE_INTEGER)
+                return String(arg) + 'D';
+            return String(arg) + 'L';
+        }
+        if (arg instanceof Date) {
+            const iso = arg.toISOString();
+            return `datetime("${iso}")`;
+        }
+        if (typeof arg === 'string') {
+            // JSON.stringify handles all special character escaping in one call.
+            // Strip the outer double quotes and re-wrap in single quotes for Gremlin.
+            const escaped = JSON.stringify(arg).slice(1, -1).replace(/'/g, "\\'");
+            return `'${escaped}'`;
+        }
+        if (arg instanceof P || arg instanceof TextP) {
+            return this._predicateAsString(arg);
+        }
+        if (arg instanceof EnumValue) {
+            return arg.toString();
+        }
+        if (arg instanceof TraversalStrategy && !(arg instanceof OptionsStrategy)) {
+            const simpleName = arg.strategyName;
+            const configEntries = Object.entries(arg.configuration);
+            if (configEntries.length === 0) {
+                return simpleName;
+            }
+            const configStr = configEntries.map(([k, v]) => `${k}:${this._argAsString(v)}`).join(',');
+            return `new ${simpleName}(${configStr})`;
+        }
+        if (typeof arg === 'function' && arg.prototype instanceof TraversalStrategy) {
+            return arg.name;
+        }
+        if (arg instanceof Vertex) {
+            return this._argAsString(arg.id);
+        }
+        if (arg instanceof GremlinLang) {
+            return arg.getGremlin('__');
+        }
+        if (typeof arg.getGremlinLang === 'function') {
+            // This is a Traversal - render as anonymous traversal
+            if (arg.graph != null) {
+                throw new Error('Child traversal must be anonymous - use __ not g');
+            }
+            return arg.getGremlinLang().getGremlin('__');
+        }
+        if (arg instanceof Set) {
+            const items = [...arg];
+            if (items.length === 0)
+                return '{}';
+            return '{' + items.map(a => this._argAsString(a)).join(',') + '}';
+        }
+        if (arg instanceof Map) {
+            if (arg.size === 0)
+                return '[:]';
+            const entries = [];
+            arg.forEach((v, k) => {
+                const ks = this._argAsString(k);
+                const vs = this._argAsString(v);
+                entries.push(typeof k === 'string' ? `${ks}:${vs}` : `(${ks}):${vs}`);
+            });
+            return '[' + entries.join(',') + ']';
+        }
+        if (Array.isArray(arg)) {
+            return '[' + arg.map(a => this._argAsString(a)).join(',') + ']';
+        }
+        if (typeof arg === 'object' && arg.constructor === Object) {
+            const entries = Object.entries(arg);
+            if (entries.length === 0)
+                return '[:]';
+            return '[' + entries.map(([k, v]) => `${this._argAsString(k)}:${this._argAsString(v)}`).join(',') + ']';
+        }
+        return String(arg);
+    }
+    addStep(name, args) {
+        const argsStr = args?.length ? args.map(a => this._argAsString(a)).join(',') : '';
+        this.gremlin += `.${name}(${argsStr})`;
+        return this;
+    }
+    addSource(name, args) {
+        if (name === 'CardinalityValueTraversal' && args) {
+            const card = args[0];
+            this.gremlin += `Cardinality.${card.elementName}(${this._argAsString(args[1])})`;
+            return this;
+        }
+        if (name === 'withStrategies' && args) {
+            const nonOptionsStrategies = [];
+            for (const strategy of args) {
+                if (strategy instanceof OptionsStrategy) {
+                    this.optionsStrategies.push(strategy);
+                }
+                else {
+                    nonOptionsStrategies.push(strategy);
+                }
+            }
+            if (nonOptionsStrategies.length > 0) {
+                const argsStr = nonOptionsStrategies.map(a => this._argAsString(a)).join(',');
+                this.gremlin += `.withStrategies(${argsStr})`;
+            }
+            return this;
+        }
+        const argsStr = args?.length ? args.map(a => this._argAsString(a)).join(',') : '';
+        this.gremlin += `.${name}(${argsStr})`;
+        return this;
+    }
+    getGremlin(prefix = 'g') {
+        if (this.gremlin.length > 0 && this.gremlin[0] !== '.') {
+            return this.gremlin;
+        }
+        return prefix + this.gremlin;
+    }
+}

package/build/esm/process/transaction.d.ts

@@ -0,0 +1,34 @@
+import { GraphTraversalSource } from './graph-traversal.js';
+/**
+ * A controller for a remote transaction that is constructed from <code>g.tx()</code>. Calling <code>begin()</code>
+ * on this object will produce a new <code>GraphTraversalSource</code> that is bound to a remote transaction over which
+ * multiple traversals may be executed in that context. Calling <code>commit()</code> or <code>rollback()</code> will
+ * then close the transaction and thus, the session. This feature only works with transaction enabled graphs.
+ */
+export declare class Transaction {
+    private readonly g;
+    private _sessionBasedConnection?;
+    constructor(g: GraphTraversalSource);
+    /**
+     * Spawns a <code>GraphTraversalSource</code> that is bound to a remote session which enables a transaction.
+     * @returns {GraphTraversalSource}
+     */
+    begin(): GraphTraversalSource;
+    /**
+     * @returns {Promise}
+     */
+    commit(): Promise<void>;
+    /**
+     * @returns {Promise}
+     */
+    rollback(): Promise<void>;
+    /**
+     * Returns true if transaction is open.
+     * @returns {Boolean}
+     */
+    get isOpen(): boolean;
+    /**
+     * @returns {Promise}
+     */
+    close(): Promise<void>;
+}

package/build/esm/process/transaction.js

@@ -0,0 +1,65 @@
+/*
+ *  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.
+ */
+/**
+ * A controller for a remote transaction that is constructed from <code>g.tx()</code>. Calling <code>begin()</code>
+ * on this object will produce a new <code>GraphTraversalSource</code> that is bound to a remote transaction over which
+ * multiple traversals may be executed in that context. Calling <code>commit()</code> or <code>rollback()</code> will
+ * then close the transaction and thus, the session. This feature only works with transaction enabled graphs.
+ */
+export class Transaction {
+    g;
+    _sessionBasedConnection = undefined;
+    constructor(g) {
+        this.g = g;
+    }
+    /**
+     * Spawns a <code>GraphTraversalSource</code> that is bound to a remote session which enables a transaction.
+     * @returns {GraphTraversalSource}
+     */
+    begin() {
+        throw new Error("Transactions are not yet implemented");
+    }
+    /**
+     * @returns {Promise}
+     */
+    commit() {
+        throw new Error("Transactions are not yet implemented");
+    }
+    /**
+     * @returns {Promise}
+     */
+    rollback() {
+        throw new Error("Transactions are not yet implemented");
+    }
+    /**
+     * Returns true if transaction is open.
+     * @returns {Boolean}
+     */
+    get isOpen() {
+        return this._sessionBasedConnection?.isOpen ?? false;
+    }
+    /**
+     * @returns {Promise}
+     */
+    async close() {
+        if (this._sessionBasedConnection) {
+            this._sessionBasedConnection.close();
+        }
+    }
+}

package/build/esm/process/traversal-strategy.d.ts

@@ -0,0 +1,211 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import type { RemoteConnection } from '../driver/remote-connection.js';
+import { Traversal } from './traversal.js';
+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);
+}