drizzle-sqlite-scaffold

Scaffolds Drizzle ORM + SQLite boilerplate — a new `drizzle.config.ts`, a singleton client with the right pragmas, per-table schema files with explicit primary keys/indexed foreign keys/relations()/inferred types, per-table repository modules with `.returning()` + `inArray()` + `.onConflictDoUpdate()`, or drizzle-zod validators. Produces convention-enforced templates for three drivers (better-sqlite3, libsql/Turso, bun:sqlite). Trigger even when the user doesn't say "scaffold" — phrases like "add a table for X", "set up Drizzle in this project", "wire up SQLite", "create a CRUD module for X", or "bootstrap the DB layer" should pull this in. Pairs with the `drizzle-sqlite` skill, which covers the 45 rules these templates encode — read it when an exception is required.

Jump to install

Repository: pproenca/dot-skills
Last source activity: July 5, 2026 at 07:23
Detected SKILL.md language: English
Stars: 194
Forks: 17

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

A direct command skips the review prompt. Inspect the source before running it.

npx skills add https://github.com/pproenca/dot-skills --skill drizzle-sqlite-scaffold

The command stays on one line. Scroll horizontally to inspect it before copying.

Prefer a local copy? Download the files currently available to SkillsMP.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer

15 files

SKILL.md

Source instructions · Read-only preview

Back to search Back to installation

drizzle-nextjs-postgres

Drizzle ORM against PostgreSQL inside a Next.js App Router app. Covers client construction (globalThis singleton across HMR, serverless pool sizing, `prepare:false` behind PgBouncer/Supavisor, driver choice when you need interactive transactions, `server-only`), reads in Server Components under Next.js 16 Cache Components (`use cache` superseding `unstable_cache` and the `revalidate`/`dynamic` segment configs, Suspense boundaries, React `cache()` dedupe), Server Actions (authorization inside the action, `updateTag` vs `revalidateTag`, `after()`), Postgres schema types (timestamptz, identity vs serial, jsonb, numeric-as-string, bigint modes), drizzle-kit migrations (generate vs push, CONCURRENTLY outside the migrator, NOT VALID constraints, rename prompts), transactions and pooled connections, and Postgres query traps (keyset pagination, count cost, driver-dependent `db.execute()` shape, NOT IN nulls, prepared statements). Use when writing or reviewing Drizzle + Postgres code in Next.js.

2026-07-24

relational-data-modeling

Corrects the wrong defaults a model has when designing a relational schema — the DDL decisions an experienced engineer makes differently. Use when creating or reviewing tables, migrations, ER models, or ORM schema definitions. Covers identity and keys (surrogate vs natural, identity vs serial, uuidv7, composite keys that make cross-tenant references impossible), relationships (polymorphic foreign keys the database cannot enforce, referential actions, unindexed FK columns, disjoint subtypes), invariants the engine can prove instead of application code (EXCLUDE, partial unique indexes, CHECK limits, deferrable cycles, NOT VALID), types (timestamptz, exact money, range types, enum vs lookup table), derived and encoded data (generated columns, JSONB as an escape hatch), and time (events vs in-place updates, soft-delete flags that silently disable constraints, temporal keys). NOT for query tuning, index selection for read paths, or connection pooling.

2026-07-23

relational-database-design

Distills a logical relational-database design methodology into rules an agent applies while designing or reviewing a schema. Covers the design sequence (mission → tables → fields → keys → relationships → business rules → views → integrity review), one-subject-per-table decomposition, atomic single-valued fields, candidate/primary/foreign keys, relationship types with deletion rules and participation, the four levels of data integrity, database-vs-application business rules, validation tables, views for derived data, and the flat-file / spreadsheet / RDBMS-driven antipatterns to avoid. The structure is logical and RDBMS-agnostic, and normalized by construction. Use when designing a new relational schema, reviewing or refactoring an existing one, resolving redundant or repeating data, choosing keys, modeling relationships, or deciding where a constraint belongs.

2026-07-23

View all from this repository

Drizzle SQLite Scaffold

Parameterized templates for bootstrapping Drizzle + SQLite in a fresh project, or adding a new table/repository to an existing one. Every output bakes in the conventions documented in references/conventions.md — explicit primary keys, indexed foreign keys, relations() declarations, $inferSelect/$inferInsert exports, timestamp_ms dates, boolean-mode bools, WAL + foreign_keys=ON + busy_timeout pragmas, singleton client with HMR guard, and CRUD helpers using .returning() + inArray() + .onConflictDoUpdate().

When to Apply

Reach for these templates when:

Starting a new project that will use Drizzle with SQLite (any driver)

Adding a new table to an existing Drizzle project — the table file should match the existing patterns

Adding a CRUD repository module for an existing table

Refactoring a hand-rolled Drizzle setup that's missing pragmas, has no relations(), or has hand-written User types that drift from the schema

Drizzle SQLite Scaffold

When to Apply

Reach for these templates when:

Starting a new project that will use Drizzle with SQLite (any driver)

Adding a new table to an existing Drizzle project — the table file should match the existing patterns

Adding a CRUD repository module for an existing table

Refactoring a hand-rolled Drizzle setup that's missing pragmas, has no relations(), or has hand-written User types that drift from the schema

Placeholder

Type

Source / derivation

{{driver}}

simple sub

config.json:driver

{{db_url_env}}

simple sub

config.json:db_url_env

{{schema_dir}}

simple sub

config.json:schema_dir

{{repository_dir}}

simple sub

config.json:repository_dir

{{validators_dir}}

simple sub

config.json:validators_dir

{{client_path}}

simple sub

config.json:client_path

{{migrations_dir}}

simple sub

config.json:migrations_dir

{{schema_index_import}}

simple sub

derived: client_path → relative path to {{schema_dir}}/index.ts (typically './schema')

{{client_import}}

simple sub

derived: from a repository file, relative path back to client_path (typically '../client')

{{schema_import}}

simple sub

derived: from a repository or validators file, relative path to the matching table file (typically '../schema/{{name}}')

{{name}}

simple sub

per-table param — kebab-case singular (user)

{{name_camel}}

simple sub

derived from name (user, orderItem)

{{name_pascal}}

simple sub

derived from name (User, OrderItem)

{{table_name}}

simple sub

per-table param, default = snake_case plural of name (users, order_items)

{{pk}}

metadata

per-table param — serial-int | uuid | cuid2 | text (drives the rows below)

{{pk_definition}}

block

the actual PK column line — see "PK Variants" table

{{pk_field}}

simple sub

always id for the four PK variants this skill ships

{{pk_ts_type}}

simple sub

number for serial-int, string for uuid / cuid2 / text

{{pk_extra_imports}}

block

empty for serial-int / uuid / text; import { createId } from '@paralleldrive/cuid2'; for cuid2

{{relation_imports}}

block

for each table in relations[], emit import { {{relatedCamel}} } from './{{related-kebab}}';

{{domain_columns}}

block

the agent (or user) replaces this with the actual non-PK, non-timestamp columns for the entity. Leave as a TODO comment if the user hasn't provided them yet.

{{timestamps_block}}

block

see expansion below — emit when timestamps=true, remove the line entirely when false

{{soft_delete_block}}

block

see expansion below — emit in the columns block when soft_delete=true

{{indexes}}

block

one index(...) line per foreign key column (and any composite (authorId, publishedAt)-style indexes the user wants)

{{soft_delete_index}}

block

the partial index on deletedAt (see expansion below); emit only when soft_delete=true

{{relations_body}}

block

one one(...) / many(...) line per related table; see expansion below

{{insert_refinements}}

block

drizzle-zod refinement callbacks for the INSERT shape; leave the example comment if none provided

{{update_refinements}}

block

same for the partial UPDATE shape

{{exports}}

block

inside schema-index.ts.template: one export * from './{{name}}'; line per table; append on each new-table run

Parameter	Required	Default	Values
`driver`	yes	—	`better-sqlite3` \| `libsql` \| `bun-sqlite` (D1 has a different lifecycle — see "Cloudflare D1" below)
`db_url_env`	no	`DATABASE_URL`	env var name
`schema_dir`	no	`./src/db/schema`	per-table schema files
`repository_dir`	no	`./src/db/repository`	per-table CRUD modules
`validators_dir`	no	`./src/db/validators`	drizzle-zod schemas (when `with_zod=true`)
`client_path`	no	`./src/db/client.ts`	singleton client module
`migrations_dir`	no	`./drizzle`	drizzle-kit output

Parameter	Required	Default	Description
`name`	yes	—	Kebab-case singular: `user`, `order-item`. Used for filenames and TS identifiers (`name_camel`, `name_pascal` derived).
`table_name`	no	snake_case plural of `name`	SQL table name: `users`, `order_items`
`pk`	no	`serial-int`	`serial-int` \| `uuid` \| `cuid2` \| `text`
`timestamps`	no	`true`	adds `createdAt`/`updatedAt` columns
`soft_delete`	no	`false`	adds nullable `deletedAt` + partial index
`relations`	no	`[]`	list of related table names — expands `relations()` body
`with_zod`	no	`true`	emits a drizzle-zod validators file

Template	Output File	When
`drizzle.config.local.ts.template`	`drizzle.config.ts`	`driver` is `better-sqlite3`, `bun-sqlite`, or `libsql` with a `file:` URL
`drizzle.config.turso.ts.template`	`drizzle.config.ts`	`driver` is `libsql` against Turso (remote `libsql:` URL)
`client.better-sqlite3.ts.template`	`{{client_path}}`	`driver` is `better-sqlite3`
`client.libsql.ts.template`	`{{client_path}}`	`driver` is `libsql`
`client.bun-sqlite.ts.template`	`{{client_path}}`	`driver` is `bun-sqlite`
`schema-index.ts.template`	`{{schema_dir}}/index.ts`	Always (initially empty; append exports as tables are added)
`gitignore.template`	`.gitignore` (append)	Always

Template	Output File	When
`table.ts.template`	`{{schema_dir}}/{{name}}.ts`	Per table
`repository.ts.template`	`{{repository_dir}}/{{name}}.ts`	Per table
`validators.ts.template`	`{{validators_dir}}/{{name}}.ts`	Per table when `with_zod=true`

`pk` value	`pk_definition`	`pk_ts_type`	Extra imports
`serial-int` (default)	`id: integer().primaryKey({ autoIncrement: true }),`	`number`	—
`uuid`	`id: text().primaryKey().$defaultFn(() => crypto.randomUUID()),`	`string`	— (uses Web Crypto)
`cuid2`	`id: text().primaryKey().$defaultFn(() => createId()),`	`string`	`import { createId } from '@paralleldrive/cuid2';`
`text`	`id: text().primaryKey(),`	`string`	— (caller supplies the ID)

drizzle-sqlite-scaffold

Install options

Review the source files