@bagelink/auth 1.1.39 → 1.1.43

package/src/composable/useAuth.ts

@@ -1,121 +1,72 @@
-import type { AxiosInstance } from 'axios'
-import type { User, NewUser, UpdatePasswordForm, ReactiveFactory } from '../types'
-import * as authApi from '../api/auth'
-
-let api: AxiosInstance | null = null
-let onError: ((error: any) => void) | null = null
-let createRef: ReactiveFactory | null = null
-
-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
 	}
 }
 
-// Vue plugin type
-interface VuePlugin {
-	install: (app: any) => void
-}
-
-// 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
-}: {
-	axios?: AxiosInstance
-	errorHandler?: (error: any) => void
-	reactive?: ReactiveFactory
-} = {}) {
-	api = axios || null
-	onError = errorHandler || null
-	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()
@@ -126,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/types.ts

@@ -1,10 +1,12 @@
+import type { AxiosResponse } from 'axios'
+
 export interface User {
 	id: string
 	email: string
-	first_name: string
-	last_name: string
-	is_superuser: boolean
-	is_active: boolean
+	first_name?: string
+	last_name?: string
+	is_superuser?: boolean
+	is_active?: boolean
 }
 
 export interface UserRegister {
@@ -24,9 +26,78 @@ export interface UpdatePasswordForm {
 	confirmNewPassword: string
 }
 
-export interface ReactiveRef<T> {
-	value: T
-	set: (newValue: T) => void
+export interface ReactiveFactory {
+	<T>(initial: T): {
+		value: T
+		set: (newValue: T) => void
+	}
+}
+
+// API Response Types
+export interface Token {
+	access_token: string
+}
+
+export interface PasswordRecovery {
+	email: string
+}
+
+export interface NewPassword {
+	new_password: string
+}
+
+export interface UserUpdate {
+	email?: string
+	is_active?: boolean
+	is_superuser?: boolean
+	first_name?: string
+	last_name?: string
+}
+
+export interface UserUpdateMe {
+	email?: string
+	first_name?: string
+	last_name?: string
+}
+
+export interface UpdatePassword {
+	current_password: string
+	new_password: string
+}
+
+export interface UserCreate {
+	email: string
+	password: string
+	first_name?: string
+	last_name?: string
+	is_active?: boolean
+	is_superuser?: boolean
+}
+
+export interface SanitizedUserOut {
+	email: string
+	is_active?: boolean
+	is_superuser?: boolean
+	first_name?: string
+	last_name?: string
+	id: string
+}
+
+export interface SanitizedUserList {
+	data: SanitizedUserOut[]
+	count: number
 }
 
-export type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>
+// API Response Types
+export type LoginResponse = AxiosResponse<Token>
+export type PasswordRecoveryResponse = AxiosResponse
+export type ResetPasswordResponse = AxiosResponse
+export type GetUserResponse = AxiosResponse<SanitizedUserOut>
+export type UpdateUserResponse = AxiosResponse<SanitizedUserOut>
+export type DeleteUserResponse = AxiosResponse
+export type GetUsersResponse = AxiosResponse<SanitizedUserList>
+export type CreateUserResponse = AxiosResponse<SanitizedUserOut>
+export type GetMeResponse = AxiosResponse<SanitizedUserOut>
+export type UpdateMeResponse = AxiosResponse<SanitizedUserOut>
+export type UpdatePasswordResponse = AxiosResponse
+export type SignupResponse = AxiosResponse<SanitizedUserOut>

package/src/api/api.ts

@@ -1,24 +0,0 @@
-import type { AxiosInstance } from 'axios'
-import axios from 'axios'
-
-let api: AxiosInstance | null = null
-
-export function initApi(axiosInstance?: AxiosInstance) {
-	if (axiosInstance) {
-		api = axiosInstance
-	} else {
-		api = axios.create({
-			baseURL: import.meta.env.VITE_API_URL || 'http://localhost:8000',
-			headers: {
-				'Content-Type': 'application/json',
-			},
-		})
-	}
-}
-
-export function getApi(): AxiosInstance {
-	if (!api) {
-		throw new Error('API not initialized. Call initApi first.')
-	}
-	return api
-}