@bagelink/auth 1.4.169 → 1.4.174

package/src/useAuth.ts

@@ -1,22 +1,22 @@
 import type { AxiosInstance } from 'axios'
 import type { App } from 'vue'
-import type { User, NewUser, UpdatePasswordForm, AuthEventMap } from './types'
-import { ref } from 'vue'
+import type {
+	AccountInfo,
+	User,
+	NewUser,
+	UpdatePasswordForm,
+	UpdateAccountRequest,
+	AuthEventMap,
+} from './types'
+import { ref, computed } from 'vue'
 import { AuthApi } from './api'
-import { AuthState } from './types'
+import { AuthState, accountToUser } from './types'
 import { EventEmitter } from './utils'
 
 // Global state
 let authApi: AuthApi | null = null
 let eventEmitter: EventEmitter | null = null
-const currentUser = ref<User>({
-	id: '',
-	email: '',
-	first_name: '',
-	last_name: '',
-	is_superuser: false,
-	is_active: false,
-})
+const accountInfo = ref<AccountInfo | null>(null)
 
 // Initialize auth
 export function initAuth({
@@ -26,26 +26,32 @@ export function initAuth({
 	axios: AxiosInstance
 	baseURL?: string
 }) {
-	if (!authApi) {
+	if (authApi === null) {
 		authApi = new AuthApi(axios, baseURL)
 	}
 
-	if (!eventEmitter) {
+	if (eventEmitter === null) {
 		eventEmitter = new EventEmitter()
 	}
 
 	return {
 		// Event listener methods
 		on<K extends AuthState>(event: K, handler: AuthEventMap[K]): void {
-			eventEmitter!.on(event, handler)
+			if (eventEmitter) {
+				eventEmitter.on(event, handler)
+			}
 		},
 
 		off<K extends AuthState>(event: K, handler: AuthEventMap[K]): void {
-			eventEmitter!.off(event, handler)
+			if (eventEmitter) {
+				eventEmitter.off(event, handler)
+			}
 		},
 
 		removeAllListeners<K extends AuthState>(event?: K): void {
-			eventEmitter!.removeAllListeners(event)
+			if (eventEmitter) {
+				eventEmitter.removeAllListeners(event)
+			}
 		},
 
 		install(app: App) {
@@ -57,147 +63,243 @@ export function initAuth({
 
 // Composable
 export function useAuth() {
-	if (!authApi) {
+	if (authApi === null) {
 		throw new Error('Auth not initialized. Call initAuth first.')
 	}
 
+	if (eventEmitter === null) {
+		throw new Error('Event emitter not initialized. Call initAuth first.')
+	}
+
+	const api = authApi
+	const emitter = eventEmitter
+
+	// Computed user - the primary interface for accessing user data
+	const user = computed<User | null>(() => accountToUser(accountInfo.value))
+
 	// Getters
-	const getFullName = () => `${currentUser.value.first_name} ${currentUser.value.last_name}`
-	const getIsLoggedIn = () => currentUser.value.id.length > 0
+	const getFullName = () => {
+		return user.value?.name ?? ''
+	}
+
+	const getIsLoggedIn = () => {
+		return user.value !== null
+	}
+
+	const getEmail = () => {
+		return user.value?.email ?? ''
+	}
+
+	const getRoles = () => {
+		return user.value?.roles ?? []
+	}
+
+	const getAccountType = () => {
+		return user.value?.type ?? 'person'
+	}
+
+	const isPersonAccount = () => {
+		return user.value?.type === 'person'
+	}
+
+	const isEntityAccount = () => {
+		return user.value?.type === 'entity'
+	}
 
 	// Actions
 	async function logout() {
-		try {
-			await authApi!.logout()
-			// Reset current user
-			currentUser.value = {
-				id: '',
-				email: '',
-				first_name: '',
-				last_name: '',
-				is_superuser: false,
-				is_active: false,
-			}
-			eventEmitter!.emit(AuthState.LOGOUT)
-		} catch (error) {
-			throw error
-		}
+		// Call logout API
+		const logoutPromise = api.logout()
+		await logoutPromise.catch(() => {
+			// Ignore logout errors
+		})
+		// Clear local state regardless of API result
+		accountInfo.value = null
+		// Emit logout event
+		emitter.emit(AuthState.LOGOUT)
 	}
 
 	async function login(credentials: { email: string, password: string }) {
-		try {
-			await authApi!.login(
-				credentials.email.toLowerCase(),
-				credentials.password
-			)
+		const { data } = await api.login(
+			credentials.email.toLowerCase(),
+			credentials.password
+		)
+
+		// If successful and not requiring verification, fetch user data
+		if (data.success === true && data.requires_verification !== true) {
 			await checkAuth()
-			eventEmitter!.emit(AuthState.LOGIN)
-		} catch (error) {
-			throw error
 		}
+
+		emitter.emit(AuthState.LOGIN)
+		return data
 	}
 
 	async function checkAuth(): Promise<boolean> {
 		try {
-			if (!getIsLoggedIn()) {
-				const { data } = await authApi!.getCurrentUser()
-				currentUser.value = data
-				if (getIsLoggedIn()) {
-					eventEmitter!.emit(AuthState.AUTH_CHECK)
-				}
+			const { data } = await api.getCurrentUser()
+			accountInfo.value = data
+			if (getIsLoggedIn()) {
+				emitter.emit(AuthState.AUTH_CHECK)
 			}
-		} catch (error) {
+			return true
+		} catch {
+			accountInfo.value = null
 			return false
 		}
-		return getIsLoggedIn()
 	}
 
-	async function signup(user: NewUser) {
-		try {
-			if (user.password !== user.confirmPassword) {
-				throw new Error('Passwords do not match')
-			}
-			const { data } = await authApi!.signup(user)
-			currentUser.value = data
-			eventEmitter!.emit(AuthState.SIGNUP)
-		} catch (error) {
-			throw error
+	async function signup(newUser: NewUser) {
+		// Check password match if password is provided
+		const hasPassword = newUser.password !== undefined && newUser.password.length > 0
+		if (hasPassword && newUser.password !== newUser.confirmPassword) {
+			throw new Error('Passwords do not match')
 		}
-	}
 
-	async function recoverPassword(email: string) {
-		try {
-			await authApi!.passwordRecovery(email)
-		} catch (error) {
-			throw error
+		const { data } = await api.register({
+			email: newUser.email,
+			first_name: newUser.first_name,
+			last_name: newUser.last_name,
+			phone_number: newUser.phone_number,
+			password: newUser.password,
+		})
+
+		// If successful and not requiring verification, fetch user data
+		if (data.success === true && data.requires_verification !== true) {
+			await checkAuth()
 		}
+
+		emitter.emit(AuthState.SIGNUP)
+		return data
 	}
 
-	async function resetPassword(newPassword: string) {
-		try {
-			await authApi!.resetPassword(newPassword)
-			eventEmitter!.emit(AuthState.PASSWORD_RESET)
-		} catch (error) {
-			throw error
-		}
+	async function forgotPassword(email: string) {
+		await api.forgotPassword(email)
 	}
 
-	async function updatePassword(form: UpdatePasswordForm) {
-		try {
-			if (form.new_password !== form.confirmNewPassword) {
-				throw new Error('Passwords do not match')
-			}
-			await authApi!.updatePassword(form)
-			eventEmitter!.emit(AuthState.PASSWORD_RESET)
-		} catch (error) {
-			throw error
-		}
+	async function verifyResetToken(token: string) {
+		await api.verifyResetToken(token)
 	}
 
-	async function updateProfile(user: Partial<User>) {
-		try {
-			const { data } = await authApi!.updateUserProfile(user)
-			currentUser.value = { ...currentUser.value, ...data }
-			eventEmitter!.emit(AuthState.PROFILE_UPDATE)
-		} catch (error) {
-			throw error
+	async function resetPassword(token: string, newPassword: string) {
+		await api.resetPassword({ token, new_password: newPassword })
+		emitter.emit(AuthState.PASSWORD_RESET)
+	}
+
+	async function changePassword(form: UpdatePasswordForm) {
+		if (form.new_password !== form.confirmNewPassword) {
+			throw new Error('Passwords do not match')
 		}
+		await api.changePassword({
+			current_password: form.current_password,
+			new_password: form.new_password,
+		})
+		emitter.emit(AuthState.PASSWORD_CHANGE)
 	}
 
-	async function toggleUserStatus(userId: string, isActive: boolean) {
-		try {
-			await authApi!.setUserStatus(userId, isActive)
-		} catch (error) {
-			throw error
+	async function updateProfile(updates: UpdateAccountRequest) {
+		const { data } = await api.updateCurrentUser(updates)
+		accountInfo.value = data
+		emitter.emit(AuthState.PROFILE_UPDATE)
+	}
+
+	async function activateAccount(accountId: string) {
+		await api.activateAccount(accountId)
+	}
+
+	async function deactivateAccount(accountId: string) {
+		await api.deactivateAccount(accountId)
+	}
+
+	async function deleteAccount(accountId: string) {
+		await api.deleteAccount(accountId)
+	}
+
+	async function deleteCurrentUser() {
+		await api.deleteCurrentUser()
+		accountInfo.value = null
+	}
+
+	async function sendVerification(email?: string) {
+		await api.sendVerification({ email })
+	}
+
+	async function verifyEmail(token: string) {
+		await api.verifyEmail(token)
+		// Refresh user data to get updated verification status
+		await checkAuth()
+		emitter.emit(AuthState.EMAIL_VERIFIED)
+	}
+
+	async function refreshSession() {
+		await api.refreshSession()
+		emitter.emit(AuthState.SESSION_REFRESH)
+	}
+
+	async function getSessions(accountId?: string) {
+		const id = accountId ?? user.value?.accountId
+		if (id === undefined || id === '') {
+			throw new Error('No account ID available')
 		}
+		return api.getSessions(id)
 	}
 
-	async function deleteUser(userId: string) {
-		try {
-			await authApi!.deleteUser(userId)
-		} catch (error) {
-			throw error
+	async function revokeSession(sessionToken: string) {
+		await api.revokeSession(sessionToken)
+	}
+
+	async function revokeAllSessions(accountId?: string) {
+		const id = accountId ?? user.value?.accountId
+		if (id === undefined || id === '') {
+			throw new Error('No account ID available')
 		}
+		await api.revokeAllSessions(id)
 	}
 
 	return {
-		// State
-		currentUser,
+		// Primary State (use this!)
+		user,
+
+		// Full account info (for advanced use cases)
+		accountInfo,
 
 		// Getters
 		getFullName,
 		getIsLoggedIn,
+		getEmail,
+		getRoles,
+		getAccountType,
+		isPersonAccount,
+		isEntityAccount,
 
-		// Actions
-		logout,
+		// Authentication Actions
 		login,
-		checkAuth,
+		logout,
 		signup,
-		recoverPassword,
-		resetPassword,
-		updatePassword,
+		checkAuth,
+		refreshSession,
+
+		// Profile Actions
 		updateProfile,
-		toggleUserStatus,
-		deleteUser,
+		deleteCurrentUser,
+
+		// Password Actions
+		changePassword,
+		forgotPassword,
+		verifyResetToken,
+		resetPassword,
+
+		// Email Verification Actions
+		sendVerification,
+		verifyEmail,
+
+		// Admin Actions
+		activateAccount,
+		deactivateAccount,
+		deleteAccount,
+
+		// Session Management
+		getSessions,
+		revokeSession,
+		revokeAllSessions,
 	}
 }