feat(firestore): Merge BsonBinaryData into Blob/Bytes behavior

Author: wu-hui

handwritten/firestore/dev/src/field-value.ts

@@ -441,6 +441,11 @@ export class BsonBinaryData implements firestore.BsonBinaryData {
    * @internal
    */
   _toProto(serializer: Serializer): api.IValue {
+    if (this.subtype === 0) {
+      return {
+        bytesValue: this.data,
+      };
+    }
     return serializer.encodeBsonBinaryData(this.subtype, this.data);
   }
 
@@ -468,11 +473,17 @@ export class BsonBinaryData implements firestore.BsonBinaryData {
    * @param other The `BsonBinaryData` to compare against.
    * @return 'true' if this `BsonBinaryData` is equal to the provided one.
    */
-  isEqual(other: BsonBinaryData): boolean {
-    return (
-      this.subtype === other.subtype &&
-      Buffer.from(this.data).equals(other.data)
-    );
+  isEqual(other: any): boolean {
+    if (other instanceof BsonBinaryData) {
+      return (
+        this.subtype === other.subtype &&
+        Buffer.from(this.data).equals(other.data)
+      );
+    }
+    if (other instanceof Uint8Array) {
+      return this.subtype === 0 && Buffer.from(this.data).equals(other);
+    }
+    return false;
   }
 }
 

handwritten/firestore/dev/src/order.ts

@@ -50,15 +50,14 @@ enum TypeOrder {
   BSON_TIMESTAMP = 5,
   STRING = 6,
   BLOB = 7,
-  BSON_BINARY = 8,
-  REF = 9,
-  BSON_OBJECT_ID = 10,
-  GEO_POINT = 11,
-  REGEX = 12,
-  ARRAY = 13,
-  VECTOR = 14,
-  OBJECT = 15,
-  MAX_KEY = 16,
+  REF = 8,
+  BSON_OBJECT_ID = 9,
+  GEO_POINT = 10,
+  REGEX = 11,
+  ARRAY = 12,
+  VECTOR = 13,
+  OBJECT = 14,
+  MAX_KEY = 15,
 }
 
 /*!
@@ -95,9 +94,8 @@ function typeOrder(val: api.IValue): TypeOrder {
     case 'bsonObjectIdValue':
       return TypeOrder.BSON_OBJECT_ID;
     case 'bytesValue':
-      return TypeOrder.BLOB;
     case 'bsonBinaryValue':
-      return TypeOrder.BSON_BINARY;
+      return TypeOrder.BLOB;
     case 'referenceValue':
       return TypeOrder.REF;
     case 'mapValue':
@@ -274,26 +272,45 @@ function compareBsonTimestamps(left: api.IValue, right: api.IValue): number {
  * @private
  * @internal
  */
-function compareBsonBinaryData(left: api.IValue, right: api.IValue): number {
-  const leftBytes =
-    left.mapValue!.fields?.[RESERVED_BSON_BINARY_KEY]?.bytesValue;
-  const rightBytes =
-    right.mapValue!.fields?.[RESERVED_BSON_BINARY_KEY]?.bytesValue;
-  if (!rightBytes || !leftBytes) {
-    throw new Error('Received incorrect bytesValue for BsonBinaryData');
+function getSubtype(value: api.IValue): number {
+  if (value.bytesValue !== undefined) {
+    return 0;
   }
-  return Buffer.compare(Buffer.from(leftBytes), Buffer.from(rightBytes));
+  const bsonBinaryFields = value.mapValue?.fields?.[RESERVED_BSON_BINARY_KEY];
+  if (bsonBinaryFields && bsonBinaryFields.bytesValue) {
+    return bsonBinaryFields.bytesValue[0];
+  }
+  throw new Error('Cannot get subtype for non-blob value: ' + JSON.stringify(value));
+}
+
+function getData(value: api.IValue): Uint8Array {
+  if (value.bytesValue !== undefined) {
+    return value.bytesValue || new Uint8Array();
+  }
+  const bsonBinaryFields = value.mapValue?.fields?.[RESERVED_BSON_BINARY_KEY];
+  if (bsonBinaryFields && bsonBinaryFields.bytesValue) {
+    return bsonBinaryFields.bytesValue.slice(1);
+  }
+  throw new Error('Cannot get data for non-blob value: ' + JSON.stringify(value));
 }
 
 /*!
  * @private
  * @internal
  */
-function compareBlobs(left: Uint8Array, right: Uint8Array): number {
-  if (!(left instanceof Buffer) || !(right instanceof Buffer)) {
+function compareBlobs(left: api.IValue, right: api.IValue): number {
+  if (left.bytesValue !== undefined && !(left.bytesValue instanceof Buffer)) {
     throw new Error('Blobs can only be compared if they are Buffers.');
   }
-  return Buffer.compare(left, right);
+  if (right.bytesValue !== undefined && !(right.bytesValue instanceof Buffer)) {
+    throw new Error('Blobs can only be compared if they are Buffers.');
+  }
+  const leftSubtype = getSubtype(left);
+  const rightSubtype = getSubtype(right);
+  if (leftSubtype !== rightSubtype) {
+    return primitiveComparator(leftSubtype, rightSubtype);
+  }
+  return Buffer.compare(Buffer.from(getData(left)), Buffer.from(getData(right)));
 }
 
 /*!
@@ -526,9 +543,7 @@ export function compare(left: api.IValue, right: api.IValue): number {
     case TypeOrder.BSON_TIMESTAMP:
       return compareBsonTimestamps(left, right);
     case TypeOrder.BLOB:
-      return compareBlobs(left.bytesValue!, right.bytesValue!);
-    case TypeOrder.BSON_BINARY:
-      return compareBsonBinaryData(left, right);
+      return compareBlobs(left, right);
     case TypeOrder.REF:
       return compareReferenceProtos(left, right);
     case TypeOrder.GEO_POINT:

handwritten/firestore/dev/system-test/firestore.ts

@@ -8712,7 +8712,7 @@ describe('Types test', () => {
   });
 });
 
-describe('non-native Firestore types', () => {
+describe.skipClassic('non-native Firestore types', () => {
   addEqualityMatcher();
   let firestore: Firestore;
   let randomCol: CollectionReference;

handwritten/firestore/dev/system-test/pipeline.ts

@@ -173,6 +173,7 @@ import {
   CollectionReference,
   FieldPath,
   Firestore,
+  BsonBinaryData,
 } from '../src';
 
 import {expect, use} from 'chai';
@@ -944,6 +945,29 @@ describe.skipClassic('Pipeline class', () => {
       });
     });
 
+    describe.skipClassic('extended BSON types', () => {
+      it('accepts and returns BsonBinaryData in pipelines', async () => {
+        const bsonSubtype0 = new BsonBinaryData(0, new Uint8Array([7, 8, 9]));
+        const bsonSubtype1 = new BsonBinaryData(128, new Uint8Array([7, 8, 9]));
+
+        const ppl = firestore
+          .pipeline()
+          .collection(randomCol.path)
+          .limit(1)
+          .select(
+            constant(bsonSubtype0).as('bsonSubtype0'),
+            constant(bsonSubtype1).as('bsonSubtype1'),
+          );
+
+        const snapshot = await ppl.execute();
+
+        expectResults(snapshot, {
+          bsonSubtype0: new Uint8Array([7, 8, 9]),
+          bsonSubtype1: bsonSubtype1,
+        });
+      });
+    });
+
     it('throws on undefined in a map', async () => {
       try {
         await firestore

handwritten/firestore/dev/test/field-value.ts

@@ -522,6 +522,28 @@ describe('non-native types', () => {
       .true;
   });
 
+  it('BSON binary data with subtype 0 acts as native bytes', () => {
+    const bson = new BsonBinaryData(0, Uint8Array.from([1, 2, 3]));
+    const native = Uint8Array.from([1, 2, 3]);
+    const otherNative = Uint8Array.from([1, 2, 4]);
+
+    expect(bson.isEqual(native)).to.be.true;
+    expect(bson.isEqual(otherNative)).to.be.false;
+
+    // Serializing BsonBinaryData with subtype 0 returns bytesValue
+    const proto = (bson as any)._toProto(null as any);
+    expect(proto).to.deep.equal({
+      bytesValue: Uint8Array.from([1, 2, 3]),
+    });
+  });
+
+  it('BSON binary data with subtype > 0 does not act as native bytes', () => {
+    const bson = new BsonBinaryData(1, Uint8Array.from([1, 2, 3]));
+    const native = Uint8Array.from([1, 2, 3]);
+
+    expect(bson.isEqual(native)).to.be.false;
+  });
+
   it('can create BSON timestamp using new', () => {
     const value1 = new BsonTimestamp(57, 4);
     const value2 = new BsonTimestamp(57, 4);

handwritten/firestore/dev/test/order.ts

@@ -263,7 +263,10 @@ describe('Order', () => {
       // blobs
       [blob([])],
       [blob([0])],
-      [blob([0, 1, 2, 3, 4])],
+      [
+        blob([0, 1, 2, 3, 4]),
+        wrap(new BsonBinaryData(0, Buffer.from([0, 1, 2, 3, 4]))),
+      ],
       [blob([0, 1, 2, 4, 3])],
       [blob([255])],
 

handwritten/firestore/types/firestore.d.ts

@@ -2842,10 +2842,10 @@ declare namespace FirebaseFirestore {
     /**
      * Returns true if this `BsonBinaryData` is equal to the provided one.
      *
-     * @param other The `BsonBinaryData` to compare against.
+     * @param other The `BsonBinaryData` or `Uint8Array` to compare against.
      * @return 'true' if this `BsonBinaryData` is equal to the provided one.
      */
-    isEqual(other: BsonBinaryData): boolean;
+    isEqual(other: BsonBinaryData | Uint8Array): boolean;
   }
   /**
    * Sentinel values that can be used when writing document fields with set(),