Stubing out the alternative API for sum-avg that only allowed one aggregate at a time without aliasing.

Author: MarkDuckworth

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

@@ -21,14 +21,16 @@ import { CountQueryRunner } from '../core/count_query_runner';
 import { cast } from '../util/input_validation';
 
 import {
-  AggregateField,
+  AggregateField, AggregateFieldSpec,
   AggregateQuerySnapshot,
-  AggregateSpec
+  AggregateSpec, AggregateType, AggregateFieldType, AggregateData
 } from './aggregate_types';
 import { getDatastore } from './components';
 import { Firestore } from './database';
 import { Query, queryEqual } from './reference';
 import { LiteUserDataWriter } from './reference_impl';
+import {FieldPath} from "./field_path";
+import {AggregateQueryRunner} from "../core/aggregate_query_runner";
 
 /**
  * Calculates the number of documents in the result set of the given query,
@@ -53,6 +55,77 @@ export function getCount(
   return new CountQueryRunner(query, datastore, userDataWriter).run();
 }
 
+export function getAggregateFromServer<T extends AggregateSpec>(
+  query: Query<unknown>,
+  aggregates: T
+): Promise<AggregateQuerySnapshot<T>>;
+
+export function getAggregateFromServer<T extends AggregateFieldType>(
+  query: Query<unknown>,
+  aggregateField: T
+): Promise<AggregateQuerySnapshot<T>>;
+
+export function getAggregateFromServer<T extends AggregateSpec | AggregateFieldType>(
+  query: Query<unknown>,
+  aggregateFieldOrSpec: T
+): Promise<AggregateQuerySnapshot<T>> {
+  let aggregateSpec: AggregateSpec | undefined;
+
+  if (aggregateFieldOrSpec instanceof AggregateField) {
+    aggregateSpec = {[aggregateFieldOrSpec.aggregateType]: aggregateFieldOrSpec};
+  }
+  else {
+    aggregateSpec = aggregateFieldOrSpec;
+  }
+
+  return new Promise(resolve => {
+    const data: any = {};
+    for (const key in aggregateSpec) {
+      const field = aggregateSpec[key];
+      switch (field.aggregateType) {
+        case "count":
+          data[key] = 1;
+          break;
+        case "sum":
+          data[key] = 1;
+          break;
+        case "average":
+          data[key] = 1;
+          break;
+      }
+    }
+    resolve(new AggregateQuerySnapshot(query, data))
+  })
+}
+
+export function sum(field: string | FieldPath): AggregateField<number, 'sum'> {
+  return new AggregateField('sum', field);
+}
+
+export function average(field: string | FieldPath): AggregateField<number | null, 'average'> {
+  return new AggregateField('average', field);
+}
+
+export function count(): AggregateField<number, 'count'> {
+  return new AggregateField('count');
+}
+
+/**
+ * Compares two 'AggregateField` instances for equality.
+ *
+ * @param left
+ * @param right
+ */
+export function aggregateFieldEqual(
+  left: AggregateField<unknown, AggregateType>,
+  right: AggregateField<unknown, AggregateType>
+): boolean {
+  return left instanceof AggregateField &&
+    right instanceof AggregateField &&
+    left.field == right.field &&
+    left.aggregateType == right.aggregateType;
+}
+
 /**
  * Compares two `AggregateQuerySnapshot` instances for equality.
  *

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

@@ -16,20 +16,29 @@
  */
 
 import { Query } from './reference';
+import {FieldPath} from "./field_path";
+import {average, count, sum} from './aggregate';
+
+export type AggregateType = 'average' | 'count' | 'sum';
 
 /**
  * Represents an aggregation that can be performed by Firestore.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export class AggregateField<T> {
+export class AggregateField<R, A extends AggregateType = 'count'> {
   /** A type string to uniquely identify instances of this class. */
-  type = 'AggregateField';
+  readonly type = 'AggregateField';
+
+  constructor(public readonly aggregateType: A, public readonly field?: string | FieldPath) {
+  }
 }
 
 /**
  * The union of all `AggregateField` types that are supported by Firestore.
  */
-export type AggregateFieldType = AggregateField<number>;
+export type AggregateFieldType =
+  ReturnType<typeof count>
+  | ReturnType<typeof sum>
+  | ReturnType<typeof average>
 
 /**
  * A type whose property values are all `AggregateField` objects.
@@ -43,14 +52,21 @@ export interface AggregateSpec {
  * result of the aggregation performed by the corresponding `AggregateField`
  * from the input `AggregateSpec`.
  */
-export type AggregateSpecData<T extends AggregateSpec> = {
-  [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+export type AggregateSpecData<T extends AggregateSpec > = {
+  [P in keyof T]: T[P] extends AggregateField<infer U, any> ? U : never;
 };
 
+export type AggregateFieldSpec<T extends AggregateFieldType> =
+  T extends AggregateField<infer R, infer A> ? Record<A, T> : never;
+
+export type AggregateData<T extends AggregateSpec | AggregateFieldType> =
+  T extends AggregateSpec ? AggregateSpecData<T> :
+    T extends AggregateFieldType ? AggregateFieldSpec<T> : never;
+
 /**
  * The results of executing an aggregation query.
  */
-export class AggregateQuerySnapshot<T extends AggregateSpec> {
+export class AggregateQuerySnapshot<T extends AggregateSpec | AggregateFieldType> {
   /** A type string to uniquely identify instances of this class. */
   readonly type = 'AggregateQuerySnapshot';
 
@@ -63,7 +79,7 @@ export class AggregateQuerySnapshot<T extends AggregateSpec> {
   /** @hideconstructor */
   constructor(
     query: Query<unknown>,
-    private readonly _data: AggregateSpecData<T>
+    private readonly _data: AggregateData<T>
   ) {
     this.query = query;
   }
@@ -79,7 +95,7 @@ export class AggregateQuerySnapshot<T extends AggregateSpec> {
    * @returns The results of the aggregations performed over the underlying
    * query.
    */
-  data(): AggregateSpecData<T> {
+  data(): AggregateData<T> {
     return this._data;
   }
 }