Hak 38 switch to superagent

lib/deep-filter.js

@@ -56,10 +56,6 @@ function resolveReferencesFilters(fortuneClient, req, resource, options) {
 
   var resourceSchema = resources[currentResource].schema;
   return when.all(_.map(filter, function(query, path) {
-    console.log('requesting subfilter',
-      isExternalLink(path, resourceSchema),
-      _.isObject(query)
-    );
     if (isExternalLink(path, resourceSchema) && _.isObject(query) && !isValidQueryKey(query)) {
       var resourceRoute = indexResources(fortuneClient.resources, 'name')[getLinkedRouteName(resourceSchema, path)].route;
       return requestSubresource(fortuneClient, resourceRoute, query, req.user)

lib/denormalize.js

@@ -4,7 +4,8 @@ var _ = require('lodash');
 function getLinkedResources(primaryName, linkName, body){
   var path = primaryName + '.' + linkName;
   var type = body.links[path] && body.links[path].type;
-  return type && body.linked && body.linked[type];
+  var concat = body[type] || [];
+  return (type && body.linked && body.linked[type] || []).concat(concat);
 }
 
 function rebaseLinks(links, top, next){

lib/fortune-client.js

@@ -1,25 +1,21 @@
 var when = require("when"),
-  requesto = require("requesto"),
-  request = require("request"),
+  superagent = require("superagent"),
   resourceLinker = require("./resource-linker"),
   deepFilter = require('./deep-filter'),
-  crypto = require("crypto"),
   _ = require("lodash"),
+  normalizeFilterMiddleware = require('./normalize-filter').Middleware,
+  oauthMiddleware = require('./oauth-middleware').Middleware,
   remoteAdapter = require("./remote-adapter"),
   utils = require("./util");
 
 module.exports = function(apps, options){
   options = options || {};
   var self = {
     resources: [],
-    id: crypto.createHash("md5")
-      .update(process.pid.toString())
-      .update(new Date().getTime().toString())
-      .update(_.uniqueId())
-      .digest("hex"),
+    id: (process && process.pid && process.pid.toString() || '' ) + _.uniqueId(),
     onRequest: null,
     onResponse: null,
-    utils: utils,
+    utils: utils
   };
 
   self.ready = initApps();
@@ -48,31 +44,63 @@ module.exports = function(apps, options){
           url: app.url + '/resources',
           oauth: {
             consumer_key: app.oauth.consumer_key,
-            consumer_secret: app.oauth.consumer_secret,
+            consumer_secret: app.oauth.consumer_secret
           }
+        };
+
+        function getResources(){
+          return when.promise(function(resolve){
+          superagent
+            .get(request.url)
+            .use(normalizeFilterMiddleware())
+            .use(oauthMiddleware(request.oauth, {}))
+            .end(function(err, response){
+              if (err) {
+                //retry in a second
+                return setTimeout(function(){
+                  resolve(getResources());
+                }, 1000);
+              }
+              try {
+                resources = JSON.parse(response.text).resources;
+
+                router.registerResources(remoteAdapter(app), resources);
+                self.changeHeader = remoteAdapter.changeHeader;
+                self.deleteHeader = remoteAdapter.deleteHeader;
+                self.resources = _.union(self.resources, resources);
+                resolve();
+              }catch(e){
+                console.error(e);
+                setTimeout(function() {
+                  resolve(getResources());
+                }, 1000);
+              }
+            });
+          });
         }
-        return requesto.get(request).then(function(data){
-          resources = JSON.parse(data.body).resources;
 
-          router.registerResources(remoteAdapter(app), resources);
-          self.changeHeader = remoteAdapter.changeHeader;
-          self.deleteHeader = remoteAdapter.deleteHeader;
-          return self.resources = _.union(self.resources, resources);
-        });
-      } else if(_.isString(app)){
-        return requesto.get(app + "/resources").then(function(data){
-          resources = JSON.parse(data.body).resources;
+        return getResources();
 
+      } else if(_.isString(app)){
+        var deferred = when.defer();
+        superagent.get(app + "/resources").end(function(err, data) {
+          if (err) return deferred.reject(err);
+          resources = JSON.parse(data.text).resources;
           router.registerResources(remoteAdapter(app), resources);
 
-          return self.resources = _.union(self.resources, resources);
+          self.resources = _.union(self.resources, resources);
+          deferred.resolve(self.resources);
         });
+        return deferred.promise;
       }else{
         throw new Error("App must be a function or an object, got " + typeof app);
       }
     })).then(function(){
       return _.extend(self,router.actions);
-    }).catch(function(err){ console.trace(err); });
+    }).catch(function(err){
+      console.trace(err);
+      throw err;
+    });
   }
 
   return self;

lib/logger.js

@@ -0,0 +1,18 @@
+'use strict';
+var superagent = require('superagent');
+var mv = require('./normalize-filter').Middleware();
+var oauth  =require('./oauth-middleware').Middleware({});
+
+superagent.get('http://localhost:3012/status/')
+  .query({
+    filter: {
+      a: 'b'
+    },
+    include: 'blah'
+  })
+  .use(mv)
+  .use(oauth)
+  .end(function(err, res) {
+    if (err) throw err;
+    console.log(res.statusCode);
+  });

lib/normalize-filter.js

@@ -0,0 +1,34 @@
+'use strict';
+var _ = require('lodash');
+var qs =  require('qs');
+
+exports.Middleware = function(){
+
+  return function(req){
+    if (req.qs && req.qs.filter && _.isObject(req.qs.filter)){
+      exports.normalize(req.qs);
+    }
+    return req;
+  };
+};
+
+exports.normalize = function(qsObject){
+  if (qsObject && qsObject.filter && _.isObject(qsObject.filter)) {
+    var filter = qsObject.filter;
+    delete qsObject.filter;
+    //No need to send it if empty
+    if (_.isEmpty(filter)) return qsObject;
+
+    var formatted = qs.stringify({filter: filter}, {encode: false, arrayFormat: 'indices'});
+    var pairs = formatted.split('&').map(function (pair) {
+      return pair.split('=');
+    }).reduce(function (memo, pair) {
+      memo[pair[0]] = pair[1];
+      return memo;
+    }, {});
+    _.extend(qsObject, pairs);
+    return qsObject;
+  }else{
+    return qsObject;
+  }
+};

lib/oauth-middleware.js

@@ -0,0 +1,89 @@
+'use strict';
+var _ = require('lodash');
+var Crypto = require('cryptojs').Crypto;
+if (!Crypto && window) Crypto = window.Crypto;
+
+var normalize = require('./normalize-filter').normalize;
+
+function encode(str){
+  return encodeURIComponent(str)
+    .replace(/[!'()]/g, escape)
+    .replace(/\*/g, "%2A");
+}
+
+function createBaseString(config, generated){
+  var params = {
+    /* jshint camelcase: false */
+    oauth_nonce: generated.nonce,
+    oauth_consumer_key: generated.appToken,
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: generated.timestamp,
+    oauth_token: "",
+    oauth_version: "1.0"
+  };
+  var encodedParams = {};
+  if (config.method === "GET"){
+    params = _.extend(params, config.qs);
+  }
+  _.each(params, function(v, k){
+    encodedParams[encode(k)] = encode(v);
+  });
+  var sortedKeys = _.keys(encodedParams).sort();
+  var baseParams = _.map(sortedKeys, function(k){
+    return k + "=" + encodedParams[k];
+  });
+  var baseParamsString = baseParams.join("&");
+  var baseUrl = config.url;
+  var baseString = config.method.toUpperCase() + "&" + encode(baseUrl) + "&" + encode(baseParamsString);
+  return baseString;
+}
+
+function buildSignature(httpConfig, params){
+  var signingKey = encode(params.appSecret) + "&";
+  var baseString = createBaseString(httpConfig, params);
+  return Crypto.util.bytesToBase64(Crypto.HMAC(Crypto.SHA1, baseString, signingKey, {asBytes: true}));
+}
+
+exports.Middleware = function(oauth, query){
+  oauth = oauth || {};
+
+  return function(req){
+
+    var signatureData = {
+      nonce: exports.getNonce(),
+      timestamp: exports.getTimestamp()
+    };
+    signatureData.appToken = oauth.consumer_key;
+    signatureData.appSecret = oauth.consumer_secret;
+
+    req.header.Authorization = "OAuth " + _.map({
+        oauth_consumer_key: signatureData.appToken,
+        oauth_token: "",
+        oauth_signature_method: "HMAC-SHA1",
+        oauth_timestamp: signatureData.timestamp,
+        oauth_nonce: signatureData.nonce,
+        oauth_version: "1.0",
+        oauth_signature: encode(buildSignature({
+          url: req.url,
+          method: req.method,
+          qs: normalize(query)
+        }, signatureData))
+      },function(v,k){
+        return k + "=" + v;
+      }).join(",");
+
+    return req;
+  }
+};
+
+exports.getTimestamp = function(){
+  return Math.round(new Date().getTime() / 1000);
+};
+exports.getNonce = function(){
+  var symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split("");
+  var result = "";
+  for (var i = 0; i < 7; i++){
+    result += symbols[Math.floor(Math.random() * symbols.length)];
+  }
+  return result;
+};