@firebase/firestore 3.5.0 → 3.6.0

package/dist/lite/index.node.mjs

@@ -2,11 +2,11 @@ import { _getProvider, getApp, _removeServiceInstance, _registerComponent, regis
 import { Component } from '@firebase/component';
 import { Logger, LogLevel } from '@firebase/logger';
 import { inspect } from 'util';
-import { FirebaseError, createMockUserToken, getModularInstance } from '@firebase/util';
+import { FirebaseError, getDefaultEmulatorHost, createMockUserToken, getModularInstance, deepEqual } from '@firebase/util';
 import nodeFetch from 'node-fetch';
 import { randomBytes as randomBytes$1 } from 'crypto';
 
-const version$1 = "3.5.0";
+const version$1 = "3.6.0";
 
 /**
  * @license
@@ -59,7 +59,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";
 
 /**
  * @license
@@ -1203,6 +1203,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.
@@ -1226,6 +1227,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);
@@ -4561,6 +4567,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;
@@ -4963,6 +4984,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));
 }
 
 /**
@@ -5173,7 +5207,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 */
@@ -5269,9 +5303,17 @@ function getFirestore(appOrDatabaseId, optionalDatabaseId) {
     const databaseId = typeof appOrDatabaseId === 'string'
         ? appOrDatabaseId
         : optionalDatabaseId || '(default)';
-    return _getProvider(app, 'firestore/lite').getImmediate({
+    const db = _getProvider(app, 'firestore/lite').getImmediate({
         identifier: databaseId
     });
+    if (!db._initialized) {
+        const firestoreEmulatorHost = getDefaultEmulatorHost('firestore');
+        if (firestoreEmulatorHost) {
+            const [host, port] = firestoreEmulatorHost.split(':');
+            connectFirestoreEmulator(db, host, parseInt(port, 10));
+        }
+    }
+    return db;
 }
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
@@ -5324,7 +5366,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
@@ -5372,6 +5414,100 @@ function registerFirestore() {
     registerVersion('firestore-lite', version$1, 'esm2017');
 }
 
+/**
+ * @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
@@ -5603,64 +5739,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
@@ -5742,6 +5820,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
@@ -7450,6 +7586,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) && deepEqual(left.data(), right.data()));
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -8442,5 +8630,5 @@ function runTransaction(firestore, updateFunction, options) {
  */
 registerFirestore();
 
-export { Bytes, CollectionReference, DocumentReference, DocumentSnapshot, FieldPath, FieldValue, Firestore, FirestoreError, GeoPoint, Query, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot, Timestamp, Transaction, WriteBatch, addDoc, arrayRemove, arrayUnion, collection, collectionGroup, connectFirestoreEmulator, deleteDoc, deleteField, doc, documentId, endAt, endBefore, getDoc, getDocs, getFirestore, increment, initializeFirestore, limit, limitToLast, orderBy, query, queryEqual, refEqual, runTransaction, serverTimestamp, setDoc, setLogLevel, snapshotEqual, startAfter, startAt, terminate, updateDoc, where, writeBatch };
+export { AggregateField, AggregateQuerySnapshot, Bytes, CollectionReference, DocumentReference, DocumentSnapshot, FieldPath, FieldValue, Firestore, FirestoreError, GeoPoint, Query, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot, Timestamp, Transaction, WriteBatch, addDoc, aggregateQuerySnapshotEqual, arrayRemove, arrayUnion, collection, collectionGroup, connectFirestoreEmulator, deleteDoc, deleteField, doc, documentId, endAt, endBefore, getCount, getDoc, getDocs, getFirestore, increment, initializeFirestore, limit, limitToLast, orderBy, query, queryEqual, refEqual, runTransaction, serverTimestamp, setDoc, setLogLevel, snapshotEqual, startAfter, startAt, terminate, updateDoc, where, writeBatch };
 //# sourceMappingURL=index.node.mjs.map