How to use the universal-cookie function in universal-cookie

import Cookies from 'universal-cookie';
import newHttpError from '../util/newHttpError';
import caches from '../util/caches';

// Use cookie to store JWT's login token
const cookies = new Cookies();

const auth = {

    authorize: async () => {

        const login_token = cookies.get('login_token');

        if(!login_token)
            throw new Error('Login_Token_Not_Defined');

        return {
            httpOptions: {
                headers: {Authorization: `Bearer ${login_token}`}
            }
        };
    },

require('es6-promise').polyfill()
require('isomorphic-fetch')

import Cookies from 'universal-cookie'

export const RECEIVE_QUESTION    = 'RECEIVE_QUESTION'
export const REQUEST_QUESTION    = 'REQUEST_QUESTION'

const cookies = new Cookies();

function headers(set_cookie=false) {
  let headers = {
        'Accept':       'application/json',
        'Content-Type': 'application/json',
        'X-CSRF-Token': $('meta[name="csrf-token"]').attr('content')
      }
  if (set_cookie){
    headers['Authorization'] = "Bearer " + cookies.get('remember_user_token')
  }
  return headers;
}

function requestTest(test_id) {
  return {
    type: REQUEST_POSTS,

break;
            }
            case 'clientUpdateMediaShuffle': {
                const { shuffle } = update;

                this.shuffle = shuffle;

                this.emit(update['@type'], update);
                break;
            }
            case 'clientUpdateMediaPlaybackRate': {
                const { playbackRate } = update;

                this.playbackRate = playbackRate;

                const cookies = new Cookies();
                cookies.set('playbackRate', playbackRate);

                this.emit(update['@type'], update);
                break;
            }
            case 'clientUpdateMediaPlay': {
                this.playing = true;

                this.emit(update['@type'], update);
                break;
            }
            case 'clientUpdateMediaTitleMouseOver': {
                this.emit(update['@type'], update);
                break;
            }
            case 'clientUpdateMediaPause': {

export default function render(req, res) {
  const cookies = new Cookies(req.headers.cookie)
  const history = createMemoryHistory()
  const token = cookies.get('token') || null
  const styleMode = cookies.get('styleMode') || 'day-mode'
  const store = configureStore({
    auth:fromJS({
      token: token,
      user: null
    }),
    globalVal:fromJS({
      styleMode: styleMode,
      captchaUrl: API_ROOT + 'users/getCaptcha?'
    })
  }, history)
  const batch = matchRoutes(routes, req.url)
  return fetchAllData(batch, store.dispatch, token).then(function(data){
    const context = {}

app.use((req, res, next) => {
  req.cookies = new Cookies(req.headers.cookie);
  next();
});
app.use(bodyParser.urlencoded({ extended: true }));

import { handleActions } from 'redux-actions';
import actionTypes from '../actionTypes';

import Cookies from 'universal-cookie';

const cookies = new Cookies();

const defaultState = {
  userName: '',
  email: '',
  uuid: '',
  accessToken: '',
  isAdmin: false,
  apiKeys: {},
  userSkills: [],
};

const { emailId, uuid, loggedIn, username } = cookies.getAll();

const cookiesAppValues = {
  email: emailId,
  uuid,

return function(ctx, next) {
    ctx.request.universalCookies = new Cookies(
      ctx.request.headers.cookie || '',
      {
        onSet(name, value, options) {
          ctx.cookies.set(name, value, options);
        },
        onRemove(name) {
          ctx.cookies.set(name, null);
        }
      }
    );
    return next();
  };
}

export function getWebToken(request) {
    if (request) {
        return new Cookies(request.headers.cookie).get(IC_WEB_TOKEN)
    } else if (ExecutionEnvironment.canUseDOM) {
        return new Cookies().get(IC_WEB_TOKEN)
    }

    return undefined;

}

function checkAuth() {
    let codalab_session = new Cookies().get('codalab_session');
    return codalab_session !== undefined;
}

import CheckIcon from '@material-ui/icons/Check';
import ClearIcon from '@material-ui/icons/Clear';
import dataProvider from '../dataProvider';
import PaginationButton from '../components/PaginationButton';
import FilterField from '../components/FilterField';
import TAIField from '../components/TAIField';
import UrlField from '../components/URLField';
import MapTags from '../components/TagsField';
import JsonIcon from '../components/JsonIcon';
import SenderTransportParamsCardsGrid from '../components/SenderTransportParams';
import ConnectionShowActions from '../components/ConnectionShowActions';
import ConnectionEditActions from '../components/ConnectionEditActions';
import JSONViewer from '../components/JSONViewer';
import ItemArrayField from '../components/ItemArrayField';

const cookies = new Cookies();

export const SendersList = () => {
    const firstLoad = async () => {
        const params = {
            filter: {},
        };
        const dataObject = await dataProvider('GET_LIST', 'senders', params);
        setData(dataObject);
    };

    const [data, setData] = useState(firstLoad);

    const nextPage = async label => {
        const dataObject = await dataProvider(label, 'senders');
        setData(dataObject);
    };