From b55633adbb18fe33e3507616d96a2c38d67c5442 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20Bajto=C5=A1?= Date: Tue, 4 Feb 2014 10:54:58 +0100 Subject: [PATCH 1/2] Implement app.getModelByType() A method similar to loopback.getModelByType(), but checking only the models added to the app via `app.model`. --- lib/application.js | 18 ++++++++++++++++++ test/app.test.js | 14 ++++++++++++++ test/support.js | 2 +- 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/lib/application.js b/lib/application.js index 6e71ce7c5..0793013d6 100644 --- a/lib/application.js +++ b/lib/application.js @@ -185,6 +185,24 @@ app.models = function () { return this._models || (this._models = []); } +/** + * Look up a model class by the base model class. + * The method can be used by LoopBack to find models configured in models.json + * over the base model. + * @param {Model} The base model class + * @return {Model} The subclass if found or null + */ +app.getModelByType = function(modelType) { + assert(typeof modelType === 'function', 'modelType must be a constructor'); + var models = this.models; + for(var m in models) { + if(models[m].prototype instanceof modelType) { + return models[m]; + } + } + return null; +}; + /** * Define a DataSource. * diff --git a/test/app.test.js b/test/app.test.js index 47f317954..9a8f05028 100644 --- a/test/app.test.js +++ b/test/app.test.js @@ -93,6 +93,20 @@ describe('app', function() { }); }); + describe('getModelByType', function() { + it('returns undefined for model not attached to app', function() { + expect(app.getModelByType(loopback.User)).to.equal(null); + }); + + it('returns model subclass', function() { + var User = app.model('User', { + options: { base: 'User' }, + dataSource: 'db' + }); + expect(app.getModelByType(loopback.User)).to.equal(User); + }); + }); + describe('app.boot([options])', function () { beforeEach(function () { app.boot({ diff --git a/test/support.js b/test/support.js index 6737119a6..f3c31c27b 100644 --- a/test/support.js +++ b/test/support.js @@ -64,4 +64,4 @@ describe.inBrowser = function describeInBrowser(name, fn) { } else { describe.skip(name, fn); } -}; \ No newline at end of file +}; From 2caae9d1f73788241da533e6a557d3831bd80b11 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miroslav=20Bajto=C5=A1?= Date: Tue, 4 Feb 2014 16:17:32 +0100 Subject: [PATCH 2/2] Modify `loopback.rest` to include `loopback.token` Make `loopback.rest` self-contained, so that authentication works out of the box. var app = loopback(); app.enableAuth(); app.use(loopback.rest()); Note that cookie parsing middleware is not added, users have to explicitly configure that if they want to store access tokens in cookies. Modify `loopback.token` to skip token lookup when the request already contains `accessToken` property. This is in line with other connect-based middleware like `cookieParser` or `json`. --- lib/middleware/rest.js | 14 +++++++++ lib/middleware/token.js | 2 ++ test/access-token.test.js | 21 +++++++++++++ test/rest.middleware.test.js | 61 ++++++++++++++++++++++++++++++++++++ 4 files changed, 98 insertions(+) create mode 100644 test/rest.middleware.test.js diff --git a/lib/middleware/rest.js b/lib/middleware/rest.js index 9ddef7502..797f84175 100644 --- a/lib/middleware/rest.js +++ b/lib/middleware/rest.js @@ -15,6 +15,7 @@ module.exports = rest; */ function rest() { + var token = null; return function (req, res, next) { var app = req.app; var handler = app.handler('rest'); @@ -23,6 +24,19 @@ function rest() { res.send(handler.adapter.allRoutes()); } else if(req.url === '/models') { return res.send(app.remotes().toJSON()); + } else if (app.isAuthEnabled) { + if (!token) { + token = loopback.token({ + model: app.getModelByType(loopback.AccessToken) + }); + } + + token(req, res, function(err) { + if (err) + next(err); + else + handler(req, res, next); + }); } else { handler(req, res, next); } diff --git a/lib/middleware/token.js b/lib/middleware/token.js index 185a71ce5..88a93c244 100644 --- a/lib/middleware/token.js +++ b/lib/middleware/token.js @@ -53,12 +53,14 @@ function token(options) { assert(TokenModel, 'loopback.token() middleware requires a AccessToken model'); return function (req, res, next) { + if (req.accessToken !== undefined) return next(); TokenModel.findForRequest(req, options, function(err, token) { if(err) return next(err); if(token) { req.accessToken = token; next(); } else { + req.accessToken = null; return next(); } }); diff --git a/test/access-token.test.js b/test/access-token.test.js index 0ac52b493..50cf4d9a4 100644 --- a/test/access-token.test.js +++ b/test/access-token.test.js @@ -32,6 +32,27 @@ describe('loopback.token(options)', function() { .end(done); }); }); + + it('should skip when req.token is already present', function(done) { + var tokenStub = { id: 'stub id' }; + app.use(function(req, res, next) { + req.accessToken = tokenStub; + next(); + }); + app.use(loopback.token({ model: Token })); + app.get('/', function(req, res, next) { + res.send(req.accessToken); + }); + + request(app).get('/') + .set('Authorization', this.token.id) + .expect(200) + .end(function(err, res) { + if (err) return done(err); + expect(res.body).to.eql(tokenStub); + done(); + }); + }); }); describe('AccessToken', function () { diff --git a/test/rest.middleware.test.js b/test/rest.middleware.test.js new file mode 100644 index 000000000..66a715970 --- /dev/null +++ b/test/rest.middleware.test.js @@ -0,0 +1,61 @@ +describe('loopback.rest', function() { + beforeEach(function() { + app.dataSource('db', { connector: loopback.Memory }); + }); + + it('works out-of-the-box', function(done) { + app.model('MyModel', { dataSource: 'db' }); + app.use(loopback.rest()); + request(app).get('/mymodels') + .expect(200) + .end(done); + }); + + it('includes loopback.token when necessary', function(done) { + // Note: we have to attach an access token model to the app. + // The auto-detection in loopback.getModelByType() + // fails in unit-tests, as there are too many AccessToken models + // (each test suite registers its' own one) + var Token = app.model('AccessToken', { + options: { base: 'AccessToken' }, + dataSource: 'db' + }); + givenUserModelWithAuth(); + app.enableAuth(); + app.use(loopback.rest()); + + givenLoggedInUser(function(err, token) { + if (err) return done(err); + expect(token).instanceOf(Token); + request(app).get('/users/' + token.userId) + .set('Authorization', token.id) + .expect(200) + .end(done); + }); + }); + + function givenUserModelWithAuth() { + return app.model('user', { + options: { + base: 'User', + relations: { + accessTokens: { + model: 'AccessToken', + type: 'hasMany', + foreignKey: 'userId' + } + } + }, + dataSource: 'db' + }); + } + function givenLoggedInUser(cb) { + var credentials = { email: 'user@example.com', password: 'pwd' }; + var User = app.getModelByType(loopback.User); + User.create(credentials, + function(err, user) { + if (err) return done(err); + User.login(credentials, cb); + }); + } +});