القائمة
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يبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى 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 |