15 промтов для Cursor: AI-assisted разработка в IDE

Generate a TypeScript function that fetches data from an API endpoint. Use async/await, add input validation (URL format check), error handling with custom error classes, and return a typed response. Include JSDoc comments.

class FetchError extends Error {
  constructor(message: string, public statusCode: number) {
    super(message);
    this.name = 'FetchError';
  }
}

interface ApiResponse<T> {
  data: T;
  status: number;
}

async function fetchData<T>(url: string): Promise<ApiResponse<T>> {
  if (!/^https?:\/\//.test(url)) {
    throw new FetchError('Invalid URL format', 400);
  }
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new FetchError(`HTTP error ${response.status}`, response.status);
    }
    const data: T = await response.json();
    return { data, status: response.status };
  } catch (error) {
    throw new FetchError('Network error', 0);
  }
}

Refactor this code to reduce duplication. Extract repeated logic into helper functions. Use DRY principle. Keep the same behavior.

// Before
const activeUsers = users.filter(u => u.isActive).map(u => u.name);
const premiumUsers = users.filter(u => u.isPremium).map(u => u.name);

// After
function getNamesByCondition(users: User[], condition: (u: User) => boolean): string[] {
  return users.filter(condition).map(u => u.name);
}
const activeUsers = getNamesByCondition(users, u => u.isActive);
const premiumUsers = getNamesByCondition(users, u => u.isPremium);

Write unit tests for the selected function using Vitest. Cover happy path, edge cases (empty input, null values, invalid types), and error scenarios. Use describe/it blocks. Include mocks for external calls.

import { describe, it, expect, vi } from 'vitest';
import { fetchData } from './api';

describe('fetchData', () => {
  it('should return data on successful request', async () => {
    global.fetch = vi.fn().mockResolvedValue({
      ok: true,
      json: async () => ({ id: 1 }),
      status: 200,
    });
    const result = await fetchData<{ id: number }>('https://api.example.com');
    expect(result.data).toEqual({ id: 1 });
  });

  it('should throw FetchError on invalid URL', async () => {
    await expect(fetchData('invalid-url')).rejects.toThrow('Invalid URL format');
  });

  it('should throw FetchError on HTTP error', async () => {
    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
    await expect(fetchData('https://api.example.com')).rejects.toThrow('HTTP error 404');
  });
});

Analyze this code for performance bottlenecks. Suggest optimizations: reduce loop complexity, replace O(n^2) with O(n), use caching, avoid unnecessary re-renders (if React). Provide before/after comparison.

Create a React component that displays a paginated list of items. Use TypeScript, useState for current page, useEffect for fetching data, and render page buttons. Handle loading and error states.

Complete this configuration object for a Node.js Express server with middleware for CORS, body-parser, and rate limiting.

Convert this Vue 2 component (Options API) to Vue 3 Composition API. Use ref, reactive, computed, and onMounted. Keep the same template.

Generate a PostgreSQL query to find top 10 customers by total purchase amount in the last month. Assume tables: customers (id, name), orders (id, customer_id, amount, created_at). Use JOIN and aggregation.

SELECT c.name, SUM(o.amount) as total
FROM customers c
JOIN orders o ON c.id = o.customer_id
WHERE o.created_at >= NOW() - INTERVAL '1 month'
GROUP BY c.id
ORDER BY total DESC
LIMIT 10;

Write a README.md for this module. Include installation, usage examples, API reference, and a section for contributing. Use Markdown formatting.

Explain why this code throws an error. Suggest a fix. The error is: 'Cannot read properties of undefined (reading 'map')'

Transform this array of objects from camelCase to snake_case keys. Use recursion for nested objects.

Create a GitHub Actions workflow for a Node.js project. Steps: install dependencies, lint, run tests, build, deploy to Vercel. Use Node 20.

Simplify this conditional logic. Extract conditions into descriptive boolean variables. Add early returns.

Generate an array of 20 mock user objects with fields: id (uuid), name (random), email (valid format), age (18-80), isActive (boolean). Use faker.js if available, else hardcode.

Convert this JavaScript file to TypeScript. Add strict types for all variables and function parameters. Use interfaces for complex objects. Enable strict mode.