nodebr · FelipeMonobe · Nov 15, 2016 · Nov 15, 2016 · Nov 15, 2016 · Nov 15, 2016
diff --git a/.env b/.env
@@ -1,3 +1,4 @@
 NODE_ENV=development
 DATABASE_URL=mysql://nodebr:nodebr@localhost/nodebr
 PORT=8080
+COOKIE_SECRET=here_be_dragons
diff --git a/circle.yml b/circle.yml
@@ -4,6 +4,7 @@ machine:
   environment:
     DATABASE_URL: mysql://ubuntu@localhost/circle_test
     NODE_ENV: test
+    COOKIE_SECRET: here_be_dragons
   node:
     version: v6.9
 test:

diff --git a/lib/async-handler.js b/lib/async-handler.js
@@ -0,0 +1,12 @@
+const co = require('co')
+
+/**
+ * Um helper para registrar handlers assíncronos
+ * @todo  Implementar funcionalidade para Promises
+ * @param {Function} handler Um generator que irá receber a requisição
+ * @return {Function} Uma função que pode ser usada como handler no Express
+ */
+module.exports = handler => (req, res, next) => {
+  co(handler.bind(null, req, res, next))
+  .catch(err => next(err))
+}
diff --git a/lib/db/drop-dabase.js b/lib/db/drop-dabase.js
@@ -0,0 +1,28 @@
+/* $lab:coverage:off$ */
+const co = require('co')
+
+/**
+ * Cria uma função no Bookshelf para zerar o banco de dados
+ * @param {Object} bookshelf Uma instância do Bookshelf
+ */
+module.exports = bookshelf => {
+  const { knex } = bookshelf
+
+  bookshelf.dropDatabase = co.wrap(function * () {
+    // Desabilita este comando em qualquer outro ambiante que não seja desenvolvimento
+    if (process.env.NODE_ENV === 'production') {
+      return Promise.reject(new Error('Você não pode executar o dropDatabase neste ambiente'))
+    }
+
+    // Pega todas as tabelas no nosso banco de dados
+    const result = yield knex.raw('SHOW TABLES;')
+    const tables = result[0].map(table => table[Object.keys(table)[0]])
+
+    yield knex.transaction(co.wrap(function * (trx) {
+      yield knex.raw('SET FOREIGN_KEY_CHECKS = 0;')
+      yield Promise.all(tables.map(table => knex.raw(`DROP TABLE ${table};`)))
+      yield knex.raw('SET FOREIGN_KEY_CHECKS = 1;')
+    }))
+  })
+}
+/* $lab:coverage:on$ */
diff --git a/lib/db/index.js b/lib/db/index.js
@@ -14,6 +14,7 @@ bookshelf.plugin(require('bookshelf-modelbase').pluggable)
 bookshelf.plugin(require('bookshelf-bcrypt'))
 bookshelf.plugin(require('./base'))
 bookshelf.plugin(require('./truncate'))
+bookshelf.plugin(require('./drop-dabase'))
 
 const modelsPath = path.resolve(__dirname, '../../resources')
 

diff --git a/lib/db/migrations/20161115211528_shares.js b/lib/db/migrations/20161115211528_shares.js
@@ -0,0 +1,11 @@
+
+exports.up = knex => knex.schema.createTableIfNotExists('shares', table => {
+  table.uuid('id').primary()
+  table.uuid('user_id').index().references('id').inTable('users')
+  table.string('title', 120).notNullable()
+  table.string('thumbnail', 255)
+  table.string('link', 255).notNullable()
+  table.timestamps()
+})
+
+exports.down = knex => knex.schema.dropTableIfExists('shares')
diff --git a/lib/error-handler.js b/lib/error-handler.js
@@ -15,15 +15,17 @@ module.exports = (err, req, res, next) => {
 
   // Verifica os tipos de erros que podemos ter
   if (err.isJoi) {
-    res.status(422).send({
+    return res.status(422).send({
       error: 'ValidationError',
       message: err.details[0].message,
       path: err.details[0].path,
       type: err.details[0].type
     })
+  } else if (err.isBoom) {
+    return res.status(err.output.statusCode).send(err.output.payload)
   } else {
     // Caso nenhum tipo de erro seja encontrado então é um erro no servidor
-    res.status(500).send({ error: 'InternalServerError' })
     console.error(err.stack)
+    return res.status(500).send({ error: 'InternalServerError' })
   }
 }
diff --git a/lib/session.js b/lib/session.js
@@ -0,0 +1,40 @@
+const cookieSession = require('cookie-session')
+
+/**
+ * Um middleware para checagem de sessão
+ * @param {Object} [config] Configurações da sessão
+ * @param {Boolean} [config.restrict=true] Deixar que apenas usuários logados
+ * acessem o handler
+ * @return {Function} Uma função que serve de middleware
+ */
+module.exports = (config = {
+  restrict: true
+}) => {
+  const session = cookieSession({
+    name: 'session',
+    keys: [process.env.COOKIE_SECRET],
+    maxAge: 7 * 24 * 60 * 60 * 1000, //  Uma semana
+    secure: process.env.NODE_ENV === 'production',
+    httpOnly: true,
+    signed: true,
+    overwrite: true
+  })
+
+  return (req, res, next) => {
+    // Checa a sessão utilizando o middleware cookie-session
+    session(req, res, err => {
+      if (err) {
+        return next(err)
+      }
+
+      // Caso o acesso seja restrito à usuários logados precisamos verificar
+      // se a sessão foi lida com sucesso
+      if ((!req.session || !req.session.user_id) && config.restrict) {
+        return res.status(401).send({ error: 'Unauthorized' })
+      }
+
+      // Tudo sob controle, podemos executar o handler
+      next()
+    })
+  }
+}
diff --git a/package.json b/package.json
@@ -7,7 +7,9 @@
     "test": "standard && lab --verbose --colors --assert code --ignore __core-js_shared__",
     "test-cov": "npm test -- -r console -o stdout -r html -o coverage/coverage.html -r lcov -o coverage/lcov.info",
     "knex": "knex --knexfile ./lib/db/knexfile.js",
-    "start": "node index.js"
+    "start": "node index.js",
+    "migrate": "npm run knex migrate:latest",
+    "reset": "node ./scripts/drop-database; npm run migrate"
   },
   "repository": {
     "type": "git",
@@ -26,7 +28,9 @@
     "bookshelf-bcrypt": "^2.1.0",
     "bookshelf-modelbase": "^2.10.1",
     "bookshelf-uuid": "^1.0.0",
+    "boom": "^4.2.0",
     "co": "^4.6.0",
+    "cookie-session": "^2.0.0-alpha.2",
     "express": "^4.14.0",
     "glob": "^7.1.1",
     "helmet": "^3.1.0",
@@ -41,6 +45,7 @@
     "eslint-plugin-standard": "^2.0.1",
     "lab": "^11.2.1",
     "standard": "^8.5.0",
-    "supertest": "^2.0.1"
+    "supertest": "^2.0.1",
+    "uuid": "^2.0.3"
   }
 }
diff --git a/resources/hello-world/routes.js b/resources/hello-world/routes.js
@@ -20,6 +20,8 @@ router.delete('/hello-world/:id', handlers.remove)
 
 // Somente exportamos esta rota caso o ambiente for de desenvolvimento
 // pois não queremos que a mesma esteja disponível em produção
+/* $lab:coverage:off$ */
 if (process.env.NODE_ENV !== 'production') {
   module.exports = router
 }
+/* $lab:coverage:on$ */
diff --git a/resources/sessions/handlers.js b/resources/sessions/handlers.js
@@ -0,0 +1,36 @@
+const Boom = require('boom')
+
+const db = require('../../lib/db')
+const User = db.model('User')
+
+exports.create = function * (req, res) {
+  // Verifica se o usuário já está logado
+  if (req.session && req.session.user_id) {
+    throw Boom.badData('Você já está logado')
+  }
+
+  // Pega no banco de dados o usuário que precisamos
+  const user = yield User.findOne({ username: req.body.username })
+  .catch(User.NotFoundError, () => {
+    throw Boom.badData('Não foi possível encontrar o usuário')
+  })
+
+  // Verifica se a senha está ok
+  if (!(yield user.compare(req.body.password))) {
+    throw Boom.badData('Sua senha está incorreta')
+  }
+
+  // Seta a sessão e retorna sucesso
+  req.session.user_id = user.id
+  res.send({ success: true })
+}
+
+exports.findOne = (req, res) => {
+  User.findById(req.session.user_id)
+  .then((user) => res.send(user))
+}
+
+exports.remove = (req, res) => {
+  req.session = null
+  res.send({ success: true })
+}
diff --git a/resources/sessions/routes.js b/resources/sessions/routes.js
@@ -0,0 +1,24 @@
+const router = require('express').Router()
+
+const handlers = require('./handlers')
+const schemas = require('./schemas')
+const validator = require('../../lib/validator')
+const session = require('../../lib/session')
+const asyncHandler = require('../../lib/async-handler')
+const bodyParser = require('body-parser')
+
+router.post('/sessions',
+  session({ restrict: false }),
+  bodyParser.json(),
+  validator({ body: schemas.create }),
+  asyncHandler(handlers.create))
+
+router.get('/sessions',
+  session(),
+  handlers.findOne)
+
+router.delete('/sessions',
+  session(),
+  handlers.remove)
+
+module.exports = router
diff --git a/resources/sessions/schemas.js b/resources/sessions/schemas.js
@@ -0,0 +1,6 @@
+const Joi = require('joi')
+
+exports.create = Joi.object({
+  username: Joi.string().token().min(3).max(20).required(),
+  password: Joi.string().min(8).max(120).required()
+})
diff --git a/resources/shares/handlers.js b/resources/shares/handlers.js
@@ -0,0 +1,37 @@
+const boom = require('boom')
+const db = require('../../lib/db')
+
+const Shares = db.model('Share')
+
+exports.findAll = (req, res) =>
+  Shares
+  .query(qb => qb.limit(req.query.limit).offset(req.query.offset))
+  .orderBy('created_at')
+  .fetchAll({}, { withRelated: ['user'] })
+  .then(collection => res.send(collection))
+  .catch(() => { throw boom.badRequest('Ocorreu um erro na consulta') })
+
+exports.findOne = (req, res) =>
+  Shares
+  .findById(req.params.id, { withRelated: ['user'] })
+  .then(share => {
+    if (!share) return res.status(404).end()
+    return res.send(share)
+  })
+  .catch(() => { throw boom.badRequest('Ocorreu um erro na consulta') })
+
+exports.remove = (req, res) => {
+  if (req.params.id !== req.session.user_id) return res.status(403).end()
+
+  return Shares
+  .forge({ id: req.params.id })
+  .destroy()
+  .then(() => res.send({ success: true }))
+  .catch(() => { throw boom.badRequest('Ocorreu um erro na exclusão') })
+}
+
+exports.create = (req, res) =>
+  Shares
+  .create(req.body)
+  .then(share => res.send(share))
+  .catch(() => { throw boom.badRequest('Ocorreu um erro na criação') })
diff --git a/resources/shares/model.js b/resources/shares/model.js
@@ -0,0 +1,10 @@
+/**
+ * Cria o modelo Share
+ * @param {Function} bookshelf Uma instância do Bookshelf
+ */
+module.exports = bookshelf => bookshelf.model('Share', {
+  tableName: 'shares',
+  user: function () {
+    return this.belongsTo('User')
+  }
+})
diff --git a/resources/shares/routes.js b/resources/shares/routes.js
@@ -0,0 +1,25 @@
+const express = require('express')
+const bodyParser = require('body-parser')
+
+const validator = require('../../lib/validator')
+const schemas = require('./schemas')
+const handlers = require('./handlers')
+const router = express.Router()
+const session = require('../../lib/session')
+
+router.get('/compartilhamentos/',
+  validator({ query: schemas.query }),
+  handlers.findAll)
+
+router.get('/compartilhamentos/:id', handlers.findOne)
+
+router.post('/compartilhamentos',
+  bodyParser.json(),
+  validator({ body: schemas.create }),
+  handlers.create)
+
+router.delete('/compartilhamentos/:id',
+  session(),
+  handlers.remove)
+
+module.exports = router
diff --git a/resources/shares/schemas.js b/resources/shares/schemas.js
@@ -0,0 +1,22 @@
+const Joi = require('joi')
+
+exports.model = Joi.object({
+  id: Joi.string().uuid(),
+  user_id: Joi.string().uuid(),
+  title: Joi.string(),
+  thumbnail: Joi.string(),
+  link: Joi.string()
+})
+
+exports.create = exports.model.concat(Joi.object({
+  id: Joi.forbidden(),
+  user_id: Joi.string().uuid(),
+  title: Joi.string().min(10).max(120).required(),
+  thumbnail: Joi.string().uri().max(255).optional(),
+  link: Joi.string().uri().max(255).required()
+}))
+
+exports.query = Joi.object({
+  limit: Joi.number().integer().positive().max(50).default(15),
+  offset: Joi.number().integer().greater(-1).default(0)
+})
diff --git a/scripts/drop-database.js b/scripts/drop-database.js
@@ -0,0 +1,8 @@
+const db = require('../lib/db')
+
+db.dropDatabase()
+.then(() => process.exit(0))
+.catch(err => {
+  console.error(err.stack)
+  process.exit(1)
+})
diff --git a/test/fixtures/sessions.js b/test/fixtures/sessions.js
@@ -0,0 +1,15 @@
+const server = require('../../lib/server')
+const request = require('supertest')
+
+/**
+ * Cria um cookie compatível com a header Cookie para ser usado com o supertest
+ * @param {String} username O nome do usuário
+ * @param {String} password A senha do usuário
+ * @return {Promise} Uma promise que resolve com o cookie de autenticação
+ */
+exports.cookie = (username, password) => request(server)
+.post('/sessions')
+.send({ username, password })
+.then(res => res.header['set-cookie']
+  .map(e => e.split(';')[0])
+  .join(';'))