@react-native-firebase/database 24.1.1 → 25.0.1

package/lib/web/RNFBDatabaseModule.ts

@@ -0,0 +1,534 @@
+import {
+  connectDatabaseEmulator,
+  enableLogging,
+  get,
+  getApp,
+  getDatabase,
+  goOffline,
+  goOnline,
+  onChildAdded,
+  onChildChanged,
+  onChildMoved,
+  onChildRemoved,
+  onDisconnect,
+  onValue,
+  ref,
+  remove,
+  runTransaction,
+  set,
+  setPriority,
+  setWithPriority,
+  update,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseDatabase';
+import {
+  emitEvent,
+  getWebError,
+  guard,
+} from '@react-native-firebase/app/dist/module/internal/web/utils';
+import { getQueryInstance } from './query';
+import type { DatabaseQueryModifier } from '../DatabaseQueryModifiers';
+import type {
+  DatabaseListenPropsInternal,
+  DatabaseSnapshotInternal,
+  DatabaseTransactionUpdatesInternal,
+} from '../types/internal';
+
+type WebApp = ReturnType<typeof getApp>;
+type WebDatabase = ReturnType<typeof getDatabase>;
+type WebDatabaseReference = ReturnType<typeof ref>;
+type WebDataSnapshot = Awaited<ReturnType<typeof get>>;
+type WebOnDisconnect = ReturnType<typeof onDisconnect>;
+type WebUnsubscribe = ReturnType<typeof onValue>;
+
+type DatabaseOperationPropsInternal =
+  | { value: unknown }
+  | { values: Record<string, unknown> }
+  | { value: unknown; priority: string | number | null }
+  | { priority: string | number | null };
+
+function rejectWithCodeAndMessage(code: string, message: string): Promise<never> {
+  const error = new Error(message) as Error & { code?: string };
+  error.code = code;
+  return Promise.reject(getWebError(error));
+}
+
+function snapshotToObject(snapshot: WebDataSnapshot): DatabaseSnapshotInternal {
+  const childKeys: string[] = [];
+
+  if (snapshot.hasChildren()) {
+    snapshot.forEach((childSnapshot: WebDataSnapshot) => {
+      if (typeof childSnapshot.key === 'string') {
+        childKeys.push(childSnapshot.key);
+      }
+    });
+  }
+
+  return {
+    key: snapshot.key,
+    exists: snapshot.exists(),
+    hasChildren: snapshot.hasChildren(),
+    childrenCount: snapshot.size,
+    childKeys,
+    priority: snapshot.priority,
+    value: snapshot.val(),
+  };
+}
+
+function getDatabaseWebError(error: unknown): unknown {
+  return getWebError(error as Error & { code?: string });
+}
+
+function snapshotWithPreviousChildToObject(
+  snapshot: WebDataSnapshot,
+  previousChildName: string | null,
+): { snapshot: DatabaseSnapshotInternal; previousChildName: string | null } {
+  return {
+    snapshot: snapshotToObject(snapshot),
+    previousChildName,
+  };
+}
+
+type SnapshotWithPreviousChildInternal = {
+  snapshot: WebDataSnapshot;
+  previousChildName: string | null;
+};
+
+const appInstances: Record<string, WebApp> = {};
+const databaseInstances: Record<string, WebDatabase> = {};
+const onDisconnectRef: Record<string, WebOnDisconnect> = {};
+const listeners: Record<string, WebUnsubscribe> = {};
+const emulatorForApp: Record<string, { host: string; port: number; connected?: boolean }> = {};
+
+function getCachedAppInstance(appName: string): WebApp {
+  return (appInstances[appName] ??= getApp(appName));
+}
+
+function getCachedDatabaseInstance(appName: string, dbURL: string): WebDatabase {
+  let instance = databaseInstances[`${appName}|${dbURL}`];
+  if (!instance) {
+    instance = getDatabase(getCachedAppInstance(appName), dbURL);
+    if (
+      emulatorForApp[appName] &&
+      !('_instanceStarted' in (instance as object)) &&
+      emulatorForApp[appName]
+    ) {
+      const { host, port } = emulatorForApp[appName];
+      connectDatabaseEmulator(instance, host, port);
+      emulatorForApp[appName].connected = true;
+    }
+  }
+  return instance;
+}
+
+function getCachedOnDisconnectInstance(refValue: WebDatabaseReference): WebOnDisconnect {
+  const cacheKey = String(refValue.key);
+  return (onDisconnectRef[cacheKey] ??= onDisconnect(refValue));
+}
+
+const databaseFallbackModule: Record<string, unknown> = {
+  goOnline(appName: string, dbURL: string): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      goOnline(db);
+    });
+  },
+
+  goOffline(appName: string, dbURL: string): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      goOffline(db);
+    });
+  },
+
+  setPersistenceEnabled(): Promise<void> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'The Firebase Database `setPersistenceEnabled` method is not available in the this environment.',
+      );
+    }
+    return Promise.resolve();
+  },
+
+  setLoggingEnabled(_app: string, _dbURL: string, enabled: boolean): Promise<void> {
+    return guard(async () => {
+      enableLogging(enabled);
+    });
+  },
+
+  setPersistenceCacheSizeBytes(): Promise<void> {
+    return Promise.resolve();
+  },
+
+  useEmulator(appName: string, dbURL: string, host: string, port: number): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      connectDatabaseEmulator(db, host, port);
+      emulatorForApp[appName] = { host, port };
+    });
+  },
+
+  set(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      await set(dbRef, (props as { value: unknown }).value);
+    });
+  },
+
+  update(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      await update(dbRef, (props as { values: Record<string, unknown> }).values);
+    });
+  },
+
+  setWithPriority(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const { value, priority } = props as { value: unknown; priority: string | number | null };
+      await setWithPriority(dbRef, value, priority);
+    });
+  },
+
+  remove(appName: string, dbURL: string, path: string): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      await remove(dbRef);
+    });
+  },
+
+  setPriority(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      await setPriority(dbRef, (props as { priority: string | number | null }).priority);
+    });
+  },
+
+  once(
+    appName: string,
+    dbURL: string,
+    path: string,
+    modifiers: DatabaseQueryModifier[],
+    eventType: string,
+  ): Promise<unknown> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const queryRef = getQueryInstance(dbRef, modifiers);
+
+      if (eventType === 'value') {
+        const snapshot = await new Promise<WebDataSnapshot>((resolve, reject) => {
+          onValue(queryRef, resolve, reject, { onlyOnce: true });
+        });
+
+        return snapshotToObject(snapshot);
+      }
+
+      if (eventType === 'child_added') {
+        const { snapshot, previousChildName } =
+          await new Promise<SnapshotWithPreviousChildInternal>((resolve, reject) => {
+            onChildAdded(
+              queryRef,
+              (childSnapshot, childPreviousChildName) => {
+                resolve({
+                  snapshot: childSnapshot,
+                  previousChildName: childPreviousChildName,
+                });
+              },
+              reject,
+              { onlyOnce: true },
+            );
+          });
+
+        return snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null);
+      }
+
+      if (eventType === 'child_changed') {
+        const { snapshot, previousChildName } =
+          await new Promise<SnapshotWithPreviousChildInternal>((resolve, reject) => {
+            onChildChanged(
+              queryRef,
+              (childSnapshot, childPreviousChildName) => {
+                resolve({
+                  snapshot: childSnapshot,
+                  previousChildName: childPreviousChildName,
+                });
+              },
+              reject,
+              { onlyOnce: true },
+            );
+          });
+
+        return snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null);
+      }
+
+      if (eventType === 'child_removed') {
+        const snapshot = await new Promise<WebDataSnapshot>((resolve, reject) => {
+          onChildRemoved(queryRef, resolve, reject, { onlyOnce: true });
+        });
+
+        return snapshotWithPreviousChildToObject(snapshot, null);
+      }
+
+      if (eventType === 'child_moved') {
+        const { snapshot, previousChildName } =
+          await new Promise<SnapshotWithPreviousChildInternal>((resolve, reject) => {
+            onChildMoved(
+              queryRef,
+              (childSnapshot, childPreviousChildName) => {
+                resolve({
+                  snapshot: childSnapshot,
+                  previousChildName: childPreviousChildName,
+                });
+              },
+              reject,
+              { onlyOnce: true },
+            );
+          });
+
+        return snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null);
+      }
+
+      const snapshot = await get(dbRef);
+      return snapshotToObject(snapshot);
+    });
+  },
+
+  on(appName: string, dbURL: string, props: DatabaseListenPropsInternal): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const { key, modifiers, path, eventType, registration } = props;
+      const { eventRegistrationKey } = registration;
+      const dbRef = ref(db, path);
+      const queryRef = getQueryInstance(dbRef, modifiers);
+
+      function sendEvent(data: unknown): void {
+        emitEvent('database_sync_event', {
+          eventName: 'database_sync_event',
+          body: {
+            data,
+            key,
+            registration,
+            eventType,
+          },
+        });
+      }
+
+      function sendError(error: unknown): void {
+        emitEvent('database_sync_event', {
+          eventName: 'database_sync_event',
+          body: {
+            key,
+            registration,
+            error: getDatabaseWebError(error),
+          },
+        });
+      }
+
+      let listener: WebUnsubscribe | null = null;
+
+      if (listeners[eventRegistrationKey]) {
+        return;
+      }
+
+      if (eventType === 'value') {
+        listener = onValue(queryRef, snapshot => sendEvent(snapshotToObject(snapshot)), sendError);
+      } else if (eventType === 'child_added') {
+        listener = onChildAdded(
+          queryRef,
+          (snapshot, previousChildName) => {
+            sendEvent(snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null));
+          },
+          sendError,
+        );
+      } else if (eventType === 'child_changed') {
+        listener = onChildChanged(
+          queryRef,
+          (snapshot, previousChildName) => {
+            sendEvent(snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null));
+          },
+          sendError,
+        );
+      } else if (eventType === 'child_removed') {
+        listener = onChildRemoved(
+          queryRef,
+          snapshot => {
+            sendEvent(snapshotWithPreviousChildToObject(snapshot, null));
+          },
+          sendError,
+        );
+      } else if (eventType === 'child_moved') {
+        listener = onChildMoved(
+          queryRef,
+          (snapshot, previousChildName) => {
+            sendEvent(snapshotWithPreviousChildToObject(snapshot, previousChildName ?? null));
+          },
+          sendError,
+        );
+      }
+
+      if (listener) {
+        listeners[eventRegistrationKey] = listener;
+      }
+    });
+  },
+
+  off(_queryKey: string, eventRegistrationKey: string): void {
+    const listener = listeners[eventRegistrationKey];
+    if (listener) {
+      listener();
+      delete listeners[eventRegistrationKey];
+    }
+  },
+
+  keepSynced(): Promise<never> {
+    return rejectWithCodeAndMessage(
+      'unsupported',
+      'This operation is not supported on this environment.',
+    );
+  },
+
+  onDisconnectCancel(appName: string, dbURL: string, path: string): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.cancel();
+      delete onDisconnectRef[String(dbRef.key)];
+    });
+  },
+
+  onDisconnectRemove(appName: string, dbURL: string, path: string): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.remove();
+    });
+  },
+
+  onDisconnectSet(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.set((props as { value: unknown }).value);
+    });
+  },
+
+  onDisconnectSetWithPriority(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      const { value, priority } = props as { value: unknown; priority: string | number | null };
+      await instance.setWithPriority(value, priority);
+    });
+  },
+
+  onDisconnectUpdate(
+    appName: string,
+    dbURL: string,
+    path: string,
+    props: DatabaseOperationPropsInternal,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+      const instance = getCachedOnDisconnectInstance(dbRef);
+      await instance.update((props as { values: Record<string, unknown> }).values);
+    });
+  },
+
+  transactionStart(
+    appName: string,
+    dbURL: string,
+    path: string,
+    transactionId: number,
+    applyLocally: boolean,
+    userExecutor?: (currentData: unknown) => unknown,
+  ): Promise<void> {
+    return guard(async () => {
+      const db = getCachedDatabaseInstance(appName, dbURL);
+      const dbRef = ref(db, path);
+
+      try {
+        const { committed, snapshot } = await runTransaction(
+          dbRef,
+          userExecutor ?? (data => data),
+          {
+            applyLocally,
+          },
+        );
+
+        emitEvent('database_transaction_event', {
+          body: {
+            committed,
+            type: 'complete',
+            snapshot: snapshotToObject(snapshot),
+          },
+          appName,
+          id: transactionId,
+          eventName: 'database_transaction_event',
+        });
+      } catch (e) {
+        emitEvent('database_transaction_event', {
+          body: {
+            committed: false,
+            type: 'error',
+            error: getDatabaseWebError(e),
+          },
+          appName,
+          id: transactionId,
+          eventName: 'database_transaction_event',
+        });
+      }
+    });
+  },
+
+  async transactionTryCommit(
+    _appName: string,
+    _dbURL: string,
+    _transactionId: string,
+    _updates: DatabaseTransactionUpdatesInternal,
+  ): Promise<never> {
+    throw new Error('Not implemented');
+  },
+};
+
+export default databaseFallbackModule;

package/lib/web/query.ts

@@ -0,0 +1,97 @@
+import {
+  endAt,
+  endBefore,
+  limitToFirst,
+  limitToLast,
+  orderByChild,
+  orderByKey,
+  orderByPriority,
+  orderByValue,
+  query,
+  startAfter,
+  startAt,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseDatabase';
+import type { DatabaseQueryModifier } from '../DatabaseQueryModifiers';
+
+type WebDatabaseReference = Parameters<typeof query>[0];
+type WebQueryConstraint = Parameters<typeof query>[1];
+type QueryFilterValue = number | string | boolean | null;
+type WebDatabaseQueryModifier =
+  | DatabaseQueryModifier
+  | {
+      type: 'filter';
+      name: 'endBefore' | 'startAfter';
+      value: QueryFilterValue;
+      key?: string;
+    };
+
+function isQueryFilterValue(value: unknown): value is QueryFilterValue {
+  return (
+    typeof value === 'number' ||
+    typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    value === null
+  );
+}
+
+export function getQueryInstance(
+  dbRef: WebDatabaseReference,
+  modifiers: WebDatabaseQueryModifier[],
+): ReturnType<typeof query> {
+  const constraints: WebQueryConstraint[] = [];
+
+  for (const modifier of modifiers) {
+    const { type, name } = modifier;
+
+    if (type === 'orderBy') {
+      switch (name) {
+        case 'orderByKey':
+          constraints.push(orderByKey());
+          break;
+        case 'orderByPriority':
+          constraints.push(orderByPriority());
+          break;
+        case 'orderByValue':
+          constraints.push(orderByValue());
+          break;
+        case 'orderByChild':
+          constraints.push(orderByChild(modifier.key ?? ''));
+          break;
+      }
+    }
+
+    if (type === 'limit') {
+      const { value } = modifier;
+
+      switch (name) {
+        case 'limitToLast':
+          constraints.push(limitToLast(value));
+          break;
+        case 'limitToFirst':
+          constraints.push(limitToFirst(value));
+          break;
+      }
+    }
+
+    if (type === 'filter' && isQueryFilterValue(modifier.value)) {
+      const { key, value } = modifier;
+
+      switch (name) {
+        case 'endAt':
+          constraints.push(endAt(value, key));
+          break;
+        case 'endBefore':
+          constraints.push(endBefore(value, key));
+          break;
+        case 'startAt':
+          constraints.push(startAt(value, key));
+          break;
+        case 'startAfter':
+          constraints.push(startAfter(value, key));
+          break;
+      }
+    }
+  }
+
+  return query(dbRef, ...constraints);
+}

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@react-native-firebase/database",
-  "version": "24.1.1",
+  "version": "25.0.1",
   "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",
-  "types": "lib/index.d.ts",
+  "main": "./dist/module/index.js",
+  "types": "./dist/typescript/lib/index.d.ts",
   "scripts": {
-    "build": "genversion --semi lib/version.js",
+    "build": "genversion --esm --semi lib/version.ts",
     "build:clean": "rimraf android/build && rimraf ios/build",
-    "prepare": "yarn run build"
+    "compile": "bob build",
+    "prepare": "yarn run build && yarn compile"
   },
   "repository": {
     "type": "git",
@@ -25,11 +26,45 @@
     "realtome database"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "24.1.1"
+    "@react-native-firebase/app": "25.0.1"
+  },
+  "devDependencies": {
+    "react-native-builder-bob": "^0.41.0"
   },
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
-  "gitHead": "ea699f0bbcc98d25eebea4bfbe88cf1e9f2d0107"
+  "exports": {
+    ".": {
+      "source": "./lib/index.ts",
+      "types": "./dist/typescript/lib/index.d.ts",
+      "default": "./dist/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "react-native-builder-bob": {
+    "source": "lib",
+    "output": "dist",
+    "exclude": "**/*.d.ts",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "tsc": "../../node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "dist/"
+  ],
+  "gitHead": "8c1c22f54a052ea8151b66ce079caf06e7703d4a"
 }