Express Database Seeding

Introduction

Database seeding is the process of populating a database with initial data. This is particularly useful during development and testing phases of your application, where having consistent test data can help you verify your application's functionality. Seeding is also beneficial when deploying applications to production, ensuring that necessary default data (like admin users, configuration settings, or starter content) is available from the start.

In this tutorial, we'll learn how to implement database seeding in Express.js applications. We'll cover various approaches and best practices to ensure your database always has the data you need when you need it.

Why Seed Your Database?

Before diving into the implementation, let's understand why database seeding is important:

Development Consistency: Ensures all developers work with the same initial dataset
Testing Reliability: Provides predictable data for automated tests
Demo-ready Applications: Makes your application immediately functional for demonstrations
Production Defaults: Sets up required initial data when deploying to production (like admin accounts)
Data Recovery: Helps restore essential data if needed

Basic Database Seeding in Express

Let's start with a simple approach to database seeding in an Express application. We'll create a script that can be run independently to populate our database.

Step 1: Creating a Seed Script

First, let's create a directory structure for our seed scripts:

project-root/
├── src/
│   ├── models/
│   │   └── User.js
│   ├── seeds/
│   │   └── userSeeder.js
│   └── seedRunner.js
├── app.js
└── package.json

Step 2: Define Your Seeder

Let's create a simple user model and seeder for MongoDB using Mongoose:

javascript
// src/models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  role: { type: String, enum: ['user', 'admin'], default: 'user' },
  createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('User', userSchema);

Now, let's write our seeder file:

javascript
// src/seeds/userSeeder.js
const User = require('../models/User');
const bcrypt = require('bcrypt');

const seedUsers = async () => {
  try {
    // Clear existing users
    await User.deleteMany({});
    
    // Generate hashed passwords
    const salt = await bcrypt.genSalt(10);
    const adminPassword = await bcrypt.hash('admin123', salt);
    const userPassword = await bcrypt.hash('user123', salt);
    
    // Create seed data
    const users = [
      {
        username: 'admin',
        email: '[email protected]',
        password: adminPassword,
        role: 'admin'
      },
      {
        username: 'user1',
        email: '[email protected]',
        password: userPassword,
        role: 'user'
      },
      {
        username: 'user2',
        email: '[email protected]',
        password: userPassword,
        role: 'user'
      }
    ];
    
    // Insert users
    const result = await User.insertMany(users);
    console.log(`${result.length} users seeded successfully!`);
    return result;
  } catch (error) {
    console.error('Error seeding users:', error);
    throw error;
  }
};

module.exports = seedUsers;

Step 3: Create a Runner Script

Let's create a runner script to execute all our seeders:

javascript
// src/seedRunner.js
const mongoose = require('mongoose');
require('dotenv').config();

// Import seeders
const seedUsers = require('./seeds/userSeeder');

// Connect to database
mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/my_database')
  .then(() => console.log('MongoDB connected for seeding'))
  .catch(err => console.error('MongoDB connection error:', err));

// Run all seeders
const runSeeders = async () => {
  try {
    await seedUsers();
    console.log('All seeders completed successfully!');
    process.exit(0);
  } catch (error) {
    console.error('Error running seeders:', error);
    process.exit(1);
  }
};

runSeeders();

Step 4: Add Script to Package.json

Add a script to your package.json to easily run the seeder:

json
{
  "scripts": {
    "start": "node app.js",
    "seed": "node src/seedRunner.js"
  }
}

Now you can run npm run seed to populate your database with the initial data.

Advanced Seeding Techniques

Let's explore more advanced techniques for database seeding.

Environment-Specific Seeding

Often, you'll want different seed data for different environments (development, testing, production). Let's modify our approach to handle this:

javascript
// src/seedRunner.js
const mongoose = require('mongoose');
require('dotenv').config();

// Import seeders
const seedUsers = require('./seeds/userSeeder');
const seedDevData = require('./seeds/devDataSeeder');
const seedTestData = require('./seeds/testDataSeeder');

// Get current environment
const environment = process.env.NODE_ENV || 'development';

// Connect to database
mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/my_database')
  .then(() => console.log(`MongoDB connected for seeding in ${environment} environment`))
  .catch(err => console.error('MongoDB connection error:', err));

// Run all seeders
const runSeeders = async () => {
  try {
    // Always seed essential data (like admin users)
    await seedUsers();
    
    // Seed environment-specific data
    if (environment === 'development') {
      await seedDevData();
    } else if (environment === 'test') {
      await seedTestData();
    }
    
    console.log(`Seeding for ${environment} environment completed successfully!`);
    process.exit(0);
  } catch (error) {
    console.error('Error running seeders:', error);
    process.exit(1);
  }
};

runSeeders();

Seeding with Relationships

When your data has relationships, you need to ensure that related data is seeded correctly. Here's an example with users and posts:

javascript
// src/seeds/postSeeder.js
const Post = require('../models/Post');
const User = require('../models/User');

const seedPosts = async () => {
  try {
    // Clear existing posts
    await Post.deleteMany({});
    
    // Get users to associate posts with
    const users = await User.find();
    
    if (users.length === 0) {
      throw new Error('No users found. Please seed users first.');
    }
    
    // Create seed data
    const posts = [];
    
    // Create posts for each user
    for (const user of users) {
      posts.push(
        {
          title: `First post by ${user.username}`,
          content: 'This is my first post content. Lorem ipsum dolor sit amet.',
          author: user._id
        },
        {
          title: `Second post by ${user.username}`,
          content: 'This is my second post content. Consectetur adipiscing elit.',
          author: user._id
        }
      );
    }
    
    // Insert posts
    const result = await Post.insertMany(posts);
    console.log(`${result.length} posts seeded successfully!`);
    return result;
  } catch (error) {
    console.error('Error seeding posts:', error);
    throw error;
  }
};

module.exports = seedPosts;

Then in your seedRunner.js, make sure to run the seeders in the correct order:

javascript
const runSeeders = async () => {
  try {
    // Seed users first since posts depend on them
    await seedUsers();
    await seedPosts();
    
    console.log('All seeders completed successfully!');
    process.exit(0);
  } catch (error) {
    console.error('Error running seeders:', error);
    process.exit(1);
  }
};

Using Faker for Realistic Data

For more realistic data, especially in development environments, you can use libraries like Faker:

javascript
// First install faker: npm install @faker-js/faker
// src/seeds/realisticUserSeeder.js
const User = require('../models/User');
const bcrypt = require('bcrypt');
const { faker } = require('@faker-js/faker');

const seedRealisticUsers = async (count = 10) => {
  try {
    // Clear existing users
    await User.deleteMany({ role: 'user' }); // Preserve admin users
    
    // Generate hashed password (same for all users to make testing easier)
    const salt = await bcrypt.genSalt(10);
    const password = await bcrypt.hash('password123', salt);
    
    // Create seed data
    const users = [];
    
    // Generate random users
    for (let i = 0; i < count; i++) {
      const firstName = faker.person.firstName();
      const lastName = faker.person.lastName();
      
      users.push({
        username: faker.internet.userName({ firstName, lastName }),
        email: faker.internet.email({ firstName, lastName }),
        password,
        role: 'user',
        profile: {
          firstName,
          lastName,
          avatar: faker.image.avatar(),
          bio: faker.lorem.paragraph(),
          location: faker.location.city()
        }
      });
    }
    
    // Insert users
    const result = await User.insertMany(users);
    console.log(`${result.length} realistic users seeded successfully!`);
    return result;
  } catch (error) {
    console.error('Error seeding realistic users:', error);
    throw error;
  }
};

module.exports = seedRealisticUsers;

Integration with Express Application

Now let's see how you can integrate database seeding directly with your Express application startup:

javascript
// app.js
const express = require('express');
const mongoose = require('mongoose');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

// Database connection
mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/my_database')
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.error('MongoDB connection error:', err));

// Import seeders
const seedUsers = require('./src/seeds/userSeeder');

// Middleware and routes setup
app.use(express.json());
// ... other middleware and routes

// Conditional seeding based on command-line arguments
if (process.argv.includes('--seed')) {
  console.log('Seeding database...');
  
  // Run seeders when application starts with --seed flag
  (async () => {
    try {
      await seedUsers();
      console.log('Database seeding completed successfully!');
    } catch (error) {
      console.error('Database seeding failed:', error);
      process.exit(1);
    }
  })();
}

// Start server
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Now you can start your application with database seeding by running:

node app.js --seed

SQL Database Seeding Example

So far, we've focused on MongoDB. Here's an example of database seeding for PostgreSQL using Sequelize ORM:

javascript
// src/seeds/sqlUserSeeder.js
const { User } = require('../models');
const bcrypt = require('bcrypt');

const seedSqlUsers = async () => {
  try {
    // Clear existing users
    await User.destroy({ where: {}, truncate: true });
    
    // Generate hashed passwords
    const salt = await bcrypt.genSalt(10);
    const adminPassword = await bcrypt.hash('admin123', salt);
    const userPassword = await bcrypt.hash('user123', salt);
    
    // Create seed data
    const users = [
      {
        username: 'admin',
        email: '[email protected]',
        password: adminPassword,
        role: 'admin',
        createdAt: new Date(),
        updatedAt: new Date()
      },
      {
        username: 'user1',
        email: '[email protected]',
        password: userPassword,
        role: 'user',
        createdAt: new Date(),
        updatedAt: new Date()
      },
      {
        username: 'user2',
        email: '[email protected]',
        password: userPassword,
        role: 'user',
        createdAt: new Date(),
        updatedAt: new Date()
      }
    ];
    
    // Insert users
    const result = await User.bulkCreate(users);
    console.log(`${result.length} SQL users seeded successfully!`);
    return result;
  } catch (error) {
    console.error('Error seeding SQL users:', error);
    throw error;
  }
};

module.exports = seedSqlUsers;

And a runner for SQL database:

javascript
// src/sqlSeedRunner.js
const { sequelize } = require('./models');
require('dotenv').config();

// Import seeders
const seedSqlUsers = require('./seeds/sqlUserSeeder');

// Run all seeders
const runSeeders = async () => {
  try {
    await sequelize.authenticate();
    console.log('SQL database connected for seeding');
    
    await seedSqlUsers();
    
    console.log('All SQL seeders completed successfully!');
    process.exit(0);
  } catch (error) {
    console.error('Error running SQL seeders:', error);
    process.exit(1);
  }
};

runSeeders();

Best Practices for Database Seeding

Idempotent Seeders: Make sure your seeders can be run multiple times without creating duplicate data.
Environmental Awareness: Create seeders that are aware of different environments (development, testing, production).
Seeding Order: Seed independent data first, followed by data that has dependencies.
Seed Data Management: Store seed data in separate JSON/YAML files for easier management.
Realistic Data: Use libraries like Faker to generate realistic test data.
Performance Considerations: Use bulk operations (like insertMany() or bulkCreate()) for better performance.
Transactional Seeding: For SQL databases, wrap seeding operations in transactions for atomicity.

Real-World Example: E-Commerce Application

Here's a more complete example for an e-commerce application with multiple seeders:

javascript
// src/seedRunner.js
const mongoose = require('mongoose');
require('dotenv').config();

// Import seeders
const seedCategories = require('./seeds/categorySeeder');
const seedProducts = require('./seeds/productSeeder');
const seedUsers = require('./seeds/userSeeder');
const seedOrders = require('./seeds/orderSeeder');

// Connect to database
mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/ecommerce')
  .then(() => console.log('MongoDB connected for seeding'))
  .catch(err => console.error('MongoDB connection error:', err));

// Run all seeders in the correct order
const runSeeders = async () => {
  try {
    await seedCategories();  // Categories have no dependencies
    await seedUsers();       // Users have no dependencies
    await seedProducts();    // Products depend on categories
    await seedOrders();      // Orders depend on users and products
    
    console.log('All seeders completed successfully!');
    process.exit(0);
  } catch (error) {
    console.error('Error running seeders:', error);
    process.exit(1);
  }
};

runSeeders();

Summary

Database seeding is a crucial part of any Express application's development and deployment process. It helps ensure that your application has the necessary data to function correctly across different environments.

In this tutorial, we've covered:

Basic database seeding concepts and implementation
Creating environment-specific seeders
Handling relationships in seed data
Generating realistic test data
Integrating seeding with Express applications
SQL database seeding
Best practices for effective database seeding

By implementing these techniques, you'll be able to create more robust and testable Express applications with consistent data across all environments.

Additional Resources

Exercise

Create a blog application with MongoDB that includes users, posts, comments, and categories. Write seeders for each model, ensuring proper relationships between them.
Modify the seeder script to accept command-line arguments for specifying how many records to create for each model.
Implement a SQL version of the same blog application using Sequelize and PostgreSQL.
Create an admin dashboard for your application that includes a "Reset Database" button that reruns your seeders.

Happy coding!

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)

Introduction​

Why Seed Your Database?​

Basic Database Seeding in Express​

Step 1: Creating a Seed Script​

Step 2: Define Your Seeder​

Step 3: Create a Runner Script​

Step 4: Add Script to Package.json​

Advanced Seeding Techniques​

Environment-Specific Seeding​

Seeding with Relationships​

Using Faker for Realistic Data​

Integration with Express Application​

SQL Database Seeding Example​

Best Practices for Database Seeding​

Real-World Example: E-Commerce Application​

Summary​

Additional Resources​

Exercise​