seed-generator

# 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

```bash
# 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
```typescript
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
```typescript
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)
```typescript
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
```typescript
// prisma/seed.ts
import { PrismaClient } from '@prisma/client';

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
```json
{
  "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:

```markdown
# 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