Laravel Aspect

https://github.com/ytake/laravel-aspect
Admin
Laravel Aspect is an aspect-oriented programming package for the Laravel framework that enables...
Tokens:8,957
Snippets:74
Trust Score:9.8
License:MIT
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install Laravel-Aspect Package

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Installs the Laravel-Aspect package using Composer. This is the primary method for adding the package to your Laravel project.

```bash
composer require ytake/laravel-aspect
```

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

### Override AspectServiceProvider for Lumen

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

An example of overriding the default AspectServiceProvider in Lumen to customize the registration of the aspect manager. This allows for fine-grained control over aspect-oriented features.

```php
use Ytake\LaravelAspect\AspectManager;
use Ytake\LaravelAspect\AnnotationManager;
use Ytake\LaravelAspect\AspectServiceProvider as AspectProvider;

/**
 * Class AspectServiceProvider
 */
final class AspectServiceProvider extends AspectProvider
{
    /**
     * {@inheritdoc}
     */
    public function register()
    {
        $this->app->configure('ytake-laravel-aop');
        $this->app->singleton('aspect.manager', function ($app) {
            $annotationConfiguration = new AnnotationConfiguration(
                $app['config']->get('ytake-laravel-aop.annotation')
            );
            $annotationConfiguration->ignoredAnnotations();
            // register annotation
            return new AspectManager($app);
        });
    }
}
```

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

### Example Usage of @Cacheable Annotation

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

An example of using the @Cacheable annotation on a service method. This annotation, when used with a custom module, can enable caching for the method's execution.

```php
namespace YourApplication\Services;

use Ytake\LaravelAspect\Annotation\Cacheable;

class SampleService
{
    /**
     * @Cacheable(cacheName="testing1",key={"#id"})
     */
    public function action($id) 
    {
        return $this;
    }
}
```

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

### Append Custom Annotations in Laravel Aspect Configuration

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This PHP configuration example demonstrates how to append custom annotations to be recognized by the Ytake Laravel Aspect package. This allows developers to extend the aspect system with their own annotation classes. The configuration is located in `config/ytake-laravel-aspect.php`.

```php
    'annotation' => [
        'ignores' => [
            // global Ignored Annotations
            'Hears',
            'Get',
            'Post',
            'Put',
            'Patch',
            'Options',
            'Delete',
            'Any',
            'Middleware',
            'Resource',
            'Controller'
        ],
        'custom' => [
            \Acme\Annotations\Transactional::class
            // etc...
        ]
    ],

```

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

### Disable Aspects During Testing with 'none' Driver

Source: https://context7.com/ytake/laravel-aspect/llms.txt

Configuration to disable Laravel-Aspect during testing by setting the ASPECT_DRIVER environment variable to 'none' in the phpunit.xml file. Alternatively, this can be achieved programmatically within the test setup.

```xml
<!-- phpunit.xml -->
<phpunit>
    <php>
        <env name="ASPECT_DRIVER" value="none"/>
    </php>
</phpunit>

```

```php
// Alternative: Set in test setup
public function setUp(): void
{
    parent::setUp();
    config(['ytake-laravel-aop.aspect.default' => 'none']);
}

```

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

### Publish Laravel-Aspect Configuration

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Publishes the configuration files for Laravel-Aspect. This allows for customization of the package's behavior, including module registration.

```bash
php artisan vendor:publish --tag=aspect
```

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

### Lumen Integration for Laravel-Aspect

Source: https://context7.com/ytake/laravel-aspect/llms.txt

Demonstrates how to integrate Laravel-Aspect into the Lumen framework by creating a custom service provider. This involves configuring the aspect settings and registering the AspectManager with the Lumen application instance.

```php
<?php
// app/Providers/LumenAspectServiceProvider.php
namespace App\Providers;

use Ytake\LaravelAspect\AspectManager;
use Ytake\LaravelAspect\AnnotationConfiguration;
use Ytake\LaravelAspect\AspectServiceProvider as AspectProvider;

final class LumenAspectServiceProvider extends AspectProvider
{
    public function register(): void
    {
        $this->app->configure('ytake-laravel-aop');

        $this->app->singleton('aspect.manager', function ($app) {
            $annotationConfiguration = new AnnotationConfiguration(
                $app['config']->get('ytake-laravel-aop.annotation')
            );
            $annotationConfiguration->ignoredAnnotations();
            return new AspectManager($app);
        });
    }
}

```

```php
// bootstrap/app.php
$app->register(App\Providers\LumenAspectServiceProvider::class);

if ($app->runningInConsole()) {
    $app->register(Ytake\LaravelAspect\ConsoleServiceProvider::class);
}

```

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

### Artisan Commands for Aspect Management

Source: https://context7.com/ytake/laravel-aspect/llms.txt

This section details essential Artisan commands provided by Laravel-Aspect for managing aspect-related functionalities. These commands include publishing module classes, clearing cached aspects, and pre-compiling aspect classes for improved performance.

```bash
# Publish aspect module class to your application
php artisan ytake:aspect-module-publish

# Clear compiled aspect cache
php artisan ytake:aspect-clear-cache

# Pre-compile all aspect classes
php artisan ytake:aspect-compile

# View available options
php artisan ytake:aspect-module-publish --help

```

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

### PreCompile Laravel-Aspect Command

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Executes the Artisan command to pre-compile aspects in Laravel-Aspect. This can improve performance by preparing aspects before runtime.

```bash
php artisan ytake:aspect-compile
```

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

### Register Custom Aspect Module

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Demonstrates how to register a custom aspect module by extending the base module class and defining the target classes. This allows for custom aspect-oriented logic.

```php
namespace App\Modules;

use Ytake\LaravelAspect\Modules\CacheableModule as PackageCacheableModule;

/**
 * Class CacheableModule
 */
class CacheableModule extends PackageCacheableModule
{
    /** @var array */
    protected $classes = [
        \YourApplication\Services\SampleService::class
    ];
}
```

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

### Register Laravel-Aspect Service Providers (Older Laravel)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

For Laravel versions older than 5.5, manual registration of the service providers is required in the `config/app.php` file. Auto-discovery handles this for newer versions.

```php
// config/app.php
'providers' => [
    \Ytake\LaravelAspect\AspectServiceProvider::class,
    \Ytake\LaravelAspect\ConsoleServiceProvider::class,
]
```

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

### Register Custom AspectServiceProvider in Lumen Bootstrap

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Registers the custom AspectServiceProvider and the ConsoleServiceProvider in Lumen's bootstrap/app.php file. This ensures that the overridden service provider and console commands are loaded.

```php
$app->register(App\Providers\AspectServiceProvider::class);

if ($app->runningInConsole()) {
    $app->register(Ytake\LaravelAspect\ConsoleServiceProvider::class);
}
```

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

### Register Aspect Service Providers in Lumen

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Registers the AspectServiceProvider and ConsoleServiceProvider for Laravel-Aspect in a Lumen application's bootstrap file. This enables the package's functionality within the Lumen framework.

```php
$app->register(\App\Providers\LumenAspectServiceProvider::class);
$app->register(\Ytake\LaravelAspect\ConsoleServiceProvider::class);
```

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

### Configure Laravel-Aspect Settings

Source: https://context7.com/ytake/laravel-aspect/llms.txt

This configuration file (`config/ytake-laravel-aop.php`) allows you to define the AOP driver, compilation settings, cache options, and register custom aspect modules. You can specify which classes should have annotations processed.

```php
return [
    'aspect' => [
        // AOP driver: "ray" (Ray.Aop) or "none" (for testing)
        'default' => env('ASPECT_DRIVER', 'ray'),

        'drivers' => [
            'ray' => [
                'force_compile' => env('ASPECT_FORCE_COMPILE', false),
                'compile_dir' => storage_path('framework/aop/compile'),
                'cache' => env('ASPECT_CACHEABLE', false),
                'cache_dir' => storage_path('framework/aop/cache'),
            ],
            'none' => [
                // Testing driver - disables all aspects
            ]
        ],

        // Register your aspect modules here
        'modules' => [
            \App\Modules\CacheableModule::class,
            \App\Modules\TransactionalModule::class,
        ],
    ],

    'annotation' => [
        'ignores' => [
            'Hears', 'Get', 'Post', 'Put', 'Patch',
            'Options', 'Delete', 'Any', 'Middleware',
            'Resource', 'Controller'
        ],
        'custom' => [
            // Add custom annotation classes
        ],
    ],
];
```

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

### QueryLog Annotation for Database Query Logging in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

The QueryLog annotation facilitates logging of database queries executed by the application. It supports specifying custom log drivers and can log queries across multiple database connections, providing insights into database activity and performance.

```php
use Ytake\LaravelAspect\Annotation\QueryLog;
use Illuminate\Database\ConnectionResolverInterface;

/**
 * Class AspectQueryLog
 */
class AspectQueryLog
{
    /** @var ConnectionResolverInterface */
    protected $db;

    /**
     * @param ConnectionResolverInterface $db
     */
    public function __construct(ConnectionResolverInterface $db)
    {
        $this->db = $db;
    }

    /**
     * @QueryLog(driver="custom")
     */
    public function multipleDatabaseAppendRecord()
    {
        $this->db->connection()->statement('CREATE TABLE tests (test varchar(255) NOT NULL)');
        $this->db->connection('testing_second')->statement('CREATE TABLE tests (test varchar(255) NOT NULL)');
        $this->db->connection()->table("tests")->insert(['test' => 'testing']);
        $this->db->connection('testing_second')->table("tests")->insert(['test' => 'testing second']);
    }
}
```

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

### Use @Transactional Annotation for Database Transactions

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Demonstrates the use of the @Transactional annotation for managing database transactions with illuminate/database. It shows how to specify the database connection and handle expected exceptions.

```php
use Ytake\LaravelAspect\Annotation\Transactional;

/**
 * @Transactional("master")
 */
public function save(array $params)
{
    return $this->eloquent->save($params);
}
```

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

### Log Database Queries with @QueryLog Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @QueryLog annotation logs all database queries executed within a method, including execution time and connection details. It can be configured with different logging drivers and names for organization.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\QueryLog;
use Illuminate\Database\ConnectionResolverInterface;

class ReportService
{
    private ConnectionResolverInterface $db;

    public function __construct(ConnectionResolverInterface $db)
    {
        $this->db = $db;
    }

    /**
     * Log all queries in this method
     * Output: [INFO] QueryLog:ReportService.generateSalesReport {"queries":[{"query":"SELECT...","bindings":[],"time":1.23,"connectionName":"mysql"}]}
     * @QueryLog(driver="daily")
     */
    public function generateSalesReport(string $startDate, string $endDate): array
    {
        $orders = $this->db->connection()->table('orders')
            ->whereBetween('created_at', [$startDate, $endDate])
            ->get();

        $products = $this->db->connection()->table('products')
            ->whereIn('id', $orders->pluck('product_id'))
            ->get();

        return $this->formatReport($orders, $products);
    }

    /**
     * Log queries across multiple database connections
     * @QueryLog(name="MultiDBReport")
     */
    public function crossDatabaseReport(): array
    {
        $primaryData = $this->db->connection('mysql')->table('orders')->get();
        $analyticsData = $this->db->connection('analytics')->table('metrics')->get();
        return compact('primaryData', 'analyticsData');
    }
}

```

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

### CacheEvict Annotation for Removing Cache in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

The CacheEvict annotation is used to remove cached items. It allows specifying cache keys, names, drivers, and tags. The 'allEntries' option can be used to flush all cache entries associated with the specified tags.

```php
use Ytake\LaravelAspect\Annotation\CacheEvict;

/**
 * @CacheEvict(cacheName="testing",tags={"testing1"},allEntries=true)
 * @return null
 */
public function removeCache()
{
    return null;
}
```

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

### Create Cacheable Aspect Module

Source: https://context7.com/ytake/laravel-aspect/llms.txt

This PHP code defines a custom `CacheableModule` that extends the package's base module. It specifies which service classes (`ProductService`, `UserService`) should have their `@Cacheable` annotations processed.

```php
<?php
// app/Modules/CacheableModule.php
namespace App\Modules;

use Ytake\LaravelAspect\Modules\CacheableModule as PackageCacheableModule;

class CacheableModule extends PackageCacheableModule
{
    // Classes that will have @Cacheable annotations processed
    protected $classes = [
        \App\Services\ProductService::class,
        \App\Services\UserService::class,
    ];
}
```

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

### Publish Laravel-Aspect Module Class

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Publishes the aspect module class using an Artisan command. This command helps in setting up custom aspect modules within your application.

```bash
php artisan ytake:aspect-module-publish
```

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

### Register Aspect Service Providers in Laravel

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Registers the necessary service providers for Laravel-Aspect in your Laravel application's configuration. This enables the package's features and console commands.

```php
'providers' => [
    // added AspectServiceProvider 
    \Ytake\LaravelAspect\AspectServiceProvider::class,
    // added Artisan Command
    \Ytake\LaravelAspect\ConsoleServiceProvider::class,
]
```

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

### CachePut Annotation for Updating Cache in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This PHP snippet uses the CachePut annotation to update or add cache entries. It supports cache names, keys, drivers, lifetimes, and tags, allowing for dynamic cache management. It's useful for scenarios where cache needs to be refreshed with new data.

```php
use Ytake\LaravelAspect\Annotation\CachePut;

/**
 * @CachePut(cacheName={"testing1"},tags="testing1")
 */
public function throwExceptionCache()
{
    return 'testing';
}
```

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

### Clear Laravel-Aspect Cache Command

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

Executes the Artisan command to clear the cache for Laravel-Aspect. This is useful for ensuring that cached aspect configurations are up-to-date.

```bash
php artisan ytake:aspect-clear-cache
```

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

### Apply @Transactional Annotation for Database Transactions

Source: https://context7.com/ytake/laravel-aspect/llms.txt

This PHP code demonstrates the use of the `@Transactional` annotation within a service class. It shows how to automatically wrap method execution in database transactions, with options for single or multiple connections, and custom exception handling for rollbacks.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\Transactional;

class OrderService
{
    private $orderRepository;
    private $inventoryRepository;

    public function __construct($orderRepository, $inventoryRepository)
    {
        $this->orderRepository = $orderRepository;
        $this->inventoryRepository = $inventoryRepository;
    }

    /**
     * Single database connection transaction
     * @Transactional("mysql")
     */
    public function createOrder(array $orderData): Order
    {
        $order = $this->orderRepository->create($orderData);
        $this->inventoryRepository->decrementStock($orderData['product_id'], $orderData['quantity']);
        return $order;
    }

    /**
     * Multiple database connections transaction
     * @Transactional({"mysql", "pgsql"})
     */
    public function syncOrderAcrossDatabases(array $orderData): void
    {
        $this->orderRepository->create($orderData);          // mysql connection
        $this->analyticsRepository->logOrder($orderData);    // pgsql connection
    }

    /**
     * Custom exception handling - only rollback on specific exception
     * @Transactional(value="mysql", expect="App\Exceptions\PaymentFailedException")
     */
    public function processPayment(int $orderId, array $paymentData): bool
    {
        $order = $this->orderRepository->find($orderId);
        return $this->paymentGateway->charge($order, $paymentData);
    }
}
```

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

### Cacheable Annotation for Caching in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This PHP code utilizes the Cacheable annotation to cache method results. It supports custom cache keys, cache names, drivers, lifetimes, and tags for flexible caching strategies. The 'negative' option can be used to cache null values.

```php
use Ytake\LaravelAspect\Annotation\Cacheable;

/**
 * @Cacheable(cacheName="testing1",key={"#id","#value"})
 * @param $id
 * @param $value
 * @return mixed
 */
public function namedMultipleKey($id, $value)
{
    return $id;
}
```

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

### LogExceptions Annotation for Exception Logging in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This PHP code uses the LogExceptions annotation to log method exceptions. Similar to Loggable, it allows specifying log drivers and names. It is designed to capture and log errors that occur during method execution, aiding in debugging.

```php
use Ytake\LaravelAspect\Annotation\LogExceptions;

class AspectLoggable
{
    /**
     * @LogExceptions(driver="custom")
     * @param null $id
     * @return null
     */
    public function dispatchLogExceptions()
    {
        return $this->__toString();
    }
}
```

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

### Configure Ignored Annotations in Laravel Aspect

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This PHP configuration snippet shows how to define global ignored annotations within the Ytake Laravel Aspect package. These annotations will not be processed by the aspect system. The configuration is typically found in `config/ytake-laravel-aspect.php`.

```php
    'annotation' => [
        'ignores' => [
            // global Ignored Annotations
            'Hears',
            'Get',
            'Post',
            'Put',
            'Patch',
            'Options',
            'Delete',
            'Any',
            'Middleware',
            'Resource',
            'Controller'
        ],
    ],

```

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

### Set Aspect Driver to None for Testing

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This XML snippet configures the Ytake Laravel Aspect driver to 'none'. This is useful for testing environments where aspect functionality should be disabled. The setting is controlled by the `ASPECT_DRIVER` environment variable.

```xml
<env name="ASPECT_DRIVER" value="none"/>

```

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

### Message Queue Integration with @MessageDriven Annotation

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

The @MessageDriven annotation is used for integrating with Laravel's message queue and bus systems. It allows specifying queue connections, queue names, and whether to use lazy or eager queueing. LazyQueue and EagerQueue are supported options.

```php
use Ytake\LaravelAspect\Annotation\EagerQueue;
use Ytake\LaravelAspect\Annotation\LazyQueue;
use Ytake\LaravelAspect\Annotation\Loggable;
use Ytake\LaravelAspect\Annotation\MessageDriven;

/**
 * Class AspectMessageDriven
 */
class AspectMessageDriven
{
    /**
     * @Loggable
     * @MessageDriven(
     *     @LazyQueue(3),
     *     onQueue="message"
     * )
     * @return void
     */
    public function exec($param)
    {
        echo $param;
    }

    /**
     * @MessageDriven(
     *     @EagerQueue
     * )
     * @param string $message
     */
    public function eagerExec($message)
    {
        $this->logWith($message);
    }

    /**
     * @Loggable(name="Queued")
     * @param string $message
     *
     * @return string
     */
    public function logWith($message)
    {
        return "Hello $message";
    }
}

```

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

### Create Transactional Aspect Module

Source: https://context7.com/ytake/laravel-aspect/llms.txt

This PHP code defines a custom `TransactionalModule` that extends the package's base module. It specifies which service classes (`OrderService`, `PaymentService`) should have their `@Transactional` annotations processed.

```php
// app/Modules/TransactionalModule.php
namespace App\Modules;

use Ytake\LaravelAspect\Modules\TransactionalModule as PackageTransactionalModule;

class TransactionalModule extends PackageTransactionalModule
{
    protected $classes = [
        \App\Services\OrderService::class,
        \App\Services\PaymentService::class,
    ];
}
```

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

### Remove Cached Entries with @CacheEvict Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @CacheEvict annotation is used to remove cached entries when data changes. It supports removing single cache entries based on keys or tags, or flushing all entries within a cache using the `allEntries=true` option. It also allows specifying a cache driver.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\CacheEvict;
use Ytake\LaravelAspect\Annotation\Cacheable;

class ProductService
{
    /**
     * Remove specific cache entry when product is updated
     * @CacheEvict(cacheName="products", key={"#id"})
     */
    public function updateProduct(int $id, array $data): Product
    {
        return $this->productRepository->update($id, $data);
    }

    /**
     * Flush all entries with specific tags
     * @CacheEvict(cacheName="products", tags={"featured"}, allEntries=true)
     */
    public function refreshFeaturedProducts(): void
    {
        $this->productRepository->recalculateFeatured();
    }

    /**
     * Remove cache using specific driver
     * @CacheEvict(cacheName="products", key={"#id"}, driver="redis")
     */
    public function deleteProduct(int $id): bool
    {
        return $this->productRepository->delete($id);
    }
}

```

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

### Loggable Annotation for Method Logging in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

The Loggable annotation enables logging of method execution details, including arguments and results. It supports specifying log levels, custom log names, and drivers. The 'skipResult' option can prevent logging the method's return value.

```php
use Ytake\LaravelAspect\Annotation\Loggable;

class AspectLoggable
{
    /**
     * @Loggable(driver="stack")
     * @param null $id
     * @return null
     */
    public function normalLog($id = null)
    {
        return $id;
    }
}
```

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

### Update Cache with @CachePut Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @CachePut annotation ensures that a method is always executed, and its return value is used to update the cache, irrespective of whether a cache entry already exists. This is useful for forcing cache refreshes or ensuring the latest data is stored. It supports cache name, key, lifetime, and tags.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\CachePut;

class InventoryService
{
    /**
     * Update cache with new stock value after modification
     * @CachePut(cacheName="inventory", key={"#productId"}, lifetime=60)
     */
    public function updateStock(int $productId, int $quantity): int
    {
        $newStock = $this->inventoryRepository->setStock($productId, $quantity);
        return $newStock;
    }

    /**
     * Force cache refresh with tagged cache
     * @CachePut(cacheName="inventory_report", key={"#warehouseId"}, tags={"inventory", "reports"})
     */
    public function generateInventoryReport(int $warehouseId): array
    {
        return $this->inventoryRepository->generateReport($warehouseId);
    }
}

```

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

### Dispatch Method Execution to Laravel Queues with @MessageDriven Annotation

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @MessageDriven annotation dispatches method execution to Laravel's queue system. It supports eager (immediate) or lazy (delayed) processing, with options to specify queue names, connections, and combine with other annotations like @Loggable for auditing.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\MessageDriven;
use Ytake\LaravelAspect\Annotation\EagerQueue;
use Ytake\LaravelAspect\Annotation\LazyQueue;
use Ytake\LaravelAspect\Annotation\Loggable;

class NotificationService
{
    /**
     * Execute immediately via queue (EagerQueue)
     * @MessageDriven(@EagerQueue)
     */
    public function sendEmail(string $to, string $subject, string $body): void
    {
        $this->mailer->send($to, $subject, $body);
    }

    /**
     * Delay execution by 5 seconds (LazyQueue)
     * @MessageDriven(@LazyQueue(5))
     */
    public function sendDelayedNotification(int $userId, string $message): void
    {
        $this->pushNotificationService->send($userId, $message);
    }

    /**
     * Specify queue name and connection
     * @MessageDriven(
     *     @LazyQueue(10),
     *     onQueue="notifications",
     *     mappedName="redis"
     * )
     */
    public function sendBulkEmails(array $recipients, string $template): void
    {
        foreach ($recipients as $recipient) {
            $this->mailer->sendTemplate($recipient, $template);
        }
    }

    /**
     * Combine with @Loggable for auditing queued tasks
     * @Loggable(name="QueuedTask")
     * @MessageDriven(@EagerQueue, onQueue="reports")
     */
    public function generateMonthlyReport(int $month, int $year): void
    {
        $this->reportGenerator->generateMonthly($month, $year);
    }
}

```

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

### Log Method Calls with @Loggable Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @Loggable annotation automatically logs method calls, including arguments, return values, and execution time. It allows customization of the log level, log driver, and log name. It also provides an option to skip logging the return value for sensitive data.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\Loggable;
use Monolog\Level;

class PaymentService
{
    /**
     * Log method execution at INFO level (default)
     * Output: [INFO] Loggable:PaymentService.processPayment {"args":{"orderId":123,"amount":99.99},"result":true,"time":0.234}
     * @Loggable
     */
    public function processPayment(int $orderId, float $amount): bool
    {
        return $this->gateway->charge($orderId, $amount);
    }

    /**
     * Custom log level and driver
     * @Loggable(value=300, driver="daily", name="Payment")
     */
    public function refund(int $transactionId, float $amount): bool
    {
        return $this->gateway->refund($transactionId, $amount);
    }

    /**
     * Skip logging the return value (useful for sensitive data)
     * @Loggable(skipResult=true, name="SecurePayment")
     */
    public function processSecurePayment(int $orderId, array $cardDetails): bool
    {
        return $this->secureGateway->charge($orderId, $cardDetails);
    }

    /**
     * Using specific logging channel
     * @Loggable(driver="stack", name="PaymentAudit")
     */
    public function auditTransaction(int $transactionId): array
    {
        return $this->auditRepository->getTransactionDetails($transactionId);
    }
}

```

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

### Cache Method Return Values with @Cacheable Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @Cacheable annotation caches method return values. It allows configuration of cache name, key generation using method parameters, cache lifetime, and the use of specific cache drivers and tags for invalidation. It can also cache null values.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\Cacheable;

class ProductService
{
    private $productRepository;

    /**
     * Basic caching with method parameter as cache key
     * Cache key: "products:123" (where 123 is the $id value)
     * @Cacheable(cacheName="products", key={"#id"}, lifetime=60)
     */
    public function findProduct(int $id): ?Product
    {
        return $this->productRepository->find($id);
    }

    /**
     * Multiple parameters in cache key
     * Cache key: "product_search:electronics:100"
     * @Cacheable(cacheName="product_search", key={"#category", "#limit"})
     */
    public function searchByCategory(string $category, int $limit = 10): array
    {
        return $this->productRepository->findByCategory($category, $limit);
    }

    /**
     * Using specific cache driver and tags for cache invalidation
     * @Cacheable(
     *     cacheName="featured_products",
     *     key={"#storeId"},
     *     driver="redis",
     *     lifetime=120,
     *     tags={"products", "featured"}
     * )
     */
    public function getFeaturedProducts(int $storeId): array
    {
        return $this->productRepository->getFeatured($storeId);
    }

    /**
     * Cache null values (useful for "not found" scenarios)
     * @Cacheable(cacheName="products", key={"#sku"}, negative=true)
     */
    public function findBySku(string $sku): ?Product
    {
        return $this->productRepository->findBySku($sku);
    }
}

```

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

### Multiple Transactional Operations in PHP

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

This snippet demonstrates how to use the Transactional annotation to manage database transactions across multiple connections. It ensures that operations within the annotated method are executed within the specified transaction scopes.

```php
use Ytake\LaravelAspect\Annotation\Transactional;

/**
 * @Transactional({"master", "second_master"})
 */
public function save(array $params)
{
    $this->eloquent->save($params);
    $this->query->save($params);
}
```

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

### Log Exceptions with @LogExceptions Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @LogExceptions annotation allows methods to automatically log any exceptions they throw without altering the method's original behavior or exception propagation. It supports custom exception types and logging drivers.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\LogExceptions;

class ExternalApiService
{
    /**
     * Log exceptions at ERROR level (default)
     * @LogExceptions
     */
    public function fetchExternalData(string $endpoint): array
    {
        $response = $this->httpClient->get($endpoint);
        if ($response->failed()) {
            throw new \RuntimeException("API request failed: " . $response->status());
        }
        return $response->json();
    }

    /**
     * Custom exception type and logging driver
     * @LogExceptions(expect="App\Exceptions\ApiException", driver="slack", name="ApiError")
     */
    public function syncWithExternalService(array $data): void
    {
        $this->externalApi->sync($data);
    }
}

```

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

### Retry Method on Failure with @RetryOnFailure Annotation

Source: https://github.com/ytake/laravel-aspect/blob/main/README.md

The @RetryOnFailure annotation allows methods to be retried automatically in case of exceptions. It supports configuring the number of attempts, delay between retries, specific exception types to retry on, and exception types to ignore. Ensure RetryOnFailureModule is used.

```php
use Ytake\LaravelAspect\Annotation\RetryOnFailure;

class ExampleRetryOnFailure
{
    /** @var int */
    public $counter = 0;

    /**
     * @RetryOnFailure(
     *     types={
     *         LogicException::class,
     *     },
     *     attempts=3,
     *     ignore=Exception::class
     * )
     */
    public function ignoreException()
    {
        $this->counter += 1;
        throw new \Exception;
    }
}

```

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

### Retry Method on Failure with @RetryOnFailure Annotation (PHP)

Source: https://context7.com/ytake/laravel-aspect/llms.txt

The @RetryOnFailure annotation enables automatic retrying of method executions when specific exceptions occur. It allows configuration of the number of attempts, delay between retries, and specific exception types to catch or ignore.

```php
<?php
namespace App\Services;

use Ytake\LaravelAspect\Annotation\RetryOnFailure;

class ExternalApiService
{
    /**
     * Retry 3 times with 1 second delay on any exception
     * @RetryOnFailure(attempts=3, delay=1)
     */
    public function fetchData(string $url): array
    {
        $response = $this->httpClient->get($url);
        if (!$response->ok()) {
            throw new \RuntimeException("Request failed");
        }
        return $response->json();
    }

    /**
     * Retry only on specific exception types
     * @RetryOnFailure(
     *     attempts=5,
     *     delay=2,
     *     types={\GuzzleHttp\Exception\ConnectException::class, \GuzzleHttp\Exception\ServerException::class}
     * )
     */
    public function callExternalService(array $data): array
    {
        return $this->externalClient->post('/api/endpoint', $data);
    }

    /**
     * Retry but ignore certain exceptions (no retry for these)
     * @RetryOnFailure(
     *     attempts=3,
     *     delay=1,
     *     types={\Exception::class},
     *     ignore=\InvalidArgumentException::class
     * )
     */
    public function processWithValidation(array $data): bool
    {
        if (empty($data['required_field'])) {
            throw new \InvalidArgumentException("Missing required field");
        }
        return $this->processor->process($data);
    }
}

```
Tokens:
Raw