resolve comments

Author: milaGGL

packages/firebase/compat/index.d.ts

@@ -8227,7 +8227,10 @@ declare namespace firebase.storage {
 }
 
 declare namespace firebase.firestore {
+
+  /** Alias dynamic document field value types to any */
   export type DocumentFieldValue = any;
+  
   /**
    * Document data (for use with `DocumentReference.set()`) consists of fields
    * mapped to values.

packages/firestore/src/api/aggregate.ts

@@ -14,14 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Query, SnapshotOptions } from '../api';
+import { Query } from '../api';
 import { firestoreClientRunCountQuery } from '../core/firestore_client';
-import {
-  AggregateField,
-  AggregateQuerySnapshot as AggregateQuerySnapshotLite,
-  AggregateSpec,
-  AggregateSpecData
-} from '../lite-api/aggregate';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate';
 import { cast } from '../util/input_validation';
 
 import { ensureFirestoreConfigured, Firestore } from './database';
@@ -31,29 +26,15 @@ export {
   AggregateSpec,
   AggregateSpecData,
   AggregateQuerySnapshot,
-  aggregateSnapshotEqual,
-  aggregateFieldEqual
+  aggregateSnapshotEqual
 } from '../lite-api/aggregate';
 
 /**
- * A `AggregateQuerySnapshot` contains the result of running an aggregation query.
- * The result data can be extracted with `.data()`.
- */
-class AggregateQuerySnapshot<
-  T extends AggregateSpec
-> extends AggregateQuerySnapshotLite<T> {
-  constructor(query: Query<unknown>, _data: AggregateSpecData<T>) {
-    super(query, _data);
-  }
-  data(options: SnapshotOptions = {}): AggregateSpecData<T> {
-    return super.data();
-  }
-}
-
-/**
- * Executes the query and returns the results as a `QuerySnapshot` from the
+ * Executes the query and returns the results as a `AggregateQuerySnapshot` from the
  * server. Returns an error if the network is not available.
  *
+ * @param query - The `Query` to execute.
+ * 
  * @returns A `Promise` that will be resolved with the results of the query.
  */
 export function getCountFromServer(

packages/firestore/src/core/firestore_client.ts

@@ -17,18 +17,17 @@
 
 import { GetOptions } from '@firebase/firestore-types';
 
-import {
-  AggregateField,
-  AggregateSpec,
-  AggregateQuerySnapshot
-} from '../api/aggregate';
+import { AggregateField } from '../api/aggregate';
 import { LoadBundleTask } from '../api/bundle';
 import {
   CredentialChangeListener,
   CredentialsProvider
 } from '../api/credentials';
 import { User } from '../auth/user';
-import { getCountFromServer } from '../lite-api/aggregate';
+import {
+  getCount as getCountFromServer,
+  AggregateQuerySnapshot as LiteAggregateQuerySnapshot
+} from '../lite-api/aggregate';
 import { Query as LiteQuery } from '../lite-api/reference';
 import { LocalStore } from '../local/local_store';
 import {
@@ -512,9 +511,9 @@ export function firestoreClientTransaction<T>(
 export function firestoreClientRunCountQuery(
   client: FirestoreClient,
   query: LiteQuery<unknown>
-): Promise<AggregateQuerySnapshot<{ count: AggregateField<number> }>> {
+): Promise<LiteAggregateQuerySnapshot<{ count: AggregateField<number> }>> {
   const deferred = new Deferred<
-    AggregateQuerySnapshot<{ count: AggregateField<number> }>
+    LiteAggregateQuerySnapshot<{ count: AggregateField<number> }>
   >();
   client.asyncQueue.enqueueAndForget(async () => {
     const remoteStore = await getRemoteStore(client);

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

@@ -24,28 +24,30 @@ import { cast } from '../util/input_validation';
 
 import { getDatastore } from './components';
 import { Firestore } from './database';
-import { DocumentFieldValue, Query, queryEqual } from './reference';
+import { Query, queryEqual } from './reference';
 import { LiteUserDataWriter } from './reference_impl';
 
 /**
- * An `AggregateField` computes some aggregation statistics from the result set of
- * an aggregation query.
+ * An `AggregateField`that captures input type T.
  */
 export class AggregateField<T> {
   type = 'AggregateField';
-  _datum?: T;
+}
 
-  constructor(readonly subType: string) {}
+/**
+ * Creates and returns an aggregation field that counts the documents in the result set.
+ * 
+ * @returns An `AggregateField` object with number input type.
+ */
+export function count(): AggregateField<number> {
+  return new AggregateField<number>();
 }
 
 /**
  * The union of all `AggregateField` types that are returned from the factory
  * functions.
  */
-export type AggregateFieldType =
-  | AggregateField<number>
-  | AggregateField<DocumentFieldValue | undefined>
-  | AggregateField<number | undefined>;
+type AggregateFieldType = ReturnType<typeof count>;
 
 /**
  * A type whose values are all `AggregateField` objects.
@@ -60,46 +62,28 @@ export type AggregateSpec = { [field: string]: AggregateFieldType };
  * `AggregateField` from the input `AggregateSpec`.
  */
 export type AggregateSpecData<T extends AggregateSpec> = {
-  [Property in keyof T]-?: T[Property]['_datum'];
+  [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
 };
 
-/**
- * Creates and returns an aggregation field that counts the documents in the result set.
- * @returns An `AggregateField` object that includes number of documents.
- */
-export function count(): AggregateField<number> {
-  return new AggregateField<number>('count');
-}
-
-/**
- * Compares two `AggregateField` instances for equality.
- * The two `AggregateField` instances are considered "equal" if and only if
- * they were created by the same factory function (e.g. `count()`, `min()`, and
- * `sum()`) with "equal" arguments.
- */
-export function aggregateFieldEqual(
-  left: AggregateField<unknown>,
-  right: AggregateField<unknown>
-): boolean {
-  return typeof left === typeof right && left.subType === right.subType;
-}
-
 /**
  * An `AggregateQuerySnapshot` contains the results of running an aggregate query.
  */
 export class AggregateQuerySnapshot<T extends AggregateSpec> {
   readonly type = 'AggregateQuerySnapshot';
 
+  /** @hideconstructor */
   constructor(
     readonly query: Query<unknown>,
-    protected readonly _data: AggregateSpecData<T>
+    private readonly _data: AggregateSpecData<T>
   ) {}
 
   /**
    * The results of the requested aggregations. The keys of the returned object
    * will be the same as those of the `AggregateSpec` object specified to the
    * aggregation method, and the values will be the corresponding aggregation
    * result.
+   *
+   * @returns The aggregation statistics result of running a query.
    */
   data(): AggregateSpecData<T> {
     return this._data;
@@ -112,10 +96,11 @@ export class AggregateQuerySnapshot<T extends AggregateSpec> {
  * whatever the server returns. If the server cannot be reached then the
  * returned promise will be rejected.
  *
- * This is a convenience shorthand for:
- * getAggregateFromServer(query, { count: count() }).
+ * @param query - The `Query` to execute.
+ *
+ * @returns An `AggregateQuerySnapshot` that contains the number of documents.
  */
-export function getCountFromServer(
+export function getCount(
   query: Query<unknown>
 ): Promise<AggregateQuerySnapshot<{ count: AggregateField<number> }>> {
   const firestore = cast(query.firestore, Firestore);
@@ -150,6 +135,11 @@ export function getCountFromServer(
  * Compares two `AggregateQuerySnapshot` instances for equality.
  * Two `AggregateQuerySnapshot` instances are considered "equal" if they have
  * the same underlying query, the same metadata, and the same data.
+ *
+ * @param left - The `AggregateQuerySnapshot` to compare.
+ * @param right - The `AggregateQuerySnapshot` to compare.
+ *
+ * @returns true if the AggregateQuerySnapshos are equal.
  */
 export function aggregateSnapshotEqual<T extends AggregateSpec>(
   left: AggregateQuerySnapshot<T>,

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

@@ -40,6 +40,7 @@ import { FieldValue } from './field_value';
 import { FirestoreDataConverter } from './snapshot';
 import { NestedUpdateFields, Primitive } from './types';
 
+/** Alias dynamic document field value types to any */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type DocumentFieldValue = any;