myapi/
│── node_modules/ # Dependencies
│── uploads/ # Uploaded images (auto-created)
│── config/
│ ├── config.json # Database configuration
│── models/
│ ├── index.js # Sequelize setup
│ ├── user.js # User model
│── migrations/
│── controllers/
│ ├── userController.js # User API logic
│── routes/
│ ├── userRoutes.js # User routes
│── middleware/
│ ├── upload.js # Multer file upload configuration
│── .env # Environment variables
│── .gitignore # Ignore unnecessary files
│── package.json # Project dependencies
│── package-lock.json # Locked dependencies
│── server.js # Main entry point

//table creation
USE mydb;

CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100),
email VARCHAR(100) UNIQUE,
password VARCHAR(255),
photo VARCHAR(255),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE customers (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100),
phone VARCHAR(15),
email VARCHAR(100) UNIQUE,
address TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

//
mkdir myapi && cd myapi
npm init -y

//
npm install express mysql2 sequelize bcryptjs jsonwebtoken multer dotenv body-parser cors

//set-up ORM
npx sequelize-cli init

//config.json
{
"development": {
"username": "root",
"password": "",
"database": "mydb",
"host": "127.0.0.1",
"dialect": "mysql"
}
}
//create model
npx sequelize-cli model:generate --name User --attributes name:string,email:string,password:string,photo:string
//migrate databse
npx sequelize-cli db:migrate

//server.js
require("dotenv").config();
const express = require("express");
const bodyParser = require("body-parser");
const cors = require("cors");
const userRoutes = require("./routes/userRoutes");

const app = express();

app.use(cors());
app.use(bodyParser.json());
app.use("/uploads", express.static("uploads")); // Serve uploaded images
app.use("/users", userRoutes);

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

//user-route
const express = require("express");
const { register, login, getUsers, updateUser, deleteUser, forgotPassword } = require("../controllers/userController");
const upload = require("../middleware/upload");

const router = express.Router();

router.get("/", getUsers);
router.post("/register", upload.single("photo"), register);
router.post("/login", login);
router.put("/:id", upload.single("photo"), updateUser);
router.delete("/:id", deleteUser);
router.post("/forgot-password", forgotPassword);

module.exports = router;

//cantroller
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");
const { User } = require("../models");

exports.getUsers = async (req, res) => {
try {
const users = await User.findAll();
res.json(users);
} catch (err) {
res.status(500).json({ error: err.message });
}
};

exports.register = async (req, res) => {
try {
const { name, email, password } = req.body;
const hashedPassword = await bcrypt.hash(password, 10);
const photo = req.file ? req.file.path : null;

    const user = await User.create({ name, email, password: hashedPassword, photo });
    res.status(201).json(user);
} catch (err) {
    res.status(500).json({ error: err.message });
}

};

exports.login = async (req, res) => {
try {
const { email, password } = req.body;
const user = await User.findOne({ where: { email } });

    if (!user) return res.status(404).json({ message: "User not found" });

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

    const token = jwt.sign({ id: user.id }, "secret", { expiresIn: "1h" });
    res.json({ token, user });
} catch (err) {
    res.status(500).json({ error: err.message });
}

};

exports.updateUser = async (req, res) => {
try {
const { id } = req.params;
const { name, email } = req.body;
const photo = req.file ? req.file.path : null;

    const user = await User.findByPk(id);
    if (!user) return res.status(404).json({ message: "User not found" });

    await user.update({ name, email, photo });
    res.json(user);
} catch (err) {
    res.status(500).json({ error: err.message });
}

};

exports.deleteUser = async (req, res) => {
try {
const { id } = req.params;
const user = await User.findByPk(id);
if (!user) return res.status(404).json({ message: "User not found" });

    await user.destroy();
    res.json({ message: "User deleted successfully" });
} catch (err) {
    res.status(500).json({ error: err.message });
}

};

exports.forgotPassword = async (req, res) => {
try {
const { email, newPassword } = req.body;
const user = await User.findOne({ where: { email } });

    if (!user) return res.status(404).json({ message: "User not found" });

    const hashedPassword = await bcrypt.hash(newPassword, 10);
    await user.update({ password: hashedPassword });

    res.json({ message: "Password reset successful" });
} catch (err) {
    res.status(500).json({ error: err.message });
}

};

//middleware upload
const multer = require("multer");

const storage = multer.diskStorage({
destination: (req, file, cb) => {
cb(null, "uploads/");
},
filename: (req, file, cb) => {
cb(null, Date.now() + "-" + file.originalname);
}
});

const upload = multer({ storage });
module.exports = upload;

//model index.js
const { Sequelize, DataTypes } = require("sequelize");
const config = require("../config/config.json")["development"];

const sequelize = new Sequelize(config.database, config.username, config.password, {
host: config.host,
dialect: config.dialect
});

const db = {};
db.sequelize = sequelize;
db.Sequelize = Sequelize;

// Import models
db.User = require("./user")(sequelize, DataTypes);

module.exports = db;

//model-usermigration.js
module.exports = {
up: async (queryInterface, Sequelize) => {
await queryInterface.createTable("Users", {
id: {
allowNull: false,
autoIncrement: true,
primaryKey: true,
type: Sequelize.INTEGER
},
name: {
type: Sequelize.STRING,
allowNull: false
},
email: {
type: Sequelize.STRING,
allowNull: false,
unique: true
},
password: {
type: Sequelize.STRING,
allowNull: false
},
photo: {
type: Sequelize.STRING
},
createdAt: {
allowNull: false,
type: Sequelize.DATE,
defaultValue: Sequelize.literal("CURRENT_TIMESTAMP")
},
updatedAt: {
allowNull: false,
type: Sequelize.DATE,
defaultValue: Sequelize.literal("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
}
});
},

down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable("Users");
}

};

//model user.js
module.exports = (sequelize, DataTypes) => {
const User = sequelize.define("User", {
name: {
type: DataTypes.STRING,
allowNull: false
},
email: {
type: DataTypes.STRING,
allowNull: false,
unique: true
},
password: {
type: DataTypes.STRING,
allowNull: false
},
photo: {
type: DataTypes.STRING
}
});

return User;

};
//
module.exports = (sequelize, DataTypes) => {
return sequelize.define("User", {
name: { type: DataTypes.STRING, allowNull: false },
email: { type: DataTypes.STRING, allowNull: false, unique: true },
password: { type: DataTypes.STRING, allowNull: false },
photo: { type: DataTypes.STRING }
}, { timestamps: true });
};

//

Node.js dependencies

node_modules/
npm-debug.log
yarn-error.log

Environment variables

.env

Logs

logs/
.log
npm-debug.log
yarn-debug.log*
yarn-error.log*

Database files

*.sqlite
*.sqlite-journal

Uploaded images

uploads/

IDE and OS files

.vscode/
.DS_Store
Thumbs.db