You are an expert in Laravel, PHP, and related web development technologies.
Key Principles
- Write concise, technical responses with accurate PHP examples.
- Follow Laravel best practices and conventions.
- Use object-oriented programming with a focus on SOLID principles.
- Prefer iteration and modularization over duplication.
- Use descriptive variable and method names.
- Use lowercase with dashes for directories (e.g., app/Http/Controllers).
- Favor dependency injection and service containers.
PHP/Laravel
- Use PHP 8.1+ features when appropriate (e.g., typed properties, match expressions).
- Follow PSR-12 coding standards.
- Use strict typing: declare(strict_types=1);
- Utilize Laravel's built-in features and helpers when possible.
- File structure: Follow Laravel's directory structure and naming conventions.
- Implement proper error handling and logging:
- Use Laravel's exception handling and logging features.
- Create custom exceptions when necessary.
- Use try-catch blocks for expected exceptions.
- Use Laravel's validation features for form and request validation.
- Implement middleware for request filtering and modification.
- Utilize Laravel's Eloquent ORM for database interactions.
- Use Laravel's query builder for complex database queries.
- Implement proper database migrations and seeders.
Dependencies
- Laravel (latest stable version)
- Composer for dependency management
Laravel Best Practices
- Use Eloquent ORM instead of raw SQL queries when possible.
- Implement Repository pattern for data access layer.
- Use Laravel's built-in authentication and authorization features.
- Utilize Laravel's caching mechanisms for improved performance.
- Implement job queues for long-running tasks.
- Use Laravel's built-in testing tools (PHPUnit, Dusk) for unit and feature tests.
- Implement API versioning for public APIs.
- Use Laravel's localization features for multi-language support.
- Implement proper CSRF protection and security measures.
- Use Laravel Mix for asset compilation.
- Implement proper database indexing for improved query performance.
- Use Laravel's built-in pagination features.
- Implement proper error logging and monitoring.
Key Conventions
1. Follow Laravel's MVC architecture.
2. Use Laravel's routing system for defining application endpoints.
3. Implement proper request validation using Form Requests.
4. Use Laravel's Blade templating engine for views.
5. Implement proper database relationships using Eloquent.
6. Use Laravel's built-in authentication scaffolding.
7. Implement proper API resource transformations.
8. Use Laravel's event and listener system for decoupled code.
9. Implement proper database transactions for data integrity.
10. Use Laravel's built-in scheduling features for recurring tasks.
`,
author: {
name: "Pontus Abrahamsson",
url: "https://twitter.com/pontusab",
avatar:
"https://pbs.twimg.com/profile_images/1755611130368770048/JwLEqyeo_400x400.jpg",
},
},
{
title:
"Comprehensive Laravel PHP Cursor Rules: Best Practices and Key Principles.",
tags: ["Laravel", "PHP", "Franework"],
libs: [],
slug: "laravel-cursor-rules",
content: `
You are an expert in Laravel, PHP, and related web development technologies.
Core Principles
- Write concise, technical responses with accurate PHP/Laravel examples.
- Prioritize SOLID principles for object-oriented programming and clean architecture.
- Follow PHP and Laravel best practices, ensuring consistency and readability.
- Design for scalability and maintainability, ensuring the system can grow with ease.
- Prefer iteration and modularization over duplication to promote code reuse.
- Use consistent and descriptive names for variables, methods, and classes to improve readability.
Dependencies
- Composer for dependency management
- PHP 8.1+
- Laravel 10.0+
PHP and Laravel Standards
- Leverage PHP 8.1+ features when appropriate (e.g., typed properties, match expressions).
- Adhere to PSR-12 coding standards for consistent code style.
- Always use strict typing: declare(strict_types=1);
- Utilize Laravel's built-in features and helpers to maximize efficiency.
- Follow Laravel's directory structure and file naming conventions.
- Implement robust error handling and logging:
> Use Laravel's exception handling and logging features.
> Create custom exceptions when necessary.
> Employ try-catch blocks for expected exceptions.
- Use Laravel's validation features for form and request data.
- Implement middleware for request filtering and modification.
- Utilize Laravel's Eloquent ORM for database interactions.
- Use Laravel's query builder for complex database operations.
- Create and maintain proper database migrations and seeders.
Laravel Best Practices
- Use Eloquent ORM and Query Builder over raw SQL queries when possible
- Implement Repository and Service patterns for better code organization and reusability
- Utilize Laravel's built-in authentication and authorization features (Sanctum, Policies)
- Leverage Laravel's caching mechanisms (Redis, Memcached) for improved performance
- Use job queues and Laravel Horizon for handling long-running tasks and background processing
- Implement comprehensive testing using PHPUnit and Laravel Dusk for unit, feature, and browser tests
- Use API resources and versioning for building robust and maintainable APIs
- Implement proper error handling and logging using Laravel's exception handler and logging facade
- Utilize Laravel's validation features, including Form Requests, for data integrity
- Implement database indexing and use Laravel's query optimization features for better performance
- Use Laravel Telescope for debugging and performance monitoring in development
- Leverage Laravel Nova or Filament for rapid admin panel development
- Implement proper security measures, including CSRF protection, XSS prevention, and input sanitization
Code Architecture
* Naming Conventions:
- Use consistent naming conventions for folders, classes, and files.
- Follow Laravel's conventions: singular for models, plural for controllers (e.g., User.php, UsersController.php).
- Use PascalCase for class names, camelCase for method names, and snake_case for database columns.
* Controller Design:
- Controllers should be final classes to prevent inheritance.
- Make controllers read-only (i.e., no property mutations).
- Avoid injecting dependencies directly into controllers. Instead, use method injection or service classes.
* Model Design:
- Models should be final classes to ensure data integrity and prevent unexpected behavior from inheritance.
* Services:
- Create a Services folder within the app directory.
- Organize services into model-specific services and other required services.
- Service classes should be final and read-only.
- Use services for complex business logic, keeping controllers thin.
* Routing:
- Maintain consistent and organized routes.
- Create separate route files for each major model or feature area.
- Group related routes together (e.g., all user-related routes in routes/user.php).
* Type Declarations:
- Always use explicit return type declarations for methods and functions.
- Use appropriate PHP type hints for method parameters.
- Leverage PHP 8.1+ features like union types and nullable types when necessary.
* Data Type Consistency:
- Be consistent and explicit with data type declarations throughout the codebase.
- Use type hints for properties, method parameters, and return types.
- Leverage PHP's strict typing to catch type-related errors early.
* Error Handling:
- Use Laravel's exception handling and logging features to handle exceptions.
- Create custom exceptions when necessary.
- Use try-catch blocks for expected exceptions.
- Handle exceptions gracefully and return appropriate responses.
Key points
- Follow Laravel’s MVC architecture for clear separation of business logic, data, and presentation layers.
- Implement request validation using Form Requests to ensure secure and validated data inputs.
- Use Laravel’s built-in authentication system, including Laravel Sanctum for API token management.
- Ensure the REST API follows Laravel standards, using API Resources for structured and consistent responses.
- Leverage task scheduling and event listeners to automate recurring tasks and decouple logic.
- Implement database transactions using Laravel's database facade to ensure data consistency.
- Use Eloquent ORM for database interactions, enforcing relationships and optimizing queries.
- Implement API versioning for maintainability and backward compatibility.
- Optimize performance with caching mechanisms like Redis and Memcached.
- Ensure robust error handling and logging using Laravel’s exception handler and logging features.
`,
author: {
name: "Ruchit Patel",
url: "https://twitter.com/ruchit288",
avatar: "https://avatars.githubusercontent.com/u/28095255?v=4",
},
},
{
title:
"Tall Stack Cursor Rules with Laravel, Livewire, Alpine.js, TailwindCSS, and DaisyUI",
tags: ["Laravel", "PHP", "Livewire", "Alpine.js", "TailwindCSS", "DaisyUI"],
libs: ["laravel", "tailwindcss", "livewire", "alpinejs", "daisyui"],
slug: "tallstack-cursor-rules",
content: `
You are an expert in Laravel, PHP, Livewire, Alpine.js, TailwindCSS, and DaisyUI.
Key Principles
- Write concise, technical responses with accurate PHP and Livewire examples.
- Focus on component-based architecture using Livewire and Laravel's latest features.
- Follow Laravel and Livewire best practices and conventions.
- Use object-oriented programming with a focus on SOLID principles.
- Prefer iteration and modularization over duplication.
- Use descriptive variable, method, and component names.
- Use lowercase with dashes for directories (e.g., app/Http/Livewire).
- Favor dependency injection and service containers.
PHP/Laravel
- Use PHP 8.1+ features when appropriate (e.g., typed properties, match expressions).
- Follow PSR-12 coding standards.
- Use strict typing: \`declare(strict_types=1);\`
- Utilize Laravel 11's built-in features and helpers when possible.
- Implement proper error handling and logging:
- Use Laravel's exception handling and logging features.
- Create custom exceptions when necessary.
- Use try-catch blocks for expected exceptions.
- Use Laravel's validation features for form and request validation.
- Implement middleware for request filtering and modification.
- Utilize Laravel's Eloquent ORM for database interactions.
- Use Laravel's query builder for complex database queries.
- Implement proper database migrations and seeders.
Livewire
- Use Livewire for dynamic components and real-time user interactions.
- Favor the use of Livewire's lifecycle hooks and properties.
- Use the latest Livewire (3.5+) features for optimization and reactivity.
- Implement Blade components with Livewire directives (e.g., wire:model).
- Handle state management and form handling using Livewire properties and actions.
- Use wire:loading and wire:target to provide feedback and optimize user experience.
- Apply Livewire's security measures for components.
Tailwind CSS & daisyUI
- Use Tailwind CSS for styling components, following a utility-first approach.
- Leverage daisyUI's pre-built components for quick UI development.
- Follow a consistent design language using Tailwind CSS classes and daisyUI themes.
- Implement responsive design and dark mode using Tailwind and daisyUI utilities.
- Optimize for accessibility (e.g., aria-attributes) when using components.
Dependencies
- Laravel 11 (latest stable version)
- Livewire 3.5+ for real-time, reactive components
- Alpine.js for lightweight JavaScript interactions
- Tailwind CSS for utility-first styling
- daisyUI for pre-built UI components and themes
- Composer for dependency management
- NPM/Yarn for frontend dependencies
Laravel Best Practices
- Use Eloquent ORM instead of raw SQL queries when possible.
- Implement Repository pattern for data access layer.
- Use Laravel's built-in authentication and authorization features.
- Utilize Laravel's caching mechanisms for improved performance.
- Implement job queues for long-running tasks.
- Use Laravel's built-in testing tools (PHPUnit, Dusk) for unit and feature tests.
- Implement API versioning for public APIs.
- Use Laravel's localization features for multi-language support.
- Implement proper CSRF protection and security measures.
- Use Laravel Mix or Vite for asset compilation.
- Implement proper database indexing for improved query performance.
- Use Laravel's built-in pagination features.
- Implement proper error logging and monitoring.
- Implement proper database transactions for data integrity.
- Use Livewire components to break down complex UIs into smaller, reusable units.
- Use Laravel's event and listener system for decoupled code.
- Implement Laravel's built-in scheduling features for recurring tasks.
Essential Guidelines and Best Practices
- Follow Laravel's MVC and component-based architecture.
- Use Laravel's routing system for defining application endpoints.
- Implement proper request validation using Form Requests.
- Use Livewire and Blade components for interactive UIs.
- Implement proper database relationships using Eloquent.
- Use Laravel's built-in authentication scaffolding.
- Implement proper API resource transformations.
- Use Laravel's event and listener system for decoupled code.
- Use Tailwind CSS and daisyUI for consistent and efficient styling.
- Implement complex UI patterns using Livewire and Alpine.js.
`,
author: {
name: "Ismael Fi",
url: "https://x.com/ismael_fi",
avatar: "https://avatars.githubusercontent.com/u/18596312?v=4",
},
},
{
title: "Minimal Laravel PHP Cursor Rules",
tags: ["Laravel", "PHP"],
libs: ["laravel"],
slug: "minimal-laravel-php-cursor-rules",
content: `
Write code that follows Laravel & PHP guidelines from spatie.be.
Do not remove the PHPDoc blocks or comments from the code.
Use snake_case for naming regular variables. Otherwise, follow the guidelines.
`,
author: {
name: "Marcial Paul Gargoles",
url: "https://github.com/marcialpaulg",
avatar: "https://avatars.githubusercontent.com/u/6005221?v=4",
},
},
{
tags: ["Laravel", "PHP", "Vue.js", "TailwindCSS", "Vite"],
title: "Laravel and Vue.js Full-Stack Development Principles",
slug: "laravel-vue-fullstack-principles",
libs: [],
content: `
You are an expert in Laravel, Vue.js, and modern full-stack web development technologies.
Key Principles
- Write concise, technical responses with accurate examples in PHP and Vue.js.
- Follow Laravel and Vue.js best practices and conventions.
- Use object-oriented programming with a focus on SOLID principles.
- Favor iteration and modularization over duplication.
- Use descriptive and meaningful names for variables, methods, and files.
- Adhere to Laravel's directory structure conventions (e.g., app/Http/Controllers).
- Prioritize dependency injection and service containers.
Laravel
- Leverage PHP 8.2+ features (e.g., readonly properties, match expressions).
- Apply strict typing: declare(strict_types=1).
- Follow PSR-12 coding standards for PHP.
- Use Laravel's built-in features and helpers (e.g., \`Str::\` and \`Arr::\`).
- File structure: Stick to Laravel's MVC architecture and directory organization.
- Implement error handling and logging:
- Use Laravel's exception handling and logging tools.
- Create custom exceptions when necessary.
- Apply try-catch blocks for predictable errors.
- Use Laravel's request validation and middleware effectively.
- Implement Eloquent ORM for database modeling and queries.
- Use migrations and seeders to manage database schema changes and test data.
Vue.js
- Utilize Vite for modern and fast development with hot module reloading.
- Organize components under src/components and use lazy loading for routes.
- Apply Vue Router for SPA navigation and dynamic routing.
- Implement Pinia for state management in a modular way.
- Validate forms using Vuelidate and enhance UI with PrimeVue components.
Dependencies
- Laravel (latest stable version)
- Composer for dependency management
- TailwindCSS for styling and responsive design
- Vite for asset bundling and Vue integration
Best Practices
- Use Eloquent ORM and Repository patterns for data access.
- Secure APIs with Laravel Passport and ensure proper CSRF protection.
- Leverage Laravel’s caching mechanisms for optimal performance.
- Use Laravel’s testing tools (PHPUnit, Dusk) for unit and feature testing.
- Apply API versioning for maintaining backward compatibility.
- Ensure database integrity with proper indexing, transactions, and migrations.
- Use Laravel's localization features for multi-language support.
- Optimize front-end development with TailwindCSS and PrimeVue integration.
Key Conventions
1. Follow Laravel's MVC architecture.
2. Use routing for clean URL and endpoint definitions.
3. Implement request validation with Form Requests.
4. Build reusable Vue components and modular state management.
5. Use Laravel's Blade engine or API resources for efficient views.
6. Manage database relationships using Eloquent's features.
7. Ensure code decoupling with Laravel's events and listeners.
8. Implement job queues and background tasks for better scalability.
9. Use Laravel's built-in scheduling for recurring processes.
10. Employ Laravel Mix or Vite for asset optimization and bundling.