Fix CUD ops inserting vectors without names in >=1.24

Author: tsmith023

.github/workflows/main.yaml

@@ -7,8 +7,8 @@ on:
   pull_request:
 
 env:
-  WEAVIATE_124: 1.24.15
-  WEAVIATE_125: 1.25.2
+  WEAVIATE_124: 1.24.19
+  WEAVIATE_125: 1.25.4
 
 jobs:
   checks:

src/collections/data/index.ts

@@ -180,7 +180,7 @@ const data = <T>(
   const objectsPath = new ObjectsPath(dbVersionSupport);
   const referencesPath = new ReferencesPath(dbVersionSupport);
 
-  const parseObject = (object?: InsertObject<any>): WeaviateObject<T> => {
+  const parseObject = async (object?: InsertObject<any>): Promise<WeaviateObject<T>> => {
     if (!object) {
       return {} as WeaviateObject<T>;
     }
@@ -191,7 +191,12 @@ const data = <T>(
         : undefined,
     };
     if (Array.isArray(object.vectors)) {
-      obj.vector = object.vectors;
+      const supportsNamedVectors = await dbVersionSupport.supportsNamedVectors();
+      if (supportsNamedVectors.supports) {
+        obj.vectors = { default: object.vectors };
+      } else {
+        obj.vector = object.vectors;
+      }
     } else if (object.vectors) {
       obj.vectors = object.vectors;
     }
@@ -225,21 +230,24 @@ const data = <T>(
         tenant
       ).do(),
     insert: (obj?: InsertObject<T> | NonReferenceInputs<T>): Promise<string> =>
-      objectsPath
-        .buildCreate(consistencyLevel)
-        .then((path) =>
-          connection.postReturn<WeaviateObject<T>, Required<WeaviateObject<T>>>(path, {
+      Promise.all([
+        objectsPath.buildCreate(consistencyLevel),
+        parseObject(
+          obj ? (DataGuards.isDataObject(obj) ? obj : ({ properties: obj } as InsertObject<T>)) : obj
+        ),
+      ]).then(([path, object]) =>
+        connection
+          .postReturn<WeaviateObject<T>, Required<WeaviateObject<T>>>(path, {
             class: name,
             tenant: tenant,
-            ...parseObject(
-              obj ? (DataGuards.isDataObject(obj) ? obj : ({ properties: obj } as InsertObject<T>)) : obj
-            ),
+            ...object,
           })
-        )
-        .then((obj) => obj.id),
+          .then((obj) => obj.id)
+      ),
     insertMany: (objects: (DataObject<T> | NonReferenceInputs<T>)[]): Promise<BatchObjectsReturn<T>> =>
       connection.batch(name, consistencyLevel).then(async (batch) => {
-        const serialized = await Serialize.batchObjects(name, objects, tenant);
+        const supportsNamedVectors = await dbVersionSupport.supportsNamedVectors();
+        const serialized = await Serialize.batchObjects(name, objects, supportsNamedVectors.supports, tenant);
         const start = Date.now();
         const reply = await batch.withObjects({ objects: serialized.mapped });
         const end = Date.now();
@@ -301,20 +309,22 @@ const data = <T>(
         .build(args.fromUuid, name, args.fromProperty, consistencyLevel, tenant)
         .then((path) => connection.put(path, referenceToBeacons(args.to), false)),
     replace: (obj: ReplaceObject<T>): Promise<void> =>
-      objectsPath.buildUpdate(obj.id, name, consistencyLevel).then((path) =>
-        connection.put(path, {
-          class: name,
-          tenant: tenant,
-          ...parseObject(obj),
-        })
+      Promise.all([objectsPath.buildUpdate(obj.id, name, consistencyLevel), parseObject(obj)]).then(
+        ([path, object]) =>
+          connection.put(path, {
+            class: name,
+            tenant: tenant,
+            ...object,
+          })
       ),
     update: (obj: UpdateObject<T>): Promise<void> =>
-      objectsPath.buildUpdate(obj.id, name, consistencyLevel).then((path) =>
-        connection.patch(path, {
-          class: name,
-          tenant: tenant,
-          ...parseObject(obj),
-        })
+      Promise.all([objectsPath.buildUpdate(obj.id, name, consistencyLevel), parseObject(obj)]).then(
+        ([path, object]) =>
+          connection.patch(path, {
+            class: name,
+            tenant: tenant,
+            ...object,
+          })
       ),
   };
 };

src/collections/data/integration.test.ts

@@ -914,3 +914,89 @@ describe('Testing of the collection.data methods with bring your own multi vecto
     expect(obj2?.vectors?.two).toEqual([10, 11, 12]);
   });
 });
+
+describe('Testing of the collection.data methods with a vector index', () => {
+  let client: WeaviateClient;
+  let collection: Collection;
+  let uuid: string;
+  beforeAll(async () => {
+    client = await weaviate.connectToLocal();
+    collection = await client.collections.create({
+      name: 'TestCollectionDataVectorizer',
+      properties: [
+        {
+          name: 'text',
+          dataType: 'text',
+        },
+      ],
+      vectorizers: weaviate.configure.vectorizer.none(),
+    });
+  });
+
+  afterAll(() => client.collections.delete('TestCollectionDataVectorizer'));
+
+  it('should be able to insert an object with a vector without specifying the name', async () => {
+    uuid = await collection.data.insert({
+      properties: {
+        text: 'test',
+      },
+      vectors: [1, 2, 3, 4],
+    });
+    const obj = await collection.query.fetchObjectById(uuid, {
+      includeVector: true,
+    });
+    expect(obj?.vectors.default).toEqual([1, 2, 3, 4]);
+  });
+
+  it('should be able to update the vector of an object without specifying the name', async () => {
+    await collection.data.update({
+      id: uuid,
+      vectors: [5, 6, 7, 8],
+    });
+    const obj = await collection.query.fetchObjectById(uuid, {
+      includeVector: true,
+    });
+    expect(obj?.vectors.default).toEqual([5, 6, 7, 8]);
+  });
+
+  it('should be able to replace the vector of an object without specifying the name', async () => {
+    await collection.data.replace({
+      id: uuid,
+      vectors: [9, 10, 11, 12],
+    });
+    const obj = await collection.query.fetchObjectById(uuid, {
+      includeVector: true,
+    });
+    expect(obj?.vectors.default).toEqual([9, 10, 11, 12]);
+  });
+
+  it('should be able to insert many objects with a vector without specifying the name', async () => {
+    const objects = [
+      {
+        properties: {
+          text: 'test',
+        },
+        vectors: [1, 2, 3, 4],
+      },
+      {
+        properties: {
+          text: 'test',
+        },
+        vectors: [5, 6, 7, 8],
+      },
+    ];
+    const insert = await collection.data.insertMany(objects);
+    expect(insert.hasErrors).toBeFalsy();
+    expect(insert.allResponses.length).toEqual(2);
+    expect(Object.values(insert.errors).length).toEqual(0);
+    expect(Object.values(insert.uuids).length).toEqual(2);
+    const obj1 = await collection.query.fetchObjectById(insert.uuids[0], {
+      includeVector: true,
+    });
+    expect(obj1?.vectors.default).toEqual([1, 2, 3, 4]);
+    const obj2 = await collection.query.fetchObjectById(insert.uuids[1], {
+      includeVector: true,
+    });
+    expect(obj2?.vectors.default).toEqual([5, 6, 7, 8]);
+  });
+});

src/collections/serialize/index.ts

@@ -1058,6 +1058,7 @@ export class Serialize {
   public static batchObjects = <T>(
     collection: string,
     objects: (DataObject<T> | NonReferenceInputs<T>)[],
+    usesNamedVectors: boolean,
     tenant?: string
   ): Promise<BatchObjects<T>> => {
     const objs: BatchObjectGRPC[] = [];
@@ -1079,22 +1080,34 @@ export class Serialize {
         ? object
         : { id: undefined, properties: object, references: undefined, vectors: undefined };
 
+      let vectorBytes: Uint8Array | undefined;
+      let vectors: VectorsGrpc[] | undefined;
+      if (obj.vectors !== undefined && !Array.isArray(obj.vectors)) {
+        vectors = Object.entries(obj.vectors).map(([k, v]) =>
+          VectorsGrpc.fromPartial({
+            vectorBytes: Serialize.vectorToBytes(v),
+            name: k,
+          })
+        );
+      } else if (Array.isArray(obj.vectors) && usesNamedVectors) {
+        vectors = [
+          VectorsGrpc.fromPartial({
+            vectorBytes: Serialize.vectorToBytes(obj.vectors),
+            name: 'default',
+          }),
+        ];
+      } else if (obj.vectors !== undefined) {
+        vectorBytes = Serialize.vectorToBytes(obj.vectors);
+      }
+
       objs.push(
         BatchObjectGRPC.fromPartial({
           collection: collection,
           properties: Serialize.batchProperties(obj.properties, obj.references),
           tenant: tenant,
           uuid: obj.id ? obj.id : uuidv4(),
-          vectorBytes: Array.isArray(obj.vectors) ? Serialize.vectorToBytes(obj.vectors) : undefined,
-          vectors:
-            obj.vectors !== undefined && !Array.isArray(obj.vectors)
-              ? Object.entries(obj.vectors).map(([k, v]) =>
-                  VectorsGrpc.fromPartial({
-                    vectorBytes: Serialize.vectorToBytes(v),
-                    name: k,
-                  })
-                )
-              : undefined,
+          vectorBytes,
+          vectors,
         })
       );