30 Prompts for Cursor: Master AI-Assisted Development in Your IDE

Create a Flask route for /api/users that returns a JSON list of users from a PostgreSQL database. Use SQLAlchemy ORM. Include error handling.

from flask import Blueprint, jsonify
from models import User
from extensions import db

users_bp = Blueprint('users', __name__)

@users_bp.route('/api/users', methods=['GET'])
def get_users():
    try:
        users = User.query.all()
        return jsonify([user.to_dict() for user in users]), 200
    except Exception as e:
        return jsonify({'error': str(e)}), 500

Explain this regex: ^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Add inline comments and a docstring to the following JavaScript function:

function calc(a, b, op) {
  if (op === '+') return a + b;
  if (op === '-') return a - b;
  return a * b;
}

/**
 * Performs basic arithmetic operations.
 * @param {number} a - First operand.
 * @param {number} b - Second operand.
 * @param {string} op - Operator: '+', '-', or '*'.
 * @returns {number} Result of the operation.
 */
function calc(a, b, op) {
  if (op === '+') return a + b;  // Addition
  if (op === '-') return a - b;  // Subtraction
  return a * b;                  // Default to multiplication
}

Convert this Python function to TypeScript with proper types:

def fetch_user(user_id: int) -> dict:
    import requests
    response = requests.get(f'https://api.example.com/users/{user_id}')
    return response.json()

import axios from 'axios';

interface User {
  id: number;
  name: string;
  email: string;
}

async function fetchUser(userId: number): Promise<User> {
  const response = await axios.get<User>(`https://api.example.com/users/${userId}`);
  return response.data;
}

Write Jest tests for this function:

export function isPalindrome(str: string): boolean {
  const cleaned = str.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
  return cleaned === cleaned.split('').reverse().join('');
}

import { isPalindrome } from './utils';

describe('isPalindrome', () => {
  it('returns true for simple palindromes', () => {
    expect(isPalindrome('racecar')).toBe(true);
  });
  it('ignores case and non-alphanumeric characters', () => {
    expect(isPalindrome('A man, a plan, a canal: Panama')).toBe(true);
  });
  it('returns false for non-palindromes', () => {
    expect(isPalindrome('hello')).toBe(false);
  });
  it('handles empty string', () => {
    expect(isPalindrome('')).toBe(true);
  });
});

Refactor this function into smaller, single-responsibility functions. Add type hints and a main orchestrator.

async def process_order(order_id: int):
    order = await db.fetch_one(...)
    if not order:
        raise ValueError('Order not found')
    if order.status != 'pending':
        raise ValueError('Order already processed')
    await payment_service.charge(order.total, order.user_id)
    await db.update(...)
    await email_service.send_confirmation(order.user_email)

async def validate_order(order_id: int) -> dict:
    order = await db.fetch_one(...)
    if not order:
        raise ValueError('Order not found')
    if order.status != 'pending':
        raise ValueError('Order already processed')
    return order

async def charge_customer(order: dict) -> bool:
    return await payment_service.charge(order.total, order.user_id)

async def update_order_status(order_id: int, status: str) -> None:
    await db.update(...)

async def send_confirmation(order: dict) -> None:
    await email_service.send_confirmation(order.user_email)

async def process_order(order_id: int) -> None:
    order = await validate_order(order_id)
    await charge_customer(order)
    await update_order_status(order_id, 'completed')
    await send_confirmation(order)

I have a Python script that reads large CSV files and holds data in a list. Memory usage grows unbounded. Suggest fixes with code examples.

import csv

def read_csv_generator(file_path):
    with open(file_path, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            yield row

# Usage:
for row in read_csv_generator('large.csv'):
    process(row)  # No list accumulation

Optimize this PostgreSQL query. It takes 30 seconds on 10 million rows:

SELECT * FROM orders WHERE user_id IN (SELECT id FROM users WHERE signup_date > '2025-01-01') AND status = 'active';

CREATE INDEX idx_orders_user_id_status ON orders (user_id, status);
CREATE INDEX idx_users_signup_date ON users (signup_date);

SELECT orders.*
FROM orders
JOIN users ON orders.user_id = users.id
WHERE users.signup_date > '2025-01-01' AND orders.status = 'active';

Convert this Node.js callback code to async/await with try/catch:

function getUser(id, cb) {
  db.find(id, (err, user) => {
    if (err) return cb(err);
    cb(null, user);
  });
}

import { promisify } from 'util';

const findAsync = promisify(db.find).bind(db);

async function getUser(id: number): Promise<User> {
  try {
    const user = await findAsync(id);
    return user;
  } catch (error) {
    throw new Error(`Failed to fetch user: ${error.message}`);
  }
}

Add structured logging (using the 'logging' module) to this FastAPI endpoint. Include request ID and execution time.

import logging
import time
from contextvars import ContextVar
from uuid import uuid4

request_id_var: ContextVar[str] = ContextVar('request_id', default='')

logger = logging.getLogger(__name__)

@app.get('/api/items/{item_id}')
async def get_item(item_id: int):
    request_id = str(uuid4())
    request_id_var.set(request_id)
    start = time.time()

    logger.info('Request started', extra={'request_id': request_id, 'item_id': item_id})
    try:
        item = await db.fetch_item(item_id)
        elapsed = time.time() - start
        logger.info('Request completed', extra={'request_id': request_id, 'elapsed': elapsed})
        return item
    except Exception as e:
        elapsed = time.time() - start
        logger.error('Request failed', extra={'request_id': request_id, 'elapsed': elapsed, 'error': str(e)})
        raise

Design a rate limiter for a public API. Support both per-user and per-IP limits. Use Redis. Provide code examples in Python.

import redis
import time

r = redis.Redis()

class RateLimiter:
    def __init__(self, max_requests: int, window_seconds: int):
        self.max_requests = max_requests
        self.window = window_seconds

    def is_allowed(self, key: str) -> bool:
        current = int(time.time())
        window_start = current - self.window

        # Remove old entries
        r.zremrangebyscore(key, 0, window_start)

        # Count requests in current window
        count = r.zcard(key)

        if count < self.max_requests:
            r.zadd(key, {current: current})
            r.expire(key, self.window)
            return True
        return False

# Usage
limiter = RateLimiter(max_requests=100, window_seconds=60)
if limiter.is_allowed(f'user:{user_id}'):
    # process request
    pass

Design an event-driven microservice architecture using RabbitMQ. Show a producer (order service) and consumer (inventory service) in Python with pika.

import pika
import json

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='orders', exchange_type='topic')

order = {'order_id': 123, 'product_id': 456, 'quantity': 2}
channel.basic_publish(exchange='orders', routing_key='order.created', body=json.dumps(order))
print('Order event published')
connection.close()

import pika
import json

def callback(ch, method, properties, body):
    order = json.loads(body)
    print(f'Reserving inventory for order {order["order_id"]}')
    # Update inventory logic
    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='orders', exchange_type='topic')
queue = channel.queue_declare(queue='inventory_queue', durable=True)
channel.queue_bind(exchange='orders', queue='inventory_queue', routing_key='order.created')
channel.basic_consume(queue='inventory_queue', on_message_callback=callback)
channel.start_consuming()

Create an ETL pipeline in Python that extracts data from a PostgreSQL database, transforms it (aggregates sales by region), and loads into a Redshift table. Use pandas and SQLAlchemy.

import pandas as pd
from sqlalchemy import create_engine

# Extract
pg_engine = create_engine('postgresql://user:pass@localhost/sales')
query = 'SELECT region, amount, date FROM orders WHERE date >= CURRENT_DATE - INTERVAL \'1 day\''
df = pd.read_sql(query, pg_engine)

# Transform
df['date'] = pd.to_datetime(df['date'])
df_agg = df.groupby(['region', df['date'].dt.date]).agg(total_sales=('amount', 'sum')).reset_index()

# Load
rs_engine = create_engine('redshift://user:pass@redshift-cluster.amazonaws.com:5439/dwh')
df_agg.to_sql('daily_sales_by_region', rs_engine, if_exists='append', index=False)

I have a Django monolith with models, views, and services all in one app. Propose a modular structure with bounded contexts. Provide folder structure and code examples.

project/
├── orders/
│   ├── models.py
│   ├── services.py
│   ├── views.py
│   └── urls.py
├── inventory/
│   ├── models.py
│   ├── services.py
│   ├── views.py
│   └── urls.py
├── users/
│   ├── models.py
│   ├── services.py
│   ├── views.py
│   └── urls.py
└── common/
    ├── base_models.py
    └── utils.py

# orders/services.py
from inventory.services import reserve_inventory

def place_order(order_data):
    reserve_inventory(order_data['product_id'], order_data['quantity'])
    # ... create order

Write a GitHub Actions workflow for a Python FastAPI project. Include linting, testing, building a Docker image, and deploying to AWS ECS.

name: CI/CD Pipeline

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.12'
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Lint
        run: flake8 .
      - name: Test
        run: pytest

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v2
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: us-east-1
      - name: Build and push Docker image
        run: |
          docker build -t myrepo/myapp:latest .
          docker push myrepo/myapp:latest
      - name: Deploy to ECS
        run: |
          aws ecs update-service --cluster my-cluster --service my-service --force-new-deployment