@bagelink/auth 1.1.41 → 1.1.43

package/src/api/auth.ts

@@ -21,88 +21,101 @@ import type {
 	UpdatePasswordResponse,
 	SignupResponse
 } from '../types'
-import { getApi } from './api'
-
-const ax = getApi()
-
-ax.interceptors.request.use((config: InternalAxiosRequestConfig) => {
-	const token = localStorage.getItem('access_token')
-	if (token !== null && config.headers) {
-		config.headers.Authorization = `Bearer ${token}`
+import axios from 'axios'
+
+export class AuthApi {
+	private api: ReturnType<typeof axios.create>
+
+	constructor(baseURL?: string) {
+		this.api = axios.create({
+			baseURL,
+			headers: {
+				'Content-Type': 'application/json',
+			},
+		})
+		this.setupInterceptors()
 	}
 
-	const urlParams = new URLSearchParams(window.location.search)
-	const resetToken = urlParams.get('token')
+	private setupInterceptors() {
+		this.api.interceptors.request.use((config: InternalAxiosRequestConfig) => {
+			const token = localStorage.getItem('access_token')
+			if (token !== null && config.headers) {
+				config.headers.Authorization = `Bearer ${token}`
+			}
+
+			const urlParams = new URLSearchParams(window.location.search)
+			const resetToken = urlParams.get('token')
+
+			if (resetToken !== null && config.headers) {
+				config.headers.Authorization = `Bearer ${resetToken}`
+			}
+			return config
+		})
+	}
 
-	if (resetToken !== null && config.headers) {
-		config.headers.Authorization = `Bearer ${resetToken}`
+	async login(username: string, password: string): Promise<LoginResponse> {
+		const { data } = await this.api.post<Token>('/auth/login', {
+			username: username.toLowerCase(),
+			password,
+		})
+		localStorage.setItem('access_token', data.access_token)
+		return { data } as LoginResponse
 	}
-	return config
-})
-
-export async function login(username: string, password: string): Promise<LoginResponse> {
-	const { data } = await ax.post<Token>('/auth/login', {
-		username: username.toLowerCase(),
-		password,
-	})
-	localStorage.setItem('access_token', data.access_token)
-	return { data } as LoginResponse
-}
 
-export function logout() {
-	localStorage.removeItem('access_token')
-	window.location.reload()
-}
+	logout() {
+		localStorage.removeItem('access_token')
+		window.location.reload()
+	}
 
-export async function passwordRecovery(email?: string): Promise<PasswordRecoveryResponse> {
-	return ax.post('/auth/password-recovery', { email })
-}
+	async passwordRecovery(email?: string): Promise<PasswordRecoveryResponse> {
+		return this.api.post('/auth/password-recovery', { email })
+	}
 
-export async function resetPassword(newPassword: NewPassword['new_password']): Promise<ResetPasswordResponse> {
-	return ax.post('/auth/reset-password', { new_password: newPassword })
-}
+	async resetPassword(newPassword: NewPassword['new_password']): Promise<ResetPasswordResponse> {
+		return this.api.post('/auth/reset-password', { new_password: newPassword })
+	}
 
-// User Management APIs
-export async function getCurrentUser(): Promise<GetMeResponse> {
-	return ax.get<SanitizedUserOut>('/users/me')
-}
+	async getCurrentUser(): Promise<GetMeResponse> {
+		return this.api.get<SanitizedUserOut>('/users/me')
+	}
 
-export async function signup(user: NewUser): Promise<SignupResponse> {
-	return ax.post<SanitizedUserOut>('/users/signup', {
-		email: user.email.toLowerCase(),
-		password: user.password,
-		first_name: user.first_name,
-		last_name: user.last_name,
-	})
-}
+	async signup(user: NewUser): Promise<SignupResponse> {
+		return this.api.post<SanitizedUserOut>('/users/signup', {
+			email: user.email.toLowerCase(),
+			password: user.password,
+			first_name: user.first_name,
+			last_name: user.last_name,
+		})
+	}
 
-export async function updatePassword(form: UpdatePasswordForm): Promise<UpdatePasswordResponse> {
-	return ax.patch('/users/me/password', {
-		current_password: form.current_password,
-		new_password: form.new_password,
-	})
-}
+	async updatePassword(form: UpdatePasswordForm): Promise<UpdatePasswordResponse> {
+		return this.api.patch('/users/me/password', {
+			current_password: form.current_password,
+			new_password: form.new_password,
+		})
+	}
 
-export async function updateUserProfile(user: Partial<User>): Promise<UpdateMeResponse> {
-	return ax.patch<SanitizedUserOut>('/users/me', user)
-}
+	async updateUserProfile(user: Partial<User>): Promise<UpdateMeResponse> {
+		return this.api.patch<SanitizedUserOut>('/users/me', user)
+	}
 
-export async function setUserStatus(userId: string, isActive: boolean): Promise<UpdateUserResponse> {
-	return ax.patch<SanitizedUserOut>(`/users/${userId}`, { is_active: isActive })
-}
+	async setUserStatus(userId: string, isActive: boolean): Promise<UpdateUserResponse> {
+		return this.api.patch<SanitizedUserOut>(`/users/${userId}`, { is_active: isActive })
+	}
 
-export async function deleteUser(userId: string): Promise<DeleteUserResponse> {
-	return ax.delete(`/users/${userId}`)
-}
+	async deleteUser(userId: string): Promise<DeleteUserResponse> {
+		return this.api.delete(`/users/${userId}`)
+	}
 
-export async function getUsers(limit: number = 100, skip?: number): Promise<GetUsersResponse> {
-	return ax.get<SanitizedUserList>('/users/', { params: { skip, limit } })
-}
+	async getUsers(limit: number = 100, skip?: number): Promise<GetUsersResponse> {
+		return this.api.get<SanitizedUserList>('/users/', { params: { skip, limit } })
+	}
 
-export async function createUser(user: UserCreate): Promise<CreateUserResponse> {
-	return ax.post<SanitizedUserOut>('/users/', user)
-}
+	async createUser(user: UserCreate): Promise<CreateUserResponse> {
+		return this.api.post<SanitizedUserOut>('/users/', user)
+	}
 
-export async function getUser(userId: string): Promise<GetUserResponse> {
-	return ax.get<SanitizedUserOut>(`/users/${userId}`)
+	async getUser(userId: string): Promise<GetUserResponse> {
+		return this.api.get<SanitizedUserOut>(`/users/${userId}`)
+	}
 }

package/src/composable/useAuth.ts

@@ -1,124 +1,72 @@
-import type { AxiosInstance } from 'axios'
-import type { User, NewUser, UpdatePasswordForm, ReactiveFactory } from '../types'
-import { createDefaultApi } from '../api/api'
-import * as authApi from '../api/auth'
-
-let api: AxiosInstance
-let onError: ((error: any) => void)
-let createRef: ReactiveFactory
-
-const defaultReactiveFactory: ReactiveFactory = <T>(initial: T) => {
-	let value = initial
-	return {
-		get value() { return value },
-		set: (newValue: T) => { value = newValue }
+import type { App } from 'vue'
+import type { User, NewUser, UpdatePasswordForm } from '../types'
+import { AuthApi } from '../api/auth'
+
+// Global state
+let authApi: AuthApi | null = null
+const currentUser = {
+	value: {
+		id: '',
+		email: '',
+		first_name: '',
+		last_name: '',
+		is_superuser: false,
+		is_active: false,
+	} as User,
+	set: (newValue: User) => {
+		currentUser.value = newValue
 	}
 }
 
-// Create Vue reactive factory
-function createVueReactiveFactory(app: any): ReactiveFactory {
-	return <T>(initial: T) => {
-		const refValue = app.ref(initial)
-		return {
-			get value() { return refValue.value },
-			set: (v: T) => { refValue.value = v }
-		}
+// Initialize auth
+export function initAuth(baseURL?: string) {
+	if (!authApi) {
+		authApi = new AuthApi(baseURL)
 	}
-}
 
-// Create plugin instance
-export function initAuth({
-	axios,
-	errorHandler,
-	reactive = defaultReactiveFactory,
-	baseURL
-}: {
-	axios?: AxiosInstance
-	errorHandler?: (error: any) => void
-	reactive?: ReactiveFactory
-	baseURL?: string
-} = {}) {
-	// Initialize API
-	api = axios || createDefaultApi(baseURL)
-
-	// Initialize error handler
-	if (errorHandler) onError = errorHandler
-
-	// Initialize reactive factory
-	createRef = reactive
-
-	// Return plugin interface
 	return {
-		install(app: any) {
-			// If Vue is detected, use Vue's reactivity
-			if (app.ref) {
-				createRef = createVueReactiveFactory(app)
-			}
-		},
-		useAuth
+		install(app: App) {
+			// Make auth available globally
+			app.config.globalProperties.$auth = useAuth()
+		}
 	}
 }
 
+// Composable
 export function useAuth() {
-	if (!api || !createRef) {
-		throw new Error('Auth composable not initialized. Call initAuth first.')
+	if (!authApi) {
+		throw new Error('Auth not initialized. Call initAuth first.')
 	}
 
-	// State
-	const currentUser = createRef<User>({
-		id: '',
-		email: '',
-		first_name: '',
-		last_name: '',
-		is_superuser: false,
-		is_active: false,
-	})
-
-	const passwordForm = createRef<UpdatePasswordForm>({
-		current_password: '',
-		new_password: '',
-		confirmNewPassword: '',
-	})
-
 	// Getters
 	const getFullName = () => `${currentUser.value.first_name} ${currentUser.value.last_name}`
 	const getIsLoggedIn = () => currentUser.value.id.length > 0
 
-	// Error handling
-	function handleError(error: any) {
-		if (onError) {
-			onError(error)
-		}
-		throw error
-	}
-
 	// Actions
 	async function logout() {
 		try {
-			await authApi.logout()
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.logout()
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function login(credentials: { email: string, password: string }) {
-		const email = credentials.email.toLowerCase()
-		const { password } = credentials
 		try {
-			await authApi.login(email, password)
+			await authApi!.login(credentials.email.toLowerCase(), credentials.password)
 			await checkAuth()
-		} catch (error: any) {
-			handleError(error)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function checkAuth(): Promise<boolean> {
 		try {
 			if (!getIsLoggedIn()) {
-				const { data } = await authApi.getCurrentUser()
+				const { data } = await authApi!.getCurrentUser()
 				currentUser.set(data)
 			}
-		} catch (error: any) {
+		} catch (error) {
 			return false
 		}
 		return getIsLoggedIn()
@@ -129,82 +77,68 @@ export function useAuth() {
 			if (user.password !== user.confirmPassword) {
 				throw new Error('Passwords do not match')
 			}
-			const { data } = await authApi.signup(user)
+			const { data } = await authApi!.signup(user)
 			currentUser.set(data)
-		} catch (error: any) {
-			handleError(error)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function recoverPassword(email: string) {
 		try {
-			await authApi.passwordRecovery(email)
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.passwordRecovery(email)
+		} catch (error) {
+			throw error
 		}
 	}
 
-	async function resetPassword(form: UpdatePasswordForm) {
+	async function resetPassword(newPassword: string) {
 		try {
-			if (form.new_password !== form.confirmNewPassword) {
-				throw new Error('Passwords do not match')
-			}
-			await authApi.resetPassword(form.new_password)
-			form = {
-				current_password: '',
-				new_password: '',
-				confirmNewPassword: '',
-			}
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.resetPassword(newPassword)
+		} catch (error) {
+			throw error
 		}
 	}
 
-	async function updatePassword() {
+	async function updatePassword(form: UpdatePasswordForm) {
 		try {
-			if (passwordForm.value.new_password !== passwordForm.value.confirmNewPassword) {
+			if (form.new_password !== form.confirmNewPassword) {
 				throw new Error('Passwords do not match')
 			}
-			await authApi.updatePassword(passwordForm.value)
-			passwordForm.set({
-				current_password: '',
-				new_password: '',
-				confirmNewPassword: '',
-			})
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.updatePassword(form)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function updateProfile(user: Partial<User>) {
 		try {
-			const { data } = await authApi.updateUserProfile(user)
+			const { data } = await authApi!.updateUserProfile(user)
 			currentUser.set({ ...currentUser.value, ...data })
-		} catch (error: any) {
-			handleError(error)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function toggleUserStatus(userId: string, isActive: boolean) {
 		try {
-			await authApi.setUserStatus(userId, isActive)
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.setUserStatus(userId, isActive)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	async function deleteUser(userId: string) {
 		try {
-			await authApi.deleteUser(userId)
-		} catch (error: any) {
-			handleError(error)
+			await authApi!.deleteUser(userId)
+		} catch (error) {
+			throw error
 		}
 	}
 
 	return {
 		// State
 		currentUser,
-		passwordForm,
 
 		// Getters
 		getFullName,

package/src/api/api.ts

@@ -1,20 +0,0 @@
-import type { AxiosInstance } from 'axios'
-import axios from 'axios'
-
-const api: AxiosInstance | undefined = undefined
-
-export function getApi(): AxiosInstance {
-	if (!api) {
-		throw new Error('API not initialized. Call initAuth first.')
-	}
-	return api
-}
-
-export function createDefaultApi(baseURL?: string) {
-	return axios.create({
-		baseURL,
-		headers: {
-			'Content-Type': 'application/json',
-		},
-	})
-}