@firebase/firestore 3.5.0-canary.5b696dece → 3.5.0-canary.e35db6f95

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

@@ -0,0 +1,29 @@
+/**
+ * @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 '../api';
+import { AggregateField, AggregateQuerySnapshot } 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.
+ *
+ * @param query - The `Query` to execute.
+ *
+ * @returns A `Promise` that will be resolved with the results of the query.
+ */
+export declare function getCountFromServer(query: Query<unknown>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}>>;

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

@@ -18,6 +18,8 @@ import { GetOptions } from '@firebase/firestore-types';
 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';
 import { DocumentKey } from '../model/document_key';
@@ -115,5 +117,8 @@ 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<{
+    count: AggregateField<number>;
+}>>;
 export declare function firestoreClientLoadBundle(client: FirestoreClient, databaseId: DatabaseId, data: ReadableStream<Uint8Array> | ArrayBuffer | string, resultTask: LoadBundleTask): void;
 export declare function firestoreClientGetNamedQuery(client: FirestoreClient, queryName: string): Promise<NamedQuery | undefined>;

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

@@ -0,0 +1,92 @@
+/**
+ * @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.
+ */
+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.
+ *
+ * @param query - The `Query` to execute.
+ *
+ * @returns An `AggregateQuerySnapshot` that contains the number of documents.
+ */
+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.
+ *
+ * @param left - The `AggregateQuerySnapshot` to compare.
+ * @param right - The `AggregateQuerySnapshot` to compare.
+ *
+ * @returns true if the AggregateQuerySnapshots are equal.
+ */
+export declare function aggregateQuerySnapshotEqual<T extends AggregateSpec>(left: AggregateQuerySnapshot<T>, right: AggregateQuerySnapshot<T>): boolean;

package/dist/firestore/src/platform/node/grpc_connection.d.ts

@@ -26,6 +26,7 @@ export declare class GrpcConnection implements Connection {
     private readonly databasePath;
     private readonly firestore;
     private cachedStub;
+    get shouldResourcePathBeIncludedInRequest(): boolean;
     constructor(protos: grpc.GrpcObject, databaseInfo: DatabaseInfo);
     private ensureActiveStub;
     invokeRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;

package/dist/firestore/src/protos/firestore_proto_api.d.ts

@@ -295,6 +295,32 @@ export declare namespace firestoreV1ApiClientInterfaces {
         readTime?: string;
         skippedResults?: number;
     }
+    interface RunAggregationQueryRequest {
+        parent?: string;
+        structuredAggregationQuery?: StructuredAggregationQuery;
+        transaction?: string;
+        newTransaction?: TransactionOptions;
+        readTime?: string;
+    }
+    interface RunAggregationQueryResponse {
+        result?: AggregationResult;
+        transaction?: string;
+        readTime?: string;
+    }
+    interface AggregationResult {
+        aggregateFields?: ApiClientObjectMap<Value>;
+    }
+    interface StructuredAggregationQuery {
+        structuredQuery?: StructuredQuery;
+        aggregations?: Aggregation[];
+    }
+    interface Aggregation {
+        count?: Count;
+        alias?: string;
+    }
+    interface Count {
+        upTo?: number;
+    }
     interface Status {
         code?: number;
         message?: string;
@@ -417,6 +443,8 @@ export declare type ReadWrite = firestoreV1ApiClientInterfaces.ReadWrite;
 export declare type RollbackRequest = firestoreV1ApiClientInterfaces.RollbackRequest;
 export declare type RunQueryRequest = firestoreV1ApiClientInterfaces.RunQueryRequest;
 export declare type RunQueryResponse = firestoreV1ApiClientInterfaces.RunQueryResponse;
+export declare type RunAggregationQueryRequest = firestoreV1ApiClientInterfaces.RunAggregationQueryRequest;
+export declare type RunAggregationQueryResponse = firestoreV1ApiClientInterfaces.RunAggregationQueryResponse;
 export declare type Status = firestoreV1ApiClientInterfaces.Status;
 export declare type StructuredQuery = firestoreV1ApiClientInterfaces.StructuredQuery;
 export declare type Target = firestoreV1ApiClientInterfaces.Target;

package/dist/firestore/src/remote/connection.d.ts

@@ -62,6 +62,13 @@ export interface Connection {
      * @param token - the Token to use for the RPC.
      */
     openStream<Req, Resp>(rpcName: string, authToken: Token | null, appCheckToken: Token | null): Stream<Req, Resp>;
+    /**
+     * Returns whether or not the implementation requires that the "path" of the resource
+     * (a document or a collection) be present in the request message. If true, then the
+     * request message must include the path. If false, then the request message must NOT
+     * include the path.
+     */
+    readonly shouldResourcePathBeIncludedInRequest: boolean;
 }
 /**
  * A bidirectional stream that can be used to send an receive messages.

package/dist/firestore/src/remote/datastore.d.ts

@@ -20,6 +20,7 @@ import { Query } from '../core/query';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { Mutation } from '../model/mutation';
+import { Value as ProtoValue } from '../protos/firestore_proto_api';
 import { AsyncQueue } from '../util/async_queue';
 import { Connection } from './connection';
 import { PersistentListenStream, PersistentWriteStream, WatchStreamListener, WriteStreamListener } from './persistent_stream';
@@ -36,5 +37,6 @@ export declare function newDatastore(authCredentials: CredentialsProvider<User>,
 export declare function invokeCommitRpc(datastore: Datastore, mutations: Mutation[]): Promise<void>;
 export declare function invokeBatchGetDocumentsRpc(datastore: Datastore, keys: DocumentKey[]): Promise<Document[]>;
 export declare function invokeRunQueryRpc(datastore: Datastore, query: Query): Promise<Document[]>;
+export declare function invokeRunAggregationQueryRpc(datastore: Datastore, query: Query): Promise<ProtoValue[]>;
 export declare function newPersistentWriteStream(datastore: Datastore, queue: AsyncQueue, listener: WriteStreamListener): PersistentWriteStream;
 export declare function newPersistentWatchStream(datastore: Datastore, queue: AsyncQueue, listener: WatchStreamListener): PersistentListenStream;

package/dist/firestore/src/remote/rest_connection.d.ts

@@ -27,6 +27,7 @@ export declare abstract class RestConnection implements Connection {
     protected readonly databaseId: DatabaseId;
     protected readonly baseUrl: string;
     private readonly databaseRoot;
+    get shouldResourcePathBeIncludedInRequest(): boolean;
     constructor(databaseInfo: DatabaseInfo);
     invokeRPC<Req, Resp>(rpcName: string, path: string, req: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;
     invokeStreamingRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null, expectedResponseCount?: number): Promise<Resp[]>;

package/dist/firestore/src/remote/serializer.d.ts

@@ -26,7 +26,7 @@ import { FieldMask } from '../model/field_mask';
 import { Mutation, MutationResult } from '../model/mutation';
 import { ObjectValue } from '../model/object_value';
 import { FieldPath, ResourcePath } from '../model/path';
-import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
+import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, RunAggregationQueryRequest as ProtoRunAggregationQueryRequest, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
 import { ByteString } from '../util/byte_string';
 import { Serializer } from './number_serializer';
 import { WatchChange } from './watch_change';
@@ -82,6 +82,7 @@ export declare function fromWriteResults(protos: ProtoWriteResult[] | undefined,
 export declare function toDocumentsTarget(serializer: JsonProtoSerializer, target: Target): ProtoDocumentsTarget;
 export declare function fromDocumentsTarget(documentsTarget: ProtoDocumentsTarget): Target;
 export declare function toQueryTarget(serializer: JsonProtoSerializer, target: Target): ProtoQueryTarget;
+export declare function toRunAggregationQueryRequest(serializer: JsonProtoSerializer, target: Target): ProtoRunAggregationQueryRequest;
 export declare function convertQueryTargetToQuery(target: ProtoQueryTarget): Query;
 export declare function fromQueryTarget(target: ProtoQueryTarget): Target;
 export declare function toListenRequestLabels(serializer: JsonProtoSerializer, targetData: TargetData): ProtoApiClientObjectMap<string> | null;

package/dist/firestore/test/integration/api_internal/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/firestore/test/integration/util/helpers.d.ts

@@ -44,6 +44,7 @@ export declare function withTestDocAndInitialData(persistence: boolean, initialD
 export declare function withTestCollection(persistence: boolean, docs: {
     [key: string]: DocumentData;
 }, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;
+export declare function withEmptyTestCollection(persistence: boolean, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;
 export declare function withTestCollectionSettings(persistence: boolean, settings: PrivateSettings, docs: {
     [key: string]: DocumentData;
 }, fn: (collection: CollectionReference, db: Firestore) => Promise<void>): Promise<void>;

package/dist/firestore/test/unit/specs/spec_test_components.d.ts

@@ -96,6 +96,7 @@ export declare class MockConnection implements Connection {
     writeStreamRequestCount: number;
     nextWriteStreamToken: number;
     constructor(queue: AsyncQueue);
+    shouldResourcePathBeIncludedInRequest: boolean;
     /**
      * Tracks the currently active watch targets as detected by the mock watch
      * stream, as a mapping from target ID to query Target.