@react-native-firebase/firestore 23.8.6 → 24.0.0

package/lib/FirestoreQueryModifiers.ts

@@ -0,0 +1,411 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { isNumber } from '@react-native-firebase/app/dist/module/common';
+import FieldPath, { DOCUMENT_ID } from './FieldPath';
+import type {
+  DocumentFieldValueInternal,
+  FirestoreCursorFieldsInternal,
+  FirestoreFilterSpecInternal,
+  FirestoreOrderSpecInternal,
+  FirestoreQueryOptionsInternal,
+} from './types/internal';
+import { buildNativeArray, generateNativeData } from './utils/serialize';
+
+export const OPERATORS: Record<string, string> = {
+  '==': 'EQUAL',
+  '>': 'GREATER_THAN',
+  '>=': 'GREATER_THAN_OR_EQUAL',
+  '<': 'LESS_THAN',
+  '<=': 'LESS_THAN_OR_EQUAL',
+  '!=': 'NOT_EQUAL',
+  'array-contains': 'ARRAY_CONTAINS',
+  'array-contains-any': 'ARRAY_CONTAINS_ANY',
+  'not-in': 'NOT_IN',
+  in: 'IN',
+};
+
+const INEQUALITY: Record<string, boolean> = {
+  LESS_THAN: true,
+  LESS_THAN_OR_EQUAL: true,
+  GREATER_THAN: true,
+  GREATER_THAN_OR_EQUAL: true,
+  NOT_EQUAL: true,
+};
+
+const DIRECTIONS: Record<string, string> = {
+  asc: 'ASCENDING',
+  desc: 'DESCENDING',
+};
+
+export interface FilterDef {
+  fieldPath?: FieldPath | string[];
+  operator: string;
+  value?: DocumentFieldValueInternal;
+  queries?: FilterDef[];
+}
+
+export interface OrderDef {
+  fieldPath: FieldPath;
+  direction: string;
+}
+
+export default class QueryModifiers {
+  _limit: number | undefined;
+  _limitToLast: number | undefined;
+  _filters: FilterDef[];
+  _orders: OrderDef[];
+  _type: 'collection' | 'collectionGroup';
+  _startAt: FirestoreCursorFieldsInternal | undefined;
+  _startAfter: FirestoreCursorFieldsInternal | undefined;
+  _endAt: FirestoreCursorFieldsInternal | undefined;
+  _endBefore: FirestoreCursorFieldsInternal | undefined;
+
+  hasInequality: false | FilterDef;
+  hasNotEqual: boolean;
+  hasArrayContains: boolean;
+  hasArrayContainsAny: boolean;
+  hasIn: boolean;
+  hasNotIn: boolean;
+
+  constructor() {
+    this._limit = undefined;
+    this._limitToLast = undefined;
+    this._filters = [];
+    this._orders = [];
+    this._type = 'collection';
+    this._startAt = undefined;
+    this._startAfter = undefined;
+    this._endAt = undefined;
+    this._endBefore = undefined;
+
+    this.hasInequality = false;
+    this.hasNotEqual = false;
+    this.hasArrayContains = false;
+    this.hasArrayContainsAny = false;
+    this.hasIn = false;
+    this.hasNotIn = false;
+  }
+
+  _copy(): QueryModifiers {
+    const newInstance = new QueryModifiers();
+    newInstance._limit = this._limit;
+    newInstance._limitToLast = this._limitToLast;
+    newInstance._filters = [...this._filters];
+    newInstance._orders = [...this._orders];
+    newInstance._type = this._type;
+    newInstance._startAt = this._startAt;
+    newInstance._startAfter = this._startAfter;
+    newInstance._endAt = this._endAt;
+    newInstance._endBefore = this._endBefore;
+    return newInstance;
+  }
+
+  get filters(): FirestoreFilterSpecInternal[] {
+    return this._filters.map(f => ({
+      ...f,
+      fieldPath: f.fieldPath instanceof FieldPath ? f.fieldPath._toArray() : f.fieldPath,
+    }));
+  }
+
+  get orders(): FirestoreOrderSpecInternal[] {
+    return this._orders.map(f => ({
+      ...f,
+      fieldPath: f.fieldPath instanceof FieldPath ? f.fieldPath._toArray() : f.fieldPath,
+    }));
+  }
+
+  get options(): FirestoreQueryOptionsInternal {
+    const options: FirestoreQueryOptionsInternal = {};
+
+    if (this._limit) {
+      options.limit = this._limit;
+    }
+
+    if (this._limitToLast) {
+      options.limitToLast = this._limitToLast;
+    }
+
+    if (this._startAt) {
+      options.startAt = this._startAt;
+    }
+    if (this._startAfter) {
+      options.startAfter = this._startAfter;
+    }
+    if (this._endAt) {
+      options.endAt = this._endAt;
+    }
+    if (this._endBefore) {
+      options.endBefore = this._endBefore;
+    }
+
+    return options;
+  }
+
+  get type(): string {
+    return this._type;
+  }
+
+  setFieldsCursor(
+    cursor: 'startAt' | 'startAfter' | 'endAt' | 'endBefore',
+    fields: FirestoreCursorFieldsInternal,
+  ): this {
+    (this as unknown as Record<string, FirestoreCursorFieldsInternal | undefined>)[`_${cursor}`] =
+      buildNativeArray(fields);
+    return this;
+  }
+
+  hasStart(): boolean {
+    return !!(this._startAt || this._startAfter);
+  }
+
+  hasEnd(): boolean {
+    return !!(this._endAt || this._endBefore);
+  }
+
+  asCollectionGroupQuery(): this {
+    this._type = 'collectionGroup';
+    return this;
+  }
+
+  isCollectionGroupQuery(): boolean {
+    return this._type === 'collectionGroup';
+  }
+
+  isValidLimit(limit: unknown): boolean {
+    return !isNumber(limit) || Math.floor(limit as number) !== limit || (limit as number) <= 0;
+  }
+
+  limit(limit: number): this {
+    this._limitToLast = undefined;
+    this._limit = limit;
+    return this;
+  }
+
+  isValidLimitToLast(limit: unknown): boolean {
+    return !isNumber(limit) || Math.floor(limit as number) !== limit || (limit as number) <= 0;
+  }
+
+  validatelimitToLast(): void {
+    if (this._limitToLast) {
+      if (!this._orders.length) {
+        throw new Error(
+          'firebase.firestore().collection().limitToLast() queries require specifying at least one firebase.firestore().collection().orderBy() clause',
+        );
+      }
+    }
+  }
+
+  limitToLast(limitToLast: number): this {
+    this._limit = undefined;
+    this._limitToLast = limitToLast;
+    return this;
+  }
+
+  isValidOperator(operator: string): boolean {
+    return !!OPERATORS[operator];
+  }
+
+  isEqualOperator(operator: string): boolean {
+    return OPERATORS[operator] === 'EQUAL';
+  }
+
+  isNotEqualOperator(operator: string): boolean {
+    return OPERATORS[operator] === 'NOT_EQUAL';
+  }
+
+  isInOperator(operator: string): boolean {
+    return (
+      OPERATORS[operator] === 'IN' ||
+      OPERATORS[operator] === 'ARRAY_CONTAINS_ANY' ||
+      OPERATORS[operator] === 'NOT_IN'
+    );
+  }
+
+  where(fieldPath: FieldPath, opStr: string, value: DocumentFieldValueInternal): this {
+    const filter: FilterDef = {
+      fieldPath,
+      operator: OPERATORS[opStr] ?? opStr,
+      value: generateNativeData(value, true),
+    };
+
+    this._filters = this._filters.concat(filter);
+    return this;
+  }
+
+  filterWhere(filter: FilterDef): this {
+    this._filters = this._filters.concat(filter);
+    return this;
+  }
+
+  validateWhere(): void {
+    if (this._filters.length > 0) {
+      this._filterCheck(this._filters);
+    }
+  }
+
+  _filterCheck(filters: FilterDef[]): void {
+    for (let i = 0; i < filters.length; i++) {
+      const filter = filters[i]!;
+
+      if (filter.queries) {
+        this._filterCheck(filter.queries as FilterDef[]);
+        continue;
+      }
+
+      if (!INEQUALITY[filter.operator]) {
+        continue;
+      }
+
+      if (filter.operator === OPERATORS['!=']) {
+        if (this.hasNotEqual) {
+          throw new Error("Invalid query. You cannot use more than one '!=' inequality filter.");
+        }
+        this.hasNotEqual = true;
+      }
+
+      if (!this.hasInequality) {
+        this.hasInequality = filter;
+        continue;
+      }
+    }
+
+    for (let i = 0; i < filters.length; i++) {
+      const filter = filters[i]!;
+
+      if (filter.operator === OPERATORS['array-contains']) {
+        if (this.hasArrayContains) {
+          throw new Error('Invalid query. Queries only support a single array-contains filter.');
+        }
+        this.hasArrayContains = true;
+      }
+
+      if (filter.operator === OPERATORS['array-contains-any']) {
+        if (this.hasArrayContainsAny) {
+          throw new Error(
+            "Invalid query. You cannot use more than one 'array-contains-any' filter.",
+          );
+        }
+
+        if (this.hasNotIn) {
+          throw new Error(
+            "Invalid query. You cannot use 'array-contains-any' filters with 'not-in' filters.",
+          );
+        }
+
+        this.hasArrayContainsAny = true;
+      }
+
+      if (filter.operator === OPERATORS.in) {
+        if (this.hasNotIn) {
+          throw new Error("Invalid query. You cannot use 'in' filters with 'not-in' filters.");
+        }
+
+        this.hasIn = true;
+      }
+
+      if (filter.operator === OPERATORS['not-in']) {
+        if (this.hasNotIn) {
+          throw new Error("Invalid query. You cannot use more than one 'not-in' filter.");
+        }
+
+        if (this.hasNotEqual) {
+          throw new Error(
+            "Invalid query. You cannot use 'not-in' filters with '!=' inequality filters",
+          );
+        }
+
+        if (this.hasIn) {
+          throw new Error("Invalid query. You cannot use 'not-in' filters with 'in' filters.");
+        }
+
+        if (this.hasArrayContainsAny) {
+          throw new Error(
+            "Invalid query. You cannot use 'not-in' filters with 'array-contains-any' filters.",
+          );
+        }
+
+        this.hasNotIn = true;
+      }
+    }
+  }
+
+  isValidDirection(directionStr: string): boolean {
+    return !!DIRECTIONS[directionStr.toLowerCase()];
+  }
+
+  orderBy(fieldPath: FieldPath, directionStr?: string): this {
+    const dir = directionStr ? DIRECTIONS[directionStr.toLowerCase()] : DIRECTIONS.asc;
+    const order: OrderDef = {
+      fieldPath: fieldPath,
+      direction: dir ?? 'ASCENDING',
+    };
+
+    this._orders = this._orders.concat(order);
+    return this;
+  }
+
+  validateOrderBy(): void {
+    this._validateOrderByCheck(this._filters);
+  }
+
+  _validateOrderByCheck(filters: FilterDef[]): void {
+    if (this._orders.length > 1) {
+      const orders = this._orders.map($ => $.fieldPath._toPath());
+      const set = new Set(orders);
+
+      if (set.size !== orders.length) {
+        throw new Error('Invalid query. Order by clause cannot contain duplicate fields.');
+      }
+    }
+
+    if (filters.length === 0) {
+      return;
+    }
+
+    for (let i = 0; i < filters.length; i++) {
+      const filter = filters[i]!;
+
+      if (filter.queries) {
+        this._validateOrderByCheck(filter.queries as FilterDef[]);
+        continue;
+      }
+      const filterFieldPath = (filter.fieldPath as FieldPath)._toPath();
+
+      for (let k = 0; k < this._orders.length; k++) {
+        const order = this._orders[k]!;
+        const orderFieldPath = order.fieldPath;
+        if (filter.operator === OPERATORS['==']) {
+          if (filterFieldPath === orderFieldPath._toPath()) {
+            throw new Error(
+              `Invalid query. Query.orderBy() parameter: ${orderFieldPath} cannot be the same as your Query.where() fieldPath parameter: ${filterFieldPath}`,
+            );
+          }
+        }
+
+        if (
+          filterFieldPath === DOCUMENT_ID._toPath() &&
+          orderFieldPath._toPath() !== DOCUMENT_ID._toPath()
+        ) {
+          throw new Error(
+            "Invalid query. Query.where() fieldPath parameter: 'FirestoreFieldPath' cannot be used in conjunction with a different Query.orderBy() parameter",
+          );
+        }
+      }
+    }
+  }
+}

package/lib/{FirestoreQuerySnapshot.js → FirestoreQuerySnapshot.ts}

@@ -16,49 +16,86 @@
  */
 
 import {
+  createDeprecationProxy,
   isBoolean,
   isFunction,
   isObject,
   isUndefined,
-  createDeprecationProxy,
 } from '@react-native-firebase/app/dist/module/common';
-import FirestoreDocumentChange from './FirestoreDocumentChange';
-import FirestoreDocumentSnapshot from './FirestoreDocumentSnapshot';
-import FirestoreSnapshotMetadata from './FirestoreSnapshotMetadata';
+import DocumentChange from './FirestoreDocumentChange';
+import DocumentSnapshot from './FirestoreDocumentSnapshot';
+import SnapshotMetadata from './FirestoreSnapshotMetadata';
+
+import type Query from './FirestoreQuery';
+import type { DocumentData, FirestoreDataConverter } from './types/firestore';
+import type { FirestoreInternal } from './types/internal';
+
+export interface QuerySnapshotNativeData {
+  source?: string;
+  excludesMetadataChanges?: boolean;
+  changes: Array<{
+    type: string;
+    doc: { path: string; data?: unknown; metadata?: [boolean, boolean]; exists?: boolean };
+    ni: number;
+    oi: number;
+    isMetadataChange?: boolean;
+  }>;
+  documents: Array<{
+    path: string;
+    data?: unknown;
+    metadata?: [boolean, boolean];
+    exists?: boolean;
+  }>;
+  metadata: [boolean, boolean];
+}
 
-export default class FirestoreQuerySnapshot {
-  constructor(firestore, query, nativeData) {
+export default class QuerySnapshot {
+  _query: Query;
+  _source: string | undefined;
+  _excludesMetadataChanges: boolean | undefined;
+  _changes: DocumentChange[];
+  _docs: DocumentSnapshot[];
+  _metadata: SnapshotMetadata;
+
+  constructor(
+    firestore: FirestoreInternal,
+    query: Query,
+    nativeData: QuerySnapshotNativeData,
+    converter: FirestoreDataConverter<DocumentData, DocumentData> | null,
+  ) {
     this._query = query;
     this._source = nativeData.source;
     this._excludesMetadataChanges = nativeData.excludesMetadataChanges;
-    this._changes = nativeData.changes.map($ => new FirestoreDocumentChange(firestore, $));
-    this._docs = nativeData.documents.map($ =>
-      createDeprecationProxy(new FirestoreDocumentSnapshot(firestore, $)),
+    this._changes = nativeData.changes.map(
+      (c: QuerySnapshotNativeData['changes'][0]) => new DocumentChange(firestore, c, converter),
     );
-    this._metadata = new FirestoreSnapshotMetadata(nativeData.metadata);
+    this._docs = nativeData.documents.map((doc: QuerySnapshotNativeData['documents'][0]) =>
+      createDeprecationProxy(new DocumentSnapshot(firestore, doc, converter)),
+    ) as DocumentSnapshot[];
+    this._metadata = new SnapshotMetadata(nativeData.metadata ?? [false, false]);
   }
 
-  get docs() {
+  get docs(): DocumentSnapshot[] {
     return this._docs;
   }
 
-  get empty() {
+  get empty(): boolean {
     return this._docs.length === 0;
   }
 
-  get metadata() {
+  get metadata(): SnapshotMetadata {
     return this._metadata;
   }
 
-  get query() {
+  get query(): Query {
     return this._query;
   }
 
-  get size() {
+  get size(): number {
     return this._docs.length;
   }
 
-  docChanges(options) {
+  docChanges(options?: { includeMetadataChanges?: boolean }): DocumentChange[] {
     if (!isUndefined(options) && !isObject(options)) {
       throw new Error(
         "firebase.firestore() QuerySnapshot.docChanges(*) 'options' expected an object.",
@@ -74,10 +111,9 @@ export default class FirestoreQuerySnapshot {
         );
       }
 
-      includeMetaDataChanges = options.includeMetadataChanges;
+      includeMetaDataChanges = options.includeMetadataChanges ?? false;
     }
 
-    // A get query should always return the document changes from native
     if (this._source === 'get') {
       return this._changes;
     }
@@ -89,16 +125,14 @@ export default class FirestoreQuerySnapshot {
     }
 
     return this._changes.filter($ => {
-      // Remove all changes that have come from metadata changes list
       if (!includeMetaDataChanges) {
         return $._isMetadataChange === false;
       }
-
       return true;
     });
   }
 
-  forEach(callback, thisArg) {
+  forEach(callback: (doc: DocumentSnapshot, index: number) => void, thisArg?: unknown): void {
     if (!isFunction(callback)) {
       throw new Error(
         "firebase.firestore() QuerySnapshot.forEach(*) 'callback' expected a function.",
@@ -108,19 +142,17 @@ export default class FirestoreQuerySnapshot {
     const cb = thisArg ? callback.bind(thisArg) : callback;
 
     for (let i = 0; i < this._docs.length; i++) {
-      cb(this._docs[i], i);
+      cb(this._docs[i]!, i);
     }
   }
 
-  // send '...args' through as it may contain our namespace deprecation marker
-  isEqual(other, ...args) {
-    if (!(other instanceof FirestoreQuerySnapshot)) {
+  isEqual(other: QuerySnapshot, ...args: unknown[]): boolean {
+    if (!(other instanceof QuerySnapshot)) {
       throw new Error(
         "firebase.firestore() QuerySnapshot.isEqual(*) 'other' expected a QuerySnapshot instance.",
       );
     }
 
-    // Simple checks first
     if (
       this.empty !== other.empty ||
       this.size !== other.size ||
@@ -129,14 +161,11 @@ export default class FirestoreQuerySnapshot {
       return false;
     }
 
-    // Expensive check
-    // Each doc must be in order & have the same data
     for (let i = 0; i < this.docs.length; i++) {
-      const thisDoc = this.docs[i];
-      const otherDoc = other.docs[i];
+      const thisDoc = this.docs[i]!;
+      const otherDoc = other.docs[i]!;
 
-      // send '...args' through as it may contain our namespace deprecation marker
-      if (!thisDoc.isEqual(otherDoc, ...args)) {
+      if (!(thisDoc.isEqual as (...a: unknown[]) => boolean)(otherDoc, ...args)) {
         return false;
       }
     }

package/lib/{FirestoreSnapshotMetadata.js → FirestoreSnapshotMetadata.ts}

@@ -17,21 +17,23 @@
 
 import { isUndefined } from '@react-native-firebase/app/dist/module/common';
 
-export default class FirestoreSnapshotMetadata {
-  constructor(metadata) {
+export default class SnapshotMetadata {
+  _metadata: [boolean, boolean];
+
+  constructor(metadata: [boolean, boolean]) {
     this._metadata = metadata;
   }
 
-  get fromCache() {
+  get fromCache(): boolean {
     return this._metadata[0];
   }
 
-  get hasPendingWrites() {
+  get hasPendingWrites(): boolean {
     return this._metadata[1];
   }
 
-  isEqual(other) {
-    if (isUndefined(other) || !(other instanceof FirestoreSnapshotMetadata)) {
+  isEqual(other: SnapshotMetadata): boolean {
+    if (isUndefined(other) || !(other instanceof SnapshotMetadata)) {
       throw new Error(
         "firebase.firestore() SnapshotMetadata.isEqual(*) 'other' expected instance of SnapshotMetadata",
       );

package/lib/{FirestoreStatics.js → FirestoreStatics.ts}

@@ -17,35 +17,42 @@
 
 import { createDeprecationProxy } from '@react-native-firebase/app/dist/module/common';
 import { getReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
-import FirestoreBlob from './FirestoreBlob';
-import FirestoreFieldPath from './FirestoreFieldPath';
-import FirestoreFieldValue from './FirestoreFieldValue';
+import Blob from './FirestoreBlob';
+import FieldPath from './FieldPath';
+import FieldValue from './FieldValue';
+import { Filter } from './FirestoreFilter';
 import FirestoreGeoPoint from './FirestoreGeoPoint';
 import FirestoreTimestamp from './FirestoreTimestamp';
-import { Filter } from './FirestoreFilter';
 import FirestoreVectorValue from './FirestoreVectorValue';
-export default {
-  Blob: FirestoreBlob,
-  FieldPath: FirestoreFieldPath,
-  FieldValue: createDeprecationProxy(FirestoreFieldValue),
+import type { LogLevel } from './types/firestore';
+import type { RNFBFirestoreModule } from './types/internal';
+
+type FirestoreLogLevel = LogLevel;
+
+const FirestoreStatics = {
+  Blob: Blob,
+  FieldPath: FieldPath,
+  FieldValue: createDeprecationProxy(FieldValue),
   GeoPoint: FirestoreGeoPoint,
   Timestamp: createDeprecationProxy(FirestoreTimestamp),
   Filter: createDeprecationProxy(Filter),
   VectorValue: FirestoreVectorValue,
-  vector(values) {
+  vector(values?: number[]): FirestoreVectorValue {
     return new FirestoreVectorValue(values);
   },
 
   CACHE_SIZE_UNLIMITED: -1,
 
-  setLogLevel(logLevel) {
+  setLogLevel(logLevel: FirestoreLogLevel): void {
     if (logLevel !== 'debug' && logLevel !== 'error' && logLevel !== 'silent') {
       throw new Error(
         "firebase.firestore.setLogLevel(*) 'logLevel' expected one of 'debug', 'error' or 'silent'",
       );
     }
 
-    const native = getReactNativeModule('RNFBFirestoreModule');
+    const native = getReactNativeModule('RNFBFirestoreModule') as unknown as RNFBFirestoreModule;
     native.setLogLevel(logLevel);
   },
 };
+
+export default FirestoreStatics;