@bagelink/auth 1.1.39 → 1.1.43

package/dist/index.mjs

@@ -1,160 +1,140 @@
-import 'axios';
+import axios from 'axios';
 
-let api$1 = null;
-function getApi() {
-  if (!api$1) {
-    throw new Error("API not initialized. Call initApi first.");
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AuthApi {
+  constructor(baseURL) {
+    __publicField(this, "api");
+    this.api = axios.create({
+      baseURL,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.setupInterceptors();
   }
-  return api$1;
-}
-
-const ax = getApi();
-ax.interceptors.request.use((config) => {
-  const token = localStorage.getItem("access_token");
-  if (token !== null && config.headers) {
-    config.headers.Authorization = `Bearer ${token}`;
+  setupInterceptors() {
+    this.api.interceptors.request.use((config) => {
+      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;
+    });
   }
-  const urlParams = new URLSearchParams(window.location.search);
-  const resetToken = urlParams.get("token");
-  if (resetToken !== null && config.headers) {
-    config.headers.Authorization = `Bearer ${resetToken}`;
+  async login(username, password) {
+    const { data } = await this.api.post("/auth/login", {
+      username: username.toLowerCase(),
+      password
+    });
+    localStorage.setItem("access_token", data.access_token);
+    return { data };
+  }
+  logout() {
+    localStorage.removeItem("access_token");
+    window.location.reload();
+  }
+  async passwordRecovery(email) {
+    return this.api.post("/auth/password-recovery", { email });
+  }
+  async resetPassword(newPassword) {
+    return this.api.post("/auth/reset-password", { new_password: newPassword });
+  }
+  async getCurrentUser() {
+    return this.api.get("/users/me");
+  }
+  async signup(user) {
+    return this.api.post("/users/signup", {
+      email: user.email.toLowerCase(),
+      password: user.password,
+      first_name: user.first_name,
+      last_name: user.last_name
+    });
+  }
+  async updatePassword(form) {
+    return this.api.patch("/users/me/password", {
+      current_password: form.current_password,
+      new_password: form.new_password
+    });
+  }
+  async updateUserProfile(user) {
+    return this.api.patch("/users/me", user);
+  }
+  async setUserStatus(userId, isActive) {
+    return this.api.patch(`/users/${userId}`, { is_active: isActive });
+  }
+  async deleteUser(userId) {
+    return this.api.delete(`/users/${userId}`);
+  }
+  async getUsers(limit = 100, skip) {
+    return this.api.get("/users/", { params: { skip, limit } });
+  }
+  async createUser(user) {
+    return this.api.post("/users/", user);
+  }
+  async getUser(userId) {
+    return this.api.get(`/users/${userId}`);
   }
-  return config;
-});
-async function login(username, password) {
-  const { data } = await ax.post("/auth/login", {
-    username: username.toLowerCase(),
-    password
-  });
-  localStorage.setItem("access_token", data.access_token);
-}
-function logout() {
-  localStorage.removeItem("access_token");
-  window.location.reload();
-}
-async function passwordRecovery(email) {
-  return ax.post(`/auth/password-recovery`, { email });
-}
-async function resetPassword(newPassword) {
-  return ax.post("/auth/reset-password", { new_password: newPassword });
-}
-async function getCurrentUser() {
-  return ax.get("/auth/me");
-}
-async function signup(user) {
-  return ax.post("/auth/signup", {
-    email: user.email.toLowerCase(),
-    password: user.password,
-    first_name: user.first_name,
-    last_name: user.last_name
-  });
-}
-async function updatePassword(form) {
-  return ax.put("/auth/password", {
-    current_password: form.current_password,
-    new_password: form.new_password
-  });
-}
-async function updateUserProfile(user) {
-  return ax.put("/auth/profile", user);
-}
-async function setUserStatus(userId, isActive) {
-  return ax.patch(`/auth/users/${userId}/status`, { is_active: isActive });
-}
-async function deleteUser(userId) {
-  return ax.delete(`/auth/users/${userId}`);
 }
 
-let api = null;
-let onError = null;
-let createRef = null;
-const defaultReactiveFactory = (initial) => {
-  let value = initial;
-  return {
-    get value() {
-      return value;
-    },
-    set: (newValue) => {
-      value = newValue;
-    }
-  };
+let authApi = null;
+const currentUser = {
+  value: {
+    id: "",
+    email: "",
+    first_name: "",
+    last_name: "",
+    is_superuser: false,
+    is_active: false
+  },
+  set: (newValue) => {
+    currentUser.value = newValue;
+  }
 };
-function createVueReactiveFactory(app) {
-  return (initial) => {
-    const refValue = app.ref(initial);
-    return {
-      get value() {
-        return refValue.value;
-      },
-      set: (v) => {
-        refValue.value = v;
-      }
-    };
-  };
-}
-function initAuth({
-  axios,
-  errorHandler,
-  reactive = defaultReactiveFactory
-} = {}) {
-  api = axios || null;
-  onError = errorHandler || null;
-  createRef = reactive;
+function initAuth(baseURL) {
+  if (!authApi) {
+    authApi = new AuthApi(baseURL);
+  }
   return {
     install(app) {
-      if (app.ref) {
-        createRef = createVueReactiveFactory(app);
-      }
-    },
-    useAuth
+      app.config.globalProperties.$auth = useAuth();
+    }
   };
 }
 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.");
   }
-  const currentUser = createRef({
-    id: "",
-    email: "",
-    first_name: "",
-    last_name: "",
-    is_superuser: false,
-    is_active: false
-  });
-  const passwordForm = createRef({
-    current_password: "",
-    new_password: "",
-    confirmNewPassword: ""
-  });
   const getFullName = () => `${currentUser.value.first_name} ${currentUser.value.last_name}`;
   const getIsLoggedIn = () => currentUser.value.id.length > 0;
-  function handleError(error) {
-    if (onError) {
-      onError(error);
-    }
-    throw error;
-  }
-  async function logout$1() {
+  async function logout() {
     try {
-      await logout();
+      await authApi.logout();
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
-  async function login$1(credentials) {
-    const email = credentials.email.toLowerCase();
-    const { password } = credentials;
+  async function login(credentials) {
     try {
-      await login(email, password);
+      await authApi.login(credentials.email.toLowerCase(), credentials.password);
       await checkAuth();
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
   async function checkAuth() {
     try {
       if (!getIsLoggedIn()) {
-        const { data } = await getCurrentUser();
+        const { data } = await authApi.getCurrentUser();
         currentUser.set(data);
       }
     } catch (error) {
@@ -162,95 +142,81 @@ function useAuth() {
     }
     return getIsLoggedIn();
   }
-  async function signup$1(user) {
+  async function signup(user) {
     try {
       if (user.password !== user.confirmPassword) {
         throw new Error("Passwords do not match");
       }
-      const { data } = await signup(user);
+      const { data } = await authApi.signup(user);
       currentUser.set(data);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
   async function recoverPassword(email) {
     try {
-      await passwordRecovery(email);
+      await authApi.passwordRecovery(email);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
-  async function resetPassword$1(form) {
+  async function resetPassword(newPassword) {
     try {
-      if (form.new_password !== form.confirmNewPassword) {
-        throw new Error("Passwords do not match");
-      }
-      await resetPassword(form.new_password);
-      form = {
-        current_password: "",
-        new_password: "",
-        confirmNewPassword: ""
-      };
+      await authApi.resetPassword(newPassword);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
-  async function updatePassword$1() {
+  async function updatePassword(form) {
     try {
-      if (passwordForm.value.new_password !== passwordForm.value.confirmNewPassword) {
+      if (form.new_password !== form.confirmNewPassword) {
         throw new Error("Passwords do not match");
       }
-      await updatePassword(passwordForm.value);
-      passwordForm.set({
-        current_password: "",
-        new_password: "",
-        confirmNewPassword: ""
-      });
+      await authApi.updatePassword(form);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
   async function updateProfile(user) {
     try {
-      const { data } = await updateUserProfile(user);
+      const { data } = await authApi.updateUserProfile(user);
       currentUser.set({ ...currentUser.value, ...data });
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
   async function toggleUserStatus(userId, isActive) {
     try {
-      await setUserStatus(userId, isActive);
+      await authApi.setUserStatus(userId, isActive);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
-  async function deleteUser$1(userId) {
+  async function deleteUser(userId) {
     try {
-      await deleteUser(userId);
+      await authApi.deleteUser(userId);
     } catch (error) {
-      handleError(error);
+      throw error;
     }
   }
   return {
     // State
     currentUser,
-    passwordForm,
     // Getters
     getFullName,
     getIsLoggedIn,
     // Actions
-    logout: logout$1,
-    login: login$1,
+    logout,
+    login,
     checkAuth,
-    signup: signup$1,
+    signup,
     recoverPassword,
-    resetPassword: resetPassword$1,
-    updatePassword: updatePassword$1,
+    resetPassword,
+    updatePassword,
     updateProfile,
     toggleUserStatus,
-    deleteUser: deleteUser$1
+    deleteUser
   };
 }
 
-export { deleteUser, getCurrentUser, initAuth, login, logout, passwordRecovery, resetPassword, setUserStatus, signup, updatePassword, updateUserProfile, useAuth };
+export { AuthApi, initAuth, useAuth };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/auth",
   "type": "module",
-  "version": "1.1.39",
+  "version": "1.1.43",
   "description": "Bagelink auth package",
   "author": {
     "name": "Bagel Studio",
@@ -41,12 +41,22 @@
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
-    "unbuild": "^2.0.0"
+    "unbuild": "^2.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.1",
+    "@typescript-eslint/parser": "^7.0.1",
+    "eslint": "^8.56.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.2"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
   },
   "scripts": {
     "dev": "unbuild --stub",
     "build": "unbuild",
     "start": "tsx src/index.ts",
-    "watch": "tsx watch src/index.ts"
+    "watch": "tsx watch src/index.ts",
+    "lint": "eslint . --ext .ts",
+    "clean": "rimraf dist"
   }
 }

package/src/api/auth.ts

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