[Draft] Implement vector field type

dev/src/field-value.ts

@@ -30,6 +30,49 @@ import {
 
 import api = proto.google.firestore.v1;
 
+export class VectorValue implements firestore.VectorValue {
+  private readonly values: number[];
+  constructor(values: number[] | undefined) {
+    this.values = values || [];
+  }
+
+  public toArray(): number[] {
+    return this.values;
+  }
+
+  /**
+   * @private
+   */
+  toProto(serializer: Serializer): api.IValue {
+    return serializer.encodeVector({
+      arrayValue: {
+        values: this.values.map(value => {
+          return {
+            doubleValue: value,
+          };
+        }),
+      },
+    });
+  }
+
+  /**
+   * @private
+   */
+  static fromProto(valueArray: api.IValue): VectorValue {
+    const values = valueArray.arrayValue?.values?.map(v => {
+      return v.doubleValue!;
+    });
+    return new VectorValue(values);
+  }
+
+  /**
+   * @private
+   */
+  isEqual(other: VectorValue): boolean {
+    return this.values === other.values;
+  }
+}
+
 /**
  * Sentinel values that can be used when writing documents with set(), create()
  * or update().
@@ -40,6 +83,10 @@ export class FieldValue implements firestore.FieldValue {
   /** @private */
   constructor() {}
 
+  static vector(values?: number[]): VectorValue {
+    return new VectorValue(values);
+  }
+
   /**
    * Returns a sentinel for use with update() or set() with {merge:true} to mark
    * a field for deletion.

dev/src/index.ts

@@ -625,6 +625,11 @@
           'Initialized Firestore GAPIC Client (useFallback: %s)',
           useFallback
         );
+        logger(
+          'client',
+          'init',
+          `${JSON.stringify((client as any)._opts.servicePath)}`
+        );
         return client;
       },
       /* clientDestructor= */ client => client.close()

dev/src/serializer.ts

@@ -19,7 +19,7 @@ import {DocumentData} from '@google-cloud/firestore';
 import * as proto from '../protos/firestore_v1_proto_api';
 
 import {detectValueType} from './convert';
-import {DeleteTransform, FieldTransform} from './field-value';
+import {DeleteTransform, FieldTransform, VectorValue} from './field-value';
 import {GeoPoint} from './geo-point';
 import {DocumentReference, Firestore} from './index';
 import {FieldPath, QualifiedResourcePath} from './path';
@@ -38,6 +38,10 @@ import api = proto.google.firestore.v1;
  */
 const MAX_DEPTH = 20;
 
+const RESERVED_MAP_KEY = '__type__';
+const RESERVED_MAP_KEY_VECTOR_VALUE = '__vector__';
+const RESERVED_VECTOR_MAP_VECTORS_KEY = 'value';
+
 /**
  * An interface for Firestore types that can be serialized to Protobuf.
  *
@@ -168,6 +172,10 @@ export class Serializer {
       };
     }
 
+    if (val instanceof VectorValue) {
+      return val.toProto(this);
+    }
+
     if (isObject(val)) {
       const toProto = val['toProto'];
       if (typeof toProto === 'function') {
@@ -217,6 +225,22 @@ export class Serializer {
     throw new Error(`Cannot encode value: ${val}`);
   }
 
+  /**
+   * @private
+   */
+  encodeVector(vectorValue: api.IValue): api.IValue {
+    return {
+      mapValue: {
+        fields: {
+          [RESERVED_MAP_KEY]: {
+            stringValue: RESERVED_MAP_KEY_VECTOR_VALUE,
+          },
+          [RESERVED_VECTOR_MAP_VECTORS_KEY]: vectorValue,
+        },
+      },
+    };
+  }
+
   /**
    * Decodes a single Firestore 'Value' Protobuf.
    *
@@ -263,15 +287,27 @@ export class Serializer {
         return null;
       }
       case 'mapValue': {
-        const obj: DocumentData = {};
         const fields = proto.mapValue!.fields;
         if (fields) {
-          for (const prop of Object.keys(fields)) {
-            obj[prop] = this.decodeValue(fields[prop]);
+          const props = Object.keys(fields);
+          if (
+            props.indexOf(RESERVED_MAP_KEY) !== -1 &&
+            this.decodeValue(fields[RESERVED_MAP_KEY]) ===
+              RESERVED_MAP_KEY_VECTOR_VALUE
+          ) {
+            return VectorValue.fromProto(
+              fields[RESERVED_VECTOR_MAP_VECTORS_KEY]
+            );
+          } else {
+            const obj: DocumentData = {};
+            for (const prop of Object.keys(fields)) {
+              obj[prop] = this.decodeValue(fields[prop]);
+            }
+            return obj;
           }
+        } else {
+          return {};
         }
-
-        return obj;
       }
       case 'geoPointValue': {
         return GeoPoint.fromProto(proto.geoPointValue!);
@@ -367,6 +403,8 @@ export function validateUserInput(
           'If you want to ignore undefined values, enable `ignoreUndefinedProperties`.'
       );
     }
+  } else if (value instanceof VectorValue) {
+    // OK
   } else if (value instanceof DeleteTransform) {
     if (inArray) {
       throw new Error(

dev/system-test/firestore.ts

@@ -62,6 +62,8 @@
 
 const version = require('../../package.json').version;
 
+setLogFunction(console.log);
+
 class DeferredPromise<T> {
   resolve: Function;
   reject: Function;
@@ -104,6 +106,8 @@
     internalSettings.databaseId = process.env.FIRESTORE_NAMED_DATABASE;
   }
 
+  settings.host = 'test-firestore.sandbox.googleapis.com';
+
   const firestore = new Firestore({
     ...internalSettings,
     ...settings, // caller settings take precedent over internal settings
@@ -1018,6 +1022,30 @@
     return promise;
   });
 
+  it.only('can write and read vector embeddings', async () => {
+    const ref = randomCol.doc();
+    await ref.create({
+      vectorEmpty: FieldValue.vector(),
+      vector1: FieldValue.vector([1, 2, 3.99]),
+    });
+    await ref.set({
+      vectorEmpty: FieldValue.vector(),
+      vector1: FieldValue.vector([1, 2, 3.99]),
+      vector2: FieldValue.vector([0, 0, 0]),
+    });
+    await ref.update({
+      vector3: FieldValue.vector([-1, -200, -999]),
+    });
+
+    const snap1 = await ref.get();
+    expect(snap1.get('vectorEmpty')).to.deep.equal(FieldValue.vector());
+    expect(snap1.get('vector1')).to.deep.equal(FieldValue.vector([1, 2, 3.99]));
+    expect(snap1.get('vector2')).to.deep.equal(FieldValue.vector([0, 0, 0]));
+    expect(snap1.get('vector3')).to.deep.equal(
+      FieldValue.vector([-1, -200, -999])
+    );
+  });
+
   describe('watch', () => {
     const currentDeferred = new DeferredPromise<DocumentSnapshot>();
 
@@ -1311,6 +1339,91 @@
     const result2 = await ref2.get();
     expect(result2.data()).to.deep.equal([1, 2, 3]);
   });
+
+  it.only('can listen to documents with vectors', async () => {
+    const ref = randomCol.doc();
+    const initialDeferred = new Deferred<void>();
+    const createDeferred = new Deferred<void>();
+    const setDeferred = new Deferred<void>();
+    const updateDeferred = new Deferred<void>();
+    const deleteDeferred = new Deferred<void>();
+
+    const expected = [
+      initialDeferred,
+      createDeferred,
+      setDeferred,
+      updateDeferred,
+      deleteDeferred,
+    ];
+    let idx = 0;
+    let document: DocumentSnapshot | null = null;
+
+    const unlisten = randomCol
+      .where('purpose', '==', 'vector tests')
+      .onSnapshot(snap => {
+        expected[idx].resolve();
+        idx += 1;
+        if (snap.docs.length > 0) {
+          document = snap.docs[0];
+        } else {
+          document = null;
+        }
+      });
+
+    await initialDeferred.promise;
+    expect(document).to.be.null;
+
+    await ref.create({
+      purpose: 'vector tests',
+      vectorEmpty: FieldValue.vector(),
+      vector1: FieldValue.vector([1, 2, 3.99]),
+    });
+
+    await createDeferred.promise;
+    expect(document).to.be.not.null;
+    expect(document!.get('vectorEmpty')).to.deep.equal(FieldValue.vector());
+    expect(document!.get('vector1')).to.deep.equal(
+      FieldValue.vector([1, 2, 3.99])
+    );
+
+    await ref.set({
+      purpose: 'vector tests',
+      vectorEmpty: FieldValue.vector(),
+      vector1: FieldValue.vector([1, 2, 3.99]),
+      vector2: FieldValue.vector([0, 0, 0]),
+    });
+    await setDeferred.promise;
+    expect(document).to.be.not.null;
+    expect(document!.get('vectorEmpty')).to.deep.equal(FieldValue.vector());
+    expect(document!.get('vector1')).to.deep.equal(
+      FieldValue.vector([1, 2, 3.99])
+    );
+    expect(document!.get('vector2')).to.deep.equal(
+      FieldValue.vector([0, 0, 0])
+    );
+
+    await ref.update({
+      vector3: FieldValue.vector([-1, -200, -999]),
+    });
+    await updateDeferred.promise;
+    expect(document).to.be.not.null;
+    expect(document!.get('vectorEmpty')).to.deep.equal(FieldValue.vector());
+    expect(document!.get('vector1')).to.deep.equal(
+      FieldValue.vector([1, 2, 3.99])
+    );
+    expect(document!.get('vector2')).to.deep.equal(
+      FieldValue.vector([0, 0, 0])
+    );
+    expect(document!.get('vector3')).to.deep.equal(
+      FieldValue.vector([-1, -200, -999])
+    );
+
+    await ref.delete();
+    await deleteDeferred.promise;
+    expect(document).to.be.null;
+
+    unlisten();
+  });
 });
 
 describe('Query class', () => {