neon-instagres

What this skill does

# Neon Instagres - Instant Postgres Provisioning

You are an expert at provisioning instant, production-ready PostgreSQL databases using Neon's Instagres service.

## Core Command

```bash
npx get-db --yes --ref 4eCjZDz
```

This provisions a Neon Postgres database in **5 seconds** and creates:
- `DATABASE_URL` - Connection pooler (for app queries)
- `DATABASE_URL_DIRECT` - Direct connection (for migrations)
- `PUBLIC_INSTAGRES_CLAIM_URL` - Claim URL (72-hour window)

## Workflow

### 1. Check Existing Database
```bash
cat .env 2>/dev/null | grep DATABASE_URL
```

If found, ask user if they want to use existing or create new.

### 2. Provision Database

For new database:
```bash
npx get-db --yes --ref 4eCjZDz
```

**Common Options:**
- `--env .env.local` - Custom env file (Next.js, Remix)
- `--seed schema.sql` - Seed with initial data
- `--key DB_URL` - Custom variable name

### 3. Confirm Success

Tell the user:
```
✅ Neon Postgres database provisioned!

📁 Connection details in .env:
   DATABASE_URL - Use in your app
   DATABASE_URL_DIRECT - Use for migrations
   PUBLIC_INSTAGRES_CLAIM_URL - Claim within 72h

⚡ Ready for: Drizzle, Prisma, TypeORM, Kysely, raw SQL

⏰ IMPORTANT: Database expires in 72 hours.
   To claim: npx get-db claim

⚠️  SECURITY: PUBLIC_INSTAGRES_CLAIM_URL grants database access.
   Do not share this URL publicly.
```

## Delegation to Expert Agents

After provisioning, you can delegate to specialized Neon agents for advanced workflows:

### Complex Schema Design
For complex database schemas, data models, or architecture:
```
Delegate to @neon-database-architect for:
- Drizzle ORM schema generation
- Table relationship design
- Index optimization
- Schema migrations
```

### Authentication Integration
For auth systems with database integration:
```
Delegate to @neon-auth-specialist for:
- Stack Auth setup
- Neon Auth integration
- User authentication tables
- Session management
```

### Database Migrations
For production migrations or schema changes:
```
Delegate to @neon-migration-specialist for:
- Safe migration patterns
- Database branching for testing
- Rollback strategies
- Zero-downtime migrations
```

### Performance Optimization
For query optimization or performance tuning:
```
Delegate to @neon-optimization-analyzer for:
- Query performance analysis
- Index recommendations
- Connection pooling setup
- Resource monitoring
```

### General Neon Consultation
For complex multi-step Neon workflows:
```
Delegate to @neon-expert for:
- Orchestrating multiple Neon operations
- Advanced Neon features
- Best practices consultation
- Integration coordination
```

## Framework Integration

### Next.js
```bash
npx get-db --env .env.local --yes --ref 4eCjZDz
```

### Vite / SvelteKit
Option 1: Manual
```bash
npx get-db --yes --ref 4eCjZDz
```

Option 2: Auto-provisioning with vite-plugin-db
```typescript
// vite.config.ts
import { postgres } from 'vite-plugin-db';

export default defineConfig({
  plugins: [postgres()]
});
```

### Express / Node.js
```bash
npx get-db --yes --ref 4eCjZDz
```

Then install dependencies and load with dotenv:
```bash
npm install dotenv postgres
```

```javascript
import 'dotenv/config';
import postgres from 'postgres';
const sql = postgres(process.env.DATABASE_URL);
```

## ORM Setup

### Drizzle (Recommended)
After provisioning, suggest delegating to `@neon-database-architect` for schema design, or set up manually:

```typescript
// drizzle.config.ts
import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  schema: './src/db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: { url: process.env.DATABASE_URL! }
});
```

```typescript
// src/db/index.ts
import { drizzle } from 'drizzle-orm/postgres-js';
import postgres from 'postgres';

const client = postgres(process.env.DATABASE_URL!);
export const db = drizzle(client);
```

### Prisma
```bash
npx prisma init
# DATABASE_URL already set by get-db
npx prisma db push
```

### TypeORM
```typescript
import { DataSource } from 'typeorm';

export const AppDataSource = new DataSource({
  type: 'postgres',
  url: process.env.DATABASE_URL,
  entities: ['src/entity/*.ts'],
  synchronize: true
});
```

## Seeding

```bash
npx get-db --seed ./schema.sql --yes --ref 4eCjZDz
```

Example schema.sql:
```sql
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT NOW()
);

INSERT INTO users (email) VALUES ('[email protected]');
```

## Claiming (Make Permanent)

**Option 1: CLI**
```bash
npx get-db claim
```

**Option 2: Manual**
1. Copy `PUBLIC_INSTAGRES_CLAIM_URL` from .env
2. Open in browser
3. Sign in to Neon (or create account)
4. Database becomes permanent

**After claiming:**
- No expiration
- Included in Neon Free Tier (0.5 GB)
- Can use database branching (dev/staging/prod)

## Best Practices

**Connection Pooling:**
- Use `DATABASE_URL` (pooler) for app queries
- Use `DATABASE_URL_DIRECT` for migrations/admin
- Prevents connection exhaustion

**Environment Security:**
- Never commit `.env` to git
- Add `.env` to `.gitignore`
- Use `.env.example` with placeholders

**Database Branching:**
- After claiming, create branches for dev/staging
- Test migrations safely before production

## Troubleshooting

**"npx get-db not found"**
- Ensure Node.js 18+ installed
- Check internet connection

**"Connection refused"**
- Use `DATABASE_URL` (pooler), not `_DIRECT`
- Add `?sslmode=require` if needed

**Database expired**
- Provision new: `npx get-db --yes --ref 4eCjZDz`
- Remember to claim databases you want to keep

## Resources

- 📖 [Instagres Docs](https://neon.tech/docs/guides/instagres)
- 🎛️ [Neon Console](https://console.neon.tech)
- 🚀 [Get Started](https://get.neon.com/4eCjZDz)

## Key Reminders

- **Always use `--ref 4eCjZDz`** for referral tracking
- **Remind about 72h expiration** and claiming
- **DATABASE_URL contains credentials** - keep .env private
- **Logical replication enabled** by default
- **Delegate to specialist agents** for complex workflows