Forem: M Ahsan Hameed

Building a Scalable Node.Js Backend: Sequelize Models, CRUD Operations & Clean Architecture

M Ahsan Hameed — Wed, 04 Jun 2025 19:58:25 +0000

How to Set Up a Node.js Express App with Sequelize and AWS MySQL RDS + Source Code

Two Ways to Get Started:

1️⃣ Follow the step-by-step guide in the tutorial above.
2️⃣ Download the source code and practice at your own pace.

🚀 An exciting journey awaits—let’s begin!

Introduction

In this post, we will:

Define Sequelize models for User and Post tables.
Set up the routes, controllers, and services to handle CRUD operations.
Maintain a clean and scalable code structure by separating concerns into different folders.

Let’s dive in and organize our code to make it more maintainable!

Step 1: Define Sequelize Models (Tables)

Sequelize models represent the structure of the database tables. Let’s start by defining the models for User and Post.

1.1. Create the User Model

In the models folder, create a file named User.js:

// src/models/User.js
const { DataTypes } = require('sequelize');
const sequelize = require('../db');

const User = sequelize.define('User', {
  id: {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  },
  username: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
  },
});

module.exports = User;

This model defines the User table with id, username, and email fields.

1.2. Create the Post Model

Next, create a Post.js file in the models folder:

// src/models/Post.js
const { DataTypes } = require('sequelize');
const sequelize = require('../db');
const User = require('./User');  // Reference to User model

const Post = sequelize.define('Post', {
  id: {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true,
  },
  title: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  content: {
    type: DataTypes.TEXT,
    allowNull: false,
  },
});

// Define relationship: One User has many Posts
Post.belongsTo(User, { foreignKey: 'userId' });

module.exports = Post;

This defines the Post model with title, content, and a relationship to the User model.

Step 2: Create Routes, Controllers, and Services

To maintain clean and scalable code, we will separate the application logic into routes, controllers, and services.

2.1. Folder Structure

Let’s organize the folders as follows:

/src
  /controllers
    userController.js
    postController.js
  /routes
    userRoutes.js
    postRoutes.js
  /services
    userService.js
    postService.js
  /models
    User.js
    Post.js
  app.js

2.2. Create Services for Business Logic

The service layer will handle the actual business logic, such as interacting with the database.

userService.js
Create the services/userService.js file:

// services/userService.js
const User = require('../models/User');

const createUser = async (username, email) => {
  const user = await User.create({ username, email });
  return user;
};

const getAllUsers = async () => {
  const users = await User.findAll();
  return users;
};

const getUserById = async (id) => {
  const user = await User.findByPk(id);
  return user;
};

const updateUser = async (id, username, email) => {
  const user = await User.findByPk(id);
  if (user) {
    user.username = username;
    user.email = email;
    await user.save();
    return user;
  }
  return null;
};

const deleteUser = async (id) => {
  const user = await User.findByPk(id);
  if (user) {
    await user.destroy();
    return true;
  }
  return false;
};

module.exports = {
  createUser,
  getAllUsers,
  getUserById,
  updateUser,
  deleteUser,
};
postService.js
Create the services/postService.js file:

javascript
Copy
// services/postService.js
const Post = require('../models/Post');

const createPost = async (title, content, userId) => {
  const post = await Post.create({ title, content, userId });
  return post;
};

const getAllPosts = async () => {
  const posts = await Post.findAll();
  return posts;
};

const getPostById = async (id) => {
  const post = await Post.findByPk(id);
  return post;
};

const updatePost = async (id, title, content) => {
  const post = await Post.findByPk(id);
  if (post) {
    post.title = title;
    post.content = content;
    await post.save();
    return post;
  }
  return null;
};

const deletePost = async (id) => {
  const post = await Post.findByPk(id);
  if (post) {
    await post.destroy();
    return true;
  }
  return false;
};

module.exports = {
  createPost,
  getAllPosts,
  getPostById,
  updatePost,
  deletePost,
};
2.3. Create Controllers for Handling Requests
The controller layer will handle HTTP requests and interact with the services.

userController.js
Create the controllers/userController.js file:

javascript
Copy
// controllers/userController.js
const userService = require('../services/userService');

const createUser = async (req, res) => {
  const { username, email } = req.body;
  try {
    const user = await userService.createUser(username, email);
    res.status(201).json(user);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const getAllUsers = async (req, res) => {
  try {
    const users = await userService.getAllUsers();
    res.status(200).json(users);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const updateUser = async (req, res) => {
  const { id } = req.params;
  const { username, email } = req.body;
  try {
    const user = await userService.updateUser(id, username, email);
    if (user) {
      res.status(200).json(user);
    } else {
      res.status(404).json({ message: 'User not found' });
    }
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const deleteUser = async (req, res) => {
  const { id } = req.params;
  try {
    const success = await userService.deleteUser(id);
    if (success) {
      res.status(200).json({ message: 'User deleted' });
    } else {
      res.status(404).json({ message: 'User not found' });
    }
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

module.exports = {
  createUser,
  getAllUsers,
  updateUser,
  deleteUser,
};

postController.js
Create the controllers/postController.js file:

// controllers/postController.js
const postService = require('../services/postService');

const createPost = async (req, res) => {
  const { title, content, userId } = req.body;
  try {
    const post = await postService.createPost(title, content, userId);
    res.status(201).json(post);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const getAllPosts = async (req, res) => {
  try {
    const posts = await postService.getAllPosts();
    res.status(200).json(posts);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const updatePost = async (req, res) => {
  const { id } = req.params;
  const { title, content } = req.body;
  try {
    const post = await postService.updatePost(id, title, content);
    if (post) {
      res.status(200).json(post);
    } else {
      res.status(404).json({ message: 'Post not found' });
    }
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const deletePost = async (req, res) => {
  const { id } = req.params;
  try {
    const success = await postService.deletePost(id);
    if (success) {
      res.status(200).json({ message: 'Post deleted' });
    } else {
      res.status(404).json({ message: 'Post not found' });
    }
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

module.exports = {
  createPost,
  getAllPosts,
  updatePost,
  deletePost,
};

2.4. Create Routes for the API

Now, let's define the routes to connect the controllers to our app.

userRoutes.js
Create the routes/userRoutes.js file:

// routes/userRoutes.js
const express = require('express');
const userController = require('../controllers/userController');
const router = express.Router();

router.post('/users', userController.createUser);
router.get('/users', userController.getAllUsers);
router.put('/users/:id', userController.updateUser);
router.delete('/users/:id', userController.deleteUser);

module.exports = router;
postRoutes.js
Create the routes/postRoutes.js file:

javascript
Copy
// routes/postRoutes.js
const express = require('express');
const postController = require('../controllers/postController');
const router = express.Router();

router.post('/posts', postController.createPost);
router.get('/posts', postController.getAllPosts);
router.put('/posts/:id', postController.updatePost);
router.delete('/posts/:id', postController.deletePost);

module.exports = router;

Step 3: Set Up Express Application and Routes

Finally, let’s bring everything together in the app.js file:

// app.js
const express = require('express');
const sequelize = require('./db');
const userRoutes = require('./routes/userRoutes');
const postRoutes = require('./routes/postRoutes');

const app = express();
const port = 3000;

app.use(express.json());
app.use(userRoutes);
app.use(postRoutes);

sequelize.authenticate().then(() => {
  console.log('Database connected successfully!');
}).catch((error) => {
  console.error('Unable to connect to the database:', error);
});

sequelize.sync({ force: true }).then(() => {
  console.log('Database synced');
});

app.listen(port, () => {
  console.log(`App running at http://localhost:${port}`);
});

Step 4: Test Your CRUD Endpoints

Now that we’ve defined the models and set up CRUD operations, let’s test everything using Postman or cURL:

POST /users: Create a new user.
GET /users: Get all users.
PUT /users/🆔 Update a user by id.
DELETE /users/🆔 Delete a user by id.
POST /posts: Create a new post.
GET /posts: Get all posts.

DOWNLOAD SOURCE CODE 'crud' BRANCH

Conclusion

In this post, we’ve:

Defined Sequelize models for User and Post.
Created routes, controllers, and services to handle CRUD operations.
Structured the code into separate folders for routes, controllers, and services to maintain a clean and scalable architecture.

In the next post, we’ll explore authentication, authorization, and deployment.

How to Set Up a Node.js Express App with Sequelize and AWS MySQL RDS + Source Code

M Ahsan Hameed — Mon, 02 Jun 2025 00:20:00 +0000

Let's Start

Introduction

In this post, we will start our journey of building a Node.js application using Express and Sequelize ORM, while connecting it to an AWS MySQL RDS (Free Tier) database. By the end of this post, we’ll have:

A basic Node.js Express app.
A connection to a MySQL database hosted on AWS RDS.
A working environment with Sequelize ORM to interact with the database.

Let’s dive into it!

Step 1: Setting Up Your Node.js Project

1.1. Install Node.js

Before we begin, make sure you have Node.js installed. If you don’t have it yet, download it from the official website: Node.js Download.

1.2. Initialize a New Node.js Project

Now, let's create a directory for our project and initialize it with npm:

mkdir node-express-mysql
cd node-express-mysql
npm init -y

The -y flag automatically accepts the default settings for your package.json file.

1.3. Install Required Dependencies

Next, let’s install the necessary libraries for our project:

express: A minimalist web framework for Node.js.
sequelize: An ORM for interacting with the database.
mysql2: MySQL client for Sequelize.
dotenv: For managing environment variables securely.

Run the following command to install these dependencies:

npm install express sequelize mysql2 dotenv

Step 2: Set Up Your AWS MySQL RDS Database

2.1. Create a MySQL RDS Instance

Log in to your AWS Management Console.
Go to RDS and click Create database.
Choose MySQL as the database engine.
For DB Instance Identifier, set a name for your database (e.g., my-mysql-db).
Set Master Username and Master Password.
Under Settings, choose the Free Tier option for cost-saving.
Set up the VPC security group to allow inbound traffic from your IP address (make sure you can access it remotely).
Note down the Endpoint, Master Username, and Password once the instance is ready.

2.2. Configure Security Group

After creating your RDS instance, configure the VPC Security Group to allow inbound connections from your local IP. This step ensures that you can access the database from your Node.js application.

Step 3: Set Up Sequelize to Connect to MySQL

3.1. Create a .env File

We will use the dotenv package to securely store our database credentials. Create a .env file in the root of your project:

DB_HOST=your-mysql-db-instance-name.rds.amazonaws.com
DB_USER=admin
DB_PASSWORD=yourpassword
DB_NAME=yourdbname
DB_DIALECT=mysql

Replace the values with your actual database details.

3.2. Sequelize Configuration

Create a file called db.js for configuring the Sequelize connection to your MySQL database.

// db.js
require('dotenv').config();
const { Sequelize } = require('sequelize');

// Set up Sequelize connection
const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, {
  host: process.env.DB_HOST,
  dialect: process.env.DB_DIALECT,
});

module.exports = sequelize;

This file will use the environment variables from the .env file to establish a connection to the MySQL database.

Step 4: Create Your Express Application

4.1. Set Up the Basic Express App

Now let’s create a basic Express app in app.js.

// app.js
const express = require('express');
const sequelize = require('./db');
require('dotenv').config();

const app = express();
const port = 3000;

app.use(express.json());

// Test DB Connection
sequelize.authenticate()
  .then(() => console.log('Database connected successfully!'))
  .catch((error) => console.error('Unable to connect to the database:', error));

app.listen(port, () => {
  console.log(`App running at http://localhost:${port}`);
});

4.2. Test Database Connection

In the above code:

We initialize Express and set it up to listen on port 3000.

We use Sequelize's authenticate method to verify if we can successfully connect to the MySQL database.

If the connection is successful, we’ll see "Database connected successfully!" in the terminal.

4.3. Run the Application

Start the application by running:

node app.js
You should see:

App running at http://localhost:3000
Database connected successfully!

If you see "Database connected successfully!", it means your connection to the MySQL database hosted on AWS RDS is working!

DOWNLOAD SOURCE CODE

Conclusion

In this first post of our learning journey, we’ve:

Set up a Node.js Express application.
Connected it to a MySQL RDS database using Sequelize ORM.
Tested the connection to ensure everything is working smoothly.

In the next post, we’ll move on to creating Sequelize models, define our database tables, and perform basic CRUD operations (Create, Read, Update, Delete).

Next Post Preview

We will define Sequelize models (tables) for our app.
We’ll dive into CRUD operations using Sequelize.

Stay tuned for the next post, and feel free to drop any questions or feedback below!

Build A Hello World API With Node.js And Express.Js + Postman

M Ahsan Hameed — Sun, 04 Sep 2022 02:06:48 +0000

Getting Started

To get started create a new folder on any directory and call it hello_world.

$ mkdir hello_world

To move to that folder use this command.

$ cd hello_world

In your hello_world folder create a new file called app.js

$ touch app.js

The next step for us to do is to install Node. You can install node here.

We are close to create the app.

After node has been installed then we’ll install express with npm. Node comes with npm so we won’t need to install npm.

npm init

Click the return key repeatedly for every questions asked of you on the command line.

Install Dependencies

npm install express —-save

Setup The App And Create Our First Endpoint

Now let’s get started creating our hello_world API in the app.js file.

const express = require('express'); const app = express();

Setting Server Port

Add more code in our app.js file.

const port =8000; app.listen(port,()=> { console.log(Server is listening on port ${port}); })

Create API

Let's start writing code for our first API.

app.get('/hello_world', (req, res)=>{ res.send('Hello World'); })

get shows the HTTP GET
First parameter is our API path
Second parameter a callback function
Callback function first request shorthand req
Callback function first response shorthand res

Start Server

Hurrah...! We are just created the server with hello world API next step is pretty easy to start the server run that command.

$ npm start

Check postman

Pretty Easy Congrats you tested it....?

Forem: M Ahsan Hameed

Building a Scalable Node.Js Backend: Sequelize Models, CRUD Operations & Clean Architecture

How to Set Up a Node.js Express App with Sequelize and AWS MySQL RDS + Source Code

Two Ways to Get Started:

Introduction

Step 1: Define Sequelize Models (Tables)

1.1. Create the User Model

1.2. Create the Post Model

Step 2: Create Routes, Controllers, and Services

2.1. Folder Structure

2.2. Create Services for Business Logic

2.4. Create Routes for the API

Step 3: Set Up Express Application and Routes

Step 4: Test Your CRUD Endpoints

Conclusion

How to Set Up a Node.js Express App with Sequelize and AWS MySQL RDS + Source Code

Let's Start

Introduction

Step 1: Setting Up Your Node.js Project

1.1. Install Node.js

1.2. Initialize a New Node.js Project

1.3. Install Required Dependencies

Step 2: Set Up Your AWS MySQL RDS Database

2.1. Create a MySQL RDS Instance

2.2. Configure Security Group

Step 3: Set Up Sequelize to Connect to MySQL

3.1. Create a .env File

3.2. Sequelize Configuration

Step 4: Create Your Express Application

4.1. Set Up the Basic Express App

4.2. Test Database Connection

4.3. Run the Application

Conclusion

Next Post Preview

Build A Hello World API With Node.js And Express.Js + Postman

Getting Started

Install Dependencies

Setup The App And Create Our First Endpoint

Setting Server Port

Create API

Start Server

Check postman

Follow For more update and stay connected