addressing comments

Author: MaxAake

packages/bolt-connection/src/bolt/bolt-protocol-v6x0.transformer.js

@@ -41,8 +41,8 @@ function createVectorTransformer () {
     signature: VECTOR,
     isTypeInstance: object => object instanceof Vector,
     toStructure: vector => {
-      const typeMarker = typeToTypeMarker[vector.type]
-      const buffer = fixBufferEndianness(typeMarker, vector.typedArray.buffer)
+      const typeMarker = typeToTypeMarker[vector.getType()]
+      const buffer = fixBufferEndianness(typeMarker, vector.asTypedArray().buffer)
       const struct = new structure.Structure(VECTOR, [Int8Array.from([typeMarker]), new Int8Array(buffer)])
       return struct
     },

packages/core/src/vector.ts

@@ -37,40 +37,48 @@ Object.freeze(vectorTypes)
  * A wrapper class for JavaScript TypedArrays that makes the driver send them as a Vector type to the database.
  * @access public
  * @exports Vector
- * @class A Integer class for representing a 64 bit two's-complement integer value.
+ * @class A Vector class that wraps a JavaScript TypedArray to enable writing/reading the Neo4j Vector type.
  * @param {Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | BigInt64Array} typedArray The TypedArray to convert to a vector
  *
  * @constructor
  *
  */
 export default class Vector<K extends Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | BigInt64Array> {
-  typedArray: K
-  type: VectorType
+  _typedArray: K
+  _type: VectorType
   constructor (typedArray: K) {
     if (typedArray instanceof Int8Array) {
-      this.type = vectorTypes.INT8
+      this._type = vectorTypes.INT8
     } else if (typedArray instanceof Int16Array) {
-      this.type = vectorTypes.INT16
+      this._type = vectorTypes.INT16
     } else if (typedArray instanceof Int32Array) {
-      this.type = vectorTypes.INT32
+      this._type = vectorTypes.INT32
     } else if (typedArray instanceof BigInt64Array) {
-      this.type = vectorTypes.INT64
+      this._type = vectorTypes.INT64
     } else if (typedArray instanceof Float32Array) {
-      this.type = vectorTypes.FLOAT32
+      this._type = vectorTypes.FLOAT32
     } else if (typedArray instanceof Float64Array) {
-      this.type = vectorTypes.FLOAT64
+      this._type = vectorTypes.FLOAT64
     } else {
       throw newError(`The neo4j Vector class is a wrapper for TypedArrays. got ${typeof typedArray}`)
     }
-    this.typedArray = typedArray
+    this._typedArray = typedArray
   }
 
   /**
    * Converts the Vector back to a typedArray
    * @returns {Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | BigInt64Array} - a TypedArray of the Vectors type.
    */
-  toTypedArray (): K {
-    return this.typedArray
+  asTypedArray (): K {
+    return this._typedArray
+  }
+
+  /**
+   * Gets the type of the Vector
+   * @returns {VectorType} - The type of the vector, corresponding to the type of the wrapped TypedArray.
+   */
+  getType (): VectorType {
+    return this._type
   }
 }
 

packages/neo4j-driver-deno/lib/bolt-connection/bolt/bolt-protocol-v6x0.transformer.js

@@ -390,3 +390,29 @@ var driver = neo4j.driver(
   { disableLosslessIntegers: true }
 )
 ```
+
+#### Writing and reading Vectors
+
+Neo4j supports storing vector embeddings in a dedicated vector type. Sending large lists with the driver will result in significant overhead as each value will be transmitted with type information, so the 6.0.0 release of the driver introduced the Neo4j Vector type.
+
+The Vector type supports signed integers of 8, 16, 32 and 64 bits, and floats of 32 and 64 bits. The Vector type is a wrapper for JavaScript TypedArrays of those types.
+
+To create a neo4j Vector in your code, do the following:
+
+```javascript
+var neo4j = require('neo4j-driver')
+
+var typedArray = Float32Array.from([1, 2, 3]) //this is how to convert a regular array of numbers into a TypedArray, useful if you handle vectors as regular arrays in your code
+
+var neo4jVector = neo4j.vector(typedArray) //this creates a neo4j Vector of type Float32, containing the values [1, 2, 3]
+
+driver.executeQuery('CREATE (n {embeddings: $myVectorParam})', { myVectorParam: neo4jVector })
+```
+
+To access the data in a retrieved Vector you can do the following:
+
+```javascript
+var retrievedTypedArray = neo4jVector.toTypedArray() //This will return a TypedArray of the same type as the Vector
+
+var retrievedArray = Array.from(retrievedTypedArray) //This will convert the TypedArray to a regular array of Numbers. (Not safe for Int64 arrays)
+```

packages/neo4j-driver-deno/lib/core/vector.ts

@@ -176,9 +176,9 @@ export default function CypherNativeBinders (neo4j) {
       })
     }
 
-    if (x.typedArray != null) {
+    if (x.asTypedArray != null) {
       const dtype = typeToDType[x.type]
-      const buffer = fixBufferEndianness(dtype, x.typedArray.buffer)
+      const buffer = fixBufferEndianness(dtype, x.asTypedArray.buffer)
       const data = toHexString(new Uint8Array(buffer))
       return structResponse('CypherVector', { dtype, data })
     }