devegram-vuex-ajax-manager/src/minified.js

Devegram Vuex Ajax Manager is package for managing ajax requests via a scalable simple structure, it handles different outgoing sources, auth token, api version, and more.

import axios from 'axios';

export const dispatch = (ctx, api, success = null, error = null) => {
  if (!api.hasOwnProperty('service')) api.service = ctx.state.service
  return new Promise((resolve, reject) => {
      ctx.dispatch('ajaxManager/api', api, { root: true }).then(r => {
        if (typeof success === 'function')
          resolve(success(r, ctx))
        else
          resolve(r);
      }).catch(e => {
        if (typeof error === 'function')
          reject(error(e, ctx))
        else
         reject(e);
      });
  })
}

export const ajax = (api, success = null, error = null) => {
  return new Promise((resolve, reject) => {
    $store.dispatch('ajaxManager/api', api, { root: true }).then(r => {
      if (typeof success === 'function')
        resolve(success(r))
      else
        resolve(r);
    }).catch(e => {
      if (typeof error === 'function')
        reject(error(e))
      else
        reject(e);
    });
  })
}

const ajaxManager = {
  namespaced: true,
  state: {
    token: null,
    services: {
      github: {
        url: 'https://github.com',
        port: '',
        apiVer: '',
        token: ''
      }
    },
    defaultHeaders: {
      'accept': 'application/json',
      'content-type': 'application/json'
    },
    loadingRequests: 0,
    debug: false,
    errorHandler: (error, reject, params) => {
      if (ajaxManager.debug) console.log('ajax manager Error Handler', error)
      if (!error.response) return

      //let errorCode = error.response.status
      let data = error.response.data
      if (data && data.hasOwnProperty('@alert')) {
        let alert = data['@alert']
        $services['alert'][alert.type](alert.title, alert.text)
      }

      if (data && data.message) $services['toast']['danger'](data.message)

      if (data && data.hasOwnProperty('@toast')) {
        let toast = data['@toast']
        $services['toast'][toast.type](toast.title)
      }

      if (params.hasOwnProperty('onError')) {
        params.onError(error, params)
      } else {
        reject(error);
      }
    },
    successHandler: null,
    finallyHandler: null,
  },
  mutations: {
    SET_SERVICE (state, services) {
      if (services.constructor !== Array) {
        services = [services]
      }

      services.forEach((service) => {
        let c = service.config
        state.services[service.name] = {...c}
        state.services[service.name].path = c.url + (c.port? ':' + c.port : '') + (c.apiVer? '/' + c.apiVer : '')
      })
    },
    SET_ERROR_HANDLER (state, func) {
      state.errorHandler = func
    },
    SET_SUCCESS_HANDLER (state, func) {
      state.successHandler = func
    },
    SET_FINALLY_HANDLER (state, func) {
      state.finallyHandler = func
    },
    SET_DEBUG (state, status) {
      state.debug = status
    },
    SET_TOKEN (state, params) {
      state.token = params.token
      localStorage.setItem('ajax_manager_token', params.token)
    },
    LOADER_INCREMENT (state, params) {
      state.loadingRequests++;
    },
    LOADER_DECREMENT (state, params) {
      state.loadingRequests--;
    },
    SET_DEFAULT_HEADERS (state, headers) {
      state.defaultHeaders = headers
    }
  },
  actions: {
    setService ({ commit }, params) {
      commit('SET_SERVICE', params)
    },
    setErrorHandler ({ commit }, func) {
      commit('SET_ERROR_HANDLER', func)
    },
    setSuccessHandler ({ commit }, func) {
      commit('SET_SUCCESS_HANDLER', func)
    },
    setFinallyHandler ({ commit }, func) {
      commit('SET_FINALLY_HANDLER', func)
    },
    setDebug ({ commit }, status) {
      commit('SET_DEBUG', status)
    },
    setToken ({ commit }, params) {
      commit('SET_TOKEN', params)
    },
    loaderIncrement ({ commit }, params) {
      commit('LOADER_INCREMENT', params)
    },
    loaderDecrement ({ commit }, params) {
      commit('LOADER_DECREMENT', params)
    },
    setDefaultHeaders ({ commit }, headers) {
      commit('SET_DEFAULT_HEADERS', headers)
    },
    api ({state, dispatch}, params) {

      let url = params.url
      let headers = params.headers || {};
      let service = false

      if (state.services.hasOwnProperty(params.service)) {
        service = state.services[params.service];
        url = service.path + url
      }

      if (!params.hasOwnProperty('noDefaultHeaders')) {
        headers = {
          ...headers,
          ...state.defaultHeaders
        }
      }

      if (!params.hasOwnProperty('noToken') && !params.hasOwnProperty('noService')) {
        let token = null
        if (params.token) {
          token = params.token
        } else if (service.token) {
          token = params.token
        } else {
          token = state.token
          if (!token) {
            token = localStorage.getItem('ajax_manager_token')
            state.token = token
          }
        }

        headers.Authorization = 'Bearer ' + token
      }

      let crossDomain = true
      if (params.hasOwnProperty('crossDomain')) {
        crossDomain = params.crossDomain
      }

      let timeout = 300000
      if (params.hasOwnProperty('timeout')) {
        timeout = params.timeout
      }

      const request = {
        method: params.verb,
        url,
        data: params.data,
        headers: headers,
        crossDomain: crossDomain,
        timeout: timeout
      }

      if (params.responseType) {
        request.responseType = params.responseType;
      }


      let isThereloadingScreenProp = params.hasOwnProperty('noLoadingScreen')
      if (!isThereloadingScreenProp) params.noLoadingScreen = true


      let loadingScreenPropValue = !params.noLoadingScreen

      if (loadingScreenPropValue) {
        dispatch('loaderIncrement');
      }

      return new Promise((resolve, reject) => {
        axios(request).then(response => {
          if (typeof state.successHandler === 'function') state.successHandler(response, params)
          resolve(response);
        }, error => {
          state.errorHandler(error, reject, params)
        }).finally(() => {
          if (loadingScreenPropValue) {
            dispatch('loaderDecrement')
          }
        })
      })
    }
  }
}
export default ajaxManager