.cursorrules Laravel Senior Padrão

Template completo de .cursorrules para desenvolvimento Laravel Senior com padrões avançados, otimizado para Cursor AI.

crie um .cursorrules laravel senior padrão

Antes de usar este template, certifique-se de ter:

• Cursor AI (versão mais recente)
• Laravel instalado
• PHP configurado
• Composer para dependências

O arquivo .cursorrules será criado na raiz do projeto com:

projeto/
└── .cursorrules          # Arquivo principal de regras

1. Verificações:

• Verificação de estrutura Laravel existente
• Criação do arquivo .cursorrules na raiz
• Configuração de regras específicas do projeto

O sistema realizará automaticamente:

1. Configuração de regras:

• Padrões de código Laravel
• Regras de nomenclatura em inglês
• Estrutura de commits padronizada
• Verificações de consistência

2. Integração com ferramentas:

• PHPStan para análise estática
• Laravel Pint para formatação
• PHPUnit para testes
• Composer para dependências

1. Arquivo não reconhecido:

• Verificar se está na raiz do projeto

2. Regras não aplicadas:

• Verificar sintaxe do arquivo
• Confirmar permissões de leitura

3. Conflitos com outros .cursorrules:

• Remover arquivos duplicados
• Manter apenas um arquivo principal

# Laravel Senior Development Rules
# Version: 1.0.0
# Author: Cursor AI Assistant

# ===== REGRAS CRÍTICAS =====
rules:
  # 1. CÓDIGO EM INGLÊS OBRIGATÓRIO
  english_code:
    description: "TODO código deve ser escrito em inglês"
    classes: "UserController, OrderService, ProductRepository"
    methods: "createUser(), processOrder(), validateEmail()"
    variables: "$userData, $orderTotal, $productList"
    interfaces: "UserInterface, OrderRepositoryInterface"
    enums: "OrderStatus, PaymentMethod"
    migrations: "create_users_table, add_email_to_orders_table"

  # 2. PADRÕES DE COMMIT
  commit_patterns:
    backend: "🐘 Backend ✨ feat: Curta Descrição"
    frontend: "⚛️ Frontend ✨ feat: Curta Descrição"
    devops: "🐳 DevOps 🚀 deploy: Curta Descrição"
    docs: "📝 Docs ✨ feat: Curta Descrição"
    prefixes:
      - "📝 docs: Alterações em documentação"
      - "✨ feat: Novas funcionalidades"
      - "🐛 fix: Correções de bugs"
      - "♻️ refactor: Refatoração de código"
      - "🎨 style: Formatação e estilo"
      - "⚡ perf: Melhorias de performance"
      - "🔧 chore: Tarefas de manutenção"
      - "🔥 remove: Remoção de código/arquivos"
      - "🚀 deploy: Alterações de deploy"

# ===== ESTRUTURA DE ARQUIVOS =====
file_structure:
  backend:
    controllers: "app/Http/Controllers/Api/"
    models: "app/Models/"
    services: "app/Services/"
    repositories: "app/Repositories/"
    requests: "app/Http/Requests/"
    resources: "app/Http/Resources/"
    migrations: "database/migrations/"
    seeders: "database/seeders/"
    factories: "database/factories/"
    tests: "tests/"
  
  frontend:
    components: "src/components/"
    pages: "src/pages/"
    hooks: "src/hooks/"
    services: "src/services/"
    types: "src/types/"
    utils: "src/utils/"
    tests: "__tests__/"

# ===== PADRÕES DE CÓDIGO =====
code_patterns:
  laravel:
    controller: |
      class OrderController extends Controller
      {
          public function __construct(
              private OrderService $orderService
          ) {}
      
          public function store(StoreOrderRequest $request): JsonResponse
          {
              $order = $this->orderService->create($request->validated());
              return new OrderResource($order);
          }
      }
    
    service: |
      class OrderService
      {
          public function create(array $data): Order
          {
              DB::beginTransaction();
              try {
                  $order = Order::create($data);
                  event(new OrderCreated($order));
                  DB::commit();
                  return $order;
              } catch (Exception $e) {
                  DB::rollBack();
                  throw $e;
              }
          }
      }
    
    repository: |
      interface ProductRepositoryInterface
      {
          public function getPaginated(array $filters): LengthAwarePaginator;
          public function findById(int $id): ?Product;
          public function create(array $data): Product;
          public function update(Product $product, array $data): Product;
          public function delete(Product $product): bool;
      }

  react:
    component: |
      interface ProductCardProps {
        product: Product;
        onAddToCart: (product: Product) => void;
      }
      
      const ProductCard: React.FC<ProductCardProps> = memo(
        ({ product, onAddToCart }) => {
          const handleAddToCart = useCallback(() => {
            onAddToCart(product);
          }, [product, onAddToCart]);
      
          return (
            <Card>
              <Card.Header>{product.name}</Card.Header>
              <Card.Body>
                <Button onClick={handleAddToCart}>Add to Cart</Button>
              </Card.Body>
            </Card>
          );
        }
      );
    
    hook: |
      export const useProducts = (filters?: ProductFilters) => {
        return useQuery({
          queryKey: ['products', filters],
          queryFn: () => productService.getProducts(filters),
          staleTime: 5 * 60 * 1000,
        });
      };

# ===== VERIFICAÇÕES AUTOMÁTICAS =====
verification_commands:
  backend:
    - "find backend/app/Models -name '*.php' | head -10"
    - "find backend/app/Http/Controllers/Api -name '*.php' | head -10"
    - "grep -r 'Route::' backend/routes/api.php"
    - "php artisan route:list"
    - "php artisan migrate:status"
  
  frontend:
    - "find frontend/src/pages -name '*.tsx' | head -10"
    - "find frontend/src/components -name '*.tsx' | head -10"
    - "find frontend/src/hooks -name '*.ts' | head -10"
    - "find frontend/src/services -name '*.ts' | head -10"
    - "npm run type-check"
    - "npm run lint"

# ===== COMANDOS ÚTEIS =====
useful_commands:
  laravel:
    development:
      - "php artisan serve"
      - "php artisan migrate:fresh --seed"
      - "php artisan queue:work"
      - "php artisan tinker"
    testing:
      - "php artisan test"
      - "php artisan test --coverage"
      - "php artisan test --filter=UserTest"
    maintenance:
      - "php artisan optimize"
      - "php artisan config:cache"
      - "php artisan route:cache"
      - "php artisan view:cache"
  
  react:
    development:
      - "npm run dev"
      - "npm run build"
      - "npm run preview"
    testing:
      - "npm test"
      - "npm run test:watch"
      - "npm run test:coverage"
    validation:
      - "npm run type-check"
      - "npm run lint"
      - "npm run validate:quick"

# ===== CONFIGURAÇÕES DE AMBIENTE =====
environment:
  backend_env: |
    APP_NAME="Nome do Projeto"
    APP_ENV=local
    APP_KEY=base64:...
    APP_DEBUG=true
    APP_URL=http://localhost:8000
    
    DB_CONNECTION=mysql
    DB_HOST=127.0.0.1
    DB_PORT=3306
    DB_DATABASE=rei_do_oleo
    DB_USERNAME=root
    DB_PASSWORD=
    
    CACHE_DRIVER=redis
    SESSION_DRIVER=redis
    QUEUE_CONNECTION=redis
    
    REDIS_HOST=127.0.0.1
    REDIS_PASSWORD=null
    REDIS_PORT=6379
  
  frontend_env: |
    VITE_APP_NAME="Nome do Projeto"
    VITE_API_URL=http://localhost:8000/api
    VITE_APP_URL=http://localhost:3000
    VITE_APP_ENV=development

# ===== SEGURANÇA E BOAS PRÁTICAS =====
security:
  laravel:
    - "Usar Rate Limiting em rotas sensíveis"
    - "Validar todos os inputs com Form Requests"
    - "Usar Eloquent ORM para prevenir SQL Injection"
    - "Implementar autenticação com Laravel Sanctum"
    - "Usar HTTPS em produção"
    - "Configurar CORS adequadamente"
  
  react:
    - "Sanitizar HTML com DOMPurify"
    - "Validar inputs no frontend"
    - "Usar HTTPS para APIs"
    - "Implementar CSRF protection"
    - "Não expor chaves de API no frontend"

# ===== TESTES =====
testing:
  laravel:
    unit_tests: "tests/Unit/"
    feature_tests: "tests/Feature/"
    coverage_threshold: 80
    commands:
      - "php artisan test"
      - "php artisan test --coverage"
      - "php artisan test --testsuite=Unit"
      - "php artisan test --testsuite=Feature"
  
  react:
    test_files: "__tests__/"
    coverage_threshold: 80
    commands:
      - "npm test"
      - "npm run test:coverage"
      - "npm run test:watch"

# ===== PERFORMANCE =====
performance:
  backend:
    - "Usar Eager Loading para evitar N+1 queries"
    - "Implementar cache para queries pesadas"
    - "Usar Redis para session e cache"
    - "Otimizar queries com indexes"
    - "Usar Queue Jobs para operações pesadas"
  
  frontend:
    - "Implementar Code Splitting"
    - "Usar React.memo para componentes"
    - "Otimizar imagens com WebP"
    - "Implementar lazy loading"
    - "Usar Service Workers para cache"

# ===== MONITORAMENTO =====
monitoring:
  tools:
    - "Laravel Telescope para debugging"
    - "Sentry para error tracking"
    - "New Relic para performance"
    - "LogRocket para frontend sessions"
  
  logging:
    - "Usar diferentes níveis de log (info, warning, error)"
    - "Implementar structured logging"
    - "Configurar log rotation"
    - "Monitorar performance metrics"

# ===== DEVOPS =====
devops:
  docker:
    - "Usar multi-stage builds"
    - "Otimizar layers do Docker"
    - "Usar .dockerignore"
    - "Configurar health checks"
  
  ci_cd:
    - "Implementar GitHub Actions"
    - "Executar testes automaticamente"
    - "Fazer deploy automático"
    - "Implementar rollback automático"

# ===== DOCUMENTAÇÃO =====
documentation:
  api_docs: "Usar Laravel API Resources"
  code_comments: "Comentários apenas quando necessário e em inglês"
  readme: "Manter README atualizado"
  changelog: "Documentar mudanças importantes"
  architecture: "Documentar arquitetura do sistema"

# ===== CHECKLIST DE QUALIDADE =====
quality_checklist:
  code_review:
    - "Código segue padrões estabelecidos"
    - "Todo código escrito em inglês"
    - "Comentários evitados ou em inglês"
    - "Testes unitários incluídos"
    - "Documentação atualizada"
    - "Performance considerada"
    - "Segurança validada"
    - "Acessibilidade verificada"
    - "Responsividade testada"
  
  before_commit:
    - "Executar testes"
    - "Verificar linting"
    - "Validar tipos TypeScript"
    - "Fazer build de produção"
    - "Revisar alterações"
    - "Usar mensagem de commit padronizada"

# ===== COMANDOS DE VERIFICAÇÃO RÁPIDA =====
quick_verification:
  structure_check: |
    # Verificar estrutura do backend
    find backend/app/Models -name "*.php" | head -10
    find backend/app/Http/Controllers/Api -name "*.php" | head -10
    grep -r "Route::" backend/routes/api.php
    
    # Verificar estrutura do frontend
    find frontend/src/pages -name "*.tsx" | head -10
    find frontend/src/components -name "*.tsx" | head -10
    find frontend/src/hooks -name "*.ts" | head -10
    find frontend/src/services -name "*.ts" | head -10
  
  build_validation: |
    # Backend
    php artisan test
    php artisan route:cache
    php artisan config:cache
    
    # Frontend
    npm run type-check
    npm run lint
    npm run build
    npm run preview

# ===== RESUMO RÁPIDO =====
quick_summary:
  critical_rules:
    - "Verificação inteligente antes de desenvolver"
    - "Código em inglês obrigatório"
    - "Build validation antes de commits"
    - "Padrões de commit padronizados"
    - "TypeScript validation obrigatório"
  
  most_used_commands:
    backend: "php artisan serve, php artisan migrate:fresh --seed, php artisan test"
    frontend: "npm run dev, npm run build, npm run validate:quick"
    docker: "docker-compose up -d, docker-compose down"
  
  naming_conventions:
    classes: "UserController, OrderService"
    methods: "createUser(), processOrder()"
    variables: "$userData, $orderTotal"
    interfaces: "UserInterface, OrderRepositoryInterface"
  
  quick_checklist:
    - "Verificação inteligente (backend + frontend)"
    - "Código em inglês"
    - "Build funcionando"
    - "Testes passando"
    - "Linting limpo"
    - "Commit com prefixo correto"
    - "Documentação atualizada"

• [ ] Verificar se o Cursor AI está atualizado
• [ ] Confirmar estrutura do projeto Laravel
• [ ] Validar permissões de escrita na raiz
• [ ] Fazer backup do projeto atual

• [ ] Executar comando de criação
• [ ] Verificar se arquivo foi criado corretamente
• [ ] Testar regras com funcionalidade simples
• [ ] Validar comandos de verificação

• [ ] Reiniciar Cursor AI
• [ ] Testar criação de funcionalidade
• [ ] Verificar aplicação das regras
• [ ] Documentar customizações necessárias

• Mensal: Revisar regras de performance
• Trimestral: Atualizar padrões de código
• Anual: Revisar estrutura completa

• Adaptar regras para domínio específico
• Adicionar comandos específicos do projeto
• Incluir ferramentas adicionais
• Personalizar padrões de commit

• Laravel Documentation
• React Documentation
• Cursor AI Documentation

• PHPStan: Análise estática de código PHP
• Laravel Pint: Formatação automática de código
• PHPUnit: Framework de testes
• ESLint: Linting para JavaScript/TypeScript
• Prettier: Formatação de código frontend

• Laracasts
• Laravel News
• React Community

Após implementar o .cursorrules:

1. Testar funcionalidade básica com Cursor AI 2. Customizar regras para seu domínio específico 3. Adicionar ferramentas específicas do projeto 4. Treinar equipe nos novos padrões 5. Monitorar eficiência e ajustar conforme necessário

Para dúvidas ou problemas:

• Verificar seção de Troubleshooting
• Consultar documentação oficial
• Revisar logs do Cursor AI
• Fazer backup antes de alterações

—

📖 Este template foi criado seguindo as melhores práticas de desenvolvimento Laravel Senior e otimizado para máxima produtividade com Cursor AI.