gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/process/traversal.d.cts

@@ -0,0 +1,212 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import { Graph } from '../structure/graph.cjs';
+import { TraversalStrategies } from './traversal-strategy.cjs';
+import GremlinLang from './gremlin-lang.cjs';
+declare const asyncIteratorSymbol: symbol;
+export declare class Traversal {
+    /**
+     * Async iterable method implementation.
+     */
+    [asyncIteratorSymbol]: () => this;
+    graph: Graph | null;
+    traversalStrategies: TraversalStrategies | null;
+    gremlinLang: GremlinLang;
+    /** @internal Async results stream set by RemoteStrategy */
+    _resultsStream: AsyncGenerator<any> | null;
+    /** @internal Buffered traverser for bulk expansion and hasNext peek */
+    private _currentTraverser;
+    /** Trailing response status from the server, populated after iteration completes. */
+    private _status;
+    sideEffects?: any;
+    private _traversalStrategiesPromise;
+    private _done;
+    constructor(graph: Graph | null, traversalStrategies: TraversalStrategies | null, gremlinLang?: GremlinLang);
+    /** @returns {GremlinLang} */
+    getGremlinLang(): 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(): {
+        code: number;
+        message: string | null;
+        exception: string | null;
+    } | null;
+    /**
+     * 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>;
+    /**
+     * Returns the next result from the traversal.
+     *
+     * When called without an argument, returns a Promise that resolves to an iterator
+     * item ({value, done}), following the async iterator protocol.
+     *
+     * When called with an amount, returns a Promise that resolves to an Array containing
+     * up to {@code amount} result values. The Array form is always used when an amount is
+     * supplied, including {@code next(1)}, which resolves to an Array of one value rather
+     * than a bare value, matching the behavior of next(n) in the other Gremlin language
+     * variants. If fewer results remain, the Array contains only those that remain, and an
+     * amount of zero or less yields an empty Array.
+     * @param {Number} [amount] The number of results to retrieve.
+     * @returns {Promise.<{value, done}>|Promise.<Array>}
+     */
+    next<T>(): Promise<IteratorResult<T, null>>;
+    next<T>(amount: number): Promise<T[]>;
+    /**
+     * Pull the next value, handling Traverser bulk expansion.
+     * @private
+     */
+    _getNext<T>(): Promise<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 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 {};

package/build/cjs/structure/PDTRegistry.cjs

@@ -0,0 +1,116 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDTRegistry = void 0;
+const graph_js_1 = require("./graph.cjs");
+/**
+ * A standalone registry that allows users to register adapters for hydrating
+ * raw {@link CompositePDT} and {@link PrimitivePDT} instances
+ * into domain-specific objects.
+ */
+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 graph_js_1.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 graph_js_1.CompositePDT) {
+                const h = this.hydrate(v);
+                hydratedFields[k] = h;
+                if (h !== v)
+                    changed = true;
+            }
+            else if (v instanceof graph_js_1.PrimitivePDT) {
+                const h = this.hydratePrimitive(v);
+                hydratedFields[k] = h;
+                if (h !== v)
+                    changed = true;
+            }
+            else {
+                hydratedFields[k] = v;
+            }
+        }
+        if (!adapter) {
+            return changed ? new graph_js_1.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 graph_js_1.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 };
+    }
+}
+exports.PDTRegistry = PDTRegistry;

package/build/cjs/structure/PDTRegistry.d.cts

@@ -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;
+}