Doppar

https://doppar.com/docs
Admin
Doppar is a high-performance PHP framework engineered for speed and efficiency, featuring a native...
Tokens:2,423
Snippets:25
Trust Score:5.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Implement Model Hooks in Doppar (PHP)

Source: https://doppar.com/docs/index

Provides an example of implementing Model Hooks in Doppar to execute custom logic during model lifecycle events like creation or updates. It includes a hook handler and a conditional execution example.

```php
<?php

use Doppar\Database\Models\Model;

class User extends Model
{
    protected $hooks = [
        'after_updated' => [
            'handler' => App\Hooks\UserUpdatedHook::class,
            'when' => [self::class, 'isAdmin']
        ],
    ];

    public static function isAdmin(Model $model): bool
    {
      return (int) $model->role === 'admin';
    }
}

class UserUpdatedHook
{
    public function handle(Model $model): void
    {
        if ($model->isDirtyAttr('name')) {
            info("Name changed from {$model->getOriginal('name')} to {$model->name}");
        }
    }
}

```

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

### Interact with Language Models using Doppar AI Agents (PHP)

Source: https://doppar.com/docs/index

Demonstrates how to use Doppar AI Agents to interact with language models, supporting both self-hosted and OpenAI deployments. Requires the Doppar AI library.

```php
<?php

// Self-Hosted
use Doppar\AI\Agent;
use Doppar\AI\AgentFactory\Agent\SelfHost;

$response = Agent::using(SelfHost::class)
    ->withHost('http://localhost:1234')
    ->model('local-model-name')
    ->prompt('Generate a PHP function to validate email')
    ->send();

// With OpenAI
use Doppar\AI\Agent;
use Doppar\AI\AgentFactory\Agent\OpenAI;

$response = Agent::using(OpenAI::class)
    ->withKey(env('OPENAI_API_KEY'))
    ->model('gpt-3.5-turbo')
    ->prompt('Explain Doppar PHP Framework')
    ->send();

```

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

### Define Routes with Doppar Routing Attributes (PHP)

Source: https://doppar.com/docs/index

Illustrates how to define routes in the Doppar framework using attributes for URIs, HTTP methods, naming, middleware, and rate limiting. Supports route-model binding.

```php
<?php

use Doppar\Http\Controllers\Controller;
use Doppar\Http\Routing\Attributes\Route;
use Doppar\Http\Routing\Attributes\Mapper;
use App\Models\User;

#[Mapper(prefix: 'user', middleware: ['auth'])]
class UserController extends Controller
{
    #[Route(
        uri: '/{user}',                   // Route URL; {user} is the route parameter
        methods: ['GET'],                 // Allowed HTTP method
        name: 'user',                     // Named route
        middleware: ['is_admin'],         // Middleware applied
        rateLimit: 10,                    // Max requests allowed
        rateLimitDecay: 1                 // Decay period in minutes
    )]
    public function show(#[Model] ?User $user)
    {
        // Example endpoint: http://example.com/user/aliba@doppar.com
        // `$user` is automatically resolved by email (route-model binding)

        return $user; // Returns the User model instance
    }
}

```

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

### Bind Services to Abstraction using Doppar Attributes (PHP)

Source: https://doppar.com/docs/index

Shows how Doppar allows dependency injection directly in method signatures using the `#[Bind]` attribute to specify concrete implementations for abstract types.

```php
<?php

use Doppar\Http\Controllers\Controller;
use Doppar\Http\Routing\Attributes\Route;
use Doppar\DependencyInjection\Attributes\Bind;
use App\Repositories\PostRepositoryInterface;
use App\Repositories\PostRepository;
use App\Services\AnotherAbstract;
use App\Services\AnotherConcrete;

class PostController extends Controller
{
    public function __construct(
        #[Bind(PostRepository::class)] readonly private PostRepositoryInterface $postRepository
    ) {}

    #[Route('/')]
    public function __invoke(
      #[Bind(AnotherConcrete::class)] AnotherAbstract $anotherRepository
    )
    {
      //
    }
}

```

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

### Define Queueable Jobs with Doppar (PHP)

Source: https://doppar.com/docs/index

Shows how to define queueable jobs in Doppar using the `#[Queueable]` attribute to configure job retries, retry delays, and queue assignment.

```php
<?php

use Doppar\Bus\Queueable;
use Doppar\Bus\Jobs\Job;

#[Queueable(tries: 3, retryAfter: 10, delayFor: 300, onQueue: 'email')]
class SendWelcomeEmailJob extends Job
{
    //
}

```

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

### Entity ORM Query Building and Data Retrieval

Source: https://doppar.com/docs/index

Illustrates the usage of Doppar's Entity ORM for building complex queries. It showcases features like scope application, selective field embedding, count embedding with conditions, and pagination, all with expressive syntax.

```php
public function __active(Builder $query): Builder
{
    return $query->whereStatus(true);
}

Post::active()
    ->present('comments.reply', function ($query) {
        $query->where('approved', true);
    })
    ->search(
        attributes: [
            'title',
            'user.name',
            'category.name',
            'tags.name',
            'comments.body',
            'comments.reply.body',
        ],
        searchTerm: $request->search
    )
    ->embed(
        relations: [
            'category:id,name',
            'user:id,name',
            'tags',
        ]
    )
    ->embedCount([
        'tags',
        'comments.reply' => fn($q) => $q->where('approved', true),
    ])
    ->paginate(perPage: 10);
```

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

### Parameter-Level Hydration with #[BindPayload]

Source: https://doppar.com/docs/index

Demonstrates how to use the #[BindPayload] attribute in PHP to automatically hydrate a model object from a request payload, reducing boilerplate code compared to traditional manual validation and data extraction.

```php
public function store(Request $request) {
    // 1. Validate the request data.
    // 2. Extract the data.
    // 3. Create a new User object and fill it manually.
    $user = new User();
    $user->name = $request->input('name');
    // ... many more lines of mapping
    $user->save();
}

// With #[BindPayload] Attribute
public function store(
    #[BindPayload] User $user // The $user object is fully ready!
) {
    return User::createFromModel($user);
}
```

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

### Automatic Transaction Wrapping with Doppar Attribute (PHP)

Source: https://doppar.com/docs/index

Demonstrates how to automatically wrap methods in a database transaction using the `#[Transaction]` attribute in Doppar, eliminating boilerplate code.

```php
<?php

use Doppar\Http\Controllers\Controller;
use Doppar\Http\Routing\Attributes\Route;
use Doppar\Database\Attributes\Transaction;

class PaymentController extends Controller
{
    #[Transaction]
    #[Route('payment', methods: ['POST'])]
    public function __invoke()
    {
      // Automatically wraps the __invoke method in a DB transaction
    }
}

```
Tokens:
Raw