BLOG POSTS

MangoHost Blog / How to Use Sequelize with Node.js and MySQL

How to Use Sequelize with Node.js and MySQL

If you’ve been wrestling with raw SQL queries and feeling like you’re reinventing the wheel every time you need to interact with your MySQL database in Node.js, you’re in for a treat. This comprehensive guide will walk you through Sequelize, the most popular Object-Relational Mapping (ORM) library for Node.js that transforms your database interactions from tedious SQL strings into elegant JavaScript objects. Whether you’re setting up a new server or migrating an existing application, mastering Sequelize will dramatically reduce your development time, improve code maintainability, and provide robust data validation out of the box. We’ll cover everything from basic setup to advanced patterns, real-world gotchas, and performance considerations that’ll save you hours of debugging down the road.

How Does Sequelize Work?

Sequelize acts as a translation layer between your JavaScript application and your MySQL database. Instead of writing raw SQL queries, you define models (JavaScript classes that represent database tables) and use JavaScript methods to perform database operations. Under the hood, Sequelize generates optimized SQL queries, handles connection pooling, provides data validation, and manages relationships between tables.

The magic happens through several key components:

Models: JavaScript representations of database tables with defined attributes, data types, and validation rules
Migrations: Version-controlled database schema changes that keep your database structure in sync across environments
Seeders: Scripts that populate your database with initial or test data
Associations: Relationships between models (one-to-one, one-to-many, many-to-many)
Hooks: Lifecycle events that let you execute custom logic before or after database operations

Here’s what makes Sequelize particularly powerful: it supports connection pooling (managing multiple database connections efficiently), transaction handling, eager and lazy loading, and automatic SQL injection prevention. Plus, it works with multiple database systems (MySQL, PostgreSQL, MariaDB, SQLite, and Microsoft SQL Server), so switching databases later won’t require rewriting your entire data layer.

Step-by-Step Setup Guide

Let’s get your hands dirty with a complete setup that you can deploy on your server. I’ll assume you’re working with a fresh Node.js environment.

Step 1: Initialize Your Project and Install Dependencies

mkdir sequelize-mysql-app
cd sequelize-mysql-app
npm init -y
npm install sequelize mysql2 dotenv
npm install --save-dev sequelize-cli nodemon

Step 2: Set Up Sequelize CLI and Project Structure

npx sequelize-cli init

This creates the following directory structure:

├── config/
│   └── config.json
├── migrations/
├── models/
│   └── index.js
├── seeders/
└── package.json

Step 3: Configure Database Connection

Replace config/config.json with config/config.js for better environment variable support:

// config/config.js
require('dotenv').config();

module.exports = {
  development: {
    username: process.env.DB_USERNAME || 'root',
    password: process.env.DB_PASSWORD || '',
    database: process.env.DB_NAME || 'myapp_dev',
    host: process.env.DB_HOST || '127.0.0.1',
    port: process.env.DB_PORT || 3306,
    dialect: 'mysql',
    logging: console.log,
    pool: {
      max: 5,
      min: 0,
      acquire: 30000,
      idle: 10000
    }
  },
  production: {
    username: process.env.DB_USERNAME,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    host: process.env.DB_HOST,
    port: process.env.DB_PORT || 3306,
    dialect: 'mysql',
    logging: false,
    pool: {
      max: 20,
      min: 5,
      acquire: 60000,
      idle: 10000
    }
  }
};

Create your .env file:

# .env
DB_USERNAME=your_mysql_user
DB_PASSWORD=your_mysql_password
DB_NAME=your_database_name
DB_HOST=localhost
DB_PORT=3306

Step 4: Update models/index.js to Use the New Config

// models/index.js
'use strict';

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.js')[env];
const db = {};

let sequelize;
if (config.use_env_variable) {
  sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
  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;

Step 5: Create Your First Model and Migration

npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string,age:integer

This generates both a model file and a migration file. Let’s enhance the migration with proper constraints:

// migrations/XXXXXXXXXXXXXX-create-user.js
'use strict';
module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.createTable('Users', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      firstName: {
        type: Sequelize.STRING,
        allowNull: false,
        validate: {
          len: [2, 50]
        }
      },
      lastName: {
        type: Sequelize.STRING,
        allowNull: false,
        validate: {
          len: [2, 50]
        }
      },
      email: {
        type: Sequelize.STRING,
        allowNull: false,
        unique: true,
        validate: {
          isEmail: true
        }
      },
      age: {
        type: Sequelize.INTEGER,
        allowNull: true,
        validate: {
          min: 0,
          max: 150
        }
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
    
    await queryInterface.addIndex('Users', ['email']);
  },
  async down(queryInterface, Sequelize) {
    await queryInterface.dropTable('Users');
  }
};

Step 6: Run Migration and Test Connection

npx sequelize-cli db:create
npx sequelize-cli db:migrate

Create a simple test script (test-connection.js):

// test-connection.js
const { sequelize } = require('./models');

async function testConnection() {
  try {
    await sequelize.authenticate();
    console.log('✅ Database connection established successfully!');
    
    // Test the connection pool
    const [results, metadata] = await sequelize.query('SELECT 1 + 1 AS result');
    console.log('✅ Query test passed:', results[0].result);
    
    process.exit(0);
  } catch (error) {
    console.error('❌ Unable to connect to database:', error.message);
    process.exit(1);
  }
}

testConnection();

node test-connection.js

Real-World Examples and Use Cases

Now let’s dive into practical scenarios you’ll encounter when managing applications and servers. I’ll cover both the success stories and the gotchas that’ll save you from 3 AM debugging sessions.

Creating a Complete CRUD API

Here’s a production-ready example with proper error handling:

// routes/users.js
const express = require('express');
const { User } = require('../models');
const { ValidationError, UniqueConstraintError } = require('sequelize');
const router = express.Router();

// GET /users - List users with pagination
router.get('/', async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const offset = (page - 1) * limit;
    
    const { count, rows } = await User.findAndCountAll({
      limit,
      offset,
      order: [['createdAt', 'DESC']],
      attributes: { exclude: ['updatedAt'] } // Don't expose internal timestamps
    });
    
    res.json({
      users: rows,
      totalPages: Math.ceil(count / limit),
      currentPage: page,
      totalUsers: count
    });
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch users' });
  }
});

// POST /users - Create new user
router.post('/', async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.status(201).json(user);
  } catch (error) {
    if (error instanceof ValidationError) {
      return res.status(400).json({
        error: 'Validation failed',
        details: error.errors.map(e => ({
          field: e.path,
          message: e.message
        }))
      });
    }
    
    if (error instanceof UniqueConstraintError) {
      return res.status(409).json({
        error: 'Email already exists'
      });
    }
    
    res.status(500).json({ error: 'Failed to create user' });
  }
});

// PUT /users/:id - Update user
router.put('/:id', async (req, res) => {
  try {
    const [updatedRowsCount] = await User.update(req.body, {
      where: { id: req.params.id },
      returning: true
    });
    
    if (updatedRowsCount === 0) {
      return res.status(404).json({ error: 'User not found' });
    }
    
    const updatedUser = await User.findByPk(req.params.id);
    res.json(updatedUser);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update user' });
  }
});

module.exports = router;

Advanced Associations and Complex Queries

Let’s create a more realistic scenario with multiple related models:

// Generate models for a blog system
npx sequelize-cli model:generate --name Post --attributes title:string,content:text,userId:integer,published:boolean
npx sequelize-cli model:generate --name Comment --attributes content:text,userId:integer,postId:integer

Define associations in your models:

// models/user.js
module.exports = (sequelize, DataTypes) => {
  const User = sequelize.define('User', {
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
    email: {
      type: DataTypes.STRING,
      unique: true,
      validate: {
        isEmail: true
      }
    },
    age: DataTypes.INTEGER,
    fullName: {
      type: DataTypes.VIRTUAL,
      get() {
        return `${this.firstName} ${this.lastName}`;
      }
    }
  });
  
  User.associate = function(models) {
    User.hasMany(models.Post, { foreignKey: 'userId', as: 'posts' });
    User.hasMany(models.Comment, { foreignKey: 'userId', as: 'comments' });
  };
  
  return User;
};

// models/post.js
module.exports = (sequelize, DataTypes) => {
  const Post = sequelize.define('Post', {
    title: {
      type: DataTypes.STRING,
      allowNull: false,
      validate: {
        len: [5, 200]
      }
    },
    content: DataTypes.TEXT,
    userId: DataTypes.INTEGER,
    published: {
      type: DataTypes.BOOLEAN,
      defaultValue: false
    }
  });
  
  Post.associate = function(models) {
    Post.belongsTo(models.User, { foreignKey: 'userId', as: 'author' });
    Post.hasMany(models.Comment, { foreignKey: 'postId', as: 'comments' });
  };
  
  return Post;
};

Now for some advanced querying magic:

// Complex queries example
const { User, Post, Comment, sequelize } = require('../models');
const { Op } = require('sequelize');

// Get popular posts with author info and comment counts
async function getPopularPosts() {
  return await Post.findAll({
    where: {
      published: true,
      createdAt: {
        [Op.gte]: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) // Last 7 days
      }
    },
    include: [
      {
        model: User,
        as: 'author',
        attributes: ['firstName', 'lastName', 'email']
      },
      {
        model: Comment,
        as: 'comments',
        attributes: []
      }
    ],
    attributes: {
      include: [
        [sequelize.fn('COUNT', sequelize.col('comments.id')), 'commentCount']
      ]
    },
    group: ['Post.id', 'author.id'],
    having: sequelize.where(sequelize.fn('COUNT', sequelize.col('comments.id')), Op.gte, 5),
    order: [[sequelize.literal('commentCount'), 'DESC']],
    limit: 10
  });
}

Performance Optimization: The Good, The Bad, and The Ugly

Scenario	❌ Bad Practice	✅ Good Practice	Performance Impact
Loading related data	N+1 queries with separate finds	Use include for eager loading	~90% query reduction
Large datasets	findAll() without limits	Pagination with findAndCountAll()	Memory usage: 95% reduction
Bulk operations	Individual create() calls in loops	bulkCreate() with validate: true	~80% speed improvement
Connection management	Creating new connections per request	Connection pooling (5-20 connections)	Latency: 60% reduction

Here’s a real example of the right way to handle bulk operations:

// ❌ Don't do this - it's slow and resource-intensive
async function badBulkInsert(userData) {
  const users = [];
  for (const data of userData) {
    const user = await User.create(data); // Each create is a separate query
    users.push(user);
  }
  return users;
}

// ✅ Do this instead - much faster
async function goodBulkInsert(userData) {
  return await User.bulkCreate(userData, {
    validate: true, // Still validates each record
    ignoreDuplicates: true, // Handles unique constraint violations gracefully
    returning: true // Returns the created records (PostgreSQL only, for MySQL use findAll after)
  });
}

Transaction Handling for Data Integrity

Transactions are crucial when you’re dealing with financial data, user registrations, or any scenario where partial updates could leave your system in an inconsistent state:

// Example: User registration with profile creation
async function registerUserWithProfile(userData, profileData) {
  const transaction = await sequelize.transaction();
  
  try {
    // Create user
    const user = await User.create(userData, { transaction });
    
    // Create associated profile
    const profile = await Profile.create({
      ...profileData,
      userId: user.id
    }, { transaction });
    
    // Send welcome email (external service)
    await sendWelcomeEmail(user.email);
    
    // If we reach here, commit the transaction
    await transaction.commit();
    
    return { user, profile };
  } catch (error) {
    // Rollback transaction on any error
    await transaction.rollback();
    throw error;
  }
}

Database Monitoring and Health Checks

For server maintenance, you’ll want to monitor your database connections and performance:

// health-check.js - Perfect for load balancer health checks
const { sequelize } = require('./models');

async function databaseHealthCheck() {
  const startTime = Date.now();
  
  try {
    await sequelize.authenticate();
    const queryTime = Date.now() - startTime;
    
    // Get connection pool status
    const pool = sequelize.connectionManager.pool;
    
    return {
      status: 'healthy',
      responseTime: queryTime,
      connections: {
        active: pool.borrowed,
        idle: pool.available,
        total: pool.size
      },
      timestamp: new Date().toISOString()
    };
  } catch (error) {
    return {
      status: 'unhealthy',
      error: error.message,
      timestamp: new Date().toISOString()
    };
  }
}

// Use in Express route
app.get('/health/database', async (req, res) => {
  const health = await databaseHealthCheck();
  const statusCode = health.status === 'healthy' ? 200 : 503;
  res.status(statusCode).json(health);
});

Migration Strategies for Production

Here’s how to handle schema changes safely in production environments:

// Safe migration example - adding a column without downtime
module.exports = {
  async up(queryInterface, Sequelize) {
    // Add column as nullable first
    await queryInterface.addColumn('Users', 'subscription_tier', {
      type: Sequelize.ENUM('free', 'premium', 'enterprise'),
      allowNull: true,
      defaultValue: 'free'
    });
    
    // Update existing records in batches to avoid locking
    await queryInterface.sequelize.query(`
      UPDATE Users 
      SET subscription_tier = 'free' 
      WHERE subscription_tier IS NULL
    `);
    
    // Now make it NOT NULL
    await queryInterface.changeColumn('Users', 'subscription_tier', {
      type: Sequelize.ENUM('free', 'premium', 'enterprise'),
      allowNull: false,
      defaultValue: 'free'
    });
  },
  
  async down(queryInterface, Sequelize) {
    await queryInterface.removeColumn('Users', 'subscription_tier');
  }
};

Integration with Related Tools and Technologies

Sequelize plays well with the broader Node.js ecosystem. Here are some powerful combinations that’ll make your server management life easier:

Redis Caching Integration

npm install redis

// cache-wrapper.js
const redis = require('redis');
const client = redis.createClient(process.env.REDIS_URL);

function withCache(model, method, cacheKey, ttl = 300) {
  return async function(...args) {
    const cachedResult = await client.get(cacheKey);
    
    if (cachedResult) {
      return JSON.parse(cachedResult);
    }
    
    const result = await model[method](...args);
    await client.setex(cacheKey, ttl, JSON.stringify(result));
    
    return result;
  };
}

// Usage
const getCachedUser = withCache(User, 'findByPk', 'user:123', 600);
const user = await getCachedUser(123);

PM2 Process Management

# ecosystem.config.js for PM2
module.exports = {
  apps: [{
    name: 'sequelize-app',
    script: './app.js',
    instances: 'max',
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      DB_POOL_MAX: 20,
      DB_POOL_MIN: 5
    },
    error_file: './logs/err.log',
    out_file: './logs/out.log',
    log_file: './logs/combined.log'
  }]
};

Comparison with Other ORMs

Feature	Sequelize	TypeORM	Prisma	Raw MySQL2
Learning Curve	Moderate	Steep (TypeScript)	Easy	Complex
Performance	Good	Good	Excellent	Excellent
Migration Support	Excellent	Good	Excellent	Manual
Type Safety	Basic	Excellent	Excellent	None
Community Size	Large	Growing	Growing	Large
Bundle Size	Heavy (~2MB)	Heavy (~3MB)	Light (~500KB)	Light (~200KB)

Docker Integration for Development and Deployment

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=mysql
      - DB_NAME=myapp
      - DB_USERNAME=root
      - DB_PASSWORD=secret
    depends_on:
      - mysql
    restart: unless-stopped

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: myapp
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    restart: unless-stopped

volumes:
  mysql_data:

Deployment Script for Production Servers

# deploy.sh
#!/bin/bash
set -e

echo "🚀 Starting deployment..."

# Pull latest code
git pull origin main

# Install dependencies
npm ci --production

# Run migrations
NODE_ENV=production npx sequelize-cli db:migrate

# Run seeders if needed
# NODE_ENV=production npx sequelize-cli db:seed:all

# Restart application with PM2
pm2 restart ecosystem.config.js

# Health check
sleep 5
curl -f http://localhost:3000/health || exit 1

echo "✅ Deployment completed successfully!"

Automation and Scripting Possibilities

Sequelize opens up numerous automation opportunities that are particularly valuable for server management and maintenance tasks.

Automated Database Backups with Model Awareness

// backup-script.js
const { sequelize } = require('./models');
const fs = require('fs');
const path = require('path');

async function intelligentBackup() {
  const models = Object.keys(sequelize.models);
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const backupDir = path.join(__dirname, 'backups', timestamp);
  
  fs.mkdirSync(backupDir, { recursive: true });
  
  for (const modelName of models) {
    const Model = sequelize.models[modelName];
    const data = await Model.findAll();
    
    fs.writeFileSync(
      path.join(backupDir, `${modelName}.json`),
      JSON.stringify(data, null, 2)
    );
    
    console.log(`✅ Backed up ${data.length} records from ${modelName}`);
  }
  
  // Create schema backup
  const schemaQueries = await sequelize.query("SHOW CREATE TABLE Users", {
    type: sequelize.QueryTypes.SELECT
  });
  
  console.log(`🗄️ Backup completed: ${backupDir}`);
}

// Schedule with cron: 0 2 * * * /usr/bin/node /path/to/backup-script.js
intelligentBackup().catch(console.error);

Data Migration Scripts for Server Moves

// data-migration.js - Perfect for moving between VPS instances
const sourceSequelize = new Sequelize(/* source DB config */);
const targetSequelize = new Sequelize(/* target DB config */);

async function migrateData() {
  const batchSize = 1000;
  const models = ['User', 'Post', 'Comment']; // Define order to respect foreign keys
  
  for (const modelName of models) {
    let offset = 0;
    let batch;
    
    do {
      batch = await sourceSequelize.models[modelName].findAll({
        limit: batchSize,
        offset,
        raw: true
      });
      
      if (batch.length > 0) {
        await targetSequelize.models[modelName].bulkCreate(batch, {
          ignoreDuplicates: true
        });
        
        console.log(`Migrated ${batch.length} ${modelName} records (offset: ${offset})`);
        offset += batchSize;
      }
    } while (batch.length === batchSize);
  }
  
  console.log('🎉 Migration completed!');
}

Automated Data Validation and Cleanup

// cleanup-script.js
async function cleanupOrphanedRecords() {
  const results = {
    orphanedComments: 0,
    inactiveUsers: 0,
    duplicateEmails: 0
  };
  
  // Find orphaned comments (posts that no longer exist)
  const orphanedComments = await Comment.findAll({
    include: [{
      model: Post,
      as: 'post',
      required: false
    }],
    where: {
      '$post.id$': null
    }
  });
  
  if (orphanedComments.length > 0) {
    await Comment.destroy({
      where: {
        id: orphanedComments.map(c => c.id)
      }
    });
    results.orphanedComments = orphanedComments.length;
  }
  
  // Clean up inactive users (no login for 2 years)
  const inactiveUsers = await User.destroy({
    where: {
      lastLoginAt: {
        [Op.lt]: new Date(Date.now() - 2 * 365 * 24 * 60 * 60 * 1000)
      }
    }
  });
  results.inactiveUsers = inactiveUsers;
  
  return results;
}

For serious production deployments, you’ll want dedicated server resources to handle the database load efficiently. Check out dedicated server options for high-traffic applications, or start with a robust VPS solution for smaller to medium-scale deployments.

Common Gotchas and Troubleshooting

Let me share some painful lessons I’ve learned (often at 3 AM during production issues) so you don’t have to:

Connection Pool Exhaustion

This is the #1 issue that’ll bite you in production. Symptoms include hanging requests and “EMFILE: too many open files” errors.

// Monitor your pool usage
app.get('/debug/pool', (req, res) => {
  const pool = sequelize.connectionManager.pool;
  res.json({
    size: pool.size,
    available: pool.available,
    borrowed: pool.borrowed,
    pending: pool.pending
  });
});

// Proper connection cleanup in long-running scripts
process.on('SIGINT', async () => {
  console.log('Closing database connections...');
  await sequelize.close();
  process.exit(0);
});

Migration Rollback Strategies

// Always test your rollbacks!
npx sequelize-cli db:migrate:undo
npx sequelize-cli db:migrate:undo:all --to XXXXXXXXXXXXXX-create-user.js

Memory Leaks in Development

// Use this in development to catch memory issues early
if (process.env.NODE_ENV === 'development') {
  setInterval(() => {
    const usage = process.memoryUsage();
    console.log('Memory usage:', {
      rss: Math.round(usage.rss / 1024 / 1024) + 'MB',
      heapUsed: Math.round(usage.heapUsed / 1024 / 1024) + 'MB'
    });
  }, 30000);
}

Conclusion and Recommendations

Sequelize strikes an excellent balance between developer productivity and database performance, making it an ideal choice for most Node.js applications running on dedicated servers or VPS environments. The ORM approach significantly reduces development time—studies show teams using ORMs like Sequelize complete database-related features 40-60% faster than those writing raw SQL.

When to use Sequelize:

Building APIs or web applications with complex data relationships
Teams that prioritize development speed and code maintainability
Applications requiring database portability (switching between MySQL, PostgreSQL, etc.)
Projects with frequent schema changes during development
Medium to large applications (10K+ users) where the abstraction benefits outweigh the performance overhead

When to consider alternatives:

High-performance applications where every millisecond counts (consider raw queries or Prisma)
Simple applications with minimal database interactions (raw mysql2 might be overkill)
TypeScript-heavy projects (TypeORM or Prisma offer better type safety)
Applications requiring complex database-specific features that ORMs abstract away

Deployment recommendations:

For production deployments, I recommend starting with a VPS if you’re handling under 10,000 concurrent users, with at least 2GB RAM and SSD storage for optimal MySQL performance. As your application scales beyond 50,000 users or requires high availability, transition to dedicated server infrastructure with proper master-slave MySQL replication.

The key to Sequelize success lies in understanding its strengths and limitations. Use it for rapid development and maintainable code, but always benchmark critical queries and be prepared to drop down to raw SQL for performance-critical operations. With proper connection pooling, caching strategies, and monitoring in place, Sequelize can easily handle production workloads while keeping your codebase clean and your development team productive.

Remember: the best ORM is the one your team can use effectively in production. Sequelize’s maturity, extensive documentation, and large community make it a safe bet for most server applications. Start with the patterns I’ve shown here, monitor your performance metrics, and scale your infrastructure as your application grows.

This article incorporates information and material from various online sources. We acknowledge and appreciate the work of all original authors, publishers, and websites. While every effort has been made to appropriately credit the source material, any unintentional oversight or omission does not constitute a copyright infringement. All trademarks, logos, and images mentioned are the property of their respective owners. If you believe that any content used in this article infringes upon your copyright, please contact us immediately for review and prompt action.

This article is intended for informational and educational purposes only and does not infringe on the rights of the copyright owners. If any copyrighted material has been used without proper credit or in violation of copyright laws, it is unintentional and we will rectify it promptly upon notification. Please note that the republishing, redistribution, or reproduction of part or all of the contents in any form is prohibited without express written permission from the author and website owner. For permissions or further inquiries, please contact us.