@react-native-firebase/database 24.1.1 → 25.0.1

package/lib/DatabaseQueryModifiers.ts

@@ -0,0 +1,283 @@
+/*
+ * 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 { isNull, isNumber, isString } from '@react-native-firebase/app/dist/module/common';
+
+const CONSTANTS = {
+  VIEW_FROM_LEFT: 'left',
+  VIEW_FROM_RIGHT: 'right',
+} as const;
+
+type QueryModifierValue = number | string | boolean | null;
+
+export interface DatabaseQueryLimitModifier {
+  id: string;
+  name: 'limitToFirst' | 'limitToLast';
+  type: 'limit';
+  value: number;
+  viewFrom: (typeof CONSTANTS)[keyof typeof CONSTANTS];
+}
+
+export interface DatabaseQueryOrderByModifier {
+  id: string;
+  type: 'orderBy';
+  name: 'orderByChild' | 'orderByKey' | 'orderByPriority' | 'orderByValue';
+  key?: string;
+}
+
+export interface DatabaseQueryFilterModifier {
+  id: string;
+  type: 'filter';
+  name: 'startAt' | 'endAt';
+  value: QueryModifierValue;
+  valueType: 'number' | 'string' | 'boolean' | 'object' | 'null';
+  key?: string;
+}
+
+export type DatabaseQueryModifier =
+  | DatabaseQueryLimitModifier
+  | DatabaseQueryOrderByModifier
+  | DatabaseQueryFilterModifier;
+
+function getFilterValueType(value: QueryModifierValue): DatabaseQueryFilterModifier['valueType'] {
+  if (value === null) {
+    return 'null';
+  }
+
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'string':
+      return 'string';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'object';
+  }
+}
+
+export default class DatabaseQueryModifiers {
+  private _limit: DatabaseQueryLimitModifier | undefined;
+  private _orderBy: DatabaseQueryOrderByModifier | undefined;
+  private _startAt: DatabaseQueryFilterModifier | undefined;
+  private _endAt: DatabaseQueryFilterModifier | undefined;
+  private _modifiers: DatabaseQueryModifier[];
+
+  constructor() {
+    this._limit = undefined;
+    this._orderBy = undefined;
+    this._startAt = undefined;
+    this._endAt = undefined;
+    this._modifiers = [];
+  }
+
+  _copy(): DatabaseQueryModifiers {
+    const newInstance = new DatabaseQueryModifiers();
+    newInstance._limit = this._limit;
+    newInstance._orderBy = this._orderBy;
+    newInstance._startAt = this._startAt;
+    newInstance._endAt = this._endAt;
+    newInstance._modifiers = [...this._modifiers];
+    return newInstance;
+  }
+
+  hasLimit(): boolean {
+    return this._limit !== undefined;
+  }
+
+  isValidLimit(limit: number): boolean {
+    return !isNumber(limit) || Math.floor(limit) !== limit || limit <= 0;
+  }
+
+  limitToFirst(limit: number): DatabaseQueryModifiers {
+    const newLimit: DatabaseQueryLimitModifier = {
+      id: `limit-limitToFirst:${limit}`,
+      name: 'limitToFirst',
+      type: 'limit',
+      value: limit,
+      viewFrom: CONSTANTS.VIEW_FROM_LEFT,
+    };
+
+    this._limit = newLimit;
+    this._modifiers.push(newLimit);
+    return this;
+  }
+
+  limitToLast(limit: number): DatabaseQueryModifiers {
+    const newLimit: DatabaseQueryLimitModifier = {
+      id: `limit-limitToLast:${limit}`,
+      name: 'limitToLast',
+      type: 'limit',
+      value: limit,
+      viewFrom: CONSTANTS.VIEW_FROM_RIGHT,
+    };
+
+    this._limit = newLimit;
+    this._modifiers.push(newLimit);
+    return this;
+  }
+
+  hasOrderBy(): boolean {
+    return this._orderBy !== undefined;
+  }
+
+  orderByChild(path: string): DatabaseQueryModifiers {
+    const newOrder: DatabaseQueryOrderByModifier = {
+      id: `order-orderByChild:${path}`,
+      type: 'orderBy',
+      name: 'orderByChild',
+      key: path,
+    };
+
+    this._orderBy = newOrder;
+    this._modifiers.push(newOrder);
+    return this;
+  }
+
+  orderByKey(): DatabaseQueryModifiers {
+    const newOrder: DatabaseQueryOrderByModifier = {
+      id: 'order-orderByKey',
+      type: 'orderBy',
+      name: 'orderByKey',
+    };
+
+    this._orderBy = newOrder;
+    this._modifiers.push(newOrder);
+    return this;
+  }
+
+  isValidPriority(priority: QueryModifierValue): boolean {
+    return isNumber(priority) || isString(priority) || isNull(priority);
+  }
+
+  orderByPriority(): DatabaseQueryModifiers {
+    const newOrder: DatabaseQueryOrderByModifier = {
+      id: 'order-orderByPriority',
+      type: 'orderBy',
+      name: 'orderByPriority',
+    };
+
+    this._orderBy = newOrder;
+    this._modifiers.push(newOrder);
+    return this;
+  }
+
+  orderByValue(): DatabaseQueryModifiers {
+    const newOrder: DatabaseQueryOrderByModifier = {
+      id: 'order-orderByValue',
+      type: 'orderBy',
+      name: 'orderByValue',
+    };
+
+    this._orderBy = newOrder;
+    this._modifiers.push(newOrder);
+    return this;
+  }
+
+  hasStartAt(): boolean {
+    return this._startAt !== undefined;
+  }
+
+  hasEndAt(): boolean {
+    return this._endAt !== undefined;
+  }
+
+  startAt(value: QueryModifierValue, key?: string): DatabaseQueryModifiers {
+    const newStart: DatabaseQueryFilterModifier = {
+      id: `filter-startAt:${value}:${key || ''}`,
+      type: 'filter',
+      name: 'startAt',
+      value,
+      valueType: getFilterValueType(value),
+      key,
+    };
+
+    this._startAt = newStart;
+    this._modifiers.push(newStart);
+    return this;
+  }
+
+  endAt(value: QueryModifierValue, key?: string): DatabaseQueryModifiers {
+    const newEnd: DatabaseQueryFilterModifier = {
+      id: `filter-endAt:${value}:${key || ''}`,
+      type: 'filter',
+      name: 'endAt',
+      value,
+      valueType: getFilterValueType(value),
+      key,
+    };
+
+    this._endAt = newEnd;
+    this._modifiers.push(newEnd);
+    return this;
+  }
+
+  toArray(): DatabaseQueryModifier[] {
+    return this._modifiers;
+  }
+
+  toString(): string {
+    const sorted = [...this._modifiers].sort((a, b) => a.id.localeCompare(b.id));
+    let key = '{';
+
+    for (let index = 0; index < sorted.length; index++) {
+      const modifier = sorted[index];
+      if (!modifier) {
+        continue;
+      }
+      if (index !== 0) {
+        key += ',';
+      }
+      key += modifier.id;
+    }
+
+    key += '}';
+    return key;
+  }
+
+  validateModifiers(prefix: string): void {
+    if (this._orderBy?.name === 'orderByKey') {
+      if ((this._startAt && !!this._startAt.key) || (this._endAt && !!this._endAt.key)) {
+        throw new Error(
+          `${prefix} When ordering by key, you may only pass a value argument to startAt(), endAt(), or equalTo().`,
+        );
+      }
+    }
+
+    if (this._orderBy?.name === 'orderByKey') {
+      if (
+        (this._startAt && this._startAt.valueType !== 'string') ||
+        (this._endAt && this._endAt.valueType !== 'string')
+      ) {
+        throw new Error(
+          `${prefix} When ordering by key, the value of startAt(), endAt(), or equalTo() must be a string.`,
+        );
+      }
+    }
+
+    if (this._orderBy?.name === 'orderByPriority') {
+      if (
+        (this._startAt && !this.isValidPriority(this._startAt.value)) ||
+        (this._endAt && !this.isValidPriority(this._endAt.value))
+      ) {
+        throw new Error(
+          `${prefix} When ordering by priority, the first value of startAt(), endAt(), or equalTo() must be a valid priority value (null, a number, or a string).`,
+        );
+      }
+    }
+  }
+}

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

@@ -16,6 +16,7 @@
  */
 
 import {
+  createDeprecationProxy,
   generateDatabaseId,
   isBoolean,
   isFunction,
@@ -25,11 +26,10 @@ import {
   isString,
   isUndefined,
   isValidPath,
+  MODULAR_DEPRECATION_ARG,
   pathChild,
   pathParent,
   promiseWithOptionalCallback,
-  createDeprecationProxy,
-  MODULAR_DEPRECATION_ARG,
 } from '@react-native-firebase/app/dist/module/common';
 import DatabaseDataSnapshot from './DatabaseDataSnapshot';
 import DatabaseOnDisconnect from './DatabaseOnDisconnect';
@@ -40,13 +40,39 @@ import DatabaseQueryModifiers from './DatabaseQueryModifiers';
 import DatabaseThenableReference, {
   provideReferenceClass as provideReferenceClassForThenable,
 } from './DatabaseThenableReference';
+import type { DatabaseInternal } from './types/internal';
+import type { FirebaseDatabaseTypes } from './types/namespaced';
+
+const internalRefs = ['.info/connected', '.info/serverTimeOffset'] as const;
+
+type ReferenceWithChildInternal = FirebaseDatabaseTypes.Reference & {
+  child(path: string, deprecationArg?: string): FirebaseDatabaseTypes.Reference;
+};
+
+type ReferenceWithSetInternal = FirebaseDatabaseTypes.Reference & {
+  set(
+    value: unknown,
+    onComplete?: (error: Error | null) => void,
+    deprecationArg?: string,
+  ): Promise<void>;
+};
+
+function apChild(reference: FirebaseDatabaseTypes.Reference): ReferenceWithChildInternal {
+  return reference as ReferenceWithChildInternal;
+}
+
+function apSet(reference: FirebaseDatabaseTypes.Reference): ReferenceWithSetInternal {
+  return reference as ReferenceWithSetInternal;
+}
 
-const internalRefs = ['.info/connected', '.info/serverTimeOffset'];
+export default class DatabaseReference
+  extends DatabaseQuery
+  implements FirebaseDatabaseTypes.Reference
+{
+  readonly _database: DatabaseInternal;
 
-export default class DatabaseReference extends DatabaseQuery {
-  constructor(database, path) {
-    // Validate the reference path
-    if (!internalRefs.includes(path) && !isValidPath(path)) {
+  constructor(database: DatabaseInternal, path: string) {
+    if (!internalRefs.includes(path as (typeof internalRefs)[number]) && !isValidPath(path)) {
       throw new Error(
         'firebase.database() Paths must be non-empty strings and can\'t contain ".", "#", "$", "[", or "]"',
       );
@@ -56,43 +82,32 @@ export default class DatabaseReference extends DatabaseQuery {
     this._database = database;
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference.html#parent
-   */
-  get parent() {
+  get parent(): FirebaseDatabaseTypes.Reference | null {
     const parentPath = pathParent(this.path);
     if (parentPath === null) {
       return null;
     }
-    return createDeprecationProxy(new DatabaseReference(this._database, parentPath));
+    return createDeprecationProxy(
+      new DatabaseReference(this._database, parentPath),
+    ) as FirebaseDatabaseTypes.Reference;
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference.html#root
-   */
-  get root() {
-    return createDeprecationProxy(new DatabaseReference(this._database, '/'));
+  get root(): FirebaseDatabaseTypes.Reference {
+    return createDeprecationProxy(
+      new DatabaseReference(this._database, '/'),
+    ) as FirebaseDatabaseTypes.Reference;
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference.html#child
-   * @param path
-   */
-  child(path) {
+  child(path: string): FirebaseDatabaseTypes.Reference {
     if (!isString(path)) {
       throw new Error("firebase.database().ref().child(*) 'path' must be a string value.");
     }
     return createDeprecationProxy(
       new DatabaseReference(this._database, pathChild(this.path, path)),
-    );
+    ) as FirebaseDatabaseTypes.Reference;
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference.html#set
-   * @param value
-   * @param onComplete
-   */
-  set(value, onComplete) {
+  set(value: any, onComplete?: (error: Error | null) => void): Promise<void> {
     if (isUndefined(value)) {
       throw new Error("firebase.database().ref().set(*) 'value' must be defined.");
     }
@@ -106,12 +121,10 @@ export default class DatabaseReference extends DatabaseQuery {
     return promiseWithOptionalCallback(this._database.native.set(this.path, { value }), onComplete);
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference.html#update
-   * @param values
-   * @param onComplete
-   */
-  update(values, onComplete) {
+  update(
+    values: { [key: string]: any },
+    onComplete?: (error: Error | null) => void,
+  ): Promise<void> {
     if (!isObject(values)) {
       throw new Error("firebase.database().ref().update(*) 'values' must be an object.");
     }
@@ -137,13 +150,11 @@ export default class DatabaseReference extends DatabaseQuery {
     );
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#setwithpriority
-   * @param newVal
-   * @param newPriority
-   * @param onComplete
-   */
-  setWithPriority(newVal, newPriority, onComplete) {
+  setWithPriority(
+    newVal: any,
+    newPriority: string | number | null,
+    onComplete?: (error: Error | null) => void,
+  ): Promise<void> {
     if (isUndefined(newVal)) {
       throw new Error("firebase.database().ref().setWithPriority(*) 'newVal' must be defined.");
     }
@@ -169,11 +180,7 @@ export default class DatabaseReference extends DatabaseQuery {
     );
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#remove
-   * @param onComplete
-   */
-  remove(onComplete) {
+  remove(onComplete?: (error: Error | null) => void): Promise<void> {
     if (!isUndefined(onComplete) && !isFunction(onComplete)) {
       throw new Error(
         "firebase.database().ref().remove(*) 'onComplete' must be a function if provided.",
@@ -183,13 +190,15 @@ export default class DatabaseReference extends DatabaseQuery {
     return promiseWithOptionalCallback(this._database.native.remove(this.path), onComplete);
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#transaction
-   * @param transactionUpdate
-   * @param onComplete
-   * @param applyLocally
-   */
-  transaction(transactionUpdate, onComplete, applyLocally) {
+  transaction(
+    transactionUpdate: (currentData: any) => any | undefined,
+    onComplete?: (
+      error: Error | null,
+      committed: boolean,
+      finalResult: FirebaseDatabaseTypes.DataSnapshot | null,
+    ) => void,
+    applyLocally?: boolean,
+  ): Promise<FirebaseDatabaseTypes.TransactionResult> {
     if (!isFunction(transactionUpdate)) {
       throw new Error(
         "firebase.database().ref().transaction(*) 'transactionUpdate' must be a function.",
@@ -209,7 +218,11 @@ export default class DatabaseReference extends DatabaseQuery {
     }
 
     return new Promise((resolve, reject) => {
-      const onCompleteWrapper = (error, committed, snapshotData) => {
+      const onCompleteWrapper = (
+        error: Error | null,
+        committed: boolean,
+        snapshotData: unknown | null,
+      ) => {
         if (isFunction(onComplete)) {
           if (error) {
             onComplete(error, committed, null);
@@ -217,31 +230,40 @@ export default class DatabaseReference extends DatabaseQuery {
             onComplete(
               null,
               committed,
-              createDeprecationProxy(new DatabaseDataSnapshot(this, snapshotData)),
+              createDeprecationProxy(
+                new DatabaseDataSnapshot(
+                  this,
+                  snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
+                ),
+              ) as FirebaseDatabaseTypes.DataSnapshot,
             );
           }
         }
 
         if (error) {
-          return reject(error);
+          reject(error);
+          return;
         }
-        return resolve({
+
+        resolve({
           committed,
-          snapshot: createDeprecationProxy(new DatabaseDataSnapshot(this, snapshotData)),
+          snapshot: createDeprecationProxy(
+            new DatabaseDataSnapshot(
+              this,
+              snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
+            ),
+          ) as FirebaseDatabaseTypes.DataSnapshot,
         });
       };
 
-      // start the transaction natively
       this._database._transaction.add(this, transactionUpdate, onCompleteWrapper, applyLocally);
     });
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#setpriority
-   * @param priority
-   * @param onComplete
-   */
-  setPriority(priority, onComplete) {
+  setPriority(
+    priority: string | number | null,
+    onComplete?: (error: Error | null) => void,
+  ): Promise<void> {
     if (!isNumber(priority) && !isString(priority) && !isNull(priority)) {
       throw new Error(
         "firebase.database().ref().setPriority(*) 'priority' must be a number, string or null value.",
@@ -260,13 +282,10 @@ export default class DatabaseReference extends DatabaseQuery {
     );
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#push
-   * @param value
-   * @param onComplete
-   * @returns {DatabaseReference}
-   */
-  push(value, onComplete) {
+  push(
+    value?: any,
+    onComplete?: (error: Error | null) => void,
+  ): FirebaseDatabaseTypes.ThenableReference {
     if (!isUndefined(onComplete) && !isFunction(onComplete)) {
       throw new Error(
         "firebase.database().ref().push(_, *) 'onComplete' must be a function if provided.",
@@ -279,32 +298,31 @@ export default class DatabaseReference extends DatabaseQuery {
       return new DatabaseThenableReference(
         this._database,
         pathChild(this.path, id),
-        Promise.resolve(this.child.call(this, id, MODULAR_DEPRECATION_ARG)),
-      );
+        Promise.resolve(apChild(this).child.call(this, id, MODULAR_DEPRECATION_ARG)),
+      ) as unknown as FirebaseDatabaseTypes.ThenableReference;
     }
 
-    const pushRef = this.child.call(this, id, MODULAR_DEPRECATION_ARG);
+    const pushRef = apChild(this).child.call(this, id, MODULAR_DEPRECATION_ARG);
 
-    const promise = pushRef.set
-      .call(pushRef, value, onComplete, MODULAR_DEPRECATION_ARG)
+    const promise = apSet(pushRef)
+      .set.call(pushRef, value, onComplete, MODULAR_DEPRECATION_ARG)
       .then(() => pushRef);
 
-    // Prevent unhandled promise rejection if onComplete is passed
     if (onComplete) {
       promise.catch(() => {});
     }
 
-    return new DatabaseThenableReference(this._database, pathChild(this.path, id), promise);
+    return new DatabaseThenableReference(
+      this._database,
+      pathChild(this.path, id),
+      promise,
+    ) as unknown as FirebaseDatabaseTypes.ThenableReference;
   }
 
-  /**
-   * @url https://firebase.google.com/docs/reference/js/firebase.database.Reference#ondisconnect
-   */
-  onDisconnect() {
+  onDisconnect(): FirebaseDatabaseTypes.OnDisconnect {
     return new DatabaseOnDisconnect(this);
   }
 }
 
-// To avoid React Native require cycle warnings
 provideReferenceClassForQuery(DatabaseReference);
 provideReferenceClassForThenable(DatabaseReference);

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

@@ -15,12 +15,12 @@
  *
  */
 
-export default {
+const DatabaseStatics = {
   ServerValue: {
     TIMESTAMP: {
       '.sv': 'timestamp',
     },
-    increment(delta) {
+    increment(delta: number): object {
       return {
         '.sv': {
           increment: delta,
@@ -29,3 +29,5 @@ export default {
     },
   },
 };
+
+export default DatabaseStatics;