useEffect keep getting executed every time even dependency not changed

Question

We have UserContext which sets user object which we can use throughout application. Our UserContext keep executing every time and unnecessary making api call even though dependency hasn't changed.

    import React, { useState, useEffect } from 'react'
    import APIService from './utils/APIService';
    import { getCookies } from './utils/Helper';

    const UserContext = React.createContext();

    const UserContextProvider = (props) => {
        const [token, setToken] = useState(getCookies('UserToken'));
      const [user, setUser] = useState(null);
        
        useEffect(() => {
            console.log('Inside userContext calling as token ', token)
        fetchUserInfo();

        }, [token]);

        const fetchUserInfo = async() => {
            if (token) {
                let userRes = await APIService.get(`/user?token=${token}`);
                console.log('User route called')
                setUser(userRes.data);
            }      
        }

        /* 
            If user logoff or login, update token from child component
        */
      const refreshToken = (newToken) => {
            //token = newToken;
            setToken(newToken);
            fetchUserInfo()
      }

        return (
            <UserContext.Provider value={{user, token, refreshToken}}>
                {props.children}
            </UserContext.Provider>
        );
    }
    export { UserContextProvider,  UserContext }

Whenever we navigate to different page in our react app, we are seeing "User" route being called every time even though token isn't updated. Our token changes only when user log off.

Our AppRouter looks like following;

    import React from 'react';
    import AppRouter from "./AppRouter";
    import { Container } from 'react-bootstrap';
    import Header from './components/Header';
    import { ToastProvider, DefaultToastContainer } from 'react-toast-notifications';
    import 'bootstrap/dist/css/bootstrap.css';
    import './scss/styles.scss';

    import { UserContextProvider } from './UserContextProvider';

    export default function App() {
      const ToastContainer = (props) => (
        <DefaultToastContainer
          className="toast-container"
          style={{ zIndex:100,top:50 }}
          {...props}
        />
      );

      return (
        <UserContextProvider>
          <ToastProvider autoDismiss={true} autoDismissTimeout={3000} components={{ ToastContainer }}>
            <Container fluid>
              <Header />
              <AppRouter />
            </Container>
          </ToastProvider>
        </UserContextProvider>
      )
    }

This is our internal app so we want user to be logged in for 30 days and they don't have to keep login every time. So when user login first time, we create a token for them and keep that token in cookies. So if user close the browser and come back again, we check token in cookies. If token exists, we make API call to fetch user information and setUser in our context. This is the part which isn't working and it keep calling our user api during navigation to each route in application.

Here is our login.js

    import React, { useState, useContext } from 'react';
    import { setCookies } from '../../utils/Helper';
    import APIService from '../../utils/RestApiService';
    import { UserContext } from '../../UserContextProvider';
    import queryString from 'query-string';
    import './_login.scss';

    const Login = (props) => {
      const [email, setEmail] = useState(null);
      const [password, setPassword] = useState(null);
      const [error, setError] = useState(null);
      const { siteId } = props;
      const { refreshToken} = useContext(UserContext);

      const onKeyPress = (e) => {
        if (e.which === 13) {
          attemptLogin()
        }
      }

      let params = queryString.parse(props.location.search)
      let redirectTo = "/"
      if (params && params.redirect)
        redirectTo = params.redirect
      
      const attemptLogin = async () => {
        const payload = {
          email: email,
          password: password,
          siteid: siteId
        };
        let response = await APIService.post('/login', payload);
        console.log('response - ', response)
        if (response.status === 200) {
          const { data } = response;
          setCookies('UserToken', data.token);
          refreshToken(data.token)
          window.location.replace(redirectTo);
        }
        else {
          const { error } = response.data;
          setError(error);
        }
      }

      const renderErrors = () => {
        return (
          <div className="text-center login-error">
            {error}
          </div>
        )
      }


        return (
        <div className="login-parent">
          <div className="container">
            <div className="login-row row justify-content-center align-items-center">
              <div className="login-column">
                <div className="login-box">
                  <form className="login-form form">
                    <h3 className="login-form-header text-center">Login</h3>
                    <div className="form-group">
                      <label>Email:</label>
                      <br/>
                      <input
                        onChange={e => setEmail(e.target.value)}
                        placeholder="enter email address"
                        type="text"
                        onKeyPress={onKeyPress}
                        className="form-control"/>
                    </div>
                    <div className="form-group">
                      <label>Password:</label>
                      <br/>
                      <input
                        onChange={e => setPassword(e.target.value)}
                        placeholder="enter password"
                        type="password"
                        className="form-control"/>
                    </div>
                    <div className="form-group">
                      <button
                        className="btn btn-secondary btn-block"
                        onClick={attemptLogin}
                        type="button">
                        Login
                      </button>
                    </div>
                    {error ? renderErrors() : null}
                  </form>
                </div>
              </div>
            </div>
          </div>
        </div>
        )
    }

    export default Login;

Our userContext looks like below

    import React, { useState, useEffect } from 'react'
    import APIService from './utils/APIService';
    import { getCookies } from './utils/Helper';

    const UserContext = React.createContext();

    const UserContextProvider = (props) => {
        const [token, setToken] = useState(getCookies('UserToken'));
      const [user, setUser] = useState(null);
        useEffect(() => {
            if (!token) return;
            console.log('Inside userContext calling as token ', token)
        fetchUserInfo();

        }, [token]);

        const fetchUserInfo = async() => {
            if (token) {
                let userRes = await APIService.get(`/user?token=${token}`);
                console.log('User route called')
                setUser(userRes.data);
            }      
        }

        /* 
            If user logoff or login, update token from child component
        */
      const refreshToken = (newToken) => {
            //token = newToken;
            setToken(newToken);
            fetchUserInfo()
      }

        return (
            <UserContext.Provider value={{user, token, refreshToken}}>
                {props.children}
            </UserContext.Provider>
        );
    }
    export { UserContextProvider,  UserContext }

Our getCookies function which simply read cookies using universal-cookies package

    export const getCookies = (name) => {
      return cookies.get(name);
    };

Answer 1

So I tried to replicate your issue using a CodeSandbox, and these are my findings based on your code:

Context:

Your context has a useEffect which depend on token. When you call refreshToken, you update the token which automatically triggers the useEffect and makes a call to fetchUserInfo. So you don't need to call fetchUserInfo after setToken in refreshToken. Your context would look like:

const UserContext = React.createContext();

const UserContextProvider = (props) => {
  const [token, setToken] = useState(getCookies("UserToken"));
  const [user, setUser] = useState(null);

  useEffect(() => {
    console.log("Inside userContext calling as token ", token);
    fetchUserInfo();
  }, [token]);

  const fetchUserInfo = async () => {
    if (token) {
      let userRes = await APIService.get(`/user?token=${token}`);
      console.log('User route called')
      setUser(userRes.data);
    }
  };

  const refreshToken = (newToken) => {
    setToken(newToken);
  };

  return (
    <UserContext.Provider value={{ user, token, refreshToken }}>
      {props.children}
    </UserContext.Provider>
  );
};
export { UserContextProvider, UserContext };

Route:

Now coming to your routing, since you've not included code of AppRouter I had to make an assumption that you use react-router with Switch component. (As shown in CodeSandbox).

I see a line in your Login component which is window.location.replace(redirectTo);. When you do this, the entire page gets refreshed (reloaded?) and React triggers a re-render, which is why I suppose your context methods fire again.

Instead use the history API from react-router (Again, my assumption) like so,

let history = useHistory();
history.push(redirectTo);

Here's the sandbox if you want to play around: