@chem-po/firebase-native 0.0.17 → 0.0.19

package/README.md

@@ -0,0 +1,215 @@
+# @chem-po/firebase-native
+
+React Native Firebase integration for ChemPo ecosystem.
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+Before using this package, ensure your React Native app has:
+
+1. **Firebase Project Setup**
+
+   - Create a Firebase project at https://console.firebase.google.com
+   - Enable Authentication with desired providers (Email/Password, Google)
+   - Enable Firestore Database
+   - Enable Cloud Storage
+
+2. **Platform Configuration**
+
+#### iOS Setup
+
+1. Download `GoogleService-Info.plist` from Firebase Console
+2. Add it to your iOS project root
+3. Configure URL schemes in `ios/[ProjectName]/Info.plist`:
+
+```xml
+<key>CFBundleURLTypes</key>
+<array>
+  <dict>
+    <key>CFBundleURLName</key>
+    <string>REVERSED_CLIENT_ID</string>
+    <key>CFBundleURLSchemes</key>
+    <array>
+      <string>YOUR_REVERSED_CLIENT_ID</string>
+    </array>
+  </dict>
+</array>
+```
+
+#### Android Setup
+
+1. Download `google-services.json` from Firebase Console
+2. Place it in `android/app/google-services.json`
+3. Ensure package name matches Firebase configuration
+
+### Installation
+
+```bash
+npm install @chem-po/firebase-native
+# or
+yarn add @chem-po/firebase-native
+```
+
+### Required Peer Dependencies
+
+```bash
+npm install @react-native-firebase/app @react-native-firebase/auth @react-native-firebase/firestore @react-native-firebase/storage @react-native-firebase/functions @react-native-google-signin/google-signin
+```
+
+## 📱 Configuration
+
+### 1. Firebase Initialization
+
+```typescript
+import { getAuth } from '@react-native-firebase/auth'
+import { getFirestore } from '@react-native-firebase/firestore'
+import { getStorage } from '@react-native-firebase/storage'
+import { getFunctions } from '@react-native-firebase/functions'
+import { getFirebaseAdapter } from '@chem-po/firebase-native'
+
+// Initialize Firebase services
+const auth = getAuth()
+const firestore = getFirestore()
+const storage = getStorage()
+const functions = getFunctions()
+
+// Create backend adapter
+const backendAdapter = getFirebaseAdapter(
+  auth,
+  firestore,
+  storage,
+  functions,
+  true // Enable two-factor authentication
+)
+```
+
+### 2. Google Authentication Setup
+
+**⚠️ REQUIRED**: You must provide your Google Web Client ID:
+
+```typescript
+import { GoogleAuthProvider } from '@chem-po/core'
+
+// Get this from Firebase Console > Authentication > Sign-in method > Google > Web SDK configuration
+const googleAuthProvider: GoogleAuthProvider = {
+  name: 'google',
+  webClientId: 'YOUR_GOOGLE_WEB_CLIENT_ID.apps.googleusercontent.com',
+}
+```
+
+### 3. Provider Setup
+
+```typescript
+import { ChempoNativeProvider } from '@chem-po/react-native'
+import { FirebaseSignIn } from '@chem-po/firebase-native'
+
+export default function App() {
+  return (
+    <ChempoNativeProvider backendAdapter={backendAdapter}>
+      <FirebaseSignIn googleProvider={googleAuthProvider} />
+    </ChempoNativeProvider>
+  )
+}
+```
+
+## 🔐 Environment Variables
+
+For debug logging (optional):
+
+```bash
+EXPO_PUBLIC_DEBUG=true  # Enable debug logging
+```
+
+## 🔧 Configuration Validation
+
+Use the built-in validation helper to identify setup issues early:
+
+```typescript
+import { validateAndLogAuthConfig } from '@chem-po/firebase-native'
+
+// Validate your auth providers configuration
+const providers = [googleAuthProvider] // Your auth providers
+validateAndLogAuthConfig(providers)
+```
+
+This will output helpful warnings and errors if configuration is missing or incorrect:
+
+- ❌ Missing Google webClientId
+- ⚠️ Incorrect webClientId format
+- ⚠️ Missing Firebase configuration files
+
+**Tip**: Call this during development to catch configuration issues before they cause runtime errors.
+
+## 🚨 Common Issues
+
+### "Google web client ID is required"
+
+- Ensure you've added the `webClientId` to your Google auth provider
+- Verify the client ID matches your Firebase project configuration
+- Use the validation helper to check your configuration
+
+### "No user found"
+
+- Check Firebase Authentication is enabled
+- Verify Google Services files are properly configured
+- Ensure bundle ID/package name matches Firebase project
+
+### Multi-factor Authentication Issues
+
+- Ensure users have enrolled MFA factors via Firebase Console
+- Check that `twoFactorRequired` parameter matches your requirements
+
+### Google Play Services Issues
+
+- Ensure Google Play Services is installed and up to date
+- Check that your app's package name matches Firebase configuration
+
+## 📚 API Reference
+
+### getFirebaseAdapter
+
+Creates a Firebase backend adapter with authentication, database, and storage.
+
+```typescript
+getFirebaseAdapter(
+  auth: Auth,
+  db: Firestore,
+  storage: Storage,
+  functions: Functions,
+  twoFactorRequired: boolean
+): FirebaseAdapter
+```
+
+### FirebaseSignIn Component
+
+Pre-built authentication component with Google Sign-in support.
+
+```typescript
+<FirebaseSignIn
+  googleProvider={googleAuthProvider}
+/>
+```
+
+### Configuration Validation
+
+Utility functions to validate your Firebase configuration:
+
+```typescript
+// Validate configuration and get results
+const result = validateAuthConfiguration(providers)
+
+// Validate and log results automatically
+validateAndLogAuthConfig(providers)
+
+// Custom logging
+logValidationResults(result, 'MyApp')
+```
+
+## 🤝 Support
+
+For issues related to:
+
+- Firebase configuration: Check [Firebase Documentation](https://firebase.google.com/docs)
+- React Native Firebase: Check [@react-native-firebase/app](https://rnfirebase.io/)
+- Google Sign-in: Check [@react-native-google-signin](https://github.com/react-native-google-signin/google-signin)

package/lib/commonjs/adapter/auth.js

@@ -6,17 +6,44 @@ Object.defineProperty(exports, "__esModule", {
 exports.getFirebaseAuthAdapter = void 0;
 var _auth = require("@react-native-firebase/auth");
 var _googleSignin = require("@react-native-google-signin/google-signin");
+var _process$env;
+const isDebug = typeof process !== 'undefined' && ((_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.EXPO_PUBLIC_DEBUG) === 'true' || false;
+const debugLog = (message, data) => {
+  if (isDebug) {
+    console.log(`[FirebaseAuth Debug] ${message}`, data || '');
+  }
+};
 const providerInitialized = {};
 const getUserWithRole = async user => {
-  var _user$multiFactor;
-  const {
-    claims
-  } = await (0, _auth.getIdTokenResult)(user);
-  return {
-    ...user,
-    role: claims.role ?? 'user',
-    multiFactorVerified: !!((_user$multiFactor = user.multiFactor) !== null && _user$multiFactor !== void 0 && _user$multiFactor.enrolledFactors.length)
-  };
+  debugLog('Getting user with role', {
+    uid: user.uid,
+    email: user.email
+  });
+  try {
+    var _user$multiFactor, _user$multiFactor2;
+    const {
+      claims
+    } = await (0, _auth.getIdTokenResult)(user);
+    debugLog('Retrieved ID token claims', {
+      role: claims.role,
+      customClaims: Object.keys(claims)
+    });
+    const userWithRole = {
+      ...user,
+      role: claims.role ?? 'user',
+      multiFactorVerified: !!((_user$multiFactor = user.multiFactor) !== null && _user$multiFactor !== void 0 && _user$multiFactor.enrolledFactors.length)
+    };
+    debugLog('User with role created', {
+      uid: userWithRole.uid,
+      role: userWithRole.role,
+      multiFactorVerified: userWithRole.multiFactorVerified,
+      enrolledFactorsCount: ((_user$multiFactor2 = user.multiFactor) === null || _user$multiFactor2 === void 0 ? void 0 : _user$multiFactor2.enrolledFactors.length) || 0
+    });
+    return userWithRole;
+  } catch (error) {
+    debugLog('Error getting user with role', error);
+    throw error;
+  }
 };
 const toEnrollmentFactor = hint => {
   if (hint.factorId === _auth.PhoneMultiFactorGenerator.FACTOR_ID) {
@@ -59,92 +86,203 @@ const toFirebaseFactor = factor => {
   throw new Error(`Unsupported factor type: ${factor.factorId ?? 'Missing factor type'}`);
 };
 const sendMultiFactorCode = async (auth, factor, resolver) => {
+  debugLog('Sending multi-factor code', {
+    factorType: factor.type,
+    factorUid: factor.uid
+  });
   const sessionId = resolver.session;
   // const verificationId = await new PhoneAuthProvider(auth).verifyPhoneNumber(phoneSignInFactor, sessionId)
   if (factor.type === 'phone') {
-    const verificationId = await auth.verifyPhoneNumberWithMultiFactorInfo(toFirebaseFactor(factor), sessionId);
-    return {
-      verificationId,
-      factor,
-      resolver
-    };
+    try {
+      const verificationId = await auth.verifyPhoneNumberWithMultiFactorInfo(toFirebaseFactor(factor), sessionId);
+      debugLog('Multi-factor code sent successfully', {
+        verificationId: verificationId.substring(0, 10) + '...'
+      });
+      return {
+        verificationId,
+        factor,
+        resolver
+      };
+    } catch (error) {
+      debugLog('Error sending multi-factor code', error);
+      throw error;
+    }
   }
   throw new Error(`Unsupported factor type: ${factor.type ?? 'Missing factor type'}`);
 };
 const getEnrolledFactors = async (auth, error) => {
-  const resolver = (0, _auth.getMultiFactorResolver)(auth, error);
-  if (resolver.hints.length === 0) {
-    throw new Error('No multi-factor verification methods found, please enroll one on the website');
+  debugLog('Getting enrolled factors from error', {
+    errorCode: error === null || error === void 0 ? void 0 : error.code
+  });
+  try {
+    const resolver = (0, _auth.getMultiFactorResolver)(auth, error);
+    debugLog('Multi-factor resolver created', {
+      hintsCount: resolver.hints.length
+    });
+    if (resolver.hints.length === 0) {
+      debugLog('No enrolled factors found');
+      throw new Error('No multi-factor verification methods found, please enroll one on the website');
+    }
+    const enrollmentFactors = resolver.hints.map(toEnrollmentFactor);
+    debugLog('Enrollment factors mapped', {
+      factors: enrollmentFactors.map(f => ({
+        type: f.type,
+        uid: f.uid
+      }))
+    });
+    return {
+      enrollmentFactors,
+      multiFactorResolver: resolver
+    };
+  } catch (error) {
+    debugLog('Error getting enrolled factors', error);
+    throw error;
   }
-  return {
-    enrollmentFactors: resolver.hints.map(toEnrollmentFactor),
-    multiFactorResolver: resolver
-  };
 };
 const verifyMultiFactor = async (verification, code) => {
-  const credential = await _auth.PhoneAuthProvider.credential(verification.verificationId, code);
-  const assertion = _auth.PhoneMultiFactorGenerator.assertion(credential);
-  const resolver = verification.resolver;
-  if (!resolver) throw new Error('Internal error signing in with two factor: resolver not found');
-  const userCredential = await resolver.resolveSignIn(assertion);
-  const user = userCredential.user;
-  if (!user) throw new Error('No user found');
-  return {
-    user: await getUserWithRole(user)
-  };
+  debugLog('Verifying multi-factor code', {
+    factorType: verification.factor.type,
+    codeLength: code.length
+  });
+  try {
+    var _userCredential$user;
+    const credential = await _auth.PhoneAuthProvider.credential(verification.verificationId, code);
+    debugLog('Phone credential created');
+    const assertion = _auth.PhoneMultiFactorGenerator.assertion(credential);
+    debugLog('Multi-factor assertion created');
+    const resolver = verification.resolver;
+    if (!resolver) {
+      debugLog('Multi-factor resolver not found');
+      throw new Error('Internal error signing in with two factor: resolver not found');
+    }
+    const userCredential = await resolver.resolveSignIn(assertion);
+    debugLog('Multi-factor sign-in resolved', {
+      uid: (_userCredential$user = userCredential.user) === null || _userCredential$user === void 0 ? void 0 : _userCredential$user.uid
+    });
+    const user = userCredential.user;
+    if (!user) {
+      debugLog('No user found after multi-factor resolution');
+      throw new Error('No user found');
+    }
+    const userWithRole = await getUserWithRole(user);
+    debugLog('Multi-factor verification completed successfully');
+    return {
+      user: userWithRole
+    };
+  } catch (error) {
+    debugLog('Error verifying multi-factor', error);
+    throw error;
+  }
 };
 const handleSignInError = async error => {
+  debugLog('Handling sign-in error', {
+    code: error === null || error === void 0 ? void 0 : error.code,
+    message: error === null || error === void 0 ? void 0 : error.message
+  });
   if (error.code === 'auth/multi-factor-auth-required') {
+    debugLog('Multi-factor authentication required');
     return {
       requestArgs: error
     };
   }
+  debugLog('Re-throwing sign-in error');
   throw error;
 };
 const initializeProvider = async provider => {
-  if (providerInitialized[provider.name]) return;
+  debugLog('Initializing provider', {
+    name: provider.name,
+    alreadyInitialized: providerInitialized[provider.name]
+  });
+  if (providerInitialized[provider.name]) {
+    debugLog('Provider already initialized, skipping');
+    return;
+  }
   switch (provider.name) {
     case 'google':
+      debugLog('Initializing Google provider', {
+        webClientId: !!provider.webClientId
+      });
       if (!provider.webClientId) {
-        throw new Error('Google web client ID is required when using Google Auth. Refer to react native firebase docs for more information.');
+        debugLog('Google web client ID missing');
+        throw new Error('Google web client ID is required when using Google Auth. ' + 'Get your webClientId from Firebase Console > Authentication > Sign-in method > Google > Web SDK configuration. ' + 'Then provide it in your GoogleAuthProvider: { name: "google", webClientId: "YOUR_CLIENT_ID" }');
+      }
+      try {
+        await _googleSignin.GoogleSignin.hasPlayServices({
+          showPlayServicesUpdateDialog: true
+        });
+        debugLog('Google Play Services available');
+        _googleSignin.GoogleSignin.configure({
+          webClientId: provider.webClientId
+        });
+        debugLog('Google Sign-In configured successfully');
+      } catch (error) {
+        debugLog('Error initializing Google provider', error);
+        if (error instanceof Error && error.message.includes('UNAVAILABLE')) {
+          throw new Error('Google Play Services is not available or needs to be updated. ' + 'Please ensure Google Play Services is installed and up to date on this device.');
+        }
+        throw error;
       }
-      await _googleSignin.GoogleSignin.hasPlayServices({
-        showPlayServicesUpdateDialog: true
-      });
-      _googleSignin.GoogleSignin.configure({
-        webClientId: provider.webClientId
-      });
       break;
     case 'email':
+      debugLog('Email provider initialization (no special setup required)');
       // Native SDK doesn't need special initialization
       break;
     default:
+      debugLog('Unsupported provider', {
+        name: provider.name
+      });
       throw new Error(`Unsupported provider: ${provider.name}`);
   }
   providerInitialized[provider.name] = true;
+  debugLog('Provider initialization completed', {
+    name: provider.name
+  });
 };
 const handleInitialLogin = async (userCredential, twoFactorRequired) => {
+  var _userCredential$user2, _userCredential$user3;
+  debugLog('Handling initial login', {
+    uid: (_userCredential$user2 = userCredential.user) === null || _userCredential$user2 === void 0 ? void 0 : _userCredential$user2.uid,
+    twoFactorRequired,
+    enrolledFactorsCount: ((_userCredential$user3 = userCredential.user) === null || _userCredential$user3 === void 0 || (_userCredential$user3 = _userCredential$user3.multiFactor) === null || _userCredential$user3 === void 0 ? void 0 : _userCredential$user3.enrolledFactors.length) || 0
+  });
   const user = userCredential.user;
-  if (!user) throw new Error('No user found');
+  if (!user) {
+    debugLog('No user found in credential');
+    throw new Error('No user found');
+  }
   if (twoFactorRequired) {
+    debugLog('Two-factor authentication is required but user has no enrolled factors');
     throw new Error('This app requires two factor authentication, please enroll a factor on the website and try again');
   }
+  const userWithRole = await getUserWithRole(user);
+  debugLog('Initial login completed successfully');
   return {
-    user: await getUserWithRole(user)
+    user: userWithRole
   };
 };
 const loginWithGoogle = async (auth, twoFactorRequired) => {
+  debugLog('Starting Google sign-in', {
+    twoFactorRequired
+  });
   try {
-    var _signInResult$data;
+    var _signInResult$data, _signInResult$data2;
+    debugLog('Calling GoogleSignin.signIn()');
     const signInResult = await _googleSignin.GoogleSignin.signIn();
-    const idToken = (_signInResult$data = signInResult.data) === null || _signInResult$data === void 0 ? void 0 : _signInResult$data.idToken;
+    debugLog('Google sign-in result received', {
+      hasIdToken: !!((_signInResult$data = signInResult.data) !== null && _signInResult$data !== void 0 && _signInResult$data.idToken)
+    });
+    const idToken = (_signInResult$data2 = signInResult.data) === null || _signInResult$data2 === void 0 ? void 0 : _signInResult$data2.idToken;
     if (!idToken) {
+      debugLog('No ID token found in Google sign-in result');
       throw new Error('No ID token found');
     }
+    debugLog('Creating Google credential');
     const googleCredential = _auth.GoogleAuthProvider.credential(idToken);
+    debugLog('Signing in with Google credential');
     const userCredential = await (0, _auth.signInWithCredential)(auth, googleCredential);
     return await handleInitialLogin(userCredential, twoFactorRequired);
   } catch (error) {
+    debugLog('Error in Google sign-in', error);
     return await handleSignInError(error);
   }
 };
@@ -152,70 +290,142 @@ const getLoginWithPassword = (auth, twoFactorRequired) => async (provider, {
   email,
   password
 }) => {
+  debugLog('Starting email/password sign-in', {
+    provider: provider.name,
+    email,
+    twoFactorRequired
+  });
   await initializeProvider(provider);
   try {
+    var _userCredential$user4;
+    debugLog('Calling signInWithEmailAndPassword');
     const userCredential = await (0, _auth.signInWithEmailAndPassword)(auth, email, password);
+    debugLog('Email/password sign-in successful', {
+      uid: (_userCredential$user4 = userCredential.user) === null || _userCredential$user4 === void 0 ? void 0 : _userCredential$user4.uid
+    });
     return await handleInitialLogin(userCredential, twoFactorRequired);
   } catch (error) {
+    debugLog('Error in email/password sign-in', error);
     return await handleSignInError(error);
   }
 };
 const getLoginWithPopup = (auth, twoFactorRequired) => async provider => {
+  debugLog('Starting popup sign-in', {
+    provider: provider.name,
+    twoFactorRequired
+  });
   await initializeProvider(provider);
   switch (provider.name) {
     case 'google':
       return loginWithGoogle(auth, twoFactorRequired);
     default:
+      debugLog('Unsupported popup provider', {
+        name: provider.name
+      });
       throw new Error(`Unsupported provider: ${provider.name}`);
   }
 };
 const getLoginWithToken = (auth, twoFactorRequired) => async (provider, token) => {
+  debugLog('Starting token sign-in', {
+    provider: provider.name,
+    tokenLength: token.length,
+    twoFactorRequired
+  });
   await initializeProvider(provider);
   try {
+    var _userCredential$user5;
+    debugLog('Calling signInWithCustomToken');
     const userCredential = await (0, _auth.signInWithCustomToken)(auth, token);
+    debugLog('Token sign-in successful', {
+      uid: (_userCredential$user5 = userCredential.user) === null || _userCredential$user5 === void 0 ? void 0 : _userCredential$user5.uid
+    });
     return await handleInitialLogin(userCredential, twoFactorRequired);
   } catch (error) {
+    debugLog('Error in token sign-in', error);
     return await handleSignInError(error);
   }
 };
 const resetPassword = async (auth, provider, usernameOrEmail) => {
+  debugLog('Starting password reset', {
+    provider: provider.name,
+    email: usernameOrEmail
+  });
   await initializeProvider(provider);
-  await (0, _auth.sendPasswordResetEmail)(auth, usernameOrEmail);
-};
-const getFirebaseAuthAdapter = (auth, twoFactorRequired) => ({
-  twoFactorRequired,
-  getCurrentUser: async () => {
-    const user = auth.currentUser;
-    if (!user) return null;
-    return getUserWithRole(user);
-  },
-  loginWithPassword: getLoginWithPassword(auth, twoFactorRequired),
-  loginWithPopup: getLoginWithPopup(auth, twoFactorRequired),
-  loginWithToken: getLoginWithToken(auth, twoFactorRequired),
-  resetPassword: (...args) => {
-    return resetPassword(auth, ...args);
-  },
-  verifyMultiFactor,
-  sendMultiFactorCode: (...args) => {
-    return sendMultiFactorCode(auth, ...args);
-  },
-  getEnrolledFactors: (...args) => {
-    return getEnrolledFactors(auth, ...args);
-  },
-  logout: async () => {
-    await (0, _auth.signOut)(auth);
-  },
-  subscribeToUser: callback => {
-    return (0, _auth.onAuthStateChanged)(auth, user => {
+  try {
+    await (0, _auth.sendPasswordResetEmail)(auth, usernameOrEmail);
+    debugLog('Password reset email sent successfully');
+  } catch (error) {
+    debugLog('Error sending password reset email', error);
+    throw error;
+  }
+};
+const getFirebaseAuthAdapter = (auth, twoFactorRequired) => {
+  debugLog('Creating Firebase Auth Adapter', {
+    twoFactorRequired
+  });
+  return {
+    twoFactorRequired,
+    getCurrentUser: async () => {
+      debugLog('Getting current user');
+      const user = auth.currentUser;
       if (!user) {
-        callback(null);
-        return;
+        debugLog('No current user found');
+        return null;
       }
-      getUserWithRole(user).then(result => {
-        callback(result);
+      debugLog('Current user found', {
+        uid: user.uid,
+        email: user.email
       });
-    });
-  }
-});
+      return getUserWithRole(user);
+    },
+    loginWithPassword: getLoginWithPassword(auth, twoFactorRequired),
+    loginWithPopup: getLoginWithPopup(auth, twoFactorRequired),
+    loginWithToken: getLoginWithToken(auth, twoFactorRequired),
+    resetPassword: (...args) => {
+      return resetPassword(auth, ...args);
+    },
+    verifyMultiFactor,
+    sendMultiFactorCode: (...args) => {
+      return sendMultiFactorCode(auth, ...args);
+    },
+    getEnrolledFactors: (...args) => {
+      return getEnrolledFactors(auth, ...args);
+    },
+    logout: async () => {
+      debugLog('Starting logout');
+      try {
+        await (0, _auth.signOut)(auth);
+        debugLog('Logout completed successfully');
+      } catch (error) {
+        debugLog('Error during logout', error);
+        throw error;
+      }
+    },
+    subscribeToUser: callback => {
+      debugLog('Setting up user subscription');
+      return (0, _auth.onAuthStateChanged)(auth, user => {
+        if (!user) {
+          debugLog('User state changed: signed out');
+          callback(null);
+          return;
+        }
+        debugLog('User state changed: user signed in', {
+          uid: user.uid,
+          email: user.email
+        });
+        getUserWithRole(user).then(result => {
+          debugLog('User subscription callback completed', {
+            uid: result.uid,
+            role: result.role
+          });
+          callback(result);
+        }).catch(error => {
+          debugLog('Error in user subscription callback', error);
+          callback(null);
+        });
+      });
+    }
+  };
+};
 exports.getFirebaseAuthAdapter = getFirebaseAuthAdapter;
 //# sourceMappingURL=auth.js.map