react-redux-django-auth 1.1.0 → 1.3.0

package/dist/index.mjs

@@ -54,6 +54,101 @@ var load_user = (apiUrl) => async (dispatch) => {
     });
   }
 };
+var googleAuthenticate = (state, code, apiUrl) => async (dispatch) => {
+  if (state && code && !localStorage.getItem("access")) {
+    const config = {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    };
+    const details = {
+      "state": state,
+      "code": code
+    };
+    const formBody = Object.keys(details).map((key) => encodeURIComponent(key) + "=" + encodeURIComponent(details[key])).join("&");
+    try {
+      const res = await axios.post(`${apiUrl}/auth/o/google-oauth2/?${formBody}`, config);
+      dispatch({
+        type: GOOGLE_AUTH_SUCCESS,
+        payload: {
+          ...res.data,
+          status: res.status
+        }
+      });
+      dispatch(load_user(apiUrl));
+    } catch (err) {
+      const error = err;
+      if (error.response) {
+        dispatch({
+          type: GOOGLE_AUTH_FAIL,
+          payload: error.response.data
+        });
+      }
+    }
+  }
+};
+var facebookAuthenticate = (state, code, apiUrl) => async (dispatch) => {
+  if (state && code && !localStorage.getItem("access")) {
+    const config = {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    };
+    const details = {
+      "state": state,
+      "code": code
+    };
+    const formBody = Object.keys(details).map((key) => encodeURIComponent(key) + "=" + encodeURIComponent(details[key])).join("&");
+    try {
+      const res = await axios.post(`${apiUrl}/auth/o/facebook/?${formBody}`, config);
+      dispatch({
+        type: FACEBOOK_AUTH_SUCCESS,
+        payload: res.data
+      });
+      dispatch(load_user(apiUrl));
+    } catch (err) {
+      const error = err;
+      if (error.response) {
+        dispatch({
+          type: FACEBOOK_AUTH_FAIL
+          // Assuming no payload is needed for this failure case, based on original code.
+          // If an error payload is expected, you would add it here.
+        });
+      }
+    }
+  }
+};
+var checkAuthenticated = (apiUrl) => async (dispatch) => {
+  if (localStorage.getItem("access")) {
+    const config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    };
+    const body = JSON.stringify({ token: localStorage.getItem("access") });
+    try {
+      const res = await axios.post(`${apiUrl}/auth/jwt/verify/`, body, config);
+      if (res.data.code !== "token_not_valid") {
+        dispatch({
+          type: AUTHENTICATED_SUCCESS
+        });
+      } else {
+        dispatch({
+          type: AUTHENTICATED_FAIL
+        });
+      }
+    } catch (err) {
+      dispatch({
+        type: AUTHENTICATED_FAIL
+      });
+    }
+  } else {
+    dispatch({
+      type: AUTHENTICATED_FAIL
+    });
+  }
+};
 var login = (formData, apiUrl) => async (dispatch) => {
   const config = {
     headers: {
@@ -127,6 +222,52 @@ var verify = (uid, token, apiUrl) => async (dispatch) => {
     }
   }
 };
+var reset_password = (email, apiUrl) => async (dispatch) => {
+  const config = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  const body = JSON.stringify({ email });
+  try {
+    const res = await axios.post(`${apiUrl}/auth/users/reset_password/`, body, config);
+    dispatch({
+      type: PASSWORD_RESET_SUCCESS,
+      payload: res.status
+    });
+  } catch (err) {
+    const error = err;
+    if (error.response) {
+      dispatch({
+        type: PASSWORD_RESET_FAIL,
+        payload: error.response.data
+      });
+    }
+  }
+};
+var reset_password_confirm = (formData, apiUrl) => async (dispatch) => {
+  const config = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  const body = JSON.stringify(formData);
+  try {
+    const res = await axios.post(`${apiUrl}/auth/users/reset_password_confirm/`, body, config);
+    dispatch({
+      type: PASSWORD_RESET_CONFIRM_SUCCESS,
+      payload: res.status
+    });
+  } catch (err) {
+    const error = err;
+    if (error.response) {
+      dispatch({
+        type: PASSWORD_RESET_CONFIRM_FAIL,
+        payload: error.response.data
+      });
+    }
+  }
+};
 var logout = () => (dispatch) => {
   dispatch({
     type: LOGOUT
@@ -137,6 +278,37 @@ var clearErrors = () => {
     type: CLEAR_ERRORS
   };
 };
+var changeLoggedInUserPassword = (formData, apiUrl) => async (dispatch) => {
+  if (localStorage.getItem("access")) {
+    const config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Authorization": `JWT ${localStorage.getItem("access")}`
+      }
+    };
+    const body = JSON.stringify(formData);
+    try {
+      const res = await axios.post(`${apiUrl}/auth/users/set_password/`, body, config);
+      dispatch({
+        type: PASSWORD_RESET_SUCCESS,
+        payload: res.data
+      });
+    } catch (err) {
+      const error = err;
+      if (error.response) {
+        dispatch({
+          type: PASSWORD_RESET_FAIL,
+          payload: error.response.data
+        });
+      }
+    }
+  } else {
+    dispatch({
+      type: AUTHENTICATED_FAIL
+    });
+  }
+};
 
 // src/hooks/useActivate.tsx
 var useActivate = (uid, token, apiUrl) => {
@@ -283,6 +455,306 @@ var useSignup = (initialFields, apiUrl) => {
 };
 var useSignup_default = useSignup;
 
+// src/hooks/useLoadUser.tsx
+import { useCallback as useCallback5, useEffect as useEffect4 } from "react";
+import { useDispatch as useDispatch5, useSelector as useSelector4 } from "react-redux";
+var useAuthicatedUser = (apiURL, location) => {
+  const dispatch = useDispatch5();
+  const isAuthenticated = useSelector4(
+    (state) => state.auth.isAuthenticated
+  );
+  const error = useSelector4((state) => state.auth.error);
+  const currentUser = useSelector4(
+    (state) => state.auth.user
+  );
+  useEffect4(() => {
+    dispatch(checkAuthenticated(apiURL));
+  }, [dispatch, apiURL, location]);
+  useEffect4(() => {
+    if (isAuthenticated) {
+      dispatch(load_user(apiURL));
+    }
+  }, [dispatch, isAuthenticated, apiURL]);
+  const refreshUser = useCallback5(() => {
+    dispatch(load_user(apiURL));
+  }, [dispatch, apiURL]);
+  const refreshAuth = useCallback5(async () => {
+    await dispatch(checkAuthenticated(apiURL));
+    dispatch(load_user(apiURL));
+  }, [dispatch, apiURL]);
+  const clearErrorsWrapper = useCallback5(() => {
+    dispatch(clearErrors());
+  }, [dispatch]);
+  return {
+    error,
+    isAuthenticated,
+    currentUser,
+    clearErrors: clearErrorsWrapper,
+    refreshUser,
+    refreshAuth
+  };
+};
+var useLoadUser_default = useAuthicatedUser;
+
+// src/hooks/useResetPassword.tsx
+import { useState as useState4, useCallback as useCallback6, useEffect as useEffect5 } from "react";
+import { useDispatch as useDispatch6, useSelector as useSelector5 } from "react-redux";
+var useResetPassword = (apiUrl) => {
+  const dispatch = useDispatch6();
+  const [loading, setLoading] = useState4(false);
+  const [email, setEmail] = useState4("");
+  const status = useSelector5((state) => state.auth.status);
+  const error = useSelector5((state) => state.auth.error);
+  const isStatus204 = status === 204;
+  useEffect5(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleChange = useCallback6((e) => {
+    setEmail(e.target.value);
+  }, []);
+  const handleSubmit = useCallback6(
+    async (e) => {
+      e.preventDefault();
+      setLoading(true);
+      try {
+        await dispatch(reset_password(email, apiUrl));
+      } catch (err) {
+        console.error("Error submitting form", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [dispatch, email, apiUrl]
+  );
+  return {
+    email,
+    loading,
+    handleChange,
+    status,
+    error,
+    handleSubmit,
+    isStatus204
+  };
+};
+var useResetPassword_default = useResetPassword;
+
+// src/hooks/usePasswordConfirm.tsx
+import { useState as useState5, useCallback as useCallback7, useEffect as useEffect6 } from "react";
+import { useDispatch as useDispatch7, useSelector as useSelector6 } from "react-redux";
+var usePasswordConfirm = (initialFields, apiUrl) => {
+  const dispatch = useDispatch7();
+  const [loading, setLoading] = useState5(false);
+  const [formData, setFormData] = useState5(initialFields);
+  const error = useSelector6((state) => state.auth.error);
+  const status = useSelector6((state) => state.auth.status);
+  const isStatus204 = status === 204;
+  useEffect6(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleChange = useCallback7((e) => {
+    const { name, value } = e.target;
+    setFormData((prevFields) => ({ ...prevFields, [name]: value }));
+  }, []);
+  const handleSubmit = useCallback7(
+    async (e) => {
+      e.preventDefault();
+      setLoading(true);
+      try {
+        await dispatch(reset_password_confirm(formData, apiUrl));
+      } catch (err) {
+        console.error("Error submitting form", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [dispatch, formData, apiUrl]
+  );
+  return {
+    loading,
+    formData,
+    error,
+    onChange: handleChange,
+    onSubmit: handleSubmit,
+    status,
+    isStatus204
+  };
+};
+var usePasswordConfirm_default = usePasswordConfirm;
+
+// src/hooks/useChangePassword.tsx
+import { useState as useState6, useCallback as useCallback8, useEffect as useEffect7 } from "react";
+import { useDispatch as useDispatch8, useSelector as useSelector7 } from "react-redux";
+var useChangeAuthenticatedUserPassword = (initialFields, apiUrl) => {
+  const dispatch = useDispatch8();
+  const [loading, setLoading] = useState6(false);
+  const [formData, setFormData] = useState6(initialFields);
+  const [error, setError] = useState6(null);
+  const authError = useSelector7(
+    (state) => state.auth.error
+  );
+  const status = useSelector7((state) => state.auth.status);
+  useEffect7(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleChange = useCallback8((e) => {
+    const { name, value } = e.target;
+    setFormData((prevFields) => ({ ...prevFields, [name]: value }));
+  }, []);
+  const handleSubmit = useCallback8(
+    async (e) => {
+      e.preventDefault();
+      const { current_password, new_password, confirm_new_password } = formData;
+      if (new_password !== confirm_new_password) {
+        setError("New passwords do not match.");
+        return;
+      }
+      setError(null);
+      setLoading(true);
+      try {
+        await dispatch(
+          changeLoggedInUserPassword({ current_password, new_password }, apiUrl)
+        );
+      } catch (err) {
+        console.error("Error submitting form", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [dispatch, formData, apiUrl]
+  );
+  return {
+    loading,
+    formData,
+    error: error || authError,
+    onChange: handleChange,
+    onSubmit: handleSubmit,
+    status
+  };
+};
+var useChangePassword_default = useChangeAuthenticatedUserPassword;
+
+// src/hooks/useGoogleAuth.tsx
+import { useDispatch as useDispatch9, useSelector as useSelector8 } from "react-redux";
+import { useEffect as useEffect8, useCallback as useCallback9, useState as useState7 } from "react";
+import axios2 from "axios";
+var useGoogleAuth = (apiUrl) => {
+  const dispatch = useDispatch9();
+  const isAuthenticated = useSelector8(
+    (state) => state.auth.isAuthenticated
+  );
+  const error = useSelector8((state) => state.auth.error);
+  const status = useSelector8((state) => state.auth.status);
+  const [loading, setLoading] = useState7(false);
+  const isStatus201 = status === 201;
+  const continueWithGoogle = useCallback9(async () => {
+    setLoading(true);
+    const redirectUri = `${window.location.origin}/login`;
+    try {
+      const res = await axios2.get(
+        `${apiUrl}/auth/o/google-oauth2/?redirect_uri=${redirectUri}`
+      );
+      window.location.replace(res.data.authorization_url);
+    } catch (err) {
+      console.error("Google Auth Failed", err);
+    } finally {
+      setLoading(false);
+    }
+  }, [apiUrl]);
+  const authenticateWithGoogle = useCallback9(
+    async (state, code) => {
+      if (!state || !code)
+        return;
+      setLoading(true);
+      try {
+        await dispatch(googleAuthenticate(state, code, apiUrl));
+      } catch (err) {
+        console.error("Authentication failed", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiUrl, dispatch]
+  );
+  useEffect8(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  return {
+    continueWithGoogle,
+    authenticateWithGoogle,
+    isAuthenticated,
+    error,
+    isStatus201,
+    loading
+  };
+};
+var useGoogleAuth_default = useGoogleAuth;
+
+// src/hooks/useFacebookAuth.tsx
+import { useDispatch as useDispatch10, useSelector as useSelector9 } from "react-redux";
+import { useEffect as useEffect9, useCallback as useCallback10, useState as useState8 } from "react";
+import axios3 from "axios";
+var useFacebookAuth = (apiUrl) => {
+  const dispatch = useDispatch10();
+  const isAuthenticated = useSelector9(
+    (state) => state.auth.isAuthenticated
+  );
+  const error = useSelector9((state) => state.auth.error);
+  const status = useSelector9((state) => state.auth.status);
+  const [loading, setLoading] = useState8(false);
+  const isStatus201 = status === 201;
+  const continueWithFacebook = useCallback10(async () => {
+    setLoading(true);
+    const redirectUri = `${window.location.origin}/login`;
+    try {
+      const res = await axios3.get(
+        `${apiUrl}/auth/o/facebook-oauth2/?redirect_uri=${redirectUri}`
+      );
+      window.location.replace(res.data.authorization_url);
+    } catch (err) {
+      console.error("Facebook Auth Failed", err);
+    } finally {
+      setLoading(false);
+    }
+  }, [apiUrl]);
+  const authenticateWithFacebook = useCallback10(
+    async (state, code) => {
+      if (!state || !code)
+        return;
+      setLoading(true);
+      try {
+        await dispatch(facebookAuthenticate(state, code, apiUrl));
+      } catch (err) {
+        console.error("Authentication failed", err);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [apiUrl, dispatch]
+  );
+  useEffect9(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  return {
+    continueWithFacebook,
+    authenticateWithFacebook,
+    isAuthenticated,
+    error,
+    isStatus201,
+    loading
+  };
+};
+var useFacebookAuth_default = useFacebookAuth;
+
 // src/app.tsx
 import React from "react";
 import { Provider } from "react-redux";
@@ -384,9 +856,10 @@ function authReducer(state = initialState, action) {
 }
 
 // src/reducers/index.ts
-var reducers_default = combineReducers({
+var rootReducer = combineReducers({
   auth: authReducer
 });
+var reducers_default = rootReducer;
 
 // src/store.ts
 var initialState2 = {};
@@ -405,7 +878,13 @@ var app_default = AuthProvider;
 export {
   app_default as AuthProvider,
   useActivate_default as useActivate,
+  useLoadUser_default as useAuthicatedUser,
+  useChangePassword_default as useChangeAuthenticatedUserPassword,
+  useFacebookAuth_default as useFacebookAuth,
+  useGoogleAuth_default as useGoogleAuth,
   useLogin_default as useLogin,
   useLogout_default as useLogout,
+  usePasswordConfirm_default as usePasswordConfirm,
+  useResetPassword_default as useResetPassword,
   useSignup_default as useSignup
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-redux-django-auth",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A React Redux Authentication system for django app built with TypeScript.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -16,7 +16,15 @@
     "react",
     "component",
     "typescript",
-    "npm"
+    "npm",
+    "redux",
+    "django",
+    "authentication",
+    "auth",
+    "redux-toolkit",
+    "redux-thunk",
+    "react-redux",
+    "redux-devtools"
   ],
   "author": "Your Name",
   "license": "MIT",