Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.
TypeScript i18nextnext-authnextjspostgresqlprismareact-emailt3-stacktailwindcsstrpcturborepotypescriptzod
π Move rules to skills
Luke Vella5d225664b6a7
diff --git a/.claude/rules/logging.md b/.agents/skills/logging/SKILL.mdsimilarity index 89%rename from .claude/rules/logging.mdrename to .agents/skills/logging/SKILL.mdindex a3fe281c3..df28b9611 100644--- a/.claude/rules/logging.md+++ b/.agents/skills/logging/SKILL.md@@ -1,3 +1,9 @@+---+name: logging+description: Wide events logging pattern and conventions for this project. Use when writing logging code, adding observability, or implementing request tracing.+user-invocable: false+---+# Logging GuidelinesThis project follows the **Wide Events** pattern. Logs are optimized for querying, not writing.@@ -107,13 +113,7 @@ When implementing log sampling, make decisions **after** request completion:## High-Cardinality Data-Include high-cardinality fields (userId, pollId, requestId). Modern observability tools handle this efficiently. High-cardinality data enables queries like:--> "Show me all poll creation failures for pro users in the last hour where the quick-create feature flag was enabled, grouped by error code"--## Field Guidelines--Aim for 50+ fields per event. More context means faster debugging. Include:+Include high-cardinality fields (userId, pollId, requestId). Modern observability tools handle this efficiently. Aim for 50+ fields per event. Include:- All IDs involved in the request- All feature flags evaluateddiff --git a/.agents/skills/prisma-cli/SKILL.md b/.agents/skills/prisma-cli/SKILL.mdnew file mode 100644index 000000000..cb1b609ca--- /dev/null+++ b/.agents/skills/prisma-cli/SKILL.md@@ -0,0 +1,243 @@+---+name: prisma-cli+description: Prisma CLI commands reference covering all available commands, options, and usage patterns. Use when running Prisma CLI commands, setting up projects, generating client, running migrations, or managing databases. Triggers on "prisma init", "prisma generate", "prisma migrate", "prisma db", "prisma studio".+license: MIT+metadata:+ author: prisma+ version: "7.0.0"+---++# Prisma CLI Reference++Complete reference for all Prisma CLI commands. This skill provides guidance on command usage, options, and best practices for Prisma ORM 7.x.++## When to Apply++Reference this skill when:+- Setting up a new Prisma project (`prisma init`)+- Generating Prisma Client (`prisma generate`)+- Running database migrations (`prisma migrate`)+- Managing database state (`prisma db push/pull`)+- Using local development database (`prisma dev`)+- Debugging Prisma issues (`prisma debug`)++## Rule Categories by Priority++| Priority | Category | Impact | Prefix |+|----------|----------|--------|--------|+| 1 | Setup | HIGH | `init` |+| 2 | Generation | HIGH | `generate` |+| 3 | Development | HIGH | `dev` |+| 4 | Database | HIGH | `db-` |+| 5 | Migrations | CRITICAL | `migrate-` |+| 6 | Utility | MEDIUM | `studio`, `validate`, `format`, `debug` |++## Command Categories++| Category | Commands | Purpose |+|----------|----------|---------|+| Setup | `init` | Bootstrap new Prisma project |+| Generation | `generate` | Generate Prisma Client |+| Validation | `validate`, `format` | Schema validation and formatting |+| Development | `dev` | Local Prisma Postgres for development |+| Database | `db pull`, `db push`, `db seed`, `db execute` | Direct database operations |+| Migrations | `migrate dev`, `migrate deploy`, `migrate reset`, `migrate status`, `migrate diff`, `migrate resolve` | Schema migrations |+| Utility | `studio`, `version`, `debug` | Development tools |++## Quick Reference++### Project Setup++```bash+# Initialize new project (creates prisma/ folder and prisma.config.ts)+prisma init++# Initialize with specific database+prisma init --datasource-provider postgresql+prisma init --datasource-provider mysql+prisma init --datasource-provider sqlite++# Initialize with Prisma Postgres (cloud)+prisma init --db++# Initialize with AI-generated schema+prisma init --prompt "E-commerce app with users, products, orders"+```++### Client Generation++```bash+# Generate Prisma Client+prisma generate++# Watch mode for development+prisma generate --watch++# Generate without engine (for Accelerate/edge)+prisma generate --no-engine++# Generate specific generator only+prisma generate --generator client+```++### Bun Runtime++When using Bun, always add the `--bun` flag so Prisma runs with the Bun runtime (otherwise it falls back to Node.js because of the CLI shebang):++```bash+bunx --bun prisma init+bunx --bun prisma generate+```++### Local Development Database++```bash+# Start local Prisma Postgres+prisma dev++# Start with specific name+prisma dev --name myproject++# Start in background (detached)+prisma dev --detach++# List all local instances+prisma dev ls++# Stop instance+prisma dev stop myproject++# Remove instance data+prisma dev rm myproject+```++### Database Operations++```bash+# Pull schema from existing database+prisma db pull++# Push schema to database (no migrations)+prisma db push++# Seed database+prisma db seed++# Execute raw SQL+prisma db execute --file ./script.sql+```++### Migrations (Development)++```bash+# Create and apply migration+prisma migrate dev++# Create migration with name+prisma migrate dev --name add_users_table++# Create migration without applying+prisma migrate dev --create-only++# Reset database and apply all migrations+prisma migrate reset+```++### Migrations (Production)++```bash+# Apply pending migrations (CI/CD)+prisma migrate deploy++# Check migration status+prisma migrate status++# Compare schemas and generate diff+prisma migrate diff --from-config-datasource --to-schema schema.prisma --script+```++### Utility Commands++```bash+# Open Prisma Studio (database GUI)+prisma studio++# Show version info+prisma version+prisma -v++# Debug information+prisma debug++# Validate schema+prisma validate++# Format schema+prisma format+```++## Prisma 7 Changes++### New Configuration File++Prisma 7 uses `prisma.config.ts` for CLI configuration:++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ seed: 'tsx prisma/seed.ts',+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++### Removed Flags++- `--skip-generate` removed from `migrate dev` and `db push`+- `--skip-seed` removed from `migrate dev`+- `--schema` and `--url` removed from `db execute`+- Run `prisma generate` explicitly after migrations++### Environment Variables++Environment variables are no longer auto-loaded. Use `dotenv`:++```typescript+// prisma.config.ts+import 'dotenv/config'+```++## Rule Files++See individual rule files for detailed command documentation:++```+references/init.md - Project initialization+references/generate.md - Client generation+references/dev.md - Local development database+references/db-pull.md - Database introspection+references/db-push.md - Schema push+references/db-seed.md - Database seeding+references/db-execute.md - Raw SQL execution+references/migrate-dev.md - Development migrations+references/migrate-deploy.md - Production migrations+references/migrate-reset.md - Database reset+references/migrate-status.md - Migration status+references/migrate-resolve.md - Migration resolution+references/migrate-diff.md - Schema diffing+references/studio.md - Database GUI+references/validate.md - Schema validation+references/format.md - Schema formatting+references/debug.md - Debug info+```++## How to Use++Use the command categories above for navigation, then open the specific command reference file you need.diff --git a/.agents/skills/prisma-cli/references/db-execute.md b/.agents/skills/prisma-cli/references/db-execute.mdnew file mode 100644index 000000000..15159b242--- /dev/null+++ b/.agents/skills/prisma-cli/references/db-execute.md@@ -0,0 +1,75 @@+# prisma db execute++Execute native commands (SQL) to your database.++## Command++```bash+prisma db execute [options]+```++## What It Does++- Connects to your database using the configured datasource+- Executes a script provided via file (`--file`) or stdin (`--stdin`)+- Useful for running raw SQL, maintenance tasks, or applying diffs from `migrate diff`+- Not supported on MongoDB++## Options++| Option | Description |+|--------|-------------|+| `--file` | Path to a file containing the script to execute |+| `--stdin` | Use terminal standard input as the script |+| `--url` | Override the datasource URL from the Prisma config file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Execute from file++```bash+prisma db execute --file ./script.sql+```++### Execute from stdin++```bash+echo "TRUNCATE TABLE User;" | prisma db execute --stdin+```++### Execute `migrate diff` output++Pipe the output of `migrate diff` directly to the database:++```bash+prisma migrate diff \+ --from-empty \+ --to-schema-datamodel prisma/schema.prisma \+ --script \+| prisma db execute --stdin+```++## Configuration++Uses `datasource` from `prisma.config.ts`:++```typescript+export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Use Cases++- **Manual Migrations**: Applying raw SQL changes+- **Data Maintenance**: Truncating tables, cleaning up data+- **Schema Synchronization**: Applying `migrate diff` scripts+- **Debugging**: Running test queries (though typically not for fetching data)++## Limitations++- **No Data Return**: The command reports success/failure, not query results (rows). Use Prisma Client or `prisma studio` to view data.+- **SQL Only**: Primarily for SQL databases.diff --git a/.agents/skills/prisma-cli/references/db-pull.md b/.agents/skills/prisma-cli/references/db-pull.mdnew file mode 100644index 000000000..58a6e47d0--- /dev/null+++ b/.agents/skills/prisma-cli/references/db-pull.md@@ -0,0 +1,185 @@+# prisma db pull++Introspects an existing database and updates your Prisma schema to reflect its structure.++## Command++```bash+prisma db pull [options]+```++## What It Does++- Connects to your database+- Reads the database schema (tables, columns, relations, indexes)+- Updates `schema.prisma` with corresponding Prisma models+- For MongoDB, samples data to infer schema++## Options++| Option | Description |+|--------|-------------|+| `--force` | Ignore current Prisma schema file |+| `--print` | Print the introspected Prisma schema to stdout |+| `--schema` | Custom path to your Prisma schema |+| `--config` | Custom path to your Prisma config file |+| `--url` | Override the datasource URL from the Prisma config file |+| `--composite-type-depth` | Specify the depth for introspecting composite types (default: -1 for infinite, 0 = off) |+| `--schemas` | Specify the database schemas to introspect |+| `--local-d1` | Generate a Prisma schema from a local Cloudflare D1 database |++## Examples++### Basic introspection++```bash+prisma db pull+```++### Preview without writing++```bash+prisma db pull --print+```++Outputs schema to terminal for review.++### Force overwrite++```bash+prisma db pull --force+```++Replaces schema file, losing any manual customizations.++## Prerequisites++Configure database connection in `prisma.config.ts`:++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Workflow++### Starting from existing database++1. Initialize Prisma:+ ```bash+ prisma init+ ```++2. Configure database URL++3. Pull schema:+ ```bash+ prisma db pull+ ```++4. Review and customize generated schema++5. Generate client:+ ```bash+ prisma generate+ ```++### Syncing changes from database++When database changes are made outside Prisma:++```bash+prisma db pull+prisma generate+```++## Generated Schema Example++Database tables become Prisma models:++```sql+-- Database tables+CREATE TABLE users (+ id SERIAL PRIMARY KEY,+ email VARCHAR(255) UNIQUE NOT NULL,+ name VARCHAR(100)+);++CREATE TABLE posts (+ id SERIAL PRIMARY KEY,+ title VARCHAR(255) NOT NULL,+ author_id INTEGER REFERENCES users(id)+);+```++Becomes:++```prisma+model users {+ id Int @id @default(autoincrement())+ email String @unique @db.VarChar(255)+ name String? @db.VarChar(100)+ posts posts[]+}++model posts {+ id Int @id @default(autoincrement())+ title String @db.VarChar(255)+ author_id Int?+ users users? @relation(fields: [author_id], references: [id])+}+```++## Post-Introspection Cleanup++After `db pull`, consider:++1. **Rename models** to PascalCase:+ ```prisma+ model User { // Was: users+ @@map("users")+ }+ ```++2. **Rename fields** to camelCase:+ ```prisma+ authorId Int? @map("author_id")+ ```++3. **Add relation names** for clarity:+ ```prisma+ author User? @relation("PostAuthor", fields: [authorId], references: [id])+ ```++4. **Add documentation**:+ ```prisma+ /// User account information+ model User {+ /// Primary email for authentication+ email String @unique+ }+ ```++## MongoDB Introspection++For MongoDB, `db pull` samples documents to infer schema:++```bash+prisma db pull+```++May require manual refinement since MongoDB is schemaless.++## Warning++`db pull` overwrites your schema file. Always:+- Commit current schema before pulling+- Use `--print` to preview first+- Backup customizations you want to keepdiff --git a/.agents/skills/prisma-cli/references/db-push.md b/.agents/skills/prisma-cli/references/db-push.mdnew file mode 100644index 000000000..eefd32d0d--- /dev/null+++ b/.agents/skills/prisma-cli/references/db-push.md@@ -0,0 +1,148 @@+# prisma db push++Pushes schema changes directly to database without creating migrations. Ideal for prototyping.++## Command++```bash+prisma db push [options]+```++## What It Does++- Syncs your Prisma schema to the database+- Creates database if it doesn't exist+- Does NOT create migration files+- Does NOT track migration history++## Options++| Option | Description |+|--------|-------------|+| `--force-reset` | Force a reset of the database before push |+| `--accept-data-loss` | Ignore data loss warnings |+| `--schema` | Custom path to your Prisma schema |+| `--config` | Custom path to your Prisma config file |+| `--url` | Override the datasource URL from the Prisma config file |++### Removed in v7++- `--skip-generate` - Run `prisma generate` explicitly++## Examples++### Basic push++```bash+prisma db push+```++### Accept data loss++```bash+prisma db push --accept-data-loss+```++Required when changes would delete data (dropping columns, etc.)++### Force reset++```bash+prisma db push --force-reset+```++Completely resets database and applies schema.++### Full workflow (v7)++```bash+prisma db push+prisma generate # Must run explicitly in v7+```++## When to Use++- **Prototyping** - Rapid schema iteration+- **Local development** - Quick schema changes+- **MongoDB** - Primary workflow (migrations not supported)+- **Testing** - Setting up test databases++## When NOT to Use++- **Production** - Use `migrate deploy`+- **Team collaboration** - Use migrations for trackable changes+- **When you need rollback** - Migrations provide history++## Comparison with migrate dev++| Feature | db push | migrate dev |+|---------|---------|-------------|+| Creates migration files | No | Yes |+| Tracks history | No | Yes |+| Requires shadow database | No | Yes |+| Speed | Faster | Slower |+| Rollback capability | No | Yes |+| Best for | Prototyping | Development |++## MongoDB Workflow++MongoDB doesn't support migrations. Use `db push` exclusively:++```bash+# Schema changes for MongoDB+prisma db push+prisma generate+```++## Common Patterns++### Prototyping workflow++```bash+# Make schema changes+# ...++# Push to database+prisma db push++# Generate client+prisma generate++# Test your changes+# Repeat as needed+```++### Reset and start fresh++```bash+prisma db push --force-reset+prisma db seed+```++### Handling conflicts++If `db push` can't apply changes safely:++```+Error: The following changes cannot be applied:+ - Removing field `email` would cause data loss++Use --accept-data-loss to proceed+```++Decide whether data loss is acceptable, then:++```bash+prisma db push --accept-data-loss+```++## Transition to Migrations++When ready for production, switch to migrations:++```bash+# Create baseline migration from current schema+prisma migrate dev --name init+```++Then use `migrate dev` for future changes.diff --git a/.agents/skills/prisma-cli/references/db-seed.md b/.agents/skills/prisma-cli/references/db-seed.mdnew file mode 100644index 000000000..2bc5e2092--- /dev/null+++ b/.agents/skills/prisma-cli/references/db-seed.md@@ -0,0 +1,191 @@+# prisma db seed++Runs your database seed script to populate data.++## Command++```bash+prisma db seed [options]+```++## What It Does++- Executes your configured seed script+- Populates database with initial/test data+- Runs independently (not auto-run by migrations in v7)++## Options++| Option | Description |+|--------|-------------|+| `--config` | Custom path to your Prisma config file |+| `--` | Pass custom arguments to seed script |++## Configuration++Configure seed script in `prisma.config.ts`:++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ seed: 'tsx prisma/seed.ts', // Your seed command+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++### Common seed commands++```typescript+// TypeScript with tsx+seed: 'tsx prisma/seed.ts'++// TypeScript with ts-node+seed: 'ts-node prisma/seed.ts'++// JavaScript+seed: 'node prisma/seed.js'+```++## Seed Script Example++```typescript+// prisma/seed.ts+import { PrismaClient } from '../generated/client'++const prisma = new PrismaClient()++async function main() {+ // Create users+ const alice = await prisma.user.upsert({+ where: { email: '[email protected]' },+ update: {},+ create: {+ email: '[email protected]',+ name: 'Alice',+ posts: {+ create: {+ title: 'Hello World',+ published: true,+ },+ },+ },+ })++ const bob = await prisma.user.upsert({+ where: { email: '[email protected]' },+ update: {},+ create: {+ email: '[email protected]',+ name: 'Bob',+ },+ })++ console.log({ alice, bob })+}++main()+ .then(async () => {+ await prisma.$disconnect()+ })+ .catch(async (e) => {+ console.error(e)+ await prisma.$disconnect()+ process.exit(1)+ })+```++## Examples++### Run seed++```bash+prisma db seed+```++### With custom arguments++```bash+prisma db seed -- --environment development+```++Arguments after `--` are passed to your seed script.++## v7 Changes++In Prisma 7, seeding is NOT automatic after migrations:++```bash+# v7 workflow+prisma migrate dev --name init+prisma generate+prisma db seed # Must run explicitly+```++Previously (v6), `migrate dev` and `migrate reset` auto-ran seeds.++## Idempotent Seeding++Use `upsert` to make seeds re-runnable:++```typescript+// Good: Can run multiple times+await prisma.user.upsert({+ where: { email: '[email protected]' },+ update: {}, // Don't change existing+ create: { email: '[email protected]', name: 'Alice' },+})++// Bad: Fails on second run+await prisma.user.create({+ data: { email: '[email protected]', name: 'Alice' },+})+```++## Common Patterns++### Development reset++```bash+prisma migrate reset --force+prisma db seed+```++### Conditional seeding++```typescript+// prisma/seed.ts+const count = await prisma.user.count()+if (count === 0) {+ // Only seed if empty+ await seedUsers()+}+```++### Environment-specific seeds++```typescript+// prisma/seed.ts+const env = process.env.NODE_ENV || 'development'++if (env === 'development') {+ await seedDevData()+} else if (env === 'test') {+ await seedTestData()+}+```++## Best Practices++1. Use `upsert` for idempotent seeds+2. Keep seeds focused and minimal+3. Use realistic but fake data+4. Document required seed data+5. Version control your seed scriptsdiff --git a/.agents/skills/prisma-cli/references/debug.md b/.agents/skills/prisma-cli/references/debug.mdnew file mode 100644index 000000000..1c2b0afc0--- /dev/null+++ b/.agents/skills/prisma-cli/references/debug.md@@ -0,0 +1,46 @@+# prisma debug++Prints information helpful for debugging and bug reports.++## Command++```bash+prisma debug [options]+```++## What It Does++Outputs details about your Prisma environment, including:+- Prisma CLI version+- Prisma Client version (if installed)+- Engine binaries (Query Engine, Migration Engine, etc.)+- Platform information (OS, Architecture)+- Node.js version+- Configured datasource provider++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Example Output++```+prisma : 7.3.0+@prisma/client : 7.3.0+Operating System : darwin+Architecture : arm64+Node.js : v20.10.0+TypeScript : 5.3.3+Query Compiler : enabled+PSL : ...+Schema Engine : ...+```++## When to Use++- **Troubleshooting**: Checking version mismatches+- **Reporting Issues**: Including environment info in GitHub issues+- **Verifying Installation**: Ensuring correct binaries are downloadeddiff --git a/.agents/skills/prisma-cli/references/dev.md b/.agents/skills/prisma-cli/references/dev.mdnew file mode 100644index 000000000..870efb960--- /dev/null+++ b/.agents/skills/prisma-cli/references/dev.md@@ -0,0 +1,157 @@+# prisma dev++Starts a local Prisma Postgres database for development. Provides a PostgreSQL-compatible database that runs entirely on your machine.++## Command++```bash+prisma dev [options]+```++## What It Does++- Starts a local PostgreSQL-compatible database+- Runs in your terminal or as a background process+- Perfect for development and testing+- Easy migration to Prisma Postgres cloud in production++## Options++| Option | Description | Default |+|--------|-------------|---------|+| `--name` / `-n` | Name for the database instance | `default` |+| `--port` / `-p` | HTTP server port | `51213` |+| `--db-port` / `-P` | Database server port | `51214` |+| `--shadow-db-port` | Shadow database port (for migrations) | `51215` |+| `--detach` / `-d` | Run in background | `false` |+| `--debug` | Enable debug logging | `false` |++## Examples++### Start local database++```bash+prisma dev+```++Interactive mode with keyboard shortcuts:+- `q` - Quit+- `h` - Show HTTP URL+- `t` - Show TCP URLs++### Named instance++```bash+prisma dev --name myproject+```++Useful for multiple projects.++### Background mode++```bash+prisma dev --detach+```++Frees your terminal for other commands.++### Custom ports++```bash+prisma dev --port 5000 --db-port 5432+```++## Instance Management++### List all instances++```bash+prisma dev ls+```++Shows all local Prisma Postgres instances with status.++### Start existing instance++```bash+prisma dev start myproject+```++Starts a previously created instance in background.++### Stop instance++```bash+prisma dev stop myproject+```++### Stop with glob pattern++```bash+prisma dev stop "myproject*"+```++Stops all instances matching pattern.++### Remove instance++```bash+prisma dev rm myproject+```++Removes instance data from filesystem.++### Force remove (stops first)++```bash+prisma dev rm myproject --force+```++## Configuration++Configure your `prisma.config.ts` to use local Prisma Postgres:++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ },+ datasource: {+ // Local Prisma Postgres URL (from prisma dev output)+ url: env('DATABASE_URL'),+ },+})+```++## Workflow++1. Start local database:+ ```bash+ prisma dev+ ```++2. In another terminal, run migrations:+ ```bash+ prisma migrate dev+ ```++3. Generate client:+ ```bash+ prisma generate+ ```++4. Run your application++## Production Migration++When ready for production, switch to Prisma Postgres cloud:++```bash+prisma init --db+```++Update your `DATABASE_URL` to the cloud connection string.diff --git a/.agents/skills/prisma-cli/references/format.md b/.agents/skills/prisma-cli/references/format.mdnew file mode 100644index 000000000..896b1ec17--- /dev/null+++ b/.agents/skills/prisma-cli/references/format.md@@ -0,0 +1,48 @@+# prisma format++Formats your Prisma schema file.++## Command++```bash+prisma format [options]+```++## What It Does++- Fixes formatting (indentation, spacing)+- Adds missing back-relations (e.g., adds the other side of a relation)+- Adds missing relation arguments (e.g., `fields`, `references`)+- Sorts fields and attributes (opinionated)++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Format default schema++```bash+prisma format+```++### Format specific schema++```bash+prisma format --schema=./custom/schema.prisma+```++## Behavior++`prisma format` modifies the file in place. It is equivalent to "Prettier for Prisma schemas" but also has semantic understanding to fix/add missing schema definitions.++## Use in Editor++Most Prisma editor extensions (VS Code, WebStorm) run `prisma format` automatically on save. This command is useful for:+- CI pipelines (check formatting)+- CLI-based workflows+- Fixing large schema refactorsdiff --git a/.agents/skills/prisma-cli/references/generate.md b/.agents/skills/prisma-cli/references/generate.mdnew file mode 100644index 000000000..886e33f66--- /dev/null+++ b/.agents/skills/prisma-cli/references/generate.md@@ -0,0 +1,147 @@+# prisma generate++Generates assets based on the generator blocks in your Prisma schema, most commonly Prisma Client.++## Command++```bash+prisma generate [options]+```++## Bun Runtime++If you're using Bun, run Prisma with `bunx --bun` so it doesn't fall back to Node.js:++```bash+bunx --bun prisma generate+```++## What It Does++1. Reads your `schema.prisma` file+2. Generates a customized Prisma Client based on your models+3. Outputs to the directory specified in the generator block++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Custom path to your Prisma schema |+| `--config` | Custom path to your Prisma config file |+| `--sql` | Generate typed sql module |+| `--watch` | Watch the Prisma schema and rerun after a change |+| `--generator` | Generator to use (may be provided multiple times) |+| `--no-hints` | Hides the hint messages but still outputs errors and warnings |+| `--require-models` | Do not allow generating a client without models |++## Examples++### Basic generation++```bash+prisma generate+```++### Watch mode (development)++```bash+prisma generate --watch+```++Auto-regenerates when `schema.prisma` changes.++### Specific generator++```bash+prisma generate --generator client+```++### Multiple generators++```bash+prisma generate --generator client --generator zod_schemas+```++### Typed SQL generation++```bash+prisma generate --sql+```++## Schema Configuration (v7)++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++### Key v7 Changes++- Provider must be `prisma-client`+- `output` is now **required** - client no longer generates to `node_modules`+- Update imports after generating:++```typescript+// Before (v6)+import { PrismaClient } from '@prisma/client'++// After (v7)+import { PrismaClient } from '../generated/client'+```++## Common Patterns++### After schema changes++```bash+prisma migrate dev --name my_migration+prisma generate+```++Note: In v7, `migrate dev` no longer auto-runs `generate`.++### CI/CD pipeline++```bash+prisma generate+```++Run before building your application.++### Multiple generators++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+}++generator zod {+ provider = "zod-prisma-types"+ output = "../generated/zod"+}+```++```bash+prisma generate # Runs all generators+```++## Output Structure++After running `prisma generate`, your output directory contains:++```+generated/+βββ client.ts+βββ models/+βββ enums.ts+βββ ...+```++Import the client:++```typescript+import { PrismaClient, Prisma } from '../generated/client'+```diff --git a/.agents/skills/prisma-cli/references/init.md b/.agents/skills/prisma-cli/references/init.mdnew file mode 100644index 000000000..f3bb76f6d--- /dev/null+++ b/.agents/skills/prisma-cli/references/init.md@@ -0,0 +1,118 @@+# prisma init++Bootstraps a fresh Prisma ORM project in the current directory.++## Command++```bash+prisma init [options]+```++## Bun Runtime++If you're using Bun, run Prisma with `bunx --bun` so it doesn't fall back to Node.js:++```bash+bunx --bun prisma init+```++## What It Creates++- `prisma/schema.prisma` - Your Prisma schema file+- `prisma.config.ts` - TypeScript configuration for Prisma CLI+- `.env` - Environment variables (DATABASE_URL)+- `.gitignore` - Ignores node_modules, .env, and generated files++## Options++| Option | Description | Default |+|--------|-------------|---------|+| `--datasource-provider` | Database provider: `postgresql`, `mysql`, `sqlite`, `sqlserver`, `mongodb`, `cockroachdb` | `postgresql` |+| `--db` | Provisions a fully managed Prisma Postgres database on the Prisma Data Platform | - |+| `--url` | Define a custom datasource url | - |+| `--generator-provider` | Define the generator provider to use | `prisma-client` |+| `--output` | Define Prisma Client generator output path to use | - |+| `--preview-feature` | Define a preview feature to use | - |+| `--with-model` | Add example model to created schema file | - |++## Examples++### Basic initialization++```bash+prisma init+```++Creates a PostgreSQL project setup.++### SQLite project++```bash+prisma init --datasource-provider sqlite+```++### MySQL with custom URL++```bash+prisma init --datasource-provider mysql --url "mysql://user:password@localhost:3306/mydb"+```++### Prisma Postgres (cloud)++```bash+prisma init --db+```++Opens browser for authentication, creates cloud database instance.++### AI-generated schema++```bash+prisma init --prompt "Blog with users, posts, comments, and tags"+```++Generates schema based on description and deploys to Prisma Postgres.++### With preview features++```bash+prisma init --preview-feature relationJoins --preview-feature fullTextSearch+```++## Generated Schema (v7)++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+}++datasource db {+ provider = "postgresql"+}+```++## Generated Config (v7)++```typescript+// prisma.config.ts+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Next Steps After Init++1. Configure `DATABASE_URL` in `prisma.config.ts` or `.env`+2. Define your models in `prisma/schema.prisma`+3. Run `prisma dev` for local development or connect to remote DB+4. Run `prisma migrate dev` to create migrations+5. Run `prisma generate` to generate Prisma Clientdiff --git a/.agents/skills/prisma-cli/references/migrate-deploy.md b/.agents/skills/prisma-cli/references/migrate-deploy.mdnew file mode 100644index 000000000..213207552--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-deploy.md@@ -0,0 +1,127 @@+# prisma migrate deploy++Applies pending migrations in production/staging environments.++## Command++```bash+prisma migrate deploy+```++## What It Does++- Applies all pending migrations from `prisma/migrations/`+- Updates `_prisma_migrations` table+- Does NOT generate new migrations+- Does NOT run seed scripts+- Safe for CI/CD and production++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Custom path to your Prisma schema |+| `--config` | Custom path to your Prisma config file |++## When to Use++- Production deployments+- Staging environments+- CI/CD pipelines+- Any non-development environment++## Examples++### Basic deployment++```bash+prisma migrate deploy+```++### In CI/CD pipeline++```yaml+# GitHub Actions example+- name: Apply migrations+ run: npx prisma migrate deploy+ env:+ DATABASE_URL: ${{ secrets.DATABASE_URL }}+```++### Docker deployment++```dockerfile+# Run migrations before starting app+CMD npx prisma migrate deploy && node dist/index.js+```++## Comparison with migrate dev++| Feature | migrate dev | migrate deploy |+|---------|-------------|----------------|+| Creates migrations | Yes | No |+| Applies migrations | Yes | Yes |+| Detects drift | Yes | No |+| Prompts for input | Yes | No |+| Uses shadow database | Yes | No |+| Safe for production | No | Yes |+| Resets on issues | Prompts | Fails |++## Production Workflow++1. **Development**: Create migrations locally+ ```bash+ prisma migrate dev --name add_feature+ ```++2. **Commit**: Include migration files in version control+ ```bash+ git add prisma/migrations+ git commit -m "Add feature migration"+ ```++3. **Deploy**: Apply in production+ ```bash+ prisma migrate deploy+ ```++## Error Handling++### Failed migration++If a migration fails, `migrate deploy` exits with error. The failed migration is marked as failed in `_prisma_migrations`.++To fix:+1. Resolve the issue (fix SQL, database state, etc.)+2. Mark as resolved: `prisma migrate resolve --applied <migration_name>`+3. Re-run: `prisma migrate deploy`++### Check status first++```bash+prisma migrate status+```++Shows pending and applied migrations before deploying.++## Configuration++Ensure `prisma.config.ts` has the production database URL:++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Best Practices++1. Always run `migrate status` before `migrate deploy` in CI+2. Have a rollback plan (backup before migrations)+3. Test migrations in staging first+4. Never use `migrate dev` in productiondiff --git a/.agents/skills/prisma-cli/references/migrate-dev.md b/.agents/skills/prisma-cli/references/migrate-dev.mdnew file mode 100644index 000000000..d35a4457d--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-dev.md@@ -0,0 +1,143 @@+# prisma migrate dev++Creates and applies migrations during development. Requires a shadow database.++## Command++```bash+prisma migrate dev [options]+```++## What It Does++1. Runs existing migrations in shadow database to detect drift+2. Applies any pending migrations+3. Generates new migration from schema changes+4. Applies new migration to development database+5. Updates `_prisma_migrations` table++## Options++| Option | Description |+|--------|-------------|+| `--name` / `-n` | Name the migration |+| `--create-only` | Create a new migration but do not apply it |+| `--schema` | Custom path to your Prisma schema |+| `--config` | Custom path to your Prisma config file |+| `--url` | Override the datasource URL from the Prisma config file |++### Removed in v7++- `--skip-generate` - Run `prisma generate` explicitly+- `--skip-seed` - Run `prisma db seed` explicitly++## Examples++### Create and apply migration++```bash+prisma migrate dev+```++Prompts for migration name if schema changed.++### Named migration++```bash+prisma migrate dev --name add_users_table+```++### Create without applying++```bash+prisma migrate dev --create-only+```++Useful for reviewing migration SQL before applying.++### Full workflow (v7)++```bash+prisma migrate dev --name my_migration+prisma generate # Must run explicitly in v7+prisma db seed # Must run explicitly in v7+```++## Migration Files++Created in `prisma/migrations/`:++```+prisma/migrations/+βββ 20240115120000_add_users_table/+β βββ migration.sql+βββ 20240116090000_add_posts/+β βββ migration.sql+βββ migration_lock.toml+```++## Schema Drift Detection++If `migrate dev` detects drift (manual database changes or edited migrations), it prompts to reset:++```+Drift detected: Your database schema is not in sync.++Do you want to reset your database? All data will be lost.+```++## When to Use++- Local development+- Adding new models/fields+- Changing relations+- Creating indexes++## When NOT to Use++- Production deployments (use `migrate deploy`)+- CI/CD pipelines (use `migrate deploy`)+- MongoDB (use `db push` instead)++## Common Patterns++### After schema changes++```prisma+// schema.prisma - Add new field+model User {+ id Int @id @default(autoincrement())+ email String @unique+ name String?+ createdAt DateTime @default(now()) // New field+}+```++```bash+prisma migrate dev --name add_created_at+```++### Handling data loss warnings++When a migration would cause data loss:++```bash+prisma migrate dev --name remove_field+# Warning: You are about to delete data...+# Accept with: --accept-data-loss+```++## Shadow Database++`migrate dev` requires a shadow database for drift detection. Configure in `prisma.config.ts`:++```typescript+export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ shadowDatabaseUrl: env('SHADOW_DATABASE_URL'),+ },+})+```++For local Prisma Postgres (`prisma dev`), shadow database is handled automatically.diff --git a/.agents/skills/prisma-cli/references/migrate-diff.md b/.agents/skills/prisma-cli/references/migrate-diff.mdnew file mode 100644index 000000000..873107ec8--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-diff.md@@ -0,0 +1,89 @@+# prisma migrate diff++Compares database schemas and generates diffs (SQL or summary).++## Command++```bash+prisma migrate diff [options]+```++## What It Does++- Compares two sources (`--from-...` and `--to-...`)+- Sources can be:+ - Empty (`empty`)+ - Schema file (`schema`)+ - Migrations directory (`migrations`)+ - Database URL (`url`) or Configured Datasource (`config-datasource`)+- Outputs the difference:+ - Human-readable summary (default)+ - SQL script (`--script`)++## Options++| Option | Description |+|--------|-------------|+| `--script` | Render SQL script to stdout |+| `--exit-code` | Exit 2 if changes detected, 0 if empty, 1 if error |+| `--config` | Custom path to your Prisma config file |++### Sources (Must provide one `from` and one `to`)++- `--from-empty`, `--to-empty`+- `--from-schema <path>`, `--to-schema <path>`+- `--from-migrations <path>`, `--to-migrations <path>`+- `--from-url <url>`, `--to-url <url>`+- `--from-config-datasource`, `--to-config-datasource` (uses `prisma.config.ts`)++## Examples++### Generate SQL for a schema change++Compare current production DB to your local schema:++```bash+prisma migrate diff \+ --from-url "$PROD_DB_URL" \+ --to-schema ./prisma/schema.prisma \+ --script+```++### Review pending migrations++Compare database state to migrations directory:++```bash+prisma migrate diff \+ --from-config-datasource \+ --to-migrations ./prisma/migrations+```++### Create baseline migration++Compare empty state to current schema:++```bash+prisma migrate diff \+ --from-empty \+ --to-schema ./prisma/schema.prisma \+ --script > prisma/migrations/0_init/migration.sql+```++### Check for drift (CI)++Check if database matches schema:++```bash+prisma migrate diff \+ --from-config-datasource \+ --to-schema ./prisma/schema.prisma \+ --exit-code+```++## Use Cases++- **Forward-generating migrations**: Creating SQL without `migrate dev`.+- **Drift detection**: Checking if DB is in sync.+- **Baselining**: Creating initial migration from existing DB.+- **Debugging**: Understanding what `migrate dev` would do.diff --git a/.agents/skills/prisma-cli/references/migrate-reset.md b/.agents/skills/prisma-cli/references/migrate-reset.mdnew file mode 100644index 000000000..89dbead00--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-reset.md@@ -0,0 +1,72 @@+# prisma migrate reset++Resets your database and re-applies all migrations.++## Command++```bash+prisma migrate reset [options]+```++## What It Does++1. **Drops** the database (if possible) or deletes all data/tables+2. **Re-creates** the database+3. **Applies** all migrations from `prisma/migrations/`+4. **Runs** the seed script (if configured)++**Warning: All data will be lost.**++## Options++| Option | Description |+|--------|-------------|+| `--force` / `-f` | Skip confirmation prompt |+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Basic reset++```bash+prisma migrate reset+```++Prompts for confirmation in interactive terminals.++### Force reset (CI/Automation)++```bash+prisma migrate reset --force+```++### With custom schema++```bash+prisma migrate reset --schema=./custom/schema.prisma+```++## When to Use++- **Development**: When you want a fresh start+- **Testing**: Resetting test database before suites+- **Drift Recovery**: When the database is out of sync and you can't migrate++## Behavior in v7++- In v6, `migrate reset` automatically ran `prisma generate`.+- In v7, you may need to run `prisma generate` separately if you want to update the client, though `reset` focuses on the database state.+- Seed script IS run by default after reset.++## Configuration++Configure seed script in `prisma.config.ts` to run it automatically after reset:++```typescript+export default defineConfig({+ migrations: {+ seed: 'tsx prisma/seed.ts',+ },+})+```diff --git a/.agents/skills/prisma-cli/references/migrate-resolve.md b/.agents/skills/prisma-cli/references/migrate-resolve.mdnew file mode 100644index 000000000..6b65f65fa--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-resolve.md@@ -0,0 +1,57 @@+# prisma migrate resolve++Resolves issues with database migrations, such as failed migrations or baselining.++## Command++```bash+prisma migrate resolve [options]+```++## What It Does++Updates the `_prisma_migrations` table to manually change the state of a migration. This is a recovery tool.++## Options++You must provide exactly one of `--applied` or `--rolled-back`.++| Option | Description |+|--------|-------------|+| `--applied <name>` | Mark a migration as **applied** (success) |+| `--rolled-back <name>` | Mark a migration as **rolled back** (ignored/failed) |+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Mark as Applied (Baselining)++If you have existing tables and want to initialize migrations without running the SQL:++```bash+prisma migrate resolve --applied 20240101000000_initial_migration+```++This tells Prisma "Assume this migration has already run".++### Mark as Rolled Back (Fixing Failures)++If a migration failed (e.g., syntax error) and you fixed the SQL or want to retry:++```bash+prisma migrate resolve --rolled-back 20240115120000_failed_migration+```++This tells Prisma "Forget this migration run, let me try applying it again".++## Use Cases++1. **Baselining**: Adopting Prisma Migrate on an existing production database.+2. **Failed Migrations**: Recovering from a failed `migrate deploy` in production.+3. **Hotfixes**: reconciling manual database changes (rare).++## References++- [Baselining](https://www.prisma.io/docs/guides/database/developing-with-prisma-migrate/baselining)+- [Troubleshooting](https://www.prisma.io/docs/guides/database/production-troubleshooting)diff --git a/.agents/skills/prisma-cli/references/migrate-status.md b/.agents/skills/prisma-cli/references/migrate-status.mdnew file mode 100644index 000000000..80a7ffa7a--- /dev/null+++ b/.agents/skills/prisma-cli/references/migrate-status.md@@ -0,0 +1,65 @@+# prisma migrate status++Checks the status of your database migrations.++## Command++```bash+prisma migrate status [options]+```++## What It Does++- Connects to the database+- Checks the `_prisma_migrations` table+- Compares applied migrations with local migration files+- Reports:+ - **Status**: Database is up-to-date or behind+ - **Unapplied migrations**: Count of pending migrations+ - **Missing migrations**: Migrations present in DB but missing locally+ - **Failed migrations**: Any migrations that failed to apply++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Check status++```bash+prisma migrate status+```++Output example (Up to date):+```+Database schema is up to date!+```++Output example (Pending):+```+Following migration have not yet been applied:+ 20240115120000_add_user++To apply migrations in development, run:+ prisma migrate dev++To apply migrations in production, run:+ prisma migrate deploy+```++## When to Use++- **Debugging**: Why is `migrate dev` complaining about drift?+- **CI/CD**: Verify database state before deploying+- **Production**: Check if migrations are needed (`migrate deploy`) or if a deployment failed++## Exit Codes++- `0`: Success (may have pending migrations, but command ran successfully)+- `1`: Error++To check for pending migrations programmatically, you might need to parse the output or use `migrate diff` with exit code flags.diff --git a/.agents/skills/prisma-cli/references/studio.md b/.agents/skills/prisma-cli/references/studio.mdnew file mode 100644index 000000000..3751ba6e0--- /dev/null+++ b/.agents/skills/prisma-cli/references/studio.md@@ -0,0 +1,122 @@+# prisma studio++Opens a visual database browser for viewing and editing data.++## Command++```bash+prisma studio [options]+```++## What It Does++- Starts a web-based database GUI+- View all your models and records+- Create, update, and delete records+- Filter and sort data+- Navigate relations++## Options++| Option | Description | Default |+|--------|-------------|---------|+| `--port` / `-p` | Port to start Studio on | `5555` |+| `--browser` / `-b` | Browser to open Studio in | System default |+| `--config` | Custom path to your Prisma config file | - |+| `--url` | Database connection string (overrides the one in your Prisma config) | - |++## Examples++### Open Studio++```bash+prisma studio+```++Opens at http://localhost:5555++### Custom port++```bash+prisma studio --port 3000+```++### Specific browser++```bash+prisma studio --browser firefox+```++### Don't open browser++```bash+BROWSER=none prisma studio+```++Useful for remote servers.++## Features++### View Records++- See all records in table format+- Pagination for large datasets+- Column sorting++### Filter Data++- Filter by any field+- Multiple conditions+- Relation filtering++### Edit Records++- Click to edit inline+- Add new records+- Delete records (with confirmation)++### Navigate Relations++- Click relations to view related records+- See counts of related items+- Follow relation links++## Use Cases++- **Development**: Quick data inspection+- **Debugging**: Check data state+- **Testing**: Verify seed data+- **Demo**: Show data to stakeholders++## Limitations++- Development tool only+- Not for production use+- Limited to configured database+- No advanced queries (use Prisma Client for that)++## Common Workflow++1. Run migrations:+ ```bash+ prisma migrate dev+ ```++2. Seed data:+ ```bash+ prisma db seed+ ```++3. Open Studio to verify:+ ```bash+ prisma studio+ ```++4. Make manual edits if needed++## Security Note++Studio provides direct database access. Only run on:+- Local development machines+- Secure internal networks+- Never expose publiclydiff --git a/.agents/skills/prisma-cli/references/validate.md b/.agents/skills/prisma-cli/references/validate.mdnew file mode 100644index 000000000..61156c6d4--- /dev/null+++ b/.agents/skills/prisma-cli/references/validate.md@@ -0,0 +1,53 @@+# prisma validate++Validates your Prisma schema file.++## Command++```bash+prisma validate [options]+```++## What It Does++- Parses the `schema.prisma` file+- Checks for syntax errors+- Validates model definitions, relations, and types+- Reports any errors or warnings without generating code++## Options++| Option | Description |+|--------|-------------|+| `--schema` | Path to schema file |+| `--config` | Custom path to your Prisma config file |++## Examples++### Validate default schema++```bash+prisma validate+```++### Validate specific schema++```bash+prisma validate --schema=./custom/schema.prisma+```++### Use in CI++Run `validate` in your CI pipeline to catch schema errors early:++```yaml+- name: Validate Schema+ run: npx prisma validate+```++## Common Errors++- Missing `@relation` fields+- Invalid types+- Duplicate model names+- Syntax errors (missing braces, etc.)diff --git a/.agents/skills/prisma-client-api/SKILL.md b/.agents/skills/prisma-client-api/SKILL.mdnew file mode 100644index 000000000..f72528b76--- /dev/null+++ b/.agents/skills/prisma-client-api/SKILL.md@@ -0,0 +1,216 @@+---+name: prisma-client-api+description: Prisma Client API reference covering model queries, filters, operators, and client methods. Use when writing database queries, using CRUD operations, filtering data, or configuring Prisma Client. Triggers on "prisma query", "findMany", "create", "update", "delete", "$transaction".+license: MIT+metadata:+ author: prisma+ version: "7.0.0"+---++# Prisma Client API Reference++Complete API reference for Prisma Client. This skill provides guidance on model queries, filtering, relations, and client methods for Prisma ORM 7.x.++## When to Apply++Reference this skill when:+- Writing database queries with Prisma Client+- Performing CRUD operations (create, read, update, delete)+- Filtering and sorting data+- Working with relations+- Using transactions+- Configuring client options++## Rule Categories by Priority++| Priority | Category | Impact | Prefix |+|----------|----------|--------|--------|+| 1 | Client Construction | HIGH | `constructor` |+| 2 | Model Queries | CRITICAL | `model-queries` |+| 3 | Query Shape | HIGH | `query-options` |+| 4 | Filtering | HIGH | `filters` |+| 5 | Relations | HIGH | `relations` |+| 6 | Transactions | CRITICAL | `transactions` |+| 7 | Raw SQL | CRITICAL | `raw-queries` |+| 8 | Client Methods | MEDIUM | `client-methods` |++## Quick Reference++- `constructor` - `PrismaClient` setup and adapter wiring+- `model-queries` - CRUD operations and bulk operations+- `query-options` - `select`, `include`, `omit`, sort, pagination+- `filters` - scalar and logical filter operators+- `relations` - relation reads and nested writes+- `transactions` - array and interactive transaction patterns+- `raw-queries` - `$queryRaw` and `$executeRaw` safety+- `client-methods` - lifecycle and extension methods++## Client Instantiation (v7)++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++## Model Query Methods++| Method | Description |+|--------|-------------|+| `findUnique()` | Find one record by unique field |+| `findUniqueOrThrow()` | Find one or throw error |+| `findFirst()` | Find first matching record |+| `findFirstOrThrow()` | Find first or throw error |+| `findMany()` | Find multiple records |+| `create()` | Create a new record |+| `createMany()` | Create multiple records |+| `createManyAndReturn()` | Create multiple and return them |+| `update()` | Update one record |+| `updateMany()` | Update multiple records |+| `updateManyAndReturn()` | Update multiple and return them |+| `upsert()` | Update or create record |+| `delete()` | Delete one record |+| `deleteMany()` | Delete multiple records |+| `count()` | Count matching records |+| `aggregate()` | Aggregate values (sum, avg, etc.) |+| `groupBy()` | Group and aggregate |++## Query Options++| Option | Description |+|--------|-------------|+| `where` | Filter conditions |+| `select` | Fields to include |+| `include` | Relations to load |+| `omit` | Fields to exclude |+| `orderBy` | Sort order |+| `take` | Limit results |+| `skip` | Skip results (pagination) |+| `cursor` | Cursor-based pagination |+| `distinct` | Unique values only |++## Client Methods++| Method | Description |+|--------|-------------|+| `$connect()` | Explicitly connect to database |+| `$disconnect()` | Disconnect from database |+| `$transaction()` | Execute transaction |+| `$queryRaw()` | Execute raw SQL query |+| `$executeRaw()` | Execute raw SQL command |+| `$on()` | Subscribe to events |+| `$extends()` | Add extensions |++## Quick Examples++### Find records++```typescript+// Find by unique field+const user = await prisma.user.findUnique({+ where: { email: '[email protected]' }+})++// Find with filter+const users = await prisma.user.findMany({+ where: { role: 'ADMIN' },+ orderBy: { createdAt: 'desc' },+ take: 10+})+```++### Create records++```typescript+const user = await prisma.user.create({+ data: {+ email: '[email protected]',+ name: 'Alice',+ posts: {+ create: { title: 'Hello World' }+ }+ },+ include: { posts: true }+})+```++### Update records++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: { name: 'Alice Smith' }+})+```++### Delete records++```typescript+await prisma.user.delete({+ where: { id: 1 }+})+```++### Transactions++```typescript+const [user, post] = await prisma.$transaction([+ prisma.user.create({ data: { email: '[email protected]' } }),+ prisma.post.create({ data: { title: 'Hello', authorId: 1 } })+])+```++## Rule Files++Detailed API documentation:++```+references/constructor.md - PrismaClient constructor options+references/model-queries.md - CRUD operations+references/query-options.md - select, include, omit, where, orderBy+references/filters.md - Filter conditions and operators+references/relations.md - Relation queries and nested operations+references/transactions.md - Transaction API+references/raw-queries.md - $queryRaw, $executeRaw+references/client-methods.md - $connect, $disconnect, $on, $extends+```++## Filter Operators++| Operator | Description |+|----------|-------------|+| `equals` | Exact match |+| `not` | Not equal |+| `in` | In array |+| `notIn` | Not in array |+| `lt`, `lte` | Less than |+| `gt`, `gte` | Greater than |+| `contains` | String contains |+| `startsWith` | String starts with |+| `endsWith` | String ends with |+| `mode` | Case sensitivity |++## Relation Filters++| Operator | Description |+|----------|-------------|+| `some` | At least one related record matches |+| `every` | All related records match |+| `none` | No related records match |+| `is` | Related record matches (1-to-1) |+| `isNot` | Related record doesn't match |++## Resources++- [Prisma Client API Reference](https://www.prisma.io/docs/orm/reference/prisma-client-reference)+- [CRUD Operations](https://www.prisma.io/docs/orm/prisma-client/queries/crud)+- [Filtering and Sorting](https://www.prisma.io/docs/orm/prisma-client/queries/filtering-and-sorting)++## How to Use++Pick the category from the table above, then open the matching reference file for implementation details and examples.diff --git a/.agents/skills/prisma-client-api/references/client-methods.md b/.agents/skills/prisma-client-api/references/client-methods.mdnew file mode 100644index 000000000..02884d27d--- /dev/null+++ b/.agents/skills/prisma-client-api/references/client-methods.md@@ -0,0 +1,221 @@+# Client Methods++Prisma Client instance methods.++## $connect()++Explicitly connect to the database:++```typescript+const prisma = new PrismaClient({ adapter })++// Explicit connection+await prisma.$connect()+```++### When to use++Usually not needed - Prisma connects automatically on first query. Use for:+- Fail fast on startup+- Health checks+- Pre-warming connections++```typescript+async function main() {+ try {+ await prisma.$connect()+ console.log('Database connected')+ } catch (e) {+ console.error('Failed to connect:', e)+ process.exit(1)+ }+}+```++## $disconnect()++Close database connection:++```typescript+await prisma.$disconnect()+```++### Graceful shutdown++```typescript+process.on('beforeExit', async () => {+ await prisma.$disconnect()+})++// Or with SIGTERM+process.on('SIGTERM', async () => {+ await prisma.$disconnect()+ process.exit(0)+})+```++### In tests++```typescript+afterAll(async () => {+ await prisma.$disconnect()+})+```++## $on()++Subscribe to events:++### Query events++```typescript+const prisma = new PrismaClient({+ adapter,+ log: [{ level: 'query', emit: 'event' }]+})++prisma.$on('query', (e) => {+ console.log('Query:', e.query)+ console.log('Params:', e.params)+ console.log('Duration:', e.duration, 'ms')+})+```++### Log events++```typescript+const prisma = new PrismaClient({+ adapter,+ log: [+ { level: 'info', emit: 'event' },+ { level: 'warn', emit: 'event' },+ { level: 'error', emit: 'event' }+ ]+})++prisma.$on('info', (e) => console.log(e.message))+prisma.$on('warn', (e) => console.warn(e.message))+prisma.$on('error', (e) => console.error(e.message))+```++## $extends()++Add extensions for custom behavior:++### Add custom methods++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ client: {+ $log: (message: string) => console.log(message)+ }+})++prisma.$log('Hello!')+```++### Add model methods++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ model: {+ user: {+ async findByEmail(email: string) {+ return prisma.user.findUnique({ where: { email } })+ }+ }+ }+})++const user = await prisma.user.findByEmail('[email protected]')+```++### Query extensions++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ query: {+ user: {+ async findMany({ args, query }) {+ // Add default filter+ args.where = { ...args.where, deletedAt: null }+ return query(args)+ }+ }+ }+})+```++### Result extensions++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ result: {+ user: {+ fullName: {+ needs: { firstName: true, lastName: true },+ compute(user) {+ return `${user.firstName} ${user.lastName}`+ }+ }+ }+ }+})++const user = await prisma.user.findFirst()+console.log(user.fullName) // Computed field+```++### Chain extensions++```typescript+const prisma = new PrismaClient({ adapter })+ .$extends(loggingExtension)+ .$extends(softDeleteExtension)+ .$extends(computedFieldsExtension)+```++## $transaction()++See `transactions.md` for details.++## $queryRaw() / $executeRaw()++See `raw-queries.md` for details.++## Type utilities++### Prisma namespace++```typescript+import { Prisma } from '../generated/client'++// Input types+type UserCreateInput = Prisma.UserCreateInput+type UserWhereInput = Prisma.UserWhereInput++// Output types+type User = Prisma.UserGetPayload<{}>+type UserWithPosts = Prisma.UserGetPayload<{+ include: { posts: true }+}>+```++### Prisma.validator++Type-safe query fragments:++```typescript+import { Prisma } from '../generated/client'++const userSelect = Prisma.validator<Prisma.UserSelect>()({+ id: true,+ email: true,+ name: true+})++const user = await prisma.user.findUnique({+ where: { id: 1 },+ select: userSelect+})+```diff --git a/.agents/skills/prisma-client-api/references/constructor.md b/.agents/skills/prisma-client-api/references/constructor.mdnew file mode 100644index 000000000..330fc820e--- /dev/null+++ b/.agents/skills/prisma-client-api/references/constructor.md@@ -0,0 +1,185 @@+# PrismaClient Constructor++Configure Prisma Client when instantiating.++## Basic Instantiation (v7)++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++## Constructor Options++### adapter (Required in v7)++Driver adapter instance:++```typescript+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++### accelerateUrl (For Accelerate users)++```typescript+import { withAccelerate } from '@prisma/extension-accelerate'++const prisma = new PrismaClient({+ accelerateUrl: process.env.DATABASE_URL, // prisma:// URL+}).$extends(withAccelerate())+```++### log++Configure logging:++```typescript+const prisma = new PrismaClient({+ adapter,+ log: ['query', 'info', 'warn', 'error'],+})+```++#### Log levels++| Level | Description |+|-------|-------------|+| `query` | All SQL queries |+| `info` | Informational messages |+| `warn` | Warnings |+| `error` | Errors |++#### Log to events++```typescript+const prisma = new PrismaClient({+ adapter,+ log: [+ { level: 'query', emit: 'event' },+ { level: 'error', emit: 'stdout' },+ ],+})++prisma.$on('query', (e) => {+ console.log('Query:', e.query)+ console.log('Duration:', e.duration, 'ms')+})+```++### errorFormat++Control error formatting:++```typescript+const prisma = new PrismaClient({+ adapter,+ errorFormat: 'pretty', // 'pretty' | 'colorless' | 'minimal'+})+```++### transactionOptions++Default transaction settings:++```typescript+const prisma = new PrismaClient({+ adapter,+ transactionOptions: {+ maxWait: 5000, // Max wait to acquire transaction (ms)+ timeout: 10000, // Max transaction duration (ms)+ isolationLevel: 'Serializable',+ },+})+```++## Singleton Pattern++Prevent multiple client instances in development:++```typescript+// lib/prisma.ts+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const globalForPrisma = globalThis as unknown as {+ prisma: PrismaClient | undefined+}++function createPrismaClient() {+ const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL!+ })+ return new PrismaClient({ adapter })+}++export const prisma = globalForPrisma.prisma ?? createPrismaClient()++if (process.env.NODE_ENV !== 'production') {+ globalForPrisma.prisma = prisma+}+```++## Next.js Pattern++```typescript+// lib/prisma.ts+import { PrismaClient } from '@/generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const createAdapter = () => new PrismaPg({+ connectionString: process.env.DATABASE_URL!+})++const prismaClientSingleton = () => {+ return new PrismaClient({ adapter: createAdapter() })+}++declare const globalThis: {+ prismaGlobal: ReturnType<typeof prismaClientSingleton>+} & typeof global++const prisma = globalThis.prismaGlobal ?? prismaClientSingleton()++export default prisma++if (process.env.NODE_ENV !== 'production') {+ globalThis.prismaGlobal = prisma+}+```++## Query Events++Listen to query events:++```typescript+const prisma = new PrismaClient({+ adapter,+ log: [{ level: 'query', emit: 'event' }],+})++prisma.$on('query', (e) => {+ console.log('Query:', e.query)+ console.log('Params:', e.params)+ console.log('Duration:', e.duration)+})+```++## Log Events++```typescript+prisma.$on('info', (e) => console.log(e.message))+prisma.$on('warn', (e) => console.warn(e.message))+prisma.$on('error', (e) => console.error(e.message))+```diff --git a/.agents/skills/prisma-client-api/references/filters.md b/.agents/skills/prisma-client-api/references/filters.mdnew file mode 100644index 000000000..a9b7eeab2--- /dev/null+++ b/.agents/skills/prisma-client-api/references/filters.md@@ -0,0 +1,256 @@+# Filter Conditions and Operators++Filter operators for the `where` clause.++## Equality++```typescript+// Exact match (implicit)+where: { email: '[email protected]' }++// Explicit equals+where: { email: { equals: '[email protected]' } }++// Not equal+where: { email: { not: '[email protected]' } }+```++## Comparison++```typescript+// Greater than+where: { age: { gt: 18 } }++// Greater than or equal+where: { age: { gte: 18 } }++// Less than+where: { age: { lt: 65 } }++// Less than or equal+where: { age: { lte: 65 } }++// Combined+where: { age: { gte: 18, lte: 65 } }+```++## Lists++```typescript+// In array+where: { role: { in: ['ADMIN', 'MODERATOR'] } }++// Not in array+where: { role: { notIn: ['GUEST', 'BANNED'] } }+```++## String Filters++```typescript+// Contains+where: { email: { contains: 'prisma' } }++// Starts with+where: { email: { startsWith: 'alice' } }++// Ends with+where: { email: { endsWith: '@prisma.io' } }++// Case-insensitive (default for some databases)+where: {+ email: {+ contains: 'PRISMA',+ mode: 'insensitive'+ }+}+```++## Null Checks++```typescript+// Is null+where: { deletedAt: null }++// Is not null+where: { deletedAt: { not: null } }++// Using isSet (for optional fields)+where: { middleName: { isSet: true } }+```++## Logical Operators++### AND (implicit)++```typescript+// Multiple conditions = AND+where: {+ email: { contains: '@prisma.io' },+ role: 'ADMIN'+}+```++### AND (explicit)++```typescript+where: {+ AND: [+ { email: { contains: '@prisma.io' } },+ { role: 'ADMIN' }+ ]+}+```++### OR++```typescript+where: {+ OR: [+ { email: { contains: '@gmail.com' } },+ { email: { contains: '@prisma.io' } }+ ]+}+```++### NOT++```typescript+where: {+ NOT: {+ role: 'GUEST'+ }+}++// Multiple NOT conditions+where: {+ NOT: [+ { role: 'GUEST' },+ { verified: false }+ ]+}+```++### Combined++```typescript+where: {+ AND: [+ { verified: true },+ {+ OR: [+ { role: 'ADMIN' },+ { role: 'MODERATOR' }+ ]+ }+ ],+ NOT: { deletedAt: { not: null } }+}+```++## Relation Filters++### some++At least one related record matches:++```typescript+// Users with at least one published post+where: {+ posts: {+ some: { published: true }+ }+}+```++### every++All related records match:++```typescript+// Users where all posts are published+where: {+ posts: {+ every: { published: true }+ }+}+```++### none++No related records match:++```typescript+// Users with no published posts+where: {+ posts: {+ none: { published: true }+ }+}+```++### is / isNot (1-to-1)++```typescript+// Users with profile in specific country+where: {+ profile: {+ is: { country: 'USA' }+ }+}++// Users without profile+where: {+ profile: {+ isNot: null+ }+}+```++## Array Field Filters++For fields like `String[]`:++```typescript+// Has element+where: { tags: { has: 'typescript' } }++// Has some elements+where: { tags: { hasSome: ['typescript', 'javascript'] } }++// Has every element+where: { tags: { hasEvery: ['typescript', 'prisma'] } }++// Is empty+where: { tags: { isEmpty: true } }+```++## JSON Filters++```typescript+// Path-based filter+where: {+ metadata: {+ path: ['settings', 'theme'],+ equals: 'dark'+ }+}++// String contains in JSON+where: {+ metadata: {+ path: ['bio'],+ string_contains: 'developer'+ }+}+```++## Full-Text Search++```typescript+// Requires @@fulltext index+where: {+ content: {+ search: 'prisma database'+ }+}+```diff --git a/.agents/skills/prisma-client-api/references/model-queries.md b/.agents/skills/prisma-client-api/references/model-queries.mdnew file mode 100644index 000000000..0687ef5bc--- /dev/null+++ b/.agents/skills/prisma-client-api/references/model-queries.md@@ -0,0 +1,281 @@+# Model Queries++CRUD operations for your Prisma models.++## Read Operations++### findUnique++Find a single record by unique field:++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 }+})++const user = await prisma.user.findUnique({+ where: { email: '[email protected]' }+})+```++#### With composite unique key++```typescript+// Model with @@unique([firstName, lastName])+const user = await prisma.user.findUnique({+ where: {+ firstName_lastName: {+ firstName: 'Alice',+ lastName: 'Smith'+ }+ }+})+```++### findUniqueOrThrow++Same as findUnique but throws if not found:++```typescript+const user = await prisma.user.findUniqueOrThrow({+ where: { id: 1 }+})+// Throws PrismaClientKnownRequestError if not found+```++### findFirst++Find first matching record:++```typescript+const user = await prisma.user.findFirst({+ where: { role: 'ADMIN' },+ orderBy: { createdAt: 'desc' }+})+```++### findFirstOrThrow++```typescript+const user = await prisma.user.findFirstOrThrow({+ where: { role: 'ADMIN' }+})+```++### findMany++Find multiple records:++```typescript+const users = await prisma.user.findMany({+ where: { role: 'USER' },+ orderBy: { name: 'asc' },+ take: 10,+ skip: 0+})+```++## Create Operations++### create++Create a single record:++```typescript+const user = await prisma.user.create({+ data: {+ email: '[email protected]',+ name: 'Alice'+ }+})+```++#### With relations++```typescript+const user = await prisma.user.create({+ data: {+ email: '[email protected]',+ posts: {+ create: [+ { title: 'First Post' },+ { title: 'Second Post' }+ ]+ }+ },+ include: { posts: true }+})+```++### createMany++Create multiple records:++```typescript+const result = await prisma.user.createMany({+ data: [+ { email: '[email protected]', name: 'Alice' },+ { email: '[email protected]', name: 'Bob' }+ ],+ skipDuplicates: true // Skip records with duplicate unique fields+})+// Returns { count: 2 }+```++### createManyAndReturn++Create multiple and return them:++```typescript+const users = await prisma.user.createManyAndReturn({+ data: [+ { email: '[email protected]', name: 'Alice' },+ { email: '[email protected]', name: 'Bob' }+ ]+})+// Returns array of created users+```++## Update Operations++### update++Update a single record:++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: { name: 'Alice Smith' }+})+```++#### Atomic operations++```typescript+const post = await prisma.post.update({+ where: { id: 1 },+ data: {+ views: { increment: 1 },+ likes: { decrement: 1 },+ score: { multiply: 2 },+ rating: { divide: 2 },+ version: { set: 5 }+ }+})+```++### updateMany++Update multiple records:++```typescript+const result = await prisma.user.updateMany({+ where: { role: 'USER' },+ data: { verified: true }+})+// Returns { count: 42 }+```++### updateManyAndReturn++```typescript+const users = await prisma.user.updateManyAndReturn({+ where: { role: 'USER' },+ data: { verified: true }+})+// Returns array of updated users+```++### upsert++Update or create:++```typescript+const user = await prisma.user.upsert({+ where: { email: '[email protected]' },+ update: { name: 'Alice Smith' },+ create: { email: '[email protected]', name: 'Alice' }+})+```++## Delete Operations++### delete++Delete a single record:++```typescript+const user = await prisma.user.delete({+ where: { id: 1 }+})+// Returns deleted record+```++### deleteMany++Delete multiple records:++```typescript+const result = await prisma.user.deleteMany({+ where: { role: 'GUEST' }+})+// Returns { count: 5 }++// Delete all+const result = await prisma.user.deleteMany({})+```++## Aggregation Operations++### count++```typescript+const count = await prisma.user.count({+ where: { role: 'ADMIN' }+})+```++### aggregate++```typescript+const result = await prisma.post.aggregate({+ _avg: { views: true },+ _sum: { views: true },+ _min: { views: true },+ _max: { views: true },+ _count: { _all: true }+})+```++### groupBy++```typescript+const groups = await prisma.user.groupBy({+ by: ['country'],+ _count: { _all: true },+ _avg: { age: true },+ having: {+ age: { _avg: { gt: 30 } }+ }+})+```++## Return Types++| Method | Returns |+|--------|---------|+| `findUnique` | Record \| null |+| `findUniqueOrThrow` | Record (throws if not found) |+| `findFirst` | Record \| null |+| `findFirstOrThrow` | Record (throws if not found) |+| `findMany` | Record[] |+| `create` | Record |+| `createMany` | { count: number } |+| `createManyAndReturn` | Record[] |+| `update` | Record |+| `updateMany` | { count: number } |+| `delete` | Record |+| `deleteMany` | { count: number } |+| `count` | number |+| `aggregate` | Aggregate result |+| `groupBy` | Group result[] |diff --git a/.agents/skills/prisma-client-api/references/query-options.md b/.agents/skills/prisma-client-api/references/query-options.mdnew file mode 100644index 000000000..25864a4bb--- /dev/null+++ b/.agents/skills/prisma-client-api/references/query-options.md@@ -0,0 +1,276 @@+# Query Options++Options for controlling query behavior.++## select++Choose specific fields to return:++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ select: {+ id: true,+ name: true,+ email: true,+ // password: false (excluded by not including)+ }+})+// Returns: { id: 1, name: 'Alice', email: '[email protected]' }+```++### Select relations++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ select: {+ name: true,+ posts: {+ select: {+ title: true,+ published: true+ }+ }+ }+})+```++### Select with include inside++```typescript+const user = await prisma.user.findMany({+ select: {+ name: true,+ posts: {+ include: {+ comments: true+ }+ }+ }+})+```++### Select relation count++```typescript+const users = await prisma.user.findMany({+ select: {+ name: true,+ _count: {+ select: { posts: true }+ }+ }+})+// Returns: { name: 'Alice', _count: { posts: 5 } }+```++## include++Include related records:++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: true,+ profile: true+ }+})+```++### Filtered include++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: {+ where: { published: true },+ orderBy: { createdAt: 'desc' },+ take: 5+ }+ }+})+```++### Nested include++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: {+ include: {+ comments: {+ include: {+ author: true+ }+ }+ }+ }+ }+})+```++### Include relation count++```typescript+const users = await prisma.user.findMany({+ include: {+ _count: {+ select: { posts: true, followers: true }+ }+ }+})+```++## omit++Exclude specific fields:++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ omit: {+ password: true+ }+})+// Returns all fields except password+```++### Omit in relations++```typescript+const users = await prisma.user.findMany({+ omit: { password: true },+ include: {+ posts: {+ omit: { content: true }+ }+ }+})+```++**Note:** Cannot use `select` and `omit` together.++## where++Filter records:++```typescript+const users = await prisma.user.findMany({+ where: {+ email: { contains: '@prisma.io' },+ role: 'ADMIN'+ }+})+```++See `filters.md` for detailed filter operators.++## orderBy++Sort results:++```typescript+// Single field+const users = await prisma.user.findMany({+ orderBy: { name: 'asc' }+})++// Multiple fields+const users = await prisma.user.findMany({+ orderBy: [+ { role: 'desc' },+ { name: 'asc' }+ ]+})+```++### Order by relation++```typescript+const users = await prisma.user.findMany({+ orderBy: {+ posts: { _count: 'desc' }+ }+})+```++### Null handling++```typescript+const users = await prisma.user.findMany({+ orderBy: {+ name: { sort: 'asc', nulls: 'last' }+ }+})+```++## take & skip++Pagination:++```typescript+// First page+const users = await prisma.user.findMany({+ take: 10,+ skip: 0+})++// Second page+const users = await prisma.user.findMany({+ take: 10,+ skip: 10+})+```++### Negative take (reverse)++```typescript+const lastUsers = await prisma.user.findMany({+ take: -10,+ orderBy: { id: 'asc' }+})+// Returns last 10 users+```++## cursor++Cursor-based pagination:++```typescript+// First page+const firstPage = await prisma.user.findMany({+ take: 10,+ orderBy: { id: 'asc' }+})++// Next page using cursor+const nextPage = await prisma.user.findMany({+ take: 10,+ skip: 1, // Skip the cursor record+ cursor: { id: firstPage[firstPage.length - 1].id },+ orderBy: { id: 'asc' }+})+```++## distinct++Return unique values:++```typescript+const cities = await prisma.user.findMany({+ distinct: ['city'],+ select: { city: true }+})+```++### Multiple distinct fields++```typescript+const locations = await prisma.user.findMany({+ distinct: ['city', 'country']+})+```diff --git a/.agents/skills/prisma-client-api/references/raw-queries.md b/.agents/skills/prisma-client-api/references/raw-queries.mdnew file mode 100644index 000000000..5d3a220b8--- /dev/null+++ b/.agents/skills/prisma-client-api/references/raw-queries.md@@ -0,0 +1,194 @@+# Raw Queries++Execute raw SQL when Prisma's query API isn't sufficient.++## $queryRaw++Execute SELECT queries and get typed results:++```typescript+const users = await prisma.$queryRaw`+ SELECT * FROM "User" WHERE email LIKE ${'%@prisma.io'}+`+```++### With type++```typescript+type User = { id: number; email: string; name: string | null }++const users = await prisma.$queryRaw<User[]>`+ SELECT id, email, name FROM "User" WHERE role = ${'ADMIN'}+`+```++### Dynamic table/column names++Use `Prisma.raw()` for identifiers (not safe for user input):++```typescript+import { Prisma } from '../generated/client'++const column = 'email'+const users = await prisma.$queryRaw`+ SELECT ${Prisma.raw(column)} FROM "User"+`+```++### With Prisma.sql++Build queries dynamically:++```typescript+import { Prisma } from '../generated/client'++const email = '[email protected]'+const query = Prisma.sql`SELECT * FROM "User" WHERE email = ${email}`+const users = await prisma.$queryRaw(query)+```++### Join multiple SQL fragments++```typescript+import { Prisma } from '../generated/client'++const conditions = [+ Prisma.sql`role = ${'ADMIN'}`,+ Prisma.sql`verified = ${true}`+]++const users = await prisma.$queryRaw`+ SELECT * FROM "User"+ WHERE ${Prisma.join(conditions, ' AND ')}+`+```++## $executeRaw++Execute INSERT, UPDATE, DELETE (returns affected count):++```typescript+const count = await prisma.$executeRaw`+ UPDATE "User" SET verified = true WHERE email LIKE ${'%@prisma.io'}+`+console.log(`Updated ${count} users`)+```++### Delete example++```typescript+const deleted = await prisma.$executeRaw`+ DELETE FROM "User" WHERE "deletedAt" < ${thirtyDaysAgo}+`+```++### Insert example++```typescript+const inserted = await prisma.$executeRaw`+ INSERT INTO "Log" (message, level, timestamp)+ VALUES (${message}, ${level}, ${new Date()})+`+```++## $queryRawUnsafe / $executeRawUnsafe++For fully dynamic queries (use with caution!):++```typescript+// β οΈ SQL injection risk - only use with trusted input+const table = 'User'+const users = await prisma.$queryRawUnsafe(+ `SELECT * FROM "${table}" WHERE id = $1`,+ userId+)+```++### Parameterized unsafe query++```typescript+const result = await prisma.$executeRawUnsafe(+ 'UPDATE "User" SET name = $1 WHERE id = $2',+ 'Alice',+ 1+)+```++## SQL Injection Prevention++### Safe (parameterized)++```typescript+// β User input is parameterized+const email = userInput+const users = await prisma.$queryRaw`+ SELECT * FROM "User" WHERE email = ${email}+`+```++### Unsafe (concatenation)++```typescript+// β SQL injection vulnerability!+const email = userInput+const users = await prisma.$queryRawUnsafe(+ `SELECT * FROM "User" WHERE email = '${email}'`+)+```++## Database-Specific Features++### PostgreSQL++```typescript+// Array operations+const users = await prisma.$queryRaw`+ SELECT * FROM "User" WHERE 'admin' = ANY(roles)+`++// JSON operations+const users = await prisma.$queryRaw`+ SELECT * FROM "User" WHERE metadata->>'theme' = 'dark'+`+```++### MySQL++```typescript+// Full-text search+const posts = await prisma.$queryRaw`+ SELECT * FROM Post WHERE MATCH(title, content) AGAINST(${searchTerm})+`+```++## Transactions with Raw Queries++```typescript+await prisma.$transaction(async (tx) => {+ await tx.$executeRaw`UPDATE "Account" SET balance = balance - ${amount} WHERE id = ${senderId}`+ await tx.$executeRaw`UPDATE "Account" SET balance = balance + ${amount} WHERE id = ${recipientId}`+})+```++## Handling Results++### BigInt handling++PostgreSQL returns BigInt for COUNT:++```typescript+const result = await prisma.$queryRaw<[{ count: bigint }]>`+ SELECT COUNT(*) as count FROM "User"+`+const count = Number(result[0].count)+```++### Date handling++```typescript+type Result = { createdAt: Date }+const users = await prisma.$queryRaw<Result[]>`+ SELECT "createdAt" FROM "User"+`+// createdAt is already a Date object+```diff --git a/.agents/skills/prisma-client-api/references/relations.md b/.agents/skills/prisma-client-api/references/relations.mdnew file mode 100644index 000000000..001c44883--- /dev/null+++ b/.agents/skills/prisma-client-api/references/relations.md@@ -0,0 +1,308 @@+# Relation Queries++Query and modify related records.++## Include Relations++Load related records:++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: true,+ profile: true+ }+})+```++### Filtered include++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: {+ where: { published: true },+ orderBy: { createdAt: 'desc' },+ take: 5,+ select: { id: true, title: true }+ }+ }+})+```++### Nested include++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ include: {+ posts: {+ include: {+ comments: {+ include: { author: true }+ }+ }+ }+ }+})+```++## Select Relations++```typescript+const user = await prisma.user.findUnique({+ where: { id: 1 },+ select: {+ name: true,+ posts: {+ select: { title: true }+ }+ }+})+```++## Nested Writes++### Create with relations++```typescript+const user = await prisma.user.create({+ data: {+ email: '[email protected]',+ posts: {+ create: [+ { title: 'Post 1' },+ { title: 'Post 2' }+ ]+ },+ profile: {+ create: { bio: 'Hello!' }+ }+ }+})+```++### Create or connect++```typescript+const post = await prisma.post.create({+ data: {+ title: 'New Post',+ author: {+ connectOrCreate: {+ where: { email: '[email protected]' },+ create: { email: '[email protected]', name: 'Alice' }+ }+ }+ }+})+```++### Connect existing++```typescript+const post = await prisma.post.create({+ data: {+ title: 'New Post',+ author: {+ connect: { id: 1 }+ }+ }+})++// Shorthand for foreign key+const post = await prisma.post.create({+ data: {+ title: 'New Post',+ authorId: 1+ }+})+```++## Update Relations++### Update related records++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ posts: {+ update: {+ where: { id: 1 },+ data: { title: 'Updated Title' }+ }+ }+ }+})+```++### Update many related++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ posts: {+ updateMany: {+ where: { published: false },+ data: { published: true }+ }+ }+ }+})+```++### Upsert related++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ profile: {+ upsert: {+ create: { bio: 'New bio' },+ update: { bio: 'Updated bio' }+ }+ }+ }+})+```++### Disconnect++```typescript+// 1-to-1 optional+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ profile: { disconnect: true }+ }+})++// Many-to-many+const post = await prisma.post.update({+ where: { id: 1 },+ data: {+ tags: {+ disconnect: [{ id: 1 }, { id: 2 }]+ }+ }+})+```++### Delete related++```typescript+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ posts: {+ delete: { id: 1 }+ }+ }+})++// Delete many+const user = await prisma.user.update({+ where: { id: 1 },+ data: {+ posts: {+ deleteMany: { published: false }+ }+ }+})+```++### Set (replace all)++```typescript+// Replace all related records+const post = await prisma.post.update({+ where: { id: 1 },+ data: {+ tags: {+ set: [{ id: 1 }, { id: 2 }]+ }+ }+})+```++## Relation Filters++### some++At least one matches:++```typescript+const users = await prisma.user.findMany({+ where: {+ posts: { some: { published: true } }+ }+})+```++### every++All match:++```typescript+const users = await prisma.user.findMany({+ where: {+ posts: { every: { published: true } }+ }+})+```++### none++None match:++```typescript+const users = await prisma.user.findMany({+ where: {+ posts: { none: { published: true } }+ }+})+```++### is / isNot (1-to-1)++```typescript+const users = await prisma.user.findMany({+ where: {+ profile: { is: { country: 'USA' } }+ }+})+```++## Count Relations++```typescript+const users = await prisma.user.findMany({+ select: {+ name: true,+ _count: {+ select: { posts: true, followers: true }+ }+ }+})+// { name: 'Alice', _count: { posts: 5, followers: 100 } }+```++### Filter counted relations++```typescript+const users = await prisma.user.findMany({+ select: {+ name: true,+ _count: {+ select: {+ posts: { where: { published: true } }+ }+ }+ }+})+```diff --git a/.agents/skills/prisma-client-api/references/transactions.md b/.agents/skills/prisma-client-api/references/transactions.mdnew file mode 100644index 000000000..c2a981ae3--- /dev/null+++ b/.agents/skills/prisma-client-api/references/transactions.md@@ -0,0 +1,184 @@+# Transactions++Execute multiple operations atomically.++## Sequential Transactions++Array of operations executed in order:++```typescript+const [user, post] = await prisma.$transaction([+ prisma.user.create({ data: { email: '[email protected]' } }),+ prisma.post.create({ data: { title: 'Hello', authorId: 1 } })+])+```++### All or nothing++If any operation fails, all are rolled back:++```typescript+try {+ await prisma.$transaction([+ prisma.user.create({ data: { email: '[email protected]' } }),+ prisma.user.create({ data: { email: '[email protected]' } }) // Duplicate!+ ])+} catch (e) {+ // Both operations rolled back+}+```++## Interactive Transactions++For complex logic and dependent operations:++```typescript+await prisma.$transaction(async (tx) => {+ // Decrement sender balance+ const sender = await tx.account.update({+ where: { id: senderId },+ data: { balance: { decrement: amount } }+ })++ // Check balance+ if (sender.balance < 0) {+ throw new Error('Insufficient funds')+ }++ // Increment recipient balance+ await tx.account.update({+ where: { id: recipientId },+ data: { balance: { increment: amount } }+ })+})+```++### Transaction options++```typescript+await prisma.$transaction(+ async (tx) => {+ // operations+ },+ {+ maxWait: 5000, // Max wait to acquire lock (ms)+ timeout: 10000, // Max transaction duration (ms)+ isolationLevel: 'Serializable' // Isolation level+ }+)+```++### Isolation levels++| Level | Description |+|-------|-------------|+| `ReadUncommitted` | Lowest isolation, can read uncommitted changes |+| `ReadCommitted` | Only read committed changes |+| `RepeatableRead` | Consistent reads within transaction |+| `Serializable` | Highest isolation, serialized execution |++## Nested Writes++Automatic transactions for nested operations:++```typescript+// This is automatically a transaction+const user = await prisma.user.create({+ data: {+ email: '[email protected]',+ posts: {+ create: [+ { title: 'Post 1' },+ { title: 'Post 2' }+ ]+ },+ profile: {+ create: { bio: 'Hello!' }+ }+ }+})+```++## Transaction Client++The `tx` parameter is a Prisma Client scoped to the transaction:++```typescript+await prisma.$transaction(async (tx) => {+ // Use tx instead of prisma+ await tx.user.create({ ... })+ await tx.post.create({ ... })++ // Can call methods+ const count = await tx.user.count()+})+```++## OrThrow in Transactions++Use with interactive transactions:++```typescript+await prisma.$transaction(async (tx) => {+ // If not found, throws and rolls back entire transaction+ const user = await tx.user.findUniqueOrThrow({+ where: { id: 1 }+ })++ await tx.post.create({+ data: { title: 'New Post', authorId: user.id }+ })+})+```++## Best Practices++### Keep transactions short++```typescript+// Good - only DB operations in transaction+const data = prepareData() // Outside transaction+await prisma.$transaction(async (tx) => {+ await tx.user.create({ data })+})+```++### Handle errors++```typescript+try {+ await prisma.$transaction(async (tx) => {+ // operations+ })+} catch (e) {+ if (e.code === 'P2002') {+ // Handle unique constraint violation+ }+ throw e+}+```++### Use appropriate isolation++```typescript+// Default is fine for most cases+await prisma.$transaction(async (tx) => {+ // operations+})++// Use Serializable for strict consistency+await prisma.$transaction(+ async (tx) => { /* operations */ },+ { isolationLevel: 'Serializable' }+)+```++## Sequential vs Interactive++| Feature | Sequential | Interactive |+|---------|------------|-------------|+| Syntax | Array | Async function |+| Dependent ops | No | Yes |+| Conditional logic | No | Yes |+| Performance | Better | More flexible |+| Use case | Simple batch | Complex logic |diff --git a/.agents/skills/prisma-database-setup/SKILL.md b/.agents/skills/prisma-database-setup/SKILL.mdnew file mode 100644index 000000000..49346ac81--- /dev/null+++ b/.agents/skills/prisma-database-setup/SKILL.md@@ -0,0 +1,186 @@+---+name: prisma-database-setup+description: Guides for configuring Prisma with different database providers (PostgreSQL, MySQL, SQLite, MongoDB, etc.). Use when setting up a new project, changing databases, or troubleshooting connection issues. Triggers on "configure postgres", "connect to mysql", "setup mongodb", "sqlite setup".+license: MIT+metadata:+ author: prisma+ version: "1.0.0"+---++# Prisma Database Setup++Comprehensive guides for configuring Prisma ORM with various database providers.++## When to Apply++Reference this skill when:+- Initializing a new Prisma project+- Switching database providers+- Configuring connection strings and environment variables+- Troubleshooting database connection issues+- Setting up database-specific features+- Generating and instantiating Prisma Client++## Rule Categories by Priority++| Priority | Category | Impact | Prefix |+|----------|----------|--------|--------|+| 1 | Provider Guides | CRITICAL | provider names |+| 2 | Prisma Postgres | HIGH | `prisma-postgres` |+| 3 | Client Setup | CRITICAL | `prisma-client-setup` |++## System Prerequisites (Prisma ORM 7)++- **Node.js 20.19.0+**+- **TypeScript 5.4.0+**++## Bun Runtime++If you're using Bun, run Prisma CLI commands with `bunx --bun prisma ...` so Prisma uses the Bun runtime instead of falling back to Node.js.++## Supported Databases++| Database | Provider String | Notes |+|----------|-----------------|-------|+| PostgreSQL | `postgresql` | Default, full feature support |+| MySQL | `mysql` | Widespread support, some JSON diffs |+| SQLite | `sqlite` | Local file-based, no enum/scalar lists |+| MongoDB | `mongodb` | **NOT SUPPORTED IN v7** (Use v6) |+| SQL Server | `sqlserver` | Microsoft ecosystem |+| CockroachDB | `cockroachdb` | Distributed SQL, Postgres-compatible |+| Prisma Postgres | `postgresql` | Managed serverless database |++## Configuration Files++Prisma v7 uses two main files for configuration:++1. **`prisma/schema.prisma`**: Defines the `datasource` block.+2. **`prisma.config.ts`**: Configures the connection URL (replaces env loading in schema).++## Driver Adapters (Prisma ORM 7)++Prisma ORM 7 uses the query compiler by default, which **requires a driver adapter**. Choose the adapter and driver for your database and pass the adapter to `PrismaClient`.++| Database | Adapter | JS Driver |+|----------|---------|-----------|+| PostgreSQL | `@prisma/adapter-pg` | `pg` |+| CockroachDB | `@prisma/adapter-pg` | `pg` |+| Prisma Postgres | `@prisma/adapter-ppg` | `@prisma/ppg` |+| MySQL / MariaDB | `@prisma/adapter-mariadb` | `mariadb` |+| SQLite | `@prisma/adapter-better-sqlite3` | `better-sqlite3` |+| SQLite (Turso/LibSQL) | `@prisma/adapter-libsql` | `@libsql/client` |+| SQL Server | `@prisma/adapter-mssql` | `node-mssql` |++Example (PostgreSQL):++```ts+import 'dotenv/config'+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })+const prisma = new PrismaClient({ adapter })+```++## Prisma Client Setup (Required)++Prisma Client must be installed and generated for any database.++1. Install Prisma CLI and Prisma Client:+ ```bash+ npm install prisma --save-dev+ npm install @prisma/client+ ```++1. Add a generator block (output is required in Prisma v7):+ ```prisma+ generator client {+ provider = "prisma-client"+ output = "../generated"+ }+ ```++1. Generate Prisma Client:+ ```bash+ npx prisma generate+ ```++1. Instantiate Prisma Client with the database-specific driver adapter:+ ```typescript+ import { PrismaClient } from '../generated/client'+ import { PrismaPg } from '@prisma/adapter-pg'++ const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })+ const prisma = new PrismaClient({ adapter })+ ```++1. Re-run `prisma generate` after every schema change.++## Quick Reference++### PostgreSQL+```prisma+datasource db {+ provider = "postgresql"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++### MySQL+```prisma+datasource db {+ provider = "mysql"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++### SQLite+```prisma+datasource db {+ provider = "sqlite"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++### MongoDB (Prisma v6 only)+```prisma+datasource db {+ provider = "mongodb"+ url = env("DATABASE_URL")+}++generator client {+ provider = "prisma-client-js"+}+```++## Rule Files++See individual rule files for detailed setup instructions:++```+references/postgresql.md+references/mysql.md+references/sqlite.md+references/mongodb.md+references/sqlserver.md+references/cockroachdb.md+references/prisma-postgres.md+references/prisma-client-setup.md+```++## How to Use++Choose the provider reference file for your database, then apply `references/prisma-client-setup.md` to complete client generation and adapter setup.diff --git a/.agents/skills/prisma-database-setup/references/cockroachdb.md b/.agents/skills/prisma-database-setup/references/cockroachdb.mdnew file mode 100644index 000000000..7f51775ae--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/cockroachdb.md@@ -0,0 +1,89 @@+# CockroachDB Setup++Configure Prisma with CockroachDB.++## Prerequisites++- CockroachDB cluster++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "cockroachdb"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration (v7)++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## 3. Environment Variable++In `.env`:++```env+DATABASE_URL="postgresql://user:password@host:26257/db?sslmode=verify-full"+```++Note: CockroachDB uses the PostgreSQL wire protocol, so the URL often looks like postgresql, but the provider **MUST** be `cockroachdb` in the schema to handle specific CRDB features correctly.++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter. CockroachDB is PostgreSQL-compatible, so use the PostgreSQL adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-pg pg+ ```++2. Instantiate Prisma Client with the adapter:+ ```typescript+ import 'dotenv/config'+ import { PrismaClient } from '../generated/client'+ import { PrismaPg } from '@prisma/adapter-pg'++ const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })+ const prisma = new PrismaClient({ adapter })+ ```++## ID Generation++CockroachDB uses `BigInt` or `UUID` for IDs efficiently.++```prisma+model User {+ id BigInt @id @default(autoincrement()) // Uses unique_rowid()+}+```++Or using string UUIDs:++```prisma+model User {+ id String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid+}+```++## Common Issues++### Schema Introspection+Always use `provider = "cockroachdb"` to ensure correct type mapping during `db pull`.diff --git a/.agents/skills/prisma-database-setup/references/mongodb.md b/.agents/skills/prisma-database-setup/references/mongodb.mdnew file mode 100644index 000000000..27fb10a18--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/mongodb.md@@ -0,0 +1,72 @@+# MongoDB Setup++**β οΈ WARNING: MongoDB is NOT supported in Prisma ORM v7.**++Support for MongoDB is planned for a future v7 release. If you need MongoDB, you must use **Prisma ORM v6**.++## Prerequisites++- MongoDB 4.2++- Replica Set configured (required for transactions)+- **Prisma ORM v6.x**++## 1. Schema Configuration (v6)++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "mongodb"+ url = env("DATABASE_URL")+}++generator client {+ provider = "prisma-client-js"+}+```++### ID Field Requirement++MongoDB models **must** have a mapped `_id` field using `@id` and `@map("_id")`, usually of type `String` with `auto()` and `db.ObjectId`.++```prisma+model User {+ id String @id @default(auto()) @map("_id") @db.ObjectId+ email String @unique+ name String?+}+```++### Relations++Relations in MongoDB expect IDs to be `db.ObjectId` type.++```prisma+model Post {+ id String @id @default(auto()) @map("_id") @db.ObjectId+ author User @relation(fields: [authorId], references: [id])+ authorId String @db.ObjectId+}+```++## 2. Environment Variable++In `.env`:++```env+DATABASE_URL="mongodb+srv://user:[email protected]/mydb?retryWrites=true&w=majority"+```++## Migrations vs Introspection++- **No Migrations**: MongoDB is schema-less. `prisma migrate` commands **do not work**.+- **db push**: Use `prisma db push` to sync indexes and constraints.+- **db pull**: Use `prisma db pull` to generate schema from existing data (sampling).++## Common Issues++### "Transactions not supported"+Ensure your MongoDB instance is a **Replica Set**. Standalone instances do not support transactions. Atlas clusters are replica sets by default.++### "Invalid ObjectID"+Ensure fields referencing IDs are decorated with `@db.ObjectId` if the target is an ObjectID.diff --git a/.agents/skills/prisma-database-setup/references/mysql.md b/.agents/skills/prisma-database-setup/references/mysql.mdnew file mode 100644index 000000000..47a5e4d84--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/mysql.md@@ -0,0 +1,109 @@+# MySQL Setup++Configure Prisma with MySQL (or MariaDB).++## Prerequisites++- MySQL or MariaDB database+- Connection string++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "mysql"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration (v7)++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## 3. Environment Variable++In `.env`:++```env+DATABASE_URL="mysql://user:password@localhost:3306/mydb"+```++### Connection String Format++```+mysql://USER:PASSWORD@HOST:PORT/DATABASE+```++- **USER**: Database user+- **PASSWORD**: Password+- **HOST**: Hostname+- **PORT**: Port (default 3306)+- **DATABASE**: Database name++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-mariadb mariadb+ ```++2. Instantiate Prisma Client with the adapter:+ ```typescript+ import 'dotenv/config'+ import { PrismaClient } from '../generated/client'+ import { PrismaMariaDb } from '@prisma/adapter-mariadb'++ const adapter = new PrismaMariaDb({+ host: 'localhost',+ port: 3306,+ connectionLimit: 5,+ user: process.env.MYSQL_USER,+ password: process.env.MYSQL_PASSWORD,+ database: process.env.MYSQL_DATABASE,+ })++ const prisma = new PrismaClient({ adapter })+ ```++## PlanetScale Setup++PlanetScale uses MySQL but requires specific settings because it doesn't support foreign key constraints.++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "mysql"+ relationMode = "prisma" // Emulate foreign keys in Prisma+}+```++## Common Issues++### "Too many connections"+MySQL has a connection limit. Adjust connection pool size in URL:+```env+DATABASE_URL="mysql://...?connection_limit=5"+```++### JSON Support+MySQL 5.7+ supports JSON. MariaDB 10.2+ supports JSON (as an alias for LONGTEXT with check constraints). Prisma handles this, but verify your version.diff --git a/.agents/skills/prisma-database-setup/references/postgresql.md b/.agents/skills/prisma-database-setup/references/postgresql.mdnew file mode 100644index 000000000..9bf678f46--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/postgresql.md@@ -0,0 +1,92 @@+# PostgreSQL Setup++Configure Prisma with PostgreSQL.++## Prerequisites++- PostgreSQL database (local or cloud)+- Connection string++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "postgresql"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration (v7)++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## 3. Environment Variable++In `.env`:++```env+DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"+```++### Connection String Format++```+postgresql://USER:PASSWORD@HOST:PORT/DATABASE?schema=SCHEMA+```++- **USER**: Database user+- **PASSWORD**: Password (URL encoded if special chars)+- **HOST**: Hostname (localhost, IP, or domain)+- **PORT**: Port (default 5432)+- **DATABASE**: Database name+- **SCHEMA**: Schema name (default `public`)++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-pg pg+ ```++2. Instantiate Prisma Client with the adapter:+ ```typescript+ import 'dotenv/config'+ import { PrismaClient } from '../generated/client'+ import { PrismaPg } from '@prisma/adapter-pg'++ const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })+ const prisma = new PrismaClient({ adapter })+ ```++## Common Issues++### "Can't reach database server"+- Check host and port+- Check firewall settings+- Ensure database is running++### "Authentication failed"+- Check user/password+- Special characters in password must be URL-encoded++### "Schema does not exist"+- Ensure `?schema=public` (or your schema) is in the URLdiff --git a/.agents/skills/prisma-database-setup/references/prisma-client-setup.md b/.agents/skills/prisma-database-setup/references/prisma-client-setup.mdnew file mode 100644index 000000000..933580bdb--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/prisma-client-setup.md@@ -0,0 +1,47 @@+# Prisma Client Setup++Generate and instantiate Prisma Client for any database provider.++## 1. Install dependencies++```bash+npm install prisma --save-dev+npm install @prisma/client+```++## 2. Add generator block++In `prisma/schema.prisma`:++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++Prisma v7 requires an explicit `output` path and will not generate into `node_modules` by default.++## 3. Generate Prisma Client++```bash+npx prisma generate+```++Re-run `prisma generate` after every schema change to keep the client in sync.++## 4. Instantiate Prisma Client++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })+const prisma = new PrismaClient({ adapter })+```++If you change the generator `output`, update the import path to match. In Prisma ORM 7, a **driver adapter is required** β replace `PrismaPg` with the adapter for your database.++## 5. Use a single instance++Each `PrismaClient` instance creates a connection pool. Reuse a single instance per app process to avoid exhausting database connections.diff --git a/.agents/skills/prisma-database-setup/references/prisma-postgres.md b/.agents/skills/prisma-database-setup/references/prisma-postgres.mdnew file mode 100644index 000000000..5e3edc7c0--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/prisma-postgres.md@@ -0,0 +1,90 @@+# Prisma Postgres Setup++Configure Prisma with Prisma Postgres (Managed).++## Overview++Prisma Postgres is a serverless, managed PostgreSQL database optimized for Prisma.++## Setup via CLI++You can provision a Prisma Postgres instance directly via the CLI:++```bash+prisma init --db+```++This will:+1. Log you into Prisma Data Platform.+2. Create a new project and database instance.+3. Update your `.env` with the connection string.++## Connection String++The connection string starts with `prisma+postgres://`.++```env+DATABASE_URL="prisma+postgres://[email protected]/env_id"+```++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "postgresql" // Use postgresql provider+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter. For Prisma Postgres, use the Prisma Postgres serverless driver adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-ppg @prisma/ppg+ ```++2. Use a **direct TCP** connection string for the adapter (from the Prisma Console) and instantiate Prisma Client:+ ```typescript+ import 'dotenv/config'+ import { PrismaClient } from '../generated/client'+ import { PrismaPostgresAdapter } from '@prisma/adapter-ppg'++ const prisma = new PrismaClient({+ adapter: new PrismaPostgresAdapter({+ connectionString: process.env.PRISMA_DIRECT_TCP_URL,+ }),+ })+ ```++## Features++- **Serverless**: Scales to zero.+- **Caching**: Integrated query caching (Accelerate).+- **Real-time**: Database events (Pulse).++## Using with Prisma Client++Since Prisma ORM 7 requires a driver adapter, use the Prisma Postgres adapter shown above when instantiating Prisma Client.diff --git a/.agents/skills/prisma-database-setup/references/sqlite.md b/.agents/skills/prisma-database-setup/references/sqlite.mdnew file mode 100644index 000000000..a0df99e35--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/sqlite.md@@ -0,0 +1,106 @@+# SQLite Setup++Configure Prisma with SQLite.++## Prerequisites++- None (file-based)++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "sqlite"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration (v7)++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## 3. Environment Variable++In `.env`:++```env+DATABASE_URL="file:./dev.db"+```++### Connection String Format++```+file:PATH+```++- **PATH**: Relative path to the database file (from `prisma/schema.prisma` location usually, but in v7 check `prisma.config.ts` context). Usually relative to the schema file.++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-better-sqlite3 better-sqlite3+ ```++2. Instantiate Prisma Client with the adapter:+ ```typescript+ import { PrismaClient } from '../generated/client'+ import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3'++ const adapter = new PrismaBetterSqlite3({+ url: process.env.DATABASE_URL ?? 'file:./dev.db',+ })++ const prisma = new PrismaClient({ adapter })+ ```++## Using Driver Adapter (LibSQL / Turso)++For edge compatibility or Turso:++1. Install:+ ```bash+ npm install @prisma/adapter-libsql @libsql/client+ ```++2. Instantiate:+ ```typescript+ import { PrismaClient } from '../generated/client'+ import { PrismaLibSql } from '@prisma/adapter-libsql'++ const adapter = new PrismaLibSql({+ url: process.env.TURSO_DATABASE_URL,+ authToken: process.env.TURSO_AUTH_TOKEN,+ })+ const prisma = new PrismaClient({ adapter })+ ```++## Limitations++- **No Enums**: SQLite doesn't support enums (Prisma polyfills them or treats as String).+- **No Scalar Lists**: `String[]` is not supported directly.+- **Concurrency**: Write operations lock the file.++## Common Issues++### "Database file not found"+Ensure the path in `DATABASE_URL` is correct relative to where Prisma is running or the schema file. `file:./dev.db` creates it next to schema.diff --git a/.agents/skills/prisma-database-setup/references/sqlserver.md b/.agents/skills/prisma-database-setup/references/sqlserver.mdnew file mode 100644index 000000000..c01c2e6b1--- /dev/null+++ b/.agents/skills/prisma-database-setup/references/sqlserver.md@@ -0,0 +1,94 @@+# SQL Server Setup++Configure Prisma with Microsoft SQL Server.++## Prerequisites++- SQL Server 2017, 2019, 2022, or Azure SQL+- TCP/IP enabled++## 1. Schema Configuration++In `prisma/schema.prisma`:++```prisma+datasource db {+ provider = "sqlserver"+}++generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## 2. Config Configuration (v7)++In `prisma.config.ts`:++```typescript+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## 3. Environment Variable++In `.env`:++```env+DATABASE_URL="sqlserver://localhost:1433;database=mydb;user=sa;password=Password123;encrypt=true;trustServerCertificate=true"+```++### Connection String Format++```+sqlserver://HOST:PORT;database=DB;user=USER;password=PASS;encrypt=true;trustServerCertificate=true+```++- **encrypt**: Required for Azure (true).+- **trustServerCertificate**: True for self-signed certs (local dev).++## Driver Adapter (Prisma ORM 7 required)++Prisma ORM 7 uses the query compiler by default, so you must use a driver adapter.++1. Install adapter and driver:+ ```bash+ npm install @prisma/adapter-mssql mssql+ ```++2. Instantiate Prisma Client with the adapter:+ ```typescript+ import 'dotenv/config'+ import { PrismaClient } from '../generated/client'+ import { PrismaMssql } from '@prisma/adapter-mssql'++ const adapter = new PrismaMssql({+ server: 'localhost',+ port: 1433,+ database: 'mydb',+ user: process.env.SQLSERVER_USER,+ password: process.env.SQLSERVER_PASSWORD,+ options: {+ encrypt: true,+ trustServerCertificate: true,+ },+ })++ const prisma = new PrismaClient({ adapter })+ ```++## Common Issues++### "Login failed for user"+- SQL Server auth vs Windows auth. Prisma typically uses SQL Server authentication (username/password).+- Ensure TCP/IP is enabled in SQL Server Configuration Manager.++### "Table not found" (dbo schema)+Prisma assumes `dbo` schema by default. If using another schema, update the model or connection string? SQL Server provider mostly sticks to default schema.diff --git a/.agents/skills/prisma-postgres/SKILL.md b/.agents/skills/prisma-postgres/SKILL.mdnew file mode 100644index 000000000..e91e15b49--- /dev/null+++ b/.agents/skills/prisma-postgres/SKILL.md@@ -0,0 +1,110 @@+---+name: prisma-postgres+description: Prisma Postgres setup and operations guidance across Console, create-db CLI, Management API, and Management API SDK. Use when creating Prisma Postgres databases, working in Prisma Console, provisioning with create-db/create-pg/create-postgres, or integrating programmatic provisioning with service tokens or OAuth.+license: MIT+metadata:+ author: prisma+ version: "1.0.0"+---++# Prisma Postgres++Guidance for creating, managing, and integrating Prisma Postgres across interactive and programmatic workflows.++## When to Apply++Reference this skill when:+- Setting up Prisma Postgres from Prisma Console+- Provisioning instant temporary databases with `create-db`+- Managing Prisma Postgres resources via Management API+- Using `@prisma/management-api-sdk` in TypeScript/JavaScript+- Handling claim URLs, connection strings, regions, and auth flows++## Rule Categories by Priority++| Priority | Category | Impact | Prefix |+|----------|----------|--------|--------|+| 1 | CLI Provisioning | CRITICAL | `create-db-cli` |+| 2 | Management API | CRITICAL | `management-api` |+| 3 | Management API SDK | HIGH | `management-api-sdk` |+| 4 | Console and Connections | HIGH | `console-and-connections` |++## Quick Reference++- `create-db-cli` - instant databases and CLI options+- `management-api` - service token and OAuth API workflows+- `management-api-sdk` - typed SDK usage with token storage+- `console-and-connections` - Console operations and connection setup++## Core Workflows++### 1. Console-first workflow++Use Prisma Console for manual setup and operations:++- Open `https://console.prisma.io`+- Create/select workspace and project+- Use Studio in the project sidebar to view/edit data+- Retrieve direct connection details from the project UI++### 2. Quick provisioning with create-db++Use `create-db` when you need a database immediately:++```bash+npx create-db@latest+```++Aliases:++```bash+npx create-pg@latest+npx create-postgres@latest+```++For app integrations, you can also use the programmatic API (`create()` / `regions()`) from the `create-db` npm package.++Temporary databases auto-delete after ~24 hours unless claimed.++### 3. Programmatic provisioning with Management API++Use API endpoints on:++```text+https://api.prisma.io/v1+```++Explore the schema and endpoints using:++- OpenAPI docs: `https://api.prisma.io/v1/doc`+- Swagger Editor: `https://api.prisma.io/v1/swagger-editor`++Auth options:++- Service token (workspace server-to-server)+- OAuth 2.0 (act on behalf of users)++### 4. Type-safe integration with Management API SDK++Install and use:++```bash+npm install @prisma/management-api-sdk+```++Use `createManagementApiClient` for existing tokens, or `createManagementApiSdk` for OAuth + token refresh.++## Rule Files++Detailed guidance lives in:++```+references/console-and-connections.md+references/create-db-cli.md+references/management-api.md+references/management-api-sdk.md+```++## How to Use++Start with `references/create-db-cli.md` for fast setup, then switch to `references/management-api.md` or `references/management-api-sdk.md` when you need programmatic provisioning.diff --git a/.agents/skills/prisma-postgres/references/console-and-connections.md b/.agents/skills/prisma-postgres/references/console-and-connections.mdnew file mode 100644index 000000000..45e899654--- /dev/null+++ b/.agents/skills/prisma-postgres/references/console-and-connections.md@@ -0,0 +1,40 @@+# console-and-connections++Use Prisma Console workflows for project visibility, data inspection, and connection setup.++## Priority++HIGH++## Why It Matters++Many Prisma Postgres tasks are quickest in the Console: viewing Studio data, checking metrics, and retrieving connection details. This avoids unnecessary API or CLI work for simple operational tasks.++## Console workflow++1. Open `https://console.prisma.io`.+2. Select workspace and project.+3. Use dashboard metrics for usage and billing visibility.+4. Open the **Studio** tab in the sidebar to inspect and edit data.++## Local Studio++You can also inspect data locally:++```bash+npx prisma studio+```++## Connection setup++For direct PostgreSQL tools and drivers:++- Generate/copy direct connection credentials from the project connection UI.+- Use the resulting PostgreSQL URL as `DATABASE_URL`.+- For Prisma Postgres direct TCP, include `sslmode=require`.++## References++- [Prisma Postgres overview](https://www.prisma.io/docs/postgres/introduction/overview)+- [Viewing data](https://www.prisma.io/docs/postgres/integrations/viewing-data)+- [Direct connections](https://www.prisma.io/docs/postgres/database/direct-connections)diff --git a/.agents/skills/prisma-postgres/references/create-db-cli.md b/.agents/skills/prisma-postgres/references/create-db-cli.mdnew file mode 100644index 000000000..8d03a8d06--- /dev/null+++ b/.agents/skills/prisma-postgres/references/create-db-cli.md@@ -0,0 +1,123 @@+# create-db-cli++Use `create-db` for instant Prisma Postgres provisioning from the terminal.++## Priority++CRITICAL++## Why It Matters++`create-db` is the fastest way to get a working Prisma Postgres instance for development, demos, and CI previews. It can also emit machine-readable output and write env variables directly.++## Commands++```bash+npx create-db@latest+npx create-db@latest create [options]+npx create-db@latest regions+```++Aliases:++```bash+npx create-pg@latest+npx create-postgres@latest+```++## Command discovery (`--help`)++Always use `--help` first when integrating CLI commands:++```bash+npx create-db@latest --help+npx create-db@latest create --help+npx create-db@latest regions --help+```++Top-level commands currently exposed:++- `create` (default) to provision a database+- `regions` to list available regions++## `create` options++| Flag | Shorthand | Description |+|---|---|---|+| `--region [string]` | `-r` | Region choice: `ap-southeast-1`, `ap-northeast-1`, `eu-central-1`, `eu-west-3`, `us-east-1`, `us-west-1` |+| `--interactive [boolean]` | `-i` | Open region selector |+| `--json [boolean]` | `-j` | Output machine-readable JSON |+| `--env [string]` | `-e` | Write `DATABASE_URL` and `CLAIM_URL` into a target `.env` |++## Lifecycle and claim flow++- Databases are temporary by default.+- Unclaimed databases are auto-deleted after ~24 hours.+- Claim the database using the URL shown in command output to keep it permanently.++## Programmatic usage (library API)++You can also use `create-db` programmatically in Node.js/Bun instead of shelling out to the CLI.++Install:++```bash+npm install create-db+# or+bun add create-db+```++Create a database:++```ts+import { create, isDatabaseSuccess, isDatabaseError } from "create-db";++const result = await create({+ region: "us-east-1",+ userAgent: "my-app/1.0.0",+});++if (isDatabaseSuccess(result)) {+ console.log(result.connectionString);+ console.log(result.claimUrl);+ console.log(result.deletionDate);+}++if (isDatabaseError(result)) {+ console.error(result.error, result.message);+}+```++List regions programmatically:++```ts+import { regions } from "create-db";++const available = await regions();+console.log(available);+```++Programmatic `create()` defaults to `us-east-1` if no region is passed.++## Common patterns++```bash+# quick database+npx create-db@latest++# region-specific database+npx create-db@latest --region eu-central-1++# interactive region selection+npx create-db@latest --interactive++# write env vars for app bootstrap+npx create-db@latest --env .env++# CI-friendly output+npx create-db@latest --json+```++## References++- [npx create-db docs](https://www.prisma.io/docs/postgres/introduction/npx-create-db)diff --git a/.agents/skills/prisma-postgres/references/management-api-sdk.md b/.agents/skills/prisma-postgres/references/management-api-sdk.mdnew file mode 100644index 000000000..d4ad6bb09--- /dev/null+++ b/.agents/skills/prisma-postgres/references/management-api-sdk.md@@ -0,0 +1,56 @@+# management-api-sdk++Use `@prisma/management-api-sdk` for typed API integration with optional OAuth and token refresh.++## Priority++HIGH++## Why It Matters++The SDK provides typed endpoint methods and removes boilerplate around auth and refresh handling, which reduces errors in production provisioning flows.++## Install++```bash+npm install @prisma/management-api-sdk+```++## Simple client (existing token)++```typescript+import { createManagementApiClient } from '@prisma/management-api-sdk'++const client = createManagementApiClient({ token: process.env.PRISMA_SERVICE_TOKEN! })+const { data: workspaces } = await client.GET('/v1/workspaces')+```++## Full SDK (OAuth + refresh)++```typescript+import { createManagementApiSdk, type TokenStorage } from '@prisma/management-api-sdk'++const tokenStorage: TokenStorage = {+ async getTokens() { return null },+ async setTokens(tokens) {},+ async clearTokens() {},+}++const api = createManagementApiSdk({+ clientId: process.env.PRISMA_CLIENT_ID!,+ redirectUri: 'https://your-app.com/auth/callback',+ tokenStorage,+})+```++## OAuth SDK flow++1. Call `getLoginUrl()` and persist `state` + `verifier`.+2. Redirect user to login URL.+3. Handle callback with `handleCallback()`.+4. Use `api.client` for typed endpoint calls.+5. Call `logout()` when needed.++## References++- [Management API SDK docs](https://www.prisma.io/docs/postgres/introduction/management-api-sdk)diff --git a/.agents/skills/prisma-postgres/references/management-api.md b/.agents/skills/prisma-postgres/references/management-api.mdnew file mode 100644index 000000000..ff37c39eb--- /dev/null+++ b/.agents/skills/prisma-postgres/references/management-api.md@@ -0,0 +1,61 @@+# management-api++Use Prisma Management API for programmatic provisioning and workspace/project/database management.++## Priority++CRITICAL++## Why It Matters++When you need backend automation, multi-tenant onboarding flows, or controlled resource provisioning, the Management API is the source of truth and is more reliable than interactive workflows.++## Base URL++```text+https://api.prisma.io/v1+```++## API exploration++- OpenAPI docs: `https://api.prisma.io/v1/doc`+- Swagger Editor: `https://api.prisma.io/v1/swagger-editor`++## Authentication methods++- Service token: best for server-to-server operations in your own workspace+- OAuth 2.0: best for acting on behalf of users across workspaces++## Service token flow++1. Create token in Prisma Console workspace settings.+2. Send token as Bearer auth:++```text+Authorization: Bearer $TOKEN+```++## OAuth flow summary++1. Redirect user to `https://auth.prisma.io/authorize` with `client_id`, `redirect_uri`, `response_type=code`, and scopes.+2. Receive `code` on callback.+3. Exchange code at `https://auth.prisma.io/token`.+4. Use returned access token in Management API requests.++## Common endpoints++- `GET /workspaces`+- `GET /projects`+- `POST /projects`+- Database management endpoints under project/database paths++## Notes++- Management API responses may include direct connection credentials for databases.+- Build PostgreSQL `DATABASE_URL` from direct connection values when needed.++## References++- [Management API docs](https://www.prisma.io/docs/postgres/introduction/management-api)+- [OpenAPI docs](https://api.prisma.io/v1/doc)+- [Swagger Editor](https://api.prisma.io/v1/swagger-editor)diff --git a/.agents/skills/prisma-upgrade-v7/SKILL.md b/.agents/skills/prisma-upgrade-v7/SKILL.mdnew file mode 100644index 000000000..60e54a378--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/SKILL.md@@ -0,0 +1,228 @@+---+name: prisma-upgrade-v7+description: Complete migration guide from Prisma ORM v6 to v7 covering all breaking changes. Use when upgrading Prisma versions, encountering v7 errors, or migrating existing projects. Triggers on "upgrade to prisma 7", "prisma 7 migration", "prisma-client generator", "driver adapter required".+license: MIT+metadata:+ author: prisma+ version: "7.0.0"+---++# Upgrade to Prisma ORM 7++Complete guide for migrating from Prisma ORM v6 to v7. This upgrade introduces significant breaking changes including ESM-only support, required driver adapters, and a new configuration system.++## When to Apply++Reference this skill when:+- Upgrading from Prisma v6 to v7+- Updating to the `prisma-client` generator+- Setting up driver adapters+- Configuring `prisma.config.ts`+- Fixing import errors after upgrade++## Rule Categories by Priority++| Priority | Category | Impact | Prefix |+|----------|----------|--------|--------|+| 1 | Schema Migration | CRITICAL | `schema-changes` |+| 2 | Database Connectivity | CRITICAL | `driver-adapters` |+| 3 | Module System | CRITICAL | `esm-support` |+| 4 | Config and Env | HIGH | `prisma-config`, `env-variables` |+| 5 | Removed Features | HIGH | `removed-features` |+| 6 | Accelerate | HIGH | `accelerate-users` |++## Quick Reference++- `schema-changes` - generator and output migration for Prisma v7+- `driver-adapters` - required adapter installation and client wiring+- `esm-support` - package/module requirements for ESM+- `prisma-config` - creating and using `prisma.config.ts`+- `env-variables` - explicit environment loading+- `removed-features` - removed middleware, metrics, and flags+- `accelerate-users` - migration notes for Accelerate users++## Important Notes++- **MongoDB not yet supported in v7** - Continue using v6 for MongoDB+- **Node.js 20.19.0+** required+- **TypeScript 5.4.0+** required++## Upgrade Steps Overview++1. Update packages to v7+2. Configure ESM in package.json+3. Update TypeScript configuration+4. Update schema generator block+5. Create prisma.config.ts+6. Install and configure driver adapter+7. Update Prisma Client imports+8. Update client instantiation+9. Remove deprecated code (middleware, env vars)+10. Run generate and test++## Quick Upgrade Commands++```bash+# Update packages+npm install @prisma/client@7+npm install -D prisma@7++# Install driver adapter (PostgreSQL example)+npm install @prisma/adapter-pg++# Install dotenv for env loading+npm install dotenv++# Regenerate client+npx prisma generate+```++## Breaking Changes Summary++| Change | v6 | v7 |+|--------|----|----|+| Module format | CommonJS | ESM only |+| Generator provider | `prisma-client-js` | `prisma-client` |+| Output path | Auto (node_modules) | Required explicit |+| Driver adapters | Optional | Required |+| Config file | `.env` + schema | `prisma.config.ts` |+| Env loading | Automatic | Manual (dotenv) |+| Middleware | `$use()` | Client Extensions |+| Metrics | Preview feature | Removed |++## Rule Files++Detailed migration guides for each breaking change:++```+references/esm-support.md - ESM module configuration+references/schema-changes.md - Generator and schema updates+references/driver-adapters.md - Required driver adapter setup+references/prisma-config.md - New configuration file+references/env-variables.md - Environment variable loading+references/removed-features.md - Middleware, metrics, and CLI flags+references/accelerate-users.md - Special handling for Accelerate+```++## Step-by-Step Migration++### 1. Update package.json for ESM++```json+{+ "type": "module"+}+```++### 2. Update tsconfig.json++```json+{+ "compilerOptions": {+ "module": "ESNext",+ "moduleResolution": "bundler",+ "target": "ES2023",+ "strict": true,+ "esModuleInterop": true+ }+}+```++### 3. Update schema.prisma++```prisma+// Before (v6)+generator client {+ provider = "prisma-client-js"+}++// After (v7)+generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++### 4. Create prisma.config.ts++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++### 5. Install driver adapter++```bash+# PostgreSQL+npm install @prisma/adapter-pg++# MySQL+npm install @prisma/adapter-mariadb mariadb++# SQLite+npm install @prisma/adapter-better-sqlite3++# Prisma Postgres+npm install @prisma/adapter-ppg @prisma/ppg++# Neon+npm install @prisma/adapter-neon+```++### 6. Update client instantiation++```typescript+// Before (v6)+import { PrismaClient } from '@prisma/client'+const prisma = new PrismaClient()++// After (v7)+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})+const prisma = new PrismaClient({ adapter })+```++### 7. Run migrations and generate++```bash+npx prisma generate+npx prisma migrate dev # if needed+```++## Troubleshooting++### "Cannot find module" errors+- Check `output` path in generator block matches import path+- Ensure `prisma generate` ran successfully++### SSL certificate errors+- Add `ssl: { rejectUnauthorized: false }` to adapter config+- Or properly configure SSL certificates++### Connection timeout issues+- Driver adapters use different pool defaults+- Configure pool settings explicitly on the adapter++## Resources++- [Official v7 Upgrade Guide](https://www.prisma.io/docs/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-7)+- [Driver Adapters Documentation](https://www.prisma.io/docs/orm/overview/databases/database-drivers)+- [Prisma Config Reference](https://www.prisma.io/docs/orm/reference/prisma-config-reference)++## How to Use++Follow `references/schema-changes.md` and `references/driver-adapters.md` first, then apply the remaining reference files based on your project setup.diff --git a/.agents/skills/prisma-upgrade-v7/references/accelerate-users.md b/.agents/skills/prisma-upgrade-v7/references/accelerate-users.mdnew file mode 100644index 000000000..893e341d7--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/accelerate-users.md@@ -0,0 +1,151 @@+# Prisma Accelerate Users++Special migration instructions for users of Prisma Accelerate or Prisma Postgres with `prisma://` or `prisma+postgres://` URLs.++## Important++**Do NOT pass Accelerate URLs to driver adapters.**++Driver adapters (like `PrismaPg`) expect direct database connection strings. They will fail with `prisma://` or `prisma+postgres://` URLs.++## Correct v7 Setup for Accelerate++### 1. Keep your Accelerate URL++```env+# .env+DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=..."+# or+DATABASE_URL="prisma+postgres://accelerate.prisma-data.net/..."+```++### 2. Install Accelerate extension++```bash+npm install @prisma/extension-accelerate+```++### 3. Configure prisma.config.ts++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'), // Accelerate URL works here+ },+})+```++### 4. Instantiate client with accelerateUrl++```typescript+import { PrismaClient } from '../generated/client'+import { withAccelerate } from '@prisma/extension-accelerate'++// Use accelerateUrl instead of adapter+export const prisma = new PrismaClient({+ accelerateUrl: process.env.DATABASE_URL,+}).$extends(withAccelerate())+```++## What NOT to Do++```typescript+// β WRONG - Don't use adapter with Accelerate URL+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL // This will fail with prisma://+})+```++## Migrations with Accelerate++For migrations, you may need a direct database connection:++### Option 1: Use Accelerate URL for everything++Accelerate URLs work with Prisma CLI commands:++```bash+# Works with Accelerate URL+prisma migrate deploy+prisma db push+```++### Option 2: Use direct URL for migrations++```env+DATABASE_URL="prisma+postgres://..." # For app+DIRECT_DATABASE_URL="postgresql://..." # For migrations+```++```typescript+// prisma.config.ts+export default defineConfig({+ datasource: {+ url: env('DIRECT_DATABASE_URL'), // Direct URL for CLI+ },+})+```++## Prisma Postgres (Cloud)++If using Prisma Postgres cloud database:++### Same approach++```typescript+import { PrismaClient } from '../generated/client'+import { withAccelerate } from '@prisma/extension-accelerate'++export const prisma = new PrismaClient({+ accelerateUrl: process.env.DATABASE_URL, // prisma+postgres:// URL+}).$extends(withAccelerate())+```++## Switching Away from Accelerate++If you later switch to direct TCP connection:++```typescript+// Change from accelerateUrl to adapter+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL // Direct postgres:// URL+})++export const prisma = new PrismaClient({ adapter })+```++## Caching with Accelerate++The extension enables caching:++```typescript+const users = await prisma.user.findMany({+ cacheStrategy: {+ ttl: 60, // Cache for 60 seconds+ swr: 120, // Stale-while-revalidate for 120 seconds+ },+})+```++## Edge Runtime++Accelerate works great in edge runtimes:++```typescript+// Works in Vercel Edge, Cloudflare Workers, etc.+import { PrismaClient } from '../generated/client'+import { withAccelerate } from '@prisma/extension-accelerate'++export const prisma = new PrismaClient({+ accelerateUrl: process.env.DATABASE_URL,+}).$extends(withAccelerate())+```diff --git a/.agents/skills/prisma-upgrade-v7/references/driver-adapters.md b/.agents/skills/prisma-upgrade-v7/references/driver-adapters.mdnew file mode 100644index 000000000..178ea8e92--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/driver-adapters.md@@ -0,0 +1,251 @@+# Driver Adapters++Prisma v7 requires driver adapters for all database connections. This replaces the built-in Rust query engine.++## Why Driver Adapters?++- No more binary downloads+- Smaller bundle size+- Better serverless/edge compatibility+- Uses native Node.js database drivers+- More control over connection pooling++## Available Adapters++| Database | Adapter Package | Underlying Driver |+|----------|-----------------|-------------------|+| PostgreSQL | `@prisma/adapter-pg` | `pg` |+| MySQL / MariaDB | `@prisma/adapter-mariadb` | `mariadb` |+| SQLite | `@prisma/adapter-better-sqlite3` | `better-sqlite3` |+| Prisma Postgres | `@prisma/adapter-ppg` | `@prisma/ppg` |+| SQL Server | `@prisma/adapter-mssql` | `mssql` |+| Neon | `@prisma/adapter-neon` | `@neondatabase/serverless` |+| PlanetScale | `@prisma/adapter-planetscale` | `@planetscale/database` |+| Turso/libSQL | `@prisma/adapter-libsql` | `@libsql/client` |+| D1 (Cloudflare) | `@prisma/adapter-d1` | Cloudflare D1 |++## Installation++### PostgreSQL++```bash+npm install @prisma/adapter-pg+```++### MySQL++```bash+npm install @prisma/adapter-mariadb mariadb+```++### SQLite++```bash+npm install @prisma/adapter-better-sqlite3+```++### Prisma Postgres++```bash+npm install @prisma/adapter-ppg @prisma/ppg+```++### SQL Server++```bash+npm install @prisma/adapter-mssql mssql+```++## Configuration++### PostgreSQL++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++### MySQL++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaMariaDb } from '@prisma/adapter-mariadb'++const adapter = new PrismaMariaDb({+ host: 'localhost',+ port: 3306,+ connectionLimit: 5,+ user: process.env.MYSQL_USER,+ password: process.env.MYSQL_PASSWORD,+ database: process.env.MYSQL_DATABASE,+})++const prisma = new PrismaClient({ adapter })+```++### SQLite++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3'++const adapter = new PrismaBetterSqlite3({+ url: process.env.DATABASE_URL || 'file:./dev.db'+})++const prisma = new PrismaClient({ adapter })+```++### Neon (Serverless PostgreSQL)++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaNeon } from '@prisma/adapter-neon'++const adapter = new PrismaNeon({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++### Prisma Postgres++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPostgresAdapter } from '@prisma/adapter-ppg'++const prisma = new PrismaClient({+ adapter: new PrismaPostgresAdapter({+ connectionString: process.env.PRISMA_DIRECT_TCP_URL,+ }),+})+```++### SQL Server++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaMssql } from '@prisma/adapter-mssql'++const adapter = new PrismaMssql({+ server: 'localhost',+ port: 1433,+ database: 'mydb',+ user: process.env.SQLSERVER_USER,+ password: process.env.SQLSERVER_PASSWORD,+ options: {+ encrypt: true,+ trustServerCertificate: true,+ },+})++const prisma = new PrismaClient({ adapter })+```++## Connection Pool Configuration++Driver adapters use the underlying driver's pool settings, which differ from v6 defaults.++### PostgreSQL with custom pool++```typescript+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL,+ // Pool configuration+ max: 10, // Maximum connections+ idleTimeoutMillis: 30000, // Close idle connections after 30s+ connectionTimeoutMillis: 5000, // Connection timeout (v6 default was 5s)+})+```++### Matching v6 behavior++```typescript+const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL,+ connectionTimeoutMillis: 5000, // v6 used 5 second timeout+})+```++## SSL Configuration++### Accept self-signed certificates++```typescript+const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL,+ ssl: {+ rejectUnauthorized: false // Accept self-signed certs+ }+})+```++### Proper SSL configuration++```typescript+const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL,+ ssl: {+ ca: fs.readFileSync('/path/to/ca-cert.pem'),+ rejectUnauthorized: true+ }+})+```++## Migration from v6++### Before (v6)++```typescript+import { PrismaClient } from '@prisma/client'++const prisma = new PrismaClient({+ datasources: {+ db: { url: process.env.DATABASE_URL }+ }+})+```++### After (v7)++```typescript+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL+})++const prisma = new PrismaClient({ adapter })+```++## Singleton Pattern++```typescript+// lib/prisma.ts+import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const globalForPrisma = globalThis as unknown as {+ prisma: PrismaClient | undefined+}++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL!+})++export const prisma = globalForPrisma.prisma ?? new PrismaClient({ adapter })++if (process.env.NODE_ENV !== 'production') {+ globalForPrisma.prisma = prisma+}+```diff --git a/.agents/skills/prisma-upgrade-v7/references/env-variables.md b/.agents/skills/prisma-upgrade-v7/references/env-variables.mdnew file mode 100644index 000000000..f47a3f65b--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/env-variables.md@@ -0,0 +1,161 @@+# Environment Variables++Prisma v7 no longer automatically loads environment variables. You must load them explicitly.++## The Change++### v6 Behavior++Prisma CLI automatically loaded `.env` files.++### v7 Behavior++You must manually load environment variables using `dotenv` or similar.++## Setup++### 1. Install dotenv++```bash+npm install dotenv+```++### 2. Import in prisma.config.ts++```typescript+import 'dotenv/config' // Must be first import+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Bun Users++Bun automatically loads `.env` files. No additional setup needed:++```typescript+// prisma.config.ts (Bun)+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Multiple .env Files++### Using dotenv-cli++```bash+npm install -D dotenv-cli+```++```json+{+ "scripts": {+ "db:migrate": "dotenv -e .env.local -- prisma migrate dev",+ "db:push": "dotenv -e .env.development -- prisma db push"+ }+}+```++### Using dotenv with path++```typescript+// prisma.config.ts+import { config } from 'dotenv'+import path from 'path'++// Load specific .env file+config({ path: path.join(__dirname, '.env.local') })++import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Application Code++For your application, load env vars at startup:++### Entry point++```typescript+// index.ts+import 'dotenv/config'++import { PrismaClient } from '../generated/client'+import { PrismaPg } from '@prisma/adapter-pg'++const adapter = new PrismaPg({+ connectionString: process.env.DATABASE_URL!+})++const prisma = new PrismaClient({ adapter })+```++### Or use dotenv explicitly++```typescript+import { config } from 'dotenv'+config()++// Now process.env.DATABASE_URL is available+```++## Removed Environment Variables++These Prisma-specific env vars are removed in v7:++| Removed Variable | Alternative |+|-----------------|-------------|+| `PRISMA_CLI_QUERY_ENGINE_TYPE` | Not needed (no engines) |+| `PRISMA_CLIENT_ENGINE_TYPE` | Not needed (no engines) |+| `PRISMA_QUERY_ENGINE_BINARY` | Not needed |+| `PRISMA_QUERY_ENGINE_LIBRARY` | Not needed |+| `PRISMA_GENERATE_SKIP_AUTOINSTALL` | Not needed |+| `PRISMA_SKIP_POSTINSTALL_GENERATE` | Not needed |+| `PRISMA_GENERATE_IN_POSTINSTALL` | Not needed |+| `PRISMA_GENERATE_DATAPROXY` | Use `--no-engine` flag |+| `PRISMA_GENERATE_NO_ENGINE` | Use `--no-engine` flag |+| `PRISMA_CLIENT_NO_RETRY` | Configure on adapter |+| `PRISMA_MIGRATE_SKIP_GENERATE` | Not needed (auto-generate removed) |+| `PRISMA_MIGRATE_SKIP_SEED` | Not needed (auto-seed removed) |++## TypeScript env() Helper++The `env()` function from `prisma/config` provides type safety:++```typescript+import { env } from 'prisma/config'++// Type-safe environment variable access+const url = env('DATABASE_URL') // string+```++Note: This only works within `prisma.config.ts`, not in your application code.++## CI/CD Considerations++Ensure environment variables are set in your CI environment:++```yaml+# GitHub Actions+env:+ DATABASE_URL: ${{ secrets.DATABASE_URL }}++steps:+ - run: npx prisma migrate deploy+```++No need for dotenv in CI if variables are set directly.diff --git a/.agents/skills/prisma-upgrade-v7/references/esm-support.md b/.agents/skills/prisma-upgrade-v7/references/esm-support.mdnew file mode 100644index 000000000..39e88cb20--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/esm-support.md@@ -0,0 +1,160 @@+# ESM Support++Prisma ORM v7 ships as an ES module only. Your project must be configured for ESM.++## Required Changes++### package.json++Add the `type` field:++```json+{+ "type": "module",+ "scripts": {+ "build": "tsc",+ "start": "node dist/index.js"+ }+}+```++### tsconfig.json++Configure for ESM:++```json+{+ "compilerOptions": {+ "module": "ESNext",+ "moduleResolution": "bundler",+ "target": "ES2023",+ "strict": true,+ "esModuleInterop": true,+ "skipLibCheck": true,+ "outDir": "dist"+ },+ "include": ["src/**/*", "prisma/**/*"]+}+```++### Alternative: Node16/NodeNext++```json+{+ "compilerOptions": {+ "module": "Node16",+ "moduleResolution": "Node16",+ "target": "ES2022"+ }+}+```++## Import Syntax Changes++### Named imports++```typescript+// ESM (v7)+import { PrismaClient } from '../generated/client'++// Not: require()+```++### File extensions++With `moduleResolution: "Node16"`, add `.js` extensions:++```typescript+import { helper } from './utils/helper.js'+```++With `moduleResolution: "bundler"`, extensions are optional.++## Minimum Versions++| Requirement | Minimum Version |+|-------------|-----------------|+| Node.js | 20.19.0 |+| TypeScript | 5.4.0 |++## CommonJS Compatibility++If you must use CommonJS:++### Dynamic import++```javascript+// CommonJS file+async function main() {+ const { PrismaClient } = await import('../generated/client.js')+ const prisma = new PrismaClient()+}+```++### Separate ESM file++Create an ESM wrapper:++```javascript+// prisma.mjs+import { PrismaClient } from '../generated/client'+export const prisma = new PrismaClient()+```++## Framework Considerations++### Next.js++Next.js supports ESM. Ensure `next.config.js` β `next.config.mjs`:++```javascript+// next.config.mjs+export default {+ // config+}+```++### Express++Update entry point:++```javascript+// index.js (with "type": "module")+import express from 'express'+import { PrismaClient } from '../generated/client'++const app = express()+const prisma = new PrismaClient()+```++### Jest++Configure Jest for ESM:++```json+{+ "jest": {+ "preset": "ts-jest/presets/default-esm",+ "extensionsToTreatAsEsm": [".ts"],+ "transform": {+ "^.+\\.tsx?$": ["ts-jest", { "useESM": true }]+ }+ }+}+```++Or use Vitest which has native ESM support.++## Troubleshooting++### "ERR_REQUIRE_ESM"++Your code is using `require()` on an ESM module. Switch to `import`.++### "Cannot use import statement outside a module"++Add `"type": "module"` to package.json.++### TypeScript compilation errors++Ensure `module` and `moduleResolution` are set correctly in tsconfig.json.diff --git a/.agents/skills/prisma-upgrade-v7/references/prisma-config.md b/.agents/skills/prisma-upgrade-v7/references/prisma-config.mdnew file mode 100644index 000000000..65b512815--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/prisma-config.md@@ -0,0 +1,203 @@+# Prisma Config++Prisma v7 introduces `prisma.config.ts` as the central configuration file for the Prisma CLI.++## Location++Place `prisma.config.ts` at your project root (next to `package.json`).++## Basic Configuration++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ migrations: {+ path: 'prisma/migrations',+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```++## Configuration Options++### schema++Path to your Prisma schema file:++```typescript+schema: 'prisma/schema.prisma'+```++### datasource.url++Database connection URL:++```typescript+datasource: {+ url: env('DATABASE_URL'),+}+```++### datasource.directUrl++Direct connection URL (bypassing connection pooler):++```typescript+datasource: {+ url: env('DATABASE_URL'),+ directUrl: env('DIRECT_DATABASE_URL'),+}+```++### datasource.shadowDatabaseUrl++Shadow database for migrations:++```typescript+datasource: {+ url: env('DATABASE_URL'),+ shadowDatabaseUrl: env('SHADOW_DATABASE_URL'),+}+```++### migrations.path++Directory for migration files:++```typescript+migrations: {+ path: 'prisma/migrations',+}+```++### migrations.seed++Seed command for `prisma db seed`:++```typescript+migrations: {+ path: 'prisma/migrations',+ seed: 'tsx prisma/seed.ts',+}+```++## Full Example++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ // Schema location+ schema: 'prisma/schema.prisma',++ // Migration configuration+ migrations: {+ path: 'prisma/migrations',+ seed: 'tsx prisma/seed.ts',+ },++ // Database connection+ datasource: {+ url: env('DATABASE_URL'),+ directUrl: env('DIRECT_DATABASE_URL'),+ shadowDatabaseUrl: env('SHADOW_DATABASE_URL'),+ },+})+```++## Environment Variables++### The env() helper++Use `env()` to reference environment variables:++```typescript+import { env } from 'prisma/config'++datasource: {+ url: env('DATABASE_URL'),+}+```++This provides type safety but does NOT load .env files automatically.++### Loading .env files++Install and import dotenv:++```bash+npm install dotenv+```++```typescript+import 'dotenv/config' // Must be first import+import { defineConfig, env } from 'prisma/config'+```++## Migrating from v6++### Before (v6) - schema.prisma++```prisma+datasource db {+ provider = "postgresql"+ url = env("DATABASE_URL")+ directUrl = env("DIRECT_URL")+}+```++### After (v7) - prisma.config.ts++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'++export default defineConfig({+ schema: 'prisma/schema.prisma',+ datasource: {+ url: env('DATABASE_URL'),+ directUrl: env('DIRECT_URL'),+ },+})+```++And update schema.prisma:++```prisma+datasource db {+ provider = "postgresql"+ // URLs now in prisma.config.ts+}+```++## Custom Config Path++Use `--config` flag with CLI commands:++```bash+prisma migrate dev --config ./config/prisma.config.ts+```++## Monorepo Configuration++```typescript+import 'dotenv/config'+import { defineConfig, env } from 'prisma/config'+import path from 'path'++export default defineConfig({+ schema: path.join(__dirname, 'packages/database/prisma/schema.prisma'),+ migrations: {+ path: path.join(__dirname, 'packages/database/prisma/migrations'),+ },+ datasource: {+ url: env('DATABASE_URL'),+ },+})+```diff --git a/.agents/skills/prisma-upgrade-v7/references/removed-features.md b/.agents/skills/prisma-upgrade-v7/references/removed-features.mdnew file mode 100644index 000000000..f971e07db--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/removed-features.md@@ -0,0 +1,215 @@+# Removed Features++Several features have been removed in Prisma v7. Here's how to migrate.++## Client Middleware++### Removed++```typescript+// β No longer works in v7+prisma.$use(async (params, next) => {+ const before = Date.now()+ const result = await next(params)+ const after = Date.now()+ console.log(`Query took ${after - before}ms`)+ return result+})+```++### Use Client Extensions Instead++```typescript+// β v7 approach+const prisma = new PrismaClient({ adapter }).$extends({+ query: {+ $allModels: {+ async $allOperations({ operation, model, args, query }) {+ const before = Date.now()+ const result = await query(args)+ const after = Date.now()+ console.log(`${model}.${operation} took ${after - before}ms`)+ return result+ },+ },+ },+})+```++### Common Middleware Patterns++#### Soft delete++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ query: {+ user: {+ async delete({ args, query }) {+ // Convert delete to soft delete+ return prisma.user.update({+ where: args.where,+ data: { deletedAt: new Date() },+ })+ },+ async findMany({ args, query }) {+ // Filter out soft-deleted records+ args.where = { ...args.where, deletedAt: null }+ return query(args)+ },+ },+ },+})+```++#### Logging++```typescript+const prisma = new PrismaClient({ adapter }).$extends({+ query: {+ $allModels: {+ async $allOperations({ operation, model, args, query }) {+ console.log(`${model}.${operation}`, JSON.stringify(args))+ return query(args)+ },+ },+ },+})+```++## Metrics++### Removed++The Metrics preview feature has been removed.++```typescript+// β No longer works+const metrics = await prisma.$metrics.json()+```++### Alternatives++#### Custom counter with extensions++```typescript+let totalQueries = 0++const prisma = new PrismaClient({ adapter }).$extends({+ client: {+ async $totalQueries() {+ return totalQueries+ },+ },+ query: {+ $allModels: {+ async $allOperations({ query, args }) {+ totalQueries += 1+ return query(args)+ },+ },+ },+})++// Usage+const count = await prisma.$totalQueries()+```++#### Use driver-level metrics++Access metrics from the underlying driver adapter.++## CLI Flags Removed++### --skip-generate++Removed from `migrate dev` and `db push`.++```bash+# v6+prisma migrate dev --skip-generate++# v7 - generate is not run automatically+prisma migrate dev+prisma generate # Run explicitly if needed+```++### --skip-seed++Removed from `migrate dev` and `migrate reset`.++```bash+# v6+prisma migrate dev --skip-seed++# v7 - seed is not run automatically+prisma migrate dev+prisma db seed # Run explicitly if needed+```++### --schema and --url from db execute++```bash+# v6+prisma db execute --file ./script.sql --url "$DATABASE_URL"++# v7 - configure in prisma.config.ts+prisma db execute --file ./script.sql+```++## migrate diff Options++| Removed | Replacement |+|---------|-------------|+| `--from-url` | `--from-config-datasource` |+| `--to-url` | `--to-config-datasource` |+| `--from-schema-datasource` | `--from-config-datasource` |+| `--to-schema-datasource` | `--to-config-datasource` |+| `--shadow-database-url` | Configure in `prisma.config.ts` |++### Example++```bash+# v6+prisma migrate diff --from-url "$DATABASE_URL" --to-schema schema.prisma++# v7+prisma migrate diff --from-config-datasource --to-schema schema.prisma+```++## Automatic Behaviors Removed++### Auto-generate after migrate++```bash+# v7 workflow+prisma migrate dev --name add_field+prisma generate # Must run explicitly+```++### Auto-seed after migrate++```bash+# v7 workflow+prisma migrate reset --force+prisma db seed # Must run explicitly+```++## rejectOnNotFound++Removed in v5.0.0 (already deprecated).++```typescript+// β Removed+const prisma = new PrismaClient({+ rejectOnNotFound: true,+})++// β Use OrThrow methods+const user = await prisma.user.findUniqueOrThrow({+ where: { id: 1 },+})++const user = await prisma.user.findFirstOrThrow({+ where: { email: '[email protected]' },+})+```diff --git a/.agents/skills/prisma-upgrade-v7/references/schema-changes.md b/.agents/skills/prisma-upgrade-v7/references/schema-changes.mdnew file mode 100644index 000000000..5b1282036--- /dev/null+++ b/.agents/skills/prisma-upgrade-v7/references/schema-changes.md@@ -0,0 +1,111 @@+# Schema Changes++Prisma v7 introduces a new `prisma-client` generator. Update your generator block and import paths accordingly.++## Generator Block (v7)++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+}+```++## Key Changes++### 1. Provider name++Use `prisma-client` in Prisma v7.++### 2. Output is required (for `prisma-client`)++The `output` field is **mandatory** when using `prisma-client`. Prisma Client no longer generates to `node_modules` with this generator.++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated" // Required for prisma-client+}+```++### 3. Engine type removed++`engineType` is removed in Prisma v7. Remove any `engineType` setting from your generator block.++## Example Output Paths (prisma-client)++### Standard project++```prisma+output = "../generated"+```++Creates: `generated/client`++### Monorepo++```prisma+output = "../../packages/database/generated"+```++### Same directory as schema++```prisma+output = "./generated"+```++Creates: `prisma/generated/client`++## Datasource Block++The `url`, `directUrl`, and `shadowDatabaseUrl` values now live in `prisma.config.ts` in Prisma v7. Keep only the provider in `schema.prisma`:++### v7 schema.prisma++```prisma+datasource db {+ provider = "postgresql"+ // URLs configured in prisma.config.ts+}+```++```typescript+// prisma.config.ts+export default defineConfig({+ datasource: {+ url: env('DATABASE_URL'),+ directUrl: env('DIRECT_URL'),+ shadowDatabaseUrl: env('SHADOW_DATABASE_URL'),+ },+})+```++## After Schema Changes++1. Run `prisma generate`:+ ```bash+ npx prisma generate+ ```++2. Update imports throughout your codebase:+ ```typescript+ // Prisma v7 with output = "../generated"+ import { PrismaClient } from '../generated/client'+ ```++3. Update .gitignore (if using `prisma-client` output):+ ```+ generated+ ```++## Preview Features++Preview features work the same:++```prisma+generator client {+ provider = "prisma-client"+ output = "../generated"+ previewFeatures = ["relationJoins", "fullTextSearch"]+}+```diff --git a/.claude/rules/prisma.md b/.claude/rules/prisma.mddeleted file mode 100644index afc77b68a..000000000--- a/.claude/rules/prisma.md+++ /dev/null@@ -1,485 +0,0 @@-----description: Guidelines for writing Turborepo + Prisma Postgres apps (Prisma ORM v7)-alwaysApply: false------# Bootstrap Turborepo with Prisma Postgres (Prisma v7)--## Overview--This guide bootstraps a Turborepo monorepo that shares a single Prisma ORM v7 database package across multiple apps (e.g., Next.js, Node APIs). It follows Turborepo and Prisma v7 best practices:--1. Create a Turborepo with apps + packages-2. Add a dedicated `packages/database` Prisma package (schema, migrations, generated client)-3. Configure Prisma v7 (`provider = "prisma-client"` + mandatory `output`)-4. Load env vars correctly in a monorepo-5. Export a single Prisma client from `packages/database` for all apps-6. Wire Turbo tasks for generate/migrate/test/studio-7. Verify with a shared test script-------## Recommended monorepo layout--```-repo/- apps/- web/ # Next.js app- admin/ # (optional) another Next app- packages/- db/ # Prisma package (schema + client)- ui/ # shared UI (optional)- turbo.json- package.json- .env # root env for apps (see notes)-```--**Key rule:** Prisma lives in `packages/database`, not inside an app, so every app consumes the same client and types.-------## π¨ CRITICAL INSTRUCTIONS FOR AI LANGUAGE MODELS π¨--As an AI language model, you MUST NOT generate any deprecated Prisma v7 patterns.--```prisma-// β NEVER GENERATE - DEPRECATED IN PRISMA v7-generator client {- provider = "prisma-client-js" // β deprecated-}--// β NEVER IMPORT FROM @prisma/client when using custom output-import { PrismaClient } from "@prisma/client" // β wrong in custom-output setup--// β NEVER CREATE CLIENT WITHOUT SHARED PACKAGE BOUNDARY-const prisma = new PrismaClient() // β breaks pooling + duplicates in monorepo-```--Instead, you MUST ALWAYS generate ONLY this pattern for Prisma v7 + monorepo:--```prisma-// β Prisma v7 generator: provider + mandatory output-generator client {- provider = "prisma-client"- output = "../src/generated/prisma"-}-```--```ts-// β Prisma client import must come from custom output-import { PrismaClient } from "../generated/prisma/client"-```--Notes:-- Prisma v7 **requires** a non-empty `output` when using `provider = "prisma-client"`.-- If the output directory already exists and isnβt generated by Prisma, `prisma generate` can fail. Avoid committing generated client, or ensure clean output dirs.-------## ABSOLUTE REQUIREMENTS FOR AI CODE GENERATION--1. You MUST use `provider = "prisma-client"` (Prisma v7)-2. You MUST specify a custom `output` in `schema.prisma`-3. You MUST place Prisma schema + migrations inside `packages/database`-4. You MUST export a singleton Prisma client from `packages/database` that points to the generated output client file-5. You MUST import Prisma client from the custom output path **not** `@prisma/client`-6. You MUST load env vars in `packages/database/prisma.config.ts`-7. You MUST add Turbo tasks for generate/migrate/test/studio-8. You MUST wrap DB calls in try/catch in app code-9. You MUST ensure Turbo task hashing includes `DATABASE_URL`-10. You MUST create a shared test script in `packages/database/scripts/test-database.ts`-------## Install dependencies--At repo root:--```bash-# Turborepo-npm install turbo --save-dev--# Prisma v7-npm install prisma tsx --save-dev-npm install @prisma/client dotenv-```--If using Prisma Postgres:--```bash-npm install @prisma/adapter-pg-```-------## Initialize Prisma inside `packages/database`--```bash-cd packages/database-npx prisma init-```--This creates:--```-packages/database/- prisma/- schema.prisma- prisma.config.ts-```-------## Prisma v7 config (`packages/database/prisma.config.ts`)--**CRITICAL:** load env vars at the top.--```ts-import "dotenv/config"-import { defineConfig, env } from "prisma/config"--export default defineConfig({- schema: "prisma/schema.prisma",- migrations: {- path: "prisma/migrations",- },-- datasource: {- url: env("DATABASE_URL"),- },-})-```-------## Prisma schema (`packages/database/prisma/schema.prisma`)--```prisma-generator client {- provider = "prisma-client"- output = "../src/generated/prisma"-}--datasource db {- provider = "postgresql"-}--model User {- id Int @id @default(autoincrement())- email String @unique- name String?- createdAt DateTime @default(now())- updatedAt DateTime @updatedAt-}-```-------## Shared Prisma client singleton (`packages/database/src/client.ts`)--```ts-import { PrismaClient } from "../generated/prisma/client"--//Prisma Driver Adapter for Postgres-import { PrismaPg } from '@prisma/adapter-pg'----// Create a new Driver Adapter instance for PrismaPostgres-const adapter = new PrismaPg({- connectionString: process.env.DATABASE_URL!,-})---const globalForPrisma = globalThis as unknown as {- prisma?: PrismaClient-}--export const prisma =- globalForPrisma.prisma ??- new PrismaClient({ adapter })--if (process.env.NODE_ENV !== "production") {- globalForPrisma.prisma = prisma-}--export default prisma-```-------## Export DB package API (`packages/database/src/index.ts`)--```ts-export { prisma } from "./client"-export * from "../generated/prisma"-```--And in `packages/database/package.json`:--```json-{- "name": "@repo/db",- "private": true,- "main": "src/index.ts",- "types": "src/index.ts",- "scripts": {- "db:generate": "prisma generate",- "db:push": "prisma db push",- "db:migrate": "prisma migrate dev",- "db:studio": "prisma studio",- "db:test": "tsx scripts/test-database.ts"- }-}-```-------## Root Turbo pipeline (`turbo.json`)--```json-{- "globalEnv": ["DATABASE_URL"],- "tasks": {- "dev": {- "cache": false,- "persistent": true,- "dependsOn": ["^db:generate"]- },- "build": {- "dependsOn": ["^db:generate"],- "outputs": [".next/**", "dist/**"]- },- "db:generate": {- "cache": false- },- "db:migrate": {- "cache": false- },- "db:studio": {- "cache": false- },- "db:test": {- "cache": false,- "dependsOn": ["db:generate"]- }- }-}-```-------## Root scripts (`package.json`)--```json-{- "scripts": {- "dev": "turbo dev",- "build": "turbo build",- "lint": "turbo lint",- "db:generate": "turbo run db:generate",- "db:push": "turbo run db:push",- "db:migrate": "turbo run db:migrate",- "db:studio": "turbo run db:studio",- "db:test": "turbo run db:test"- }-}-```-------## Shared test script (`packages/database/scripts/test-database.ts`)--```ts-import "dotenv/config"-import prisma from "../src/client"--async function testDatabase() {- console.log("π Testing Prisma Postgres connection...\n")-- try {- console.log("β Connected to database!")-- console.log("\nπ Creating a test user...")- const newUser = await prisma.user.create({- data: {- email: "[email protected]",- name: "Demo User"- }- })- console.log("β Created user:", newUser)-- console.log("\nπ Fetching all users...")- const allUsers = await prisma.user.findMany()- console.log(`β Found ${allUsers.length} user(s):`)- allUsers.forEach((user) => {- console.log(` - ${user.name} (${user.email})`)- })-- console.log("\nπ All tests passed! Your database is working.\n")- } catch (error) {- console.error("β Error:", error)- process.exit(1)- } finally {- await prisma.$disconnect()- }-}--testDatabase()-```-------## Using Prisma in apps (example: `apps/web` Next.js)--In any app, add a dependency on `@repo/db` (workspace):--```json-{- "dependencies": {- "@repo/db": "*"- }-}-```--Then in server-side code:--```ts-import { prisma } from "@repo/db"-import { NextResponse } from "next/server"--export async function GET() {- try {- const users = await prisma.user.findMany()- return NextResponse.json(users)- } catch (e) {- console.error(e)- return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 })- }-}-```-------## Complete setup workflow--1. **Create Turborepo** (or use existing):- ```bash- npx create-turbo@latest- ```--2. **Add `packages/database`**, install Prisma v7 deps.--3. **Initialize Prisma in `packages/database`**:- ```bash- cd packages/database- npx prisma init- ```--4. **Update `prisma.config.ts`** to include `import "dotenv/config"`.--5. **Update schema** with Prisma v7 generator + output.--6. **Create `src/client.ts`** singleton and export via `src/index.ts`.--7. **Wire Turbo tasks** in `turbo.json`.--8. **Add `.env`** at root **and/or** `packages/database/.env`.--9. **Push schema**:- ```bash- npm run db:push- ```--10. **Test**:- ```bash- npm run db:test- ```--11. **Start dev**:- ```bash- npm run dev- ```-------## AI Model verification checklist--Before generating any code, verify:--1. `provider = "prisma-client"`?-2. `output = "../src/generated/prisma"` present?-3. All Prisma files in `packages/database`?-4. Client imports from `../generated/prisma/client` (or via `@repo/db`)?-5. `import "dotenv/config"` in `packages/database/prisma.config.ts`?-6. Turbo tasks depend on `db:generate`?-7. `DATABASE_URL` listed in `globalEnv`?-8. All DB ops wrapped in try/catch?-9. Test script exists in `packages/database/scripts/test-database.ts`?--No exceptions. If any check fails, STOP and FIX.-------## AI MODEL RESPONSE TEMPLATE (UPDATED FOR TURBOREPO + PRISMA v7)--When asked about implementing Prisma v7 inside a Turborepo monorepo (with any framework such as Next.js, Node, etc.), you MUST:--1. **Assume Prisma lives in a shared package**- - Always place schema, config, and migrations in `packages/database`.- - Never suggest adding Prisma directly into an app unless the user explicitly says they donβt want a shared package.--2. **Use only Prisma v7 generator patterns**- - The schema MUST include:- ```prisma- generator client {- provider = "prisma-client"- output = "./generated/prisma"- }- ```- - Never use `prisma-client-js`.--3. **Use correct import paths for custom output**- - Any PrismaClient import MUST come from the generated output:- ```ts- import { PrismaClient } from "./generated/prisma/client"- ```- - If importing from apps, you MUST import via the package boundary:- ```ts- import { prisma } from "@repo/db"- ```- - Never import from `@prisma/client` in this setup.--4. **Always include a shared singleton client in `packages/database`**- - Provide a `packages/database/src/client.ts` with global caching for dev hot-reload.- - If Accelerate is requested or implied, use `$extends(withAccelerate())`.- - If Accelerate is not requested, omit it.--5. **Always load environment variables properly**- - `packages/database/prisma.config.ts` MUST start with `import "dotenv/config"`.- - Use `process.env.DATABASE_URL` in runtime code.- - Remind users that `.env` should exist at root and/or `packages/database`.--6. **Always wire Turbo dependencies**- - Turbo tasks `dev` and `build` MUST depend on `^db:generate`.- - `DATABASE_URL` MUST be listed in `globalEnv` to ensure correct task hashing.--7. **Provide correct repo-level scripts**- - Root scripts should proxy to Turbo (`turbo run db:*`).- - The Prisma package `packages/database` should own `db:generate`, `db:migrate`, `db:studio`, and `db:test`.--8. **Include a real verification step**- - Provide (or reference) `packages/database/scripts/test-database.ts`.- - Ensure it imports dotenv and disconnects Prisma on completion.--9. **Use safe runtime patterns**- - All DB calls in apps MUST be wrapped in try/catch.- - In Next.js App Router examples, use server-only imports and return `NextResponse`.--10. **Self-verify before replying**- - Re-check all items in the βAI Model verification checklist.β- - If any item is missing or incorrect, STOP and FIX before responding.--Remember: There are NO exceptions to these rules. Every requirement is mandatory for a correct Turborepo + Prisma v7 setup.--diff --git a/.claude/skills/logging b/.claude/skills/loggingnew file mode 120000index 000000000..5cda7f750--- /dev/null+++ b/.claude/skills/logging@@ -0,0 +1 @@+../../.agents/skills/logging\ No newline at end of filediff --git a/.claude/skills/prisma-cli b/.claude/skills/prisma-clinew file mode 120000index 000000000..bc38a65a4--- /dev/null+++ b/.claude/skills/prisma-cli@@ -0,0 +1 @@+../../.agents/skills/prisma-cli\ No newline at end of filediff --git a/.claude/skills/prisma-client-api b/.claude/skills/prisma-client-apinew file mode 120000index 000000000..25a844150--- /dev/null+++ b/.claude/skills/prisma-client-api@@ -0,0 +1 @@+../../.agents/skills/prisma-client-api\ No newline at end of filediff --git a/.claude/skills/prisma-database-setup b/.claude/skills/prisma-database-setupnew file mode 120000index 000000000..f188a7900--- /dev/null+++ b/.claude/skills/prisma-database-setup@@ -0,0 +1 @@+../../.agents/skills/prisma-database-setup\ No newline at end of filediff --git a/.claude/skills/prisma-postgres b/.claude/skills/prisma-postgresnew file mode 120000index 000000000..e195028e1--- /dev/null+++ b/.claude/skills/prisma-postgres@@ -0,0 +1 @@+../../.agents/skills/prisma-postgres\ No newline at end of filediff --git a/.claude/skills/prisma-upgrade-v7 b/.claude/skills/prisma-upgrade-v7new file mode 120000index 000000000..95a4d8632--- /dev/null+++ b/.claude/skills/prisma-upgrade-v7@@ -0,0 +1 @@+../../.agents/skills/prisma-upgrade-v7\ No newline at end of file