gremlin 3.8.0 → 4.0.0-beta.2

package/build/esm/structure/io/binary/internals/UuidSerializer.js

@@ -0,0 +1,106 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class UuidSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.UUID] = this;
+    }
+    canBeUsedFor(value) {
+        // TODO: any idea to support UUID automatic serialization via AnySerializer in future?
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.UUID, 0x01]);
+            }
+            return Buffer.from([
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]);
+        }
+        const uuid_str = String(item)
+            .replace(/^urn:uuid:/, '')
+            .replace(/[{}-]/g, '');
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.UUID, 0x00]));
+        }
+        const v = Buffer.alloc(16, 0);
+        for (let i = 0; i < 16 && i * 2 < uuid_str.length; i++) {
+            v[i] = parseInt(uuid_str.slice(i * 2, i * 2 + 2), 16);
+        }
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true, nullable = false) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.UUID) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (fullyQualifiedFormat || nullable) {
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (cursor.length < 16) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 16;
+            // Example: 2075278D-F624-4B2B-960D-25D374D57C04
+            const v = cursor.slice(0, 4).toString('hex') +
+                '-' +
+                cursor.slice(4, 6).toString('hex') +
+                '-' +
+                cursor.slice(6, 8).toString('hex') +
+                '-' +
+                cursor.slice(8, 10).toString('hex') +
+                '-' +
+                cursor.slice(10, 16).toString('hex');
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

package/build/esm/structure/io/binary/internals/VertexPropertySerializer.d.ts

@@ -0,0 +1,15 @@
+export default class VertexPropertySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is VertexProperty<any, any, any, any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: VertexProperty<any, any, Record<string, any>, any>;
+        len: number;
+    };
+}
+import { VertexProperty } from '../../../graph.js';
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/VertexPropertySerializer.js

@@ -0,0 +1,160 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { VertexProperty } from '../../../graph.js';
+export default class VertexPropertySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEXPROPERTY] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof VertexProperty;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x01]);
+            }
+            return Buffer.concat([
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {id}=null
+                this.ioc.listSerializer.serialize([], false), // {label}=empty list
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {value}=null
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {parent}=null
+                this.ioc.listSerializer.serialize([], true), // {properties}=empty list
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {value}
+        bufs.push(this.ioc.anySerializer.serialize(item.value));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.VERTEXPROPERTY) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            // {id} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+            let id, id_len;
+            try {
+                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += id_len;
+            }
+            catch (err) {
+                err.message = '{id}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(id_len);
+            // {label} is a List value
+            let label, label_len;
+            try {
+                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
+                len += label_len;
+            }
+            catch (err) {
+                err.message = '{label}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(label_len);
+            // {value} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+            let value, value_len;
+            try {
+                ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += value_len;
+            }
+            catch (err) {
+                err.message = '{value}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(value_len);
+            // {parent} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} which contains the parent Vertex.
+            // Note that as TinkerPop currently send "references" only, this value will always be null.
+            let parent_len;
+            try {
+                ({ len: parent_len } = this.ioc.unspecifiedNullSerializer.deserialize(cursor));
+                len += parent_len;
+            }
+            catch (err) {
+                err.message = '{parent}: ' + err.message;
+                throw err;
+            }
+            // TODO: should we verify that parent is null?
+            cursor = cursor.slice(parent_len);
+            // {properties} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} which contains properties. Note that as TinkerPop currently send "references" only, this value will always be null.
+            let properties, properties_len;
+            try {
+                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += properties_len;
+            }
+            catch (err) {
+                err.message = '{properties}: ' + err.message;
+                throw err;
+            }
+            // TODO: should we verify that properties is null?
+            cursor = cursor.slice(properties_len);
+            // null properties are deserialized into empty lists
+            const vp_props = properties ? properties : [];
+            const v = new VertexProperty(id, label, value, vp_props);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

package/build/esm/structure/io/binary/internals/VertexSerializer.d.ts

@@ -0,0 +1,17 @@
+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>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: Vertex<any, Record<string, any>, any, {
+            [x: string]: [import("../../../graph.js").VertexProperty<string, any, Record<string, any>, any>, ...import("../../../graph.js").VertexProperty<string, any, Record<string, any>, any>[]];
+        }>;
+        len: number;
+    };
+}
+import { Vertex } from '../../../graph.js';
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/VertexSerializer.js

@@ -0,0 +1,125 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { Vertex } from '../../../graph.js';
+export default class VertexSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEX] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Vertex;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.VERTEX, 0x01]);
+            }
+            const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const label = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const properties = [0x09, 0x00, 0x00, 0x00, 0x00, 0x00]; // empty list
+            return Buffer.from([...id, ...label, ...properties]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.VERTEX, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.VERTEX) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            let id, id_len;
+            try {
+                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += id_len;
+            }
+            catch (err) {
+                err.message = '{id}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(id_len);
+            let label, label_len;
+            try {
+                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
+                len += label_len;
+            }
+            catch (err) {
+                err.message = '{label}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(label_len);
+            let properties, properties_len;
+            try {
+                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += properties_len;
+            }
+            catch (err) {
+                err.message = '{properties}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(properties_len);
+            // null properties are deserialized into empty lists
+            const vertex_props = properties ? properties : [];
+            const v = new Vertex(id, label, vertex_props);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

package/build/esm/structure/io/binary/internals/utils.d.ts

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

package/{lib → build/esm}/structure/io/binary/internals/utils.js

@@ -16,46 +16,34 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 /**
  * @author Igor Ostapenko
  */
-'use strict';
-
-const { Buffer } = require('buffer');
-
+import { Buffer } from '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) {
-    if (cursor.length > 32) {
-      cursor_tail = '...';
+export const des_error = ({ serializer, args, cursor, err }) => {
+    if (cursor === undefined) {
+        cursor = args[0]; // buffer
     }
-    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;
-};
-
-module.exports = {
-  des_error,
+    let cursor_tail = '';
+    if (cursor instanceof 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;
 };

package/build/esm/utils.d.ts

@@ -0,0 +1,20 @@
+export declare function toLong(value: number | string): Long;
+export declare class Long {
+    value: number | string;
+    constructor(value: number | string);
+}
+export declare function getUuid(): 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/utils.js

@@ -0,0 +1,98 @@
+/*
+ *  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 module containing any utility functions.
+ * @author Jorge Bay Gondra
+ */
+import * as uuid from 'uuid';
+const gremlinVersion = '4.0.0-beta.2'; // DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+export function toLong(value) {
+    return new Long(value);
+}
+export class Long {
+    value;
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new TypeError('The value must be a string or a number');
+        }
+    }
+}
+export function getUuid() {
+    // TODO: replace with `globalThis.crypto.randomUUID` once supported Node version is bump to >=19
+    return uuid.v4();
+}
+export const emptyArray = Object.freeze([]);
+export class ImmutableMap extends Map {
+    constructor(iterable) {
+        super(iterable);
+    }
+    set() {
+        return this;
+    }
+    ['delete']() {
+        return false;
+    }
+    clear() { }
+}
+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;
+}
+export function getUserAgentHeader() {
+    return 'User-Agent';
+}
+export const getUserAgent = async () => {
+    if ('navigator' in globalThis) {
+        return globalThis.navigator.userAgent;
+    }
+    if (process?.versions?.node !== undefined) {
+        return await generateNodeUserAgent();
+    }
+    return undefined;
+};
+export const toArrayBuffer = (buffer) => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+export const DeferredPromise = () => {
+    let resolve = (value) => { };
+    let reject = (reason) => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return Object.assign(promise, { resolve, reject });
+};