メニュー
Drizzle ORM type-safe queries, schema definitions, migrations, relations, transactions, and performance patterns
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/InugamiDev/ultrathink-oss --skill drizzleコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SKILL.md を表示中
Unified design foundations — design system architecture, tokens, component specs, visual principles, creative vision, figma integration, plus brand design system loader (66 real brands via DESIGN.md). Absorbs design, design-system, design-systems, design-principles, design-router, creative-vision, figma, design-md.
Render, summarize, and present markdown documents and structured content in multiple output modes
Ultra UI skill - combines Google's DESIGN.md spec (machine-readable design tokens) with the ui-ux-pro-max knowledge base (91 styles, 161 palettes, 73 font pairings, 161 products, 104 UX guidelines, 25 chart types). Generates lint-clean DESIGN.md files, validates token references and WCAG contrast, exports Tailwind/DTCG tokens, and diffs design systems version-over-version.
SOC 職業分類に基づく
| name | drizzle |
| description | Drizzle ORM type-safe queries, schema definitions, migrations, relations, transactions, and performance patterns |
| layer | domain |
| category | database |
| triggers | ["drizzle","drizzle orm","drizzle kit","drizzle schema","drizzle query"] |
| inputs | ["Data model requirements","Query patterns","Migration needs"] |
| outputs | ["Drizzle schema definitions","Type-safe query implementations","Migration configurations"] |
| linksTo | ["postgresql","nodejs","graphql","microservices"] |
| linkedFrom | ["error-handling","testing"] |
| preferredNextSkills | ["postgresql","nodejs","redis"] |
| fallbackSkills | ["prisma","supabase"] |
| riskLevel | low |
| memoryReadPolicy | selective |
| memoryWritePolicy | none |
| sideEffects | [] |
Provide expert-level guidance on Drizzle ORM, including schema definitions, type-safe queries, relational queries, migrations with Drizzle Kit, transactions, prepared statements, and performance optimization. Drizzle is SQL-first: if you know SQL, you know Drizzle.
select().from().where() maps directly to SQLwith syntax for nested data// db/schema/users.ts
import {
pgTable, text, timestamp, boolean, integer, uuid,
uniqueIndex, index, pgEnum, check, primaryKey,
} from 'drizzle-orm/pg-core';
import { relations, sql } from 'drizzle-orm';
// Enums
export const roleEnum = pgEnum('role', ['admin', 'member', 'viewer']);
// Tables
export const users = pgTable('users', {
id: uuid('id').primaryKey().defaultRandom(),
email: text('email').notNull(),
name: text('name').(),
: ().().(),
: ().().(),
: ().().(),
: (, { : }).().(),
: (, { : }).().()
.$onUpdate( ()),
: (, { : }),
}, [
().(table.),
().(table., table.),
().(table.).(
sql
),
(, sql),
]);
posts = (, {
: ().().(),
: ().(),
: ().().(),
: ().(),
: ().().(),
: (, { : }),
: ().().( users., { : }),
: ().().(),
: ().(),
: (, { : }).().(),
: (, { : }).().()
.$onUpdate( ()),
}, [
().(table., table.),
().(table., table.),
]);
categories = (, {
: ().().(),
: ().().(),
: ().().(),
});
postsToCategories = (, {
: ().().( posts., { : }),
: ().().( categories., { : }),
: (, { : }).().(),
}, [
({ : [table., table.] }),
]);
usersRelations = (users, ({
: (posts),
: (profiles, {
: [users.],
: [profiles.],
}),
}));
postsRelations = (posts, ({
: (users, {
: [posts.],
: [users.],
}),
: (postsToCategories),
}));
postsToCategoriesRelations = (postsToCategories, ({
: (posts, {
: [postsToCategories.],
: [posts.],
}),
: (categories, {
: [postsToCategories.],
: [categories.],
}),
}));
// db/index.ts
import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import * as schema from './schema';
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
max: 20,
idleTimeoutMillis: 30_000,
connectionTimeoutMillis: 5_000,
});
export const db = drizzle(pool, {
schema,
logger: process.env.NODE_ENV === 'development',
});
// For serverless (Neon, Vercel Postgres)
import { neon } from '@neondatabase/serverless';
import { drizzle as drizzleNeon } from 'drizzle-orm/neon-http';
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzleNeon(sql, { schema });
// Type exports
export type Database = typeof db;
export type User = typeof schema.users.$inferSelect;
export type NewUser = typeof schema.users.$inferInsert;
import { eq, and, or, gt, lt, desc, asc, sql, ilike, inArray, isNull, count, avg } from 'drizzle-orm';
// Basic CRUD
// Select with filtering
const activeAdmins = await db
.select()
.from(users)
.where(
and(
eq(users.role, 'admin'),
eq(users.isActive, true),
isNull(users.deletedAt),
)
)
.orderBy(desc(users.createdAt))
.limit(20);
// Select specific columns
const userEmails = await db
.select({ id: users.id, email: users.email, name: users.name })
.from(users)
.where(eq(users.isActive, true));
// Insert with returning
const [newUser] = await db
.insert(users)
.values({
email: 'jane@example.com',
name: 'Jane Doe',
role: 'member',
})
.returning();
// Bulk insert
await db.insert(users).values([
{ email: 'a@example.com', name: 'Alice' },
{ email: 'b@example.com', name: 'Bob' },
]);
// Update
const [updated] = await db
.update(users)
.set({ name: 'Jane Updated', role: 'admin' })
.where(eq(users.id, userId))
.returning();
// Upsert (INSERT ... ON CONFLICT)
await db
.insert(users)
.values({ email: 'jane@example.com', name: 'Jane', credits: 100 })
.onConflictDoUpdate({
target: users.email,
set: { credits: sql`${users.credits} + 100` },
});
// Delete
await db.delete(users).where(eq(users.id, userId));
// Joins
const postsWithAuthors = await db
.select({
postId: posts.id,
title: posts.title,
authorName: users.name,
authorEmail: users.email,
})
.from(posts)
.innerJoin(users, eq(posts.authorId, users.id))
.where(eq(posts.published, true))
.orderBy(desc(posts.createdAt))
.limit(20);
// Subqueries
const subquery = db
.select({ authorId: posts.authorId, postCount: count().as('post_count') })
.from(posts)
.where(eq(posts.published, true))
.groupBy(posts.authorId)
.as('post_counts');
const prolificAuthors = await db
.select({
name: users.name,
email: users.email,
postCount: subquery.postCount,
})
.from(users)
.innerJoin(subquery, eq(users.id, subquery.authorId))
.where(gt(subquery.postCount, 10))
.orderBy(desc(subquery.postCount));
// Aggregations
const stats = await db
.select({
role: users.role,
count: count(),
avgCredits: avg(users.credits),
})
.from(users)
.where(eq(users.isActive, true))
.groupBy(users.role);
// Nested queries with the relational API
const usersWithPosts = await db.query.users.findMany({
where: eq(users.isActive, true),
columns: {
id: true,
name: true,
email: true,
},
with: {
posts: {
where: eq(posts.published, true),
orderBy: [desc(posts.createdAt)],
limit: 5,
columns: {
id: true,
title: true,
slug: true,
createdAt: true,
},
with: {
categories: {
with: {
category: true,
},
},
},
},
profile: true,
},
orderBy: [desc(users.createdAt)],
limit: 20,
});
// Find first
const user = await db.query.users.findFirst({
where: eq(users.email, 'jane@example.com'),
with: { profile: true },
});
// Transaction
async function transferCredits(fromId: string, toId: string, amount: number) {
return db.transaction(async (tx) => {
const [sender] = await tx
.select({ credits: users.credits })
.from(users)
.where(eq(users.id, fromId))
.for('update'); // SELECT ... FOR UPDATE
if (!sender || sender.credits < amount) {
throw new Error('Insufficient credits');
// Transaction auto-rolls back on throw
}
await tx
.update(users)
.set({ credits: sql`${users.credits} - ${amount}` })
.where(eq(users.id, fromId));
await tx
.update(users)
.set({ credits: sql`${users.credits} + ${amount}` })
.where(eq(users.id, toId));
return { success: true };
});
}
// Prepared statements (reusable, optimized)
const getUserByEmail = db
.select()
.from(users)
.where(eq(users.email, sql.placeholder('email')))
.prepare('get_user_by_email');
const user = await getUserByEmail.execute({ email: 'jane@example.com' });
// Dynamic where builder
function buildFilter(params: {
search?: string;
role?: string;
active?: boolean;
}) {
const conditions = [];
if (params.search) {
conditions.push(
or(
ilike(users.name, `%${params.search}%`),
ilike(users.email, `%${params.search}%`),
)
);
}
if (params.role) {
conditions.push(eq(users.role, params.role));
}
if (params.active !== undefined) {
conditions.push(eq(users.isActive, params.active));
}
return conditions.length > 0 ? and(...conditions) : undefined;
}
// drizzle.config.ts
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
schema: './db/schema/*',
out: './db/migrations',
dialect: 'postgresql',
dbCredentials: {
url: process.env.DATABASE_URL!,
},
verbose: true,
strict: true,
});
# Generate migration from schema changes
npx drizzle-kit generate
# Apply migrations
npx drizzle-kit migrate
# Open Drizzle Studio (database GUI)
npx drizzle-kit studio
# Push schema directly (development only)
npx drizzle-kit push
$inferSelect and $inferInsert for type exports, not manual type definitionssql.placeholder() for dynamic but safe parameterized queriesfeatures/users/schema.tsdrizzle-kit generate for migrations, not push in production.returning() after insert/update to avoid extra SELECT queriesfor('update') in transactions to prevent race conditions| Pitfall | Impact | Fix |
|---|---|---|
Missing relations() definitions | Relational queries fail | Define relations for all foreign keys |
Using push in production | Data loss risk | Use generate + migrate in production |
Not using .returning() | Extra SELECT query needed | Chain .returning() on insert/update |
| Missing indexes on foreign keys | Slow joins | Add index() on all FK columns |
Not handling undefined in dynamic filters | Invalid SQL generated | Use conditional array building with and() |
Forgetting $onUpdate for updatedAt | Stale timestamps | Add .$onUpdate(() => new Date()) |
Using raw SQL without sql template | SQL injection risk | Always use sql\...`` tagged template |