dauth-context-react 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,8 +1,733 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-'use strict'
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  DauthProvider: () => DauthProvider,
+  useDauth: () => useDauth
+});
+module.exports = __toCommonJS(index_exports);
+var import_react = require("react");
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./dauth-context-react.cjs.production.min.js')
-} else {
-  module.exports = require('./dauth-context-react.cjs.development.js')
+// src/initialDauthState.ts
+var initialDauthState = {
+  user: {
+    language: (typeof window !== "undefined" ? window.document.documentElement.getAttribute("lang") : null) || "es"
+  },
+  domain: {},
+  isLoading: true,
+  isAuthenticated: false,
+  loginWithRedirect: () => {
+  },
+  logout: () => {
+  },
+  getAccessToken: () => Promise.resolve(""),
+  updateUser: () => Promise.resolve(false),
+  updateUserWithRedirect: () => {
+  },
+  // Send email verification
+  sendEmailVerificationStatus: {
+    status: {
+      type: "info",
+      message: "Sending email verification..."
+    },
+    isLoading: false
+  },
+  sendEmailVerification: () => Promise.resolve(false),
+  deleteAccount: () => Promise.resolve(false)
+};
+var initialDauthState_default = initialDauthState;
+
+// src/reducer/dauth.types.ts
+var LOGIN = "LOGIN";
+var SET_IS_LOADING = "SET_IS_LOADING";
+var UPDATE_USER = "UPDATE_USER";
+var SET_SEND_EMAIL_VERIFICATION_IS_LOADING = "SET_SEND_EMAIL_VERIFICATION_IS_LOADING";
+var SET_SEND_EMAIL_VERIFICATION_STATUS = "SET_SEND_EMAIL_VERIFICATION_STATUS";
+
+// src/reducer/dauth.reducer.ts
+function userReducer(state, action) {
+  const { type, payload } = action;
+  switch (type) {
+    case LOGIN: {
+      const login = {
+        ...state,
+        user: payload.user,
+        domain: payload.domain,
+        isAuthenticated: payload.isAuthenticated
+      };
+      return login;
+    }
+    case SET_IS_LOADING: {
+      const isLoading = {
+        ...state,
+        isLoading: payload.isLoading
+      };
+      return isLoading;
+    }
+    case UPDATE_USER: {
+      const updateUser = {
+        ...state,
+        user: {
+          ...state.user,
+          ...payload
+        }
+      };
+      return updateUser;
+    }
+    case SET_SEND_EMAIL_VERIFICATION_STATUS: {
+      const setSendEmailVerificationStatus = {
+        ...state,
+        sendEmailVerificationStatus: {
+          ...state.sendEmailVerificationStatus,
+          status: {
+            type: payload.type,
+            message: payload.message
+          }
+        }
+      };
+      return setSendEmailVerificationStatus;
+    }
+    case SET_SEND_EMAIL_VERIFICATION_IS_LOADING: {
+      const setSendEmailVerificationIsLoading = {
+        ...state,
+        sendEmailVerificationStatus: {
+          ...state.sendEmailVerificationStatus,
+          isLoading: payload
+        }
+      };
+      return setSendEmailVerificationIsLoading;
+    }
+    default:
+      return state;
+  }
+}
+
+// src/api/utils/config.ts
+var apiVersion = "v1";
+var serverDomain = "dauth.ovh";
+function checkIsLocalhost() {
+  if (typeof window === "undefined") return false;
+  const hostname = window.location.hostname;
+  return Boolean(
+    hostname === "localhost" || hostname === "[::1]" || hostname.match(
+      /(192)\.(168)\.(1)\.([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/gm
+    ) || hostname.match(/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/)
+  );
+}
+function getServerBasePath() {
+  const isLocalhost = checkIsLocalhost();
+  const serverPort = 4012;
+  const serverLocalUrl = `${window.location.protocol}//${window.location.hostname}:${serverPort}/api/${apiVersion}`;
+  const serverProdUrl = `https://${serverDomain}/api/${apiVersion}`;
+  return isLocalhost ? serverLocalUrl : serverProdUrl;
+}
+function getClientBasePath() {
+  const isLocalhost = checkIsLocalhost();
+  const clientPort = 5185;
+  const clientLocalUrl = `${window.location.protocol}//${window.location.hostname}:${clientPort}`;
+  const clientProdUrl = `https://${serverDomain}`;
+  return isLocalhost ? clientLocalUrl : clientProdUrl;
+}
+
+// src/api/dauth.api.ts
+var getUserAPI = async (domainName, token) => {
+  const params = {
+    method: "GET",
+    headers: {
+      Authorization: token,
+      "Content-Type": "application/json"
+    }
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/user`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};
+var updateUserAPI = async (domainName, user, token) => {
+  const params = {
+    method: "PATCH",
+    headers: {
+      Authorization: token,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(user)
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/user`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};
+var sendEmailVerificationAPI = async (domainName, token) => {
+  const params = {
+    method: "GET",
+    headers: {
+      Authorization: token,
+      "Content-Type": "application/json"
+    }
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/resend-email-verification`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};
+var refreshTokenAPI = async (domainName, refreshToken) => {
+  const params = {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ refreshToken })
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/refresh-token`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};
+var deleteAccountAPI = async (domainName, token) => {
+  const params = {
+    method: "DELETE",
+    headers: {
+      Authorization: token,
+      "Content-Type": "application/json"
+    }
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/user`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};
+var logoutAPI = async (domainName, refreshToken) => {
+  const params = {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ refreshToken })
+  };
+  const response = await fetch(
+    `${getServerBasePath()}/app/${domainName}/logout`,
+    params
+  );
+  return { response };
+};
+
+// src/reducer/dauth.actions.ts
+async function setDauthStateAction({
+  dispatch,
+  token,
+  refreshToken,
+  domainName,
+  storageKeys,
+  onError
+}) {
+  dispatch({ type: SET_IS_LOADING, payload: { isLoading: true } });
+  try {
+    const getUserFetch = await getUserAPI(domainName, token);
+    if (getUserFetch.response.status === 200) {
+      dispatch({
+        type: LOGIN,
+        payload: {
+          user: getUserFetch.data.user,
+          domain: getUserFetch.data.domain,
+          isAuthenticated: true
+        }
+      });
+      window.history.replaceState({}, document.title, window.location.pathname);
+      localStorage.setItem(storageKeys.accessToken, token);
+      localStorage.setItem(storageKeys.refreshToken, refreshToken);
+      return;
+    } else {
+      return resetUser(dispatch, storageKeys);
+    }
+  } catch (error) {
+    onError(error instanceof Error ? error : new Error(String(error)));
+    return resetUser(dispatch, storageKeys);
+  } finally {
+    dispatch({
+      type: SET_IS_LOADING,
+      payload: { isLoading: false }
+    });
+  }
+}
+async function setAutoLoginAction({
+  dispatch,
+  domainName,
+  storageKeys,
+  onError
+}) {
+  dispatch({ type: SET_IS_LOADING, payload: { isLoading: true } });
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
+  if (!storedRefreshToken) {
+    dispatch({
+      type: SET_IS_LOADING,
+      payload: { isLoading: false }
+    });
+    return resetUser(dispatch, storageKeys);
+  }
+  try {
+    const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
+    if (refreshResult.response.status === 200) {
+      const newAccessToken = refreshResult.data.accessToken;
+      const newRefreshToken = refreshResult.data.refreshToken;
+      localStorage.setItem(storageKeys.accessToken, newAccessToken);
+      localStorage.setItem(storageKeys.refreshToken, newRefreshToken);
+      const getUserFetch = await getUserAPI(domainName, newAccessToken);
+      if (getUserFetch.response.status === 200) {
+        dispatch({
+          type: LOGIN,
+          payload: {
+            user: getUserFetch.data.user,
+            domain: getUserFetch.data.domain,
+            isAuthenticated: true
+          }
+        });
+        return;
+      }
+    }
+    resetUser(dispatch, storageKeys);
+  } catch (error) {
+    onError(error instanceof Error ? error : new Error(String(error)));
+    resetUser(dispatch, storageKeys);
+  } finally {
+    dispatch({
+      type: SET_IS_LOADING,
+      payload: { isLoading: false }
+    });
+  }
 }
+async function setLogoutAction({
+  dispatch,
+  domainName,
+  storageKeys
+}) {
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
+  if (storedRefreshToken && domainName) {
+    try {
+      await logoutAPI(domainName, storedRefreshToken);
+    } catch (_) {
+    }
+  }
+  dispatch({ type: SET_IS_LOADING, payload: { isLoading: true } });
+  dispatch({
+    type: LOGIN,
+    payload: {
+      user: {
+        language: window.document.documentElement.getAttribute("lang") || "es"
+      },
+      domain: {},
+      isAuthenticated: false
+    }
+  });
+  localStorage.removeItem(storageKeys.accessToken);
+  localStorage.removeItem(storageKeys.refreshToken);
+  return dispatch({
+    type: SET_IS_LOADING,
+    payload: { isLoading: false }
+  });
+}
+async function refreshSessionAction({
+  dispatch,
+  domainName,
+  storageKeys,
+  onError
+}) {
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
+  if (!storedRefreshToken) {
+    return resetUser(dispatch, storageKeys);
+  }
+  try {
+    const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
+    if (refreshResult.response.status === 200) {
+      localStorage.setItem(
+        storageKeys.accessToken,
+        refreshResult.data.accessToken
+      );
+      localStorage.setItem(
+        storageKeys.refreshToken,
+        refreshResult.data.refreshToken
+      );
+      return;
+    }
+    resetUser(dispatch, storageKeys);
+  } catch (error) {
+    onError(error instanceof Error ? error : new Error(String(error)));
+    resetUser(dispatch, storageKeys);
+  }
+}
+async function setUpdateUserAction({
+  dispatch,
+  domainName,
+  user,
+  token,
+  onError
+}) {
+  if (user.language) {
+    window.document.documentElement.setAttribute("lang", user.language);
+  }
+  if (!token) {
+    dispatch({
+      type: UPDATE_USER,
+      payload: user
+    });
+    return false;
+  }
+  try {
+    const getUserFetch = await updateUserAPI(domainName, user, token);
+    if (getUserFetch.response.status === 200) {
+      dispatch({
+        type: UPDATE_USER,
+        payload: getUserFetch.data.user
+      });
+      return true;
+    } else {
+      onError(new Error("Update user error: " + getUserFetch.data.message));
+      return false;
+    }
+  } catch (error) {
+    onError(
+      error instanceof Error ? error : new Error("Update user error")
+    );
+    return false;
+  }
+}
+async function sendEmailVerificationAction({
+  dispatch,
+  domainName,
+  token
+}) {
+  dispatch({
+    type: SET_SEND_EMAIL_VERIFICATION_IS_LOADING,
+    payload: true
+  });
+  dispatch({
+    type: SET_SEND_EMAIL_VERIFICATION_STATUS,
+    payload: { type: "info", message: "Sending email verification..." }
+  });
+  try {
+    const sendEmailFetch = await sendEmailVerificationAPI(domainName, token);
+    if (sendEmailFetch.response.status === 200) {
+      dispatch({
+        type: SET_SEND_EMAIL_VERIFICATION_STATUS,
+        payload: { type: "success", message: sendEmailFetch.data.message }
+      });
+      dispatch({
+        type: SET_SEND_EMAIL_VERIFICATION_IS_LOADING,
+        payload: false
+      });
+      return true;
+    } else {
+      dispatch({
+        type: SET_SEND_EMAIL_VERIFICATION_STATUS,
+        payload: { type: "error", message: sendEmailFetch.data.message }
+      });
+      dispatch({
+        type: SET_SEND_EMAIL_VERIFICATION_IS_LOADING,
+        payload: false
+      });
+      return false;
+    }
+  } catch (_) {
+    dispatch({
+      type: SET_SEND_EMAIL_VERIFICATION_STATUS,
+      payload: {
+        type: "error",
+        message: "Send email verification fetch error"
+      }
+    });
+    dispatch({
+      type: SET_SEND_EMAIL_VERIFICATION_IS_LOADING,
+      payload: false
+    });
+    return false;
+  }
+}
+async function getAccessTokenAction({
+  dispatch,
+  domainName,
+  storageKeys,
+  onError
+}) {
+  const token_ls = localStorage.getItem(storageKeys.accessToken);
+  if (!token_ls) return "token-not-found";
+  try {
+    const payloadB64 = token_ls.split(".")[1];
+    if (payloadB64) {
+      const payload = JSON.parse(atob(payloadB64));
+      const expiresIn = (payload.exp || 0) * 1e3 - Date.now();
+      if (expiresIn < 5 * 60 * 1e3) {
+        await refreshSessionAction({
+          dispatch,
+          domainName,
+          storageKeys,
+          onError
+        });
+        const refreshedToken = localStorage.getItem(storageKeys.accessToken);
+        return refreshedToken || "token-not-found";
+      }
+    }
+  } catch (_) {
+  }
+  return token_ls;
+}
+async function deleteAccountAction({
+  dispatch,
+  domainName,
+  storageKeys,
+  onError,
+  token
+}) {
+  try {
+    const result = await deleteAccountAPI(domainName, token);
+    if (result.response.status === 200) {
+      resetUser(dispatch, storageKeys);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    onError(
+      error instanceof Error ? error : new Error("Delete account error")
+    );
+    return false;
+  }
+}
+var resetUser = (dispatch, storageKeys) => {
+  localStorage.removeItem(storageKeys.accessToken);
+  localStorage.removeItem(storageKeys.refreshToken);
+  return dispatch({
+    type: LOGIN,
+    payload: {
+      user: {},
+      domain: {},
+      isAuthenticated: false
+    }
+  });
+};
+
+// src/constants.ts
+var TOKEN_LS = "dauth_state";
+var REFRESH_TOKEN_LS = "dauth_refresh_token";
+
+// src/api/utils/routes.ts
+var routes = {
+  signin: "signin",
+  updateUser: "update-user"
+};
+
+// src/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultOnError = (error) => console.error(error);
+var DauthProvider = (props) => {
+  const { domainName, children, storageKey, onError, env } = props;
+  const [dauthState, dispatch] = (0, import_react.useReducer)(userReducer, initialDauthState_default);
+  const refreshTimerRef = (0, import_react.useRef)(null);
+  const storageKeys = (0, import_react.useMemo)(
+    () => ({
+      accessToken: storageKey?.accessToken ?? TOKEN_LS,
+      refreshToken: storageKey?.refreshToken ?? REFRESH_TOKEN_LS
+    }),
+    [storageKey?.accessToken, storageKey?.refreshToken]
+  );
+  const handleError = (0, import_react.useCallback)(
+    (error) => (onError ?? defaultOnError)(error),
+    [onError]
+  );
+  const ctx = (0, import_react.useMemo)(
+    () => ({ dispatch, domainName, storageKeys, onError: handleError }),
+    [domainName, storageKeys, handleError]
+  );
+  const scheduleRefresh = (0, import_react.useCallback)(() => {
+    if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current);
+    const token = localStorage.getItem(storageKeys.accessToken);
+    if (!token) return;
+    try {
+      const payloadB64 = token.split(".")[1];
+      if (!payloadB64) return;
+      const payload = JSON.parse(atob(payloadB64));
+      const expiresIn = (payload.exp || 0) * 1e3 - Date.now();
+      const refreshIn = Math.max(expiresIn - 5 * 60 * 1e3, 1e4);
+      refreshTimerRef.current = setTimeout(async () => {
+        await refreshSessionAction(ctx);
+        scheduleRefresh();
+      }, refreshIn);
+    } catch (_) {
+      refreshTimerRef.current = setTimeout(async () => {
+        await refreshSessionAction(ctx);
+        scheduleRefresh();
+      }, 5 * 60 * 1e3);
+    }
+  }, [ctx, storageKeys.accessToken]);
+  (0, import_react.useEffect)(() => {
+    (async () => {
+      const queryString = window.location.search;
+      if (!queryString) return;
+      const urlParams = new URLSearchParams(queryString);
+      const token_url = urlParams.get(storageKeys.accessToken);
+      const refresh_url = urlParams.get(storageKeys.refreshToken);
+      if (token_url && refresh_url && !dauthState.isAuthenticated) {
+        return setDauthStateAction({
+          ...ctx,
+          token: token_url,
+          refreshToken: refresh_url
+        });
+      }
+    })();
+  }, []);
+  (0, import_react.useEffect)(() => {
+    (async () => {
+      const refreshToken = localStorage.getItem(storageKeys.refreshToken);
+      if (refreshToken && !dauthState.isAuthenticated) {
+        return setAutoLoginAction(ctx);
+      } else {
+        return dispatch({
+          type: SET_IS_LOADING,
+          payload: { isLoading: false }
+        });
+      }
+    })();
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (dauthState.isAuthenticated) {
+      scheduleRefresh();
+    }
+    return () => {
+      if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current);
+    };
+  }, [dauthState.isAuthenticated, scheduleRefresh]);
+  const loginWithRedirect = (0, import_react.useCallback)(() => {
+    const base = `${getClientBasePath()}/${domainName}/${routes.signin}`;
+    const url = env ? `${base}?env=${encodeURIComponent(env)}` : base;
+    return window.location.replace(url);
+  }, [domainName, env]);
+  const logout = (0, import_react.useCallback)(() => {
+    if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current);
+    return setLogoutAction({
+      dispatch,
+      domainName,
+      storageKeys
+    });
+  }, [domainName, storageKeys]);
+  const getAccessToken = (0, import_react.useCallback)(async () => {
+    const token = await getAccessTokenAction(ctx);
+    return token;
+  }, [ctx]);
+  const updateUser = (0, import_react.useCallback)(
+    async (fields) => {
+      const token_ls = localStorage.getItem(storageKeys.accessToken);
+      const {
+        name,
+        lastname,
+        nickname,
+        telPrefix,
+        telSuffix,
+        language,
+        avatar,
+        birthDate,
+        country,
+        metadata
+      } = fields;
+      const user = {
+        name,
+        lastname,
+        nickname,
+        telPrefix,
+        telSuffix,
+        language,
+        avatar,
+        birthDate,
+        country,
+        metadata
+      };
+      return await setUpdateUserAction({
+        ...ctx,
+        user,
+        token: token_ls
+      });
+    },
+    [ctx, storageKeys.accessToken]
+  );
+  const updateUserWithRedirect = (0, import_react.useCallback)(() => {
+    const token_ls = localStorage.getItem(storageKeys.accessToken);
+    if (!token_ls) return;
+    return window.location.replace(
+      `${getClientBasePath()}/${domainName}/${routes.updateUser}/${token_ls}`
+    );
+  }, [domainName, storageKeys.accessToken]);
+  const sendEmailVerification = (0, import_react.useCallback)(async () => {
+    const token_ls = localStorage.getItem(storageKeys.accessToken);
+    if (!token_ls) return false;
+    return await sendEmailVerificationAction({
+      ...ctx,
+      token: token_ls
+    });
+  }, [ctx, storageKeys.accessToken]);
+  const deleteAccount = (0, import_react.useCallback)(async () => {
+    const token_ls = localStorage.getItem(storageKeys.accessToken);
+    if (!token_ls) return false;
+    if (refreshTimerRef.current) clearTimeout(refreshTimerRef.current);
+    return await deleteAccountAction({
+      ...ctx,
+      token: token_ls
+    });
+  }, [ctx, storageKeys.accessToken]);
+  const memoProvider = (0, import_react.useMemo)(
+    () => ({
+      ...dauthState,
+      loginWithRedirect,
+      logout,
+      getAccessToken,
+      updateUser,
+      updateUserWithRedirect,
+      sendEmailVerification,
+      deleteAccount
+    }),
+    [
+      dauthState,
+      loginWithRedirect,
+      logout,
+      getAccessToken,
+      updateUser,
+      updateUserWithRedirect,
+      sendEmailVerification,
+      deleteAccount
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DauthContext.Provider, { value: memoProvider, children });
+};
+var DauthContext = (0, import_react.createContext)(initialDauthState_default);
+var useDauth = () => {
+  const context = (0, import_react.useContext)(DauthContext);
+  if (!context) {
+    throw new Error("useDauth must be used inside DauthProvider");
+  }
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DauthProvider,
+  useDauth
+});
+//# sourceMappingURL=index.js.map