@chem-po/firebase-native 0.0.16 → 0.0.17

package/lib/typescript/types/storage.d.ts

@@ -0,0 +1,3 @@
+import { getStorage } from '@react-native-firebase/storage';
+export type Storage = ReturnType<typeof getStorage>;
+//# sourceMappingURL=storage.d.ts.map

package/lib/typescript/types/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/types/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAE3D,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/package.json

@@ -1,18 +1,35 @@
 {
   "name": "@chem-po/firebase-native",
-  "version": "0.0.16",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "author": "Elan Canfield",
+  "license": "MIT",
+  "version": "0.0.17",
+  "main": "lib/commonjs/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "source": "src/index.ts",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "react-native": "src/index.ts"
   },
   "sideEffects": false,
   "keywords": [],
   "files": [
-    "dist"
+    "src",
+    "lib",
+    "android",
+    "cpp",
+    "*.podspec",
+    "!lib/typescript/example",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
   ],
-  "author": "",
-  "license": "ISC",
   "dependencies": {
     "@react-native-google-signin/google-signin": "^14.0.1",
     "@react-native-firebase/app": "^22.2.0",
@@ -26,9 +43,9 @@
     "react-native-paper": "^5.14.3",
     "react-native-svg": "15.11.2",
     "zustand": "^4.3.3",
-    "@chem-po/core": "0.0.16",
-    "@chem-po/react-native": "0.0.16",
-    "@chem-po/react": "0.0.16"
+    "@chem-po/react": "0.0.17",
+    "@chem-po/core": "0.0.17",
+    "@chem-po/react-native": "0.0.17"
   },
   "devDependencies": {
     "@babel/core": "^7.26.0",
@@ -69,7 +86,7 @@
     "lint": "pnpm type-check && eslint . --fix",
     "build": "bob build",
     "prebuild": "pnpm lint",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf lib"
   },
-  "module": "dist/index.js"
+  "module": "lib/module/index.js"
 }

package/src/adapter/auth.ts

@@ -0,0 +1,281 @@
+import {
+  AuthAdapter,
+  BaseAuthProvider,
+  BaseUserData,
+  BaseUserRole,
+  EnrollmentFactor,
+  EnrollmentFactorsResult,
+  LoginResult,
+  MultiFactorVerification,
+  WithMultiFactorVerified,
+} from '@chem-po/core'
+import {
+  FirebaseAuthTypes,
+  getIdTokenResult,
+  getMultiFactorResolver,
+  GoogleAuthProvider,
+  onAuthStateChanged,
+  PhoneAuthProvider,
+  PhoneMultiFactorGenerator,
+  sendPasswordResetEmail,
+  signInWithCredential,
+  signInWithCustomToken,
+  signInWithEmailAndPassword,
+  signOut,
+} from '@react-native-firebase/auth'
+
+import { GoogleSignin } from '@react-native-google-signin/google-signin'
+import { Auth, User } from '../types/auth'
+
+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>
+}
+
+const toEnrollmentFactor = (hint: FirebaseAuthTypes.MultiFactorInfo): EnrollmentFactor => {
+  if (hint.factorId === PhoneMultiFactorGenerator.FACTOR_ID) {
+    return {
+      type: 'phone',
+      phoneNumber: (hint as FirebaseAuthTypes.PhoneMultiFactorInfo).phoneNumber,
+      enrollmentTime: hint.enrollmentTime,
+      displayName: (hint as FirebaseAuthTypes.PhoneMultiFactorInfo).displayName,
+      uid: hint.uid,
+    }
+  }
+  if (hint.factorId === 'totp') {
+    return {
+      type: 'totp',
+      enrollmentTime: hint.enrollmentTime,
+      displayName: hint.displayName,
+      uid: hint.uid,
+    }
+  }
+  throw new Error('Unsupported factor type: ' + hint.factorId)
+}
+
+const toFirebaseFactor = (factor: EnrollmentFactor): FirebaseAuthTypes.MultiFactorInfo => {
+  if (factor.type === 'phone') {
+    return {
+      factorId: PhoneMultiFactorGenerator.FACTOR_ID,
+      phoneNumber: factor.phoneNumber,
+      enrollmentTime: factor.enrollmentTime,
+      uid: factor.uid,
+      displayName: factor.displayName,
+    }
+  }
+  if (factor.type === 'totp') {
+    return {
+      factorId: 'totp',
+      enrollmentTime: factor.enrollmentTime,
+      uid: factor.uid,
+      displayName: factor.displayName,
+    }
+  }
+  throw new Error(
+    `Unsupported factor type: ${(factor as FirebaseAuthTypes.MultiFactorInfo).factorId ?? 'Missing factor type'}`
+  )
+}
+
+const sendMultiFactorCode = async (
+  auth: Auth,
+  factor: EnrollmentFactor,
+  resolver: FirebaseAuthTypes.MultiFactorResolver
+): Promise<MultiFactorVerification> => {
+  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,
+    }
+  }
+  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,
+  }
+}
+
+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) }
+}
+
+const handleSignInError = async (error: any): Promise<LoginResult<User>> => {
+  if (error.code === 'auth/multi-factor-auth-required') {
+    return { requestArgs: error }
+  }
+  throw error
+}
+
+const initializeProvider = async (provider: BaseAuthProvider) => {
+  if (providerInitialized[provider.name]) return
+  switch (provider.name) {
+    case 'google':
+      if (!(provider as GoogleAuthProvider).webClientId) {
+        throw new Error(
+          'Google web client ID is required when using Google Auth. Refer to react native firebase docs for more information.'
+        )
+      }
+      await GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true })
+      GoogleSignin.configure({
+        webClientId: (provider as any).webClientId,
+      })
+      break
+    case 'email':
+      // Native SDK doesn't need special initialization
+      break
+    default:
+      throw new Error(`Unsupported provider: ${provider.name}`)
+  }
+
+  providerInitialized[provider.name] = true
+}
+
+const handleInitialLogin = async (
+  userCredential: FirebaseAuthTypes.UserCredential,
+  twoFactorRequired: boolean
+): Promise<LoginResult<User>> => {
+  const user = userCredential.user
+  if (!user) throw new Error('No user found')
+  if (twoFactorRequired) {
+    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 loginWithGoogle = async (
+  auth: Auth,
+  twoFactorRequired: boolean
+): Promise<LoginResult<User>> => {
+  try {
+    const signInResult = await GoogleSignin.signIn()
+    const idToken = signInResult.data?.idToken
+    if (!idToken) {
+      throw new Error('No ID token found')
+    }
+    const googleCredential = GoogleAuthProvider.credential(idToken)
+    const userCredential = await signInWithCredential(auth, googleCredential)
+    return await handleInitialLogin(userCredential, twoFactorRequired)
+  } catch (error) {
+    return await handleSignInError(error)
+  }
+}
+
+const getLoginWithPassword =
+  (auth: Auth, twoFactorRequired: boolean) =>
+  async (
+    provider: BaseAuthProvider,
+    { email, password }: { email: string; password: string }
+  ): Promise<LoginResult<User>> => {
+    await initializeProvider(provider)
+    try {
+      const userCredential = await signInWithEmailAndPassword(auth, email, password)
+      return await handleInitialLogin(userCredential, twoFactorRequired)
+    } catch (error) {
+      return await handleSignInError(error)
+    }
+  }
+
+const getLoginWithPopup =
+  (auth: Auth, twoFactorRequired: boolean) =>
+  async (provider: BaseAuthProvider): Promise<LoginResult<User>> => {
+    await initializeProvider(provider)
+    switch (provider.name) {
+      case 'google':
+        return loginWithGoogle(auth, twoFactorRequired)
+      default:
+        throw new Error(`Unsupported provider: ${provider.name}`)
+    }
+  }
+
+const getLoginWithToken =
+  (auth: Auth, twoFactorRequired: boolean) =>
+  async (provider: BaseAuthProvider, token: string): Promise<LoginResult<User>> => {
+    await initializeProvider(provider)
+    try {
+      const userCredential = await signInWithCustomToken(auth, token)
+      return await handleInitialLogin(userCredential, twoFactorRequired)
+    } catch (error) {
+      return await handleSignInError(error)
+    }
+  }
+
+const resetPassword = async (
+  auth: Auth,
+  provider: BaseAuthProvider,
+  usernameOrEmail: string
+): Promise<void> => {
+  await initializeProvider(provider)
+  await sendPasswordResetEmail(auth, usernameOrEmail)
+}
+
+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) => {
+      if (!user) {
+        callback(null)
+        return
+      }
+      getUserWithRole(user).then((result) => {
+        callback(result)
+      })
+    })
+  },
+})

package/src/adapter/db.ts

@@ -0,0 +1,146 @@
+import {
+  addMetadata,
+  AnyObject,
+  BaseError,
+  DatabaseAdapter,
+  DBItem,
+  OnError,
+  OnItemData,
+  Unsubscribe,
+  WithMetadata,
+} from '@chem-po/core'
+import { useAuth } from '@chem-po/react'
+import {
+  deleteDoc,
+  doc,
+  FirebaseFirestoreTypes,
+  getDoc,
+  getDocs,
+  onSnapshot,
+  setDoc,
+} from '@react-native-firebase/firestore'
+import { httpsCallable } from '@react-native-firebase/functions'
+import { toCursorQuery, toFirestoreQuery } from '../db/utils'
+import { Firestore, FirestoreBaseQuery, FirestoreCursor, FirestoreOnItemsData } from '../types/db'
+import { Functions } from '../types/functions'
+// import { BaseQuery, FirestoreCursor } from '../types/db'
+
+const handleFirestoreError = (error: any): BaseError => ({
+  code: error?.code ?? 'unknown',
+  message: error?.name ?? 'Unknown Error',
+  description: error?.message ?? 'An unknown error occurred',
+})
+
+const toDBItem = <T extends AnyObject>(
+  doc: FirebaseFirestoreTypes.DocumentSnapshot<T>,
+): DBItem<T> => ({
+  ...(doc.data() as WithMetadata<T>),
+  id: doc.id,
+})
+
+const getSubscribeToQuery =
+  (db: Firestore) =>
+  <T extends AnyObject>(
+    baseQuery: FirestoreBaseQuery<T>,
+    onData: FirestoreOnItemsData<T>,
+    onError: OnError,
+  ): Unsubscribe => {
+    const q = toFirestoreQuery<T>(db, baseQuery)
+    return onSnapshot(
+      q,
+      snapshot => {
+        const items = snapshot.docs.map(doc => toDBItem(doc))
+        onData(items, snapshot.docs[snapshot.docs.length - 1] as FirestoreCursor)
+      },
+      error => onError(handleFirestoreError(error)),
+    )
+  }
+
+const getFetchNextCursor =
+  (db: Firestore) =>
+  async <T extends AnyObject>(
+    baseQuery: FirestoreBaseQuery<T>,
+  ): Promise<FirestoreCursor | null> => {
+    const { cursor } = baseQuery
+    const cursorDoc = cursor ? await getDoc(doc(db, baseQuery.collection, cursor.id)) : null
+    const q = toCursorQuery<T>(db, baseQuery, cursorDoc as FirestoreCursor | null)
+    const snapshot = await getDocs(q)
+    return (snapshot.docs[0] ?? null) as FirestoreCursor | null
+  }
+
+const getFetchCount =
+  (functions: Functions) =>
+  async <T extends AnyObject>(baseQuery: FirestoreBaseQuery<T>): Promise<number> => {
+    const fetchCountFunc = httpsCallable(functions, 'getQueryCount')
+    const { data } = await fetchCountFunc(baseQuery)
+    return (data as { count: number }).count
+  }
+
+const getFetchItem =
+  (db: Firestore) =>
+  async <T extends AnyObject>(path: string): Promise<DBItem<T> | null> => {
+    const docRef = doc(db, path)
+    const docSnap = await getDoc(docRef)
+    const data = docSnap.data()
+    return data ? ({ ...data, id: docSnap.id } as DBItem<T>) : null
+  }
+
+const getFetchItems =
+  (db: Firestore) =>
+  async <T extends AnyObject>(baseQuery: FirestoreBaseQuery<T>): Promise<DBItem<T>[]> => {
+    const q = toFirestoreQuery<T>(db, baseQuery)
+    const snapshot = await getDocs(q)
+    return snapshot.docs.map(doc => ({ ...doc.data(), id: doc.id }) as DBItem<T>)
+  }
+
+const getCreateItem =
+  (db: Firestore) =>
+  async (path: string, item: AnyObject): Promise<string> => {
+    const docRef = doc(db, path)
+    const data = addMetadata(useAuth.getState().user, item, true)
+    await setDoc(docRef, data, { merge: true })
+    return docRef.id
+  }
+
+const getDeleteItem =
+  (db: Firestore) =>
+  async (path: string): Promise<void> => {
+    const docRef = doc(db, path)
+    await deleteDoc(docRef)
+  }
+
+const getUpdateItem =
+  (db: Firestore) =>
+  async <T extends AnyObject>(path: string, item: Partial<T>): Promise<void> => {
+    const docRef = doc(db, path)
+    await setDoc(docRef, item, { merge: true })
+  }
+
+const getSubscribeToItem =
+  (db: Firestore) =>
+  <T extends AnyObject>(path: string, onData: OnItemData<T>, onError: OnError): Unsubscribe => {
+    const docRef = doc(db, path)
+    return onSnapshot(
+      docRef,
+      snapshot => {
+        const data = snapshot.data()
+        onData(data ? ({ ...data, id: snapshot.id } as DBItem<T>) : null)
+      },
+      error => onError(handleFirestoreError(error)),
+    )
+  }
+
+export const getFirebaseDatabaseAdapter = (
+  db: Firestore,
+  functions: Functions,
+): DatabaseAdapter<FirestoreCursor> => ({
+  fetchNextCursor: getFetchNextCursor(db),
+  fetchCount: getFetchCount(functions),
+  fetchItem: getFetchItem(db),
+  fetchItems: getFetchItems(db),
+  createItem: getCreateItem(db),
+  deleteItem: getDeleteItem(db),
+  updateItem: getUpdateItem(db),
+  subscribeToItem: getSubscribeToItem(db),
+  subscribeToQuery: getSubscribeToQuery(db),
+})

package/src/adapter/index.ts

@@ -0,0 +1,30 @@
+import { BackendAdapter, BaseAuthProvider } from '@chem-po/core'
+import { FirebaseStorageTypes } from '@react-native-firebase/storage'
+import { Auth, EmailPasswordLogin, User } from '../types/auth'
+import { Firestore, FirestoreCursor } from '../types/db'
+import { Functions } from '../types/functions'
+import { Storage } from '../types/storage'
+import { getFirebaseAuthAdapter } from './auth'
+import { getFirebaseDatabaseAdapter } from './db'
+import { getFirebaseStorageAdapter } from './storage'
+
+export type FirebaseAdapter<AuthProvider extends BaseAuthProvider> = BackendAdapter<
+  AuthProvider,
+  User,
+  EmailPasswordLogin,
+  FirestoreCursor,
+  Blob,
+  FirebaseStorageTypes.FullMetadata
+>
+
+export const getFirebaseAdapter = <AuthProvider extends BaseAuthProvider>(
+  auth: Auth,
+  db: Firestore,
+  storage: Storage,
+  functions: Functions,
+  twoFactorRequired: boolean,
+): FirebaseAdapter<AuthProvider> => ({
+  auth: getFirebaseAuthAdapter(auth, twoFactorRequired),
+  db: getFirebaseDatabaseAdapter(db, functions),
+  storage: getFirebaseStorageAdapter(storage),
+})

package/src/adapter/storage.ts

@@ -0,0 +1,58 @@
+import { StorageAdapter, UploadedFileValue } from '@chem-po/core'
+import {
+  deleteObject,
+  getDownloadURL,
+  getMetadata,
+  ref,
+  uploadBytesResumable,
+} from '@react-native-firebase/storage'
+import { Storage } from '../types/storage'
+
+export const getFirebaseStorageAdapter = (storage: Storage): StorageAdapter<Blob, any> => ({
+  delete: async path => {
+    const storageRef = ref(storage, path)
+    await deleteObject(storageRef)
+  },
+  fetchObject: async path => {
+    const storageRef = ref(storage, path)
+    const url = await getDownloadURL(storageRef)
+    const response = await fetch(url)
+    return await response.blob()
+  },
+  fetchMetadata: async path => {
+    const storageRef = ref(storage, path)
+    return await getMetadata(storageRef)
+  },
+  getObjectUrl: async path => {
+    const storageRef = ref(storage, path)
+    return await getDownloadURL(storageRef)
+  },
+  upload: async (path, data, onUploadProgress) => {
+    const storageRef = ref(storage, path)
+    // Convert dataUrl to Blob
+    const blob = await fetch(data.dataUrl).then(res => res.blob())
+    const uploadTask = uploadBytesResumable(storageRef, blob)
+    return new Promise<UploadedFileValue>((resolve, reject) => {
+      uploadTask.on(
+        'state_changed',
+        snapshot => {
+          const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100
+          onUploadProgress({
+            loaded: snapshot.bytesTransferred,
+            total: snapshot.totalBytes,
+            percent: progress,
+          })
+        },
+        error => reject(error),
+        () => {
+          const fileValue: UploadedFileValue = {
+            filename: data.filename,
+            type: data.type,
+            storagePath: path,
+          }
+          resolve(fileValue)
+        },
+      )
+    })
+  },
+})

package/src/auth/functions.ts

@@ -0,0 +1,7 @@
+import { FirebaseFunctionsTypes } from '@react-native-firebase/functions'
+
+export const getThirdPartyAuthUrl = (functions: FirebaseFunctionsTypes.Module) =>
+  functions.httpsCallable('getThirdPartyAuthUrl')
+
+export const getThirdPartyAuthToken = (functions: FirebaseFunctionsTypes.Module) =>
+  functions.httpsCallable('getThirdPartyAuthToken')

package/src/auth/index.ts

@@ -0,0 +1 @@
+export * from './functions'

package/src/components/AuthenticatorVerify.tsx

@@ -0,0 +1,75 @@
+import { LoadingButton, Txt } from '@chem-po/react-native'
+import React from 'react'
+import { StyleSheet, TextInput, View } from 'react-native'
+import { useAuthenticatorVerify } from '../hooks/useAuthenticatorVerify'
+
+export const AuthenticatorVerify = () => {
+  const { code, setCode, verifying, error, handleVerify } = useAuthenticatorVerify()
+
+  return (
+    <View style={styles.wrapper}>
+      <View style={styles.container}>
+        <Txt style={styles.text}>Enter the code on your authenticator app:</Txt>
+        <TextInput
+          style={styles.input}
+          value={code}
+          onChangeText={setCode}
+          placeholder="Verification Code"
+          keyboardType="number-pad"
+          maxLength={6}
+          autoFocus
+        />
+        {error ? <Txt style={styles.errorText}>{error}</Txt> : null}
+        <LoadingButton style={styles.button} onPress={handleVerify} disabled={verifying}>
+          <Txt style={styles.buttonText}>{verifying ? 'Verifying...' : 'Verify'}</Txt>
+        </LoadingButton>
+      </View>
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  wrapper: {
+    flex: 1,
+    padding: 16,
+  },
+  container: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 16,
+  },
+  text: {
+    fontSize: 16,
+    textAlign: 'center',
+    marginBottom: 8,
+  },
+  input: {
+    width: '100%',
+    height: 48,
+    borderWidth: 1,
+    borderColor: '#ccc',
+    borderRadius: 8,
+    paddingHorizontal: 16,
+    fontSize: 16,
+    marginBottom: 8,
+  },
+  button: {
+    backgroundColor: '#007AFF',
+    paddingHorizontal: 24,
+    paddingVertical: 12,
+    borderRadius: 8,
+    minWidth: 200,
+    alignItems: 'center',
+  },
+  buttonText: {
+    color: 'white',
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  errorText: {
+    color: 'red',
+    fontSize: 14,
+    marginBottom: 8,
+  },
+})