# Sequelize Folder Structure

1. **<mark>Introduction</mark>**  
    When building a Node.js application using Sequelize (an ORM for interacting with SQL databases), it's common to organize the code into a structured folder system that reflects the different layers of the application. Here's a common folder structure for Sequelize CRUD (Create, Read, Update, Delete) operations,  
    i) /models  
    ii) /controllers
    
    iii) /routes  
    iv) /config  
    v) /app.js or /server.js
    
2. **<mark>/models</mark>**  
    Contains the Sequelize models, which define the structure of your database tables and the relationships between them.
    
    Each model file typically represents a database table.
    
    A common pattern is to have a `index.js` file in this folder to dynamically load and initialize all models.
    
    ```bash
    /models
      ├── user.js         # Sequelize model for 'User'
      ├── post.js         # Sequelize model for 'Post'
      └── index.js        # Initializes and exports all models
    ```
    
    ```javascript
    // user.js (Model Example)
    module.exports = (sequelize, DataTypes) => {
      const User = sequelize.define('User', {
        name: {
          type: DataTypes.STRING,
          allowNull: false
        },
        email: {
          type: DataTypes.STRING,
          allowNull: false,
          unique: true
        }
      });
      return User;
    };
    ```
    
    ```javascript
    // index.js (Model Initialization)
    const fs = require('fs');
    const path = require('path');
    const Sequelize = require('sequelize');
    const basename = path.basename(__filename);
    const env = process.env.NODE_ENV || 'development';
    const config = require(__dirname + '/../config/config.json')[env];
    const db = {};
    
    const sequelize = new Sequelize(config.database, config.username, config.password, config);
    
    fs.readdirSync(__dirname)
      .filter(file => {
        return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
      })
      .forEach(file => {
        const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
        db[model.name] = model;
      });
    
    Object.keys(db).forEach(modelName => {
      if (db[modelName].associate) {
        db[modelName].associate(db);
      }
    });
    
    db.sequelize = sequelize;
    db.Sequelize = Sequelize;
    
    module.exports = db;
    ```
    
3. **<mark>/controllers</mark>**
    
    Contains logic that responds to incoming requests and interacts with the models. This is where the CRUD operations (Create, Read, Update, Delete) happen.
    
    Each controller typically maps to a model and defines the methods for handling the operations on the corresponding table (e.g., `UserController` for the `User` model).
    
    ```bash
    /controllers
      ├── userController.js
      └── postController.js
    ```
    
    ```javascript
    // userController.js (CRUD Example)
    const { User } = require('../models');
    
    // Create a new User
    exports.createUser = async (req, res) => {
      try {
        const user = await User.create(req.body);
        res.status(201).json(user);
      } catch (error) {
        res.status(400).json({ error: error.message });
      }
    };
    
    // Get all Users
    exports.getAllUsers = async (req, res) => {
      try {
        const users = await User.findAll();
        res.status(200).json(users);
      } catch (error) {
        res.status(500).json({ error: error.message });
      }
    };
    
    // Update a User
    exports.updateUser = async (req, res) => {
      try {
        const { id } = req.params;
        const user = await User.findByPk(id);
        if (!user) {
          return res.status(404).json({ error: 'User not found' });
        }
        await user.update(req.body);
        res.status(200).json(user);
      } catch (error) {
        res.status(400).json({ error: error.message });
      }
    };
    
    // Delete a User
    exports.deleteUser = async (req, res) => {
      try {
        const { id } = req.params;
        const user = await User.findByPk(id);
        if (!user) {
          return res.status(404).json({ error: 'User not found' });
        }
        await user.destroy();
        res.status(204).json();
      } catch (error) {
        res.status(500).json({ error: error.message });
      }
    };
    ```
    
4. **<mark>/routes</mark>**  
    This folder contains the route definitions. Each route typically maps to a controller method for handling a specific HTTP request (GET, POST, PUT, DELETE).
    
    ```bash
    /routes
      ├── userRoutes.js
      └── postRoutes.js
    ```
    
    ```javascript
    // userRoutes.js (Route Example)
    const express = require('express');
    const router = express.Router();
    const userController = require('../controllers/userController');
    
    // Routes for User CRUD operations
    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;
    ```
    
5. **<mark>/config</mark>**
    
    This folder contains configuration files, such as database configurations for different environments (development, production, testing).
    
    ```bash
    /config
      └── config.json
    ```
    
    ```bash
    # config.json (Example)
    {
      "development": {
        "username": "root",
        "password": null,
        "database": "database_dev",
        "host": "127.0.0.1",
        "dialect": "mysql"
      },
      "test": {
        "username": "root",
        "password": null,
        "database": "database_test",
        "host": "127.0.0.1",
        "dialect": "mysql"
      },
      "production": {
        "username": "root",
        "password": null,
        "database": "database_prod",
        "host": "127.0.0.1",
        "dialect": "mysql"
      }
    }
    ```
    
6. **<mark>/app.js or /server.js</mark>**
    
    This file initializes the Express server, connects to the database, and loads the routes.
    
    ```javascript
    const express = require('express');
    const app = express();
    const db = require('./models');
    const userRoutes = require('./routes/userRoutes');
    
    app.use(express.json());
    app.use('/api', userRoutes);
    
    db.sequelize.sync().then(() => {
      app.listen(3000, () => {
        console.log('Server is running on port 3000');
      });
    });
    ```
    
7. **<mark>Complete Folder Structure Example</mark>**
    
    ```bash
    /my-sequelize-app
      ├── /models
      ├── /controllers
      ├── /routes
      ├── /config
      ├── /migrations (optional)
      ├── /seeders (optional)
      ├── app.js
      └── package.json
    ```
    
    This structure provides a clean separation of concerns, where models handle database interactions, controllers manage business logic, and routes define the API endpoints. This approach keeps the code modular, scalable, and easier to maintain.