Create Backend using NODE, EXPRESS, MONGODB

FileSystem

server>

     -databse 

     -model

     -router

     -src

src>

    -app.js

    -config.env

db>

    -conn.js

model>

    -userSchema.js

router>

    -auth.js

src/app.js

const express = require("express");
const app = express();
const User = require("../model/userSchema");
const authRoute = require("../router/auth");
require("../db/conn");
const port = process.env.PORT || 8000;
app.use(express.json());
app.use(authRoute);

// middleware
const middleware = (req, res, next) => {
    console.log("hello, i'm middleware");
    next();
}
app.get("/about", middleware, (req, res) => {
    res.send("about")
})
app.get("/contact", (req, res) => {
    res.send("contact")
})
app.get("/signin", (req, res) => {
    res.cookie("Test", "shreyash Kolhe");
    res.send("this is login page")
})
app.get("/signup", (req, res) => {
    res.send("resister")
})
app.listen(port, () => {
    console.log(`listening...${port}`);
})

src/config.eng

DATABASE='mongodb://s510:s510@cluster0-shard-00-01.x
SECRET_KEY=LKAJSDFLKJADSLFKJALDJFSLJADLKJADSA

Model/userSchema.js

const mongoose = require("mongoose");
const bcrypt = require('bcryptjs');
const jwt = require("jsonwebtoken");
// const dotenv = require("dotenv");
// dotenv.config({path: './src/config.env'});
const userSchema = new mongoose.Schema({
    name: {
        type: String,
        required: true
    },
    email: {
        type: String,
        required: true
    },
    phone: {
        type: Number,
        required: true
    },
    work: {
        type: String,
        required: true
    },
    password: {
        type: String,
        required: true
    },
    cpassword: {
        type: String,
        required: true
    },
    tokens: [{
        token: {
            type: String,
            required: true
        }
    }]
})
// password hashing 
userSchema.pre('save', async function (next) {
    // console.log("hii... from the outside");
    if (this.isModified('password')) {
        // console.log('password decrypt successfully')
        this.password = await bcrypt.hash(this.password, 12);
        this.cpassword = await bcrypt.hash(this.cpassword, 12);
    }
    next();
})
// generating token
userSchema.methods.generateAuthToken = async function() {
    try {
        let newToken = jwt.sign({ _id: this._id }, process.env.SECRET_KEY);
    
        this.tokens = this.tokens.concat({ token: newToken });
        await this.save();
        return newToken;
    } catch (e) {
        console.log(e);
    }
}
const User = mongoose.model('USER', userSchema);
module.exports = User;

db/conn.js

const mongoose = require('mongoose');
const dotenv = require("dotenv");
dotenv.config({path: './src/config.env'});
const db = process.env.DATABASE;
mongoose.connect(db, {
    useNewUrlParser: true,
    // useCreateIndex: true,
    useUnifiedTopology: true,
    // useFindAndModify: false
}).then(() => {
    console.log("connection successful")
}).catch((err) => {
    console.log(err)
})

router/auth.js

const jwt = require("jsonwebtoken");
const express = require("express");
const router = express.Router();
const bcrypt = require('bcryptjs');
require("../db/conn");
const User = require("../model/userSchema");
router.get("/", (req, res) => {
    res.send("hello router")
});
// user registration 
router.post("/register", async (req, res) => {
    const { name, email, phone, work, password, cpassword } = req.body;
    if (!name || !email || !phone || !work || !password || !cpassword) {
        return res.status(422).json({ error: "plz filled the field properly" });
    }
    try {
        const userExist = await User.findOne({ email: email })
        if (userExist) {
            return res.status(422).json({
                error: "email already exist"
            });
        }
        const user = new User({ name, email, phone, work, password, cpassword })
        const userResister = await user.save();
        if (userResister) {
            return res.status(201).json({
                message: "user registered successfully"
            });
        } else {
            res.status(500).json({ error: "failed to register" })
        }
    } catch (err) {
        console.log(err)
    }
});
// user login 
router.post("/login", async (req, res) => {
    try {
        const { email, password } = req.body;
        if (!email || !password) {
            return res.status(400).json({ error: "Plz fill the data" });
        }
        const userLogin = await User.findOne({ email: email })
        // console.log(userLogin);
        if (userLogin) {
            const isMatch = await bcrypt.compare(password, userLogin.password);
            const token = await userLogin.generateAuthToken();
            console.log(token);
            res.cookie("jwtoken", token, {
                expires: new Date(Date.now()+25892000000),
                httpOnly: true
            });
            
            
            if (!isMatch) {
                res.json({ error: "invalid email" })
            } else {
                res.json({ message: "User signin Successfully" })
            }
        } else {
            res.status(400).json({ error: "Invalid creadients" });
        }
    } catch (err) {
        console.log(err)
    }
})
module.exports = router;