skeleton code

.env

@@ -0,0 +1,8 @@
+SECRET_KEY_JWT="BluePeriod"
+
+DEV_USERNAME = "postgres"
+DEV_PASSWORD = 
+DEV_SERVER = "localhost"
+DEV_DB = "kanban_db"
+
+DEV_G_CLIENT_ID = 982085477024-6n2tpq82aracq5krun8e705oj863h0q2.apps.googleusercontent.com

.gitignore

@@ -0,0 +1,2 @@
+.env
+node_modules

app.js

@@ -0,0 +1,21 @@
+require("dotenv").config();
+const express = require('express')
+const app = express()
+const port = 3000
+const routes = require('./routes')
+const cors = require('cors')
+const { hash, compareHash } = require('./helpers/brcypt')
+const errorHandler = require('./middlewares/error-handler')
+
+app.locals.hash = hash
+app.locals.compareHash = compareHash
+
+app.use(cors())
+app.use(express.urlencoded({extended:true}))
+app.use(express.json())
+app.use('/', routes)
+app.use('/', errorHandler)
+
+app.listen(port, () => {
+  console.log(`app listening at http://localhost:${port}`)
+})

config/config.js

@@ -0,0 +1,23 @@
+module.exports = {
+  "development": {
+    "username": process.env.DEV_USERNAME,
+    "password": process.env.DEV_PASSWORD,
+    "database": process.env.DEV_DB,
+    "host": process.env.DEV_SERVER,
+    "dialect": "postgres"
+  },
+  "test": {
+    "username": "root",
+    "password": null,
+    "database": "database_test",
+    "host": "127.0.0.1",
+    "dialect": "mysql"
+  },
+  "production": {
+    "username": "root",
+    "password": null,
+    "database": "database_production",
+    "host": "127.0.0.1",
+    "dialect": "mysql"
+  }
+}

helpers/brcypt.js

@@ -0,0 +1,14 @@
+const bcrypt = require('bcryptjs')
+
+function hash(password) {
+  return bcrypt.hashSync(password, bcrypt.genSaltSync(10))
+}
+
+function compareHash(password, db_password) {
+  return bcrypt.compareSync(password, db_password)
+}
+
+module.exports = {
+  hash,
+  compareHash
+} 

helpers/jwt.js

@@ -0,0 +1,8 @@
+const jwt = require("jsonwebtoken")
+
+const SECRET_KEY = process.env.SECRET_KEY_JWT
+const jwtEncrypt = (payload) => jwt.sign(payload, SECRET_KEY)
+
+const jwtDecrypt = (token) => jwt.verify(token, SECRET_KEY)
+
+module.exports = {jwtDecrypt, jwtEncrypt}

middlewares/auth.js

@@ -0,0 +1,24 @@
+const {jwtDecrypt} = require("../helpers/jwt")
+const {User, Todo} = require("../models")
+
+const authentication = (req, res, next) =>{
+    try{
+        const {access_token} = req.headers
+        const dataDecoded = jwtDecrypt(access_token)
+        User.findByPk(dataDecoded.id)
+            .then(user => {
+                if (!user){
+                    throw {name: "AuthenticationError", message:"User not Found"}
+                } else {
+                    req.currentUser = {id: user.id}
+                    next()
+                }
+            }) .catch(err => {
+                next(err)
+            })
+    } catch(err) {
+        next(err)
+    } 
+}
+
+module.exports = {authentication, todoAuth}

middlewares/error-handler.js

@@ -0,0 +1,53 @@
+const errorHandler = (err, req, res, next) => {
+    let statusCode
+    let message
+    console.log(err)
+    switch (err.name) {
+        case "noEmail":
+            statusCode = 400
+            message = "Email not found"
+            break;
+
+        case "wrongPassword":
+            statusCode = 400
+            message = "Wrong password"
+            break;
+
+        case "SequelizeUniqueConstraintError":
+            statusCode = 400
+            message = err.errors.map(el => el.message)
+            break;
+
+        case "FillEmailPassword":
+            statusCode = 400
+            message = "Please Fill Email and Password"
+            break;
+
+        case "TodoNotFound":
+            statusCode = 404
+            message = "Todo not Found"
+            break;
+
+        case "AuthorizationError":
+            statusCode = 401
+            message = "User does not have permission"
+            break;
+
+        case "JsonWebTokenError":
+            statusCode = 400
+            message= "Login Error"
+            break;
+
+        case "SequelizeValidationError":
+            statusCode = 400
+            message = err.errors.map(el => el.message)
+            break;
+
+        default:
+            statusCode = 500
+            message = "Internal Server Error"
+            break;
+    }
+    res.status(statusCode).json({message: message, devMessage: err})
+}
+module.exports = errorHandler

migrations/20210611124853-create-users.js

@@ -0,0 +1,33 @@
+'use strict';
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('Users', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      email: {
+        type: Sequelize.STRING,
+        unique:true,
+        allowNull: false,
+      },
+      password: {
+        type: Sequelize.STRING,
+        allowNull: false
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('Users');
+  }
+};

models/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Sequelize = require('sequelize');
+const basename = path.basename(__filename);
+const env = process.env.NODE_ENV || 'development';
+const config = require(__dirname + '/../config/config.json')[env];
+const db = {};
+
+let sequelize;
+if (config.use_env_variable) {
+  sequelize = new Sequelize(process.env[config.use_env_variable], config);
+} else {
+  sequelize = new Sequelize(config.database, config.username, config.password, config);
+}
+
+fs
+  .readdirSync(__dirname)
+  .filter(file => {
+    return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
+  })
+  .forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
+    db[model.name] = model;
+  });
+
+Object.keys(db).forEach(modelName => {
+  if (db[modelName].associate) {
+    db[modelName].associate(db);
+  }
+});
+
+db.sequelize = sequelize;
+db.Sequelize = Sequelize;
+
+module.exports = db;

models/users.js

@@ -0,0 +1,24 @@
+'use strict';
+const {
+  Model
+} = require('sequelize');
+module.exports = (sequelize, DataTypes) => {
+  class Users extends Model {
+    /**
+     * Helper method for defining associations.
+     * This method is not a part of Sequelize lifecycle.
+     * The `models/index` file will call this method automatically.
+     */
+    static associate(models) {
+      // define association here
+    }
+  };
+  Users.init({
+    email: DataTypes.STRING,
+    password: DataTypes.STRING
+  }, {
+    sequelize,
+    modelName: 'Users',
+  });
+  return Users;
+};