问错误:操作必须是纯对象，请对异步操作使用自定义中间件

EN

import React from 'react';
import ReactDOM from 'react-dom';
import { createStore, applyMiddleware } from 'redux';
import { Provider } from 'react-redux';
import { createLogger } from 'redux-logger';
import Thunk from 'redux-thunk';
import reducer from './reducers/reducer';
import App from './App';

import './css/index.css';
import './css/font-awesome.css';
import './css/bulma.css';

const logger = createLogger();
const store = createStore(reducer, applyMiddleware(Thunk, logger));

ReactDOM.render(
  <Provider store={store}>
    <App />
  </Provider>, document.getElementById('root'));

import React, { Component } from 'react';
import { connect } from 'react-redux';
import { searchRepositories } from '../actions/searchActions';

class Results extends Component {

  componentDidMount() {
    this.props.searchRepositories();
  }

  render() {
    return (
      <div>Some Stuff</div>
    );
  }
}

const mapDispatchToProps = (dispatch) => {
  return {
    searchRepositories: () => {
      dispatch(searchRepositories());
    },
  };
};

const mapStateToProps = (state) => {
  return {
    repositories: state.repositories,
  };
};


export default connect(mapStateToProps, mapDispatchToProps)(Results);

import * as types from '../actions/types';
import initialState from './INITIAL_STATE';


function reducer(prevState = initialState, action) {
  if (!action) return prevState;

  switch (action.type) {
    case types.FETCH_REPOS_REQUEST:
      return { ...prevState, loading: true };

    case types.FETCH_REPOS_SUCCESS:
      return {
        ...prevState,
        loading: false,
        repositories: action.data,
        error: '',
      };

    case types.FETCH_REPOS_ERROR:
      return { ...prevState, error: 'Encountered an error during GET request' };

    default:
      return prevState;
  }
}

export default reducer;

import axios from 'axios';
import * as types from './types';
import { ROOT } from '../config';


export function searchRepositoriesRequest() {
  return {
    type: types.FETCH_REPOS_REQUEST,
  };
}

export function searchRepositoriesSuccess(repositories) {
  return {
    type: types.FETCH_REPOS_SUCCESS,
    data: repositories,
  };
}

export function searchRepositoriesError(error) {
  return {
    type: types.FETCH_REPOS_ERROR,
    data: error,
  };
}

export function searchRepositories() {
  return function (dispatch) {
    dispatch(searchRepositoriesRequest());
    return axios.get(`${ROOT}topic:ruby+topic:rails`).then((res) => {
      dispatch(searchRepositoriesSuccess(res.data));
    }).catch((err) => {
      dispatch(searchRepositoriesError(err));
    });
  };
}