fix circular dependency between count_query_runner.ts and lite-api/aggregate.ts

Author: dconeybe

packages/firestore/lite/index.ts

@@ -27,16 +27,18 @@
 import { registerFirestore } from './register';
 registerFirestore();
 
+export {
+  aggregateQuerySnapshotEqual,
+  getCount
+} from '../src/lite-api/aggregate';
 export {
   AggregateField,
   AggregateFieldType,
   AggregateSpec,
   AggregateSpecData,
   AggregateQuerySnapshot,
-  aggregateQuerySnapshotEqual,
-  count,
-  getCount
-} from '../src/lite-api/aggregate';
+  count
+} from '../src/lite-api/aggregate_types';
 
 export { FirestoreSettings as Settings } from '../src/lite-api/settings';
 

packages/firestore/src/api/aggregate.ts

@@ -17,21 +17,23 @@
 
 import { Query } from '../api';
 import { firestoreClientRunCountQuery } from '../core/firestore_client';
-import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
 import { cast } from '../util/input_validation';
 
 import { ensureFirestoreConfigured, Firestore } from './database';
 import { ExpUserDataWriter } from './reference_impl';
 
+export {
+  aggregateQuerySnapshotEqual
+} from '../lite-api/aggregate';
 export {
   AggregateField,
   AggregateFieldType,
   AggregateSpec,
   AggregateSpecData,
   AggregateQuerySnapshot,
-  count,
-  aggregateQuerySnapshotEqual
-} from '../lite-api/aggregate';
+  count
+} from '../lite-api/aggregate_types';
 
 /**
  * Executes the query and returns the results as a `AggregateQuerySnapshot` from the

packages/firestore/src/core/count_query_runner.ts

@@ -16,7 +16,7 @@
  */
 
 import { AbstractUserDataWriter, Query } from '../api';
-import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
 import { Value } from '../protos/firestore_proto_api';
 import { Datastore, invokeRunAggregationQueryRpc } from '../remote/datastore';
 import { hardAssert } from '../util/assert';

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

@@ -19,76 +19,12 @@ import { deepEqual } from '@firebase/util';
 import { CountQueryRunner } from '../core/count_query_runner';
 import { cast } from '../util/input_validation';
 
+import { AggregateField, AggregateQuerySnapshot, AggregateSpec } from './aggregate_types';
 import { getDatastore } from './components';
 import { Firestore } from './database';
 import { Query, queryEqual } from './reference';
 import { LiteUserDataWriter } from './reference_impl';
 
-/**
- * An `AggregateField`that captures input type T.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export class AggregateField<T> {
-  type = 'AggregateField';
-}
-
-/**
- * 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 = ReturnType<typeof count>;
-
-/**
- * A type whose values are all `AggregateField` objects.
- * This is used as an argument to the "getter" functions, and the snapshot will
- * map the same names to the corresponding values.
- */
-export interface AggregateSpec {
-  [field: string]: AggregateFieldType;
-}
-
-/**
- * A type whose keys are taken from an `AggregateSpec` type, and whose values
- * are the 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;
-};
-
-/**
- * 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>,
-    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;
-  }
-}
-
 /**
  * Counts the number of documents in the result set of the given query, ignoring
  * any locally-cached data and any locally-pending writes and simply surfacing

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

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Query } from './reference';
+
+/**
+ * An `AggregateField`that captures input type T.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class AggregateField<T> {
+  type = 'AggregateField';
+}
+
+/**
+ * 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 = ReturnType<typeof count>;
+
+/**
+ * A type whose values are all `AggregateField` objects.
+ * This is used as an argument to the "getter" functions, and the snapshot will
+ * map the same names to the corresponding values.
+ */
+export interface AggregateSpec {
+  [field: string]: AggregateFieldType;
+}
+
+/**
+ * A type whose keys are taken from an `AggregateSpec` type, and whose values
+ * are the 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;
+};
+
+/**
+ * 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>,
+    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;
+  }
+}