@libreapps/auth 3.0.1

package/server/rest-api-handlers.ts

@@ -0,0 +1,33 @@
+import { cookies } from 'next/headers'
+import { NextRequest, NextResponse } from 'next/server'
+import { createSessionCookie, revokeAllSessions } from './firebase-support'
+import type { APIResponse } from '../types'  
+
+export async function handleLogin(request: NextRequest) {
+  const reqBody = (await request.json()) as { idToken: string }
+  const idToken = reqBody.idToken
+
+  const expiresIn = 60 * 60 * 24 * 5 * 1000 // 5 days
+
+  const sessionCookie = await createSessionCookie(idToken, { expiresIn })
+
+  const c = await cookies()
+  c.set('__session', sessionCookie, { maxAge: expiresIn, httpOnly: true, secure: true })
+
+  return NextResponse.json<APIResponse<string>>({ success: true, data: 'Signed in successfully.' })
+}
+
+export async function handleLogout() {
+  const c = await cookies()
+  const sessionCookie = c.get('__session')?.value
+
+  if (!sessionCookie) {
+    return NextResponse.json<APIResponse<string>>({ success: false, error: 'Session not found.' }, { status: 400 })
+  }
+
+  c.delete('__session')
+
+  await revokeAllSessions(sessionCookie)
+
+  return NextResponse.json<APIResponse<string>>({ success: true, data: 'Signed out successfully.' })
+}

package/server/stub-server.ts

@@ -0,0 +1,28 @@
+/**
+ * Stub Server-side Authentication
+ *
+ * Used when Firebase Admin is not configured.
+ * All functions return null/false gracefully.
+ */
+
+import type { LibreAppsUserInfoValue } from '../types'
+
+export async function getUserServerSide(): Promise<LibreAppsUserInfoValue | null> {
+  console.warn('Server-side auth not configured. Install @libreapps/auth-firebase for Firebase support.')
+  return null
+}
+
+export async function generateCustomToken(): Promise<{success: boolean, token: string | null}> {
+  console.warn('Server-side auth not configured. Install @libreapps/auth-firebase for Firebase support.')
+  return { success: false, token: null }
+}
+
+export async function createSessionCookie(_idToken: string, _sessionCookieOptions: any): Promise<string> {
+  console.warn('Server-side auth not configured. Install @libreapps/auth-firebase for Firebase support.')
+  throw new Error('Auth provider not configured')
+}
+
+export async function revokeAllSessions(_session: string): Promise<void> {
+  console.warn('Server-side auth not configured. Install @libreapps/auth-firebase for Firebase support.')
+  throw new Error('Auth provider not configured')
+}

package/service/auth-service.ts

@@ -0,0 +1,21 @@
+import type { LibreAppsUserInfo } from "../types"
+
+type AuthProvider = 'google' | 'facebook' | 'github'
+
+interface AuthService {
+
+  get loggedIn(): boolean 
+  get user(): LibreAppsUserInfo | null // returns current info obj // all fields observable :)
+
+  signupEmailAndPassword: ( email: string,  password: string ) => Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}> 
+  loginEmailAndPassword: ( email: string,  password: string ) => Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}>
+  loginWithProvider: ( provider: AuthProvider ) => Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}> 
+  loginWithCustomToken: ( token: string ) => Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}>
+  associateWallet: () => Promise<void>
+  logout: () => Promise<{success: boolean}>
+}
+
+export {
+  type AuthService as default,
+  type AuthProvider
+}

package/service/context.tsx

@@ -0,0 +1,46 @@
+'use client'
+
+import React, {
+  useContext,
+  type PropsWithChildren
+} from 'react'
+
+import type { AuthServiceConf, LibreAppsUserInfoValue} from '../types'
+import type AuthService from './auth-service'
+import getSingleton from './get-singleton' 
+
+const AuthServiceContext = React.createContext<AuthService | undefined>(undefined)
+
+/* PLEASE LEAVE
+const _log = (s: string) => {
+  const d = new Date()
+  console.log(`TIMESTAMPED: ${d.getUTCMinutes()}:${d.getUTCSeconds()}:${d.getUTCMilliseconds()}`)
+  console.log(s)
+}
+*/
+
+const useAuth = (): AuthService => (
+  useContext(AuthServiceContext) as AuthService
+)
+
+const AuthServiceProvider: React.FC<
+  PropsWithChildren & {
+    conf: AuthServiceConf
+    user: LibreAppsUserInfoValue | null
+  }
+> = ({
+  children,
+  user,
+  conf
+}) => (
+  <AuthServiceContext.Provider value={getSingleton(conf, user)}>
+    {children}
+  </AuthServiceContext.Provider>
+)
+
+
+export {
+  AuthServiceProvider,
+  useAuth
+}
+

package/service/get-singleton.ts

@@ -0,0 +1,37 @@
+import { enableStaticRendering } from 'mobx-react-lite'
+
+import type AuthService from './auth-service'
+import type { AuthServiceConf, LibreAppsUserInfoValue } from '../types'
+import { getActiveProvider } from './provider-registry'
+import { StubAuthService } from './impl/stub-auth-service'
+
+enableStaticRendering(typeof window === "undefined")
+
+// https://dev.to/ivandotv/mobx-server-side-rendering-with-next-js-4m18
+let instance: AuthService | undefined = undefined
+
+const getSingleton = (
+  conf: AuthServiceConf,
+  serverSideUser: LibreAppsUserInfoValue | null
+): AuthService => {
+
+  // Get the registered auth provider, or use stub if none configured
+  const AuthServiceClass = getActiveProvider() ?? StubAuthService
+
+  // For server side rendering always create a new store
+  if (typeof window === "undefined") {
+    return new AuthServiceClass(conf, serverSideUser)
+  }
+
+  // Client side, create the store only once in the client
+  if (!instance) {
+    instance = new AuthServiceClass(conf, serverSideUser)
+  }
+  else if ('setServerSideUser' in instance && typeof instance.setServerSideUser === 'function') {
+    instance.setServerSideUser(serverSideUser)
+  }
+
+  return instance
+}
+
+export default getSingleton

package/service/impl/firebase-support.ts

@@ -0,0 +1,241 @@
+
+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 '../../types/api-response'
+
+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
+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 (isFirebaseConfigured()) {
+  firebaseApp = getApps().length === 0 ? initializeApp(firebaseConfig) : getApps()[0]
+  auth = getAuth(firebaseApp)
+  db = getFirestore(firebaseApp, 'accounts')
+} else {
+  console.warn('Firebase is not configured. Auth features will not work.')
+}
+
+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 Google', error)
+    return { success: false, user: null }
+  }
+}
+
+const isAuthUserNotFound = (e: any) => (
+  typeof e === 'object' &&
+  e !== null &&
+  e.hasOwnProperty('code') &&
+  e.code === 'auth/user-not-found'
+)
+
+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 on on server with Firebase', error)
+    return { success: false }
+  }
+}

package/service/impl/index.ts

@@ -0,0 +1,231 @@
+import { makeAutoObservable, makeObservable, computed  } from 'mobx'
+
+import type AuthService from '../auth-service'
+import type { AuthServiceConf, LibreAppsUserInfo, LibreAppsUserInfoValue } from '../../types'
+
+import { 
+  auth as fbAuth, 
+  signupWithEmailAndPassword,
+  loginWithCustomToken, 
+  loginWithEmailAndPassword,
+  loginWithProvider,
+  logoutBackend 
+} 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)  
+  }
+}
+
+
+
+class AuthServiceImpl implements AuthService {
+
+  private _hzUser = new LibreAppsUserInfoStore()
+
+  constructor(conf: AuthServiceConf, user: LibreAppsUserInfoValue | null) {
+
+    makeObservable(this, {
+      loggedIn: computed,
+      user: computed
+    })
+      // ignore conf for now
+    if (user) {
+      this._hzUser.set(user)
+    }
+  }
+
+  get user(): LibreAppsUserInfo | null {
+    return this._hzUser.isValid ? this._hzUser : null
+  }
+
+  get loggedIn(): boolean {
+    return (
+      /*!!fbAuth.currentUser &&*/ 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) {
+        //runInAction(() => {
+          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 AuthServiceImpl