@chem-po/firebase-native 0.0.17 → 0.0.19

package/lib/typescript/adapter/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/adapter/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,gBAAgB,EAQjB,MAAM,eAAe,CAAA;AAiBtB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AAwN1C,eAAO,MAAM,sBAAsB,GACjC,MAAM,IAAI,EACV,mBAAmB,OAAO,KACzB,WAAW,CAAC,gBAAgB,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAkCxE,CAAA"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/adapter/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,gBAAgB,EAQjB,MAAM,eAAe,CAAA;AAiBtB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AAkY1C,eAAO,MAAM,sBAAsB,GACjC,MAAM,IAAI,EACV,mBAAmB,OAAO,KACzB,WAAW,CAAC,gBAAgB,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAyDzE,CAAA"}

package/lib/typescript/index.d.ts

@@ -6,4 +6,5 @@ export * from './db';
 export * from './hooks';
 export * from './storage';
 export * from './types';
+export * from './utils/validation';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,MAAM,CAAA;AACpB,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,MAAM,CAAA;AACpB,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,oBAAoB,CAAA"}

package/lib/typescript/utils/validation.d.ts

@@ -0,0 +1,21 @@
+import { BaseAuthProvider } from '@chem-po/core';
+interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validates Firebase authentication configuration to help identify common setup issues
+ */
+export declare const validateAuthConfiguration: (providers: BaseAuthProvider[]) => ValidationResult;
+/**
+ * Logs validation results with appropriate console methods
+ */
+export declare const logValidationResults: (result: ValidationResult, packageName?: string) => void;
+/**
+ * Validates and logs Firebase auth configuration
+ * Call this during development to identify setup issues early
+ */
+export declare const validateAndLogAuthConfig: (providers: BaseAuthProvider[]) => ValidationResult;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/lib/typescript/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/utils/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAsB,MAAM,eAAe,CAAA;AAEpE,UAAU,gBAAgB;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAI,WAAW,gBAAgB,EAAE,KAAG,gBAyCzE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,gBAAgB,EACxB,oBAAwC,SAezC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,WAAW,gBAAgB,EAAE,qBAIrE,CAAA"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@chem-po/firebase-native",
   "author": "Elan Canfield",
   "license": "MIT",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "main": "lib/commonjs/index.js",
   "types": "lib/typescript/index.d.ts",
   "source": "src/index.ts",
@@ -43,9 +43,9 @@
     "react-native-paper": "^5.14.3",
     "react-native-svg": "15.11.2",
     "zustand": "^4.3.3",
-    "@chem-po/react": "0.0.17",
-    "@chem-po/core": "0.0.17",
-    "@chem-po/react-native": "0.0.17"
+    "@chem-po/core": "0.0.19",
+    "@chem-po/react": "0.0.19",
+    "@chem-po/react-native": "0.0.19"
   },
   "devDependencies": {
     "@babel/core": "^7.26.0",

package/src/adapter/auth.ts

@@ -27,17 +27,46 @@ import {
 import { GoogleSignin } from '@react-native-google-signin/google-signin'
 import { Auth, User } from '../types/auth'
 
+const isDebug = (
+  typeof process !== 'undefined' && 
+  process.env?.EXPO_PUBLIC_DEBUG === 'true'
+) || false
+
+const debugLog = (message: string, data?: any) => {
+  if (isDebug) {
+    console.log(`[FirebaseAuth Debug] ${message}`, data || '')
+  }
+}
+
 const providerInitialized: Record<string, boolean> = {}
 
 const getUserWithRole = async <UserData extends BaseUserData>(
   user: FirebaseAuthTypes.User
 ): Promise<WithMultiFactorVerified<UserData>> => {
-  const { claims } = await getIdTokenResult(user)
-  return {
-    ...(user as any),
-    role: claims.role ?? ('user' as BaseUserRole),
-    multiFactorVerified: !!user.multiFactor?.enrolledFactors.length
-  } as WithMultiFactorVerified<UserData>
+  debugLog('Getting user with role', { uid: user.uid, email: user.email })
+  
+  try {
+    const { claims } = await getIdTokenResult(user)
+    debugLog('Retrieved ID token claims', { role: claims.role, customClaims: Object.keys(claims) })
+    
+    const userWithRole = {
+      ...(user as any),
+      role: claims.role ?? ('user' as BaseUserRole),
+      multiFactorVerified: !!user.multiFactor?.enrolledFactors.length
+    } as WithMultiFactorVerified<UserData>
+    
+    debugLog('User with role created', { 
+      uid: userWithRole.uid, 
+      role: userWithRole.role, 
+      multiFactorVerified: userWithRole.multiFactorVerified,
+      enrolledFactorsCount: user.multiFactor?.enrolledFactors.length || 0
+    })
+    
+    return userWithRole
+  } catch (error) {
+    debugLog('Error getting user with role', error)
+    throw error
+  }
 }
 
 const toEnrollmentFactor = (hint: FirebaseAuthTypes.MultiFactorInfo): EnrollmentFactor => {
@@ -89,30 +118,52 @@ const sendMultiFactorCode = async (
   factor: EnrollmentFactor,
   resolver: FirebaseAuthTypes.MultiFactorResolver
 ): Promise<MultiFactorVerification> => {
+  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: Auth, error: any): Promise<EnrollmentFactorsResult> => {
-  const resolver = getMultiFactorResolver(auth, error)
-  if (resolver.hints.length === 0) {
-    throw new Error('No multi-factor verification methods found, please enroll one on the website')
-  }
-  return {
-    enrollmentFactors: resolver.hints.map(toEnrollmentFactor),
-    multiFactorResolver: resolver,
+  debugLog('Getting enrolled factors from error', { errorCode: error?.code })
+  
+  try {
+    const resolver = 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
   }
 }
 
@@ -120,75 +171,163 @@ const verifyMultiFactor = async (
   verification: MultiFactorVerification,
   code: string
 ): Promise<LoginResult<User>> => {
-  const credential = await PhoneAuthProvider.credential(verification.verificationId, code)
-  const assertion = PhoneMultiFactorGenerator.assertion(credential)
-  const resolver = (verification as any).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 {
+    const credential = await PhoneAuthProvider.credential(verification.verificationId, code)
+    debugLog('Phone credential created')
+    
+    const assertion = PhoneMultiFactorGenerator.assertion(credential)
+    debugLog('Multi-factor assertion created')
+    
+    const resolver = (verification as any).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?.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: any): Promise<LoginResult<User>> => {
+  debugLog('Handling sign-in error', { code: error?.code, message: 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: BaseAuthProvider) => {
-  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 as GoogleAuthProvider).webClientId })
+      
       if (!(provider as GoogleAuthProvider).webClientId) {
+        debugLog('Google web client ID missing')
         throw new Error(
-          'Google web client ID is required when using Google Auth. Refer to react native firebase docs for more information.'
+          '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" }'
         )
       }
-      await GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true })
-      GoogleSignin.configure({
-        webClientId: (provider as any).webClientId,
-      })
+      
+      try {
+        await GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true })
+        debugLog('Google Play Services available')
+        
+        GoogleSignin.configure({
+          webClientId: (provider as any).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
+      }
       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: FirebaseAuthTypes.UserCredential,
   twoFactorRequired: boolean
 ): Promise<LoginResult<User>> => {
+  debugLog('Handling initial login', { 
+    uid: userCredential.user?.uid, 
+    twoFactorRequired,
+    enrolledFactorsCount: userCredential.user?.multiFactor?.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'
     )
   }
-  return { user: await getUserWithRole(user) }
+  
+  const userWithRole = await getUserWithRole(user)
+  debugLog('Initial login completed successfully')
+  
+  return { user: userWithRole }
 }
 
 const loginWithGoogle = async (
   auth: Auth,
   twoFactorRequired: boolean
 ): Promise<LoginResult<User>> => {
+  debugLog('Starting Google sign-in', { twoFactorRequired })
+  
   try {
+    debugLog('Calling GoogleSignin.signIn()')
     const signInResult = await GoogleSignin.signIn()
+    debugLog('Google sign-in result received', { hasIdToken: !!signInResult.data?.idToken })
+    
     const idToken = signInResult.data?.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 = GoogleAuthProvider.credential(idToken)
+    
+    debugLog('Signing in with Google credential')
     const userCredential = await signInWithCredential(auth, googleCredential)
+    
     return await handleInitialLogin(userCredential, twoFactorRequired)
   } catch (error) {
+    debugLog('Error in Google sign-in', error)
     return await handleSignInError(error)
   }
 }
@@ -199,11 +338,21 @@ const getLoginWithPassword =
     provider: BaseAuthProvider,
     { email, password }: { email: string; password: string }
   ): Promise<LoginResult<User>> => {
+    debugLog('Starting email/password sign-in', { 
+      provider: provider.name, 
+      email, 
+      twoFactorRequired 
+    })
+    
     await initializeProvider(provider)
     try {
+      debugLog('Calling signInWithEmailAndPassword')
       const userCredential = await signInWithEmailAndPassword(auth, email, password)
+      debugLog('Email/password sign-in successful', { uid: userCredential.user?.uid })
+      
       return await handleInitialLogin(userCredential, twoFactorRequired)
     } catch (error) {
+      debugLog('Error in email/password sign-in', error)
       return await handleSignInError(error)
     }
   }
@@ -211,11 +360,14 @@ const getLoginWithPassword =
 const getLoginWithPopup =
   (auth: Auth, twoFactorRequired: boolean) =>
   async (provider: BaseAuthProvider): Promise<LoginResult<User>> => {
+    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}`)
     }
   }
@@ -223,11 +375,21 @@ const getLoginWithPopup =
 const getLoginWithToken =
   (auth: Auth, twoFactorRequired: boolean) =>
   async (provider: BaseAuthProvider, token: string): Promise<LoginResult<User>> => {
+    debugLog('Starting token sign-in', { 
+      provider: provider.name, 
+      tokenLength: token.length,
+      twoFactorRequired 
+    })
+    
     await initializeProvider(provider)
     try {
+      debugLog('Calling signInWithCustomToken')
       const userCredential = await signInWithCustomToken(auth, token)
+      debugLog('Token sign-in successful', { uid: userCredential.user?.uid })
+      
       return await handleInitialLogin(userCredential, twoFactorRequired)
     } catch (error) {
+      debugLog('Error in token sign-in', error)
       return await handleSignInError(error)
     }
   }
@@ -237,45 +399,76 @@ const resetPassword = async (
   provider: BaseAuthProvider,
   usernameOrEmail: string
 ): Promise<void> => {
+  debugLog('Starting password reset', { provider: provider.name, email: usernameOrEmail })
+  
   await initializeProvider(provider)
-  await sendPasswordResetEmail(auth, usernameOrEmail)
+  try {
+    await sendPasswordResetEmail(auth, usernameOrEmail)
+    debugLog('Password reset email sent successfully')
+  } catch (error) {
+    debugLog('Error sending password reset email', error)
+    throw error
+  }
 }
 
 export const getFirebaseAuthAdapter = (
   auth: Auth,
   twoFactorRequired: boolean
-): AuthAdapter<BaseAuthProvider, User, { email: string; password: string }> => ({
-  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 signOut(auth)
-  },
-  subscribeToUser: (callback) => {
-    return onAuthStateChanged(auth, (user) => {
+): AuthAdapter<BaseAuthProvider, User, { email: string; password: string }> => {
+  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
+      }
+      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 signOut(auth)
+        debugLog('Logout completed successfully')
+      } catch (error) {
+        debugLog('Error during logout', error)
+        throw error
       }
-      getUserWithRole(user).then((result) => {
-        callback(result)
+    },
+    subscribeToUser: (callback) => {
+      debugLog('Setting up user subscription')
+      return 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)
+        })
       })
-    })
-  },
-})
+    },
+  }
+}

package/src/components/FirebaseSignIn.tsx

@@ -25,7 +25,7 @@ const GoogleLogin = ({ provider }: { provider: GoogleAuthProvider }) => {
   const { showError } = useToast()
 
   const handleSignIn = useCallback(() => {
-    auth.loginWithPopup(provider).catch(error => {
+    return auth.loginWithPopup(provider).catch(error => {
       showError(error instanceof Error ? error.message : 'An unknown error occurred')
     })
   }, [auth, provider, showError])

package/src/index.ts

@@ -6,3 +6,4 @@ export * from './db'
 export * from './hooks'
 export * from './storage'
 export * from './types'
+export * from './utils/validation'

package/src/utils/validation.ts

@@ -0,0 +1,85 @@
+import { BaseAuthProvider, GoogleAuthProvider } from '@chem-po/core'
+
+interface ValidationResult {
+  isValid: boolean
+  errors: string[]
+  warnings: string[]
+}
+
+/**
+ * Validates Firebase authentication configuration to help identify common setup issues
+ */
+export const validateAuthConfiguration = (providers: BaseAuthProvider[]): ValidationResult => {
+  const errors: string[] = []
+  const warnings: string[] = []
+
+  // Check for Google provider configuration
+  const googleProvider = providers.find(p => p.name === 'google') as GoogleAuthProvider | undefined
+
+  if (googleProvider) {
+    if (!googleProvider.webClientId) {
+      errors.push(
+        'Google provider is missing webClientId. ' +
+          'Get this from Firebase Console > Authentication > Sign-in method > Google > Web SDK configuration',
+      )
+    } else if (!googleProvider.webClientId.includes('.apps.googleusercontent.com')) {
+      warnings.push(
+        'Google webClientId format looks incorrect. Expected format: "xxx.apps.googleusercontent.com"',
+      )
+    }
+  }
+
+  // Check environment
+  if (typeof process === 'undefined') {
+    warnings.push('Process environment is not available - some features may not work as expected')
+  }
+
+  // Check for Firebase configuration files (platform-specific warnings)
+  const isExpo =
+    typeof process !== 'undefined' && process.env?.EXPO_PUBLIC_ENVIRONMENT !== undefined
+  if (!isExpo) {
+    warnings.push(
+      'Ensure Firebase configuration files are present:\n' +
+        '- iOS: GoogleService-Info.plist in ios/ directory\n' +
+        '- Android: google-services.json in android/app/ directory',
+    )
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+  }
+}
+
+/**
+ * Logs validation results with appropriate console methods
+ */
+export const logValidationResults = (
+  result: ValidationResult,
+  packageName = '@chem-po/firebase-native',
+) => {
+  if (result.errors.length > 0) {
+    console.error(`[${packageName}] Configuration errors found:`)
+    result.errors.forEach(error => console.error(`  ❌ ${error}`))
+  }
+
+  if (result.warnings.length > 0) {
+    console.warn(`[${packageName}] Configuration warnings:`)
+    result.warnings.forEach(warning => console.warn(`  ⚠️  ${warning}`))
+  }
+
+  if (result.isValid && result.warnings.length === 0) {
+    console.log(`[${packageName}] ✅ Configuration validation passed`)
+  }
+}
+
+/**
+ * Validates and logs Firebase auth configuration
+ * Call this during development to identify setup issues early
+ */
+export const validateAndLogAuthConfig = (providers: BaseAuthProvider[]) => {
+  const result = validateAuthConfiguration(providers)
+  logValidationResults(result)
+  return result
+}