change AggregateQuery type to unknwon

Author: milaGGL

packages/firestore/src/lite-api/aggregate.ts

@@ -30,25 +30,21 @@ import { LiteUserDataWriter } from './reference_impl';
  * in test mocks. Subclassing is not supported in production code and new SDK releases may break
  * code that does so.
  */
-export class AggregateQuery<T = DocumentData> {
+export class AggregateQuery {
   readonly type = 'AggregateQuery';
   /**
    * The query on which you called {@link countQuery} in order to get this
    * `AggregateQuery`.
    * Query type is set to unknown to avoid error caused by query type converter.
    * might change it back to T after testing if the error do exist or not
    */
-  readonly query: Query<T>;
+  readonly query: Query<unknown>;
 
   /** @hideconstructor */
-  constructor(query: Query<T>) {
+  constructor(query: Query<unknown>) {
     this.query = query;
   }
 
-  /** Returns the base {@link Query} for this aggregate query. */
-  getQuery(): Query<T> {
-    return this.query;
-  }
 }
 
 /**
@@ -61,25 +57,18 @@ export class AggregateQuery<T = DocumentData> {
 export class AggregateQuerySnapshot {
   readonly type = 'AggregateQuerySnapshot';
   readonly query: AggregateQuery;
-  readonly count: number | null;
 
   /** @hideconstructor */
-  constructor(query: AggregateQuery, count: number | null) {
+  constructor(query: AggregateQuery, private readonly _count: number) {
     this.query = query;
-    this.count = count;
-  }
-
-  /** @return The original {@link AggregateQuery} this snapshot is a result of. */
-  getQuery(): AggregateQuery {
-    return this.query;
   }
 
   /**
    * @return The result of a document count aggregation. Returns null if no count aggregation is
    * available in the result.
    */
   getCount(): number | null {
-    return this.count;
+    return this._count;
   }
 }
 
@@ -89,15 +78,15 @@ export class AggregateQuerySnapshot {
  * @return An {@link AggregateQuery} object that can be used to count the number of documents in
  * the result set of this query.
  */
-export function countQuery<T>(query: Query<T>): AggregateQuery<T> {
+export function countQuery(query: Query<unknown>): AggregateQuery {
   /**
    * TODO(mila): add the "count" aggregateField to the params after the AggregateQuery is updated.
    */
   return new AggregateQuery(query);
 }
 
-export function getAggregateFromServerDirect<T>(
-  aggregateQuery: AggregateQuery<T>
+export function getAggregateFromServerDirect(
+  aggregateQuery: AggregateQuery
 ): Promise<AggregateQuerySnapshot> {
   const firestore = cast(aggregateQuery.query.firestore, Firestore);
   const datastore = getDatastore(firestore);

packages/firestore/test/lite/integration.test.ts

@@ -2046,12 +2046,12 @@ describe('withConverter() support', () => {
 
 describe('countQuery()', () => {
   const converter = {
-    toFirestore(value: string): DocumentData {
-      return { key: value };
+    toFirestore(input: { id: string, content: string}): DocumentData {
+      return { key: input.id, value:input.content };
     },
-    fromFirestore(snapshot: QueryDocumentSnapshot): string {
+    fromFirestore(snapshot: QueryDocumentSnapshot): {id: string, content: string} {
       const data = snapshot.data();
-      return data.value;
+      return {content:data.value, id:data.documentId} ;
     }
   };
 
@@ -2139,40 +2139,40 @@ describe('countQuery()', () => {
 
   it.only('test collection count with converter on query', () => {
     const testDocs = [
-      { key: 'a' },
-      { key: 'b' },
-      { key: 'c' },
-      { key: 'a' },
-      { key: 'b' },
-      { key: 'c' }
+      { key: 'a', value:"Adam" },
+      { key: 'b' , value: "Bob"},
+      { key: 'c', value: "Chris" },
+      { key: 'a', value:"Anna" },
+      { key: 'b' , value: "Bill"},
+      { key: 'c', value: "Cooper" }
     ];
     //testing out the converter impact on the AggregateQuery type
     return withTestCollectionAndInitialData(testDocs, async collection => {
-      let query_ = query(collection).withConverter(converter);
+      let query_ = query(collection, where('key', '==', 'a')).withConverter(converter);
 
       const countQuery_ = countQuery(query_);
       const snapshot = await getAggregateFromServerDirect(countQuery_);
-      expect(snapshot.getCount()).to.equal(6);
+      expect(snapshot.getCount()).to.equal(2);
     });
   });
 
   it.only('test collection count with converter on collection', () => {
     const testDocs = [
-      { key: 'a' },
-      { key: 'b' },
-      { key: 'c' },
-      { key: 'a' },
-      { key: 'b' },
-      { key: 'c' }
+      { key: 'a', value:"Adam" },
+      { key: 'b' , value: "Bob"},
+      { key: 'c', value: "Chris" },
+      { key: 'a', value:"Anna" },
+      { key: 'b' , value: "Bill"},
+      { key: 'c', value: "Cooper" }
     ];
     //testing out the converter impact on the AggregateQuery type
     return withTestCollectionAndInitialData(testDocs, async collection => {
       const ref = collection.withConverter(converter);
-      let query_ = query(ref);
+      let query_ = query(ref,where('key', '==', 'a'));
 
       const countQuery_ = countQuery(query_);
       const snapshot = await getAggregateFromServerDirect(countQuery_);
-      expect(snapshot.getCount()).to.equal(6);
+      expect(snapshot.getCount()).to.equal(2);
     });
   });
 });