Database Seeding | Bootspring Docs

Patterns for seeding databases with test and initial data.

Overview#

Database seeding enables:

Consistent development environments
Test data generation
Initial production data
Demo environment setup

Prerequisites:

Prisma ORM setup
Faker.js (optional, for realistic data)

Installation#

npm install -D @faker-js/faker

// package.json
{
  "prisma": {
    "seed": "ts-node --compiler-options {\"module\":\"CommonJS\"} prisma/seed.ts"
  },
  "scripts": {
    "db:seed": "prisma db seed",
    "db:seed:prod": "SEED_ENV=production prisma db seed",
    "db:reset": "prisma migrate reset"
  }
}

Implementation#

Basic Seed Script#

// prisma/seed.ts
import { prisma } from '../src/lib/db'
import { hash } from 'bcryptjs'

async function main() {
  console.log('Seeding database...')

  // Create admin user
  const adminPassword = await hash('admin123', 12)
  const admin = await prisma.user.upsert({
    where: { email: 'admin@example.com' },
    update: {},
    create: {
      email: 'admin@example.com',
      name: 'Admin User',
      password: adminPassword,
      role: 'ADMIN',
      emailVerified: new Date()
    }
  })

  console.log('Created admin:', admin.email)

  // Create categories
  const categories = await Promise.all(
    ['Technology', 'Design', 'Business'].map(name =>
      prisma.category.upsert({
        where: { slug: name.toLowerCase() },
        update: {},
        create: { name, slug: name.toLowerCase() }
      })
    )
  )

  console.log('Created categories:', categories.length)

  // Create sample posts
  for (let i = 0; i < 10; i++) {
    await prisma.post.create({
      data: {
        title: `Sample Post ${i + 1}`,
        slug: `sample-post-${i + 1}`,
        content: `This is the content for post ${i + 1}`,
        published: true,
        authorId: admin.id,
        categoryId: categories[i % categories.length].id
      }
    })
  }

  console.log('Created 10 sample posts')
}

main()
  .catch(console.error)
  .finally(() => prisma.$disconnect())

Faker-Based Seeding#

// prisma/seed.ts
import { prisma } from '../src/lib/db'
import { faker } from '@faker-js/faker'
import { hash } from 'bcryptjs'

async function main() {
  // Clear existing data
  await prisma.post.deleteMany()
  await prisma.user.deleteMany()

  // Create users
  const password = await hash('password123', 12)

  const users = await Promise.all(
    Array.from({ length: 20 }).map(() =>
      prisma.user.create({
        data: {
          email: faker.internet.email(),
          name: faker.person.fullName(),
          password,
          image: faker.image.avatar(),
          emailVerified: faker.datatype.boolean() ? faker.date.past() : null
        }
      })
    )
  )

  // Create posts
  const posts = await Promise.all(
    Array.from({ length: 50 }).map(() =>
      prisma.post.create({
        data: {
          title: faker.lorem.sentence(),
          slug: faker.helpers.slugify(faker.lorem.words(3)),
          content: faker.lorem.paragraphs(5),
          excerpt: faker.lorem.paragraph(),
          published: faker.datatype.boolean(),
          authorId: faker.helpers.arrayElement(users).id,
          createdAt: faker.date.past(),
          updatedAt: faker.date.recent()
        }
      })
    )
  )

  // Create comments
  await Promise.all(
    posts.flatMap(post =>
      Array.from({ length: faker.number.int({ min: 0, max: 10 }) }).map(() =>
        prisma.comment.create({
          data: {
            content: faker.lorem.sentences(),
            postId: post.id,
            userId: faker.helpers.arrayElement(users).id,
            createdAt: faker.date.recent()
          }
        })
      )
    )
  )

  console.log('Database seeded!')
}

main()
  .catch(console.error)
  .finally(() => prisma.$disconnect())

Environment-Specific Seeds#

// prisma/seed.ts
import { prisma } from '../src/lib/db'

const ENV = process.env.SEED_ENV || 'development'

async function seedDevelopment() {
  // Create test users and data
  await createTestUsers()
  await createSampleContent()
}

async function seedProduction() {
  // Only create essential data
  await createAdminUser()
  await createDefaultCategories()
  await createSystemSettings()
}

async function seedStaging() {
  // Production-like but with some test data
  await seedProduction()
  await createDemoAccounts()
}

async function main() {
  console.log(`Seeding for environment: ${ENV}`)

  switch (ENV) {
    case 'production':
      await seedProduction()
      break
    case 'staging':
      await seedStaging()
      break
    default:
      await seedDevelopment()
  }
}

main()
  .catch(console.error)
  .finally(() => prisma.$disconnect())

Seed with Relations#

// prisma/seed.ts
async function seedWithRelations() {
  // Create team with members
  const team = await prisma.team.create({
    data: {
      name: 'Development Team',
      members: {
        create: [
          { role: 'OWNER', user: { create: { email: 'owner@example.com', name: 'Owner' } } },
          { role: 'ADMIN', user: { create: { email: 'admin@example.com', name: 'Admin' } } },
          { role: 'MEMBER', user: { create: { email: 'member@example.com', name: 'Member' } } }
        ]
      },
      projects: {
        create: [
          {
            name: 'Project Alpha',
            tasks: {
              create: [
                { title: 'Task 1', status: 'TODO' },
                { title: 'Task 2', status: 'IN_PROGRESS' },
                { title: 'Task 3', status: 'DONE' }
              ]
            }
          }
        ]
      }
    },
    include: {
      members: { include: { user: true } },
      projects: { include: { tasks: true } }
    }
  })

  console.log('Created team with members and projects:', team.name)
}

Idempotent Seeding#

// prisma/seed.ts
async function idempotentSeed() {
  // Use upsert to make seeding repeatable
  const categories = [
    { name: 'Technology', slug: 'technology' },
    { name: 'Design', slug: 'design' },
    { name: 'Business', slug: 'business' }
  ]

  for (const category of categories) {
    await prisma.category.upsert({
      where: { slug: category.slug },
      update: { name: category.name },
      create: category
    })
  }

  // Or use createMany with skipDuplicates
  await prisma.setting.createMany({
    data: [
      { key: 'site_name', value: 'My App' },
      { key: 'site_description', value: 'A great application' },
      { key: 'maintenance_mode', value: 'false' }
    ],
    skipDuplicates: true
  })
}

Seed from JSON/CSV#

// prisma/seed.ts
import * as fs from 'fs'
import * as path from 'path'

async function seedFromFile() {
  // Read JSON file
  const dataPath = path.join(__dirname, 'data', 'products.json')
  const products = JSON.parse(fs.readFileSync(dataPath, 'utf-8'))

  // Batch insert
  await prisma.product.createMany({
    data: products,
    skipDuplicates: true
  })

  console.log(`Seeded ${products.length} products from file`)
}

Usage Examples#

Running Seeds#

# Run seed
npx prisma db seed

# Reset and reseed
npx prisma migrate reset

# Seed specific environment
SEED_ENV=staging npx prisma db seed

Test Setup with Seeds#

// tests/setup.ts
import { prisma } from '@/lib/db'
import { seedTestData } from './fixtures'

beforeAll(async () => {
  await prisma.$transaction([
    prisma.post.deleteMany(),
    prisma.user.deleteMany()
  ])
  await seedTestData()
})

afterAll(async () => {
  await prisma.$disconnect()
})

Best Practices#

Make seeds idempotent - Use upsert or skipDuplicates for repeatability
Use environment-specific seeds - Different data for dev/staging/prod
Hash passwords securely - Never store plain text passwords
Clear data before seeding - Start fresh to avoid duplicates
Document test accounts - Make test credentials easy to find

Prisma - Prisma setup and basics
Migrations - Migration strategies
Transactions - Transaction handling