@bagelink/auth 1.1.41 → 1.1.45

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { AxiosResponse, AxiosInstance } from 'axios';
+import { App } from 'vue';
 
 interface User {
     id: string;
@@ -86,38 +87,36 @@ type UpdateMeResponse = AxiosResponse<SanitizedUserOut>;
 type UpdatePasswordResponse = AxiosResponse;
 type SignupResponse = AxiosResponse<SanitizedUserOut>;
 
-declare function login(username: string, password: string): Promise<LoginResponse>;
-declare function logout(): void;
-declare function passwordRecovery(email?: string): Promise<PasswordRecoveryResponse>;
-declare function resetPassword(newPassword: NewPassword['new_password']): Promise<ResetPasswordResponse>;
-declare function getCurrentUser(): Promise<GetMeResponse>;
-declare function signup(user: NewUser): Promise<SignupResponse>;
-declare function updatePassword(form: UpdatePasswordForm): Promise<UpdatePasswordResponse>;
-declare function updateUserProfile(user: Partial<User>): Promise<UpdateMeResponse>;
-declare function setUserStatus(userId: string, isActive: boolean): Promise<UpdateUserResponse>;
-declare function deleteUser(userId: string): Promise<DeleteUserResponse>;
-declare function getUsers(limit?: number, skip?: number): Promise<GetUsersResponse>;
-declare function createUser(user: UserCreate): Promise<CreateUserResponse>;
-declare function getUser(userId: string): Promise<GetUserResponse>;
+declare class AuthApi {
+    private api;
+    constructor(axiosInstance?: AxiosInstance, 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, baseURL }?: {
-    axios?: AxiosInstance;
-    errorHandler?: (error: any) => void;
-    reactive?: ReactiveFactory;
+declare function initAuth({ axios, baseURL, }: {
+    axios: AxiosInstance;
     baseURL?: string;
 }): {
-    install(app: any): void;
-    useAuth: typeof useAuth;
+    install(app: App): void;
 };
 declare function useAuth(): {
     currentUser: {
         value: User;
         set: (newValue: User) => void;
     };
-    passwordForm: {
-        value: UpdatePasswordForm;
-        set: (newValue: UpdatePasswordForm) => void;
-    };
     getFullName: () => string;
     getIsLoggedIn: () => boolean;
     logout: () => Promise<void>;
@@ -128,11 +127,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 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, createUser, deleteUser, getCurrentUser, getUser, getUsers, 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 };

package/dist/index.mjs

@@ -1,180 +1,155 @@
 import axios from 'axios';
 
-const api$1 = void 0;
-function getApi() {
-  if (!api$1) {
-    throw new Error("API not initialized. Call initAuth first.");
-  }
-  return api$1;
-}
-function createDefaultApi(baseURL) {
+function createAxiosInstance(baseURL = "") {
   return axios.create({
-    baseURL,
+    baseURL: baseURL || "",
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "withCredentials": true
     }
   });
 }
 
-const ax = getApi();
-ax.interceptors.request.use((config) => {
-  const token = localStorage.getItem("access_token");
-  if (token !== null && config.headers) {
-    config.headers.Authorization = `Bearer ${token}`;
+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(axiosInstance, baseURL = "") {
+    __publicField(this, "api");
+    this.api = axiosInstance || createAxiosInstance(baseURL);
+    this.setupInterceptors();
   }
-  const urlParams = new URLSearchParams(window.location.search);
-  const resetToken = urlParams.get("token");
-  if (resetToken !== null && config.headers) {
-    config.headers.Authorization = `Bearer ${resetToken}`;
+  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;
+    });
+  }
+  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);
-  return { data };
-}
-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("/users/me");
-}
-async function signup(user) {
-  return ax.post("/users/signup", {
-    email: user.email.toLowerCase(),
-    password: user.password,
-    first_name: user.first_name,
-    last_name: user.last_name
-  });
-}
-async function updatePassword(form) {
-  return ax.patch("/users/me/password", {
-    current_password: form.current_password,
-    new_password: form.new_password
-  });
-}
-async function updateUserProfile(user) {
-  return ax.patch("/users/me", user);
-}
-async function setUserStatus(userId, isActive) {
-  return ax.patch(`/users/${userId}`, { is_active: isActive });
-}
-async function deleteUser(userId) {
-  return ax.delete(`/users/${userId}`);
-}
-async function getUsers(limit = 100, skip) {
-  return ax.get("/users/", { params: { skip, limit } });
-}
-async function createUser(user) {
-  return ax.post("/users/", user);
-}
-async function getUser(userId) {
-  return ax.get(`/users/${userId}`);
 }
 
-let api;
-let onError;
-let createRef;
-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,
   baseURL
-} = {}) {
-  api = axios || createDefaultApi(baseURL);
-  if (errorHandler)
-    onError = errorHandler;
-  createRef = reactive;
+}) {
+  if (!authApi) {
+    authApi = new AuthApi(axios, 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) {
@@ -182,95 +157,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 { createUser, deleteUser, getCurrentUser, getUser, getUsers, 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.41",
+  "version": "1.1.45",
   "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"
   }
 }