Laravel Prose

https://github.com/sulimanbenhalim/laravel-prose
Admin
Laravel Prose converts Laravel Eloquent queries into natural language descriptions, automatically...
Tokens:10,700
Snippets:76
Trust Score:6.8
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### PHP: Complex E-commerce Query Examples

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Provides advanced, real-world examples of building complex Eloquent queries for e-commerce scenarios. These examples showcase combining multiple `where` clauses, `with`, `orderBy`, `whereHas`, and date/time filtering for sophisticated data retrieval. Requires the Prose package for descriptive output.

```php
use App\Models\Product;
use App\Models\Customer;
use App\Models\Order;

// E-commerce: Premium customers analysis
$description = Customer::where('is_premium_member', true)
    ->where('last_login_at', '>', now()->subDays(7))
    ->whereNotNull('email_verified_at')
    ->with('subscriptions')
    ->orderBy('total_lifetime_spending_usd', 'desc')
    ->describe();
// → "Find customers that are premium member, with last login within the last 7 days and with verified email including their subscriptions sorted by total lifetime spending in USD (highest to lowest)"

// E-commerce: Out of stock products needing reorder
$description = Product::where('stock_quantity_available', '<=', 5)
    ->where('minimum_stock_threshold', '>', 10)
    ->where('is_currently_available', true)
    ->whereHas('category', function($query) {
        $query->where('is_featured_category', true);
    })
    ->describe();
// → "Find products with stock quantity available less than or equal to 5, minimum stock threshold greater than 10, that are currently available and who have product categories"

// E-commerce: High value orders with express shipping
$description = Order::where('total_amount_usd', '>', 500)
    ->where('express_shipping_requested', true)
    ->where('order_status', 'processing')
    ->whereDate('estimated_delivery_date', '<=', now()->addDays(2))
    ->describe();
// → "Find orders with total amount in USD greater than 500, with express shipping requested, order status is 'processing' and estimated delivery in the next 2 days"

// E-commerce: Gift orders with special requirements
$description = Order::where('is_gift_order', true)
    ->whereNotNull('special_instructions')
    ->where('payment_method', 'credit_card')
    ->whereHas('customer', function($query) {
        $query->where('is_premium_member', true);
    })
    ->with(['customer', 'orderItems.product'])
    ->describe();
// → "Find orders that are gift order, with special instructions, payment method is 'credit_card', who have customer and including their customer and order items product"
```

--------------------------------

### Install Laravel Prose

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

This snippet shows how to install the Laravel Prose package using Composer. It requires a PHP environment with Composer installed.

```bash
composer require sulimanbenhalim/laravel-prose
```

--------------------------------

### User Behavior Analysis Description

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

This PHP example showcases an Eloquent query for analyzing recently active premium users, generating a description with `describe()`. It filters customers by premium status, recent login activity, and verified email, includes their subscriptions, and orders by lifetime spending. The result is a descriptive sentence of the user behavior query.

```php
// Recently active premium users
Customer::where('is_premium_member', true)
    ->where('last_login_at', '>', now()->subDays(7))
    ->whereNotNull('email_verified_at')
    ->with('subscriptions')
    ->orderBy('total_lifetime_spending_usd', 'desc')
    ->describe();

// → "Find customers that are premium member, with last login within the last 7 days 
//    and with verified email including their subscriptions sorted by total lifetime 
//    spending in USD (highest to lowest)"
```

--------------------------------

### Accessing Prose Facade in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

This PHP snippet demonstrates how to access the Prose functionality directly through its facade. It requires importing the Prose facade class. The `describe` method is then called with an Eloquent builder instance to get the query description.

```php
use SulimanBenhalim\Prose\Facades\Prose;

Prose::describe($builder);              // Direct access
```

--------------------------------

### PHP: Use Prose Facade for Query Description

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Illustrates how to directly use the Prose facade (`Prose::describe()`) to generate descriptions for Eloquent query builders. This provides an alternative to calling the `describe()` method directly on the query builder instance. Requires the Prose facade to be set up and the package installed.

```php
use SulimanBenhalim\Prose\Facades\Prose;
use App\Models\User;

// Create a query builder
$builder = User::where('is_active', true)
    ->where('role', 'admin')
    ->orderBy('last_login_at', 'desc');

// Use facade directly
$description = Prose::describe($builder);
// → "Find users that are active and with role is 'admin' sorted by last login (most recent to oldest)"

// This is equivalent to:
$description = $builder->describe();
```

--------------------------------

### PHP: Perform Pattern Matching with whereLike

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Demonstrates how to use the `whereLike` method for pattern matching in string columns, including searching for values that start with, end with, or contain specific substrings. This is useful for flexible text-based searches. The Prose package is needed for the `describe()` method.

```php
use App\Models\Customer;
use App\Models\Product;

// Contains pattern
$description = Customer::where('email', 'like', '%@gmail.com')->describe();
// → "Find customers whose email ends with '@gmail.com'"

$description = Product::where('name', 'like', 'iPhone%')->describe();
// → "Find products whose name starts with 'iPhone'"

$description = Product::where('description', 'like', '%wireless%')->describe();
// → "Find products whose description contains 'wireless'"
```

--------------------------------

### Delete Operations: describeDelete() in PHP

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Shows how to use the describeDelete() method to generate descriptive strings for delete operations on Eloquent models. Examples include simple deletes, deletes with multiple conditions, deletes based on stock quantity, and deleting all records.

```php
use App\Models\Customer;
use App\Models\Product;
use App\Models\User;

// Simple delete
$description = Customer::where('status', 'banned')->describeDelete();
// → "Delete customers with status is 'banned'"

// Delete with multiple conditions
$description = User::where('last_login_at', '<', now()->subYears(2))
    ->whereNull('email_verified_at')
    ->describeDelete();
// → "Delete users with last login more than 2 years ago and with unverified email"

// Delete with stock condition
$description = Product::where('stock_quantity_available', 0)->describeDelete();
// → "Delete products with stock quantity available is 0"

// Delete all records (no conditions)
$description = Customer::query()->describeDelete();
// → "Delete all customers"
```

--------------------------------

### Eager Loading: with() Descriptions in PHP

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Demonstrates the use of the `with()` method for eager loading relationships in Laravel Eloquent models. This technique helps optimize queries by loading related data in a single query. Examples include loading single, multiple, and nested relationships.

```php
use App\Models\Order;
use App\Models\Customer;

// Single relationship
$description = Order::where('order_status', 'shipped')
    ->with('customer')
    ->describe();
// → "Find orders with order status is 'shipped' including their customer"

// Multiple relationships
$description = Order::where('order_status', 'shipped')
    ->with('customer', 'products')
    ->describe();
// → "Find orders with order status is 'shipped' including their customer and products"

// Nested relationships (automatic filtering)
$description = Order::with('customer', 'orderItems.product')->describe();
// → "Find orders including their customer and order items product"
```

--------------------------------

### PHP: Compare Column Values with whereColumn

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Illustrates how to compare the values of two columns or a column against an expression using `whereColumn`. This is useful for scenarios where you need to filter records based on the relationship between different fields. The Prose package must be installed to use the `describe()` method.

```php
use App\Models\Product;

// Basic column comparison
$description = Product::whereColumn('price_usd', '>', 'wholesale_cost_usd')
    ->describe();
// → "Find products where price in USD is greater than wholesale cost in USD"

// Expression with column comparison
$description = Product::whereColumn('price_usd', '>', 'wholesale_cost_usd * 2')
    ->where('stock_quantity_available', '>', 50)
    ->describe();
// → "Find products with stock quantity available greater than 50"
```

--------------------------------

### PHP: Search Across Multiple Columns with whereAny and whereAll

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Demonstrates searching across multiple columns using `whereAny` for OR conditions and `whereAll` for AND conditions. This method is useful for creating flexible search queries based on multiple fields. It requires the Eloquent model and the Prose package to be installed.

```php
use App\Models\Product;

// whereAny - search across multiple columns
$description = Product::whereAny(['name', 'description'], 'like', '%laptop%')
    ->describe();
// → "Find products whose either name or description contain 'laptop'"

// whereAll
$description = Product::whereAll(['is_featured', 'is_currently_available'], '=', true)
    ->describe();
// → "Find products that are featured and that are currently available"
```

--------------------------------

### Basic Query Translation in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Demonstrates basic Eloquent query translation to natural language using the `describe()` method. This requires the Laravel framework and the Laravel Prose package.

```php
User::where('created_at', '>', '2024-01-01')->describe();
// → "Find users created after January 1, 2024"

Product::where('is_featured', true)
    ->orderBy('price_usd', 'desc')
    ->limit(10)
    ->describe();
// → "Find first 10 products that are featured sorted by price in USD (highest to lowest)"
```

--------------------------------

### E-commerce Product Analysis Description

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

This PHP code demonstrates a complex Eloquent query for e-commerce product analysis, generating a natural language description using the `describe()` method. It filters products by featured status, stock availability, and review ratings, includes relationships, orders by sales count, and limits results. The output is a human-readable sentence describing the query.

```php
// Complex product analysis
Product::where('is_featured', true)
    ->where('stock_quantity_available', '>', 0) 
    ->whereHas('reviews', function($q) {
        $q->where('rating', '>=', 4);
    })
    ->with('category', 'reviews')
    ->orderBy('sales_count', 'desc')
    ->limit(20)
    ->describe();

// → "Find first 20 products that are featured, with stock quantity available 
//    greater than 0 and who have product reviews with rating greater than or equal to 4 
//    including their category and reviews sorted by sales count (highest to lowest)"
```

--------------------------------

### Statistical Aggregations: describeAvg(), describeMax(), describeMin() in PHP

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Demonstrates the use of describeAvg(), describeMax(), and describeMin() methods for calculating average, maximum, and minimum values of specified columns on Eloquent models. These methods are useful for quick statistical analysis directly from the database.

```php
use App\Models\Customer;
use App\Models\Product;

// Average
$description = Customer::where('is_premium_member', true)
    ->describeAvg('total_lifetime_spending_usd');
// → "Average total lifetime spending in USD for customers that are premium member"

// Maximum
$description = Product::where('is_currently_available', true)
    ->describeMax('price_usd');
// → "Maximum price in USD for products that are currently available"

// Minimum
$description = Product::where('stock_quantity_available', '>', 0)
    ->describeMin('wholesale_cost_usd');
// → "Minimum wholesale cost in USD for products with stock quantity available greater than 0"
```

--------------------------------

### Publish Configuration File

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

This command publishes the configuration file for the Prose package to your Laravel project. This allows you to customize settings like date humanization, maximum conditions, and text templates. No external dependencies are required, and it outputs the configuration file.

```bash
php artisan vendor:publish --tag=prose-config
```

--------------------------------

### Sum Aggregation Descriptions (describeSum)

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Use the `describeSum()` macro to generate a human-readable description for a sum aggregation query. It can include conditions and date ranges.

```php
use App\Models\Order;

// Sum with condition
$description = Order::where('order_status', 'completed')
    ->describeSum('total_amount_usd');
// → "Sum total amount in USD for orders with order status is 'completed'"

// Sum with date range
$description = Order::whereBetween('created_at', [now()->startOfMonth(), now()->endOfMonth()])
    ->describeSum('total_amount_usd');
// → "Sum total amount in USD for orders with created at ranging from December 1, 2025 to December 6, 2025"
```

--------------------------------

### Generate Natural Language from Eloquent Queries (describe)

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Use the `describe()` macro on an Eloquent query builder to generate a human-readable description of the query. It handles various conditions, ordering, and limits.

```php
use App\Models\User;

// Simple where clause
$description = User::where('created_at', '>', '2024-01-01')->describe();
// → "Find users created after January 1, 2024"

// Multiple conditions
$description = User::where('is_active', true)
    ->where('role', 'admin')
    ->where('last_login_at', '>', now()->subDays(30))
    ->describe();
// → "Find users that are active, with role is 'admin' and with last login within the last 30 days"

// With ordering and limit
$description = Product::where('is_featured', true)
    ->orderBy('price_usd', 'desc')
    ->limit(10)
    ->describe();
// → "Find first 10 products that are featured sorted by price in USD (highest to lowest)"

// Boolean field detection
$description = Product::where('has_warranty', false)
    ->where('stock_quantity_available', '>', 0)
    ->describe();
// → "Find products that don't have warranty and with stock quantity available greater than 0"

// Null checks with Laravel timestamps
$description = User::whereNull('email_verified_at')
    ->where('created_at', '<', now()->subMonths(6))
    ->describe();
// → "Find users with unverified email and created older than 6 months ago"
```

--------------------------------

### Currency and Units Intelligence in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Demonstrates how Laravel Prose understands currency and unit suffixes (e.g., `_usd`, `_gbp`) in column names to provide context in natural language descriptions, such as 'price in USD' or 'total lifetime spending in USD'. Requires Laravel Eloquent and Laravel Prose.

```php
Product::where('price_usd', '>', 100)->describe();
// → "Find products with price in USD greater than 100"

Customer::whereBetween('total_lifetime_spending_usd', [500, 5000])->describe();
// → "Find customers with total lifetime spending in USD ranging from 500 to 5000"
```

--------------------------------

### Count Query Descriptions (describeCount)

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Use the `describeCount()` macro to generate a human-readable description for a count query. It supports various conditions and date ranges.

```php
use App\Models\Order;

// Simple count
$description = Order::where('order_status', 'pending')->describeCount();
// → "Count orders with order status is 'pending'"

// Count with date conditions
$description = Order::where('created_at', '>', now()->subWeeks(2))->describeCount();
// → "Count orders created within the last 14 days"

// Count with multiple conditions
$description = Customer::where('is_premium_member', true)
    ->where('total_lifetime_spending_usd', '>', 1000)
    ->describeCount();
// → "Count customers that are premium member and with total lifetime spending in USD greater than 1000"
```

--------------------------------

### Action Descriptions for CRUD Operations in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Shows how to generate natural language descriptions for delete, update, sum, and average operations using methods like `describeDelete()`, `describeUpdate()`, `describeSum()`, and `describeAvg()`. These require Laravel Eloquent and Laravel Prose.

```php
Customer::where('status', 'banned')->describeDelete();
// → "Delete customers with status is 'banned'"

User::where('last_login_at', '<', now()->subYears(2))
    ->whereNull('email_verified_at')
    ->describeDelete();
// → "Delete users with last login more than 2 years ago and with unverified email"

Customer::where('email_verified_at', null)->describeUpdate(['email_verified_at' => now()]);
// → "Update customers with unverified email to be verified"

Product::where('stock_quantity_available', 0)
    ->where('is_currently_available', true)
    ->describeUpdate(['is_currently_available' => false]);
// → "Update products with stock quantity available is 0 and that are currently available to not be currently available"

Order::where('order_status', 'pending')
    ->where('created_at', '<', now()->subHours(24))
    ->describeUpdate(['order_status' => 'cancelled']);
// → "Update orders with order status is 'pending' and created before yesterday to have cancelled order status"

Product::where('stock_quantity_available', 0)->describeDelete();
// → "Delete products with stock quantity available is 0"

Order::where('order_status', 'completed')->describeSum('total_amount_usd');
// → "Sum total amount in USD for orders with order status is 'completed'"

Customer::where('is_premium_member', true)->describeAvg('total_lifetime_spending_usd');
// → "Average total lifetime spending in USD for customers that are premium member"
```

--------------------------------

### Laravel Prose Configuration File

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

The configuration file for Laravel Prose allows customization of sentence templates, actions, connectors, and other parameters. It defines how queries are translated into natural language.

```php
return [
    'sentence_template' => '{action} {model} {conditions} {relationships} {ordering} {limit}',

    'actions' => [
        'select' => 'Find',
        'count' => 'Count',
        'sum' => 'Sum',
        'avg' => 'Average',
        'max' => 'Maximum',
        'min' => 'Minimum',
        'update' => 'Update',
        'delete' => 'Delete',
    ],

    'connectors' => [
        'and' => 'and',
        'or' => 'or',
        'relationships' => 'including their',
        'ordering' => 'sorted by',
        'limit' => 'first',
        'offset' => 'starting from position',
    ],

    'max_conditions' => 12,
    'humanize_dates' => true,
    'enabled' => env('PROSE_ENABLED', true),
    'include_raw_fallback' => true,
    'raw_fallback_text' => 'with custom database operations',
];
```

--------------------------------

### Currency and Unit Detection in Laravel

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Details how Laravel Prose intelligently handles queries involving currency and unit fields, recognized by suffixes like `_usd`, `_kg`, or `_quantity`. It simplifies filtering based on monetary values or physical quantities. This relies on convention over configuration for field naming.

```php
use App\Models\Product;
use App\Models\Customer;

// Currency fields (suffix: _usd, _eur, _gbp, etc.)
$description = Product::where('price_usd', '>', 100)->describe();
// → "Find products with price in USD greater than 100"

$description = Customer::whereBetween('total_lifetime_spending_usd', [500, 5000])
    ->describe();
// → "Find customers with total lifetime spending in USD ranging from 500 to 5000"

// Weight and quantity fields
$description = Product::where('weight_kg', '>', 10)
    ->where('stock_quantity_available', '<', 50)
    ->describe();
// → "Find products with weight kg greater than 10 and with stock quantity available less than 50"
```

--------------------------------

### Eloquent Query Description Methods

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

These PHP methods, when called on an Eloquent query builder instance, generate a natural language description of the query. They cover various operations including basic descriptions, counts, sums, averages, maximums, minimums, updates, and deletes. These methods require an active Eloquent query builder instance as input.

```php
$builder->describe();                    // Basic description
$builder->describeCount();               // Count operation  
$builder->describeSum($column);          // Sum operation
$builder->describeAvg($column);          // Average operation
$builder->describeMax($column);          // Maximum operation
$builder->describeMin($column);          // Minimum operation
$builder->describeUpdate($values);       // Update operation
$builder->describeDelete();              // Delete operation
```

--------------------------------

### Relationship Intelligence in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Demonstrates how Laravel Prose handles relationships in queries, including eager loading with `with()` and checking for the absence of relationships with `whereDoesntHave()`. Requires Laravel Eloquent and Laravel Prose.

```php
Order::with('customer', 'products')->describe();
// → "Find orders including their customer and products"

Customer::whereDoesntHave('orders')->describe();  
// → "Find customers who don't have orders"

Order::where('order_status', 'shipped')
    ->with('customer', 'products')
    ->describe();
// → "Find orders with order status is 'shipped' including their customer and products"
```

--------------------------------

### Advanced Query Operations in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Illustrates advanced Eloquent query translations including Carbon operations, `describeCount()`, `whereHas()`, and multi-column searches with `whereAny()`. These functionalities depend on Laravel, Eloquent, Carbon, and the Laravel Prose package.

```php
// Carbon operations with natural language
Order::where('created_at', '>', now()->subWeeks(2))->describeCount();
// → "Count orders created within the last 14 days"

Customer::whereHas('orders', function($q) {
    $q->where('total_amount_usd', '>', 1000);
})->describe();
// → "Find customers who have orders with total amount in USD greater than 1000"

// Multi-column searches
Product::whereAny(['name', 'description'], 'like', '%laptop%')->describe();
// → "Find products whose either name or description contain 'laptop'"
```

--------------------------------

### Configuration: Disable Prose Globally via .env and config

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Shows how to disable the Laravel Prose package globally by setting the `PROSE_ENABLED` environment variable to `false` in the `.env` file and ensuring the configuration reflects this. When disabled, all `describe()` calls will return empty strings. This is useful for disabling descriptive query logging in production environments.

```dotenv
// In .env
PROSE_ENABLED=false
```

```php
// In config/prose.php
'enabled' => env('PROSE_ENABLED', true),

// All describe() calls will return empty strings when disabled
$description = User::where('is_active', true)->describe();
// → "" (empty string)
```

--------------------------------

### Carbon Date Operations in Laravel

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Shows how to perform date and time queries using Laravel's Carbon library. This includes relative dates (e.g., 'last 30 minutes', 'next 14 days'), specific dates ('today', 'yesterday'), and absolute date comparisons. It utilizes Eloquent's `where` clause with Carbon instances.

```php
use App\Models\User;
use App\Models\Order;

// Relative dates with now()
$description = User::where('created_at', '>', now()->subMinutes(30))->describe();
// → "Find users created within the last 30 minutes"

$description = Order::where('created_at', '>', now()->subDays(7))->describe();
// → "Find orders created within the last 7 days"

$description = Order::where('created_at', '>', now()->subWeeks(2))->describe();
// → "Find orders created within the last 14 days"

// Future dates
$description = Order::where('estimated_delivery_date', '<', now()->addDays(14))->describe();
// → "Find orders with estimated delivery in the next 14 days"

// Today, yesterday, tomorrow
$description = Order::whereDate('created_at', today())->describe();
// → "Find orders created today"

// Absolute dates
$description = User::where('created_at', '>', '2024-01-01')->describe();
// → "Find users created after January 1, 2024"
```

--------------------------------

### Laravel Timestamp Detection

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Covers how Laravel Prose handles common timestamp fields like `email_verified_at`, `created_at`, `updated_at`, and `deleted_at`. It simplifies queries for email verification status and record creation/modification times. This includes checks for null timestamps and comparisons against `now()`.

```php
use App\Models\Customer;
use App\Models\User; // Assuming User model is also relevant here

// email_verified_at handling
$description = Customer::where('email_verified_at', '>', now()->subDays(30))
    ->describe();
// → "Find customers who verified their email within the last 30 days"

$description = Customer::whereNull('email_verified_at')->describe();
// → "Find customers with unverified email"

$description = Customer::whereNotNull('email_verified_at')->describe();
// → "Find customers with verified email"

// created_at, updated_at, deleted_at
$description = Customer::where('created_at', '>', now()->subMonths(3))->describe();
// → "Find customers created within the last 3 months"

$description = User::where('last_login_at', '<', now()->subYears(1))->describe();
// → "Find users with last login more than 1 year ago"
```

--------------------------------

### Date Range Queries in Laravel

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Illustrates how to query for records within specific date ranges using `whereBetween`, `whereMonth`, `whereDay`, and `whereYear`. This is ideal for filtering data based on periods like months, days, or years. It leverages Eloquent's date-specific query builder methods.

```php
use App\Models\Customer;

// whereBetween with dates
$description = Customer::whereBetween('created_at', [
    now()->startOfMonth(),
    now()->endOfMonth()
])->describe();
// → "Find customers with created at ranging from December 1, 2025 to December 6, 2025"

// whereMonth, whereDay, whereYear
$description = Customer::whereMonth('date_of_birth', now()->addWeek()->month)
    ->whereDay('date_of_birth', '>=', now()->addWeek()->day)
    ->whereDay('date_of_birth', '<=', now()->addWeek()->addDays(7)->day)
    ->where('email_notifications_enabled', true)
    ->describe();
// → "Find customers with date of birth in August, with date of birth greater than or equal to 13, with date of birth less than or equal to 20 and with email notifications enabled"
```

--------------------------------

### Adjusting Condition Limits in Laravel Prose

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Allows setting a maximum number of conditions to be described in a query. The 'max_conditions' configuration option in config/prose.php, defaults to 12. Setting it to a lower value, like 5, truncates longer descriptions with an ellipsis, useful for brevity.

```php
// config/prose.php
'max_conditions' => 5,  // Default is 12

// If query has more than 5 conditions:
$description = Product::where('field1', 'value1')
    ->where('field2', 'value2')
    ->where('field3', 'value3')
    ->where('field4', 'value4')
    ->where('field5', 'value5')
    ->where('field6', 'value6')  // This exceeds the limit
    ->describe();
// → "Find products with field1 is 'value1', field2 is 'value2', field3 is 'value3', field4 is 'value4', field5 is 'value5' ..."
```

--------------------------------

### Boolean Field Detection in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Shows how Laravel Prose interprets boolean values in queries to generate natural language descriptions, such as 'is premium member' or 'don't have warranty'. Requires Laravel Eloquent and Laravel Prose.

```php
Customer::where('is_premium_member', true)->describe();
// → "Find customers that are premium member"

Product::where('has_warranty', false)->describe();  
// → "Find products that don't have warranty"
```

--------------------------------

### Update Operations: describeUpdate() in PHP

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Illustrates how to use the describeUpdate() method in Laravel Prose to generate descriptive strings for update operations on Eloquent models. It covers simple updates, updates with multiple conditions, and updates with date-based conditions.

```php
use App\Models\Customer;
use App\Models\Product;
use App\Models\Order;

// Simple update
$description = Customer::where('email_verified_at', null)
    ->describeUpdate(['email_verified_at' => now()]);
// → "Update customers with unverified email to be verified"

// Update with multiple conditions
$description = Product::where('stock_quantity_available', 0)
    ->where('is_currently_available', true)
    ->describeUpdate(['is_currently_available' => false]);
// → "Update products with stock quantity available is 0 and that are currently available to not be currently available"

// Update with date conditions
$description = Order::where('order_status', 'pending')
    ->where('created_at', '<', now()->subHours(24))
    ->describeUpdate(['order_status' => 'cancelled']);
// → "Update orders with order status is 'pending' and created before yesterday to have cancelled order status"
```

--------------------------------

### Customizing Action Words in Laravel Prose

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Allows customization of default action words used in query descriptions. Modify the 'actions' array in the config/prose.php file to change words like 'Find' to 'Retrieve'. This impacts how queries are described, e.g., 'Retrieve users that are active'.

```php
// config/prose.php
'actions' => [
    'select' => 'Retrieve',      // Instead of "Find"
    'count' => 'Total count of',  // Instead of "Count"
    'sum' => 'Calculate sum of',  // Instead of "Sum"
    'delete' => 'Remove',         // Instead of "Delete"
    'update' => 'Modify',         // Instead of "Update"
],

// Results in:
User::where('is_active', true)->describe();
// → "Retrieve users that are active"

User::where('is_active', true)->describeCount();
// → "Total count of users that are active"
```

--------------------------------

### Negative Relationship Conditions in Laravel

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Demonstrates how to query for records that do not have a specific relationship, including complex nested conditions. This is useful for finding records lacking certain associated data. It relies on Eloquent's `whereDoesntHave` method.

```php
use App\Models\Customer;

// No relationship exists
$description = Customer::whereDoesntHave('orders')->describe();
// → "Find customers who don't have orders"

// Complex negative relationship
$description = Customer::where('last_login_at', '<', now()->subMonths(6))
    ->where('total_lifetime_spending_usd', '>', 250)
    ->whereDoesntHave('orders', function($query) {
        $query->where('created_at', '>', now()->subMonths(3));
    })
    ->orderBy('total_lifetime_spending_usd', 'desc')
    ->describe();
// → "Find customers with last login more than 6 months ago, total lifetime spending in USD greater than 250 and who don't have orders sorted by total lifetime spending in USD (highest to lowest)"
```

--------------------------------

### Relationship Existence: whereHas() in PHP

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Explains how to use the `whereHas()` method to filter Eloquent models based on the existence of related records that meet specific conditions. It covers simple relationship checks, multiple relationship conditions, and nested `whereHas` calls.

```php
use App\Models\Customer;
use App\Models\Product;
use App\Models\Order;

// Has relationship with condition
$description = Customer::whereHas('orders', function($q) {
    $q->where('total_amount_usd', '>', 1000);
})->describe();
// → "Find customers who have orders with total amount in USD greater than 1000"

// Multiple relationship conditions
$description = Product::where('is_featured', true)
    ->where('stock_quantity_available', '>', 0)
    ->whereHas('reviews', function($q) {
        $q->where('rating', '>=', 4);
    })
    ->with('category', 'reviews')
    ->orderBy('sales_count', 'desc')
    ->limit(20)
    ->describe();
// → "Find first 20 products that are featured, with stock quantity available greater than 0 and who have product reviews with rating greater than or equal to 4 including their category and reviews sorted by sales count (highest to lowest)"

// Nested whereHas
$description = Order::where('order_status', 'cancelled')
    ->where('total_amount_usd', '>', 300)
    ->whereHas('orderItems', function($query) {
        $query->whereHas('product', function($productQuery) {
            $productQuery->where('is_currently_available', true);
        });
    })
    ->whereDate('created_at', '>=', now()->subDays(7))
    ->describe();
// → "Find orders with order status is 'cancelled', total amount in USD greater than 300, who have order items and created within the last 7 days"
```

--------------------------------

### PHP: Filter Records with whereIn and whereNotIn

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Shows how to filter records based on whether a column's value is within a given array (`whereIn`) or not within a given array (`whereNotIn`). These methods are efficient for checking against multiple possible values. Requires the Prose package for descriptive output.

```php
use App\Models\Order;

// whereIn
$description = Order::whereIn('order_status', ['pending', 'processing', 'shipped'])
    ->describe();
// → "Find orders with order status being one of: 'pending', 'processing', 'shipped'"

// whereNotIn
$description = Order::whereNotIn('payment_method', ['cash_on_delivery'])
    ->describe();
// → "Find orders with payment method not being any of: 'cash_on_delivery'"
```

--------------------------------

### Customizing Connectors in Laravel Prose

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Enables customization of connector words used to join conditions and relationships in query descriptions. Edit the 'connectors' array in config/prose.php to alter words like 'and' to 'AND' or 'with their' for relationships. This affects the readability of complex queries.

```php
// config/prose.php
'connectors' => [
    'and' => 'AND',
    'or' => 'OR',
    'relationships' => 'with their',
    'ordering' => 'ordered by',
],

// Results in:
Order::where('status', 'pending')->where('total', '>', 100)->with('customer')->describe();
// → "Find orders with status is 'pending' AND total greater than 100 with their customer"
```

--------------------------------

### Laravel Timestamps Intelligence in PHP

Source: https://github.com/sulimanbenhalim/laravel-prose/blob/main/README.md

Illustrates how Laravel Prose interprets date and time comparisons with Laravel timestamps (e.g., `created_at`, `updated_at`, `email_verified_at`) to generate descriptions like 'within the last 30 days' or 'with unverified email'. Requires Laravel Eloquent and Laravel Prose.

```php
Customer::where('email_verified_at', '>', now()->subDays(30))->describe();
// → "Find customers who verified their email within the last 30 days"

Customer::whereNull('email_verified_at')->describe();
// → "Find customers with unverified email"
```

--------------------------------

### Boolean Field Handling in Laravel

Source: https://context7.com/sulimanbenhalim/laravel-prose/llms.txt

Explains how to query boolean fields in Laravel Eloquent models. It covers filtering for `true` and `false` conditions, which is common for flags like 'is_premium_member' or 'is_currently_available'. This uses the standard `where` clause with boolean values.

```php
use App\Models\Customer;
use App\Models\Product;

// Boolean true conditions
$description = Customer::where('is_premium_member', true)->describe();
// → "Find customers that are premium member"

$description = Product::where('is_currently_available', true)
    ->where('has_warranty', true)
    ->describe();
// → "Find products that are currently available and that have warranty"

// Boolean false conditions
$description = Product::where('has_warranty', false)->describe();
// → "Find products that don't have warranty"

$description = Customer::where('email_notifications_enabled', false)->describe();
// → "Find customers with email notifications not enabled"
```
Tokens:
Raw