@firebase/firestore 3.7.3 → 3.8.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @firebase/firestore
 
+## 3.8.0
+
+### Minor Changes
+
+- [`ab3f16cba`](https://github.com/firebase/firebase-js-sdk/commit/ab3f16cbabc420fab0a322a21c9e28d3cbed4f24) [#6796](https://github.com/firebase/firebase-js-sdk/pull/6796) - Upgrade TypeScript to 4.7.4 (was 4.2.2)
+
+- [`fde5adf63`](https://github.com/firebase/firebase-js-sdk/commit/fde5adf638dae4714ff7f25c75e475344907e05e) [#6694](https://github.com/firebase/firebase-js-sdk/pull/6694) - Functions in the Firestore package that return QueryConstraints (for example: `where(...)`, `limit(...)`, and `orderBy(...)`)
+  now return a more specific type, which extends QueryConstraint. Refactoring and code that supports future features is also
+  included in this release.
+
+### Patch Changes
+
+- Updated dependencies [[`c20633ed3`](https://github.com/firebase/firebase-js-sdk/commit/c20633ed35056cbadc9d65d9ceddf4e28d1ea666), [`1625f7a95`](https://github.com/firebase/firebase-js-sdk/commit/1625f7a95cc3ffb666845db0a8044329be74b5be)]:
+  - @firebase/util@1.8.0
+  - @firebase/component@0.6.0
+  - @firebase/logger@0.4.0
+  - @firebase/webchannel-wrapper@0.9.0
+
 ## 3.7.3
 
 ### Patch Changes

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

@@ -11,7 +11,7 @@ export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, A
 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';
-export { endAt, endBefore, startAt, startAfter, limit, limitToLast, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryConstraint, QueryConstraintType } from '../src/lite-api/query';
+export { and, endAt, endBefore, startAt, startAfter, limit, limitToLast, where, or, orderBy, query, QueryConstraint, QueryConstraintType, QueryCompositeFilterConstraint, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryNonFilterConstraint, QueryStartAtConstraint, QueryEndAtConstraint, OrderByDirection, WhereFilterOp } from '../src/lite-api/query';
 export { addDoc, deleteDoc, updateDoc, setDoc, getDoc, getDocs } from '../src/lite-api/reference_impl';
 export { Primitive, NestedUpdateFields, ChildUpdateFields, AddPrefixToKeys, UnionToIntersection } from '../src/lite-api/types';
 export { FieldPath, documentId } from '../src/lite-api/field_path';

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

@@ -14,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { endAt, endBefore, startAfter, startAt, limitToLast, limit, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryConstraint, QueryConstraintType } from '../lite-api/query';
+export { and, endAt, endBefore, startAfter, startAt, limitToLast, limit, or, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryCompositeFilterConstraint, QueryConstraint, QueryConstraintType, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryStartAtConstraint, QueryEndAtConstraint, QueryNonFilterConstraint } from '../lite-api/query';

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

@@ -22,7 +22,7 @@ export { LoadBundleTask, LoadBundleTaskProgress, TaskState } from './api/bundle'
 export { FirestoreSettings, PersistenceSettings } from './api/settings';
 export { DocumentChange, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot, snapshotEqual, SnapshotOptions, FirestoreDataConverter, DocumentChangeType, SnapshotMetadata } from './api/snapshot';
 export { DocumentReference, CollectionReference, Query, doc, collection, collectionGroup, SetOptions, DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, refEqual, queryEqual } from './api/reference';
-export { endAt, endBefore, startAt, startAfter, limit, limitToLast, where, orderBy, query, QueryConstraint, QueryConstraintType, OrderByDirection, WhereFilterOp } from './api/filter';
+export { and, endAt, endBefore, startAt, startAfter, limit, limitToLast, where, or, orderBy, query, QueryConstraint, QueryConstraintType, QueryCompositeFilterConstraint, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryNonFilterConstraint, QueryStartAtConstraint, QueryEndAtConstraint, OrderByDirection, WhereFilterOp } from './api/filter';
 export { Unsubscribe, SnapshotListenOptions } from './api/reference_impl';
 export { TransactionOptions } from './api/transaction_options';
 export { runTransaction, Transaction } from './api/transaction';

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

@@ -0,0 +1,49 @@
+/**
+ * @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 { Document } from '../model/document';
+import { Value as ProtoValue } from '../protos/firestore_proto_api';
+import { OrderBy } from './order_by';
+/**
+ * Represents a bound of a query.
+ *
+ * The bound is specified with the given components representing a position and
+ * whether it's just before or just after the position (relative to whatever the
+ * query order is).
+ *
+ * The position represents a logical index position for a query. It's a prefix
+ * of values for the (potentially implicit) order by clauses of a query.
+ *
+ * Bound provides a function to determine whether a document comes before or
+ * after a bound. This is influenced by whether the position is just before or
+ * just after the provided values.
+ */
+export declare class Bound {
+    readonly position: ProtoValue[];
+    readonly inclusive: boolean;
+    constructor(position: ProtoValue[], inclusive: boolean);
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+export declare function boundSortsAfterDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+export declare function boundSortsBeforeDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
+export declare function boundEquals(left: Bound | null, right: Bound | null): boolean;

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

@@ -0,0 +1,134 @@
+/**
+ * @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 { Document } from '../model/document';
+import { FieldPath } from '../model/path';
+import { Value as ProtoValue } from '../protos/firestore_proto_api';
+export 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"
+}
+export declare const enum CompositeOperator {
+    OR = "or",
+    AND = "and"
+}
+export declare abstract class Filter {
+    abstract matches(doc: Document): boolean;
+    abstract getFlattenedFilters(): readonly FieldFilter[];
+    abstract getFilters(): Filter[];
+    abstract getFirstInequalityField(): FieldPath | null;
+}
+export declare class FieldFilter extends Filter {
+    readonly field: FieldPath;
+    readonly op: Operator;
+    readonly value: ProtoValue;
+    protected constructor(field: FieldPath, op: Operator, value: ProtoValue);
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(field: FieldPath, op: Operator, value: ProtoValue): FieldFilter;
+    private static createKeyFieldInFilter;
+    matches(doc: Document): boolean;
+    protected matchesComparison(comparison: number): boolean;
+    isInequality(): boolean;
+    getFlattenedFilters(): readonly FieldFilter[];
+    getFilters(): Filter[];
+    getFirstInequalityField(): FieldPath | null;
+}
+export declare class CompositeFilter extends Filter {
+    readonly filters: readonly Filter[];
+    readonly op: CompositeOperator;
+    private memoizedFlattenedFilters;
+    protected constructor(filters: readonly Filter[], op: CompositeOperator);
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(filters: Filter[], op: CompositeOperator): CompositeFilter;
+    matches(doc: Document): boolean;
+    getFlattenedFilters(): readonly FieldFilter[];
+    getFilters(): Filter[];
+    getFirstInequalityField(): FieldPath | null;
+    private findFirstMatchingFilter;
+}
+export declare function compositeFilterIsConjunction(compositeFilter: CompositeFilter): boolean;
+export declare function compositeFilterIsDisjunction(compositeFilter: CompositeFilter): boolean;
+/**
+ * Returns true if this filter is a conjunction of field filters only. Returns false otherwise.
+ */
+export declare function compositeFilterIsFlatConjunction(compositeFilter: CompositeFilter): boolean;
+/**
+ * Returns true if this filter does not contain any composite filters. Returns false otherwise.
+ */
+export declare function compositeFilterIsFlat(compositeFilter: CompositeFilter): boolean;
+export declare function canonifyFilter(filter: Filter): string;
+export declare function filterEquals(f1: Filter, f2: Filter): boolean;
+export declare function fieldFilterEquals(f1: FieldFilter, f2: Filter): boolean;
+export declare function compositeFilterEquals(f1: CompositeFilter, f2: Filter): boolean;
+/**
+ * Returns a new composite filter that contains all filter from
+ * `compositeFilter` plus all the given filters in `otherFilters`.
+ */
+export declare function compositeFilterWithAddedFilters(compositeFilter: CompositeFilter, otherFilters: Filter[]): CompositeFilter;
+/** Returns a debug description for `filter`. */
+export declare function stringifyFilter(filter: Filter): string;
+export declare function stringifyCompositeFilter(filter: CompositeFilter): string;
+export declare function stringifyFieldFilter(filter: FieldFilter): string;
+/** Filter that matches on key fields (i.e. '__name__'). */
+export declare class KeyFieldFilter extends FieldFilter {
+    private readonly key;
+    constructor(field: FieldPath, op: Operator, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** Filter that matches on key fields within an array. */
+export declare class KeyFieldInFilter extends FieldFilter {
+    private readonly keys;
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** Filter that matches on key fields not present within an array. */
+export declare class KeyFieldNotInFilter extends FieldFilter {
+    private readonly keys;
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** A Filter that implements the array-contains operator. */
+export declare class ArrayContainsFilter extends FieldFilter {
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** A Filter that implements the IN operator. */
+export declare class InFilter extends FieldFilter {
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** A Filter that implements the not-in operator. */
+export declare class NotInFilter extends FieldFilter {
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}
+/** A Filter that implements the array-contains-any operator. */
+export declare class ArrayContainsAnyFilter extends FieldFilter {
+    constructor(field: FieldPath, value: ProtoValue);
+    matches(doc: Document): boolean;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * @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 { FieldPath } from '../model/path';
+/**
+ * The direction of sorting in an order by.
+ */
+export declare const enum Direction {
+    ASCENDING = "asc",
+    DESCENDING = "desc"
+}
+/**
+ * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
+ */
+export declare class OrderBy {
+    readonly field: FieldPath;
+    readonly dir: Direction;
+    constructor(field: FieldPath, dir?: Direction);
+}
+export declare function canonifyOrderBy(orderBy: OrderBy): string;
+export declare function stringifyOrderBy(orderBy: OrderBy): string;
+export declare function orderByEquals(left: OrderBy, right: OrderBy): boolean;

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

@@ -16,7 +16,10 @@
  */
 import { Document } from '../model/document';
 import { FieldPath, ResourcePath } from '../model/path';
-import { Bound, Filter, Operator, OrderBy, Target } from './target';
+import { Bound } from './bound';
+import { Filter } from './filter';
+import { OrderBy } from './order_by';
+import { Target } from './target';
 export declare const enum LimitType {
     First = "F",
     Last = "L"
@@ -77,13 +80,9 @@ export declare function asCollectionQueryAtPath(query: Query, path: ResourcePath
  * could remove results.
  */
 export declare function queryMatchesAllDocuments(query: Query): boolean;
+export declare function queryContainsCompositeFilters(query: Query): boolean;
 export declare function getFirstOrderByField(query: Query): FieldPath | null;
 export declare function getInequalityFilterField(query: Query): FieldPath | null;
-/**
- * Checks if any of the provided Operators are included in the query and
- * returns the first one that is, or null if none are.
- */
-export declare function findFilterOperator(query: Query, operators: Operator[]): Operator | null;
 /**
  * Creates a new Query for a collection group query that matches all documents
  * within the provided collection group.

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

@@ -14,10 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Document } from '../model/document';
 import { FieldIndex } from '../model/field_index';
 import { FieldPath, ResourcePath } from '../model/path';
 import { Value as ProtoValue } from '../protos/firestore_proto_api';
+import { Bound } from './bound';
+import { Filter, FieldFilter } from './filter';
+import { OrderBy } from './order_by';
 /**
  * A Target represents the WatchTarget representation of a Query, which is used
  * by the LocalStore and the RemoteStore to keep track of and to execute
@@ -84,122 +86,4 @@ export declare function targetGetLowerBound(target: Target, fieldIndex: FieldInd
 export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound;
 /** Returns the number of segments of a perfect index for this target. */
 export declare function targetGetSegmentCount(target: Target): number;
-export declare abstract class Filter {
-    abstract matches(doc: Document): boolean;
-}
-export 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"
-}
-/**
- * The direction of sorting in an order by.
- */
-export declare const enum Direction {
-    ASCENDING = "asc",
-    DESCENDING = "desc"
-}
-export declare class FieldFilter extends Filter {
-    field: FieldPath;
-    op: Operator;
-    value: ProtoValue;
-    protected constructor(field: FieldPath, op: Operator, value: ProtoValue);
-    /**
-     * Creates a filter based on the provided arguments.
-     */
-    static create(field: FieldPath, op: Operator, value: ProtoValue): FieldFilter;
-    private static createKeyFieldInFilter;
-    matches(doc: Document): boolean;
-    protected matchesComparison(comparison: number): boolean;
-    isInequality(): boolean;
-}
-export declare function canonifyFilter(filter: Filter): string;
-export declare function filterEquals(f1: Filter, f2: Filter): boolean;
-/** Returns a debug description for `filter`. */
-export declare function stringifyFilter(filter: Filter): string;
-/** Filter that matches on key fields (i.e. '__name__'). */
-export declare class KeyFieldFilter extends FieldFilter {
-    private readonly key;
-    constructor(field: FieldPath, op: Operator, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** Filter that matches on key fields within an array. */
-export declare class KeyFieldInFilter extends FieldFilter {
-    private readonly keys;
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** Filter that matches on key fields not present within an array. */
-export declare class KeyFieldNotInFilter extends FieldFilter {
-    private readonly keys;
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** A Filter that implements the array-contains operator. */
-export declare class ArrayContainsFilter extends FieldFilter {
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** A Filter that implements the IN operator. */
-export declare class InFilter extends FieldFilter {
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** A Filter that implements the not-in operator. */
-export declare class NotInFilter extends FieldFilter {
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/** A Filter that implements the array-contains-any operator. */
-export declare class ArrayContainsAnyFilter extends FieldFilter {
-    constructor(field: FieldPath, value: ProtoValue);
-    matches(doc: Document): boolean;
-}
-/**
- * Represents a bound of a query.
- *
- * The bound is specified with the given components representing a position and
- * whether it's just before or just after the position (relative to whatever the
- * query order is).
- *
- * The position represents a logical index position for a query. It's a prefix
- * of values for the (potentially implicit) order by clauses of a query.
- *
- * Bound provides a function to determine whether a document comes before or
- * after a bound. This is influenced by whether the position is just before or
- * just after the provided values.
- */
-export declare class Bound {
-    readonly position: ProtoValue[];
-    readonly inclusive: boolean;
-    constructor(position: ProtoValue[], inclusive: boolean);
-}
-/**
- * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
- */
-export declare class OrderBy {
-    readonly field: FieldPath;
-    readonly dir: Direction;
-    constructor(field: FieldPath, dir?: Direction);
-}
-export declare function canonifyOrderBy(orderBy: OrderBy): string;
-export declare function stringifyOrderBy(orderBy: OrderBy): string;
-export declare function orderByEquals(left: OrderBy, right: OrderBy): boolean;
-/**
- * Returns true if a document sorts after a bound using the provided sort
- * order.
- */
-export declare function boundSortsAfterDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-export declare function boundSortsBeforeDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
-export declare function boundEquals(left: Bound | null, right: Bound | null): boolean;
+export declare function targetHasLimit(target: Target): boolean;