@esreekarreddy/ai-prompts 1.0.0

package/contexts/patterns/repository-pattern.md

@@ -0,0 +1,163 @@
+# Repository Pattern
+
+> Abstracting data access from business logic
+
+## Concept
+
+The Repository Pattern separates the data access layer from business logic:
+
+```
+Business Logic → Repository Interface → Repository Implementation → Database
+```
+
+## Benefits
+
+- **Testability**: Mock repositories in tests
+- **Flexibility**: Switch databases without changing business logic
+- **Single Responsibility**: Data access logic in one place
+- **Abstraction**: Business logic doesn't know about SQL/ORM
+
+## Implementation
+
+### TypeScript Example
+
+```typescript
+// types/user.ts
+interface User {
+  id: string;
+  email: string;
+  name: string;
+  createdAt: Date;
+}
+
+interface CreateUserInput {
+  email: string;
+  name: string;
+}
+
+// repositories/user.repository.interface.ts
+interface IUserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  findAll(): Promise<User[]>;
+  create(data: CreateUserInput): Promise<User>;
+  update(id: string, data: Partial<User>): Promise<User>;
+  delete(id: string): Promise<void>;
+}
+
+// repositories/user.repository.ts
+class PrismaUserRepository implements IUserRepository {
+  constructor(private prisma: PrismaClient) {}
+  
+  async findById(id: string): Promise<User | null> {
+    return this.prisma.user.findUnique({ where: { id } });
+  }
+  
+  async findByEmail(email: string): Promise<User | null> {
+    return this.prisma.user.findUnique({ where: { email } });
+  }
+  
+  async findAll(): Promise<User[]> {
+    return this.prisma.user.findMany();
+  }
+  
+  async create(data: CreateUserInput): Promise<User> {
+    return this.prisma.user.create({ data });
+  }
+  
+  async update(id: string, data: Partial<User>): Promise<User> {
+    return this.prisma.user.update({ where: { id }, data });
+  }
+  
+  async delete(id: string): Promise<void> {
+    await this.prisma.user.delete({ where: { id } });
+  }
+}
+```
+
+### Using in Service Layer
+
+```typescript
+// services/user.service.ts
+class UserService {
+  constructor(private userRepo: IUserRepository) {}
+  
+  async registerUser(email: string, name: string): Promise<User> {
+    // Business logic here
+    const existing = await this.userRepo.findByEmail(email);
+    if (existing) {
+      throw new Error('Email already exists');
+    }
+    
+    return this.userRepo.create({ email, name });
+  }
+  
+  async getUserById(id: string): Promise<User> {
+    const user = await this.userRepo.findById(id);
+    if (!user) {
+      throw new NotFoundError('User');
+    }
+    return user;
+  }
+}
+```
+
+### Testing with Mock Repository
+
+```typescript
+// tests/user.service.test.ts
+class MockUserRepository implements IUserRepository {
+  private users: User[] = [];
+  
+  async findById(id: string) {
+    return this.users.find(u => u.id === id) || null;
+  }
+  
+  async findByEmail(email: string) {
+    return this.users.find(u => u.email === email) || null;
+  }
+  
+  async create(data: CreateUserInput) {
+    const user = { id: '1', ...data, createdAt: new Date() };
+    this.users.push(user);
+    return user;
+  }
+  
+  // ... other methods
+}
+
+describe('UserService', () => {
+  it('should register new user', async () => {
+    const repo = new MockUserRepository();
+    const service = new UserService(repo);
+    
+    const user = await service.registerUser('test@example.com', 'Test');
+    
+    expect(user.email).toBe('test@example.com');
+  });
+  
+  it('should reject duplicate email', async () => {
+    const repo = new MockUserRepository();
+    const service = new UserService(repo);
+    
+    await service.registerUser('test@example.com', 'Test');
+    
+    await expect(
+      service.registerUser('test@example.com', 'Test2')
+    ).rejects.toThrow('Email already exists');
+  });
+});
+```
+
+## When to Use
+
+**Good for:**
+- Large applications with complex data access
+- When you might switch databases
+- When extensive testing is needed
+- Multi-database scenarios
+
+**Overkill for:**
+- Simple CRUD apps
+- Prototypes
+- Small projects with single database

package/contexts/patterns/service-layer.md

@@ -0,0 +1,185 @@
+# Service Layer Pattern
+
+> Organizing business logic in a dedicated layer
+
+## Concept
+
+The Service Layer contains business logic, sitting between controllers/handlers and data access:
+
+```
+Controller → Service → Repository → Database
+    ↑           ↓
+    └─── Response
+```
+
+## Benefits
+
+- **Reusability**: Same logic used by API, CLI, jobs
+- **Testability**: Test business logic without HTTP
+- **Separation of Concerns**: Controllers handle HTTP, services handle logic
+- **Transaction Management**: Coordinate multiple operations
+
+## Implementation
+
+### TypeScript Example
+
+```typescript
+// services/order.service.ts
+import { OrderRepository } from '../repositories/order.repository';
+import { ProductRepository } from '../repositories/product.repository';
+import { PaymentService } from './payment.service';
+import { EmailService } from './email.service';
+
+interface CreateOrderInput {
+  userId: string;
+  items: Array<{ productId: string; quantity: number }>;
+  paymentMethodId: string;
+}
+
+class OrderService {
+  constructor(
+    private orderRepo: OrderRepository,
+    private productRepo: ProductRepository,
+    private paymentService: PaymentService,
+    private emailService: EmailService
+  ) {}
+
+  async createOrder(input: CreateOrderInput): Promise<Order> {
+    // 1. Validate products exist and have stock
+    const products = await this.validateAndGetProducts(input.items);
+    
+    // 2. Calculate total
+    const total = this.calculateTotal(products, input.items);
+    
+    // 3. Process payment
+    const payment = await this.paymentService.charge({
+      amount: total,
+      methodId: input.paymentMethodId,
+      userId: input.userId,
+    });
+    
+    if (!payment.success) {
+      throw new PaymentError(payment.error);
+    }
+    
+    // 4. Create order
+    const order = await this.orderRepo.create({
+      userId: input.userId,
+      items: input.items,
+      total,
+      paymentId: payment.id,
+      status: 'confirmed',
+    });
+    
+    // 5. Update inventory
+    await this.productRepo.decrementStock(input.items);
+    
+    // 6. Send confirmation (async, don't wait)
+    this.emailService.sendOrderConfirmation(order).catch(console.error);
+    
+    return order;
+  }
+
+  private async validateAndGetProducts(items: OrderItem[]) {
+    const productIds = items.map(i => i.productId);
+    const products = await this.productRepo.findByIds(productIds);
+    
+    // Check all products exist
+    if (products.length !== productIds.length) {
+      throw new ValidationError('Some products not found');
+    }
+    
+    // Check stock
+    for (const item of items) {
+      const product = products.find(p => p.id === item.productId);
+      if (product.stock < item.quantity) {
+        throw new ValidationError(`Insufficient stock for ${product.name}`);
+      }
+    }
+    
+    return products;
+  }
+
+  private calculateTotal(products: Product[], items: OrderItem[]): number {
+    return items.reduce((sum, item) => {
+      const product = products.find(p => p.id === item.productId);
+      return sum + (product.price * item.quantity);
+    }, 0);
+  }
+}
+```
+
+### Using in Controller
+
+```typescript
+// controllers/order.controller.ts
+class OrderController {
+  constructor(private orderService: OrderService) {}
+
+  async create(req: Request, res: Response, next: NextFunction) {
+    try {
+      const order = await this.orderService.createOrder({
+        userId: req.user.id,
+        items: req.body.items,
+        paymentMethodId: req.body.paymentMethodId,
+      });
+      
+      res.status(201).json(order);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return res.status(400).json({ error: error.message });
+      }
+      if (error instanceof PaymentError) {
+        return res.status(402).json({ error: error.message });
+      }
+      next(error);
+    }
+  }
+}
+```
+
+## Service Guidelines
+
+### Do
+- Contain all business logic
+- Coordinate between repositories
+- Handle transactions
+- Throw domain-specific errors
+
+### Don't
+- Handle HTTP request/response
+- Access request objects directly
+- Know about view layer
+- Contain data access logic
+
+## Service Method Patterns
+
+```typescript
+// Query methods - return data or null
+async getUser(id: string): Promise<User | null> {
+  return this.userRepo.findById(id);
+}
+
+// Command methods - throw on failure
+async createUser(data: CreateUserInput): Promise<User> {
+  // Validation
+  if (await this.userRepo.findByEmail(data.email)) {
+    throw new DuplicateError('Email already exists');
+  }
+  
+  // Business logic
+  const hashedPassword = await this.hashPassword(data.password);
+  
+  // Persistence
+  return this.userRepo.create({
+    ...data,
+    password: hashedPassword,
+  });
+}
+
+// Boolean checks
+async canUserAccess(userId: string, resourceId: string): Promise<boolean> {
+  const resource = await this.resourceRepo.findById(resourceId);
+  return resource?.ownerId === userId;
+}
+```

package/contexts/stacks/fastapi.md

@@ -0,0 +1,187 @@
+# FastAPI Context
+
+> Reference for FastAPI Python web framework
+
+## Key Features
+
+- Fast (async support, Starlette + Pydantic)
+- Automatic OpenAPI/Swagger docs
+- Type hints for validation
+- Dependency injection system
+
+## Basic Structure
+
+```python
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel
+
+app = FastAPI()
+
+class Item(BaseModel):
+    name: str
+    price: float
+    
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+
+@app.get("/items/{item_id}")
+async def get_item(item_id: int):
+    return {"item_id": item_id}
+
+@app.post("/items/")
+async def create_item(item: Item):
+    return item
+```
+
+## Request Handling
+
+### Path Parameters
+```python
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):  # Validated as int
+    return {"user_id": user_id}
+```
+
+### Query Parameters
+```python
+@app.get("/items/")
+async def list_items(
+    skip: int = 0,
+    limit: int = 10,
+    search: str | None = None
+):
+    return {"skip": skip, "limit": limit, "search": search}
+```
+
+### Request Body
+```python
+class CreateUser(BaseModel):
+    email: str
+    name: str
+    password: str
+
+@app.post("/users/")
+async def create_user(user: CreateUser):
+    return {"email": user.email}
+```
+
+## Pydantic Models
+
+```python
+from pydantic import BaseModel, EmailStr, Field
+from datetime import datetime
+
+class UserBase(BaseModel):
+    email: EmailStr
+    name: str = Field(..., min_length=2, max_length=100)
+
+class UserCreate(UserBase):
+    password: str = Field(..., min_length=8)
+
+class UserResponse(UserBase):
+    id: int
+    created_at: datetime
+    
+    model_config = {"from_attributes": True}
+```
+
+## Dependencies
+
+```python
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+async def get_db():
+    async with async_session() as session:
+        yield session
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db)
+):
+    user = await verify_token(db, token)
+    if not user:
+        raise HTTPException(status_code=401)
+    return user
+
+@app.get("/me")
+async def get_me(user: User = Depends(get_current_user)):
+    return user
+```
+
+## Error Handling
+
+```python
+from fastapi import HTTPException, status
+
+@app.get("/items/{item_id}")
+async def get_item(item_id: int):
+    item = await get_item_by_id(item_id)
+    if not item:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Item not found"
+        )
+    return item
+```
+
+## Background Tasks
+
+```python
+from fastapi import BackgroundTasks
+
+async def send_email(email: str, message: str):
+    # Send email
+    pass
+
+@app.post("/notify/")
+async def notify(
+    email: str,
+    background_tasks: BackgroundTasks
+):
+    background_tasks.add_task(send_email, email, "Hello")
+    return {"message": "Notification scheduled"}
+```
+
+## Middleware
+
+```python
+from fastapi.middleware.cors import CORSMiddleware
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.middleware("http")
+async def log_requests(request, call_next):
+    print(f"{request.method} {request.url}")
+    response = await call_next(request)
+    return response
+```
+
+## Routers
+
+```python
+# routers/users.py
+from fastapi import APIRouter
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+@router.get("/")
+async def list_users():
+    return []
+
+# main.py
+from routers import users
+app.include_router(users.router)
+```
+
+## OpenAPI Docs
+
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+- OpenAPI JSON: `http://localhost:8000/openapi.json`

package/contexts/stacks/nextjs-14.md

@@ -0,0 +1,149 @@
+# Next.js 14 Context
+
+> Reference for Next.js 14 with App Router
+
+## Key Concepts
+
+### App Router vs Pages Router
+Next.js 14 uses the **App Router** by default:
+- Files in `app/` directory
+- React Server Components by default
+- New data fetching patterns
+- Layouts and loading states built-in
+
+### Server Components (Default)
+```tsx
+// This is a Server Component (no directive needed)
+async function Page() {
+  const data = await db.query(...);  // Direct database access
+  return <Component data={data} />;
+}
+```
+
+### Client Components (Opt-in)
+```tsx
+'use client';
+
+import { useState } from 'react';
+
+export function Counter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount(c => c + 1)}>{count}</button>;
+}
+```
+
+## File Conventions
+
+| File | Purpose |
+|------|---------|
+| `page.tsx` | Route UI |
+| `layout.tsx` | Shared layout |
+| `loading.tsx` | Loading UI |
+| `error.tsx` | Error boundary |
+| `not-found.tsx` | 404 page |
+| `route.ts` | API route |
+
+## Data Fetching
+
+### In Server Components
+```tsx
+// Fetch directly - no useEffect needed
+async function Page() {
+  const res = await fetch('https://api.example.com/data', {
+    cache: 'force-cache',  // Default: cache
+    // cache: 'no-store',  // No cache
+    // next: { revalidate: 60 }  // Revalidate every 60s
+  });
+  const data = await res.json();
+  return <Display data={data} />;
+}
+```
+
+### Server Actions
+```tsx
+// app/actions.ts
+'use server';
+
+export async function createItem(formData: FormData) {
+  const name = formData.get('name');
+  await db.items.create({ data: { name } });
+  revalidatePath('/items');
+}
+
+// In component
+<form action={createItem}>
+  <input name="name" />
+  <button type="submit">Create</button>
+</form>
+```
+
+## Route Handlers (API)
+
+```typescript
+// app/api/users/route.ts
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+  const users = await db.users.findMany();
+  return NextResponse.json(users);
+}
+
+export async function POST(request: Request) {
+  const body = await request.json();
+  const user = await db.users.create({ data: body });
+  return NextResponse.json(user, { status: 201 });
+}
+```
+
+## Common Patterns
+
+### Dynamic Routes
+```
+app/
+├── users/
+│   └── [id]/
+│       └── page.tsx     → /users/123
+├── blog/
+│   └── [...slug]/
+│       └── page.tsx     → /blog/a/b/c
+```
+
+### Route Groups
+```
+app/
+├── (marketing)/
+│   ├── about/page.tsx   → /about
+│   └── layout.tsx       → Marketing layout
+├── (dashboard)/
+│   ├── dashboard/page.tsx → /dashboard
+│   └── layout.tsx       → Dashboard layout
+```
+
+### Parallel Routes
+```
+app/
+├── @modal/
+│   └── login/page.tsx
+├── @sidebar/
+│   └── default.tsx
+└── layout.tsx           → Renders both in parallel
+```
+
+## Caching
+
+| Type | Default | Control |
+|------|---------|---------|
+| fetch() | Cached | `cache: 'no-store'` |
+| Route Handlers | Not cached | `export const dynamic = 'force-static'` |
+| Server Actions | Not cached | Use `revalidatePath()` |
+
+## When to Use What
+
+| Need | Use |
+|------|-----|
+| Database queries | Server Component |
+| User interaction | Client Component |
+| Form submission | Server Action |
+| External API (frontend) | Client + SWR/React Query |
+| External API (backend) | Route Handler |
+| Mutations | Server Action |