Moving hovercardsserver into hovercardsextension

 #10

Author: saiichihashimoto

.eslintrc

@@ -1,5 +1,6 @@
 {
 	"extends": "xo",
+	"plugins": ["react"],
 	"env": {
 		"browser": true
 	},
@@ -17,6 +18,7 @@
 		"no-mixed-spaces-and-tabs": [2, "smart-tabs"],
 		"no-multi-spaces": [2, { "exceptions": { "VariableDeclarator": true } }],
 		"object-curly-spacing": [2, "always"],
+		"react/jsx-uses-react": 2,
 		"space-before-function-paren": [2, "never"]
 	}
 }

.gitignore

@@ -1,5 +1,6 @@
 .env
 dist-landing/*
 dist/*
+dump.rdb
 node_modules/
 npm-debug.log*

Procfile

@@ -1,4 +1 @@
-copy:     watch 'npm run copy:other' app
-postcss:  npm run postcss -- -w
-watchify: npm run watchify
-landing:  webpack-dev-server --inline --hot
+web: node server

Procfile.dev

@@ -0,0 +1,6 @@
+web:      nodemon --ignore dist/ -e js,jsx server
+redis:    redis-server
+copy:     watch 'npm run copy:other' app
+postcss:  npm run postcss -- -w
+watchify: npm run watchify
+landing:  webpack-dev-server --inline --hot

app.json

@@ -0,0 +1,22 @@
+{
+	"name": "hovercards",
+	"env": {
+		"CHROMIUM_IDS":                    { "required": true },
+		"GOOGLE_SERVER_KEY":               { "required": true },
+		"IMGUR_CLIENT_ID":                 { "required": true },
+		"INSTAGRAM_CLIENT_ID":             { "required": true },
+		"INSTAGRAM_CLIENT_SECRET":         { "required": true },
+		"MASHAPE_KEY":                     { "required": false },
+		"REDDIT_CLIENT_ID":                { "required": true },
+		"SOUNDCLOUD_CLIENT_ID":            { "required": true },
+		"TWITTER_APP_ACCESS_TOKEN":        { "required": true },
+		"TWITTER_APP_ACCESS_TOKEN_SECRET": { "required": true },
+		"TWITTER_CONSUMER_KEY":            { "required": true },
+		"TWITTER_CONSUMER_SECRET":         { "required": true }
+	},
+	"addons": [
+		"papertrail",
+		"rediscloud",
+		"securekey"
+	]
+}

package.json

@@ -19,15 +19,15 @@
   "scripts": {
     "browserify": "mkdir -p dist && browserify $npm_package_config_browserify_input $npm_package_config_browserify_output",
     "build:landing": "rm -rf dist && webpack -p",
-    "clean": "rm -rf dist/* *.pem *.nex",
+    "clean": "rm -rf dist/* dist-landing/* *.pem *.nex dump.rdb",
     "copy:other": "rsync -rm --include='*/' --include='*.json' --include='options.html' --exclude='*' app/* dist && mkdir -p dist/assets/images && cp app/images/logo-* dist/assets/images && cp app/images/*-icon-full_color.png dist/assets/images",
     "postcss": "postcss app/*.css -d dist/ -c postcss.js",
     "cssfmt": "( git diff --staged --name-only | grep \".s\\?css$\" | xargs -I '{}' -n 1 cssfmt {} ) && ( git diff --staged --name-only | grep \".s\\?css$\" | xargs git add )",
     "deploy:landing": "gh-pages -d dist-landing",
     "eslint-fix": "( git diff --staged --name-only | grep \".jsx\\?$\" | xargs eslint --fix ) && ( git diff --staged --name-only | grep \".jsx\\?$\" | xargs git add )",
     "fix": "npm run cssfmt && npm run eslint-fix",
     "pkg": "npm run clean && npm run copy:other && npm run postcss && npm run browserify && npm run uglifyjs && zip -q -r build/pkg-$npm_package_version.zip dist",
-    "start": "foreman start",
+    "start": "if [ \"$NODE_ENV\" = 'production' ]; then foreman start; else foreman start -f Procfile.dev; fi",
     "test": "eslint . --ignore-path .gitignore",
     "uglifyjs": "mkdir -p dist && find dist -name \\*.js | xargs -I FILENAME uglifyjs FILENAME -o FILENAME -c drop_console,warnings=false --stats",
     "watchify": "mkdir -p dist && watchify $npm_package_config_browserify_input -t [ envify --NODE_ENV development ] $npm_package_config_browserify_output --full-paths -v -d"
@@ -52,12 +52,25 @@
     ]
   },
   "dependencies": {
-    "async": "^1.4.2",
-    "hovercardsshared": "cameronrohani/hovercardsshared#v3.0.0",
+    "async": "^1.5.0",
+    "cheerio": "^0.19.0",
+    "connect-redis": "^3.0.2",
+    "express": "^4.13.3",
+    "express-session": "^1.11.3",
+    "googleapis": "^2.1.6",
+    "hovercardsshared": "git+https://0df3b2f2114c8ec057c69f5f3d53e9a16afd26a1:[email protected]:cameronrohani/hovercardsshared.git#v3.0.0",
+    "instagram-node": "^0.5.8",
     "jquery": "^2.1.4",
     "memoizee": "^0.3.9",
+    "passport": "^0.2.2",
+    "passport-twitter": "^1.0.3",
     "ractive": "^0.7.3",
-    "underscore": "^1.8.3"
+    "redis": "^2.4.2",
+    "request": "^2.65.0",
+    "snoocore": "^3.2.0",
+    "twit": "^2.1.1",
+    "underscore": "^1.8.3",
+    "urijs": "^1.17.0"
   },
   "devDependencies": {
     "autoprefixer": "^6.0.3",
@@ -68,6 +81,7 @@
     "envify": "^3.4.0",
     "eslint": "^1.10.3",
     "eslint-config-xo": "^0.9.1",
+    "eslint-plugin-react": "^3.15.0",
     "extract-text-webpack-plugin": "^1.0.1",
     "factor-bundle": "^2.5.0",
     "file-loader": "^0.9.0",
@@ -76,6 +90,7 @@
     "html-webpack-plugin": "^2.22.0",
     "image-webpack-loader": "^2.0.0",
     "jquery": "^2.2.2",
+    "nodemon": "^1.8.1",
     "postcss-class-prefix": "^0.3.0",
     "postcss-cli": "^2.3.2",
     "postcss-color-rgba-fallback": "^2.0.0",
@@ -97,6 +112,10 @@
     "webpack": "^1.13.1",
     "webpack-dev-server": "^1.14.1"
   },
+  "engines": {
+    "node": ">= 4.1.0",
+    "npm": ">= 3.9.0"
+  },
   "pre-commit": [
     "fix",
     "test"

server/api-routes.js

@@ -0,0 +1,138 @@
+var _          = require('underscore');
+var async      = require('async');
+var express    = require('express');
+var passport   = require('passport');
+var session    = require('express-session');
+var RedisStore = require('connect-redis')(session);
+
+var config       = require('./config');
+var redis_client = require('./redis-client');
+
+var routes = express.Router();
+
+routes.use(session({
+	store:             new RedisStore({ client: redis_client }),
+	secret:            (process.env.SECURE_KEY || '').split(','),
+	saveUninitialized: false,
+	resave:            false
+}));
+routes.use(passport.initialize());
+routes.use(passport.session());
+
+var serialize   = JSON.stringify;
+var deserialize = JSON.parse;
+
+function respond_to_caller(req, res, callback, err, result, usage) {
+	_.each(usage, function(value, header) {
+		res.append('usage-' + header, value);
+	});
+	if (err) {
+		return callback(err);
+	}
+	res.json(result);
+}
+
+var callers = _.mapObject(config.apis, function(api_config) {
+	return api_config.caller ? api_config.caller(api_config) : {};
+});
+
+_.each(config.apis, function(api_config, api) {
+	if (api_config.authenticate) {
+		api_config.authenticate(routes);
+	}
+	if (callers[api].content) {
+		routes.get('/' + api + '/content/:id', function(req, res, callback) {
+			callers[api].content(_.defaults({}, req.params, req.query, req.headers), _.partial(respond_to_caller, req, res, callback));
+		});
+	}
+
+	if (callers[api].discussion) {
+		routes.get('/' + api + '/content/:id/discussion', function(req, res, callback) {
+			callers[api].discussion(_.defaults({}, req.params, req.query, req.headers), _.partial(respond_to_caller, req, res, callback));
+		});
+	}
+
+	_.chain(api_config.discussion_apis)
+	 .without(api)
+	 .each(function(discussion_api) {
+		if (callers[discussion_api].discussion) {
+			routes.get('/' + api + '/content/:id/discussion/' + discussion_api, function(req, res, callback) {
+				callers[discussion_api].discussion(
+					_.defaults({ for: _.defaults({ api: api, type: 'content', id: req.params.id }, req.query.for, req.header.for) }, req.query, req.headers),
+					_.partial(respond_to_caller, req, res, callback)
+				);
+			});
+		}
+	})
+	 .value();
+
+	if (callers[api].account) {
+		routes.get('/' + api + '/account/:id', function(req, res, callback) {
+			callers[api].account(_.defaults({}, req.params, req.query, req.headers), _.partial(respond_to_caller, req, res, callback));
+		});
+	}
+
+	if (callers[api].account_content) {
+		routes.get('/' + api + '/account/:id/content', function(req, res, callback) {
+			callers[api].account_content(_.defaults({}, req.params, req.query, req.headers), _.partial(respond_to_caller, req, res, callback));
+		});
+	}
+
+	if (process.env.NODE_ENV === 'production') {
+		_.extend(callers[api].model, _.mapObject(callers[api].model, function(func, name) {
+			var promises = {};
+
+			return function(args, args_not_cached, usage, callback) {
+				if (_.result(args_not_cached, 'user')) {
+					// The server-side cache (ie redis) helps us use the same work we've done
+					// for other users who want the same thing. An authenticated request needs
+					// work that is specific to that user's view, so this doesn't apply there.
+					// The user will have the request cached on the client-side, in those cases.
+					return func(args, args_not_cached, usage, callback);
+				}
+				var key = _.chain(['cache', api, name])
+					.union(_.map(args, function(val, key) {
+						return key + ':' + JSON.stringify(val);
+					}))
+					.join('::')
+					.value();
+
+				promises[key] = promises[key] || new Promise(function(resolve, reject) {
+					redis_client.get(key, function(err, result) {
+						if (!err && result) {
+							return async.setImmediate(function() {
+								resolve(deserialize(result));
+							});
+						}
+						func(args, args_not_cached, usage, function(err, result) {
+							if (err) {
+								return reject(err);
+							}
+							redis_client.setex(key, (api_config['cache_' + name] || api_config.cache_default || 5 * 60 * 1000) / 1000, serialize(result));
+							resolve(result);
+						});
+					});
+				});
+
+				promises[key]
+					.then(function(result) {
+						delete promises[key];
+						callback(null, result);
+					})
+					.catch(function(err) {
+						delete promises[key];
+						callback(err);
+					});
+			};
+		}));
+	}
+});
+
+/* eslint-disable no-unused-vars */
+routes.use(function(err, req, res, callback) {
+	/* eslint-enable no-unused-vars */
+	err = _.defaults(err, { message: 'Do not recognize url ' + req.path, status: 404 });
+	res.status(err.status).json(err);
+});
+
+module.exports = routes;

server/config.js

@@ -0,0 +1,86 @@
+var _               = require('underscore');
+var TwitterStrategy = require('passport-twitter').Strategy;
+var passport        = require('passport');
+var redis_client    = require('./redis-client');
+var shared_config   = require('hovercardsshared/config');
+
+var CHROMIUM_IDS = process.env.CHROMIUM_IDS.split(';');
+
+var youtube_keys = [process.env.GOOGLE_SERVER_KEY];
+for (var i = 2; process.env['GOOGLE_SERVER_KEY_' + i]; i++) {
+	youtube_keys.push(process.env['GOOGLE_SERVER_KEY_' + i]);
+}
+
+var config = {
+	apis: {
+		imgur: {
+			caller:      require('hovercardsshared/imgur'),
+			key:         process.env.IMGUR_CLIENT_ID,
+			mashape_key: process.env.MASHAPE_KEY
+		},
+		instagram: {
+			caller: require('hovercardsshared/instagram'),
+			key:    process.env.INSTAGRAM_CLIENT_ID,
+			secret: process.env.INSTAGRAM_CLIENT_SECRET
+		},
+		reddit:     {},
+		soundcloud: {},
+		twitter:    {
+			caller:          require('hovercardsshared/twitter'),
+			key:             process.env.TWITTER_CONSUMER_KEY,
+			secret:          process.env.TWITTER_CONSUMER_SECRET,
+			app_user:        process.env.TWITTER_APP_ACCESS_TOKEN,
+			app_user_secret: process.env.TWITTER_APP_ACCESS_TOKEN_SECRET
+		},
+		youtube: (youtube_keys.length === 1) ? {
+			caller: require('hovercardsshared/youtube'),
+			key:    _.first(youtube_keys)
+		} : {
+			caller: require('hovercardsshared/youtube'),
+			keys:   youtube_keys
+		}
+	}
+};
+
+config.apis.twitter.secret_storage = {
+	del: function(token, callback) {
+		redis_client.del('auth:twitter:' + token, callback);
+	},
+	get: function(token, callback) {
+		redis_client.get('auth:twitter:' + token, callback);
+	}
+};
+
+config.apis.twitter.authenticate = function(routes) {
+	passport.use(new TwitterStrategy({
+		consumerKey:    process.env.TWITTER_CONSUMER_KEY,
+		consumerSecret: process.env.TWITTER_CONSUMER_SECRET,
+		callbackURL:    '/v2/twitter/callback'
+	}, function(token, tokenSecret, profile, callback) {
+		redis_client.set('auth:twitter:' + token, tokenSecret, _.partial(callback, _, token));
+	}));
+
+	routes.get('/twitter/authenticate', function(req, res, callback) {
+		if (!_.contains(CHROMIUM_IDS, req.query.chromium_id)) {
+			return callback({ status: 400 });
+		}
+		passport.authenticate('twitter', { session: false, callbackURL: '/v2/twitter/callback?chromium_id=' + req.query.chromium_id })(req, res, callback);
+	});
+	routes.get('/twitter/callback', passport.authenticate('twitter', { session: false }), function(req, res, callback) {
+		if (!_.contains(CHROMIUM_IDS, req.query.chromium_id)) {
+			return callback({ status: 400 });
+		}
+		res.redirect('https://' + req.query.chromium_id + '.chromiumapp.org/callback#access_token=' + req.user);
+	});
+};
+
+var apis = _.intersection(_.keys(config.apis), _.keys(shared_config.apis));
+
+config.apis = _.chain(config.apis)
+	.pick(apis)
+	.each(function(api_config, api) {
+		_.defaults(api_config, shared_config.apis[api]);
+	})
+	.value();
+
+module.exports = config;

server/index.js

@@ -0,0 +1,17 @@
+var express = require('express');
+var os      = require('os');
+
+var app = express();
+
+app.set('port', process.env.PORT || 5000);
+
+app.get('/', function(req, res) {
+	res.redirect('http://www.hovercards.com');
+});
+app.use('/v2', require('./api-routes'));
+app.use('/v1', require('./old/hovercards'));
+// app.use('/', require('./view-routes'));
+
+app.listen(app.get('port'), function() {
+	console.log('Server is running at', 'http://' + os.hostname() + ':' + app.get('port'));
+});