@react-native-firebase/database 18.4.0 → 18.6.0

package/lib/modular/query.js

@@ -0,0 +1,291 @@
+/**
+ * @typedef {import('../..').DatabaseReference} DatabaseReference
+ * @typedef {import('../..').DataSnapshot} DataSnapshot
+ * @typedef {import('./query').QueryConstraint} IQueryConstraint
+ * @typedef {import('./query').Query} Query
+ * @typedef {import('./query').OnDisconnect} OnDisconnect
+ * @typedef {import('./query').ListenOptions} ListenOptions
+ * @typedef {import('./query').Unsubscribe} Unsubscribe
+ * @typedef {import('./query').EventType} EventType
+ * @typedef {import('./query').ThenableReference} ThenableReference
+ */
+
+/**
+ * @implements {IQueryConstraint}
+ */
+class QueryConstraint {
+  constructor(type, ...args) {
+    this._type = type;
+    this._args = args;
+  }
+
+  _apply(query) {
+    return query[this._type].apply(query, this._args);
+  }
+}
+
+/**
+ * @param {number | string | boolean | null} value
+ * @param {string?} key
+ * @returns {QueryConstraint}
+ */
+export function endAt(value, key) {
+  return new QueryConstraint('endAt', value, key);
+}
+
+/**
+ * @param {number | string | boolean | null} value
+ * @param {string?} key
+ * @returns {QueryConstraint}
+ */
+export function endBefore(value, key) {
+  return new QueryConstraint('endBefore', value, key);
+}
+
+/**
+ * @param {number | string | boolean | null} value,
+ * @param {string?} key,
+ * @returns {QueryConstraint}
+ */
+export function startAt(value, key) {
+  return new QueryConstraint('startAt', value, key);
+}
+
+/**
+ * @param {number | string | boolean | null} value,
+ * @param {string?} key,
+ * @returns {QueryConstraint}
+ */
+export function startAfter(value, key) {
+  return new QueryConstraint('startAfter', value, key);
+}
+
+/**
+ * @param {number} limit
+ * @returns {QueryConstraint}
+ */
+export function limitToFirst(limit) {
+  return new QueryConstraint('limitToFirst', limit);
+}
+
+/**
+ * @param {number} limit
+ * @returns {QueryConstraint}
+ */
+export function limitToLast(limit) {
+  return new QueryConstraint('limitToLast', limit);
+}
+
+/**
+ * @param {string} path
+ * @returns {QueryConstraint}
+ */
+export function orderByChild(path) {
+  return new QueryConstraint('orderByChild', path);
+}
+
+export function orderByKey() {
+  return new QueryConstraint('orderByKey');
+}
+
+export function orderByPriority() {
+  return new QueryConstraint('orderByPriority');
+}
+
+export function orderByValue() {
+  return new QueryConstraint('orderByValue');
+}
+
+/**
+ * @param {number | string | boolean | null} value
+ * @param {string?} key
+ * @returns {QueryConstraint}
+ */
+export function equalTo(value, key) {
+  return new QueryConstraint('equalTo', value, key);
+}
+
+/**
+ * @param {Query} query
+ * @param {QueryConstraint[]} queryConstraints
+ * @returns {Query}
+ */
+export function query(query, ...queryConstraints) {
+  let q = query;
+  for (const queryConstraint of queryConstraints) {
+    q = queryConstraint._apply(q);
+  }
+  return q;
+}
+
+/**
+ * @param {Query} query
+ * @param {EventType} eventType
+ * @param {(snapshot: DataSnapshot) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+function addEventListener(query, eventType, callback, cancelCallbackOrListenOptions, options) {
+  let cancelCallback = cancelCallbackOrListenOptions;
+
+  if (typeof cancelCallbackOrListenOptions === 'object') {
+    cancelCallback = undefined;
+    options = cancelCallbackOrListenOptions;
+  }
+
+  if (options && options.onlyOnce) {
+    const userCallback = callback;
+    callback = snapshot => {
+      query.off(eventType, callback);
+      return userCallback(snapshot);
+    };
+  }
+
+  query.on(eventType, callback, cancelCallback);
+
+  return () => query.off(eventType, callback);
+}
+
+/**
+ * @param {Query} query
+ * @param {(snapshot: DataSnapshot) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions | undefined} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+export function onValue(query, callback, cancelCallbackOrListenOptions, options) {
+  return addEventListener(query, 'value', callback, cancelCallbackOrListenOptions, options);
+}
+
+/**
+ * @param {Query} query
+ * @param {(snapshot: DataSnapshot, previousChildName: string | null) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions | undefined} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+export function onChildAdded(query, callback, cancelCallbackOrListenOptions, options) {
+  return addEventListener(query, 'child_added', callback, cancelCallbackOrListenOptions, options);
+}
+
+/**
+ * @param {Query} query
+ * @param {(snapshot: DataSnapshot, previousChildName: string | null) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions | undefined} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+export function onChildChanged(query, callback, cancelCallbackOrListenOptions, options) {
+  return addEventListener(query, 'child_changed', callback, cancelCallbackOrListenOptions, options);
+}
+
+/**
+ * @param {Query} query
+ * @param {(snapshot: DataSnapshot, previousChildName: string | null) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions | undefined} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+export function onChildMoved(query, callback, cancelCallbackOrListenOptions, options) {
+  return addEventListener(query, 'child_moved', callback, cancelCallbackOrListenOptions, options);
+}
+
+/**
+ * @param {Query} query
+ * @param {(snapshot: DataSnapshot, previousChildName: string | null) => unknown} callback
+ * @param {((error: Error) => unknown) | ListenOptions | undefined} cancelCallbackOrListenOptions
+ * @param {ListenOptions?} options
+ * @returns {Unsubscribe}
+ */
+export function onChildRemoved(query, callback, cancelCallbackOrListenOptions, options) {
+  return addEventListener(query, 'child_removed', callback, cancelCallbackOrListenOptions, options);
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {unknown} value
+ * @returns {Promise<void>}
+ */
+export function set(ref, value) {
+  return ref.set(value);
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {string | number | null} priority
+ * @returns {Promise<void>}
+ */
+export function setPriority(ref, priority) {
+  return ref.setPriority(priority);
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {unknown} value
+ * @param {string | number | null} priority
+ * @returns {Promise<void>}
+ */
+export function setWithPriority(ref, value, priority) {
+  return ref.setWithPriority(value, priority);
+}
+
+/**
+ * @param {Query} query
+ * @returns {DataSnapshot}
+ */
+export function get(query) {
+  return query.once('value');
+}
+
+/**
+ * @param {DatabaseReference} parent
+ * @param {string} path
+ * @returns {DatabaseReference}
+ */
+export function child(parent, path) {
+  return parent.child(path);
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @returns {OnDisconnect}
+ */
+export function onDisconnect(ref) {
+  return ref.onDisconnect();
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {boolean} value
+ * @returns {Promise<void>}
+ */
+export function keepSynced(ref, value) {
+  return ref.keepSynced(value);
+}
+
+/**
+ * @param {DatabaseReference} parent
+ * @param {unknown} value
+ * @returns {ThenableReference}
+ */
+export function push(parent, value) {
+  return parent.push(value);
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @returns {Promise<void>}
+ */
+export function remove(ref) {
+  return ref.remove();
+}
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {object} values
+ * @returns {Promise<void>}
+ */
+export function update(ref, values) {
+  return ref.update(values);
+}

package/lib/modular/transaction.d.ts

@@ -0,0 +1,56 @@
+import { FirebaseDatabaseTypes } from '../../index';
+
+import TransactionResult = FirebaseDatabaseTypes.TransactionResult;
+import DatabaseReference = FirebaseDatabaseTypes.Reference;
+
+export { TransactionResult };
+
+/**
+ * An options object to configure transactions.
+ */
+export interface TransactionOptions {
+  readonly applyLocally?: boolean;
+}
+
+/**
+ * Atomically modifies the data at this location.
+ *
+ * Atomically modify the data at this location. Unlike a normal `set()`, which
+ * just overwrites the data regardless of its previous value, `runTransaction()` is
+ * used to modify the existing value to a new value, ensuring there are no
+ * conflicts with other clients writing to the same location at the same time.
+ *
+ * To accomplish this, you pass `runTransaction()` an update function which is
+ * used to transform the current value into a new value. If another client
+ * writes to the location before your new value is successfully written, your
+ * update function will be called again with the new current value, and the
+ * write will be retried. This will happen repeatedly until your write succeeds
+ * without conflict or you abort the transaction by not returning a value from
+ * your update function.
+ *
+ * Note: Modifying data with `set()` will cancel any pending transactions at
+ * that location, so extreme care should be taken if mixing `set()` and
+ * `runTransaction()` to update the same data.
+ *
+ * Note: When using transactions with Security and Firebase Rules in place, be
+ * aware that a client needs `.read` access in addition to `.write` access in
+ * order to perform a transaction. This is because the client-side nature of
+ * transactions requires the client to read the data in order to transactionally
+ * update it.
+ *
+ * @param ref - The location to atomically modify.
+ * @param transactionUpdate - A developer-supplied function which will be passed
+ * the current data stored at this location (as a JavaScript object). The
+ * function should return the new value it would like written (as a JavaScript
+ * object). If `undefined` is returned (i.e. you return with no arguments) the
+ * transaction will be aborted and the data at this location will not be
+ * modified.
+ * @param options - An options object to configure transactions.
+ * @returns A `Promise` that can optionally be used instead of the `onComplete`
+ * callback to handle success and failure.
+ */
+export function runTransaction(
+  ref: DatabaseReference,
+  transactionUpdate: (currentData: any) => unknown,
+  options?: TransactionOptions,
+): Promise<TransactionResult>;

package/lib/modular/transaction.js

@@ -0,0 +1,15 @@
+/**
+ * @typedef {import('./database').DatabaseReference} DatabaseReference
+ * @typedef {import('./transaction').TransactionOptions} TransactionOptions
+ * @typedef {import('./transaction').TransactionResult} TransactionResult
+ */
+
+/**
+ * @param {DatabaseReference} ref
+ * @param {(options: any) => unknown} transactionUpdate
+ * @param {TransactionOptions?} options
+ * @returns {Promise<TransactionResult>}
+ */
+export function runTransaction(ref, transactionUpdate, options) {
+  return ref.transaction(transactionUpdate, undefined, options && options.applyLocally);
+}

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/database",
-  "version": "18.4.0",
+  "version": "18.6.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - The Firebase Realtime Database is a cloud-hosted database. Data is stored as JSON and synchronized in realtime to every connected client. React Native Firebase provides native integration with the Android & iOS Firebase SDKs, supporting both realtime data sync and offline capabilities.",
   "main": "lib/index.js",
@@ -25,10 +25,10 @@
     "realtome database"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "18.4.0"
+    "@react-native-firebase/app": "18.6.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5f6460a87970d8b6013530de980bc760ddc70f90"
+  "gitHead": "adbbd4171adb1e3c2306da1285520abbaf9313b8"
 }