Update firebase dependency to 9.0.0 beta.8

package.json

@@ -26,7 +26,7 @@
     "docs": "typedoc --options typedoc.json && markdown-toc -i docs/use.md"
   },
   "peerDependencies": {
-    "firebase": "9.0.0-beta.7",
+    "firebase": "9.0.0-beta.8",
     "react": ">=16 || experimental"
   },
   "husky": {
@@ -81,7 +81,7 @@
     "babel-jest": "^26.6.3",
     "babel-plugin-minify-replace": "^0.5.0",
     "eslint-plugin-no-only-tests": "^2.6.0",
-    "firebase": "9.0.0-beta.7",
+    "firebase": "9.0.0-beta.8",
     "firebase-tools": "^9.16.0",
     "globalthis": "^1.0.1",
     "husky": "^4.3.0",

src/database.tsx

@@ -4,7 +4,7 @@ import { ReactFireOptions, useObservable, checkIdField, ObservableStatus, ReactF
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 
-import type { Query as DatabaseQuery, Reference } from 'firebase/database';
+import type { Query as DatabaseQuery, DatabaseReference } from 'firebase/database';
 
 // Since we're side-effect free, we need to ensure our observableId cache is global
 const cachedQueries: Array<DatabaseQuery> = (globalThis as any as ReactFireGlobals)._reactFireDatabaseCachedQueries || [];
@@ -27,7 +27,7 @@ function getUniqueIdForDatabaseQuery(query: DatabaseQuery) {
  * @param ref - Reference to the DB object you want to listen to
  * @param options
  */
-export function useDatabaseObject<T = unknown>(ref: Reference, options?: ReactFireOptions<T>): ObservableStatus<QueryChange | T> {
+export function useDatabaseObject<T = unknown>(ref: DatabaseReference, options?: ReactFireOptions<T>): ObservableStatus<QueryChange | T> {
   const observableId = `database:object:${ref.toString()}`;
   const observable$ = object(ref);
 
@@ -57,7 +57,7 @@ function changeToData(change: QueryChange, keyField?: string): {} {
 }
 // ============================================================================
 
-export function useDatabaseObjectData<T>(ref: Reference, options?: ReactFireOptions<T>): ObservableStatus<T> {
+export function useDatabaseObjectData<T>(ref: DatabaseReference, options?: ReactFireOptions<T>): ObservableStatus<T> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';
   const observableId = `database:objectVal:${ref.toString()}:idField=${idField}`;
   const observable$ = objectVal<T>(ref, idField);
@@ -72,7 +72,7 @@ export function useDatabaseObjectData<T>(ref: Reference, options?: ReactFireOpti
  * @param options
  */
 export function useDatabaseList<T = { [key: string]: unknown }>(
-  ref: Reference | DatabaseQuery,
+  ref: DatabaseReference | DatabaseQuery,
   options?: ReactFireOptions<T[]>
 ): ObservableStatus<QueryChange[] | T[]> {
   const hash = `database:list:${getUniqueIdForDatabaseQuery(ref)}`;
@@ -82,7 +82,7 @@ export function useDatabaseList<T = { [key: string]: unknown }>(
 }
 
 export function useDatabaseListData<T = { [key: string]: unknown }>(
-  ref: Reference | DatabaseQuery,
+  ref: DatabaseReference | DatabaseQuery,
   options?: ReactFireOptions<T[]>
 ): ObservableStatus<T[] | null> {
   const idField = options ? checkIdField(options) : 'NO_ID_FIELD';

src/sdk.tsx

@@ -1,10 +1,10 @@
 import * as React from 'react';
 
 import type { Auth } from 'firebase/auth';
-import type { FirebaseDatabase } from 'firebase/database';
-import type { FirebaseFirestore } from 'firebase/firestore';
+import type { Database } from 'firebase/database';
+import type { Firestore } from 'firebase/firestore';
 import type { FirebasePerformance } from 'firebase/performance';
-import type { StorageService } from 'firebase/storage';
+import type { FirebaseStorage } from 'firebase/storage';
 import type { RemoteConfig } from 'firebase/remote-config';
 import { useFirebaseApp } from './firebaseApp';
 import { FirebaseApp } from 'firebase/app';
@@ -13,13 +13,13 @@ import { from } from 'rxjs';
 import { ReactFireOptions } from '.';
 
 const AuthSdkContext = React.createContext<Auth | undefined>(undefined);
-const DatabaseSdkContext = React.createContext<FirebaseDatabase | undefined>(undefined);
-const FirestoreSdkContext = React.createContext<FirebaseFirestore | undefined>(undefined);
-const StorageSdkContext = React.createContext<StorageService | undefined>(undefined);
+const DatabaseSdkContext = React.createContext<Database | undefined>(undefined);
+const FirestoreSdkContext = React.createContext<Firestore | undefined>(undefined);
+const StorageSdkContext = React.createContext<FirebaseStorage | undefined>(undefined);
 const PerformanceSdkContext = React.createContext<FirebasePerformance | undefined>(undefined);
 const RemoteConfigSdkContext = React.createContext<RemoteConfig | undefined>(undefined);
 
-type FirebaseSdks = Auth | FirebaseDatabase | FirebaseFirestore | FirebasePerformance | StorageService | RemoteConfig;
+type FirebaseSdks = Auth | Database | Firestore | FirebasePerformance | FirebaseStorage | RemoteConfig;
 
 function getSdkProvider<Sdk extends FirebaseSdks>(SdkContext: React.Context<Sdk | undefined>) {
   return function SdkProvider(props: React.PropsWithChildren<{ sdk: Sdk }>) {
@@ -80,17 +80,17 @@ function useInitSdk<Sdk extends FirebaseSdks>(
 }
 
 export const AuthProvider = getSdkProvider<Auth>(AuthSdkContext);
-export const DatabaseProvider = getSdkProvider<FirebaseDatabase>(DatabaseSdkContext);
-export const FirestoreProvider = getSdkProvider<FirebaseFirestore>(FirestoreSdkContext);
+export const DatabaseProvider = getSdkProvider<Database>(DatabaseSdkContext);
+export const FirestoreProvider = getSdkProvider<Firestore>(FirestoreSdkContext);
 export const PerformanceProvider = getSdkProvider<FirebasePerformance>(PerformanceSdkContext);
-export const StorageProvider = getSdkProvider<StorageService>(StorageSdkContext);
+export const StorageProvider = getSdkProvider<FirebaseStorage>(StorageSdkContext);
 export const RemoteConfigProvider = getSdkProvider<RemoteConfig>(RemoteConfigSdkContext);
 
 export const useAuth = () => useSdk<Auth>(AuthSdkContext);
-export const useDatabase = () => useSdk<FirebaseDatabase>(DatabaseSdkContext);
-export const useFirestore = () => useSdk<FirebaseFirestore>(FirestoreSdkContext);
+export const useDatabase = () => useSdk<Database>(DatabaseSdkContext);
+export const useFirestore = () => useSdk<Firestore>(FirestoreSdkContext);
 export const usePerformance = () => useSdk<FirebasePerformance>(PerformanceSdkContext);
-export const useStorage = () => useSdk<StorageService>(StorageSdkContext);
+export const useStorage = () => useSdk<FirebaseStorage>(StorageSdkContext);
 export const useRemoteConfig = () => useSdk<RemoteConfig>(RemoteConfigSdkContext);
 
 type InitSdkHook<Sdk extends FirebaseSdks> = (
@@ -99,13 +99,11 @@ type InitSdkHook<Sdk extends FirebaseSdks> = (
 ) => ObservableStatus<Sdk>;
 
 export const useInitAuth: InitSdkHook<Auth> = (initializer, options) => useInitSdk<Auth>('auth', AuthSdkContext, initializer, options);
-export const useInitDatabase: InitSdkHook<FirebaseDatabase> = (initializer, options) =>
-  useInitSdk<FirebaseDatabase>('database', DatabaseSdkContext, initializer, options);
-export const useInitFirestore: InitSdkHook<FirebaseFirestore> = (initializer, options) =>
-  useInitSdk<FirebaseFirestore>('firestore', FirestoreSdkContext, initializer, options);
+export const useInitDatabase: InitSdkHook<Database> = (initializer, options) => useInitSdk<Database>('database', DatabaseSdkContext, initializer, options);
+export const useInitFirestore: InitSdkHook<Firestore> = (initializer, options) => useInitSdk<Firestore>('firestore', FirestoreSdkContext, initializer, options);
 export const useInitPerformance: InitSdkHook<FirebasePerformance> = (initializer, options) =>
   useInitSdk<FirebasePerformance>('performance', PerformanceSdkContext, initializer, options);
 export const useInitRemoteConfig: InitSdkHook<RemoteConfig> = (initializer, options) =>
   useInitSdk<RemoteConfig>('remoteconfig', RemoteConfigSdkContext, initializer, options);
-export const useInitStorage: InitSdkHook<StorageService> = (initializer, options) =>
-  useInitSdk<StorageService>('storage', StorageSdkContext, initializer, options);
+export const useInitStorage: InitSdkHook<FirebaseStorage> = (initializer, options) =>
+  useInitSdk<FirebaseStorage>('storage', StorageSdkContext, initializer, options);

src/storage.tsx

@@ -5,7 +5,7 @@ import { ReactFireOptions, useObservable, ObservableStatus, useStorage } from '.
 import { useSuspenseEnabledFromConfigAndContext } from './firebaseApp';
 import { ref } from 'firebase/storage';
 
-import type { UploadTask, UploadTaskSnapshot, StorageReference, StorageService } from 'firebase/storage';
+import type { UploadTask, UploadTaskSnapshot, StorageReference, FirebaseStorage } from 'firebase/storage';
 
 /**
  * modified version of rxFire's _fromTask
@@ -57,7 +57,7 @@ export function useStorageDownloadURL<T = string>(ref: StorageReference, options
 
 type StorageImageProps = {
   storagePath: string;
-  storage?: StorageService;
+  storage?: FirebaseStorage;
   suspense?: boolean;
   placeHolder?: JSX.Element;
 };

test/auth.test.tsx

@@ -18,7 +18,7 @@ import { baseConfig } from './appConfig';
 import { FirebaseApp, initializeApp } from 'firebase/app';
 import { randomString } from './test-utils';
 
-import { getAuth, GoogleAuthProvider, signInWithCredential, signInWithCustomToken, signOut, useAuthEmulator, UserCredential } from 'firebase/auth';
+import { getAuth, GoogleAuthProvider, signInWithCredential, signInWithCustomToken, signOut, connectAuthEmulator, UserCredential } from 'firebase/auth';
 
 describe('Authentication', () => {
   let app: FirebaseApp;
@@ -55,7 +55,7 @@ describe('Authentication', () => {
 
     app = initializeApp(baseConfig);
 
-    useAuthEmulator(getAuth(app), 'http://localhost:9099/', { disableWarnings: true });
+    connectAuthEmulator(getAuth(app), 'http://localhost:9099/', { disableWarnings: true });
 
     signIn = async () => {
       return signInWithCredential(getAuth(app), GoogleAuthProvider.credential('{"sub": "abc123", "email": "foo@example.com", "email_verified": true}'));

test/database.test.tsx

@@ -3,14 +3,14 @@ import * as React from 'react';
 import { useDatabaseObject, useDatabaseList, FirebaseAppProvider, DatabaseProvider, ObservableStatus } from '..';
 import { baseConfig } from './appConfig';
 import { initializeApp } from 'firebase/app';
-import { getDatabase, useDatabaseEmulator, ref, set, push, query, orderByChild, equalTo, get } from 'firebase/database';
+import { getDatabase, connectDatabaseEmulator, ref, set, push, query, orderByChild, equalTo, get } from 'firebase/database';
 import { QueryChange } from 'rxfire/database';
 import { randomString } from './test-utils';
 
 describe('Realtime Database (RTDB)', () => {
   const app = initializeApp(baseConfig);
   const database = getDatabase(app);
-  useDatabaseEmulator(database, 'localhost', 9000);
+  connectDatabaseEmulator(database, 'localhost', 9000);
 
   const Provider: React.FunctionComponent = ({ children }) => (
     <FirebaseAppProvider firebaseApp={app}>

test/firestore.test.tsx

@@ -18,12 +18,12 @@ import fetch from 'node-fetch';
 import { baseConfig } from './appConfig';
 import { randomString } from './test-utils';
 
-import { addDoc, collection, doc, getFirestore, query, setDoc, useFirestoreEmulator, where } from 'firebase/firestore';
+import { addDoc, collection, doc, getFirestore, query, setDoc, connectFirestoreEmulator, where } from 'firebase/firestore';
 
 describe('Firestore', () => {
   const app = initializeApp(baseConfig, 'firestore-test-suite');
   const db = getFirestore(app);
-  useFirestoreEmulator(db, 'localhost', 8080);
+  connectFirestoreEmulator(db, 'localhost', 8080);
 
   const Provider = ({ children }: { children: React.ReactNode }) => (
     <FirebaseAppProvider firebaseApp={app} suspense={true}>

test/storage.test.tsx

@@ -1,5 +1,5 @@
 import { initializeApp } from 'firebase/app';
-import { getDownloadURL, getStorage, ref, uploadBytesResumable, UploadTaskSnapshot, useStorageEmulator } from 'firebase/storage';
+import { getDownloadURL, getStorage, ref, uploadBytesResumable, UploadTaskSnapshot, connectStorageEmulator } from 'firebase/storage';
 import { FunctionComponent } from 'react';
 import { FirebaseAppProvider, ObservableStatus, StorageProvider, useStorageDownloadURL, useStorageTask } from '..';
 import { baseConfig } from './appConfig';
@@ -9,7 +9,7 @@ import * as React from 'react';
 describe('Storage', () => {
   const app = initializeApp(baseConfig);
   const storage = getStorage(app);
-  useStorageEmulator(storage, 'localhost', 9199);
+  connectStorageEmulator(storage, 'localhost', 9199);
 
   const Provider: FunctionComponent = ({ children }) => (
     <FirebaseAppProvider firebaseApp={app}>