@react-native-firebase/firestore 18.4.0 → 18.6.0

package/lib/modular/query.js

@@ -0,0 +1,202 @@
+/**
+ * @typedef {import('..').FirebaseFirestoreTypes.DocumentReference} DocumentReference
+ * @typedef {import('..').FirebaseFirestoreTypes.DocumentSnapshot} DocumentSnapshot
+ * @typedef {import('..').FirebaseFirestoreTypes.FieldPath} FieldPath
+ * @typedef {import('..').FirebaseFirestoreTypes.QueryCompositeFilterConstraint} QueryCompositeFilterConstraint
+ * @typedef {import('..').FirebaseFirestoreTypes.QuerySnapshot} QuerySnapshot
+ * @typedef {import('..').FirebaseFirestoreTypes.Query} Query
+ * @typedef {import('..').FirebaseFirestoreTypes.WhereFilterOp} WhereFilterOp
+ * @typedef {import('../FirestoreFilter')._Filter} _Filter
+ * @typedef {import('./query').IQueryConstraint} IQueryConstraint
+ * @typedef {import('./query').OrderByDirection} OrderByDirection
+ * @typedef {import('./query').QueryFieldFilterConstraint} QueryFieldFilterConstraint
+ * @typedef {import('./query').QueryLimitConstraint} QueryLimitConstraint
+ * @typedef {import('./query').QueryNonFilterConstraint} QueryNonFilterConstraint
+ * @typedef {import('./query').QueryOrderByConstraint} QueryOrderByConstraint
+ * @typedef {import('./query').QueryStartAtConstraint} QueryStartAtConstraint
+ */
+
+import { _Filter, Filter } from '../FirestoreFilter';
+
+/**
+ * @implements {IQueryConstraint}
+ */
+class QueryConstraint {
+  constructor(type, ...args) {
+    this.type = type;
+    this._args = args;
+  }
+
+  _apply(query) {
+    return query[this.type].apply(query, this._args);
+  }
+}
+
+/**
+ * @param {Query} query
+ * @param {QueryCompositeFilterConstraint | QueryConstraint | undefined} queryConstraint
+ * @param {(QueryConstraint | QueryNonFilterConstraint)[]} additionalQueryConstraints
+ * @returns {Query}
+ */
+export function query(query, queryConstraint, ...additionalQueryConstraints) {
+  const queryConstraints = [queryConstraint, ...additionalQueryConstraints].filter(
+    constraint => constraint !== undefined,
+  );
+  let q = query;
+  for (const queryConstraint of queryConstraints) {
+    q = queryConstraint._apply(q);
+  }
+  return q;
+}
+
+/**
+ * @param {string | FieldPath} fieldPath
+ * @param {WhereFilterOp} opStr
+ * @param {unknown} value
+ * @returns {QueryFieldFilterConstraint}
+ */
+export function where(fieldPath, opStr, value) {
+  return new QueryConstraint('where', fieldPath, opStr, value);
+}
+
+/**
+ * @param {QueryFieldFilterConstraint[]} queries
+ * @returns {_Filter[]}
+ */
+function getFilterOps(queries) {
+  const ops = [];
+  for (const query of queries) {
+    if (query.type !== 'where') {
+      throw 'Not where'; // FIXME: Better error message
+    }
+
+    const args = query._args;
+    if (!args.length) {
+      throw 'No args'; // FIXME: Better error message
+    }
+
+    if (args[0] instanceof _Filter) {
+      ops.push(args[0]);
+      continue;
+    }
+
+    const [fieldPath, opStr, value] = args;
+    ops.push(Filter(fieldPath, opStr, value));
+  }
+  return ops;
+}
+
+/**
+ * @param {QueryFieldFilterConstraint[]} queries
+ * @returns {QueryCompositeFilterConstraint}
+ */
+export function or(...queries) {
+  const ops = getFilterOps(queries);
+  return new QueryConstraint('where', Filter.or(...ops));
+}
+
+/**
+ * @param {QueryFieldFilterConstraint[]} queries
+ * @returns {QueryCompositeFilterConstraint}
+ */
+export function and(...queries) {
+  const ops = getFilterOps(queries);
+  return new QueryConstraint('where', Filter.and(...ops));
+}
+
+/**
+ * @param {string | FieldPath} fieldPath
+ * @param {OrderByDirection} directionStr
+ * @returns {QueryOrderByConstraint}
+ */
+export function orderBy(fieldPath, directionStr) {
+  return new QueryConstraint('orderBy', fieldPath, directionStr);
+}
+
+/**
+ * @param {(unknown | DocumentSnapshot)} docOrFields
+ * @returns {QueryStartAtConstraint}
+ */
+export function startAt(...docOrFields) {
+  return new QueryConstraint('startAt', ...docOrFields);
+}
+
+/**
+ * @param {(unknown | DocumentSnapshot)} docOrFields
+ * @returns {QueryStartAtConstraint}
+ */
+export function startAfter(...docOrFields) {
+  return new QueryConstraint('startAfter', ...docOrFields);
+}
+
+/**
+ * @param {number | string | boolean | null} value
+ * @param {string?} key
+ * @returns {QueryConstraint}
+ */
+export function endAt(value, key) {
+  if (!key) {
+    return new QueryConstraint('endAt', value);
+  }
+  return new QueryConstraint('endAt', value, key);
+}
+
+/**
+ * @param {number | string | boolean | null} value
+ * @param {string?} key
+ * @returns {QueryConstraint}
+ */
+export function endBefore(value, key) {
+  if (!key) {
+    return new QueryConstraint('endBefore', value);
+  }
+  return new QueryConstraint('endBefore', value, key);
+}
+
+/**
+ * @param {number} limit
+ * @returns {QueryLimitConstraint}
+ */
+export function limit(limit) {
+  return new QueryConstraint('limit', limit);
+}
+
+/**
+ * @param {number} limit
+ * @returns {QueryConstraint}
+ */
+export function limitToLast(limit) {
+  return new QueryConstraint('limitToLast', limit);
+}
+
+/**
+ * @param {Query} query
+ * @returns {Promise<QuerySnapshot>}
+ */
+export function getDocs(query) {
+  return query.get({ source: 'default' });
+}
+
+/**
+ * @param {Query} query
+ * @returns {Promise<QuerySnapshot>}
+ */
+export function getDocsFromCache(query) {
+  return query.get({ source: 'cache' });
+}
+
+/**
+ * @param {Query} query
+ * @returns {Promise<QuerySnapshot>}
+ */
+export function getDocsFromServer(query) {
+  return query.get({ source: 'server' });
+}
+
+/**
+ * @param {DocumentReference} reference
+ * @returns {Promise<void>}
+ */
+export function deleteDoc(reference) {
+  return reference.delete();
+}

package/lib/modular/snapshot.d.ts

@@ -0,0 +1,203 @@
+import { FirebaseFirestoreTypes } from '../index';
+
+import DocumentReference = FirebaseFirestoreTypes.DocumentReference;
+import DocumentSnapshot = FirebaseFirestoreTypes.DocumentSnapshot;
+import SnapshotListenOptions = FirebaseFirestoreTypes.SnapshotListenOptions;
+import QuerySnapshot = FirebaseFirestoreTypes.QuerySnapshot;
+import Query = FirebaseFirestoreTypes.Query;
+
+export type Unsubscribe = () => void;
+export type FirestoreError = Error;
+
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  reference: DocumentReference<T>,
+  observer: {
+    next?: (snapshot: DocumentSnapshot<T>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+  },
+): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  reference: DocumentReference<T>,
+  options: SnapshotListenOptions,
+  observer: {
+    next?: (snapshot: DocumentSnapshot<T>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+  },
+): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot`
+ * is available.
+ * @param onError - A callback to be called if the listen fails or is
+ * cancelled. No further callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are
+ * never ending.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  reference: DocumentReference<T>,
+  onNext: (snapshot: DocumentSnapshot<T>) => void,
+  onError?: (error: FirestoreError) => void,
+  onCompletion?: () => void,
+): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot`
+ * is available.
+ * @param onError - A callback to be called if the listen fails or is
+ * cancelled. No further callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are
+ * never ending.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  reference: DocumentReference<T>,
+  options: SnapshotListenOptions,
+  onNext: (snapshot: DocumentSnapshot<T>) => void,
+  onError?: (error: FirestoreError) => void,
+  onCompletion?: () => void,
+): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  query: Query<T>,
+  observer: {
+    next?: (snapshot: QuerySnapshot<T>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+  },
+): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  query: Query<T>,
+  options: SnapshotListenOptions,
+  observer: {
+    next?: (snapshot: QuerySnapshot<T>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+  },
+): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot`
+ * is available.
+ * @param onCompletion - Can be provided, but will not be called since streams are
+ * never ending.
+ * @param onError - A callback to be called if the listen fails or is
+ * cancelled. No further callbacks will occur.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  query: Query<T>,
+  onNext: (snapshot: QuerySnapshot<T>) => void,
+  onError?: (error: FirestoreError) => void,
+  onCompletion?: () => void,
+): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass
+ * individual `onNext` and `onError` callbacks or pass a single observer
+ * object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will
+ * never be called because the snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot`
+ * is available.
+ * @param onCompletion - Can be provided, but will not be called since streams are
+ * never ending.
+ * @param onError - A callback to be called if the listen fails or is
+ * cancelled. No further callbacks will occur.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export function onSnapshot<T>(
+  query: Query<T>,
+  options: SnapshotListenOptions,
+  onNext: (snapshot: QuerySnapshot<T>) => void,
+  onError?: (error: FirestoreError) => void,
+  onCompletion?: () => void,
+): Unsubscribe;

package/lib/modular/snapshot.js

@@ -0,0 +1,14 @@
+/**
+ * @typedef {import('../..').FirebaseFirestoreTypes.Query} Query
+ * @typedef {import('../..').FirebaseFirestoreTypes.DocumentReference} DocumentReference
+ * @typedef {import('snapshot').Unsubscribe} Unsubscribe
+ */
+
+/**
+ * @param {Query | DocumentReference} reference
+ * @param {unknown} args
+ * @returns {Promise<unknown>}
+ */
+export function onSnapshot(reference, ...args) {
+  return reference.onSnapshot(...args);
+}

package/lib/modular/utils/observer.js

@@ -0,0 +1,16 @@
+/**
+ * @param {unknown} obj
+ * @returns {boolean}
+ */
+export function isPartialObserver(obj) {
+  const observerMethods = ['next', 'error', 'complete'];
+  if (typeof obj !== 'object' || obj == null) return false;
+
+  for (const method of observerMethods) {
+    if (method in obj && typeof obj[method] === 'function') {
+      return true;
+    }
+  }
+
+  return false;
+}

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '18.4.0';
+module.exports = '18.6.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/firestore",
-  "version": "18.4.0",
+  "version": "18.6.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - Cloud Firestore is a NoSQL cloud database to store and sync data between your React Native application and Firebase's database. The API matches the Firebase Web SDK whilst taking advantage of the native SDKs performance and offline capabilities.",
   "main": "lib/index.js",
@@ -27,10 +27,10 @@
     "firestore"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "18.4.0"
+    "@react-native-firebase/app": "18.6.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5f6460a87970d8b6013530de980bc760ddc70f90"
+  "gitHead": "adbbd4171adb1e3c2306da1285520abbaf9313b8"
 }