@bagelink/auth 1.1.39

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Neveh Allon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# @bagelink/auth
+
+A framework-agnostic authentication composable with Vue support.
+
+## Features
+
+- Framework-agnostic reactivity system
+- Automatic Vue integration
+- TypeScript support
+- Complete authentication flow (login, signup, password recovery, etc.)
+- Error handling
+- User management
+
+## Installation
+
+```bash
+bun add @bagelink/auth
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { initAuth } from '@bagelink/auth'
+
+// Initialize with axios instance
+const auth = initAuth({ 
+  axios: axiosInstance,
+  errorHandler: (error) => console.error(error)
+})
+```
+
+### Vue Integration
+
+```typescript
+// In your main.ts
+import { createApp } from 'vue'
+import { initAuth } from '@bagelink/auth'
+
+const app = createApp(App)
+
+// Initialize auth
+const auth = initAuth({ 
+  axios: axiosInstance,
+  errorHandler: (error) => console.error(error)
+})
+
+// Use as a plugin
+app.use(auth)
+
+// In your components
+import { useAuth } from '@bagelink/auth'
+
+export default {
+  setup() {
+    const { login, currentUser, getIsLoggedIn } = useAuth()
+    
+    // Use auth methods
+    const handleLogin = async () => {
+      await login({
+        email: 'user@example.com',
+        password: 'password'
+      })
+    }
+
+    return {
+      currentUser,
+      getIsLoggedIn,
+      handleLogin
+    }
+  }
+}
+```
+
+### Vanilla JavaScript
+
+```typescript
+import { initAuth } from '@bagelink/auth'
+
+const auth = initAuth({ 
+  axios: axiosInstance,
+  errorHandler: (error) => console.error(error)
+})
+
+const { login, currentUser, getIsLoggedIn } = auth.useAuth()
+```
+
+## API
+
+### State
+
+- `currentUser`: Current user information
+- `passwordForm`: Password update form state
+
+### Getters
+
+- `getFullName()`: Get user's full name
+- `getIsLoggedIn()`: Check if user is logged in
+
+### Actions
+
+- `login(credentials)`: Login with email and password
+- `logout()`: Logout current user
+- `checkAuth()`: Check authentication status
+- `signup(user)`: Register new user
+- `recoverPassword(email)`: Request password recovery
+- `resetPassword(form)`: Reset password
+- `updatePassword()`: Update current user's password
+- `updateProfile(user)`: Update user profile
+- `toggleUserStatus(userId, isActive)`: Toggle user active status
+- `deleteUser(userId)`: Delete user
+
+## License
+
+MIT 

package/dist/index.cjs

@@ -0,0 +1,269 @@
+'use strict';
+
+require('axios');
+
+let api$1 = null;
+function getApi() {
+  if (!api$1) {
+    throw new Error("API not initialized. Call initApi first.");
+  }
+  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}`;
+  }
+  const urlParams = new URLSearchParams(window.location.search);
+  const resetToken = urlParams.get("token");
+  if (resetToken !== null && config.headers) {
+    config.headers.Authorization = `Bearer ${resetToken}`;
+  }
+  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;
+    }
+  };
+};
+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;
+  return {
+    install(app) {
+      if (app.ref) {
+        createRef = createVueReactiveFactory(app);
+      }
+    },
+    useAuth
+  };
+}
+function useAuth() {
+  if (!api || !createRef) {
+    throw new Error("Auth composable 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() {
+    try {
+      await logout();
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function login$1(credentials) {
+    const email = credentials.email.toLowerCase();
+    const { password } = credentials;
+    try {
+      await login(email, password);
+      await checkAuth();
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function checkAuth() {
+    try {
+      if (!getIsLoggedIn()) {
+        const { data } = await getCurrentUser();
+        currentUser.set(data);
+      }
+    } catch (error) {
+      return false;
+    }
+    return getIsLoggedIn();
+  }
+  async function signup$1(user) {
+    try {
+      if (user.password !== user.confirmPassword) {
+        throw new Error("Passwords do not match");
+      }
+      const { data } = await signup(user);
+      currentUser.set(data);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function recoverPassword(email) {
+    try {
+      await passwordRecovery(email);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function resetPassword$1(form) {
+    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: ""
+      };
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function updatePassword$1() {
+    try {
+      if (passwordForm.value.new_password !== passwordForm.value.confirmNewPassword) {
+        throw new Error("Passwords do not match");
+      }
+      await updatePassword(passwordForm.value);
+      passwordForm.set({
+        current_password: "",
+        new_password: "",
+        confirmNewPassword: ""
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function updateProfile(user) {
+    try {
+      const { data } = await updateUserProfile(user);
+      currentUser.set({ ...currentUser.value, ...data });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function toggleUserStatus(userId, isActive) {
+    try {
+      await setUserStatus(userId, isActive);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function deleteUser$1(userId) {
+    try {
+      await deleteUser(userId);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  return {
+    // State
+    currentUser,
+    passwordForm,
+    // Getters
+    getFullName,
+    getIsLoggedIn,
+    // Actions
+    logout: logout$1,
+    login: login$1,
+    checkAuth,
+    signup: signup$1,
+    recoverPassword,
+    resetPassword: resetPassword$1,
+    updatePassword: updatePassword$1,
+    updateProfile,
+    toggleUserStatus,
+    deleteUser: deleteUser$1
+  };
+}
+
+exports.deleteUser = deleteUser;
+exports.getCurrentUser = getCurrentUser;
+exports.initAuth = initAuth;
+exports.login = login;
+exports.logout = logout;
+exports.passwordRecovery = passwordRecovery;
+exports.resetPassword = resetPassword;
+exports.setUserStatus = setUserStatus;
+exports.signup = signup;
+exports.updatePassword = updatePassword;
+exports.updateUserProfile = updateUserProfile;
+exports.useAuth = useAuth;

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+import { AxiosResponse, AxiosInstance } from 'axios';
+
+interface User {
+    id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    is_superuser: boolean;
+    is_active: boolean;
+}
+interface UserRegister {
+    email: string;
+    password: string;
+    first_name: string;
+    last_name: string;
+}
+interface NewUser extends UserRegister {
+    confirmPassword: string;
+}
+interface UpdatePasswordForm {
+    current_password: string;
+    new_password: string;
+    confirmNewPassword: string;
+}
+interface ReactiveRef<T> {
+    value: T;
+    set: (newValue: T) => void;
+}
+type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>;
+
+interface NewPasswordPayload {
+    token: string;
+    new_password: string;
+}
+declare function login(username: string, password: string): Promise<void>;
+declare function logout(): void;
+declare function passwordRecovery(email?: string): Promise<AxiosResponse>;
+declare function resetPassword(newPassword: NewPasswordPayload['new_password']): Promise<AxiosResponse>;
+declare function getCurrentUser(): Promise<AxiosResponse<User>>;
+declare function signup(user: NewUser): Promise<AxiosResponse<User>>;
+declare function updatePassword(form: UpdatePasswordForm): Promise<AxiosResponse>;
+declare function updateUserProfile(user: Partial<User>): Promise<AxiosResponse<User>>;
+declare function setUserStatus(userId: string, isActive: boolean): Promise<AxiosResponse>;
+declare function deleteUser(userId: string): Promise<AxiosResponse>;
+
+declare function initAuth({ axios, errorHandler, reactive }?: {
+    axios?: AxiosInstance;
+    errorHandler?: (error: any) => void;
+    reactive?: ReactiveFactory;
+}): {
+    install(app: any): void;
+    useAuth: typeof useAuth;
+};
+declare function useAuth(): {
+    currentUser: ReactiveRef<User>;
+    passwordForm: ReactiveRef<UpdatePasswordForm>;
+    getFullName: () => string;
+    getIsLoggedIn: () => boolean;
+    logout: () => Promise<void>;
+    login: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    checkAuth: () => Promise<boolean>;
+    signup: (user: NewUser) => Promise<void>;
+    recoverPassword: (email: string) => Promise<void>;
+    resetPassword: (form: UpdatePasswordForm) => Promise<void>;
+    updatePassword: () => Promise<void>;
+    updateProfile: (user: Partial<User>) => Promise<void>;
+    toggleUserStatus: (userId: string, isActive: boolean) => Promise<void>;
+    deleteUser: (userId: string) => Promise<void>;
+};
+
+export { type NewPasswordPayload, type NewUser, type ReactiveFactory, type ReactiveRef, type UpdatePasswordForm, type User, type UserRegister, deleteUser, getCurrentUser, initAuth, login, logout, passwordRecovery, resetPassword, setUserStatus, signup, updatePassword, updateUserProfile, useAuth };

package/dist/index.d.mts

@@ -0,0 +1,74 @@
+import { AxiosResponse, AxiosInstance } from 'axios';
+
+interface User {
+    id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    is_superuser: boolean;
+    is_active: boolean;
+}
+interface UserRegister {
+    email: string;
+    password: string;
+    first_name: string;
+    last_name: string;
+}
+interface NewUser extends UserRegister {
+    confirmPassword: string;
+}
+interface UpdatePasswordForm {
+    current_password: string;
+    new_password: string;
+    confirmNewPassword: string;
+}
+interface ReactiveRef<T> {
+    value: T;
+    set: (newValue: T) => void;
+}
+type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>;
+
+interface NewPasswordPayload {
+    token: string;
+    new_password: string;
+}
+declare function login(username: string, password: string): Promise<void>;
+declare function logout(): void;
+declare function passwordRecovery(email?: string): Promise<AxiosResponse>;
+declare function resetPassword(newPassword: NewPasswordPayload['new_password']): Promise<AxiosResponse>;
+declare function getCurrentUser(): Promise<AxiosResponse<User>>;
+declare function signup(user: NewUser): Promise<AxiosResponse<User>>;
+declare function updatePassword(form: UpdatePasswordForm): Promise<AxiosResponse>;
+declare function updateUserProfile(user: Partial<User>): Promise<AxiosResponse<User>>;
+declare function setUserStatus(userId: string, isActive: boolean): Promise<AxiosResponse>;
+declare function deleteUser(userId: string): Promise<AxiosResponse>;
+
+declare function initAuth({ axios, errorHandler, reactive }?: {
+    axios?: AxiosInstance;
+    errorHandler?: (error: any) => void;
+    reactive?: ReactiveFactory;
+}): {
+    install(app: any): void;
+    useAuth: typeof useAuth;
+};
+declare function useAuth(): {
+    currentUser: ReactiveRef<User>;
+    passwordForm: ReactiveRef<UpdatePasswordForm>;
+    getFullName: () => string;
+    getIsLoggedIn: () => boolean;
+    logout: () => Promise<void>;
+    login: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    checkAuth: () => Promise<boolean>;
+    signup: (user: NewUser) => Promise<void>;
+    recoverPassword: (email: string) => Promise<void>;
+    resetPassword: (form: UpdatePasswordForm) => Promise<void>;
+    updatePassword: () => Promise<void>;
+    updateProfile: (user: Partial<User>) => Promise<void>;
+    toggleUserStatus: (userId: string, isActive: boolean) => Promise<void>;
+    deleteUser: (userId: string) => Promise<void>;
+};
+
+export { type NewPasswordPayload, type NewUser, type ReactiveFactory, type ReactiveRef, type UpdatePasswordForm, type User, type UserRegister, deleteUser, getCurrentUser, initAuth, login, logout, passwordRecovery, resetPassword, setUserStatus, signup, updatePassword, updateUserProfile, useAuth };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { AxiosResponse, AxiosInstance } from 'axios';
+
+interface User {
+    id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    is_superuser: boolean;
+    is_active: boolean;
+}
+interface UserRegister {
+    email: string;
+    password: string;
+    first_name: string;
+    last_name: string;
+}
+interface NewUser extends UserRegister {
+    confirmPassword: string;
+}
+interface UpdatePasswordForm {
+    current_password: string;
+    new_password: string;
+    confirmNewPassword: string;
+}
+interface ReactiveRef<T> {
+    value: T;
+    set: (newValue: T) => void;
+}
+type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>;
+
+interface NewPasswordPayload {
+    token: string;
+    new_password: string;
+}
+declare function login(username: string, password: string): Promise<void>;
+declare function logout(): void;
+declare function passwordRecovery(email?: string): Promise<AxiosResponse>;
+declare function resetPassword(newPassword: NewPasswordPayload['new_password']): Promise<AxiosResponse>;
+declare function getCurrentUser(): Promise<AxiosResponse<User>>;
+declare function signup(user: NewUser): Promise<AxiosResponse<User>>;
+declare function updatePassword(form: UpdatePasswordForm): Promise<AxiosResponse>;
+declare function updateUserProfile(user: Partial<User>): Promise<AxiosResponse<User>>;
+declare function setUserStatus(userId: string, isActive: boolean): Promise<AxiosResponse>;
+declare function deleteUser(userId: string): Promise<AxiosResponse>;
+
+declare function initAuth({ axios, errorHandler, reactive }?: {
+    axios?: AxiosInstance;
+    errorHandler?: (error: any) => void;
+    reactive?: ReactiveFactory;
+}): {
+    install(app: any): void;
+    useAuth: typeof useAuth;
+};
+declare function useAuth(): {
+    currentUser: ReactiveRef<User>;
+    passwordForm: ReactiveRef<UpdatePasswordForm>;
+    getFullName: () => string;
+    getIsLoggedIn: () => boolean;
+    logout: () => Promise<void>;
+    login: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    checkAuth: () => Promise<boolean>;
+    signup: (user: NewUser) => Promise<void>;
+    recoverPassword: (email: string) => Promise<void>;
+    resetPassword: (form: UpdatePasswordForm) => Promise<void>;
+    updatePassword: () => Promise<void>;
+    updateProfile: (user: Partial<User>) => Promise<void>;
+    toggleUserStatus: (userId: string, isActive: boolean) => Promise<void>;
+    deleteUser: (userId: string) => Promise<void>;
+};
+
+export { type NewPasswordPayload, type NewUser, type ReactiveFactory, type ReactiveRef, type UpdatePasswordForm, type User, type UserRegister, deleteUser, getCurrentUser, initAuth, login, logout, passwordRecovery, resetPassword, setUserStatus, signup, updatePassword, updateUserProfile, useAuth };

package/dist/index.mjs

@@ -0,0 +1,256 @@
+import 'axios';
+
+let api$1 = null;
+function getApi() {
+  if (!api$1) {
+    throw new Error("API not initialized. Call initApi first.");
+  }
+  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}`;
+  }
+  const urlParams = new URLSearchParams(window.location.search);
+  const resetToken = urlParams.get("token");
+  if (resetToken !== null && config.headers) {
+    config.headers.Authorization = `Bearer ${resetToken}`;
+  }
+  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;
+    }
+  };
+};
+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;
+  return {
+    install(app) {
+      if (app.ref) {
+        createRef = createVueReactiveFactory(app);
+      }
+    },
+    useAuth
+  };
+}
+function useAuth() {
+  if (!api || !createRef) {
+    throw new Error("Auth composable 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() {
+    try {
+      await logout();
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function login$1(credentials) {
+    const email = credentials.email.toLowerCase();
+    const { password } = credentials;
+    try {
+      await login(email, password);
+      await checkAuth();
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function checkAuth() {
+    try {
+      if (!getIsLoggedIn()) {
+        const { data } = await getCurrentUser();
+        currentUser.set(data);
+      }
+    } catch (error) {
+      return false;
+    }
+    return getIsLoggedIn();
+  }
+  async function signup$1(user) {
+    try {
+      if (user.password !== user.confirmPassword) {
+        throw new Error("Passwords do not match");
+      }
+      const { data } = await signup(user);
+      currentUser.set(data);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function recoverPassword(email) {
+    try {
+      await passwordRecovery(email);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function resetPassword$1(form) {
+    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: ""
+      };
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function updatePassword$1() {
+    try {
+      if (passwordForm.value.new_password !== passwordForm.value.confirmNewPassword) {
+        throw new Error("Passwords do not match");
+      }
+      await updatePassword(passwordForm.value);
+      passwordForm.set({
+        current_password: "",
+        new_password: "",
+        confirmNewPassword: ""
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function updateProfile(user) {
+    try {
+      const { data } = await updateUserProfile(user);
+      currentUser.set({ ...currentUser.value, ...data });
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function toggleUserStatus(userId, isActive) {
+    try {
+      await setUserStatus(userId, isActive);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  async function deleteUser$1(userId) {
+    try {
+      await deleteUser(userId);
+    } catch (error) {
+      handleError(error);
+    }
+  }
+  return {
+    // State
+    currentUser,
+    passwordForm,
+    // Getters
+    getFullName,
+    getIsLoggedIn,
+    // Actions
+    logout: logout$1,
+    login: login$1,
+    checkAuth,
+    signup: signup$1,
+    recoverPassword,
+    resetPassword: resetPassword$1,
+    updatePassword: updatePassword$1,
+    updateProfile,
+    toggleUserStatus,
+    deleteUser: deleteUser$1
+  };
+}
+
+export { deleteUser, getCurrentUser, initAuth, login, logout, passwordRecovery, resetPassword, setUserStatus, signup, updatePassword, updateUserProfile, useAuth };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@bagelink/auth",
+  "type": "module",
+  "version": "1.1.39",
+  "description": "Bagelink auth package",
+  "author": {
+    "name": "Bagel Studio",
+    "email": "info@bagelstudio.co.il",
+    "url": "https://bagelstudio.co.il"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/bageldb/bagelink/tree/master/packages/auth#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bageldb/bagelink.git",
+    "directory": "packages/auth"
+  },
+  "bugs": "https://github.com/bageldb/bagelink/issues",
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.8.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "unbuild": "^2.0.0"
+  },
+  "scripts": {
+    "dev": "unbuild --stub",
+    "build": "unbuild",
+    "start": "tsx src/index.ts",
+    "watch": "tsx watch src/index.ts"
+  }
+}

package/src/api/api.ts

@@ -0,0 +1,24 @@
+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
+}

package/src/api/auth.ts

@@ -0,0 +1,81 @@
+import type { AxiosResponse, InternalAxiosRequestConfig } from 'axios'
+import type { User, NewUser, UpdatePasswordForm } from '../types'
+import { getApi } from './api'
+
+export interface NewPasswordPayload {
+	token: string
+	new_password: string
+}
+
+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}`
+	}
+
+	const urlParams = new URLSearchParams(window.location.search)
+	const resetToken = urlParams.get('token')
+
+	if (resetToken !== null && config.headers) {
+		config.headers.Authorization = `Bearer ${resetToken}`
+	}
+	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()
+}
+
+export async function passwordRecovery(email?: string): Promise<AxiosResponse> {
+	return ax.post(`/auth/password-recovery`, { email })
+}
+
+export async function resetPassword(
+	newPassword: NewPasswordPayload['new_password'],
+): Promise<AxiosResponse> {
+	return ax.post('/auth/reset-password', { new_password: newPassword })
+}
+
+// User Management APIs
+export async function getCurrentUser(): Promise<AxiosResponse<User>> {
+	return ax.get('/auth/me')
+}
+
+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,
+	})
+}
+
+export async function updatePassword(form: UpdatePasswordForm): Promise<AxiosResponse> {
+	return ax.put('/auth/password', {
+		current_password: form.current_password,
+		new_password: form.new_password,
+	})
+}
+
+export async function updateUserProfile(user: Partial<User>): Promise<AxiosResponse<User>> {
+	return ax.put('/auth/profile', user)
+}
+
+export async function setUserStatus(userId: string, isActive: boolean): Promise<AxiosResponse> {
+	return ax.patch(`/auth/users/${userId}/status`, { is_active: isActive })
+}
+
+export async function deleteUser(userId: string): Promise<AxiosResponse> {
+	return ax.delete(`/auth/users/${userId}`)
+}

package/src/composable/useAuth.ts

@@ -0,0 +1,222 @@
+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 }
+	}
+}
+
+// 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 }
+		}
+	}
+}
+
+// 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
+	}
+}
+
+export function useAuth() {
+	if (!api || !createRef) {
+		throw new Error('Auth composable 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)
+		}
+	}
+
+	async function login(credentials: { email: string, password: string }) {
+		const email = credentials.email.toLowerCase()
+		const { password } = credentials
+		try {
+			await authApi.login(email, password)
+			await checkAuth()
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	async function checkAuth(): Promise<boolean> {
+		try {
+			if (!getIsLoggedIn()) {
+				const { data } = await authApi.getCurrentUser()
+				currentUser.set(data)
+			}
+		} catch (error: any) {
+			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.set(data)
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	async function recoverPassword(email: string) {
+		try {
+			await authApi.passwordRecovery(email)
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	async function resetPassword(form: UpdatePasswordForm) {
+		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)
+		}
+	}
+
+	async function updatePassword() {
+		try {
+			if (passwordForm.value.new_password !== passwordForm.value.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)
+		}
+	}
+
+	async function updateProfile(user: Partial<User>) {
+		try {
+			const { data } = await authApi.updateUserProfile(user)
+			currentUser.set({ ...currentUser.value, ...data })
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	async function toggleUserStatus(userId: string, isActive: boolean) {
+		try {
+			await authApi.setUserStatus(userId, isActive)
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	async function deleteUser(userId: string) {
+		try {
+			await authApi.deleteUser(userId)
+		} catch (error: any) {
+			handleError(error)
+		}
+	}
+
+	return {
+		// State
+		currentUser,
+		passwordForm,
+
+		// Getters
+		getFullName,
+		getIsLoggedIn,
+
+		// Actions
+		logout,
+		login,
+		checkAuth,
+		signup,
+		recoverPassword,
+		resetPassword,
+		updatePassword,
+		updateProfile,
+		toggleUserStatus,
+		deleteUser,
+	}
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './api/auth'
+export * from './composable/useAuth'
+export * from './types'

package/src/types.ts

@@ -0,0 +1,32 @@
+export interface User {
+	id: string
+	email: string
+	first_name: string
+	last_name: string
+	is_superuser: boolean
+	is_active: boolean
+}
+
+export interface UserRegister {
+	email: string
+	password: string
+	first_name: string
+	last_name: string
+}
+
+export interface NewUser extends UserRegister {
+	confirmPassword: string
+}
+
+export interface UpdatePasswordForm {
+	current_password: string
+	new_password: string
+	confirmNewPassword: string
+}
+
+export interface ReactiveRef<T> {
+	value: T
+	set: (newValue: T) => void
+}
+
+export type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>