vuejs-jsonapi/proxy.js

A simple proxy to consume JSONAPI endpoints with VueJS

var Vue = require('vue') 
var VueResource = require('vue-resource') 
var Auth = require('jwt-basic-auth')  
 
Vue.use(VueResource) 
 
var exports = module.exports = {} 
 
function deserialize (payload) { 
  return new Promise( 
    function (resolve, reject) { 
      var JSONAPIDeserializer = require('jsonapi-serializer').Deserializer 
      new JSONAPIDeserializer().deserialize(payload.body, function (err, resources) { 
        if (err !== null) { 
          reject(err) 
        } else { 
          var response = {} 
          response.meta = payload.body.meta 
          response.status = payload.status 
          response.data = resources 
          resolve(response) 
        } 
      }) 
    } 
  ) 
} 
 
function parseError (payload) { 
  var response = {} 
  response.status = payload.status 
  response.errors = payload.body.errors 
  return response 
} 
 
function headers () { 
  return { 
    headers: { 
      'Content-Type': 'application/vnd.api+json', 
      'Accept': 'application/vnd.api+json', 
      'Authorization': 'Bearer ' + Auth.getToken() 
    } 
  } 
} 
 
exports.createRessource = function (endpoint, resource) { 
  delete resource.data.id 
  return new Promise( 
    function (resolve, reject) { 
      Vue.http.post(endpoint, resource, headers()).then((payload) => { 
        deserialize(payload).then((parsed) => { 
          switch (parsed.status) { 
            case 201: 
              resolve(parsed) 
              break 
            default: 
              reject(parseError(payload)) 
              break 
          } 
        }) 
      }, (payload) => { 
        // error callback 
        if (payload.status === 401) { 
          Auth.logout() 
          window.location.reload(true) 
        } 
        reject(parseError(payload)) 
      }) 
    } 
  ) 
} 
 
exports.createRelationship = function (endpoint, resource) { 
  return new Promise( 
    function (resolve, reject) { 
      Vue.http.post(endpoint, resource, headers()).then((payload) => { 
        switch (payload.status) { 
          case 204: 
            resolve(payload) 
            break 
          default: 
            reject(parseError(payload)) 
            break 
        } 
      }, (payload) => { 
        // error callback 
        if (payload.status === 401) { 
          Auth.logout() 
          window.location.reload(true) 
        } 
        reject(parseError(payload)) 
      }) 
    } 
  ) 
} 
 
exports.pushRessource = function (endpoint, resource) { 
  return new Promise( 
    function (resolve, reject) { 
      Vue.http.patch(endpoint, resource, headers()).then((payload) => { 
        deserialize(payload).then((parsed) => { 
          resolve(parsed) 
        }) 
      }, (payload) => { 
        // error callback 
        if (payload.status === 401) { 
          Auth.logout() 
          window.location.reload(true) 
        } 
        var error = parseError(payload) 
        reject(error) 
      }) 
    } 
  ) 
} 
 
exports.pullRessources = function (endpoint) { 
  return new Promise( 
    function (resolve, reject) { 
      Vue.http.get(endpoint, headers()).then((payload) => { 
        deserialize(payload).then((parsed) => { 
          resolve(parsed) 
        }) 
      }, (payload) => { 
        // error callback 
        if (payload.status === 401) { 
          Auth.logout() 
          window.location.reload(true) 
        } 
        var error = parseError(payload) 
        reject(error) 
      }) 
    } 
  ) 
} 
 
exports.deleteRessources = function (endpoint) { 
  return new Promise( 
    function (resolve, reject) { 
      Vue.http.delete(endpoint, headers()).then((payload) => { 
        resolve() 
      }, (payload) => { 
        // error callback 
        if (payload.status === 401) { 
          Auth.logout() 
          window.location.reload(true) 
        } 
        var error = parseError(payload) 
        reject(error) 
      }) 
    } 
  ) 
}