music-player/src/reducers/index.js

import {createStore, combineReducers, applyMiddleware} from 'redux';
import thunk from 'redux-thunk';
import createHistory from "history/createBrowserHistory";

export const history = createHistory()


const getGQL = url =>
    async (query, variables = {}) => {
        let obj = await fetch(url, {
            method: 'POST',
            headers: {
                "Content-Type": "application/json",
                Authorization: localStorage.authToken ? 'Bearer ' + localStorage.authToken : {},
            },
            body: JSON.stringify({ query, variables })
        })
        let a = await obj.json()
        if (!a.data && a.errors)
            throw new Error(JSON.stringify(a.errors))
        return a.data[Object.keys(a.data)[0]]
    }

export const backURL = 'http://player.asmer.fs.a-level.com.ua'

export const gql = getGQL(backURL + '/graphql');


const jwtDecode = token => {
    try {
        let arrToken = token.split('.')
        let base64Token = atob(arrToken[1])
        return JSON.parse(base64Token)
    }
    catch (e) {
        console.log('Лажа, Бро ' + e);
    }
}

function authReducer(state, { type, token }) {
    if (!state) {
        if (localStorage.authToken) {
            type = 'AUTH_LOGIN'
            token = localStorage.authToken
        } else state = {}
    }
    if (type === 'AUTH_LOGIN') {
        localStorage.setItem('authToken', token)
        let payload = jwtDecode(token)
        if (typeof payload === 'object') {
            return {
                ...state,
                token,
                payload
            }
        } else return state
    }
    if (type === 'AUTH_LOGOUT') {
        localStorage.removeItem('authToken')
        return {}
    }
    return state
}

const actionLogin = (login, password) => {
    return actionPromise(
        "login",
        gql(
            `query log($login:String!, $password:String!) {
    login(login:$login, password:$password)
    }`,
            {login, password }
        )
    );
};

function promiseReducer(state = {}, { type, status, payload, error, name }) {
    if (type === 'PROMISE') {
        return {
            ...state,
            [name]: { status, payload, error }
        }
    }
    return state;
}


const actionAuthLogin = token => ({ type: 'AUTH_LOGIN', token })
export const actionAuthLogout = () => ({ type: 'AUTH_LOGOUT' })
export const actionFullLogin = (login, password) =>
    async function i(dispatch) {
        let token = await dispatch(actionLogin(login, password));
        if (token) {
            dispatch(actionAuthLogin(token));
        }
    }



const actionPending = name => ({ type: 'PROMISE', status: 'PENDING', name })
const actionResolved = (name, payload) => ({ type: 'PROMISE', status: 'RESOLVED', name, payload })
const actionRejected = (name, error) => ({ type: 'PROMISE', status: 'REJECTED', name, error })
export const actionPromise = (name, promise) =>
    async dispatch => {
        dispatch(actionPending(name))
        try {
            let data = await promise
            dispatch(actionResolved(name, data))
            return data
        }
        catch (error) {
            dispatch(actionRejected(name, error))
        }
    }



export const actionFullReg = (login, password) =>
    async function a(dispatch) {
        try {
            await dispatch(actionReg(login, password));
        } catch (e) {
            return 0;
        }
        await dispatch(actionFullLogin(login, password));
    }

const actionReg = (login, password) => {
    return actionPromise(
        "reg",
        gql(
            `mutation reg($l: String!, $p: String!){
        createUser(login: $l, password:$p){
          _id login
        }
      }`,
            { l: login, p: password }
        )
    );
};


const store = createStore(combineReducers({promise: promiseReducer,
        auth: authReducer,}),
        applyMiddleware(thunk))

store.subscribe(() => console.log(store.getState()))

export default store