aswi2022code-of-duty-gitlab/frontend/src/features/Auth/userSlice.ts @ b45d0300

import { createSlice } from '@reduxjs/toolkit'
import { persistReducer } from 'redux-persist'
import storage from 'redux-persist/lib/storage'
import {logIn, register} from './userThunks'

export interface UserState {
    accessToken?: string
    refreshToken?: string
    username: string
    roles: string[]
    isLoggingIn: boolean
    isLoggedIn: boolean
    lastErr?: string// consumable for errors during thunks
    isRegistered: boolean
}

const persistConfig = {
    key: 'auth',
    storage, // localStorage for browsers
}

// Default state when user first starts the application
const initialState: UserState = {
    roles: [],
    isLoggedIn: false,
    isLoggingIn: false,
    username: '',
    isRegistered: false,
}

export const userSlice = createSlice({
    name: 'user', // name to generate action types
    initialState, // default state
    // Reducers that update the state
    reducers: {
        logout: () => initialState, // Reset to the inital state
        refreshTokens: (state, action) => ({
            ...state,
            accessToken: action.payload.accessToken,
            refreshToken: action.payload.refreshToken,
        }),
        setErr: (state, action) => ({
            ...state,
            lastErr: action.payload,
        }),
        setUserState: (state, action) => ({ ...state, ...action.payload }),
        resetLoggingIn: (state) => ({ ...state, isLoggingIn: false }),
        resetIsRegistered: (state) => ({ ...state, isRegistered: false }),
    },

    // Thunks
    extraReducers: (builder) => {
        builder.addCase(logIn.fulfilled, (state, action) => {
            return { ...state, ...action.payload }
        })
        builder.addCase(logIn.rejected, (state, action) => {
            if (action.payload && typeof action.error.message === 'string') {
                return { ...state, lastErr: action.error.message }
            }
        })
        builder.addCase(logIn.pending, (state) => {
            return { ...state, isLoggingIn: true }
        })
        builder.addCase(register.fulfilled, (state, action) => {
            return {...state, isRegistered: true}
        })
    },
})

const userReducer = persistReducer(persistConfig, userSlice.reducer)

export const { logout, refreshTokens, setErr, setUserState, resetLoggingIn, resetIsRegistered } =
    userSlice.actions

export default userReducer