feat: add user regiteration logic

- create project skeleton
- create registration page
- create registration form
- create error page
- add authorization error handling
- add custom error handling

Author: headlessNode

.gitignore

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

app.js

@@ -2,16 +2,33 @@ const path = require('path');
 const express = require('express');
 const app = express();
 const indexRouter = require('./routes/indexRouter.js');
+const loginRouter = require('./routes/loginRouter.js');
+const registerRouter = require('./routes/registerRouter.js');
+const customErrors = require('./errors/CustomErrors.js');
+
+// EXPRESS SETUP //
 
 const assestsPath = path.join(__dirname, 'public');
 app.use(express.static(assestsPath));
-
 app.use(express.urlencoded({ extended: true }));
-
 app.set('view engine', 'ejs');
 app.set('views', path.join(__dirname, 'views'));
 
+// ROUTERS //
+
 app.use('/', indexRouter);
+app.use('/login', loginRouter);
+app.use('/register', registerRouter);
+app.use((req, res, next) => {
+    const err = new customErrors.CustomNotFoundError('This page doesnot exist.');
+    next(err);
+});
+app.use((err, req, res, next) => {
+    console.log(err);
+    res.status(err.status || 500).render('error', { err });
+});
+
+// SERVER STARTUP //
 
 app.listen(process.env.PORT || 3000, () => {
     console.log('Server started');

controllers/registerController.js

@@ -0,0 +1,83 @@
+const {body, validationResult} = require('express-validator');
+const db = require('../db/query.js');
+const asyncHandler = require('express-async-handler');
+const bcrypt = require('bcryptjs');
+const customErrors = require('../errors/CustomErrors.js');
+
+// VALIDATIONS //
+
+const validateUsername = [
+    body('username').trim().notEmpty().withMessage('Username is required'),
+    body('username').custom(async (value) => {
+        const count = await db.filterUsername(value);
+        if (count > 0) {
+            Promise.reject();
+        };
+        Promise.resolve();
+    }).withMessage('Username already exists')
+];
+
+const validatePassword = [
+    body('password')
+        .isLength({ min: 8 })
+        .withMessage('Password must be at least 8 characters long')
+        .matches(/[A-Z]/)
+        .withMessage('Password must contain at least one uppercase letter')
+        .matches(/\d/)
+        .withMessage('Password must contain at least one number'),
+    body('password').custom((value, { req }) => {
+        if (value !== req.body.verify_password) {
+            throw new Error('Passwords do not match');
+        }
+        return true;
+    })
+];
+
+
+const validateFirstName = [
+    body('first_name')
+        .trim()
+        .notEmpty()
+        .withMessage('First name is required'),
+    body('first_name')
+        .isAlpha()
+        .withMessage('First name must contain only alphabetic characters')
+];
+
+const validateLastName = [
+    body('last_name')
+        .trim()
+        .notEmpty()
+        .withMessage('Last name is required'),
+    body('last_name')
+        .isAlpha()
+        .withMessage('Last name must contain only alphabetic characters')
+];
+
+// CONTROLLER //
+
+const registerController = {
+    renderForm: asyncHandler((req, res) => {
+        res.render('register');
+    }),
+
+    registerUser: [
+        validateUsername,
+        validatePassword,
+        validateFirstName,
+        validateLastName,
+        asyncHandler( async (req, res) => {
+            const errors = validationResult(req);
+            if (errors.isEmpty()) {
+                const {username, password, first_name, last_name} = req.body;
+                const hash = await bcrypt.hash(password, 10);
+                await db.registerUser(username, hash, first_name, last_name);
+                res.redirect('/login');
+            } else {
+                res.render('register', {errors: errors.array()});
+            }
+        })
+    ]
+};
+
+module.exports = registerController;

db/pool.js

@@ -0,0 +1,6 @@
+require('dotenv').config(); 
+const {Pool} = require('pg');
+
+module.exports = new Pool({
+    connectionString: process.env.DB_URL
+});

db/populatedb.js

@@ -0,0 +1,32 @@
+const {Client} = require('pg');
+
+const SQL = `
+    CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+        username VARCHAR(255),
+        password VARCHAR(255),
+        first_name VARCHAR(255),
+        last_name VARCHAR(255),
+        is_member BOOLEAN DEFAULT FALSE
+    );
+
+    CREATE TABLE IF NOT EXISTS posts (
+        id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+        user_id INTEGER,
+        title VARCHAR(255),
+        content TEXT,
+        FOREIGN KEY (user_id) REFERENCES users(id)
+    );
+`;
+
+async function main() {
+    const client = new Client({
+        connectionString: process.argv[2],
+    });
+    await client.connect();
+    await client.query(SQL);
+    await client.end();
+    console.log('Database populated');
+};
+
+main();

db/query.js

@@ -0,0 +1,37 @@
+const pool = require('./pool.js');
+const asyncHandler = require('express-async-handler');
+
+// DB QUERIES //
+
+const filterUsername = asyncHandler(async (username) => {
+    const isTableEmpty = async () => {
+        const {rows} = await pool.query(
+            'SELECT COUNT(*) FROM users;'
+        );
+        if( rows[0].count === 0){
+            return true;
+        }
+        return false;
+    }
+    if(!isTableEmpty && username) {
+        const {rows} = await pool.query(
+            'SELECT COUNT(*) FROM users WHERE username = $1', [username]
+        );
+        return rows[0].count;
+    } else {
+        return 0;
+    }
+});
+
+const registerUser = asyncHandler(async (username, hash, first_name, last_name) => {
+    console.log(hash);
+    const result = await pool.query(
+        'INSERT INTO users (username, password, first_name, last_name) VALUES ($1, $2, $3, $4)', [username, hash, first_name, last_name]
+    );
+    console.log(result);
+});
+
+module.exports = {
+    filterUsername,
+    registerUser
+};

errors/CustomErrors.js

@@ -0,0 +1,20 @@
+class CustomNotFoundError extends Error {
+    constructor(message){
+        super(message);
+        this.status = 404;
+        this.name = "NotFoundError";
+    }
+}
+
+class HashingFailed extends Error {
+    constructor(message){
+        super(message);
+        this.status = 500;
+        this.name = "HashingFailed";
+    }
+}
+
+module.exports = {
+    CustomNotFoundError,
+    HashingFailed
+}

package-lock.json

@@ -10,9 +10,13 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "dotenv": "^16.4.5",
     "ejs": "^3.1.10",
     "express": "^4.21.1",
+    "express-async-handler": "^1.2.0",
     "express-session": "^1.18.1",
+    "express-validator": "^7.2.0",
     "passport": "^0.7.0",
     "passport-local": "^1.0.0",
     "pg": "^8.13.1"