majiayu000 Data Seeding & Fixtures Builder
Generate realistic, deterministic seed data for development and testing.
Seed Data Strategy
// prisma/seed.ts
import { PrismaClient } from "@prisma/client";
import { faker } from "@faker-js/faker";
const prisma = new PrismaClient();
async function main() {
console.log("🌱 Seeding database...");
// Clear existing data
await prisma.order.deleteMany();
await prisma.user.deleteMany();
// Seed users
const users = await seedUsers(10);
console.log(`✅ Created ${users.length} users`);
// Seed orders
const orders = await seedOrders(users, 50);
console.log(`✅ Created ${orders.length} orders`);
console.log("✅ Seeding complete!");
}
main()
.catch((e) => {
console.error(e);
process.exit(1);
})
.finally(async () => {
await prisma.$disconnect();
});
Factory Functions
// factories/user.factory.ts
import { faker } from "@faker-js/faker";
import { PrismaClient, User } from "@prisma/client";
const prisma = new PrismaClient();
export interface UserFactoryOptions {
email?: string;
name?: string;
role?: "USER" | "ADMIN";
}
export class UserFactory {
static async create(options: UserFactoryOptions = {}): Promise<User> {
return prisma.user.create({
data: {
email: options.email || faker.internet.email(),
name: options.name || faker.person.fullName(),
role: options.role || "USER",
createdAt: faker.date.past(),
},
});
}
static async createMany(
count: number,
options: UserFactoryOptions = {}
): Promise<User[]> {
return Promise.all(
Array.from({ length: count }, () => this.create(options))
);
}
static async createAdmin(): Promise<User> {
return this.create({ role: "ADMIN" });
}
}
// Usage:
// const user = await UserFactory.create();
// const admin = await UserFactory.createAdmin();
// const users = await UserFactory.createMany(10);
Realistic Fixtures
// fixtures/products.ts
import { Product } from "@prisma/client";
export const PRODUCT_FIXTURES: Omit<
Product,
"id" | "createdAt" | "updatedAt"
>[] = [
{
name: 'MacBook Pro 16"',
description: "Powerful laptop for developers",
price: 2499.99,
stock: 50,
category: "Electronics",
},
{
name: "iPhone 15 Pro",
description: "Latest flagship smartphone",
price: 999.99,
stock: 100,
category: "Electronics",
},
{
name: "AirPods Pro",
description: "Wireless earbuds with noise cancellation",
price: 249.99,
stock: 200,
category: "Electronics",
},
];
// Seed products
async function seedProducts() {
return Promise.all(
PRODUCT_FIXTURES.map((product) => prisma.product.create({ data: product }))
);
}
Deterministic Seeding
// Use fixed seed for reproducibility
import { faker } from "@faker-js/faker";
// Set seed for deterministic data
faker.seed(12345);
// Same data every time
const user1 = {
email: faker.internet.email(), // Always same email
name: faker.person.fullName(), // Always same name
};
// Reset for different test
faker.seed(67890);
Relationship Building
// factories/order.factory.ts
export class OrderFactory {
static async create(userId: number): Promise<Order> {
const products = await prisma.product.findMany({ take: 3 });
const order = await prisma.order.create({
data: {
userId,
status: faker.helpers.arrayElement(["pending", "paid", "shipped"]),
total: faker.number.float({ min: 10, max: 1000, precision: 0.01 }),
},
});
// Create order items
await Promise.all(
products.map((product) =>
prisma.orderItem.create({
data: {
orderId: order.id,
productId: product.id,
quantity: faker.number.int({ min: 1, max: 5 }),
price: product.price,
},
})
)
);
return order;
}
static async createForUser(user: User, count: number): Promise<Order[]> {
return Promise.all(
Array.from({ length: count }, () => this.create(user.id))
);
}
}
Environment-Specific Seeds
// seeds/development.ts
export async function seedDevelopment() {
// Development: Few records, easy to debug
const users = await UserFactory.createMany(5);
const products = await ProductFactory.createMany(10);
for (const user of users) {
await OrderFactory.createForUser(user, 2);
}
}
// seeds/staging.ts
export async function seedStaging() {
// Staging: Moderate data, realistic scenarios
const users = await UserFactory.createMany(50);
const products = await ProductFactory.createMany(100);
for (const user of users) {
await OrderFactory.createForUser(
user,
faker.number.int({ min: 1, max: 10 })
);
}
}
// seeds/testing.ts
export async function seedTesting() {
// Testing: Minimal, predictable data
faker.seed(12345); // Deterministic
const user = await UserFactory.create({
email: "test@example.com",
name: "Test User",
});
const product = await ProductFactory.create({
name: "Test Product",
price: 99.99,
});
return { user, product };
}
// Main seed file
async function main() {
const env = process.env.NODE_ENV;
if (env === "development") {
await seedDevelopment();
} else if (env === "staging") {
await seedStaging();
} else if (env === "test") {
await seedTesting();
}
}
Database Reset Script
// scripts/reset-db.ts
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
async function resetDatabase() {
console.log("🗑️ Resetting database...");
// Disable foreign key checks (PostgreSQL)
await prisma.$executeRaw`SET session_replication_role = 'replica';`;
// Get all tables
const tables = await prisma.$queryRaw<{ tablename: string }[]>`
SELECT tablename FROM pg_tables WHERE schemaname = 'public';
`;
// Truncate all tables
for (const { tablename } of tables) {
if (tablename !== "_prisma_migrations") {
await prisma.$executeRawUnsafe(`TRUNCATE TABLE "${tablename}" CASCADE;`);
console.log(` Truncated ${tablename}`);
}
}
// Re-enable foreign key checks
await prisma.$executeRaw`SET session_replication_role = 'origin';`;
console.log("✅ Database reset complete");
}
resetDatabase()
.catch((e) => {
console.error(e);
process.exit(1);
})
.finally(() => prisma.$disconnect());
Test Fixtures for E2E Tests
// tests/fixtures/e2e.fixture.ts
import { test as base } from "@playwright/test";
import { UserFactory, ProductFactory } from "../factories";
type Fixtures = {
authenticatedUser: User;
products: Product[];
};
export const test = base.extend<Fixtures>({
authenticatedUser: async ({ page }, use) => {
// Create user
const user = await UserFactory.create();
// Login
await page.goto("/login");
await page.fill('[name="email"]', user.email);
await page.fill('[name="password"]', "password123");
await page.click('button[type="submit"]');
await use(user);
// Cleanup
await prisma.user.delete({ where: { id: user.id } });
},
products: async ({}, use) => {
const products = await ProductFactory.createMany(5);
await use(products);
// Cleanup
await prisma.product.deleteMany({
where: { id: { in: products.map((p) => p.id) } },
});
},
});
// Usage:
test("should add product to cart", async ({ authenticatedUser, products }) => {
// Test with pre-seeded data
});
Package.json Scripts
{
"scripts": {
"db:seed": "tsx prisma/seed.ts",
"db:seed:dev": "NODE_ENV=development tsx prisma/seed.ts",
"db:seed:staging": "NODE_ENV=staging tsx prisma/seed.ts",
"db:reset": "tsx scripts/reset-db.ts && npm run db:seed",
"db:reset:test": "tsx scripts/reset-db.ts && NODE_ENV=test tsx prisma/seed.ts"
}
}
Best Practices
- Use factories: Reusable data generation
- Deterministic in tests: Fixed seed values
- Realistic fixtures: Production-like data
- Environment-specific: Different needs per environment
- Cleanup after tests: Avoid pollution
- Relationship integrity: Proper foreign keys
- Performance: Batch inserts for large datasets
Output Checklist
- Seed script created
- Factory functions for each model
- Realistic fixtures defined
- Deterministic seeding (tests)
- Relationship building logic
- Environment-specific seeds
- Database reset script
- E2E test fixtures