secondsky/claude-skills / plugins/drizzle-orm-d1/skills/drizzle-orm-d1
drizzle-orm-d1
Verified| Type-safe ORM for Cloudflare D1 databases using Drizzle. Use when: building D1 database schemas, writing type-safe SQL queries, managing migrations with Drizzle Kit, defining table relations, implementing prepared statements, using D1 batch API, or encountering D1_ERROR, transaction errors, foreign key constraint failures, or schema inference issues.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 9.2 KB |
| references/common-errors.md | markdown | 5.3 KB |
| references/error-catalog.md | markdown | 7.9 KB |
| references/links-to-official-docs.md | markdown | 1.8 KB |
| references/migration-workflow.md | markdown | 2.7 KB |
| references/query-builder-api.md | markdown | 3.9 KB |
| references/schema-patterns.md | markdown | 3.4 KB |
| references/wrangler-setup.md | markdown | 2.7 KB |
| scripts/check-versions.shexecutable | script | 1017 B |
| templates/basic-queries.ts | script | 7.5 KB |
| templates/basic-schema.ts | script | 2.9 KB |
| templates/client.ts | script | 2.2 KB |
| templates/cloudflare-worker-integration.ts | script | 7.7 KB |
| templates/drizzle.config.ts | script | 2.2 KB |
| templates/migrations/0001_example.sql | other | 2.1 KB |
| templates/package.json | manifest | 1.1 KB |
| templates/prepared-statements.ts | script | 7.3 KB |
| templates/relations-queries.ts | script | 6.8 KB |
| templates/schema.ts | script | 6.5 KB |
| templates/transactions.ts | script | 6.8 KB |
templates/transactions.ts
View on GitHub/**
* Transactions with Drizzle ORM and D1 Batch API
*
* IMPORTANT: D1 does not support traditional SQL transactions (BEGIN/COMMIT/ROLLBACK).
* Instead, use D1's batch API to execute multiple statements atomically.
*
* Issue: https://github.com/drizzle-team/drizzle-orm/issues/4212
*/
import { drizzle } from 'drizzle-orm/d1';
import { users, posts, comments } from './schema';
/**
* ❌ DON'T: Use Drizzle's transaction API
*
* This will fail with D1_ERROR: Cannot use BEGIN TRANSACTION
*/
export async function DONT_useTraditionalTransaction(db: ReturnType<typeof drizzle>) {
try {
await db.transaction(async (tx) => {
await tx.insert(users).values({ email: 'test@example.com', name: 'Test' });
await tx.insert(posts).values({ title: 'Post', slug: 'post', content: 'Content', authorId: 1 });
});
} catch (error) {
console.error('Transaction failed:', error);
// Error: D1_ERROR: Cannot use BEGIN TRANSACTION
}
}
/**
* ✅ DO: Use D1 Batch API
*
* Execute multiple statements in a single batch
*/
// Basic batch insert
export async function batchInsertUsers(
db: ReturnType<typeof drizzle>,
usersData: { email: string; name: string }[]
) {
const statements = usersData.map((user) =>
db.insert(users).values(user).returning()
);
// All statements execute atomically
const results = await db.batch(statements);
return results;
}
// Batch insert with related records
export async function createUserWithPosts(
db: ReturnType<typeof drizzle>,
userData: { email: string; name: string },
postsData: { title: string; slug: string; content: string }[]
) {
try {
// First insert user
const [user] = await db.insert(users).values(userData).returning();
// Then batch insert posts
const postStatements = postsData.map((post) =>
db.insert(posts).values({ ...post, authorId: user.id }).returning()
);
const postResults = await db.batch(postStatements);
return {
user,
posts: postResults.flat(),
};
} catch (error) {
console.error('Batch operation failed:', error);
// Manual cleanup if needed
// await db.delete(users).where(eq(users.email, userData.email));
throw error;
}
}
// Batch with mixed operations (insert, update, delete)
export async function batchMixedOperations(db: ReturnType<typeof drizzle>) {
const results = await db.batch([
// Insert new user
db.insert(users).values({ email: 'new@example.com', name: 'New User' }).returning(),
// Update existing post
db.update(posts).set({ published: true }).where(eq(posts.id, 1)).returning(),
// Delete old comments
db.delete(comments).where(lt(comments.createdAt, new Date('2024-01-01'))).returning(),
]);
const [newUsers, updatedPosts, deletedComments] = results;
return {
newUsers,
updatedPosts,
deletedComments,
};
}
/**
* Error Handling with Batch API
*
* If any statement in a batch fails, the entire batch fails.
* However, D1 doesn't provide automatic rollback like traditional transactions.
*/
// Batch with error handling
export async function batchWithErrorHandling(
db: ReturnType<typeof drizzle>,
usersData: { email: string; name: string }[]
) {
const statements = usersData.map((user) =>
db.insert(users).values(user).returning()
);
try {
const results = await db.batch(statements);
console.log('All operations succeeded');
return { success: true, results };
} catch (error) {
console.error('Batch failed:', error);
// Implement manual cleanup logic if needed
// For example, delete any partially created records
return { success: false, error };
}
}
// Batch with validation before execution
export async function safeBatchInsert(
db: ReturnType<typeof drizzle>,
usersData: { email: string; name: string }[]
) {
// Validate all data before batching
for (const user of usersData) {
if (!user.email || !user.name) {
throw new Error('Invalid user data');
}
// Check for duplicates
const existing = await db
.select()
.from(users)
.where(eq(users.email, user.email))
.get();
if (existing) {
throw new Error(`User with email ${user.email} already exists`);
}
}
// All validation passed, execute batch
const statements = usersData.map((user) =>
db.insert(users).values(user).returning()
);
return await db.batch(statements);
}
/**
* Batch Query Patterns
*/
// Batch read operations
export async function batchReadOperations(db: ReturnType<typeof drizzle>, userIds: number[]) {
const queries = userIds.map((id) =>
db.select().from(users).where(eq(users.id, id))
);
return await db.batch(queries);
}
// Batch with dependent operations
export async function createBlogPost(
db: ReturnType<typeof drizzle>,
postData: { title: string; slug: string; content: string; authorId: number },
tagsData: string[]
) {
// Insert post first
const [post] = await db.insert(posts).values(postData).returning();
// Then batch insert tags (if you had a tags table)
// This is a two-step process because we need the post.id
return post;
}
/**
* Performance Optimization with Batch
*/
// Batch insert for large datasets
export async function bulkInsertUsers(
db: ReturnType<typeof drizzle>,
usersData: { email: string; name: string }[]
) {
const BATCH_SIZE = 100; // Process in chunks
const results = [];
for (let i = 0; i < usersData.length; i += BATCH_SIZE) {
const chunk = usersData.slice(i, i + BATCH_SIZE);
const statements = chunk.map((user) =>
db.insert(users).values(user).returning()
);
const chunkResults = await db.batch(statements);
results.push(...chunkResults);
}
return results.flat();
}
/**
* Important Notes:
*
* 1. D1 Batch API vs Traditional Transactions:
* - Batch API: Executes multiple statements in one round-trip
* - Traditional transactions: Support ROLLBACK on error (not available in D1)
*
* 2. Error Handling:
* - If batch fails, manually clean up any partially created records
* - Use try-catch for error handling
* - Validate data before executing batch
*
* 3. Atomicity:
* - All statements in a batch execute together
* - If one fails, the entire batch fails
* - No partial success (all or nothing)
*
* 4. Performance:
* - Batching reduces round-trips to the database
* - Process large datasets in chunks (100-1000 records)
* - Consider rate limits when batching
*
* 5. Supported Operations:
* - INSERT
* - UPDATE
* - DELETE
* - SELECT
* - Mixed operations in a single batch
*/
/**
* Workaround for Complex Transactions:
*
* If you need more complex transaction logic with rollback:
* 1. Use application-level transaction management
* 2. Implement compensating transactions
* 3. Use idempotency keys to prevent duplicate operations
* 4. Consider using a different database if ACID is critical
*/
import { eq, lt } from 'drizzle-orm';
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| deprecation-and-migrationaddyosmani/agent-skillsManages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| performance-optimizationaddyosmani/agent-skillsOptimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |
| agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |