yarn-api-behavior.html

<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="../yarn-endpoints-behavior/yarn-endpoints-behavior.html">
<link rel="import" href="../promise-polyfill/promise-polyfill-lite.html">
<link rel="import" href="../iron-ajax/iron-ajax.html">

<script>
var YarnBehaviors = YarnBehaviors || {};

(function() {

APIBehaviorImpl = {
  
  properties: {
    endpoints: {
      type: Object,
      observer: '_onEndpointsChange'
    },
    defaultHost: {
      type: String,
      value: 'localhost:3000'
    },
    defaultProtocol: {
      type: String,
      value: 'http'
    },
    headers: {
      type: Object,
      observer: '_onHeadersChange'
    },
    simLatency: {
      type: Boolean,
      value: true
    },
    _body: {
      type: Object,
      observer: '_onBodyChange'
    },
    _withCredentials: {
      type: Boolean,
      value: false,
      observer: '_onWithCredentialsChange'
    },
    _handleAs: {
      type: String,
      observer: '_onHandleAsChange'
    },
    _defaultHandleAs: {
      type: String,
      value: 'json'
    },
    _method: {
      type: String,
      observer: '_onMethodChange'
    }
  },
  
  created: function() {
    
    this.ajax = document.createElement("iron-ajax");
    this.ajax.set('handleAs', this._defaultHandleAs);
    this.ajax.set('contentType', "application/json");
    this.addEventListener('url-changed', this._onUrlChange);
  },
  
  _onEndpointsChange: function() {
    this._makeApi();
  },
  
  _onProtocolChange: function(newVal, oldVal) {
    this.ajax.set('protocol', newVal);
  },
  
  _onHostChange: function(newVal, oldVal) {
    this.ajax.set('host', newVal);
  },
  
  _onUrlChange: function(e) {
    this.ajax.set('url', e.detail.value);
  },
  
  _onBodyChange: function(newVal) {
    this.ajax.set('body', newVal);
  },
  
  _onHandleAsChange: function(newVal) {
    this.ajax.set('handleAs', newVal);
  },
  
  _onMethodChange: function(newVal) {
    this.ajax.set('method', newVal);
  },
  
  _onHeadersChange: function(newVal) {
    this.ajax.set('headers', newVal);
  },
  
  _onWithCredentialsChange: function(newVal) {
    this.ajax.set('withCredentials', newVal);
  },
  
  _makeApi: function() {
    var self = this;
    Object.keys(this.endpoints).forEach(function(endpoint) {
      var method = self.endpoints[endpoint].method;
      
      switch(method) {
        case 'GET':
          // Creating a function on the element that matches the endpoint's name
          self[endpoint] = function(params, cb) {
            
            if(self.apiPreRequestHook) {
              self.apiPreRequestHook(null, params, cb);
            }
            
            if(typeof params === 'function') {
              
              cb = params;
              params = null;
            }
            
            self.set('_body', null);
            
            if(params) {
              self.set('params', params);
            } else {
              self.set('params', {});
            }
            
            setEndpointVars(endpoint);
            
            return generateAndHandleRequest(cb);
            
          }
          break;
        case 'POST':
        case 'PUT':
        case 'DELETE':
          // Creating a function on the element that matches the endpoint's name
          self[endpoint] = function(body, params, cb) {
            
            if(typeof body != 'object') {
              throw new Error('Your call for "' + endpoint + '" needs a body, and it needs to be an object!');
            }
            
            if(typeof params === 'function') {
              cb = params;
              params = null;
            }
            
            if(self.apiPreRequestHook) {
              self.apiPreRequestHook(body, params, cb);
            }
            
            self.set('_body', body);
            
            if(params) {
              self.set('params', params);
            } else {
              self.set('params', {});
            }
            
            setEndpointVars(endpoint);
            
            return generateAndHandleRequest(cb);
            
          }
          break;
      }
      
      function setEndpointVars(endpoint) {
        
        self.set('_method', self.endpoints[endpoint].method);
        if(self.endpoints[endpoint].host) {
          self.set('host', self.endpoints[endpoint].host);
        } else {
          self.set('host', self.defaultHost);
        }
        if(self.endpoints[endpoint].headers) {
          self.set('headers', self.endpoints[endpoint].headers);
        }
        if(self.endpoints[endpoint].protocol) {
          self.set('protocol', self.endpoints[endpoint].protocol);
        } else {
          self.set('protocol', self.defaultProtocol);
        }
        if(self.endpoints[endpoint].handleAs) {
          self.set('_handleAs', self.endpoints[endpoint].handleAs);
        } else {
          self.set('_handleAs', self._defaultHandleAs);
        }
        if(self.endpoints[endpoint].withCredentials) {
          self.set('_withCredentials', self.endpoints[endpoint].withCredentials);
          var tmp = {};
          if(self.headers) {
            tmp = self.headers;
          }
          tmp['Access-Control-Allow-Credentials'] = true;
          self.set('headers', tmp);
        } else {
          self.set('_withCredentials', false);
        }
        
        self.set('endpoint', endpoint);
      }
      
      function generateAndHandleRequest(cb) {
        var apiResponseHook = self.apiResponseHook;
        
        if(typeof cb == 'function') {
          
          self.ajax.generateRequest().completes.then(function(request) {
            
            if(request.xhr.status >= 400 && request.xhr.status < 600) {
              self.fire('api-error', {api: self, request:request});
            }
            
            if(apiResponseHook) {
              apiResponseHook(null, request, cb, function() {
                cb(null, request);
              });
            } else {
              cb(null, request);
            }
            
          })
          .catch(function(reason) {
            
            if(apiResponseHook) {
              apiResponseHook(reason, null, cb, function() {
                cb(reason, null);
              });
            } else {
              cb(reason, null);
            }
          });
          
        } else {
          
          var promiseResolve;
          var promiseReject;
          var ajaxRequest;
          
          return new Promise(function(resolve, reject) {
            
            promiseResolve = resolve;
            promiseReject = reject;
            
            self.ajax.generateRequest().completes.then(function(request) {
              if(request.xhr.status >= 400 && request.xhr.status < 600) {
                self.fire('api-error', {api: self, request:request});
              }
              
              callResponseHookIfExists(null, request);
              
            })
            .catch(function(reason) {
              
              callResponseHookIfExists(reason, null);
              
            })
            
          })
          
          function callResponseHookIfExists(err, request) {
            if(apiResponseHook) {
              var promiseResolveReject = {resolve: promiseResolve, reject: promiseReject};
              apiResponseHook(err, request, promiseResolveReject, function() {
                if(err) {
                  promiseReject(err);
                } else {
                  promiseResolve(request);
                }
              });
            } else {
              if(err) {
                promiseReject(err);
              } else {
                promiseResolve(request);
              }
            }
          }
          
        }
        
        self.set('headers', {});
        
      }
      
      if(!self.host) {
        self.host = self.defaultHost;
      }
      
      // Simulate latency if this.simLatency && host contains 'localhost'
      // monkeypatch
      if(self.simLatency && self.host.indexOf("localhost") !== -1) {
        
        var currentFunc = self[endpoint];
        
        // The length of a function is the number of expected arguments
        if(currentFunc.length === 2) {
          
          self[endpoint] = function(params, cb) {
            
            return new Promise(function(resolve, reject) {
              self.async(function() {
                resolve(currentFunc(params, cb));
              }, 300)
            });
            
          }
        } else if(currentFunc.length === 3) {
          
          self[endpoint] = function(body, params, cb) {
            
            return new Promise(function(resolve, reject) {
              self.async(function() {
                resolve(currentFunc(body, params, cb));
              }, 300)
            });
          }
        }
      }
    });
  }
};

YarnBehaviors.APIBehavior = [YarnBehaviors.EndpointsBehavior, APIBehaviorImpl];

})()
</script>