first commit and first version

Author: David Inga

Diff for: .editorconfig

@@ -0,0 +1,14 @@
+# editorconfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

Diff for: .eslintrc.json

@@ -0,0 +1,15 @@
+{
+  "env": {
+    "browser": true,
+    "node": true,
+    "mocha": true,
+    "es6": true
+  },
+  "globals": {
+  },
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module"
+  },
+  "extends": "vizzuality"
+}

Diff for: .gitignore

@@ -0,0 +1,12 @@
+# Mac OS
+.DS_Store
+
+# Text editors
+*.sublime*
+.sublime*
+
+# Vendors
+/node_modules
+
+# Logs
+*.log*

Diff for: README.md

@@ -0,0 +1,78 @@
+# Passport control tower Strategy
+
+A Passport's strategy for Control Tower
+
+## Installation
+
+```bash
+npm install --save passport-control-tower
+```
+
+## Example of use
+
+```js
+const express = require('express');
+const passport = require('passport');
+const ControlTowerStrategy = require('passport-control-tower');
+const cookieParser = require('cookie-parser');
+const bodyParser = require('body-parser');
+const app = express();
+
+function isAuthenticated(req, res, next) {
+  if (req.isAuthenticated()) return next();
+  // if they aren't redirect them to the home page
+  res.redirect('/login');
+}
+
+// Use the Control Tower Strategy within Passport.
+passport.use(new ControlTowerStrategy({
+  apiUrl: '[CONTROL_TOWER_API_URL]',
+  callbackUrl: '[YOUR_CALLBACK_URL]'
+}));
+
+// Passport session setup.
+//   To support persistent login sessions, Passport needs to be able to
+//   serialize users into and deserialize users out of the session. Typically,
+//   this will be as simple as storing the user ID when serializing, and finding
+//   the user by ID when deserializing. However, since this example does not
+//   have a database of user records, the complete spotify profile is serialized
+//   and deserialized.
+passport.serializeUser(function(user, done) {
+  done(null, user);
+});
+passport.deserializeUser(function(obj, done) {
+  done(null, obj);
+});
+
+// configure Express
+app.use(cookieParser());
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(bodyParser.json());
+app.use(require('express-session')({ secret: 'keyboard cat', resave: false, saveUninitialized: false }));
+// Initialize Passport!  Also use passport.session() middleware, to support
+// persistent login sessions (recommended).
+app.use(passport.initialize());
+app.use(passport.session());
+
+app.get('/', function(req, res) {
+  res.send('Welcome!');
+});
+
+app.get('/private', isAuthenticated, function(req, res) {
+  res.send('Success!');
+});
+
+app.get('/login', passport.authenticate('control-tower'), function(req, res) {
+  // Success
+  res.redirect('/private');
+});
+
+app.get('/logout', function(req, res) {
+  req.session.destroy();
+  req.logout();
+  // Success
+  res.redirect('/');
+});
+
+app.listen(3000);
+```

Diff for: lib/auth.js

@@ -0,0 +1,52 @@
+const request = require('superagent');
+const passport = require('passport-strategy');
+const util = require('util');
+
+function Strategy(options = {}) {
+  this.name = 'control-tower';
+  if (!options.apiUrl) throw new TypeError('apiUrl param is required');
+  if (!options.callbackUrl) throw new TypeError('callbackUrl param is required');
+  passport.Strategy.call(this);
+  this.apiUrl = options.apiUrl;
+  this.callbackUrl = options.callbackUrl;
+}
+
+// Inherits from Passport Strategy
+util.inherits(Strategy, passport.Strategy);
+
+/**
+ * Authentication method
+ */
+Strategy.prototype.authenticate = function authenticate(req) {
+  passport.Strategy.call(this);
+  if (!req.isAuthenticated() && !req.query.token) {
+    this.redirect(`${this.apiUrl}/auth?callbackUrl=${this.callbackUrl}&token=true`);
+  } else {
+    this.verify({ token: req.query.token }, (err, user, info) => {
+      if (err) return this.error(err);
+      if (!user) return this.fail(info);
+      return this.success(user, info);
+    });
+  }
+};
+
+/**
+ * Verify using Control Tower gateway
+ */
+Strategy.prototype.verify = function verify(user, done) {
+  request(`${this.apiUrl}/auth/check-logged`)
+    .set('Authorization', `Bearer ${user.token}`)
+    .end((err, res) => {
+      if (err) {
+        done(err, null, 'User unathorized');
+      } else {
+        done(null, res.body, 'User authenticated correctly');
+      }
+    });
+};
+
+Strategy.prototype.error = function error(err) {
+  throw err || 'An error happened';
+};
+
+module.exports = Strategy;

Diff for: package.json

@@ -0,0 +1,28 @@
+{
+  "name": "passport-control-tower",
+  "version": "0.1.0",
+  "description": "A Passport's strategy for Control Tower",
+  "main": "lib/auth.js",
+  "scripts": {
+    "lint": "eslint .",
+    "test": "npm run lint"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davidsingal/passport-control-tower.git"
+  },
+  "author": "David Inga",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/davidsingal/passport-control-tower/issues"
+  },
+  "homepage": "https://github.com/davidsingal/passport-control-tower#readme",
+  "devDependencies": {
+    "eslint": "^3.15.0",
+    "eslint-config-vizzuality": "^1.0.3"
+  },
+  "dependencies": {
+    "passport-strategy": "^1.0.0",
+    "superagent": "^3.4.3"
+  }
+}