Backend code  in routes/auth.js file code:-

const express = require('express');
const router = express.Router();
const Admin = require('../models/Admin');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');

const JWT_SECRET = process.env.JWT_SECRET;

// @route   POST /login
// @desc    Authenticate admin and return token
router.post('/', async (req, res) => {
  const { username, password } = req.body;

  try {
    const admin = await Admin.findOne({ username });
    if (!admin) return res.status(404).json({ message: 'Admin not found' });

    const isMatch = await bcrypt.compare(password, admin.password);
    if (!isMatch)
      return res.status(401).json({ message: 'Invalid credentials' });

    const token = jwt.sign({ id: admin._id }, JWT_SECRET, { expiresIn: '1h' });
    res.json({ token });
  } catch (err) {
    console.error('Login error:', err.message);
    res.status(500).json({ message: 'Server error' });
  }
});

// @route   POST /login/signup
// @desc    Create new admin
router.post('/signup', async (req, res) => {
  try {
    const { username, password } = req.body;

    if (!username || !password)
      return res
        .status(400)
        .json({ message: 'Username and password are required' });

    const existing = await Admin.findOne({ username });
    if (existing)
      return res.status(400).json({ message: 'Username already exists' });

    const hashed = await bcrypt.hash(password, 10);
    await Admin.create({ username, password: hashed });

    res.json({ message: 'Admin created' });
  } catch (err) {
    console.error('Signup error:', err);
    res.status(500).json({ message: 'Internal server error' });
  }
});

module.exports = router;


routes/record.js file code:-




✅ Optional: Update server.js for clarity
// You could do:
app.use('/auth', require('./routes/auth'));

// Then your endpoints become:
// POST /auth             → login
// POST /auth/signup      → signup




✅ routes/records.js (Full CRUD with inline controller code):-


const express = require('express');
const router = express.Router();
const Record = require('../models/Record');
const jwt = require('jsonwebtoken');

const JWT_SECRET = process.env.JWT_SECRET;

// Token verification middleware
function verifyToken(req, res, next) {
  const token = req.headers['authorization'];
  if (!token) return res.status(401).json({ message: 'No token provided' });

  jwt.verify(token, JWT_SECRET, (err, decoded) => {
    if (err) return res.status(403).json({ message: 'Invalid token' });
    req.adminId = decoded.id;
    next();
  });
}

// @route   GET /records
// @desc    Get all records
router.get('/', verifyToken, async (req, res) => {
  try {
    const records = await Record.find();
    res.json(records);
  } catch (err) {
    res.status(500).json({ message: 'Error fetching records' });
  }
});

// @route   GET /records/:id
// @desc    Get record by ID
router.get('/:id', verifyToken, async (req, res) => {
  try {
    const record = await Record.findById(req.params.id);
    if (!record) return res.status(404).json({ message: 'Record not found' });
    res.json(record);
  } catch (err) {
    res.status(400).json({ message: 'Invalid record ID' });
  }
});

// @route   POST /records
// @desc    Create a new record
router.post('/', verifyToken, async (req, res) => {
  try {
    const newRecord = new Record(req.body);
    await newRecord.save();
    res.json({ message: 'Record added', record: newRecord });
  } catch (err) {
    res.status(500).json({ message: 'Error creating record' });
  }
});

// @route   PUT /records/:id
// @desc    Update a record
router.put('/:id', verifyToken, async (req, res) => {
  try {
    const updated = await Record.findByIdAndUpdate(req.params.id, req.body, {
      new: true,
      runValidators: true,
    });
    if (!updated)
      return res.status(404).json({ message: 'Record not found' });
    res.json({ message: 'Record updated', record: updated });
  } catch (err) {
    res.status(400).json({ message: 'Invalid update request' });
  }
});

// @route   DELETE /records/:id
// @desc    Delete a record
router.delete('/:id', verifyToken, async (req, res) => {
  try {
    const deleted = await Record.findByIdAndDelete(req.params.id);
    if (!deleted)
      return res.status(404).json({ message: 'Record not found' });
    res.json({ message: 'Record deleted', record: deleted });
  } catch (err) {
    res.status(400).json({ message: 'Invalid delete request' });
  }
});

module.exports = router;



✅ server.js Reminder

Make sure you have:

app.use('/records', require('./routes/records'));


server.js file code will be :-

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const connectDB = require('./config/db');

const app = express();

// Middleware
app.use(express.json());
app.use(cors());

// Connect to MongoDB
connectDB();

// Routes
app.use('/auth', require('./routes/auth'));     // POST /auth (login), POST /auth/signup
app.use('/records', require('./routes/records'));// All CRUD operations on records (JWT protected)

// Start the server
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});



✅.env File (make sure it exists)

In the root of your project, create a file named .env:

JWT_SECRET=a1b2c3d4e5f60123456789abcdef0123456789abcdef0123456789abcdef0123