@firebase/firestore 3.7.3-canary.e9fb4037f → 3.7.3-canary.fde5adf63

package/dist/lite/packages/firestore/test/util/helpers.d.ts

@@ -15,11 +15,13 @@
  * limitations under the License.
  */
 import { Bytes, DocumentReference } from '../../src';
+import { Bound } from '../../src/core/bound';
 import { BundledDocuments } from '../../src/core/bundle';
 import { DatabaseId } from '../../src/core/database_info';
+import { FieldFilter, CompositeFilter, Filter } from '../../src/core/filter';
+import { OrderBy } from '../../src/core/order_by';
 import { Query } from '../../src/core/query';
 import { SnapshotVersion } from '../../src/core/snapshot_version';
-import { Bound, FieldFilter, Filter, OrderBy } from '../../src/core/target';
 import { TargetId } from '../../src/core/types';
 import { LimboDocumentChange, View, ViewChange } from '../../src/core/view';
 import { UserDataReader } from '../../src/lite-api/user_data_reader';
@@ -68,6 +70,8 @@ export declare function fieldIndex(collectionGroup: string, options?: {
 export declare function mask(...paths: string[]): FieldMask;
 export declare function blob(...bytes: number[]): Bytes;
 export declare function filter(path: string, op: string, value: unknown): FieldFilter;
+export declare function andFilter(...filters: Filter[]): CompositeFilter;
+export declare function orFilter(...filters: Filter[]): CompositeFilter;
 export declare function setMutation(keyStr: string, json: JsonObject<unknown>): SetMutation;
 export declare function patchMutation(keyStr: string, json: JsonObject<unknown>, precondition?: Precondition): PatchMutation;
 export declare function mergeMutation(keyStr: string, json: JsonObject<unknown>, updateMask: FieldPath[]): PatchMutation;

package/dist/lite/packages/firestore/test/util/test_platform.d.ts

@@ -36,10 +36,10 @@ export declare function testWindow(sharedWebStorage?: SharedFakeWebStorage): Fak
 export declare class FakeDocument implements DocumentLike {
     private _visibilityState;
     private visibilityListener;
-    get visibilityState(): VisibilityState;
+    get visibilityState(): DocumentVisibilityState;
     addEventListener(type: string, listener: EventListener): void;
     removeEventListener(type: string, listener: EventListener): void;
-    raiseVisibilityEvent(visibility: VisibilityState): void;
+    raiseVisibilityEvent(visibility: DocumentVisibilityState): void;
 }
 export declare function testDocument(): FakeDocument;
 /**

package/dist/lite/private.d.ts

@@ -112,10 +112,24 @@ export declare type AggregateSpecData<T extends AggregateSpec> = {
     [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
 };
 
+/* Excluded from this release type: and */
+
 declare interface ApiClientObjectMap<T> {
     [k: string]: T;
 }
 
+/**
+ * An `AppliableConstraint` is an abstraction of a constraint that can be applied
+ * to a Firestore query.
+ */
+declare abstract class AppliableConstraint {
+    /**
+     * Takes the provided {@link Query} and returns a copy of the {@link Query} with this
+     * {@link AppliableConstraint} applied.
+     */
+    abstract _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * 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
@@ -412,7 +426,12 @@ export declare class CollectionReference<T = DocumentData> extends Query<T> {
     withConverter(converter: null): CollectionReference<DocumentData>;
 }
 
-declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND';
+declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND' | 'OR';
+
+declare const enum CompositeOperator {
+    OR = "or",
+    AND = "and"
+}
 
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
@@ -785,48 +804,66 @@ export declare class DocumentSnapshot<T = DocumentData> {
 export { EmulatorMockTokenOptions }
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end at the
- * provided document (inclusive). The end position is relative to the order of
- * the query. The document must contain all of the fields provided in the
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end at
+ * the provided document (inclusive). The end position is relative to the order
+ * of the query. The document must contain all of the fields provided in the
  * orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to end at.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endAt(snapshot: DocumentSnapshot<unknown>): QueryConstraint;
+export declare function endAt(snapshot: DocumentSnapshot<unknown>): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end at the
- * provided fields relative to the order of the query. The order of the field
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end at
+ * the provided fields relative to the order of the query. The order of the field
  * values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to end this query at, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endAt(...fieldValues: unknown[]): QueryConstraint;
+export declare function endAt(...fieldValues: unknown[]): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end before the
- * provided document (exclusive). The end position is relative to the order of
- * the query. The document must contain all of the fields provided in the
- * orderBy of the query.
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end
+ * before the provided document (exclusive). The end position is relative to the
+ * order of the query. The document must contain all of the fields provided in
+ * the orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to end before.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endBefore(snapshot: DocumentSnapshot<unknown>): QueryConstraint;
+export declare function endBefore(snapshot: DocumentSnapshot<unknown>): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end before the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end
+ * before the provided fields relative to the order of the query. The order of
+ * the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to end this query before, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endBefore(...fieldValues: unknown[]): QueryConstraint;
+export declare function endBefore(...fieldValues: unknown[]): QueryEndAtConstraint;
+
+declare class FieldFilter extends Filter {
+    readonly field: FieldPath_2;
+    readonly op: Operator;
+    readonly value: Value;
+    protected constructor(field: FieldPath_2, op: Operator, value: Value);
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(field: FieldPath_2, op: Operator, value: Value): FieldFilter;
+    private static createKeyFieldInFilter;
+    matches(doc: Document_2): boolean;
+    protected matchesComparison(comparison: number): boolean;
+    isInequality(): boolean;
+    getFlattenedFilters(): readonly FieldFilter[];
+    getFilters(): Filter[];
+    getFirstInequalityField(): FieldPath_2 | null;
+}
 
 declare type FieldFilterOp = 'OPERATOR_UNSPECIFIED' | 'LESS_THAN' | 'LESS_THAN_OR_EQUAL' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUAL' | 'EQUAL' | 'NOT_EQUAL' | 'ARRAY_CONTAINS' | 'IN' | 'ARRAY_CONTAINS_ANY' | 'NOT_IN';
 
@@ -915,6 +952,9 @@ export declare abstract class FieldValue {
 
 declare abstract class Filter {
     abstract matches(doc: Document_2): boolean;
+    abstract getFlattenedFilters(): readonly FieldFilter[];
+    abstract getFilters(): Filter[];
+    abstract getFirstInequalityField(): FieldPath_2 | null;
 }
 
 /* Excluded from this release type: _FirebaseService */
@@ -1611,23 +1651,25 @@ export declare function initializeFirestore(app: FirebaseApp, settings: Settings
 /* Excluded declaration from this release type: initializeFirestore */
 
 /**
- * Creates a {@link QueryConstraint} that only returns the first matching documents.
+ * Creates a {@link QueryLimitConstraint} that only returns the first matching
+ * documents.
  *
  * @param limit - The maximum number of items to return.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryLimitConstraint}.
  */
-export declare function limit(limit: number): QueryConstraint;
+export declare function limit(limit: number): QueryLimitConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that only returns the last matching documents.
+ * Creates a {@link QueryLimitConstraint} that only returns the last matching
+ * documents.
  *
  * You must specify at least one `orderBy` clause for `limitToLast` queries,
  * otherwise an exception will be thrown during execution.
  *
  * @param limit - The maximum number of items to return.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryLimitConstraint}.
  */
-export declare function limitToLast(limit: number): QueryConstraint;
+export declare function limitToLast(limit: number): QueryLimitConstraint;
 
 declare const enum LimitType {
     First = "F",
@@ -1830,6 +1872,21 @@ declare class ObjectValue {
     clone(): ObjectValue;
 }
 
+declare const enum Operator {
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    EQUAL = "==",
+    NOT_EQUAL = "!=",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    ARRAY_CONTAINS = "array-contains",
+    IN = "in",
+    NOT_IN = "not-in",
+    ARRAY_CONTAINS_ANY = "array-contains-any"
+}
+
+/* Excluded from this release type: or */
+
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -1840,15 +1897,18 @@ declare class OrderBy {
 }
 
 /**
- * Creates a {@link QueryConstraint} that sorts the query result by the
+ * Creates a {@link QueryOrderByConstraint} that sorts the query result by the
  * specified field, optionally in descending order instead of ascending.
  *
+ * Note: Documents that do not contain the specified field will not be present
+ * in the query result.
+ *
  * @param fieldPath - The field to sort by.
  * @param directionStr - Optional direction to sort by ('asc' or 'desc'). If
  * not specified, order will be ascending.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryOrderByConstraint}.
  */
-export declare function orderBy(fieldPath: string | FieldPath, directionStr?: OrderByDirection): QueryConstraint;
+export declare function orderBy(fieldPath: string | FieldPath, directionStr?: OrderByDirection): QueryOrderByConstraint;
 
 /**
  * The direction of a {@link orderBy} clause is specified as 'desc' or 'asc'
@@ -1973,11 +2033,14 @@ export declare class Query<T = DocumentData> {
     withConverter<U>(converter: FirestoreDataConverter<U>): Query<U>;
 }
 
+/* Excluded declaration from this release type: query */
+
 /**
- * Creates a new immutable instance of {@link Query} that is extended to also include
- * additional query constraints.
+ * Creates a new immutable instance of {@link Query} that is extended to also
+ * include additional query constraints.
  *
- * @param query - The {@link Query} instance to use as a base for the new constraints.
+ * @param query - The {@link Query} instance to use as a base for the new
+ * constraints.
  * @param queryConstraints - The list of {@link QueryConstraint}s to apply.
  * @throws if any of the provided query constraints cannot be combined with the
  * existing or new constraints.
@@ -2001,20 +2064,22 @@ declare interface Query_2 {
     readonly endAt: Bound | null;
 }
 
+/* Excluded from this release type: QueryCompositeFilterConstraint */
+
 /**
  * A `QueryConstraint` is used to narrow the set of documents returned by a
  * Firestore query. `QueryConstraint`s are created by invoking {@link where},
- * {@link orderBy}, {@link (startAt:1)}, {@link (startAfter:1)}, {@link
- * endBefore:1}, {@link (endAt:1)}, {@link limit} or {@link limitToLast} and
+ * {@link orderBy}, {@link startAt}, {@link startAfter}, {@link
+ * endBefore}, {@link endAt}, {@link limit}, {@link limitToLast} and
  * can then be passed to {@link query} to create a new query instance that
  * also contains this `QueryConstraint`.
  */
-export declare abstract class QueryConstraint {
-    /** The type of this query constraints */
+export declare abstract class QueryConstraint extends AppliableConstraint {
+    /** The type of this query constraint */
     abstract readonly type: QueryConstraintType;
     /**
      * Takes the provided {@link Query} and returns a copy of the {@link Query} with this
-     * {@link QueryConstraint} applied.
+     * {@link AppliableConstraint} applied.
      */
     abstract _apply<T>(query: Query<T>): Query<T>;
 }
@@ -2043,6 +2108,23 @@ export declare class QueryDocumentSnapshot<T = DocumentData> extends DocumentSna
     data(): T;
 }
 
+/**
+ * A `QueryEndAtConstraint` is used to exclude documents from the end of a
+ * result set returned by a Firestore query.
+ * `QueryEndAtConstraint`s are created by invoking {@link (endAt:1)} or
+ * {@link (endBefore:1)} and can then be passed to {@link query} to create a new
+ * query instance that also contains this `QueryEndAtConstraint`.
+ */
+export declare class QueryEndAtConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'endBefore' | 'endAt';
+    private readonly _docOrFields;
+    private readonly _inclusive;
+    /* Excluded from this release type: __constructor */
+    static _create(type: 'endBefore' | 'endAt', _docOrFields: Array<unknown | DocumentSnapshot<unknown>>, _inclusive: boolean): QueryEndAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * Returns true if the provided queries point to the same collection and apply
  * the same constraints.
@@ -2054,6 +2136,74 @@ export declare class QueryDocumentSnapshot<T = DocumentData> extends DocumentSna
  */
 export declare function queryEqual<T>(left: Query<T>, right: Query<T>): boolean;
 
+/**
+ * A `QueryFieldFilterConstraint` is used to narrow the set of documents returned by
+ * a Firestore query by filtering on one or more document fields.
+ * `QueryFieldFilterConstraint`s are created by invoking {@link where} and can then
+ * be passed to {@link query} to create a new query instance that also contains
+ * this `QueryFieldFilterConstraint`.
+ */
+export declare class QueryFieldFilterConstraint extends QueryConstraint {
+    private readonly _field;
+    private _op;
+    private _value;
+    /** The type of this query constraint */
+    readonly type = "where";
+    /* Excluded from this release type: __constructor */
+    static _create(_field: FieldPath_2, _op: Operator, _value: unknown): QueryFieldFilterConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+    _parse<T>(query: Query<T>): FieldFilter;
+}
+
+/* Excluded from this release type: QueryFilterConstraint */
+
+/**
+ * A `QueryLimitConstraint` is used to limit the number of documents returned by
+ * a Firestore query.
+ * `QueryLimitConstraint`s are created by invoking {@link limit} or
+ * {@link limitToLast} and can then be passed to {@link query} to create a new
+ * query instance that also contains this `QueryLimitConstraint`.
+ */
+export declare class QueryLimitConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'limit' | 'limitToLast';
+    private readonly _limit;
+    private readonly _limitType;
+    /* Excluded from this release type: __constructor */
+    static _create(type: 'limit' | 'limitToLast', _limit: number, _limitType: LimitType): QueryLimitConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
+/**
+ * `QueryNonFilterConstraint` is a helper union type that represents
+ * QueryConstraints which are used to narrow or order the set of documents,
+ * but that do not explicitly filter on a document field.
+ * `QueryNonFilterConstraint`s are created by invoking {@link orderBy},
+ * {@link startAt}, {@link startAfter}, {@link endBefore}, {@link endAt},
+ * {@link limit} or {@link limitToLast} and can then be passed to {@link query}
+ * to create a new query instance that also contains the `QueryConstraint`.
+ */
+export declare type QueryNonFilterConstraint = QueryOrderByConstraint | QueryLimitConstraint | QueryStartAtConstraint | QueryEndAtConstraint;
+
+/**
+ * A `QueryOrderByConstraint` is used to sort the set of documents returned by a
+ * Firestore query. `QueryOrderByConstraint`s are created by invoking
+ * {@link orderBy} and can then be passed to {@link query} to create a new query
+ * instance that also contains this `QueryOrderByConstraint`.
+ *
+ * Note: Documents that do not contain the orderBy field will not be present in
+ * the query result.
+ */
+export declare class QueryOrderByConstraint extends QueryConstraint {
+    private readonly _field;
+    private _direction;
+    /** The type of this query constraint */
+    readonly type = "orderBy";
+    /* Excluded from this release type: __constructor */
+    static _create(_field: FieldPath_2, _direction: Direction): QueryOrderByConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * A `QuerySnapshot` contains zero or more `DocumentSnapshot` objects
  * representing the results of a query. The documents can be accessed as an
@@ -2086,6 +2236,23 @@ export declare class QuerySnapshot<T = DocumentData> {
     forEach(callback: (result: QueryDocumentSnapshot<T>) => void, thisArg?: unknown): void;
 }
 
+/**
+ * A `QueryStartAtConstraint` is used to exclude documents from the start of a
+ * result set returned by a Firestore query.
+ * `QueryStartAtConstraint`s are created by invoking {@link (startAt:1)} or
+ * {@link (startAfter:1)} and can then be passed to {@link query} to create a
+ * new query instance that also contains this `QueryStartAtConstraint`.
+ */
+export declare class QueryStartAtConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'startAt' | 'startAfter';
+    private readonly _docOrFields;
+    private readonly _inclusive;
+    /* Excluded from this release type: __constructor */
+    static _create(type: 'startAt' | 'startAfter', _docOrFields: Array<unknown | DocumentSnapshot<unknown>>, _inclusive: boolean): QueryStartAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * Returns true if the provided references are equal.
  *
@@ -2245,48 +2412,48 @@ declare class SnapshotVersion {
 }
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start after the
- * provided document (exclusive). The starting position is relative to the order
- * of the query. The document must contain all of the fields provided in the
- * orderBy of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start after the provided document (exclusive). The starting position is
+ * relative to the order of the query. The document must contain all of the
+ * fields provided in the orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to start after.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`
  */
-export declare function startAfter(snapshot: DocumentSnapshot<unknown>): QueryConstraint;
+export declare function startAfter(snapshot: DocumentSnapshot<unknown>): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start after the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start after the provided fields relative to the order of the query. The order
+ * of the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to start this query after, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`
  */
-export declare function startAfter(...fieldValues: unknown[]): QueryConstraint;
+export declare function startAfter(...fieldValues: unknown[]): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start at the
- * provided document (inclusive). The starting position is relative to the order
- * of the query. The document must contain all of the fields provided in the
- * `orderBy` of this query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start at the provided document (inclusive). The starting position is relative
+ * to the order of the query. The document must contain all of the fields
+ * provided in the `orderBy` of this query.
  *
  * @param snapshot - The snapshot of the document to start at.
- * @returns A {@link QueryConstraint} to pass to `query()`.
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`.
  */
-export declare function startAt(snapshot: DocumentSnapshot<unknown>): QueryConstraint;
+export declare function startAt(snapshot: DocumentSnapshot<unknown>): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start at the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start at the provided fields relative to the order of the query. The order of
+ * the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to start this query at, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`.
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`.
  */
-export declare function startAt(...fieldValues: unknown[]): QueryConstraint;
+export declare function startAt(...fieldValues: unknown[]): QueryStartAtConstraint;
 
 declare type TargetChangeTargetChangeType = 'NO_CHANGE' | 'ADD' | 'REMOVE' | 'CURRENT' | 'RESET';
 
@@ -2774,17 +2941,17 @@ declare type Value = firestoreV1ApiClientInterfaces.Value;
 declare type ValueNullValue = 'NULL_VALUE';
 
 /**
- * Creates a {@link QueryConstraint} that enforces that documents must contain the
- * specified field and that the value should satisfy the relation constraint
- * provided.
+ * Creates a {@link QueryFieldFilterConstraint} that enforces that documents
+ * must contain the specified field and that the value should satisfy the
+ * relation constraint provided.
  *
  * @param fieldPath - The path to compare
  * @param opStr - The operation string (e.g "&lt;", "&lt;=", "==", "&lt;",
  *   "&lt;=", "!=").
  * @param value - The value for comparison
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryFieldFilterConstraint}.
  */
-export declare function where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: unknown): QueryConstraint;
+export declare function where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: unknown): QueryFieldFilterConstraint;
 
 /**
  * Filter conditions in a {@link where} clause are specified using the