Redux-Saga Login_REQUEST 문제입니다.

redux-saga 쪼개고 reducer 연결 하려고 하니 user reducer만 반응하고 LOG_IN_SUCCESS 는 반응을 하지 않습니다.
커뮤니티 게시판에서 여러가지를 확인해보고 해도 어디 부분이 잘못 된지 몰라 올려봅니다..

제가 작성한 코드는 이러합니다.

store/configureStore.js

import { applyMiddleware, createStore, compose } from "redux";
import createSagaMiddleware from "redux-saga";
import { createWrapper } from "next-redux-wrapper";
import { composeWithDevTools } from "redux-devtools-extension";
import reducer from "../reducers";
import rootSaga from "../sagas";


const configureStore = (context) => {
  console.log("context", context);
  const sagaMiddleware = createSagaMiddleware();
  const middlewares = [sagaMiddleware];

  const enhancer =
    process.env.NODE_ENV === "production"
      ? compose(applyMiddleware(...middlewares)) // 배포용
      : composeWithDevTools(applyMiddleware(...middlewares));
  

  const store = createStore(reducer, enhancer);


  store.sagaTask = sagaMiddleware.run(rootSaga);

  return store;
};

const wrapper = createWrapper(configureStore, {
  debug: process.env.NODE_ENV === "development",
});

export default wrapper;

reducers/index.js

import { HYDRATE } from "next-redux-wrapper"; // HYDRATE = action
import { combineReducers } from "redux";

import user from "./user";
import post from "./post";

const rootReducer = combineReducers({
  index: (state = {}, action) => {
    switch (action.type) {
      case HYDRATE:
        console.log("HYDRATE", action);
        return { ...state, ...action.payload };
      default:
        return state;
    }
  },
  user,
  post,
});

export default rootReducer;

reducers/user.js

export const initialState = {
  isLoggingIn: false, // 로그인 시도중
  isLoggedIn: false, // 로그인
  isLoggingOut: false, // 로그아웃 시도중
  meUser: null,
  signUpData: {},
  loginData: {},
};

export const LOG_IN_REQUEST = "LOG_IN_REQUEST";
export const LOG_IN_SUCCESS = "LOG_IN_SUCCESS";
export const LOG_IN_FAILURE = "LOG_IN_FAILURE";

export const LOG_OUT_REQUEST = "LOG_OUT_REQUEST";
export const LOG_OUT_SUCCESS = "LOG_OUT_SUCCESS";
export const LOG_OUT_FAILURE = "LOG_OUT_FAILURE";

export const loginRequestAction = (data) => ({
  type: LOG_IN_REQUEST,
  value: data,
});

export const logoutRequestAction = () => ({
  type: LOG_OUT_REQUEST,
});

const reducer = (state = initialState, action) => {
  // prettier-ignore
  switch(action.type) {
    case LOG_OUT_REQUEST : return {...state, isLoggingIn : true}; 
    case LOG_IN_SUCCESS :  return {...state, isLoggingIn : false, isLoggedIn:true, meUser:{...action.value, nickName:"Jay"}};
    case LOG_IN_FAILURE :  return {...state,  isLoggingIn : false, isLoggedIn:false };

    case "LOG_OUT_REQUEST" : return {...state,  isLoggingOut:true};
    case "LOG_OUT_SUCCESS" : return {...state,  isLoggingOut:false, isLoggedIn:true, meUser:null};
    case "LOG_OUT_FAILURE" : return {...state,  isLoggingOut:false};


    default: return state;
  }
};
export default reducer;

sagas/index.js

import { all, fork, call } from "redux-saga/effects";

import userSaga from "./user";



export default function* rootSaga() {
  yield all([fork(userSaga)]);
}

sagas/user.js

import { all, fork, put, delay, takeLatest } from "redux-saga/effects";
import {
  LOG_IN_FAILURE,
  LOG_IN_REQUEST,
  LOG_IN_SUCCESS,
} from "../reducers/user";



function* logIn(action) {
  try {
    console.log("saga logIn");
    // const result = yield call(logInAPI);
    yield delay(1000);
    yield put({
      type: LOG_IN_SUCCESS,
      value: action.value,
    });
  } catch (err) {
    console.error(err);
    yield put({
      type: LOG_IN_FAILURE,
      error: err.response.data,
    });
  }
}

function* watchLogIn() {
  yield takeLatest(LOG_IN_REQUEST, logIn);

}

function* watchLogOut() {
  yield takeLatest("LOG_OUT_REQUEST");
}

export default function* userSaga() {
  yield all([fork(watchLogIn), fork(watchLogOut)]);
}

function* logOut() {
  try {
    // const result = yield call(logOutAPI);
    yield delay(1000);
    yield put({
      type: LOG_OUT_SUCCESS,
    });
  } catch (err) {
    console.error(err);
    yield put({
      type: LOG_OUT_FAILURE,
      error: err.response.data,
    });
  }
}

function* watchLogIn() {
  console.log("확인");
  yield takeLatest(LOG_IN_REQUEST, logIn);
}

function* logIn(action) {
  try {
    console.log("saga logIn");
    // const result = yield call(logInAPI);
    yield delay(1000);
    yield put({
      type: LOG_IN_SUCCESS,
      value: action.value,
    });
  } catch (err) {
    console.error(err);
    yield put({
      type: LOG_IN_FAILURE,
      error: err.response.data,
    });
  }
}

import PropTypes from "prop-types";
import Head from "next/head"; 
import wrapper from "../store/configureStore";

const App = ({ Component }) => {
  return (
    <>
      <Head>
        <meta charSet="utf-8" />
        <title>NodeBird</title>
      </Head>
      <Component />
    </>
  );
};

App.propTypes = {
  Component: PropTypes.elementType.isRequired,
};


export default wrapper.withRedux(App);