@react-native-firebase/database 24.1.1 → 25.0.1

package/lib/types/internal.ts

@@ -0,0 +1,317 @@
+/*
+ * 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 type { ReactNativeFirebase } from '@react-native-firebase/app';
+import type {
+  DataSnapshot,
+  Database,
+  DatabaseReference,
+  EventType,
+  EmulatorMockTokenOptions,
+  ListenOptions,
+  OnDisconnect,
+  Query,
+  QueryConstraint,
+  QueryConstraintType,
+  ThenableReference,
+  TransactionResult,
+} from './database';
+import type { FirebaseDatabaseTypes } from './namespaced';
+import type { DatabaseQueryModifier } from '../DatabaseQueryModifiers';
+
+/** Optional final argument passed by modular API wrappers (MODULAR_DEPRECATION_ARG). */
+export type DatabaseModularDeprecationArg = string;
+
+/** App instance with database() method (e.g. from getApp() when used for getDatabase()). */
+export interface AppWithDatabaseInternal {
+  database(url?: string): Database;
+}
+
+/** Public database instance viewed through the modular wrapper methods. */
+export interface DatabaseWithMethodsInternal extends Database {
+  useEmulator(
+    host: string,
+    port: number,
+    options?: { mockUserToken?: EmulatorMockTokenOptions | string },
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): unknown;
+  goOffline(deprecationArg?: DatabaseModularDeprecationArg): unknown;
+  goOnline(deprecationArg?: DatabaseModularDeprecationArg): unknown;
+  ref(path?: string, deprecationArg?: DatabaseModularDeprecationArg): DatabaseReference;
+  refFromURL(url: string, deprecationArg?: DatabaseModularDeprecationArg): DatabaseReference;
+  setPersistenceEnabled(enabled: boolean, deprecationArg?: DatabaseModularDeprecationArg): unknown;
+  setLoggingEnabled(enabled: boolean, deprecationArg?: DatabaseModularDeprecationArg): unknown;
+  setPersistenceCacheSizeBytes(
+    bytes: number,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): unknown;
+  getServerTime(deprecationArg?: DatabaseModularDeprecationArg): Date;
+}
+
+/** Native emitter subscription returned by addListener. */
+export interface DatabaseEmitterSubscriptionInternal {
+  remove(): void;
+}
+
+/** Serialized database snapshot payload received from native or web fallback modules. */
+export interface DatabaseSnapshotInternal {
+  value: unknown;
+  key: string | null;
+  exists: boolean;
+  hasChildren?: boolean;
+  childrenCount?: number;
+  childKeys: string[];
+  priority?: string | number | null;
+  childPriorities?: Record<string, string | number | null | undefined>;
+}
+
+/** Child-event payload received from native once/on listeners. */
+export interface DatabaseChildSnapshotResultInternal {
+  snapshot: DatabaseSnapshotInternal;
+  previousChildName?: string | null;
+}
+
+/** Query listener registration bookkeeping passed to native. */
+export interface DatabaseListenRegistrationInternal {
+  eventRegistrationKey: string;
+  key: string;
+  registrationCancellationKey?: string;
+}
+
+/** Query subscription payload passed to native. */
+export interface DatabaseListenPropsInternal {
+  key: string;
+  modifiers: DatabaseQueryModifier[];
+  path: string;
+  eventType: EventType;
+  registration: DatabaseListenRegistrationInternal;
+}
+
+/** Transaction commit payload sent to native. */
+export interface DatabaseTransactionUpdatesInternal {
+  value: unknown;
+  abort: boolean;
+}
+
+/** Transaction bridge event payload received from native. */
+export interface DatabaseTransactionEventInternal {
+  id: number;
+  body:
+    | {
+        type: 'update';
+        value?: unknown;
+      }
+    | {
+        type: 'error';
+        error?: unknown;
+      }
+    | {
+        type: 'complete';
+        committed?: boolean;
+        snapshot?: DatabaseSnapshotInternal;
+      }
+    | {
+        type: string;
+        [key: string]: unknown;
+      };
+}
+
+/** Shared emitter shape used by database transaction listeners. */
+export interface DatabaseEventEmitterInternal {
+  addListener(
+    eventName: string,
+    listener: (event: DatabaseTransactionEventInternal) => void,
+  ): DatabaseEmitterSubscriptionInternal;
+}
+
+/** Wrapped native module interface for database. */
+export interface RNFBDatabaseModule {
+  goOnline(): Promise<void>;
+  goOffline(): Promise<void>;
+  setPersistenceEnabled(enabled: boolean): Promise<void>;
+  setLoggingEnabled(enabled: boolean): Promise<void>;
+  setPersistenceCacheSizeBytes(bytes: number): Promise<void>;
+  useEmulator(host: string, port: number): void | Promise<void>;
+  set(path: string, props: { value: unknown }): Promise<void>;
+  update(path: string, props: { values: Record<string, unknown> }): Promise<void>;
+  setWithPriority(
+    path: string,
+    props: { value: unknown; priority: string | number | null },
+  ): Promise<void>;
+  remove(path: string): Promise<void>;
+  setPriority(path: string, props: { priority: string | number | null }): Promise<void>;
+  once(
+    path: string,
+    modifiers: DatabaseQueryModifier[],
+    eventType: FirebaseDatabaseTypes.EventType,
+  ): Promise<DatabaseSnapshotInternal | DatabaseChildSnapshotResultInternal>;
+  on(props: DatabaseListenPropsInternal): void;
+  off(queryKey: string, eventRegistrationKey: string): void | Promise<void>;
+  keepSynced(
+    queryKey: string,
+    path: string,
+    modifiers: DatabaseQueryModifier[],
+    value: boolean,
+  ): Promise<void>;
+  onDisconnectCancel(path: string): Promise<void>;
+  onDisconnectRemove(path: string): Promise<void>;
+  onDisconnectSet(path: string, props: { value: unknown }): Promise<void>;
+  onDisconnectSetWithPriority(
+    path: string,
+    props: { value: unknown; priority: string | number | null },
+  ): Promise<void>;
+  onDisconnectUpdate(path: string, props: { values: Record<string, unknown> }): Promise<void>;
+  transactionStart(
+    path: string,
+    id: number,
+    applyLocally: boolean,
+    userExecutor?: (currentData: unknown) => unknown,
+  ): void | Promise<void>;
+  transactionTryCommit(
+    id: number,
+    updates: DatabaseTransactionUpdatesInternal,
+  ): void | Promise<void>;
+}
+
+declare module '@react-native-firebase/app/dist/module/internal/NativeModules' {
+  interface ReactNativeFirebaseNativeModules {
+    RNFBDatabaseModule: RNFBDatabaseModule;
+  }
+}
+
+/** Legacy DatabaseReference shape needed by namespaced/runtime helpers before full TS port. */
+export interface DatabaseReferenceInternal {
+  readonly path: string;
+  on(
+    eventType: FirebaseDatabaseTypes.EventType,
+    callback: (data: FirebaseDatabaseTypes.DataSnapshot, previousChildKey?: string | null) => void,
+    cancelCallbackOrContext?:
+      | ((a: Error) => void)
+      | Record<string, any>
+      | DatabaseModularDeprecationArg
+      | null,
+    context?: Record<string, any> | null,
+  ): (a: FirebaseDatabaseTypes.DataSnapshot | null, b?: string | null) => void;
+}
+
+/** Query instance viewed through the chainable query modifier methods. */
+export type QueryWithModifiersInternal = Query &
+  Record<QueryConstraintType, (...args: Array<unknown>) => Query>;
+
+/** Query instance viewed through the subscription helpers used by modular wrappers. */
+export interface QueryWithSubscriptionMethodsInternal extends Query {
+  on(
+    eventType: EventType,
+    callback: (snapshot: DataSnapshot, previousChildName?: string | null) => unknown,
+    cancelCallbackOrContext?:
+      | ((error: Error) => unknown)
+      | ListenOptions
+      | DatabaseModularDeprecationArg,
+    context?: ListenOptions | null,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): unknown;
+  off(
+    eventType?: EventType,
+    callback?: (snapshot: DataSnapshot, previousChildName?: string | null) => unknown,
+    context?: null,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): void;
+  once(
+    eventType: EventType,
+    successCallback?: (snapshot: DataSnapshot, previousChildName?: string | null) => unknown,
+    failureCallbackContext?: ((error: Error) => void) | null,
+    context?: ListenOptions,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): Promise<DataSnapshot>;
+}
+
+/** Query constraint instance that can apply itself to a query. */
+export interface QueryConstraintWithApplyInternal extends QueryConstraint {
+  _apply(query: Query): Query;
+}
+
+/** Database reference viewed through the mutating modular helpers. */
+export interface DatabaseReferenceWithMethodsInternal extends DatabaseReference {
+  set(
+    value: unknown,
+    onComplete?: () => void,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): Promise<void>;
+  setPriority(
+    priority: string | number | null,
+    onComplete?: () => void,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): Promise<void>;
+  setWithPriority(
+    value: unknown,
+    priority: string | number | null,
+    onComplete?: () => void,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): Promise<void>;
+  child(path: string, deprecationArg?: DatabaseModularDeprecationArg): DatabaseReference;
+  onDisconnect(deprecationArg?: DatabaseModularDeprecationArg): OnDisconnect;
+  keepSynced(value: boolean, deprecationArg?: DatabaseModularDeprecationArg): Promise<void>;
+  push(
+    value?: unknown,
+    onComplete?: undefined,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): ThenableReference;
+  remove(deprecationArg?: DatabaseModularDeprecationArg): Promise<void>;
+  update(values: object, deprecationArg?: DatabaseModularDeprecationArg): Promise<void>;
+}
+
+/** Minimal transaction handler contract used by DatabaseReference and namespaced module. */
+export interface DatabaseTransactionInternal {
+  add(
+    reference: DatabaseReferenceInternal,
+    transactionUpdater: (currentData: unknown) => unknown,
+    onComplete: (error: Error | null, committed: boolean, snapshot: unknown | null) => void,
+    applyLocally?: boolean,
+  ): void;
+}
+
+/** Namespaced database instance with typed native and transaction bridge. */
+export interface DatabaseModuleInternal {
+  readonly native: RNFBDatabaseModule;
+  readonly emitter: DatabaseEventEmitterInternal;
+  readonly app: ReactNativeFirebase.FirebaseApp;
+  readonly type: 'database';
+  readonly firebaseJson: Record<string, unknown>;
+  eventNameForApp(...args: Array<string | number>): string;
+  _serverTimeOffset: number;
+  _customUrlOrRegion: string | null;
+  _transaction: DatabaseTransactionInternal;
+}
+
+/** Public database module instance plus internal bridge fields. */
+export interface DatabaseInternal extends Database, DatabaseModuleInternal {}
+
+/** Database reference viewed through the transaction modular helper. */
+export interface DatabaseReferenceWithTransactionInternal extends DatabaseReference {
+  transaction(
+    transactionUpdate: (currentData: any) => unknown,
+    onComplete?: undefined,
+    applyLocally?: boolean,
+    deprecationArg?: DatabaseModularDeprecationArg,
+  ): Promise<TransactionResult>;
+}
+
+/** Runtime ServerValue object shape used by modular wrappers. */
+export interface ServerValueStaticInternal {
+  TIMESTAMP: object;
+  increment(delta: number, deprecationArg?: DatabaseModularDeprecationArg): object;
+}

package/lib/{index.d.ts → types/namespaced.ts}

@@ -53,12 +53,20 @@ import { ReactNativeFirebase } from '@react-native-firebase/app';
  *
  * @firebase database
  */
+/**
+ * @deprecated Use the exported types directly instead.
+ * FirebaseDatabaseTypes namespace is kept for backwards compatibility.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace FirebaseDatabaseTypes {
   import FirebaseModule = ReactNativeFirebase.FirebaseModule;
 
   /**
    * The ServerValue interface provides access to Firebase server values.
    */
+  /**
+   * @deprecated Use the exported `ServerValue` type instead.
+   */
   export interface ServerValue {
     /**
      * A placeholder value for auto-populating the current timestamp (time since the Unix epoch,
@@ -99,6 +107,9 @@ export namespace FirebaseDatabaseTypes {
    * firebase.database;
    * ```
    */
+  /**
+   * @deprecated Use the exported runtime/statics directly instead.
+   */
   export interface Statics {
     /**
      * Returns server specific values, such as the server timestamp.
@@ -113,6 +124,9 @@ export namespace FirebaseDatabaseTypes {
     SDK_VERSION: string;
   }
 
+  /**
+   * @deprecated Use the exported `TransactionResult` type instead.
+   */
   export interface TransactionResult {
     committed: boolean;
     snapshot: DataSnapshot;
@@ -125,6 +139,9 @@ export namespace FirebaseDatabaseTypes {
    * You can reference the root or child location in your Database by calling `firebase.database().ref()`
    * or `firebase.database().ref("child/path")`.
    */
+  /**
+   * @deprecated Use the exported `DatabaseReference` type instead.
+   */
   export interface Reference extends Query {
     /**
      * The parent location of a Reference. The parent of a root Reference is `null`.
@@ -379,7 +396,11 @@ export namespace FirebaseDatabaseTypes {
      */
     transaction(
       transactionUpdate: (currentData: any) => any | undefined,
-      onComplete?: (error: Error | null, committed: boolean, finalResult: DataSnapshot) => void,
+      onComplete?: (
+        error: Error | null,
+        committed: boolean,
+        finalResult: DataSnapshot | null,
+      ) => void,
       applyLocally?: boolean,
     ): Promise<TransactionResult>;
 
@@ -410,7 +431,7 @@ export namespace FirebaseDatabaseTypes {
      * @param value Optional value to be written at the generated location.
      * @param onComplete Callback called when write to server is complete.
      */
-    push(value?: any, onComplete?: () => void): ThenableReference;
+    push(value?: any, onComplete?: (error: Error | null) => void): ThenableReference;
 
     /**
      * Returns an {@link OnDisconnect} instance.
@@ -426,7 +447,11 @@ export namespace FirebaseDatabaseTypes {
     onDisconnect(): OnDisconnect;
   }
 
-  export type ThenableReference = Reference;
+  /**
+   * @deprecated Use the exported `ThenableReference` type instead.
+   */
+  export interface ThenableReference
+    extends Reference, Pick<Promise<Reference>, 'then' | 'catch'> {}
 
   /**
    * A Query sorts and filters the data at a Database location so only a subset of the child data
@@ -438,6 +463,9 @@ export namespace FirebaseDatabaseTypes {
    * Just as with a `Reference`, you can receive data from a Query by using the on() method. You will
    * only receive events and `DataSnapshot`s for the subset of the data that matches your query.
    */
+  /**
+   * @deprecated Use the exported `Query` type instead.
+   */
   export interface Query {
     /**
      * Returns a Reference to the Query's location.
@@ -783,7 +811,7 @@ export namespace FirebaseDatabaseTypes {
     /**
      * Returns a JSON-serializable representation of this object.
      */
-    toJSON(): object;
+    toJSON(): string;
 
     /**
      * Gets the absolute URL for this location.
@@ -837,6 +865,9 @@ export namespace FirebaseDatabaseTypes {
    * Note that `onDisconnect` operations are only triggered once. If you want an operation to occur each time a
    * disconnect occurs, you'll need to re-establish the `onDisconnect` operations each time you reconnect.
    */
+  /**
+   * @deprecated Use the exported `OnDisconnect` type instead.
+   */
   export interface OnDisconnect {
     /**
      * Cancels all previously queued `onDisconnect()` set or update events for this location and all children.
@@ -932,6 +963,9 @@ export namespace FirebaseDatabaseTypes {
     ): Promise<void>;
   }
 
+  /**
+   * @deprecated Use the exported `EventType` type instead.
+   */
   export type EventType =
     | 'value'
     | 'child_added'
@@ -947,6 +981,9 @@ export namespace FirebaseDatabaseTypes {
    * of the snapshot as a JavaScript object by calling the val() method. Alternatively, you can traverse
    * into the snapshot by calling `child()` to return child snapshots (which you could then call `val()` on).
    */
+  /**
+   * @deprecated Use the exported `DataSnapshot` type instead.
+   */
   export interface DataSnapshot {
     /**
      * The key (last part of the path) of the location of this `DataSnapshot`.
@@ -1026,7 +1063,7 @@ export namespace FirebaseDatabaseTypes {
      *
      * @param action A function that will be called for each child DataSnapshot. The callback can return true to cancel further enumeration.
      */
-    forEach(action: (child: DataSnapshot) => true | undefined): boolean;
+    forEach(action: (child: DataSnapshot) => boolean | void): boolean;
 
     /**
      * Gets the priority value of the data in this DataSnapshot.
@@ -1113,7 +1150,10 @@ export namespace FirebaseDatabaseTypes {
    * ```
    *
    */
-  export class Module extends FirebaseModule {
+  /**
+   * @deprecated Use the exported `Database` type and modular API instead.
+   */
+  export declare class Module extends FirebaseModule {
     /**
      * The current `FirebaseApp` instance for this Firebase service.
      */
@@ -1296,21 +1336,20 @@ type DatabaseNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
 
 declare const defaultExport: DatabaseNamespace;
 
-export const firebase: ReactNativeFirebase.Module & {
+export declare const firebase: ReactNativeFirebase.Module & {
   database: typeof defaultExport;
   app(
     name?: string,
   ): ReactNativeFirebase.FirebaseApp & { database(): FirebaseDatabaseTypes.Module };
 };
 
-export * from './modular';
-
 export default defaultExport;
 
 /**
  * Attach namespace to `firebase.` and `FirebaseApp.`.
  */
 declare module '@react-native-firebase/app' {
+  // eslint-disable-next-line @typescript-eslint/no-namespace -- module augmentation uses namespace
   namespace ReactNativeFirebase {
     import FirebaseModuleWithStaticsAndApp = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp;
     interface Module {

package/lib/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '25.0.1';

package/lib/web/RNFBDatabaseModule.android.ts

@@ -0,0 +1,4 @@
+// No-op for android.
+const databaseAndroidFallbackModule: Record<string, never> = {};
+
+export default databaseAndroidFallbackModule;

package/lib/web/RNFBDatabaseModule.ios.ts

@@ -0,0 +1,4 @@
+// No-op for ios.
+const databaseIosFallbackModule: Record<string, never> = {};
+
+export default databaseIosFallbackModule;