Chapter 16: Advanced Sequelize

Master relationships between tables, complex queries, and transactions to build real-world databases.

One-to-One

One-to-Many

Many-to-Many

Operators

Transactions

Quiz

One-to-One Relationships

Think of a family tree. Relationships in a database work just like family relationships. A one-to-one relationship is like a person and their passport — each person has exactly one passport, and each passport belongs to exactly one person.

In Sequelize, you define one-to-one relationships using hasOne and belongsTo:

JavaScript — One-to-One: User & Profile

// models/User.js
const User = sequelize.define('User', {
    name: { type: DataTypes.STRING, allowNull: false },
    email: { type: DataTypes.STRING, unique: true }
});

// models/Profile.js
const Profile = sequelize.define('Profile', {
    bio: DataTypes.TEXT,
    avatar: DataTypes.STRING,
    website: DataTypes.STRING
});

// Define the relationship
// This adds a UserId column to the Profile table
User.hasOne(Profile);       // "A User HAS ONE Profile"
Profile.belongsTo(User);    // "A Profile BELONGS TO a User"

// CREATE a user with a profile
const user = await User.create({
    name: 'Rahul',
    email: 'rahul@example.com'
});
const profile = await Profile.create({
    bio: 'Full-stack developer',
    website: 'https://rahul.dev',
    UserId: user.id  // Links this profile to the user
});

// QUERY: Get user WITH their profile (eager loading)
const userWithProfile = await User.findOne({
    where: { id: 1 },
    include: Profile  // JOIN the Profile table
});
console.log(userWithProfile.name);         // "Rahul"
console.log(userWithProfile.Profile.bio);  // "Full-stack developer"

One-to-Many Relationships

A one-to-many relationship is like a parent and children. One parent can have many children, but each child has exactly one biological parent. In databases: one user can write many blog posts, but each post has only one author.

JavaScript — One-to-Many: User & Posts

// models/Post.js
const Post = sequelize.define('Post', {
    title: { type: DataTypes.STRING, allowNull: false },
    content: DataTypes.TEXT,
    published: { type: DataTypes.BOOLEAN, defaultValue: false }
});

// Define the relationship
// This adds a UserId column to the Post table
User.hasMany(Post);        // "A User HAS MANY Posts"
Post.belongsTo(User);      // "A Post BELONGS TO a User"

// CREATE posts for a user
await Post.create({ title: 'Learning Node.js', content: '...', UserId: 1 });
await Post.create({ title: 'Express Guide',    content: '...', UserId: 1 });
await Post.create({ title: 'React Basics',     content: '...', UserId: 1 });

// QUERY: Get user with ALL their posts
const userWithPosts = await User.findOne({
    where: { id: 1 },
    include: Post
});
console.log(userWithPosts.Posts.length);  // 3
userWithPosts.Posts.forEach(post => {
    console.log('-', post.title);
});

// QUERY: Get all published posts WITH author name
const publishedPosts = await Post.findAll({
    where: { published: true },
    include: {
        model: User,
        attributes: ['name', 'email']  // Only fetch these columns
    }
});

// QUERY: Count posts per user
const postCount = await Post.count({
    where: { UserId: 1 }
});
console.log(`User has ${postCount} posts`);

Many-to-Many Relationships

A many-to-many relationship is like students and courses. One student can enroll in many courses, and one course can have many students. To track this, you need a junction table (also called a "join table") that connects the two.

JavaScript — Many-to-Many: Posts & Tags

// models/Tag.js
const Tag = sequelize.define('Tag', {
    name: { type: DataTypes.STRING, unique: true }
});

// Junction table is created automatically by Sequelize!
// It will create a "PostTag" table with PostId and TagId columns
Post.belongsToMany(Tag, { through: 'PostTag' });
Tag.belongsToMany(Post, { through: 'PostTag' });

// CREATE tags
const jsTag = await Tag.create({ name: 'JavaScript' });
const nodeTag = await Tag.create({ name: 'Node.js' });
const reactTag = await Tag.create({ name: 'React' });

// ADD tags to a post (creates entries in PostTag junction table)
const post = await Post.findByPk(1);
await post.addTags([jsTag, nodeTag]);  // Add multiple tags at once
await post.addTag(reactTag);           // Add a single tag

// QUERY: Get post with all its tags
const postWithTags = await Post.findOne({
    where: { id: 1 },
    include: Tag
});
console.log(postWithTags.Tags.map(t => t.name));
// ["JavaScript", "Node.js", "React"]

// QUERY: Get all posts with a specific tag
const jsPosts = await Tag.findOne({
    where: { name: 'JavaScript' },
    include: Post
});
console.log(jsPosts.Posts.length);  // Number of JS-tagged posts

// REMOVE a tag from a post
await post.removeTag(reactTag);

// SET exact tags (replaces all existing)
await post.setTags([jsTag, nodeTag]);

Relationship Summary

Relationship	Example	Sequelize Methods
One-to-One	User ↔ Profile	hasOne / belongsTo
One-to-Many	User ↔ Posts	hasMany / belongsTo
Many-to-Many	Posts ↔ Tags	belongsToMany (with through table)

Sequelize Operators

Operators let you build complex queries — filtering by ranges, patterns, lists, and more.

JavaScript — Sequelize Operators

const { Op } = require('sequelize');

// COMPARISON operators
const adults = await User.findAll({
    where: { age: { [Op.gte]: 18 } }        // age >= 18
});

const teenagers = await User.findAll({
    where: { age: { [Op.between]: [13, 19] } }  // age BETWEEN 13 AND 19
});

// SEARCH with LIKE (pattern matching)
const searchResults = await Post.findAll({
    where: {
        title: { [Op.like]: '%JavaScript%' }  // Title contains "JavaScript"
    }
});

// IN operator (match any value in a list)
const specificUsers = await User.findAll({
    where: {
        id: { [Op.in]: [1, 3, 5, 7] }  // id is 1, 3, 5, or 7
    }
});

// COMBINING conditions with AND / OR
const filteredPosts = await Post.findAll({
    where: {
        [Op.and]: [
            { published: true },
            { createdAt: { [Op.gte]: new Date('2026-01-01') } }
        ]
    }
});

const searchPosts = await Post.findAll({
    where: {
        [Op.or]: [
            { title: { [Op.like]: '%Node%' } },
            { title: { [Op.like]: '%Express%' } }
        ]
    }
});

// PAGINATION & SORTING
const page1 = await Post.findAll({
    order: [['createdAt', 'DESC']],  // Newest first
    limit: 10,                        // 10 per page
    offset: 0                         // Skip 0 (page 1)
});
// Page 2 would be: offset: 10, Page 3: offset: 20, etc.

Operator Reference

Operator	SQL Equivalent	Example
`Op.eq`	=	Exact match
`Op.ne`	!=	Not equal
`Op.gt / Op.gte`	> / >=	Greater than
`Op.lt / Op.lte`	< / <=	Less than
`Op.between`	BETWEEN	Range of values
`Op.like`	LIKE	Pattern matching
`Op.in`	IN	Match any in list
`Op.and / Op.or`	AND / OR	Combine conditions

Transactions

A transaction is like a bank transfer. When you transfer $100 from Account A to Account B, two things must happen: A loses $100 AND B gains $100. If the second step fails, the first must be reversed. It is all or nothing — you never want money to disappear into thin air! Database transactions work the same way.

JavaScript — Sequelize Transactions

const { sequelize } = require('./models');

// MANAGED transaction (recommended - auto rollback on error)
async function transferMoney(fromId, toId, amount) {
    // sequelize.transaction automatically:
    // - Commits if the function succeeds
    // - Rolls back if the function throws an error
    const result = await sequelize.transaction(async (t) => {
        // 1. Deduct from sender
        const sender = await Account.findByPk(fromId, { transaction: t });
        if (sender.balance < amount) {
            throw new Error('Insufficient funds');
        }
        await sender.update(
            { balance: sender.balance - amount },
            { transaction: t }
        );

        // 2. Add to receiver
        const receiver = await Account.findByPk(toId, { transaction: t });
        await receiver.update(
            { balance: receiver.balance + amount },
            { transaction: t }
        );

        // 3. Create a transfer record
        const transfer = await Transfer.create({
            fromAccountId: fromId,
            toAccountId: toId,
            amount
        }, { transaction: t });

        return transfer;
    });
    // If we reach here, everything committed successfully!
    console.log('Transfer complete:', result.id);
}

Always use transactions when multiple database operations must succeed or fail together. Without a transaction, a crash between operations could leave your data in an inconsistent state.

📝 Chapter 16 Quiz

1. Which Sequelize methods define a one-to-one relationship?

hasMany + belongsTo

belongsToMany + through

hasOne + belongsTo

connectOne + linkTo

2. What is needed for a many-to-many relationship?

A foreign key on both tables

A junction table (through table)

A special many-to-many column type

Two hasMany declarations

3. How do you fetch a user WITH their posts in one query?

Use include: Post in findOne/findAll

Use join: Post in the where clause

Make two separate queries and merge them

Use User.withPosts()

4. Which operator finds posts with "Node" in the title?

Op.eq with 'Node'

Op.in with ['Node']

Op.contains with 'Node'

Op.like with '%Node%'

5. What happens if an error occurs inside a managed transaction?

Only the failed operation is skipped

All operations inside the transaction are rolled back

The database retries automatically

The successful operations stay committed

← Chapter 15: Authentication Chapter 17: Full Backend Project →