@libreapps/auth-firebase 1.1.1

package/service/firebase-auth-service.ts

@@ -0,0 +1,233 @@
+/**
+ * Firebase Authentication Service Implementation
+ * Implements the AuthService interface using Firebase as the auth provider.
+ */
+
+import { makeAutoObservable, makeObservable, computed } from 'mobx'
+
+import type { AuthService, AuthServiceConf, LibreAppsUserInfo, LibreAppsUserInfoValue } from '@libreapps/auth'
+
+import {
+  auth as fbAuth,
+  signupWithEmailAndPassword,
+  loginWithCustomToken,
+  loginWithEmailAndPassword,
+  loginWithProvider,
+  logoutBackend,
+  isFirebaseConfigured
+} from './firebase-support'
+import { associateWalletAddressWithAccount, getAssociatedWalletAddress } from './wallet-support'
+
+class LibreAppsUserInfoStore implements LibreAppsUserInfo {
+
+  constructor() {
+    makeAutoObservable(this)
+  }
+
+  _email: string = ''
+  _displayName: string | null = null
+  _walletAddress: string | null = null
+
+  get email(): string { return this._email}
+  get displayName(): string | null { return this._displayName}
+  get walletAddress(): string | null { return this._walletAddress}
+
+  clear():void  {
+    this._email = ''
+    this._displayName = null
+    this._walletAddress = null
+  }
+
+  set(v: LibreAppsUserInfoValue):void {
+    this._email = v.email
+    this._displayName = v.displayName
+    this._walletAddress = v.walletAddress
+  }
+
+  get isValid(): boolean {
+    return (this._email.length > 0)
+  }
+}
+
+export class FirebaseAuthService implements AuthService {
+
+  private _hzUser = new LibreAppsUserInfoStore()
+
+  constructor(conf: AuthServiceConf, user: LibreAppsUserInfoValue | null) {
+    makeObservable(this, {
+      loggedIn: computed,
+      user: computed
+    })
+
+    if (user) {
+      this._hzUser.set(user)
+    }
+  }
+
+  static isConfigured(): boolean {
+    return isFirebaseConfigured()
+  }
+
+  get user(): LibreAppsUserInfo | null {
+    return this._hzUser.isValid ? this._hzUser : null
+  }
+
+  get loggedIn(): boolean {
+    return this._hzUser.isValid
+  }
+
+  signupEmailAndPassword = async (
+    email: string,
+    password: string
+   ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}> => {
+
+    try {
+      this._hzUser.clear()
+      const res = await signupWithEmailAndPassword(email, password)
+      if (res.success && res.user) {
+        const walletAddress = res.user.email ? await getAssociatedWalletAddress(res.user.email) : undefined
+        this._hzUser.set({
+          email: res.user.email ?? '',
+          displayName : res.user.displayName ?? null,
+          walletAddress : walletAddress?.result ?? null
+        })
+
+        return {
+          success: true,
+          userInfo: this._hzUser,
+          message: res.message
+        }
+      }
+      return {
+        success: false,
+        userInfo: null,
+        message: res.message
+      }
+    }
+    catch (e) {
+      console.error('Error signing in with Firebase auth', e)
+      return {success: false, userInfo: null, message: 'Error signing in with Firebase auth'}
+    }
+  }
+
+  loginEmailAndPassword = async (
+    email: string,
+    password: string
+   ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}> => {
+
+    try {
+      this._hzUser.clear()
+      const res = await loginWithEmailAndPassword(email, password)
+      if (res.success && res.user) {
+        const walletAddress = res.user.email ? await getAssociatedWalletAddress(res.user.email) : undefined
+        this._hzUser.set({
+          email: res.user.email ?? '',
+          displayName : res.user.displayName ?? null,
+          walletAddress : walletAddress?.result ?? null
+        })
+
+        return {
+          success: true,
+          userInfo: this._hzUser,
+          message: res.message
+        }
+      }
+      return {
+        success: false,
+        userInfo: null,
+        message: res.message
+      }
+    }
+    catch (e) {
+      console.error('Error signing in with Firebase auth', e)
+      return {success: false, userInfo: null, message: 'Error signing in with Firebase auth'}
+    }
+  }
+
+  loginWithProvider = async (
+    provider: 'google' | 'facebook' | 'github'
+   ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}> => {
+
+    try {
+      this._hzUser.clear()
+      const res = await loginWithProvider(provider)
+      if (res.success && res.user) {
+        const walletAddress = res.user.email ? await getAssociatedWalletAddress(res.user.email) : undefined
+        this._hzUser.set({
+          email: res.user.email ?? '',
+          displayName : res.user.displayName ?? null,
+          walletAddress : walletAddress?.result ?? null
+        })
+
+        return {
+          success: true,
+          userInfo: this._hzUser
+        }
+      }
+      return {
+        success: false,
+        userInfo: null
+      }
+    }
+    catch (e) {
+      console.error('Error signing in with Firebase auth', e)
+      return {success: false, userInfo: null}
+    }
+  }
+
+  loginWithCustomToken = async (
+    token: string
+   ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}> => {
+
+    try {
+      this._hzUser.clear()
+      const res = await loginWithCustomToken(token)
+      if (res.success && res.user) {
+        const walletAddress = res.user.email ? await getAssociatedWalletAddress(res.user.email) : undefined
+        this._hzUser.set({
+          email: res.user.email ?? '',
+          displayName : res.user.displayName ?? null,
+          walletAddress : walletAddress?.result ?? null
+        })
+
+        return {
+          success: true,
+          userInfo: this._hzUser
+        }
+      }
+      return {
+        success: false,
+        userInfo: null
+      }
+    }
+    catch (e) {
+      console.error('Error signing in with Firebase auth', e)
+      return {success: false, userInfo: null}
+    }
+  }
+
+  associateWallet = async (): Promise<void>  => {
+    if (this._hzUser.isValid) {
+      const res = await associateWalletAddressWithAccount(this._hzUser.email)
+      if (!res.error) {
+        this._hzUser._walletAddress = res.result ?? null
+      }
+    }
+  }
+
+  logout = async (): Promise<{ success: boolean }> => {
+    if (fbAuth) {
+      await fbAuth.signOut()
+    }
+    this._hzUser.clear()
+    return await logoutBackend()
+  }
+
+  setServerSideUser = (user: LibreAppsUserInfoValue | null) => {
+    if (user) {
+      this._hzUser.set(user)
+    }
+  }
+}
+
+export default FirebaseAuthService

package/service/firebase-support.ts

@@ -0,0 +1,234 @@
+/**
+ * Firebase Client-side Authentication Support
+ * This module provides Firebase authentication methods for the client-side.
+ */
+
+import {
+  FacebookAuthProvider,
+  GoogleAuthProvider,
+  GithubAuthProvider,
+  signInWithPopup,
+  createUserWithEmailAndPassword,
+  type User,
+  signInWithEmailAndPassword,
+  signInWithCustomToken,
+  type Auth,
+} from 'firebase/auth'
+
+import { initializeApp, getApps, FirebaseError, type FirebaseApp } from "firebase/app"
+import { getAuth } from "firebase/auth"
+import { getFirestore, type Firestore } from 'firebase/firestore'
+
+import type { APIResponse } from '@libreapps/auth/types'
+
+export const firebaseConfig = {
+  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+  authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.NEXT_PUBLIC_FIREBASE_APP_ID,
+}
+
+// Check if Firebase is configured
+export const isFirebaseConfigured = () => {
+  return !!(firebaseConfig.apiKey && firebaseConfig.projectId)
+}
+
+// Initialize Firebase only if configured
+let firebaseApp: FirebaseApp | null = null
+let auth: Auth | null = null
+let db: Firestore | null = null
+
+if (typeof window !== 'undefined' && isFirebaseConfigured()) {
+  firebaseApp = getApps().length === 0 ? initializeApp(firebaseConfig) : getApps()[0]
+  auth = getAuth(firebaseApp)
+  db = getFirestore(firebaseApp, 'accounts')
+}
+
+export { auth, db }
+
+export async function loginWithProvider(provider: string): Promise<{ success: boolean, user: User | null }> {
+  if (!auth) {
+    console.warn('Firebase auth not configured')
+    return { success: false, user: null }
+  }
+
+  const authProvider = (() => {
+    switch (provider) {
+      case 'google':
+        return new GoogleAuthProvider()
+      case 'facebook':
+        return new FacebookAuthProvider()
+      case 'github':
+        return new GithubAuthProvider()
+      default:
+        return null
+    }
+  })()
+
+  if (!authProvider) {
+    return { success: false, user: null }
+  }
+
+  try {
+    const userCreds = await signInWithPopup(auth, authProvider)
+    const idToken = await userCreds.user.getIdToken()
+
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ idToken }),
+    })
+    const resBody = (await response.json()) as unknown as APIResponse<string>
+
+    if (response.ok && resBody.success) {
+      return { success: true, user: userCreds.user }
+    }
+    else {
+      return { success: false, user: null }
+    }
+  }
+  catch (error) {
+    console.error('Error signing in with provider', error)
+    return { success: false, user: null }
+  }
+}
+
+export async function signupWithEmailAndPassword(
+  email: string,
+  password: string
+): Promise<{ success: boolean, user?: User, message?: string }> {
+  if (!auth) {
+    return { success: false, message: 'Firebase auth not configured' }
+  }
+
+  let user: User | undefined = undefined
+  try {
+    const userCredential = await createUserWithEmailAndPassword(auth, email, password)
+    user = userCredential.user
+  }
+  catch (error) {
+    if (error instanceof FirebaseError) {
+      console.error(error.code)
+      return {success: false, message: error.code as string}
+    }
+    return {success: false, message: error as string}
+  }
+
+  try {
+    const idToken = await user.getIdToken()
+
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ idToken }),
+    })
+    const resBody = (await response.json()) as unknown as APIResponse<string>
+
+    if (response.ok && resBody.success) {
+      return { success: true, user }
+    }
+    else {
+      return { success: false }
+    }
+  }
+  catch (error) {
+    console.error('Error signing in with Firebase auth', error)
+    return { success: false }
+  }
+}
+
+export async function loginWithEmailAndPassword(
+  email: string,
+  password: string
+): Promise<{ success: boolean, user?: User, message?: string }> {
+  if (!auth) {
+    return { success: false, message: 'Firebase auth not configured' }
+  }
+
+  let user: User | undefined = undefined
+  try {
+    const userCredential = await signInWithEmailAndPassword(auth, email, password)
+    user = userCredential.user
+  } catch (error) {
+    if (error instanceof FirebaseError) {
+      console.error(error.code)
+      return {success: false, message: error.code as string}
+    }
+    return {success: false, message: error as string}
+  }
+
+  try {
+    const idToken = await user.getIdToken()
+
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ idToken }),
+    })
+    const resBody = (await response.json()) as unknown as APIResponse<string>
+
+    if (response.ok && resBody.success) {
+      return { success: true, user, message: "Login Successfully!" }
+    }
+    else {
+      return { success: false , message: "Login API Failed"}
+    }
+  }
+  catch (error) {
+    console.error('Error signing in with Firebase auth', error)
+    return { success: false, message: "Error signing in with Firebase auth" }
+  }
+}
+
+export async function loginWithCustomToken(
+  token: string,
+): Promise<{ success: boolean, user?: User }> {
+  if (!auth) {
+    return { success: false }
+  }
+
+  let user: User | undefined = undefined
+  const userCredential = await signInWithCustomToken(auth, token)
+  user = userCredential.user
+
+  try {
+    const idToken = await user.getIdToken()
+
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ idToken }),
+    })
+    const resBody = (await response.json()) as unknown as APIResponse<string>
+
+    if (response.ok && resBody.success) {
+      return { success: true, user }
+    }
+    else {
+      return { success: false }
+    }
+  }
+  catch (error) {
+    console.error('Error signing in with Firebase auth', error)
+    return { success: false }
+  }
+}
+
+export async function logoutBackend(): Promise<{ success: boolean }> {
+  try {
+    const response = await fetch('/api/auth/logout', { headers: { 'Content-Type': 'application/json' } })
+    const resBody = (await response.json()) as unknown as APIResponse<string>
+    if (response.ok && resBody.success) {
+      return { success: true }
+    }
+    else {
+      return { success: false }
+    }
+  }
+  catch (error) {
+    console.error('Error logging out on server', error)
+    return { success: false }
+  }
+}

package/service/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Firebase Auth Service exports
+ */
+
+export { default as FirebaseAuthService } from './firebase-auth-service'
+export {
+  auth,
+  db,
+  isFirebaseConfigured,
+  firebaseConfig,
+  loginWithProvider,
+  signupWithEmailAndPassword,
+  loginWithEmailAndPassword,
+  loginWithCustomToken,
+  logoutBackend
+} from './firebase-support'
+export {
+  associateWalletAddressWithAccount,
+  getAssociatedWalletAddress
+} from './wallet-support'

package/service/wallet-support.ts

@@ -0,0 +1,103 @@
+/**
+ * Wallet Support - Firebase Firestore integration for wallet addresses
+ */
+
+import { collection, doc, getDoc, setDoc } from 'firebase/firestore'
+
+import { auth, db } from './firebase-support'
+
+const isObject = (obj: any): obj is Record<any, any> => typeof obj === 'object' && obj !== null
+const isGlobalThisEthereum = (obj: any): obj is { ethereum: { request: <R = any>(payload: Record<any, any>) => Promise<R> } } => isObject(obj) && isObject(obj.ethereum) && typeof obj.ethereum.request === 'function'
+const getEthereum = (obj: any) => isGlobalThisEthereum(obj) ? obj.ethereum : null
+
+const ethereum = getEthereum(globalThis)
+
+let signMessage = (opts: { siteName: string, address: string }) => `${opts.siteName} wants you to sign in with your Ethereum account:\n${opts.address}`
+
+const USER_INFO_COLLECTION = 'HZ_USER_INFO'
+
+async function connectWalletAddress(siteName?: string) {
+  if (!ethereum) {
+    throw new Error('No ethereum provider found')
+  }
+
+  if (!auth) {
+    throw new Error('Firebase auth not configured')
+  }
+
+  const [account] = await ethereum.request<string[]>({ method: 'eth_requestAccounts' })
+
+  if (!account) {
+    throw new Error('No account found')
+  }
+
+  const signed = await ethereum.request<string>({
+    method: 'personal_sign',
+    params: [
+      signMessage({
+        siteName: siteName ?? auth.app.options.projectId ?? globalThis.location.hostname,
+        address: account,
+      }),
+      account,
+      auth.app.options.appId,
+    ],
+  })
+
+  if (!signed) {
+    throw new Error('Not signed')
+  }
+
+  return {account, signed}
+}
+
+export async function associateWalletAddressWithAccount(userEmail: string, siteName?: string) {
+  const {account} = await connectWalletAddress(siteName)
+
+  if (!db) {
+    return { result: null, error: new Error('Firebase Firestore not configured') }
+  }
+
+  let result = null
+  let error = null
+  const accountsRef = collection(db, USER_INFO_COLLECTION)
+
+  try {
+    try {
+      await setDoc(doc(accountsRef, userEmail), { walletAddress: account })
+      result = account
+    } catch (e) {
+      console.error(e)
+      error = e
+    }
+  } catch (e) {
+    console.error(e)
+    error = e
+  }
+
+  return { result, error }
+}
+
+export async function getAssociatedWalletAddress(userEmail: string) : Promise<{error: any, result?: string}> {
+  if (!db) {
+    return { error: new Error('Firebase Firestore not configured'), result: undefined }
+  }
+
+  let result = undefined
+  let error = null
+  try {
+    try {
+      const docRef = await getDoc(doc(db, USER_INFO_COLLECTION, userEmail))
+      result = docRef.data() ? docRef.data()!.walletAddress as string : undefined
+    }
+    catch (e) {
+      console.error(e)
+      error = e
+    }
+  }
+  catch (e) {
+    console.error(e)
+    error = e
+  }
+
+  return { result, error }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.libreapps.base.json",
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true
+  }
+}