@bagelink/auth 1.1.39 → 1.1.43

package/dist/index.cjs

@@ -1,162 +1,146 @@
 'use strict';
 
-require('axios');
+const axios = require('axios');
 
-let api$1 = null;
-function getApi() {
-  if (!api$1) {
-    throw new Error("API not initialized. Call initApi first.");
-  }
-  return api$1;
-}
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-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}`);
-}
+const axios__default = /*#__PURE__*/_interopDefaultCompat(axios);
 
-let api = null;
-let onError = null;
-let createRef = null;
-const defaultReactiveFactory = (initial) => {
-  let value = initial;
-  return {
-    get value() {
-      return value;
-    },
-    set: (newValue) => {
-      value = newValue;
-    }
-  };
+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;
 };
-function createVueReactiveFactory(app) {
-  return (initial) => {
-    const refValue = app.ref(initial);
-    return {
-      get value() {
-        return refValue.value;
-      },
-      set: (v) => {
-        refValue.value = v;
+class AuthApi {
+  constructor(baseURL) {
+    __publicField(this, "api");
+    this.api = axios__default.create({
+      baseURL,
+      headers: {
+        "Content-Type": "application/json"
       }
-    };
-  };
-}
-function initAuth({
-  axios,
-  errorHandler,
-  reactive = defaultReactiveFactory
-} = {}) {
-  api = axios || null;
-  onError = errorHandler || null;
-  createRef = reactive;
-  return {
-    install(app) {
-      if (app.ref) {
-        createRef = createVueReactiveFactory(app);
+    });
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.api.interceptors.request.use((config) => {
+      const token = localStorage.getItem("access_token");
+      if (token !== null && config.headers) {
+        config.headers.Authorization = `Bearer ${token}`;
       }
-    },
-    useAuth
-  };
-}
-function useAuth() {
-  if (!api || !createRef) {
-    throw new Error("Auth composable not initialized. Call initAuth first.");
+      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 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 });
   }
-  const currentUser = createRef({
+  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}`);
+  }
+}
+
+let authApi = null;
+const currentUser = {
+  value: {
     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);
+  },
+  set: (newValue) => {
+    currentUser.value = newValue;
+  }
+};
+function initAuth(baseURL) {
+  if (!authApi) {
+    authApi = new AuthApi(baseURL);
+  }
+  return {
+    install(app) {
+      app.config.globalProperties.$auth = useAuth();
     }
-    throw error;
+  };
+}
+function useAuth() {
+  if (!authApi) {
+    throw new Error("Auth not initialized. Call initAuth first.");
   }
-  async function logout$1() {
+  const getFullName = () => `${currentUser.value.first_name} ${currentUser.value.last_name}`;
+  const getIsLoggedIn = () => currentUser.value.id.length > 0;
+  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) {
@@ -164,106 +148,83 @@ 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
   };
 }
 
-exports.deleteUser = deleteUser;
-exports.getCurrentUser = getCurrentUser;
+exports.AuthApi = AuthApi;
 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

@@ -1,12 +1,13 @@
-import { AxiosResponse, AxiosInstance } from 'axios';
+import { AxiosResponse } from 'axios';
+import { App } from 'vue';
 
 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;
 }
 interface UserRegister {
     email: string;
@@ -22,38 +23,97 @@ interface UpdatePasswordForm {
     new_password: string;
     confirmNewPassword: string;
 }
-interface ReactiveRef<T> {
-    value: T;
-    set: (newValue: T) => void;
+interface ReactiveFactory {
+    <T>(initial: T): {
+        value: T;
+        set: (newValue: T) => void;
+    };
 }
-type ReactiveFactory = <T>(initial: T) => ReactiveRef<T>;
-
-interface NewPasswordPayload {
-    token: string;
+interface Token {
+    access_token: string;
+}
+interface PasswordRecovery {
+    email: string;
+}
+interface NewPassword {
+    new_password: string;
+}
+interface UserUpdate {
+    email?: string;
+    is_active?: boolean;
+    is_superuser?: boolean;
+    first_name?: string;
+    last_name?: string;
+}
+interface UserUpdateMe {
+    email?: string;
+    first_name?: string;
+    last_name?: string;
+}
+interface UpdatePassword {
+    current_password: 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>;
+interface UserCreate {
+    email: string;
+    password: string;
+    first_name?: string;
+    last_name?: string;
+    is_active?: boolean;
+    is_superuser?: boolean;
+}
+interface SanitizedUserOut {
+    email: string;
+    is_active?: boolean;
+    is_superuser?: boolean;
+    first_name?: string;
+    last_name?: string;
+    id: string;
+}
+interface SanitizedUserList {
+    data: SanitizedUserOut[];
+    count: number;
+}
+type LoginResponse = AxiosResponse<Token>;
+type PasswordRecoveryResponse = AxiosResponse;
+type ResetPasswordResponse = AxiosResponse;
+type GetUserResponse = AxiosResponse<SanitizedUserOut>;
+type UpdateUserResponse = AxiosResponse<SanitizedUserOut>;
+type DeleteUserResponse = AxiosResponse;
+type GetUsersResponse = AxiosResponse<SanitizedUserList>;
+type CreateUserResponse = AxiosResponse<SanitizedUserOut>;
+type GetMeResponse = AxiosResponse<SanitizedUserOut>;
+type UpdateMeResponse = AxiosResponse<SanitizedUserOut>;
+type UpdatePasswordResponse = AxiosResponse;
+type SignupResponse = AxiosResponse<SanitizedUserOut>;
+
+declare class AuthApi {
+    private api;
+    constructor(baseURL?: string);
+    private setupInterceptors;
+    login(username: string, password: string): Promise<LoginResponse>;
+    logout(): void;
+    passwordRecovery(email?: string): Promise<PasswordRecoveryResponse>;
+    resetPassword(newPassword: NewPassword['new_password']): Promise<ResetPasswordResponse>;
+    getCurrentUser(): Promise<GetMeResponse>;
+    signup(user: NewUser): Promise<SignupResponse>;
+    updatePassword(form: UpdatePasswordForm): Promise<UpdatePasswordResponse>;
+    updateUserProfile(user: Partial<User>): Promise<UpdateMeResponse>;
+    setUserStatus(userId: string, isActive: boolean): Promise<UpdateUserResponse>;
+    deleteUser(userId: string): Promise<DeleteUserResponse>;
+    getUsers(limit?: number, skip?: number): Promise<GetUsersResponse>;
+    createUser(user: UserCreate): Promise<CreateUserResponse>;
+    getUser(userId: string): Promise<GetUserResponse>;
+}
 
-declare function initAuth({ axios, errorHandler, reactive }?: {
-    axios?: AxiosInstance;
-    errorHandler?: (error: any) => void;
-    reactive?: ReactiveFactory;
-}): {
-    install(app: any): void;
-    useAuth: typeof useAuth;
+declare function initAuth(baseURL?: string): {
+    install(app: App): void;
 };
 declare function useAuth(): {
-    currentUser: ReactiveRef<User>;
-    passwordForm: ReactiveRef<UpdatePasswordForm>;
+    currentUser: {
+        value: User;
+        set: (newValue: User) => void;
+    };
     getFullName: () => string;
     getIsLoggedIn: () => boolean;
     logout: () => Promise<void>;
@@ -64,11 +124,11 @@ declare function useAuth(): {
     checkAuth: () => Promise<boolean>;
     signup: (user: NewUser) => Promise<void>;
     recoverPassword: (email: string) => Promise<void>;
-    resetPassword: (form: UpdatePasswordForm) => Promise<void>;
-    updatePassword: () => Promise<void>;
+    resetPassword: (newPassword: string) => Promise<void>;
+    updatePassword: (form: UpdatePasswordForm) => 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 };
+export { AuthApi, type CreateUserResponse, type DeleteUserResponse, type GetMeResponse, type GetUserResponse, type GetUsersResponse, type LoginResponse, type NewPassword, type NewUser, type PasswordRecovery, type PasswordRecoveryResponse, type ReactiveFactory, type ResetPasswordResponse, type SanitizedUserList, type SanitizedUserOut, type SignupResponse, type Token, type UpdateMeResponse, type UpdatePassword, type UpdatePasswordForm, type UpdatePasswordResponse, type UpdateUserResponse, type User, type UserCreate, type UserRegister, type UserUpdate, type UserUpdateMe, initAuth, useAuth };