@firebase/firestore 3.5.0 → 3.6.0-canary.03d1fabcb

package/dist/lite/index.d.ts

@@ -35,6 +35,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
@@ -466,7 +529,7 @@ export declare abstract class FieldValue {
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 export declare class Firestore {
     /**
@@ -659,6 +722,23 @@ 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).
+ *
+ * @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>;
+}>>;
 /**
  * Reads the document referred to by the specified document reference.
  *
@@ -729,8 +809,8 @@ export declare function increment(n: number): FieldValue;
 /**
  * Initializes a new instance of Cloud Firestore with the provided settings.
  * Can only be called before any other functions, including
- * {@link getFirestore}. If the custom settings are empty, this function is
- * equivalent to calling {@link getFirestore}.
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
  *
  * @param app - The {@link @firebase/app#FirebaseApp} with which the `Firestore` instance will
  * be associated.
@@ -1089,7 +1169,7 @@ export declare function startAt(...fieldValues: unknown[]): QueryConstraint;
  * response from the server will not be resolved.
  *
  * To restart after termination, create a new instance of `Firestore` with
- * {@link getFirestore}.
+ * {@link (getFirestore:1)}.
  *
  * Note: Under normal circumstances, calling `terminate()` is not required. This
  * function is useful only when you want to force this instance to release all of

package/dist/lite/index.node.cjs.js

@@ -14,7 +14,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-const version$1 = "3.5.0";
+const version$1 = "3.6.0-canary.03d1fabcb";
 
 /**
  * @license
@@ -67,7 +67,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.10.0";
+const version = "9.11.0-canary.03d1fabcb";
 
 /**
  * @license
@@ -1211,6 +1211,7 @@ const RPC_NAME_URL_MAPPING = {};
 RPC_NAME_URL_MAPPING['BatchGetDocuments'] = 'batchGet';
 RPC_NAME_URL_MAPPING['Commit'] = 'commit';
 RPC_NAME_URL_MAPPING['RunQuery'] = 'runQuery';
+RPC_NAME_URL_MAPPING['RunAggregationQuery'] = 'runAggregationQuery';
 const RPC_URL_VERSION = 'v1';
 // SDK_VERSION is updated to different value at runtime depending on the entry point,
 // so we need to get its value when we need it in a function.
@@ -1234,6 +1235,11 @@ class RestConnection {
                 this.databaseId.database +
                 '/documents';
     }
+    get shouldResourcePathBeIncludedInRequest() {
+        // Both `invokeRPC()` and `invokeStreamingRPC()` use their `path` arguments to determine
+        // where to run the query, and expect the `request` to NOT specify the "path".
+        return false;
+    }
     invokeRPC(rpcName, path, req, authToken, appCheckToken) {
         const url = this.makeUrl(rpcName, path);
         logDebug(LOG_TAG$3, 'Sending: ', url, req);
@@ -4569,6 +4575,21 @@ function toQueryTarget(serializer, target) {
     }
     return result;
 }
+function toRunAggregationQueryRequest(serializer, target) {
+    const queryTarget = toQueryTarget(serializer, target);
+    return {
+        structuredAggregationQuery: {
+            aggregations: [
+                {
+                    count: {},
+                    alias: 'count_alias'
+                }
+            ],
+            structuredQuery: queryTarget.structuredQuery
+        },
+        parent: queryTarget.parent
+    };
+}
 function toFilter(filters) {
     if (filters.length === 0) {
         return;
@@ -4971,6 +4992,19 @@ async function invokeRunQueryRpc(datastore, query) {
         // Omit RunQueryResponses that only contain readTimes.
         .filter(proto => !!proto.document)
         .map(proto => fromDocument(datastoreImpl.serializer, proto.document, undefined)));
+}
+async function invokeRunAggregationQueryRpc(datastore, query) {
+    const datastoreImpl = debugCast(datastore);
+    const request = toRunAggregationQueryRequest(datastoreImpl.serializer, queryToTarget(query));
+    const parent = request.parent;
+    if (!datastoreImpl.connection.shouldResourcePathBeIncludedInRequest) {
+        delete request.parent;
+    }
+    const response = await datastoreImpl.invokeStreamingRPC('RunAggregationQuery', parent, request, /*expectedResponseCount=*/ 1);
+    return (response
+        // Omit RunAggregationQueryResponse that only contain readTimes.
+        .filter(proto => !!proto.result)
+        .map(proto => proto.result.aggregateFields));
 }
 
 /**
@@ -5181,7 +5215,7 @@ class FirestoreSettingsImpl {
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 class Firestore {
     /** @hideconstructor */
@@ -5277,9 +5311,16 @@ function getFirestore(appOrDatabaseId, optionalDatabaseId) {
     const databaseId = typeof appOrDatabaseId === 'string'
         ? appOrDatabaseId
         : optionalDatabaseId || '(default)';
-    return app._getProvider(app$1, 'firestore/lite').getImmediate({
+    const db = app._getProvider(app$1, 'firestore/lite').getImmediate({
         identifier: databaseId
     });
+    if (!db._initialized) {
+        const emulator = util.getDefaultEmulatorHostnameAndPort('firestore');
+        if (emulator) {
+            connectFirestoreEmulator(db, ...emulator);
+        }
+    }
+    return db;
 }
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
@@ -5332,7 +5373,7 @@ function connectFirestoreEmulator(firestore, host, port, options = {}) {
  * response from the server will not be resolved.
  *
  * To restart after termination, create a new instance of `Firestore` with
- * {@link getFirestore}.
+ * {@link (getFirestore:1)}.
  *
  * Note: Under normal circumstances, calling `terminate()` is not required. This
  * function is useful only when you want to force this instance to release all of
@@ -5380,6 +5421,100 @@ function registerFirestore() {
     app.registerVersion('firestore-lite', version$1, 'cjs5');
 }
 
+/**
+ * @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.
+ */
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class AggregateField {
+    constructor() {
+        /** A type string to uniquely identify instances of this class. */
+        this.type = 'AggregateField';
+    }
+}
+/**
+ * The results of executing an aggregation query.
+ */
+class AggregateQuerySnapshot {
+    /** @hideconstructor */
+    constructor(query, _data) {
+        this._data = _data;
+        /** A type string to uniquely identify instances of this class. */
+        this.type = 'AggregateQuerySnapshot';
+        this.query = query;
+    }
+    /**
+     * 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() {
+        return this._data;
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * CountQueryRunner encapsulates the logic needed to run the count aggregation
+ * queries.
+ */
+class CountQueryRunner {
+    constructor(query, datastore, userDataWriter) {
+        this.query = query;
+        this.datastore = datastore;
+        this.userDataWriter = userDataWriter;
+    }
+    run() {
+        return invokeRunAggregationQueryRpc(this.datastore, this.query._query).then(result => {
+            hardAssert(result[0] !== undefined);
+            const counts = Object.entries(result[0])
+                .filter(([key, value]) => key === 'count_alias')
+                .map(([key, value]) => this.userDataWriter.convertValue(value));
+            const countValue = counts[0];
+            hardAssert(typeof countValue === 'number');
+            return Promise.resolve(new AggregateQuerySnapshot(this.query, {
+                count: countValue
+            }));
+        });
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -5611,64 +5746,6 @@ function queryEqual(left, right) {
     return false;
 }
 
-/**
- * @license
- * Copyright 2020 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.
- */
-/**
- * A `FieldPath` refers to a field in a document. The path may consist of a
- * single field name (referring to a top-level field in the document), or a
- * list of field names (referring to a nested field in the document).
- *
- * Create a `FieldPath` by providing field names. If more than one field
- * name is provided, the path will point to a nested field in a document.
- */
-class FieldPath {
-    /**
-     * Creates a `FieldPath` from the provided field names. If more than one field
-     * name is provided, the path will point to a nested field in a document.
-     *
-     * @param fieldNames - A list of field names.
-     */
-    constructor(...fieldNames) {
-        for (let i = 0; i < fieldNames.length; ++i) {
-            if (fieldNames[i].length === 0) {
-                throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid field name at argument $(i + 1). ` +
-                    'Field names must not be empty.');
-            }
-        }
-        this._internalPath = new FieldPath$1(fieldNames);
-    }
-    /**
-     * Returns true if this `FieldPath` is equal to the provided one.
-     *
-     * @param other - The `FieldPath` to compare against.
-     * @returns true if this `FieldPath` is equal to the provided one.
-     */
-    isEqual(other) {
-        return this._internalPath.isEqual(other._internalPath);
-    }
-}
-/**
- * Returns a special sentinel `FieldPath` to refer to the ID of a document.
- * It can be used in queries to sort or filter by the document ID.
- */
-function documentId() {
-    return new FieldPath(DOCUMENT_KEY_NAME);
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -5750,6 +5827,64 @@ class Bytes {
     }
 }
 
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+/**
+ * A `FieldPath` refers to a field in a document. The path may consist of a
+ * single field name (referring to a top-level field in the document), or a
+ * list of field names (referring to a nested field in the document).
+ *
+ * Create a `FieldPath` by providing field names. If more than one field
+ * name is provided, the path will point to a nested field in a document.
+ */
+class FieldPath {
+    /**
+     * Creates a `FieldPath` from the provided field names. If more than one field
+     * name is provided, the path will point to a nested field in a document.
+     *
+     * @param fieldNames - A list of field names.
+     */
+    constructor(...fieldNames) {
+        for (let i = 0; i < fieldNames.length; ++i) {
+            if (fieldNames[i].length === 0) {
+                throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid field name at argument $(i + 1). ` +
+                    'Field names must not be empty.');
+            }
+        }
+        this._internalPath = new FieldPath$1(fieldNames);
+    }
+    /**
+     * Returns true if this `FieldPath` is equal to the provided one.
+     *
+     * @param other - The `FieldPath` to compare against.
+     * @returns true if this `FieldPath` is equal to the provided one.
+     */
+    isEqual(other) {
+        return this._internalPath.isEqual(other._internalPath);
+    }
+}
+/**
+ * Returns a special sentinel `FieldPath` to refer to the ID of a document.
+ * It can be used in queries to sort or filter by the document ID.
+ */
+function documentId() {
+    return new FieldPath(DOCUMENT_KEY_NAME);
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -7458,6 +7593,58 @@ function addDoc(reference, data) {
     ]).then(() => docRef);
 }
 
+/**
+ * @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.
+ */
+/**
+ * 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).
+ *
+ * @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.
+ */
+function getCount(query) {
+    const firestore = cast(query.firestore, Firestore);
+    const datastore = getDatastore(firestore);
+    const userDataWriter = new LiteUserDataWriter(firestore);
+    return new CountQueryRunner(query, datastore, userDataWriter).run();
+}
+/**
+ * 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.
+ */
+function aggregateQuerySnapshotEqual(left, right) {
+    return (queryEqual(left.query, right.query) && util.deepEqual(left.data(), right.data()));
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -8450,6 +8637,8 @@ function runTransaction(firestore, updateFunction, options) {
  */
 registerFirestore();
 
+exports.AggregateField = AggregateField;
+exports.AggregateQuerySnapshot = AggregateQuerySnapshot;
 exports.Bytes = Bytes;
 exports.CollectionReference = CollectionReference;
 exports.DocumentReference = DocumentReference;
@@ -8467,6 +8656,7 @@ exports.Timestamp = Timestamp;
 exports.Transaction = Transaction;
 exports.WriteBatch = WriteBatch;
 exports.addDoc = addDoc;
+exports.aggregateQuerySnapshotEqual = aggregateQuerySnapshotEqual;
 exports.arrayRemove = arrayRemove;
 exports.arrayUnion = arrayUnion;
 exports.collection = collection;
@@ -8478,6 +8668,7 @@ exports.doc = doc;
 exports.documentId = documentId;
 exports.endAt = endAt;
 exports.endBefore = endBefore;
+exports.getCount = getCount;
 exports.getDoc = getDoc;
 exports.getDocs = getDocs;
 exports.getFirestore = getFirestore;