feat: Add database skill with Drizzle ORM and bun:sqlite

Author: ciro-maciel

.agent/skills/riligar-design-system/references/design-system.md

@@ -104,10 +104,3 @@ Ao pedir código ou design para uma IA, use este formato:
 - **Modais:** Devem ter um backdrop com blur (`backdrop-blur-sm`) e fundo branco sólido. Sem cabeçalhos coloridos.
 - **Dashboards:** Devem privilegiar números grandes (Big Numbers) em monocromia, com rótulos pequenos abaixo. Gráficos devem ser limpos, sem grid lines pesadas.
 
----
-
-## 🤖 Integração com Gemini CLI
-
-Este repositório possui uma **Skill do Gemini CLI** configurada em [`riligar-design-system/SKILL.md`](../SKILL.md). Ao usar o Gemini CLI neste repositório, o agente aplicará automaticamente estas diretrizes a qualquer código ou design gerado.
-
-Para saber como usar, veja o [README principal](../../README.md).

.agent/skills/riligar-dev-database/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: riligar-dev-database
+description: Database patterns for RiLiGar using Drizzle ORM + bun:sqlite. Use when setting up database connections, defining schemas, creating migrations, or writing queries. Covers SQLite on Fly.io volumes with the drizzle-kit workflow.
+---
+
+# Database — Drizzle + bun:sqlite
+
+> SQLite nativo no Bun. Zero drivers externos. Base de dados no volume do Fly.io (`/app/data`).
+
+## Referências
+
+| Arquivo | Quando usar |
+| --- | --- |
+| [connection.md](references/connection.md) | Setup inicial: instalação, db.js, drizzle.config |
+| [schema.md](references/schema.md) | Definir tabelas, tipos de colunas, relações |
+| [migrations.md](references/migrations.md) | Criar e executar migrations com drizzle-kit |
+| [queries.md](references/queries.md) | Select, insert, update, delete, queries com relações |
+
+## Quick Start
+
+```javascript
+// database/db.js
+import { drizzle } from 'drizzle-orm/bun-sqlite'
+import Database from 'bun:sqlite'
+
+const sqlite = new Database(process.env.DB_PATH ?? './data/database.db')
+const db = drizzle({ client: sqlite })
+
+export { db }
+```
+
+## Regras
+
+- **Caminho do banco:** `/app/data/database.db` em produção (volume Fly.io). `./data/database.db` em desenvolvimento.
+- **Migrations sempre:** Use `drizzle-kit generate` + `drizzle-kit migrate`. Nunca edite migrations à mão.
+- **Schema único:** Todas as tabelas em `database/schema.js`.
+- **Migrations no startup:** Use `migrate()` no `index.js` antes de `.listen()`.
+
+## Related Skills
+
+| Need | Skill |
+| --- | --- |
+| **Backend (Elysia)** | @[.agent/skills/riligar-dev-manager] |
+| **Payments (Stripe)** | @[.agent/skills/riligar-infra-stripe] |
+| **Infrastructure** | @[.agent/skills/riligar-infra-fly] |

.agent/skills/riligar-dev-database/references/connection.md

@@ -0,0 +1,74 @@
+# Database Connection
+
+## Installation
+
+```bash
+bun add drizzle-orm
+bun add -d drizzle-kit
+```
+
+No additional drivers needed — `bun:sqlite` is built into Bun.
+
+## db.js
+
+```javascript
+// database/db.js
+import { drizzle } from 'drizzle-orm/bun-sqlite'
+import Database from 'bun:sqlite'
+
+const sqlite = new Database(process.env.DB_PATH ?? './data/database.db')
+const db = drizzle({ client: sqlite })
+
+export { db }
+```
+
+- Em **desenvolvimento**: `DB_PATH` não é definido → usa `./data/database.db`
+- Em **produção** (Fly.io): `fly secrets set DB_PATH=/app/data/database.db`
+
+## drizzle.config.js
+
+```javascript
+// drizzle.config.js (na raiz do projeto)
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+    dialect: 'sqlite',
+    schema: './database/schema.js',
+    out: './database/migrations',
+    dbCredentials: {
+        url: process.env.DB_PATH ?? './data/database.db',
+    },
+})
+```
+
+## Migrations no Startup
+
+No `index.js`, execute migrations antes de iniciar o servidor:
+
+```javascript
+// index.js
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator'
+import { db } from './database/db'
+
+await migrate(db, { migrationsFolder: './database/migrations' })
+
+// ... resto do setup
+const app = new Elysia()
+    .use(routes)
+    .listen(3000)
+```
+
+Isso garante que o banco esteja sempre atualizado quando o servidor inicia no Fly.io.
+
+## Estrutura de Arquivos
+
+```
+database/
+├── db.js              # Conexão (drizzle + bun:sqlite)
+├── schema.js          # Todas as tabelas e relações
+└── migrations/
+    ├── 0000_*.sql     # Migrations geradas pelo drizzle-kit
+    ├── 0001_*.sql
+    └── meta/
+        └── _journal.json
+```

.agent/skills/riligar-dev-database/references/migrations.md

@@ -0,0 +1,70 @@
+# Migrations — drizzle-kit
+
+## Fluxo Padrão
+
+```
+1. Edite database/schema.js
+2. bun run db:generate    → gera migration SQL
+3. bun run db:migrate     → aplica no banco
+```
+
+## Scripts no package.json
+
+```javascript
+{
+    "scripts": {
+        "db:generate": "drizzle-kit generate",
+        "db:migrate": "drizzle-kit migrate",
+        "db:push": "drizzle-kit push",
+        "db:studio": "drizzle-kit studio"
+    }
+}
+```
+
+## Comandos
+
+### Gerar migration
+
+```bash
+bun run db:generate
+```
+
+Compara o schema atual com o último snapshot. Gera um arquivo `.sql` em `database/migrations/`. Pergunta se algum campo foi renomeado (vs criado novo + deletado).
+
+### Aplicar migrations
+
+```bash
+bun run db:migrate
+```
+
+Lê as migrations não aplicadas, executa em ordem. Mantém histórico no banco.
+
+### Push (apenas desenvolvimento)
+
+```bash
+bun run db:push
+```
+
+Aplica mudanças diretamente no banco sem gerar arquivos de migration. Útil durante prototipage rápido. **Nunca use em produção.**
+
+### Studio (GUI)
+
+```bash
+bun run db:studio
+```
+
+Abre uma interface visual para explorar e editar dados no banco.
+
+## Migrations Programáticas (Startup)
+
+Em produção, as migrations são executadas automaticamente no startup da aplicação:
+
+```javascript
+// index.js
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator'
+import { db } from './database/db'
+
+await migrate(db, { migrationsFolder: './database/migrations' })
+```
+
+Isso garante que o banco esteja sempre atualizado quando o servidor inicia no Fly.io.

.agent/skills/riligar-dev-database/references/queries.md

@@ -0,0 +1,173 @@
+# Queries — Drizzle
+
+## Imports Comuns
+
+```javascript
+import { db } from '../database/db'
+import { users, posts } from '../database/schema'
+import { eq, and, or, desc, asc } from 'drizzle-orm'
+```
+
+## Select
+
+### Básico
+
+```javascript
+// Todos os registros
+const allUsers = await db.select().from(users)
+
+// Campos específicos
+const names = await db.select({
+    id: users.id,
+    name: users.name,
+}).from(users)
+```
+
+### Filtrar
+
+```javascript
+// Por campo único
+const [user] = await db.select().from(users).where(eq(users.id, userId)).limit(1)
+
+// Múltiplos filtros (AND)
+const results = await db.select().from(users).where(
+    and(
+        eq(users.active, true),
+        eq(users.plan, 'pro')
+    )
+)
+
+// OR
+const results = await db.select().from(users).where(
+    or(eq(users.id, '1'), eq(users.id, '2'))
+)
+```
+
+### Ordenar e Paginar
+
+```javascript
+const page = await db.select().from(posts)
+    .orderBy(desc(posts.createdAt))
+    .limit(10)
+    .offset(pageIndex * 10)
+```
+
+## Insert
+
+```javascript
+// Básico
+await db.insert(users).values({ name: 'Dan', email: 'dan@email.com' })
+
+// Com retorno
+const [user] = await db.insert(users)
+    .values({ name: 'Dan', email: 'dan@email.com' })
+    .returning()
+
+// Múltiplos
+await db.insert(users).values([
+    { name: 'Dan', email: 'dan@email.com' },
+    { name: 'Ana', email: 'ana@email.com' },
+])
+
+// Upsert (conflict handling)
+await db.insert(users)
+    .values({ id: '1', name: 'Dan' })
+    .onConflictDoUpdate({
+        target: users.id,
+        set: { name: 'Dan', updatedAt: new Date() },
+    })
+```
+
+## Update
+
+```javascript
+await db.update(users)
+    .set({ name: 'Mr. Dan', updatedAt: new Date() })
+    .where(eq(users.id, userId))
+
+// Com retorno
+const [updated] = await db.update(users)
+    .set({ plan: 'pro' })
+    .where(eq(users.id, userId))
+    .returning()
+```
+
+## Delete
+
+```javascript
+await db.delete(users).where(eq(users.id, userId))
+
+// Com retorno
+const [deleted] = await db.delete(users)
+    .where(eq(users.id, userId))
+    .returning()
+```
+
+## Queries com Relações
+
+Quando tiver relações definidas no schema, use `db.query` em vez de `db.select`:
+
+```javascript
+// Usuário com todos os posts
+const user = await db.query.users.findOne({
+    where: eq(users.id, userId),
+    with: {
+        posts: true,
+    },
+})
+
+// Posts com autor
+const posts = await db.query.posts.findMany({
+    with: {
+        author: true,
+    },
+    orderBy: desc(posts.createdAt),
+    limit: 10,
+})
+
+// Nesting profundo
+const user = await db.query.users.findOne({
+    where: eq(users.id, userId),
+    with: {
+        posts: {
+            with: {
+                comments: true,
+            },
+        },
+    },
+})
+```
+
+## Padrão de Serviço
+
+Sempre encapsule queries em serviços:
+
+```javascript
+// services/user.js
+import { db } from '../database/db'
+import { users } from '../database/schema'
+import { eq } from 'drizzle-orm'
+
+export async function getUserById(id) {
+    const [user] = await db.select().from(users).where(eq(users.id, id)).limit(1)
+    return user ?? null
+}
+
+export async function createUser(data) {
+    const [user] = await db.insert(users).values(data).returning()
+    return user
+}
+
+export async function updateUser(id, data) {
+    const [user] = await db.update(users)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(users.id, id))
+        .returning()
+    return user ?? null
+}
+
+export async function deleteUser(id) {
+    const [user] = await db.delete(users).where(eq(users.id, id)).returning()
+    return user ?? null
+}
+```