@bagelink/auth 1.4.171 → 1.4.174

package/src/types.ts

@@ -83,6 +83,14 @@ export interface AccountInfo {
 	last_login?: string
 	authentication_methods: AuthMethodInfo[]
 	person?: PersonInfo
+	entity?: EntityInfo
+}
+
+export interface EntityInfo {
+	id: string
+	name: string
+	type?: string
+	metadata?: Record<string, any>
 }
 
 export interface SessionInfo {
@@ -94,6 +102,39 @@ export interface SessionInfo {
 	is_current?: boolean
 }
 
+// ============================================
+// Unified User Type (Person or Entity)
+// ============================================
+
+/**
+ * Unified user representation that works for both person and entity accounts
+ * This is the primary interface for accessing user data in the application
+ */
+export interface User {
+	/** Unique identifier (person_id or entity_id) */
+	id: string
+	/** Account ID */
+	accountId: string
+	/** Display name */
+	name: string
+	/** Email address (from person or authentication methods) */
+	email?: string
+	/** Account type: 'person', 'entity', or 'service' */
+	type: AuthenticationAccountType
+	/** User roles (only for person accounts) */
+	roles?: string[]
+	/** Is the account active */
+	isActive: boolean
+	/** Is the account verified */
+	isVerified: boolean
+	/** Last login timestamp */
+	lastLogin?: string
+	/** Entity-specific info (only for entity accounts) */
+	entityType?: string
+	/** Additional metadata */
+	metadata?: Record<string, any>
+}
+
 // ============================================
 // Request Types
 // ============================================
@@ -224,14 +265,59 @@ export type CleanupSessionsResponse = AxiosResponse<MessageResponse>
 export type GetMethodsResponse = AxiosResponse<AvailableMethodsResponse>
 
 // ============================================
-// Legacy Type Aliases (for backward compatibility)
+// Helper Functions (exported for convenience)
 // ============================================
 
-/** @deprecated Use AccountInfo instead */
-export type User = AccountInfo & {
-	email: string
-	first_name?: string
-	last_name?: string
-	is_superuser?: boolean
-	is_active?: boolean
+/**
+ * Extract unified user from account info
+ */
+export function accountToUser(account: AccountInfo | null): User | null {
+	if (account === null) return null
+
+	// Person account - most common case
+	if (account.person !== undefined) {
+		return {
+			id: account.person.id,
+			accountId: account.id,
+			name: account.person.name,
+			email: account.person.email,
+			type: account.account_type as AuthenticationAccountType,
+			roles: account.person.roles,
+			isActive: account.is_active,
+			isVerified: account.is_verified,
+			lastLogin: account.last_login,
+		}
+	}
+
+	// Entity account
+	if (account.entity !== undefined) {
+		return {
+			id: account.entity.id,
+			accountId: account.id,
+			name: account.entity.name,
+			type: account.account_type as AuthenticationAccountType,
+			isActive: account.is_active,
+			isVerified: account.is_verified,
+			lastLogin: account.last_login,
+			entityType: account.entity.type,
+			metadata: account.entity.metadata,
+		}
+	}
+
+	// Fallback - use account info directly
+	// Extract email from authentication methods
+	const emailMethod = account.authentication_methods?.find(
+		m => m.type === 'password' || m.type === 'email_token',
+	)
+
+	return {
+		id: account.id,
+		accountId: account.id,
+		name: account.display_name,
+		email: emailMethod?.identifier,
+		type: account.account_type as AuthenticationAccountType,
+		isActive: account.is_active,
+		isVerified: account.is_verified,
+		lastLogin: account.last_login,
+	}
 }

package/src/useAuth.ts

@@ -2,20 +2,21 @@ import type { AxiosInstance } from 'axios'
 import type { App } from 'vue'
 import type {
 	AccountInfo,
+	User,
 	NewUser,
 	UpdatePasswordForm,
 	UpdateAccountRequest,
 	AuthEventMap,
 } from './types'
-import { ref } from 'vue'
+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<AccountInfo | null>(null)
+const accountInfo = ref<AccountInfo | null>(null)
 
 // Initialize auth
 export function initAuth({
@@ -73,33 +74,36 @@ export function useAuth() {
 	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 = () => {
-		const user = currentUser.value
-		if (user === null) return ''
-		if (user.person !== undefined) return user.person.name
-		return user.display_name ?? ''
+		return user.value?.name ?? ''
 	}
 
 	const getIsLoggedIn = () => {
-		const user = currentUser.value
-		return user !== null && user.id.length > 0
+		return user.value !== null
 	}
 
 	const getEmail = () => {
-		const user = currentUser.value
-		if (user === null) return ''
+		return user.value?.email ?? ''
+	}
 
-		// Try to get email from person info first
-		if (user.person?.email !== undefined) {
-			return user.person.email
-		}
+	const getRoles = () => {
+		return user.value?.roles ?? []
+	}
 
-		// Otherwise look for email in authentication methods
-		const emailMethod = user.authentication_methods?.find(
-			m => m.type === 'password' || m.type === 'email_token'
-		)
-		return emailMethod?.identifier ?? ''
+	const getAccountType = () => {
+		return user.value?.type ?? 'person'
+	}
+
+	const isPersonAccount = () => {
+		return user.value?.type === 'person'
+	}
+
+	const isEntityAccount = () => {
+		return user.value?.type === 'entity'
 	}
 
 	// Actions
@@ -110,7 +114,7 @@ export function useAuth() {
 			// Ignore logout errors
 		})
 		// Clear local state regardless of API result
-		currentUser.value = null
+		accountInfo.value = null
 		// Emit logout event
 		emitter.emit(AuthState.LOGOUT)
 	}
@@ -133,29 +137,30 @@ export function useAuth() {
 	async function checkAuth(): Promise<boolean> {
 		try {
 			const { data } = await api.getCurrentUser()
-			currentUser.value = data
+			accountInfo.value = data
 			if (getIsLoggedIn()) {
 				emitter.emit(AuthState.AUTH_CHECK)
 			}
 			return true
 		} catch {
-			currentUser.value = null
+			accountInfo.value = null
 			return false
 		}
 	}
 
-	async function signup(user: NewUser) {
+	async function signup(newUser: NewUser) {
 		// Check password match if password is provided
-		if (user.password && user.password !== user.confirmPassword) {
+		const hasPassword = newUser.password !== undefined && newUser.password.length > 0
+		if (hasPassword && newUser.password !== newUser.confirmPassword) {
 			throw new Error('Passwords do not match')
 		}
 
 		const { data } = await api.register({
-			email: user.email,
-			first_name: user.first_name,
-			last_name: user.last_name,
-			phone_number: user.phone_number,
-			password: user.password,
+			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
@@ -193,7 +198,7 @@ export function useAuth() {
 
 	async function updateProfile(updates: UpdateAccountRequest) {
 		const { data } = await api.updateCurrentUser(updates)
-		currentUser.value = data
+		accountInfo.value = data
 		emitter.emit(AuthState.PROFILE_UPDATE)
 	}
 
@@ -211,7 +216,7 @@ export function useAuth() {
 
 	async function deleteCurrentUser() {
 		await api.deleteCurrentUser()
-		currentUser.value = null
+		accountInfo.value = null
 	}
 
 	async function sendVerification(email?: string) {
@@ -231,7 +236,7 @@ export function useAuth() {
 	}
 
 	async function getSessions(accountId?: string) {
-		const id = accountId ?? currentUser.value?.id
+		const id = accountId ?? user.value?.accountId
 		if (id === undefined || id === '') {
 			throw new Error('No account ID available')
 		}
@@ -243,7 +248,7 @@ export function useAuth() {
 	}
 
 	async function revokeAllSessions(accountId?: string) {
-		const id = accountId ?? currentUser.value?.id
+		const id = accountId ?? user.value?.accountId
 		if (id === undefined || id === '') {
 			throw new Error('No account ID available')
 		}
@@ -251,13 +256,20 @@ export function useAuth() {
 	}
 
 	return {
-		// State
-		currentUser,
+		// Primary State (use this!)
+		user,
+
+		// Full account info (for advanced use cases)
+		accountInfo,
 
 		// Getters
 		getFullName,
 		getIsLoggedIn,
 		getEmail,
+		getRoles,
+		getAccountType,
+		isPersonAccount,
+		isEntityAccount,
 
 		// Authentication Actions
 		login,