gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/structure/io/binary/internals/VertexSerializer.d.cts

@@ -0,0 +1,22 @@
+export default class VertexSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Vertex<any, any, any, any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Async deserialization of vertex value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Vertex>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Vertex>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Vertex|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Vertex | null>;
+}
+import { Vertex } from '../../../graph.cjs';
+import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/utils.cjs

@@ -0,0 +1,53 @@
+"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.des_error = void 0;
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+/*
+ * Deserialization error general constructor.
+ */
+const des_error = ({ serializer, args, cursor, err }) => {
+    if (cursor === undefined) {
+        cursor = args[0]; // buffer
+    }
+    let cursor_tail = '';
+    if (cursor instanceof buffer_1.Buffer) {
+        if (cursor.length > 32) {
+            cursor_tail = '...';
+        }
+        cursor = cursor.slice(0, 32).toString('hex');
+    }
+    const fullyQualifiedFormat = args[1];
+    const nullable = args[2];
+    let m = `${serializer.constructor.name}.deserialize(cursor=${cursor}${cursor_tail}`;
+    if (fullyQualifiedFormat !== undefined) {
+        m += `, fullyQualifiedFormat=${fullyQualifiedFormat}`;
+    }
+    if (nullable !== undefined) {
+        m += `, nullable=${nullable}`;
+    }
+    m += `): ${err.message.replace(/\.$/, '')}.`;
+    err.message = m;
+    return err;
+};
+exports.des_error = des_error;

package/build/cjs/structure/io/binary/internals/utils.d.cts

@@ -0,0 +1,6 @@
+export function des_error({ serializer, args, cursor, err }: {
+    serializer: any;
+    args: any;
+    cursor: any;
+    err: any;
+}): any;

package/build/cjs/utils.cjs

@@ -0,0 +1,259 @@
+"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.DeferredPromise = exports.toArrayBuffer = exports.getUserAgent = exports.ImmutableMap = exports.emptyArray = exports.Byte = exports.Short = exports.Double = exports.Float = exports.Int = exports.Long = exports.INT32_MAX = exports.INT32_MIN = void 0;
+exports.toLong = toLong;
+exports.toInt = toInt;
+exports.toFloat = toFloat;
+exports.toDouble = toDouble;
+exports.toShort = toShort;
+exports.toByte = toByte;
+exports.unwrap = unwrap;
+exports.getUuid = getUuid;
+exports.getUserAgentHeader = getUserAgentHeader;
+/**
+ * A module containing any utility functions.
+ * @author Jorge Bay Gondra
+ */
+const gremlinVersion = '4.0.0-beta.3'; // DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+const INT64_MIN = -9223372036854775808n;
+const INT64_MAX = 9223372036854775807n;
+exports.INT32_MIN = -2147483648;
+exports.INT32_MAX = 2147483647;
+function toLong(value) {
+    return new Long(value);
+}
+class Long {
+    value;
+    type = 'long';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'bigint') {
+            throw new TypeError('The value must be a string, a number, or a bigint');
+        }
+        if (typeof value === 'string') {
+            if (!/^(?:0|-?[1-9]\d*)$/.test(value)) {
+                throw new TypeError('Long value must be a valid integer');
+            }
+            const n = BigInt(value);
+            if (n < INT64_MIN || n > INT64_MAX) {
+                throw new RangeError('Long value is outside int64 range');
+            }
+        }
+        if (typeof value === 'number') {
+            if (!Number.isInteger(value)) {
+                throw new TypeError('Long value must be an integer');
+            }
+            if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+                throw new RangeError('Long number values outside safe integer range lose precision; use string or bigint');
+            }
+        }
+        if (typeof value === 'bigint') {
+            if (value < INT64_MIN || value > INT64_MAX) {
+                throw new RangeError('Long value is outside int64 range');
+            }
+        }
+    }
+    valueOf() {
+        if (typeof this.value === 'number')
+            return this.value;
+        const big = typeof this.value === 'bigint' ? this.value : BigInt(this.value);
+        if (big > BigInt(Number.MAX_SAFE_INTEGER) || big < BigInt(Number.MIN_SAFE_INTEGER)) {
+            throw new RangeError('Long value is outside safe integer range');
+        }
+        return Number(big);
+    }
+    [Symbol.toPrimitive](hint) {
+        if (hint === 'string')
+            return String(this.value);
+        return this.valueOf();
+    }
+    toJSON() {
+        if (typeof this.value === 'bigint')
+            return this.value.toString();
+        return this.value;
+    }
+}
+exports.Long = Long;
+class Int {
+    value;
+    type = 'int';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Int value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Int value must be a finite integer');
+        }
+        if (value < exports.INT32_MIN || value > exports.INT32_MAX) {
+            throw new RangeError('Int value must be within int32 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+exports.Int = Int;
+class Float {
+    value;
+    type = 'float';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Float value must be a number');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+exports.Float = Float;
+class Double {
+    value;
+    type = 'double';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Double value must be a number');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+exports.Double = Double;
+class Short {
+    value;
+    type = 'short';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Short value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Short value must be a finite integer');
+        }
+        if (value < -32768 || value > 32767) {
+            throw new RangeError('Short value must be within int16 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+exports.Short = Short;
+class Byte {
+    value;
+    type = 'byte';
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'number') {
+            throw new TypeError('Byte value must be a number');
+        }
+        if (!Number.isFinite(value) || !Number.isInteger(value)) {
+            throw new TypeError('Byte value must be a finite integer');
+        }
+        if (value < -128 || value > 127) {
+            throw new RangeError('Byte value must be within int8 range');
+        }
+    }
+    valueOf() { return this.value; }
+    [Symbol.toPrimitive](hint) { return hint === 'string' ? String(this.value) : this.value; }
+    toJSON() { return this.value; }
+}
+exports.Byte = Byte;
+function toInt(value) { return new Int(value); }
+function toFloat(value) { return new Float(value); }
+function toDouble(value) { return new Double(value); }
+function toShort(value) { return new Short(value); }
+function toByte(value) { return new Byte(value); }
+function unwrap(value) {
+    if (value instanceof Long || value instanceof Int || value instanceof Float ||
+        value instanceof Double || value instanceof Short || value instanceof Byte) {
+        return value.value;
+    }
+    return value;
+}
+function getUuid() {
+    return globalThis.crypto.randomUUID();
+}
+exports.emptyArray = Object.freeze([]);
+class ImmutableMap extends Map {
+    constructor(iterable) {
+        super(iterable);
+    }
+    set() {
+        return this;
+    }
+    ['delete']() {
+        return false;
+    }
+    clear() { }
+}
+exports.ImmutableMap = ImmutableMap;
+async function generateNodeUserAgent() {
+    const os = await import('node:os');
+    const applicationName = (process?.env.npm_package_name ?? 'NotAvailable').replace('_', ' ');
+    let runtimeVersion;
+    let osName;
+    let osVersion;
+    let cpuArch;
+    runtimeVersion = osName = osVersion = cpuArch = 'NotAvailable';
+    if (process != null) {
+        if (process.version) {
+            runtimeVersion = process.version.replace(' ', '_');
+        }
+        if (process.arch) {
+            cpuArch = process.arch.replace(' ', '_');
+        }
+    }
+    if (os != null) {
+        osName = os.platform().replace(' ', '_');
+        osVersion = os.release().replace(' ', '_');
+    }
+    const userAgent = `${applicationName} Gremlin-Javascript.${gremlinVersion} ${runtimeVersion} ${osName}.${osVersion} ${cpuArch}`;
+    return userAgent;
+}
+function getUserAgentHeader() {
+    return 'User-Agent';
+}
+const getUserAgent = async () => {
+    if ('navigator' in globalThis) {
+        return globalThis.navigator.userAgent;
+    }
+    if (process?.versions?.node !== undefined) {
+        return await generateNodeUserAgent();
+    }
+    return undefined;
+};
+exports.getUserAgent = getUserAgent;
+const toArrayBuffer = (buffer) => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+exports.toArrayBuffer = toArrayBuffer;
+const DeferredPromise = () => {
+    let resolve = (value) => { };
+    let reject = (reason) => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return Object.assign(promise, { resolve, reject });
+};
+exports.DeferredPromise = DeferredPromise;

package/build/cjs/utils.d.cts

@@ -0,0 +1,78 @@
+export declare const INT32_MIN = -2147483648;
+export declare const INT32_MAX = 2147483647;
+export declare function toLong(value: number | string | bigint): Long;
+export declare class Long {
+    readonly value: number | string | bigint;
+    readonly type = "long";
+    constructor(value: number | string | bigint);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): string | number;
+}
+export declare class Int {
+    readonly value: number;
+    readonly type = "int";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Float {
+    readonly value: number;
+    readonly type = "float";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Double {
+    readonly value: number;
+    readonly type = "double";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Short {
+    readonly value: number;
+    readonly type = "short";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare class Byte {
+    readonly value: number;
+    readonly type = "byte";
+    constructor(value: number);
+    valueOf(): number;
+    [Symbol.toPrimitive](hint: string): string | number;
+    toJSON(): number;
+}
+export declare function toInt(value: number): Int;
+export declare function toFloat(value: number): Float;
+export declare function toDouble(value: number): Double;
+export declare function toShort(value: number): Short;
+export declare function toByte(value: number): Byte;
+export declare function unwrap(value: Float): number;
+export declare function unwrap(value: Double): number;
+export declare function unwrap(value: Int): number;
+export declare function unwrap(value: Long): number | string | bigint;
+export declare function unwrap(value: Short): number;
+export declare function unwrap(value: Byte): number;
+export declare function unwrap<T>(value: T): T;
+export declare function getUuid(): `${string}-${string}-${string}-${string}-${string}`;
+export declare const emptyArray: any[];
+export declare class ImmutableMap<K, V> extends Map<K, V> implements ReadonlyMap<K, V> {
+    constructor(iterable?: Iterable<[K, V]>);
+    set(): this;
+    ['delete'](): boolean;
+    clear(): void;
+}
+export declare function getUserAgentHeader(): string;
+export declare const getUserAgent: () => Promise<string | undefined>;
+export declare const toArrayBuffer: (buffer: Buffer) => ArrayBuffer | SharedArrayBuffer;
+export declare const DeferredPromise: <T>() => Promise<T> & {
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};

package/build/esm/driver/auth.d.ts

@@ -0,0 +1,9 @@
+import type { RequestInterceptor } from './http-request.js';
+export declare function basic(username: string, password: string): RequestInterceptor;
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export type AwsCredentialsProvider = () => AwsCredentials | Promise<AwsCredentials>;
+export declare function sigv4(region: string, service: string, credentialsProvider?: AwsCredentialsProvider): RequestInterceptor;

package/build/esm/driver/auth.js

@@ -0,0 +1,72 @@
+/*
+ *  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 { Buffer } from 'buffer';
+export function basic(username, password) {
+    return (request) => {
+        request.headers['authorization'] = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
+    };
+}
+export function sigv4(region, service, credentialsProvider) {
+    let signer;
+    let resolvedProvider;
+    return async (request) => {
+        // Ensure body is serialized to JSON bytes before signing.
+        // serializeBody is idempotent: safe to call even if already serialized.
+        request.serializeBody();
+        // Lazy-initialize signer and credentials provider on first use
+        if (!signer) {
+            const { SignatureV4 } = await import('@smithy/signature-v4');
+            const { Hash } = await import('@smithy/hash-node');
+            if (credentialsProvider) {
+                resolvedProvider = credentialsProvider;
+            }
+            else {
+                const { fromNodeProviderChain } = await import('@aws-sdk/credential-providers');
+                const chain = fromNodeProviderChain({ clientConfig: { region } });
+                resolvedProvider = () => chain();
+            }
+            signer = new SignatureV4({
+                service,
+                region,
+                sha256: Hash.bind(null, 'sha256'),
+                credentials: () => Promise.resolve(resolvedProvider()),
+            });
+        }
+        const url = new URL(request.url);
+        // Sign only the Host header; the signer itself adds (and signs) x-amz-date, the payload hash,
+        // and x-amz-security-token for session credentials. The request's own headers (accept,
+        // content-type, ...) are deliberately NOT fed into the signature: the HTTP stack may add or
+        // rewrite transport-managed headers such as accept-encoding after this interceptor runs, so a
+        // signature covering them would no longer match the bytes actually sent.
+        const signed = await signer.sign({
+            method: request.method,
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : undefined,
+            path: url.pathname + url.search,
+            headers: {
+                host: url.host,
+            },
+            body: request.body,
+        });
+        // Merge the signed auth headers onto the request; the request's other headers (accept,
+        // content-type, ...) still reach the wire, they are simply not part of the signature.
+        request.headers = { ...request.headers, ...signed.headers };
+    };
+}

package/build/esm/driver/client.d.ts

@@ -0,0 +1,88 @@
+import { ConnectionOptions } from './connection.js';
+import { Transaction } from '../process/transaction.js';
+export type RequestOptions = {
+    parameters?: any;
+    language?: string;
+    accept?: string;
+    timeoutMillis?: number;
+    batchSize?: number;
+    userAgent?: string;
+    materializeProperties?: string;
+    bulkResults?: boolean;
+    params?: Record<string, any>;
+    transactionId?: string;
+};
+export type ClientOptions = ConnectionOptions & RequestOptions & {
+    processor?: string;
+};
+/**
+ * A {@link Client} contains methods to send messages to a Gremlin Server.
+ */
+export default class Client {
+    #private;
+    readonly url: string;
+    readonly options: ClientOptions;
+    private readonly _connection;
+    /**
+     * Creates a new instance of {@link Client}.
+     * @param {String} url The resource uri.
+     * @param {ClientOptions} [options] The connection options.
+     */
+    private readonly _trackedTransactions;
+    constructor(url: string, options?: ClientOptions);
+    /**
+     * Opens the underlying connection to the Gremlin Server, if it's not already opened.
+     * @returns {Promise}
+     */
+    open(): Promise<void>;
+    /**
+     * Returns true if the underlying connection is open
+     * @returns {Boolean}
+     */
+    get isOpen(): boolean;
+    /**
+     * Send a request to the Gremlin Server and buffer the entire response.
+     * @param {string} message The script to send
+     * @param {Object|null} [parameters] The query parameters, if any.
+     * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
+     * @returns {Promise<ResultSet>}
+     */
+    submit(message: string, parameters: any | null, requestOptions?: RequestOptions): Promise<any>;
+    /**
+     * Send a request to the Gremlin Server and stream results incrementally.
+     * Returns an AsyncGenerator that yields individual result items as they are
+     * deserialized from the response. For bulked responses, yields Traverser objects.
+     * @param {string} message The script to send
+     * @param {Object|null} [parameters] The query parameters, if any.
+     * @param {RequestOptions} [requestOptions] Configuration specific to the current request.
+     * @returns {AsyncGenerator<any>}
+     */
+    stream(message: string, parameters: any | null, requestOptions?: RequestOptions): AsyncGenerator<any>;
+    /**
+     * Closes the underlying connection
+     * @returns {Promise}
+     */
+    close(): Promise<void>;
+    trackTransaction(tx: any): void;
+    untrackTransaction(tx: any): void;
+    /**
+     * Creates a new Transaction for executing operations within an explicit transaction.
+     * Transactions are short-lived and single-use. After commit or rollback,
+     * create a new Transaction for the next unit of work.
+     * The traversal source (g alias) is inherited from this Client.
+     * @returns {Transaction}
+     */
+    transact(): Transaction;
+    /**
+     * Adds an event listener to the connection
+     * @param {String} event The event name that you want to listen to.
+     * @param {Function} handler The callback to be called when the event occurs.
+     */
+    addListener(event: string, handler: (...args: any[]) => unknown): void;
+    /**
+     * Removes a previously added event listener to the connection
+     * @param {String} event The event name that you want to listen to.
+     * @param {Function} handler The event handler to be removed.
+     */
+    removeListener(event: string, handler: (...args: any[]) => unknown): void;
+}