@firebase/firestore 3.5.0-canary.e33694638 → 3.5.0-canary.ee871fc0b

package/dist/firestore/lite/index.d.ts

@@ -6,6 +6,8 @@
  * directly to the backend, and `onSnapshot()` APIs are not supported.
  * @packageDocumentation
  */
+export { aggregateQuerySnapshotEqual, getCount } from '../src/lite-api/aggregate';
+export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } from '../src/lite-api/aggregate_types';
 export { FirestoreSettings as Settings } from '../src/lite-api/settings';
 export { Firestore as Firestore, EmulatorMockTokenOptions, initializeFirestore, getFirestore, terminate, connectFirestoreEmulator } from '../src/lite-api/database';
 export { DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, SetOptions, DocumentReference, Query, CollectionReference, collection, collectionGroup, doc, refEqual, queryEqual } from '../src/lite-api/reference';

package/dist/firestore/src/api/aggregate.d.ts

@@ -15,14 +15,28 @@
  * limitations under the License.
  */
 import { Query } from '../api';
-import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
+export { aggregateQuerySnapshotEqual } from '../lite-api/aggregate';
 /**
- * Executes the query and returns the results as a `AggregateQuerySnapshot` from the
- * server. Returns an error if the network is not available.
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
  *
- * @param query - The `Query` to execute.
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
  *
- * @returns A `Promise` that will be resolved with the results of the query.
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used: every request using this source necessarily involves a round trip to
+ * the server.
+ *
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
  */
 export declare function getCountFromServer(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
     count: AggregateField<number>;

package/dist/firestore/src/api.d.ts

@@ -14,6 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export { aggregateQuerySnapshotEqual, getCountFromServer } from './api/aggregate';
+export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, AggregateQuerySnapshot } from './lite-api/aggregate_types';
 export { FieldPath, documentId } from './api/field_path';
 export { Firestore, EmulatorMockTokenOptions, initializeFirestore, getFirestore, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, clearIndexedDbPersistence, waitForPendingWrites, disableNetwork, enableNetwork, terminate, connectFirestoreEmulator, loadBundle, namedQuery, ensureFirestoreConfigured } from './api/database';
 export { LoadBundleTask, LoadBundleTaskProgress, TaskState } from './api/bundle';

package/dist/firestore/src/core/count_query_runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 { AbstractUserDataWriter, Query } from '../api';
+import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate_types';
+import { Datastore } from '../remote/datastore';
+/**
+ * CountQueryRunner encapsulates the logic needed to run the count aggregation
+ * queries.
+ */
+export declare class CountQueryRunner {
+    private readonly query;
+    private readonly datastore;
+    private readonly userDataWriter;
+    constructor(query: Query<unknown>, datastore: Datastore, userDataWriter: AbstractUserDataWriter);
+    run(): Promise<AggregateQuerySnapshot<{
+        count: AggregateField<number>;
+    }>>;
+}

package/dist/firestore/src/core/firestore_client.d.ts

@@ -15,10 +15,10 @@
  * limitations under the License.
  */
 import { GetOptions } from '@firebase/firestore-types';
+import { AbstractUserDataWriter, AggregateField, AggregateQuerySnapshot } from '../api';
 import { LoadBundleTask } from '../api/bundle';
 import { CredentialsProvider } from '../api/credentials';
 import { User } from '../auth/user';
-import { AggregateField, AggregateQuerySnapshot } from '../lite-api/aggregate';
 import { Query as LiteQuery } from '../lite-api/reference';
 import { LocalStore } from '../local/local_store';
 import { Document } from '../model/document';
@@ -117,7 +117,7 @@ export declare function firestoreClientAddSnapshotsInSyncListener(client: Firest
  * performed before any writes. Transactions must be performed while online.
  */
 export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>, options: TransactionOptions): Promise<T>;
-export declare function firestoreClientRunCountQuery(client: FirestoreClient, query: LiteQuery<unknown>): Promise<AggregateQuerySnapshot<{
+export declare function firestoreClientRunCountQuery(client: FirestoreClient, query: LiteQuery<unknown>, userDataWriter: AbstractUserDataWriter): Promise<AggregateQuerySnapshot<{
     count: AggregateField<number>;
 }>>;
 export declare function firestoreClientLoadBundle(client: FirestoreClient, databaseId: DatabaseId, data: ReadableStream<Uint8Array> | ArrayBuffer | string, resultTask: LoadBundleTask): void;

package/dist/firestore/src/lite-api/aggregate.d.ts

@@ -14,79 +14,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { AggregateField, AggregateQuerySnapshot, AggregateSpec } from './aggregate_types';
 import { Query } from './reference';
 /**
- * An `AggregateField`that captures input type T.
- */
-export declare class AggregateField<T> {
-    type: string;
-}
-/**
- * Creates and returns an aggregation field that counts the documents in the result set.
- * @returns An `AggregateField` object with number input type.
- */
-export declare function count(): AggregateField<number>;
-/**
- * The union of all `AggregateField` types that are returned from the factory
- * functions.
- */
-export declare 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 declare 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 declare class AggregateQuerySnapshot<T extends AggregateSpec> {
-    readonly query: Query<unknown>;
-    private readonly _data;
-    readonly type = "AggregateQuerySnapshot";
-    /** @hideconstructor */
-    constructor(query: Query<unknown>, _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>;
-}
-/**
- * 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
- * whatever the server returns. If the server cannot be reached then the
- * returned promise will be rejected.
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
  *
- * @param query - The `Query` to execute.
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
  *
- * @returns An `AggregateQuerySnapshot` that contains the number of documents.
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
  */
 export declare function getCount(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
     count: AggregateField<number>;
 }>>;
 /**
  * Compares two `AggregateQuerySnapshot` instances for equality.
+ *
  * Two `AggregateQuerySnapshot` instances are considered "equal" if they have
- * the same underlying query, and the same data.
+ * underlying queries that compare equal, and the same data.
  *
- * @param left - The `AggregateQuerySnapshot` to compare.
- * @param right - The `AggregateQuerySnapshot` to compare.
+ * @param left - The first `AggregateQuerySnapshot` to compare.
+ * @param right - The second `AggregateQuerySnapshot` to compare.
  *
- * @returns true if the AggregateQuerySnapshots are equal.
+ * @returns `true` if the objects are "equal", as defined above, or `false`
+ * otherwise.
  */
 export declare function aggregateQuerySnapshotEqual<T extends AggregateSpec>(left: AggregateQuerySnapshot<T>, right: AggregateQuerySnapshot<T>): boolean;

package/dist/firestore/src/lite-api/aggregate_types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @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';
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+export declare class AggregateField<T> {
+    /** A type string to uniquely identify instances of this class. */
+    type: string;
+}
+/**
+ * The union of all `AggregateField` types that are supported by Firestore.
+ */
+export declare type AggregateFieldType = AggregateField<number>;
+/**
+ * A type whose property values are all `AggregateField` objects.
+ */
+export interface AggregateSpec {
+    [field: string]: AggregateFieldType;
+}
+/**
+ * A type whose keys are taken from an `AggregateSpec`, and whose values are the
+ * result of the aggregation performed by the corresponding `AggregateField`
+ * from the input `AggregateSpec`.
+ */
+export declare type AggregateSpecData<T extends AggregateSpec> = {
+    [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+};
+/**
+ * The results of executing an aggregation query.
+ */
+export declare class AggregateQuerySnapshot<T extends AggregateSpec> {
+    private readonly _data;
+    /** A type string to uniquely identify instances of this class. */
+    readonly type = "AggregateQuerySnapshot";
+    /**
+     * The underlying query over which the aggregations recorded in this
+     * `AggregateQuerySnapshot` were performed.
+     */
+    readonly query: Query<unknown>;
+    /** @hideconstructor */
+    constructor(query: Query<unknown>, _data: AggregateSpecData<T>);
+    /**
+     * Returns the results of the aggregations performed over the underlying
+     * query.
+     *
+     * 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 results of the aggregations performed over the underlying
+     * query.
+     */
+    data(): AggregateSpecData<T>;
+}

package/dist/firestore/test/integration/api/aggregation.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export {};

package/dist/index.d.ts

@@ -26,6 +26,69 @@ export declare function addDoc<T>(reference: CollectionReference<T>, data: WithF
 export declare type AddPrefixToKeys<Prefix extends string, T extends Record<string, unknown>> = {
     [K in keyof T & string as `${Prefix}.${K}`]+?: T[K];
 };
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+export declare class AggregateField<T> {
+    /** A type string to uniquely identify instances of this class. */
+    type: string;
+}
+/**
+ * The union of all `AggregateField` types that are supported by Firestore.
+ */
+export declare type AggregateFieldType = AggregateField<number>;
+/**
+ * The results of executing an aggregation query.
+ */
+export declare class AggregateQuerySnapshot<T extends AggregateSpec> {
+    /** A type string to uniquely identify instances of this class. */
+    readonly type = "AggregateQuerySnapshot";
+    /**
+     * The underlying query over which the aggregations recorded in this
+     * `AggregateQuerySnapshot` were performed.
+     */
+    readonly query: Query<unknown>;
+    private constructor();
+    /**
+     * Returns the results of the aggregations performed over the underlying
+     * query.
+     *
+     * 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 results of the aggregations performed over the underlying
+     * query.
+     */
+    data(): AggregateSpecData<T>;
+}
+/**
+ * Compares two `AggregateQuerySnapshot` instances for equality.
+ *
+ * Two `AggregateQuerySnapshot` instances are considered "equal" if they have
+ * underlying queries that compare equal, and the same data.
+ *
+ * @param left - The first `AggregateQuerySnapshot` to compare.
+ * @param right - The second `AggregateQuerySnapshot` to compare.
+ *
+ * @returns `true` if the objects are "equal", as defined above, or `false`
+ * otherwise.
+ */
+export declare function aggregateQuerySnapshotEqual<T extends AggregateSpec>(left: AggregateQuerySnapshot<T>, right: AggregateQuerySnapshot<T>): boolean;
+/**
+ * A type whose property values are all `AggregateField` objects.
+ */
+export declare interface AggregateSpec {
+    [field: string]: AggregateFieldType;
+}
+/**
+ * A type whose keys are taken from an `AggregateSpec`, and whose values are the
+ * result of the aggregation performed by the corresponding `AggregateField`
+ * from the input `AggregateSpec`.
+ */
+export declare type AggregateSpecData<T extends AggregateSpec> = {
+    [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+};
 /**
  * Returns a special value that can be used with {@link (setDoc:1)} or {@link
  * updateDoc:1} that tells the server to remove the given elements from any
@@ -845,6 +908,30 @@ export declare class GeoPoint {
         longitude: number;
     };
 }
+/**
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
+ *
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
+ *
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used: every request using this source necessarily involves a round trip to
+ * the server.
+ *
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
+ */
+export declare function getCountFromServer(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;
 /**
  * Reads the document referred to by this `DocumentReference`.
  *