Seed Generator

Analyze database schema and generate realistic test data. Write seed files directly.

Process

1. Analyze Schema - Read database models/schema
2. Understand Relations - Map foreign keys and constraints
3. Generate Data - Create realistic fake data
4. Write Seeds - Create seed script files
5. Test - Run seeds to verify

Schema Analysis

# Find Prisma schema
cat prisma/schema.prisma 2>/dev/null | head -100

# Find Drizzle schema
find src -name "schema.ts" -path "*/db/*" | xargs cat 2>/dev/null

# Find TypeORM entities
find src -name "*.entity.ts" | xargs cat 2>/dev/null | head -100

# Find existing seeds
find . -name "seed*.ts" -o -name "seed*.js" 2>/dev/null

Data Generation Patterns

Users

const users = [
  {
    id: 'user_1',
    email: 'admin@example.com',
    name: 'Admin User',
    role: 'ADMIN',
    createdAt: new Date('2024-01-01'),
  },
  {
    id: 'user_2',
    email: 'john@example.com',
    name: 'John Doe',
    role: 'USER',
    createdAt: new Date('2024-01-15'),
  },
  // Generate more with faker
];

Products

const products = [
  {
    id: 'prod_1',
    name: 'Premium Widget',
    price: 2999, // cents
    description: 'A high-quality widget for professionals',
    category: 'ELECTRONICS',
    stock: 100,
    createdAt: new Date('2024-01-01'),
  },
];

Orders (with relations)

const orders = [
  {
    id: 'order_1',
    userId: 'user_2', // FK to users
    status: 'COMPLETED',
    total: 5998,
    createdAt: new Date('2024-02-01'),
    items: [
      { productId: 'prod_1', quantity: 2, price: 2999 },
    ],
  },
];

Seed Script Template

Prisma Seed

// prisma/seed.ts

const prisma = new PrismaClient();

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

  // Clear existing data (in correct order for FKs)
  await prisma.orderItem.deleteMany();
  await prisma.order.deleteMany();
  await prisma.product.deleteMany();
  await prisma.user.deleteMany();

  // Create users
  const admin = await prisma.user.create({
    data: {
      email: 'admin@example.com',
      name: 'Admin User',
      role: 'ADMIN',
    },
  });

  const user = await prisma.user.create({
    data: {
      email: 'john@example.com',
      name: 'John Doe',
      role: 'USER',
    },
  });

  // Create products
  const products = await prisma.product.createMany({
    data: [
      { name: 'Widget A', price: 1999, stock: 50 },
      { name: 'Widget B', price: 2999, stock: 30 },
      { name: 'Widget C', price: 4999, stock: 20 },
    ],
  });

  // Create orders with items
  const order = await prisma.order.create({
    data: {
      userId: user.id,
      status: 'COMPLETED',
      total: 4998,
      items: {
        create: [
          { productId: products[0].id, quantity: 1, price: 1999 },
          { productId: products[1].id, quantity: 1, price: 2999 },
        ],
      },
    },
  });

  console.log('Seeding complete!');
  console.log({ users: 2, products: 3, orders: 1 });
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

package.json script

{
  "prisma": {
    "seed": "ts-node --compiler-options {\\"module\\":\\"CommonJS\\"} prisma/seed.ts"
  }
}

Data Requirements by Environment

Development

• Small dataset (10-50 records)
• Predictable IDs for testing
• Known test accounts
• Edge cases included

Testing

• Minimal dataset
• Deterministic (same data each time)
• Covers all code paths
• Fast to create/destroy

Demo/Staging

• Realistic volume (100-1000 records)
• Varied data (different statuses, dates)
• No real customer data
• Visually appealing

Output

After generating seeds, report:

# Seed Data Report

## Generated Files

| File | Purpose |
|------|---------|
| `prisma/seed.ts` | Main seed script |
| `prisma/data/users.json` | User data (optional) |
| `prisma/data/products.json` | Product data (optional) |

## Data Summary

| Table | Records | Notes |
|-------|---------|-------|
| users | 5 | 1 admin, 4 regular |
| products | 20 | Various categories |
| orders | 10 | Mixed statuses |
| orderItems | 25 | Linked to orders |

## Test Accounts

| Email | Password | Role |
|-------|----------|------|
| admin@example.com | admin123 | ADMIN |
| user@example.com | user123 | USER |

## Run Seeds

```bash
# Prisma
npx prisma db seed

# Reset and seed
npx prisma migrate reset

# Manual
npx ts-node prisma/seed.ts

Notes

• All passwords are hashed
• Dates span last 6 months
• Product prices in cents
• Images use placeholder URLs

## Rules

1. **Match schema exactly** - Use correct types and constraints
2. **Respect relations** - Create parent records first
3. **Use realistic data** - Names, emails, prices that make sense
4. **Include edge cases** - Empty strings, nulls (where allowed), max lengths
5. **Deterministic IDs** - Use predictable IDs for testing
6. **Document accounts** - List test credentials
7. **Idempotent** - Can run multiple times safely