gremlin 3.8.0 → 4.0.0-beta.2

package/build/esm/process/traversal-strategy.js

@@ -0,0 +1,319 @@
+/*
+ *  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 { Traversal } from './traversal.js';
+export class TraversalStrategies {
+    strategies;
+    /**
+     * Creates a new instance of TraversalStrategies.
+     * @param {TraversalStrategies} [parent] The parent strategies from where to clone the values from.
+     */
+    constructor(parent) {
+        if (parent) {
+            // Clone the strategies
+            this.strategies = [...parent.strategies];
+        }
+        else {
+            this.strategies = [];
+        }
+    }
+    /** @param {TraversalStrategy} strategy */
+    addStrategy(strategy) {
+        this.strategies.push(strategy);
+    }
+    /** @param {TraversalStrategy} strategy */
+    removeStrategy(strategy) {
+        const idx = this.strategies.findIndex((s) => s.strategyName === strategy.strategyName);
+        if (idx !== -1) {
+            return this.strategies.splice(idx, 1)[0];
+        }
+        return undefined;
+    }
+    /**
+     * @param {Traversal} traversal
+     * @returns {Promise}
+     */
+    applyStrategies(traversal) {
+        // Apply all strategies serially
+        return this.strategies.reduce((promise, strategy) => promise.then(() => strategy.apply(traversal)), Promise.resolve());
+    }
+}
+export class TraversalStrategy {
+    configuration;
+    connection;
+    strategyName;
+    /**
+     * @param {TraversalStrategyConfiguration} configuration for the strategy
+     */
+    constructor(configuration = {}) {
+        this.configuration = configuration;
+        this.strategyName = this.constructor.name;
+    }
+    /**
+     * @abstract
+     * @param {Traversal} traversal
+     * @returns {Promise}
+     */
+    async apply(traversal) { }
+}
+export class ConnectiveStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class ElementIdStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class HaltedTraverserStrategy extends TraversalStrategy {
+    /**
+     * @param {String} haltedTraverserFactory full qualified class name in Java of a `HaltedTraverserFactory` implementation
+     */
+    constructor({ haltedTraverserFactory = "" }) {
+        super({ haltedTraverserFactory: haltedTraverserFactory });
+    }
+}
+export class MessagePassingReductionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class OptionsStrategy extends TraversalStrategy {
+    constructor(options) {
+        super(options);
+    }
+}
+export 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 } = {}) {
+        const config = {};
+        if (partitionKey !== undefined)
+            config.partitionKey = partitionKey;
+        if (writePartition !== undefined)
+            config.writePartition = writePartition;
+        if (readPartitions !== undefined)
+            config.readPartitions = readPartitions;
+        if (includeMetaProperties !== undefined)
+            config.includeMetaProperties = includeMetaProperties;
+        super(config);
+    }
+}
+export class ProfileStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export 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 } = {}) {
+        const config = {};
+        if (vertices !== undefined)
+            config.vertices = vertices instanceof Traversal ? vertices.gremlinLang : vertices;
+        if (edges !== undefined)
+            config.edges = edges instanceof Traversal ? edges.gremlinLang : edges;
+        if (vertexProperties !== undefined)
+            config.vertexProperties = vertexProperties instanceof Traversal ? vertexProperties.gremlinLang : vertexProperties;
+        if (checkAdjacentVertices !== undefined)
+            config.checkAdjacentVertices = checkAdjacentVertices;
+        super(config);
+    }
+}
+export class ProductiveByStrategy extends TraversalStrategy {
+    /**
+     * @param options
+     * @param options.productiveKeys - set of keys that will always be productive
+     */
+    constructor({ productiveKeys = [] } = {}) {
+        super({ productiveKeys });
+    }
+}
+export class ReferenceElementStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class VertexProgramStrategy extends TraversalStrategy {
+    constructor(options) {
+        super(options);
+    }
+}
+export class MatchAlgorithmStrategy extends TraversalStrategy {
+    /**
+     * @param matchAlgorithm
+     */
+    constructor({ matchAlgorithm = "" }) {
+        super({ matchAlgorithm: matchAlgorithm });
+    }
+}
+export class ComputerFinalizationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class AdjacentToIncidentStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class FilterRankingStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class ByModulatorOptimizationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class IdentityRemovalStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class IncidentToAdjacentStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class InlineFilterStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class LazyBarrierStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class MatchPredicateStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class OrderLimitStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class PathProcessorStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class PathRetractionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class CountStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class RepeatUnrollStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class GraphFilterStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class EarlyLimitStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class ComputerVerificationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class LambdaRestrictionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class ReadOnlyStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export 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 = false, throwException = false } = {}) {
+        super({
+            logWarnings: logWarnings,
+            throwException: throwException,
+        });
+    }
+}
+export 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 = false, throwException = false, keys = ['id', 'label'] } = {}) {
+        super({
+            logWarnings: logWarnings,
+            throwException: throwException,
+            keys: keys,
+        });
+    }
+}
+export class VertexProgramRestrictionStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export class StandardVerificationStrategy extends TraversalStrategy {
+    constructor() {
+        super();
+    }
+}
+export 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) {
+        super({
+            seed: options.seed,
+        });
+    }
+}

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

@@ -0,0 +1,186 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import { Graph } from '../structure/graph.js';
+import { TraversalStrategies } from './traversal-strategy.js';
+import GremlinLang from './gremlin-lang.js';
+declare const asyncIteratorSymbol: symbol;
+export declare class Traversal {
+    /**
+     * Async iterable method implementation.
+     */
+    [asyncIteratorSymbol]: () => this;
+    graph: Graph | null;
+    traversalStrategies: TraversalStrategies | null;
+    gremlinLang: GremlinLang;
+    results: any[] | null;
+    sideEffects?: any;
+    private _traversalStrategiesPromise;
+    private _resultsIteratorIndex;
+    constructor(graph: Graph | null, traversalStrategies: TraversalStrategies | null, gremlinLang?: GremlinLang);
+    /** @returns {GremlinLang} */
+    getGremlinLang(): GremlinLang;
+    /**
+     * Returns an Array containing the traverser objects.
+     * @returns {Promise.<Array>}
+     */
+    toList<T>(): Promise<T[]>;
+    /**
+     * Determines if there are any more items to iterate from the traversal.
+     * @returns {Promise.<boolean>}
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Iterates all Traverser instances in the traversal.
+     * @returns {Promise}
+     */
+    iterate(): Promise<void>;
+    /**
+     * Async iterator method implementation.
+     * Returns a promise containing an iterator item.
+     * @returns {Promise.<{value, done}>}
+     */
+    next<T>(): Promise<IteratorResult<T, null>>;
+    /**
+     * Synchronous iterator of traversers including
+     * @private
+     */
+    _getNext<T>(): IteratorResult<T, null>;
+    _applyStrategies(): Promise<void>;
+    /**
+     * Returns step instructions during JSON serialization
+     * @returns {Array}
+     */
+    toJSON(): string;
+    /**
+     * Returns the GremlinLang representation of the traversal
+     * @returns {String}
+     */
+    toString(): string;
+}
+export declare class IO {
+    static get graphml(): string;
+    static get graphson(): string;
+    static get gryo(): string;
+    static get reader(): string;
+    static get registry(): string;
+    static get writer(): string;
+}
+export declare class P<T1 = any, T2 = any> {
+    operator: string;
+    value: T1;
+    other: T2;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator: string, value: T1, other: T2);
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString(): string;
+    and(arg?: any): P<this, any>;
+    or(arg?: any): P<this, any>;
+    static within(...args: any[]): P<any[], null>;
+    static without(...args: any[]): P<any[], null>;
+    /** @param {...Object} args */
+    static between(...args: any[]): any;
+    /** @param {...Object} args */
+    static eq(...args: any[]): any;
+    /** @param {...Object} args */
+    static gt(...args: any[]): any;
+    /** @param {...Object} args */
+    static gte(...args: any[]): any;
+    /** @param {...Object} args */
+    static inside(...args: any[]): any;
+    /** @param {...Object} args */
+    static lt(...args: any[]): any;
+    /** @param {...Object} args */
+    static lte(...args: any[]): any;
+    /** @param {...Object} args */
+    static neq(...args: any[]): any;
+    /** @param {...Object} args */
+    static not(...args: any[]): any;
+    /** @param {...Object} args */
+    static outside(...args: any[]): any;
+    /** @param {...Object} args */
+    static typeOf(...args: any[]): any;
+    /** @param {...Object} args */
+    static test(...args: any[]): any;
+}
+export declare class TextP<T1 = any, T2 = any> {
+    operator: string;
+    value: T1;
+    other: T2;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator: string, value: T1, other: T2);
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString(): string;
+    and(arg: any): P<this, any>;
+    or(arg: any): P<this, any>;
+    /** @param {...Object} args */
+    static containing(...args: any[]): any;
+    /** @param {...Object} args */
+    static endingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static notContaining(...args: any[]): any;
+    /** @param {...Object} args */
+    static notEndingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static notStartingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static startingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static regex(...args: any[]): any;
+    /** @param {...Object} args */
+    static notRegex(...args: any[]): any;
+}
+export declare class Traverser<T = any> {
+    object: T;
+    bulk: number;
+    constructor(object: T, bulk: number);
+}
+export declare class TraversalSideEffects {
+}
+export declare const withOptions: {
+    tokens: string;
+    none: number;
+    ids: number;
+    labels: number;
+    keys: number;
+    values: number;
+    all: number;
+    indexer: string;
+    list: number;
+    map: number;
+};
+export declare class EnumValue {
+    typeName: string;
+    elementName: string;
+    constructor(typeName: string, elementName: string);
+    toString(): string;
+}
+export declare const barrier: Record<string, EnumValue>;
+export declare const cardinality: Record<string, EnumValue>;
+export declare const column: Record<string, EnumValue>;
+export declare const direction: Record<string, EnumValue>;
+export declare const dt: Record<string, EnumValue>;
+export declare const gType: {
+    [key: string]: any;
+};
+export declare const graphSONVersion: Record<string, EnumValue>;
+export declare const gryoVersion: Record<string, EnumValue>;
+export declare const merge: Record<string, EnumValue>;
+export declare const operator: Record<string, EnumValue>;
+export declare const order: Record<string, EnumValue>;
+export declare const pick: Record<string, EnumValue>;
+export declare const pop: Record<string, EnumValue>;
+export declare const scope: Record<string, EnumValue>;
+export declare const t: Record<string, EnumValue>;
+export declare const n: Record<string, EnumValue>;
+export {};