Database Seed Generator

Generate seed scripts that populate databases with realistic, domain-appropriate sample data. Reads your schema and produces ready-to-run seed files.

Workflow

1. Find the Schema

Scan the project for schema definitions:

Source

Location pattern

Drizzle schema

src/db/schema.ts, src/schema/*.ts, db/schema.ts

D1 migrations

drizzle/*.sql, migrations/*.sql

Raw SQL

schema.sql, db/*.sql

Prisma

prisma/schema.prisma

Read all schema files. Build a mental model of:

• Tables and their columns

• Data types and constraints (NOT NULL, UNIQUE, DEFAULT)

• Foreign key relationships (which tables reference which)

• JSON fields stored as TEXT (common in D1/SQLite)

2. Determine Seed Parameters

Ask the user:

Parameter

Options

Default

Purpose

dev, demo, testing

dev

Volume

small (5-10 rows/table), medium (20-50), large (100+)

small

Domain context

"e-commerce store", "SaaS app", "blog", etc.

Infer from schema

Output format

TypeScript (Drizzle), raw SQL, or both

Match project's ORM

Purpose affects data quality:

• dev: Varied data, some edge cases (empty fields, long strings, unicode)

• demo: Polished data that looks good in screenshots and presentations

• testing: Systematic data covering boundary conditions, duplicates, special characters

3. Plan Insert Order

Build a dependency graph from foreign keys. Insert parent tables before children.

Example order for a blog schema:

1. users        (no dependencies)

2. categories   (no dependencies)

3. posts        (depends on users, categories)

4. comments     (depends on users, posts)

5. tags         (no dependencies)

6. post_tags    (depends on posts, tags)

Circular dependencies: If table A references B and B references A, use nullable foreign keys and insert in two passes (insert with NULL, then UPDATE).

4. Generate Realistic Data

Do NOT use generic placeholders like "test123", "foo@bar.com", or "Lorem ipsum". Generate data that matches the domain.

#### Data Generation Patterns (no external libraries needed)

Names: Use a hardcoded list of common names. Mix genders and cultural backgrounds.

const firstNames = ['Sarah', 'James', 'Priya', 'Mohammed', 'Emma', 'Wei', 'Carlos', 'Aisha'];

const lastNames = ['Chen', 'Smith', 'Patel', 'Garcia', 'Kim', 'O\'Brien', 'Nguyen', 'Wilson'];

Emails: Derive from names — sarah.chen@example.com. Use example.com domain (RFC 2606 reserved).

Dates: Generate within a realistic range. Use ISO 8601 format for D1/SQLite.

const randomDate = (daysBack: number) => {

  const d = new Date();

  d.setDate(d.getDate() - Math.floor(Math.random() * daysBack));

  return d.toISOString();

};

IDs: Use crypto.randomUUID() for UUIDs, or sequential integers if the schema uses auto-increment.

Deterministic seeding: For reproducible data, use a seeded PRNG:

function seededRandom(seed: number) {

  return () => {

    seed = (seed * 16807) % 2147483647;

    return (seed - 1) / 2147483646;

  };

}

const rand = seededRandom(42); // Same seed = same data every time

Prices/amounts: Use realistic ranges. (rand() * 900 + 100).toFixed(2) for $1-$10 range.

Descriptions/content: Write 3-5 realistic variations per content type and cycle through them. Don't generate AI-sounding prose — write like real user data.

5. Output Format

#### TypeScript (Drizzle ORM)

// scripts/seed.ts

import { drizzle } from 'drizzle-orm/d1';

import * as schema from '../src/db/schema';

export async function seed(db: ReturnType<typeof drizzle>) {

  console.log('Seeding database...');

  // Clear existing data (reverse dependency order)

  await db.delete(schema.comments);

  await db.delete(schema.posts);

  await db.delete(schema.users);

  // Insert users

  const users = [

    { id: crypto.randomUUID(), name: 'Sarah Chen', email: 'sarah@example.com', ... },

    // ...

  ];

  // D1 batch limit: 10 rows per INSERT

  for (let i = 0; i < users.length; i += 10) {

    await db.insert(schema.users).values(users.slice(i, i + 10));

  }

  // Insert posts (references users)

  const posts = [

    { id: crypto.randomUUID(), userId: users[0].id, title: '...', ... },

    // ...

  ];

  for (let i = 0; i < posts.length; i += 10) {

    await db.insert(schema.posts).values(posts.slice(i, i + 10));

  }

  console.log(`Seeded: ${users.length} users, ${posts.length} posts`);

}

Run with: npx tsx scripts/seed.ts

For Cloudflare Workers, add a seed endpoint (remove before production):

app.post('/api/seed', async (c) => {

  const db = drizzle(c.env.DB);

  await seed(db);

  return c.json({ ok: true });

});

#### Raw SQL (D1)

-- seed.sql

-- Run: npx wrangler d1 execute DB_NAME --local --file=./scripts/seed.sql

-- Clear existing (reverse order)

DELETE FROM comments;

DELETE FROM posts;

DELETE FROM users;

-- Users

INSERT INTO users (id, name, email, created_at) VALUES

  ('uuid-1', 'Sarah Chen', 'sarah@example.com', '2025-01-15T10:30:00Z'),

  ('uuid-2', 'James Wilson', 'james@example.com', '2025-02-01T14:22:00Z');

-- Posts (max 10 rows per INSERT for D1)

INSERT INTO posts (id, user_id, title, body, created_at) VALUES

  ('post-1', 'uuid-1', 'Getting Started', 'Welcome to...', '2025-03-01T09:00:00Z');

6. Idempotency

Seed scripts must be safe to re-run:

// Option A: Delete-then-insert (simple, loses data)

await db.delete(schema.users);

await db.insert(schema.users).values(seedUsers);

// Option B: Upsert (preserves non-seed data)

for (const user of seedUsers) {

  await db.insert(schema.users)

    .values(user)

    .onConflictDoUpdate({ target: schema.users.id, set: user });

}

Default to Option A for dev/testing, Option B for demo (where users may have added their own data).

D1-Specific Gotchas

Gotcha

Solution

Max ~10 rows per INSERT

Batch inserts in chunks of 10

No native BOOLEAN

Use INTEGER (0/1)

No native DATETIME

Use TEXT with ISO 8601 strings

JSON stored as TEXT

JSON.stringify() before insert

Foreign keys always enforced

Insert parent tables first

100 bound parameter limit

Keep batch size × columns < 100

Quality Rules

• Match the domain — an e-commerce seed has products with real-sounding names and prices, not "Product 1"

• Vary the data — don't make every user "John Smith" or every price "$9.99"

• Include edge cases (for testing seeds) — empty strings, very long text, special characters, maximum values

• Reference real IDs — foreign keys must point to actually-inserted parent rows

• Print what was seeded — always log counts so the user knows it worked

• Document the run command — put it in a comment at the top of the file