Stubing out the API for sum and average.

Author: MarkDuckworth

packages/firestore/src/api.ts

@@ -25,7 +25,8 @@ export {
   AggregateFieldType,
   AggregateSpec,
   AggregateSpecData,
-  AggregateQuerySnapshot
+  AggregateQuerySnapshot,
+  AggregateType
 } from './lite-api/aggregate_types';
 
 export { FieldPath, documentId } from './api/field_path';

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

@@ -21,16 +21,15 @@ import { CountQueryRunner } from '../core/count_query_runner';
 import { cast } from '../util/input_validation';
 
 import {
-  AggregateField, AggregateFieldSpec,
+  AggregateField,
   AggregateQuerySnapshot,
-  AggregateSpec, AggregateType, AggregateFieldType, AggregateData
+  AggregateSpec,
 } 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,
@@ -55,33 +54,20 @@ export function getCount(
   return new CountQueryRunner(query, datastore, userDataWriter).run();
 }
 
+/**
+ * TODO
+ * @param query
+ * @param aggregates
+ */
 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];
+    for (const key in aggregates) {
+      const field = aggregates[key];
       switch (field.aggregateType) {
         case "count":
           data[key] = 1;
@@ -98,15 +84,26 @@ export function getAggregateFromServer<T extends AggregateSpec | AggregateFieldT
   })
 }
 
-export function sum(field: string | FieldPath): AggregateField<number, 'sum'> {
+/**
+ * TODO
+ * @param field
+ */
+export function sum(field: string | FieldPath): AggregateField<number> {
   return new AggregateField('sum', field);
 }
 
-export function average(field: string | FieldPath): AggregateField<number | null, 'average'> {
+/**
+ * TODO
+ * @param field
+ */
+export function average(field: string | FieldPath): AggregateField<number | null> {
   return new AggregateField('average', field);
 }
 
-export function count(): AggregateField<number, 'count'> {
+/**
+ * TODO
+ */
+export function count(): AggregateField<number> {
   return new AggregateField('count');
 }
 
@@ -117,8 +114,8 @@ export function count(): AggregateField<number, 'count'> {
  * @param right
  */
 export function aggregateFieldEqual(
-  left: AggregateField<unknown, AggregateType>,
-  right: AggregateField<unknown, AggregateType>
+  left: AggregateField<unknown>,
+  right: AggregateField<unknown>
 ): boolean {
   return left instanceof AggregateField &&
     right instanceof AggregateField &&

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

@@ -19,16 +19,26 @@ import { Query } from './reference';
 import {FieldPath} from "./field_path";
 import {average, count, sum} from './aggregate';
 
+/**
+ * Union type representing the aggregate type to be performed.
+ */
 export type AggregateType = 'average' | 'count' | 'sum';
 
 /**
  * Represents an aggregation that can be performed by Firestore.
  */
-export class AggregateField<R, A extends AggregateType = 'count'> {
+export class AggregateField<R> {
   /** A type string to uniquely identify instances of this class. */
   readonly type = 'AggregateField';
 
-  constructor(public readonly aggregateType: A, public readonly field?: string | FieldPath) {
+  /**
+   * Create a new AggregateField<R>
+   * @param aggregateType
+   * @param field
+   */
+  constructor(
+    public readonly aggregateType: AggregateType = 'count',
+    public readonly field?: string | FieldPath) {
   }
 }
 
@@ -53,20 +63,13 @@ export interface AggregateSpec {
  * from the input `AggregateSpec`.
  */
 export type AggregateSpecData<T extends AggregateSpec > = {
-  [P in keyof T]: T[P] extends AggregateField<infer U, any> ? U : never;
+  [P in keyof T]: T[P] extends AggregateField<infer U> ? 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 | AggregateFieldType> {
+export class AggregateQuerySnapshot<T extends AggregateSpec> {
   /** A type string to uniquely identify instances of this class. */
   readonly type = 'AggregateQuerySnapshot';
 
@@ -79,7 +82,7 @@ export class AggregateQuerySnapshot<T extends AggregateSpec | AggregateFieldType
   /** @hideconstructor */
   constructor(
     query: Query<unknown>,
-    private readonly _data: AggregateData<T>
+    private readonly _data: AggregateSpecData<T>
   ) {
     this.query = query;
   }
@@ -95,7 +98,7 @@ export class AggregateQuerySnapshot<T extends AggregateSpec | AggregateFieldType
    * @returns The results of the aggregations performed over the underlying
    * query.
    */
-  data(): AggregateData<T> {
+  data(): AggregateSpecData<T> {
     return this._data;
   }
 }