react-redux-django-auth 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,16 +1,411 @@
-// src/index.tsx
-import React from "react";
-var Button = ({ label, onClick }) => {
-  return /* @__PURE__ */ React.createElement(
-    "button",
-    {
-      onClick,
-      style: { padding: "10px", borderRadius: "5px", border: "1px solid #ccc" }
+// src/hooks/useActivate.tsx
+import { useState, useCallback, useEffect } from "react";
+import { useDispatch, useSelector } from "react-redux";
+
+// src/actions/auth.ts
+import axios from "axios";
+
+// src/actions/types.ts
+var LOGIN_SUCCESS = "LOGIN_SUCCESS";
+var LOGIN_FAIL = "LOGIN_FAIL";
+var USER_LOADED_SUCCESS = "USER_LOADED_SUCCESS";
+var USER_LOADED_FAIL = "USER_LOADED_FAIL";
+var AUTHENTICATED_SUCCESS = "AUTHENTICATED_SUCCESS";
+var AUTHENTICATED_FAIL = "AUTHENTICATED_FAIL";
+var PASSWORD_RESET_SUCCESS = "PASSWORD_RESET_SUCCESS";
+var PASSWORD_RESET_FAIL = "PASSWORD_RESET_FAIL";
+var PASSWORD_RESET_CONFIRM_SUCCESS = "PASSWORD_RESET_CONFIRM_SUCCESS";
+var PASSWORD_RESET_CONFIRM_FAIL = "PASSWORD_RESET_CONFIRM_FAIL";
+var SIGNUP_SUCCESS = "SIGNUP_SUCCESS";
+var SIGNUP_FAIL = "SIGNUP_FAIL";
+var ACTIVATION_SUCCESS = "ACTIVATION_SUCCESS";
+var ACTIVATION_FAIL = "ACTIVATION_FAIL";
+var GOOGLE_AUTH_SUCCESS = "GOOGLE_AUTH_SUCCESS";
+var GOOGLE_AUTH_FAIL = "GOOGLE_AUTH_FAIL";
+var FACEBOOK_AUTH_SUCCESS = "FACEBOOK_AUTH_SUCCESS";
+var FACEBOOK_AUTH_FAIL = "FACEBOOK_AUTH_FAIL";
+var LOGOUT = "LOGOUT";
+var CLEAR_ERRORS = "CLEAR_ERRORS";
+
+// src/actions/auth.ts
+var load_user = (apiUrl) => async (dispatch) => {
+  if (localStorage.getItem("access")) {
+    const config = {
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `JWT ${localStorage.getItem("access")}`,
+        "Accept": "application/json"
+      }
+    };
+    try {
+      const res = await axios.get(`${apiUrl}/auth/users/me/`, config);
+      dispatch({
+        type: USER_LOADED_SUCCESS,
+        payload: res.data
+      });
+    } catch (err) {
+      dispatch({
+        type: USER_LOADED_FAIL
+      });
+    }
+  } else {
+    dispatch({
+      type: USER_LOADED_FAIL
+    });
+  }
+};
+var login = (formData, apiUrl) => async (dispatch) => {
+  const config = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  const body = JSON.stringify(formData);
+  try {
+    const res = await axios.post(`${apiUrl}/auth/jwt/create/`, body, config);
+    dispatch({
+      type: LOGIN_SUCCESS,
+      payload: {
+        ...res.data,
+        status: res.status
+      }
+    });
+    dispatch(load_user(apiUrl));
+  } catch (err) {
+    const error = err;
+    if (error.response) {
+      dispatch({
+        type: LOGIN_FAIL,
+        payload: error.response.data
+      });
+    }
+  }
+};
+var signup = (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/`, body, config);
+    dispatch({
+      type: SIGNUP_SUCCESS,
+      payload: res.status
+    });
+  } catch (err) {
+    const error = err;
+    if (error.response) {
+      dispatch({
+        type: SIGNUP_FAIL,
+        payload: error.response.data
+      });
+    }
+  }
+};
+var verify = (uid, token, apiUrl) => async (dispatch) => {
+  const config = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  const body = JSON.stringify({ uid, token });
+  try {
+    const res = await axios.post(`${apiUrl}/auth/users/activation/`, body, config);
+    dispatch({
+      type: ACTIVATION_SUCCESS,
+      payload: res.status
+    });
+  } catch (err) {
+    const error = err;
+    if (error.response) {
+      dispatch({
+        type: ACTIVATION_FAIL,
+        payload: error.response.data
+      });
+    }
+  }
+};
+var logout = () => (dispatch) => {
+  dispatch({
+    type: LOGOUT
+  });
+};
+var clearErrors = () => {
+  return {
+    type: CLEAR_ERRORS
+  };
+};
+
+// src/hooks/useActivate.tsx
+var useActivate = (uid, token, apiUrl) => {
+  const [loading, setLoading] = useState(false);
+  const dispatch = useDispatch();
+  const error = useSelector((state) => state.error);
+  const status = useSelector((state) => state.status);
+  const isStatus204 = status === 204;
+  useEffect(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleSubmit = useCallback(
+    async (e) => {
+      e.preventDefault();
+      setLoading(true);
+      try {
+        await dispatch(verify(uid, token, apiUrl));
+      } catch (error2) {
+        console.error("Error submitting form", error2);
+      } finally {
+        setLoading(false);
+      }
     },
-    label
+    [dispatch, uid, token, apiUrl]
   );
+  return {
+    loading,
+    error,
+    onSubmit: handleSubmit,
+    status,
+    isStatus204
+  };
+};
+var useActivate_default = useActivate;
+
+// src/hooks/useLogin.tsx
+import { useState as useState2, useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { useDispatch as useDispatch2, useSelector as useSelector2 } from "react-redux";
+var useLogin = (initialFields, apiUrl) => {
+  const [loading, setLoading] = useState2(false);
+  const [formData, setFormData] = useState2(initialFields);
+  const dispatch = useDispatch2();
+  const isAuthenticated = useSelector2(
+    (state) => state.isAuthenticated
+  );
+  const error = useSelector2((state) => state.error);
+  const status = useSelector2((state) => state.status);
+  const isStatus200 = status === 200;
+  useEffect2(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleChange = useCallback2((e) => {
+    const { name, value } = e.target;
+    setFormData((prevFields) => ({ ...prevFields, [name]: value }));
+  }, []);
+  const handleSubmit = useCallback2(
+    async (e) => {
+      e.preventDefault();
+      setLoading(true);
+      try {
+        await dispatch(login(formData, apiUrl));
+      } catch (error2) {
+        console.error("Error submitting form", error2);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [dispatch, formData, apiUrl]
+  );
+  return {
+    loading,
+    formData,
+    error,
+    onChange: handleChange,
+    onSubmit: handleSubmit,
+    isAuthenticated,
+    isStatus200
+  };
+};
+var useLogin_default = useLogin;
+
+// src/hooks/useLogout.tsx
+import { useCallback as useCallback3 } from "react";
+import { useDispatch as useDispatch3 } from "react-redux";
+var useLogout = () => {
+  const dispatch = useDispatch3();
+  const handleLogout = useCallback3(() => {
+    dispatch(logout());
+  }, [dispatch]);
+  return handleLogout;
+};
+var useLogout_default = useLogout;
+
+// src/hooks/useSignup.tsx
+import { useState as useState3, useCallback as useCallback4, useEffect as useEffect3 } from "react";
+import { useDispatch as useDispatch4, useSelector as useSelector3 } from "react-redux";
+var useSignup = (initialFields, apiUrl) => {
+  const [loading, setLoading] = useState3(false);
+  const [formData, setFormData] = useState3(initialFields);
+  const dispatch = useDispatch4();
+  const isAuthenticated = useSelector3(
+    (state) => state.isAuthenticated
+  );
+  const error = useSelector3((state) => state.error);
+  const status = useSelector3((state) => state.status);
+  const isStatus201 = status === 201;
+  useEffect3(() => {
+    return () => {
+      dispatch(clearErrors());
+    };
+  }, [dispatch]);
+  const handleChange = useCallback4((e) => {
+    const { name, value } = e.target;
+    setFormData((prevFields) => ({ ...prevFields, [name]: value }));
+  }, []);
+  const handleSubmit = useCallback4(
+    async (e) => {
+      e.preventDefault();
+      setLoading(true);
+      try {
+        await dispatch(signup(formData, apiUrl));
+      } catch (error2) {
+        console.error("Error submitting form", error2);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [dispatch, formData, apiUrl]
+  );
+  return {
+    loading,
+    formData,
+    error,
+    onChange: handleChange,
+    onSubmit: handleSubmit,
+    isAuthenticated,
+    status,
+    isStatus201
+  };
+};
+var useSignup_default = useSignup;
+
+// src/app.tsx
+import React from "react";
+import { Provider } from "react-redux";
+
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+
+// src/reducers/index.ts
+import { combineReducers } from "redux";
+
+// src/reducers/auth.ts
+var initialState = {
+  access: localStorage.getItem("access"),
+  refresh: localStorage.getItem("refresh"),
+  isAuthenticated: null,
+  user: null,
+  error: null,
+  status: null
+};
+function authReducer(state = initialState, action) {
+  const { type, payload } = action;
+  switch (type) {
+    case AUTHENTICATED_SUCCESS:
+      return {
+        ...state,
+        isAuthenticated: true
+      };
+    case LOGIN_SUCCESS:
+    case GOOGLE_AUTH_SUCCESS:
+    case FACEBOOK_AUTH_SUCCESS:
+      localStorage.setItem("access", payload.access);
+      localStorage.setItem("refresh", payload.refresh);
+      return {
+        ...state,
+        isAuthenticated: true,
+        access: payload.access,
+        refresh: payload.refresh,
+        status: payload.status
+      };
+    case SIGNUP_SUCCESS:
+      return {
+        ...state,
+        isAuthenticated: false,
+        status: payload
+      };
+    case USER_LOADED_SUCCESS:
+      return {
+        ...state,
+        user: payload
+      };
+    case AUTHENTICATED_FAIL:
+      return {
+        ...state,
+        isAuthenticated: false
+      };
+    case USER_LOADED_FAIL:
+      return {
+        ...state,
+        user: null
+      };
+    case GOOGLE_AUTH_FAIL:
+    case FACEBOOK_AUTH_FAIL:
+    case LOGIN_FAIL:
+    case SIGNUP_FAIL:
+    case LOGOUT:
+      localStorage.removeItem("access");
+      localStorage.removeItem("refresh");
+      return {
+        ...state,
+        access: null,
+        refresh: null,
+        isAuthenticated: false,
+        user: null,
+        error: payload
+      };
+    case PASSWORD_RESET_SUCCESS:
+    case PASSWORD_RESET_CONFIRM_SUCCESS:
+    case ACTIVATION_SUCCESS:
+      return {
+        ...state,
+        status: payload
+      };
+    case ACTIVATION_FAIL:
+    case PASSWORD_RESET_CONFIRM_FAIL:
+    case PASSWORD_RESET_FAIL:
+      return {
+        ...state,
+        error: payload
+      };
+    case CLEAR_ERRORS:
+      return {
+        ...state,
+        error: null,
+        status: null
+      };
+    default:
+      return state;
+  }
+}
+
+// src/reducers/index.ts
+var reducers_default = combineReducers({
+  auth: authReducer
+});
+
+// src/store.ts
+var initialState2 = {};
+var store = configureStore({
+  reducer: reducers_default,
+  // If you want to set an initial state, use preloadedState instead:
+  preloadedState: initialState2
+});
+var store_default = store;
+
+// src/app.tsx
+var AuthProvider = ({ children }) => {
+  return /* @__PURE__ */ React.createElement(Provider, { store: store_default }, children);
 };
-var src_default = Button;
+var app_default = AuthProvider;
 export {
-  src_default as default
+  app_default as AuthProvider,
+  useActivate_default as useActivate,
+  useLogin_default as useLogin,
+  useLogout_default as useLogout,
+  useSignup_default as useSignup
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-redux-django-auth",
-  "version": "1.0.0",
-  "description": "A simple React component package with TypeScript.",
+  "version": "1.1.0",
+  "description": "A React Redux Authentication system for django app built with TypeScript.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -32,5 +32,13 @@
     "react-dom": "^18.2.0",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@redux-devtools/extension": "^3.3.0",
+    "@reduxjs/toolkit": "^2.8.2",
+    "axios": "^1.11.0",
+    "react-redux": "^9.2.0",
+    "redux": "^5.0.1",
+    "redux-thunk": "^3.1.0"
   }
 }