### Run Yii3 Web Application with Docker

Source: https://github.com/yiisoft/app/blob/master/README.md

Instructions for installing and running the Yii3 web application using Docker. This involves forking the repository, cloning it, updating dependencies with `make composer update`, and starting the application with `make up`. The application is then accessible via `https://localhost`.

```shell
cd myproject
make composer update
make up
```

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

### Install Yii3 Web Application with Composer

Source: https://github.com/yiisoft/app/blob/master/README.md

This snippet shows how to create a new Yii3 web application project using Composer. It involves running the `create-project` command and navigating into the project directory. The application can then be served using the provided command.

```shell
composer create-project yiisoft/app myproject
cd myproject
APP_ENV=dev ./yii serve
```

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

### Running Yii3 Application in Different Environments (Bash)

Source: https://context7.com/yiisoft/app/llms.txt

Provides bash commands to run the Yii3 application in various environments. Includes instructions for local development using the built-in server, production deployment, Docker setup, running tests with Codeception, and executing console commands. Environment variables like APP_ENV and APP_DEBUG are used to control application behavior.

```bash
# Local development with built-in server
export APP_ENV=dev
export APP_DEBUG=true
./yii serve

# Access at http://localhost:8080

# Production mode
export APP_ENV=prod
export APP_DEBUG=false
php public/index.php

# Docker environment
make composer update
make up
# Access at https://localhost

# Run tests
export APP_ENV=test
./vendor/bin/codecept build
./yii serve > ./runtime/yii.log 2>&1 &
./vendor/bin/codecept run
# Kill background server when done
kill $(cat runtime/yii.pid)

# Run console commands
./yii list
./yii hello
./yii user:create john john@example.com --admin

# Static analysis
./vendor/bin/psalm

# Code style fixing
./vendor/bin/php-cs-fixer fix
```

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

### Define Yii3 Application Routes

Source: https://context7.com/yiisoft/app/llms.txt

This snippet demonstrates how to define application routes using Yii3's router. It includes examples of simple GET routes, routes with parameters, POST routes, routes supporting multiple HTTP methods, and grouped routes with a prefix.

```php
<?php

declare(strict_types=1);

use App\Web;
use Yiisoft\Router\Group;
use Yiisoft\Router\Route;

return [
    Group::create()
        ->routes(
            // Simple GET route
            Route::get('/')
                ->action(Web\HomePage\Action::class)
                ->name('home'),

            // Route with parameters
            Route::get('/user/{id:\d+}')
                ->action(Web\User\ProfileAction::class)
                ->name('user/profile'),

            // POST route
            Route::post('/user/create')
                ->action(Web\User\CreateAction::class)
                ->name('user/create'),

            // Multiple HTTP methods
            Route::methods(['GET', 'POST'], '/contact')
                ->action(Web\Contact\FormAction::class)
                ->name('contact'),

            // Grouped routes with prefix
            Group::create('/api')
                ->routes(
                    Route::get('/users')
                        ->action(Web\Api\UsersAction::class)
                        ->name('api/users'),
                    Route::get('/posts')
                        ->action(Web\Api\PostsAction::class)
                        ->name('api/posts'),
                ),
        ),
];

```

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

### Handle Web Requests with Yii3 View Rendering

Source: https://context7.com/yiisoft/app/llms.txt

This snippet demonstrates creating web action handlers in Yii3 that respond to HTTP requests by rendering views. The `Action` class utilizes `Yiisoft\Yii\View\Renderer\ViewRenderer` to render templates. The first example shows rendering a template from the same directory. The second example, `ProfileAction`, shows how to access request attributes (like 'id') and pass data to the view.

```php
<?php

declare(strict_types=1);

namespace App\Web\HomePage;

use Psr\Http\Message\ResponseInterface;
use Yiisoft\Yii\View\Renderer\ViewRenderer;

final readonly class Action
{
    public function __construct(
        private ViewRenderer $viewRenderer,
    ) {}

    public function __invoke(): ResponseInterface
    {
        // Render template from same directory
        return $this->viewRenderer->render(__DIR__ . '/template');
    }
}

// With parameters example:
namespace App\Web\User;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Yiisoft\Yii\View\Renderer\ViewRenderer;

final readonly class ProfileAction
{
    public function __construct(
        private ViewRenderer $viewRenderer,
    ) {}

    public function __invoke(ServerRequestInterface $request): ResponseInterface
    {
        $userId = $request->getAttribute('id');

        // Pass data to view
        return $this->viewRenderer->render(__DIR__ . '/template', [
            'userId' => $userId,
            'username' => 'John Doe',
        ]);
    }
}

```

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

### Create Yii3 Application Parameters Value Object

Source: https://context7.com/yiisoft/app/llms.txt

This snippet defines a read-only value object for storing and accessing application-wide configuration parameters in a Yii3 application. It includes examples of how to use this object in dependency injection configuration and within views/actions.

```php
<?php

declare(strict_types=1);

namespace App\Shared;

final readonly class ApplicationParams
{
    public function __construct(
        public string $name = 'My Project',
        public string $charset = 'UTF-8',
        public string $locale = 'en',
    ) {}
}

// Usage in dependency injection configuration (config/common/di/application.php):
use App\Shared\ApplicationParams;

return [
    ApplicationParams::class => [
        '__construct()' => [
            'name' => $params['application']['name'],
            'charset' => $params['application']['charset'],
            'locale' => $params['application']['locale'],
        ],
    ],
];

// Usage in views and actions (auto-injected):
namespace App\Web\Settings;

use App\Shared\ApplicationParams;
use Psr\Http\Message\ResponseInterface;
use Yiisoft\Yii\View\Renderer\ViewRenderer;

final readonly class SettingsAction
{
    public function __construct(
        private ViewRenderer $viewRenderer,
        private ApplicationParams $params,
    ) {}

    public function __invoke(): ResponseInterface
    {
        // Access application parameters
        $appName = $this->params->name;
        $charset = $this->params->charset;

        return $this->viewRenderer->render(__DIR__ . '/template', [
            'appName' => $appName,
            'charset' => $charset,
        ]);
    }
}

```

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

### Build and Run Tests with Codeception

Source: https://github.com/yiisoft/app/blob/master/README.md

These commands demonstrate how to build the test suite and then run the tests for the Yii3 application using Codeception. It includes setting the environment variable and serving the application to a log file for testing purposes.

```shell
./vendor/bin/codecept build

APP_ENV=test ./yii serve > ./runtime/yii.log 2>&1 &
./vendor/bin/codecept run
```

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

### Build and Run Tests with Codeception (Docker)

Source: https://github.com/yiisoft/app/blob/master/README.md

Instructions for building and running Codeception tests when using Docker. This streamlines the testing process within a containerized environment.

```shell
make codecept build
make codecept run
```

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

### List Available Make Commands

Source: https://github.com/yiisoft/app/blob/master/README.md

This command lists all available `make` commands defined in the `Makefile`. This is useful for discovering various build, run, and utility tasks for the project.

```shell
make help
```

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

### Run Static Analysis with Psalm (Docker)

Source: https://github.com/yiisoft/app/blob/master/README.md

Command to run Psalm static analysis using Docker. This ensures that the analysis is performed in a consistent, isolated environment.

```shell
make psalm
```

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

### Run Static Analysis with Psalm

Source: https://github.com/yiisoft/app/blob/master/README.md

This snippet shows how to execute Psalm for static analysis of the Yii3 application code. It helps in identifying potential bugs and code quality issues before runtime.

```shell
./vendor/bin/psalm
```

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

### Console Application Bootstrap

Source: https://context7.com/yiisoft/app/llms.txt

Boots the console application, providing an entry point for command-line operations with environment configuration. It utilizes the `yiisoft/yii-runner-console` package.

```php
<?php

declare(strict_types=1);

use App\Environment;
use Yiisoft\Yii\Runner\Console\ConsoleApplicationRunner;

require_once __DIR__ . '/src/autoload.php';

// Run console application
$runner = new ConsoleApplicationRunner(
    rootPath: __DIR__,
    debug: Environment::appDebug(),
    checkEvents: Environment::appDebug(),
    environment: Environment::appEnv(),
);
$runner->run();

// Shell usage examples:
// List all commands: ./yii list
// Run specific command: ./yii hello
// Get help: ./yii help hello
// Start web server: APP_ENV=dev ./yii serve

```

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

### Configure Application Environment Settings with Yii3 Environment

Source: https://context7.com/yiisoft/app/llms.txt

This snippet demonstrates how to prepare and access application environment settings using the `App\Environment` class. It covers checking the current environment (dev, prod), debug mode, C3 mode, and retrieving host paths. Ensure `Environment::prepare()` is called before accessing any environment-related methods. Environment variables can be set via shell exports.

```php
<?php

use App\Environment;

// Initialize environment variables (must be called before accessing any environment methods)
Environment::prepare();

// Check current environment
if (Environment::isDev()) {
    // Development-specific logic
    error_reporting(E_ALL);
}

if (Environment::isProd()) {
    // Production-specific logic
    ini_set('display_errors', '0');
}

// Get environment value
$env = Environment::appEnv(); // Returns 'dev', 'test', or 'prod'

// Check debug mode
$debug = Environment::appDebug(); // Returns boolean

// Check if Codeception C3 mode is enabled
$c3Enabled = Environment::appC3(); // Returns boolean

// Get host path if configured
$hostPath = Environment::appHostPath(); // Returns string|null

// Example: Set environment via shell before running
// export APP_ENV=dev
// export APP_DEBUG=true
// export APP_C3=false
// php public/index.php

```

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

### HTTP Application Bootstrap

Source: https://context7.com/yiisoft/app/llms.txt

Boots the HTTP application, handling web requests with error management and environment configuration. It requires the `yiisoft/yii-runner-http` package and sets up logging via `yiisoft/log`.

```php
<?php

declare(strict_types=1);

use App\Environment;
use Psr\Log\LogLevel;
use Yiisoft\ErrorHandler\ErrorHandler;
use Yiisoft\ErrorHandler\Renderer\HtmlRenderer;
use Yiisoft\Log\Logger;
use Yiisoft\Log\Target\File\FileTarget;
use Yiisoft\Yii\Runner\Http\HttpApplicationRunner;

$root = dirname(__DIR__);

require_once $root . '/src/autoload.php';

// Enable Codeception coverage collection (if APP_C3=true)
if (Environment::appC3()) {
    $c3 = $root . '/c3.php';
    if (file_exists($c3)) {
        require_once $c3;
    }
}

// Run HTTP application
$runner = new HttpApplicationRunner(
    rootPath: $root,
    debug: Environment::appDebug(),
    checkEvents: Environment::appDebug(),
    environment: Environment::appEnv(),
    temporaryErrorHandler: new ErrorHandler(
        new Logger(
            [
                (new FileTarget($root . '/runtime/logs/app-container-building.log'))->setLevels([
                    LogLevel::EMERGENCY,
                    LogLevel::ERROR,
                    LogLevel::WARNING,
                ]),
            ],
        ),
        new HtmlRenderer(),
    ),
);
$runner->run();

// For custom middleware configuration:
// Create config/web/di/middleware.php
use Yiisoft\Middleware\Dispatcher\MiddlewareDispatcher;
use App\Web\Middleware\AuthMiddleware;
use App\Web\Middleware\LoggingMiddleware;

return [
    MiddlewareDispatcher::class => [
        '__construct()' => [
            'middlewares' => [
                LoggingMiddleware::class,
                AuthMiddleware::class,
            ],
        ],
    ],
];

```

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

### Create Custom Console Commands with Yii3 and Symfony Console

Source: https://context7.com/yiisoft/app/llms.txt

This code illustrates how to create custom console commands in Yii3 using Symfony Console components. It defines a command named 'user:create' with required arguments ('username', 'email') and an optional flag ('--admin'). The `execute` method handles the command logic, interacting with input and output interfaces. The command can be executed via the Yii console runner.

```php
<?php

declare(strict_types=1);

namespace App\Console;

use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Yiisoft\Yii\Console\ExitCode;

#[AsCommand(
    name: 'user:create',
    description: 'Creates a new user account',
)]
final class UserCreateCommand extends Command
{
    protected function configure(): void
    {
        $this
            ->addArgument('username', InputArgument::REQUIRED, 'Username')
            ->addArgument('email', InputArgument::REQUIRED, 'Email address')
            ->addOption('admin', 'a', InputOption::VALUE_NONE, 'Grant admin privileges');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $username = $input->getArgument('username');
        $email = $input->getArgument('email');
        $isAdmin = $input->getOption('admin');

        // Create user logic here
        $output->writeln(sprintf('Creating user: %s (%s)', $username, $email));

        if ($isAdmin) {
            $output->writeln('Granting admin privileges');
        }

        return ExitCode::OK;
    }
}

// Run command: ./yii user:create john john@example.com --admin

```

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

### View Template Rendering with Yiisoft WebView

Source: https://context7.com/yiisoft/app/llms.txt

Renders PHP view templates, supporting layouts, view injection, and HTML encoding using `yiisoft/view`. It allows for dynamic title setting, CSS/JS registration, and safe output of dynamic content.

```php
<?php

declare(strict_types=1);

use App\Shared\ApplicationParams;
use Yiisoft\View\WebView;
use Yiisoft\Html\Html;

/**
 * @var WebView $this
 * @var ApplicationParams $applicationParams
 * @var string $customData
 */

// Set page title
$this->setTitle('Page Title - ' . $applicationParams->name);

// Register inline CSS
$this->addCssString(
    '.custom-class {
        color: #333;
        font-size: 16px;
    }
');

// Register inline JavaScript
$this->addJsString(
    'console.log("Page loaded");',
    position: WebView::POSITION_END
);

?>

<div class="container">
    <h1><?= Html::encode($this->getTitle()) ?></h1>

    <!-- Safely output user data -->
    <p><?= Html::encode($customData) ?></p>

    <!-- Render HTML attributes -->
    <div <?= Html::renderTagAttributes([
        'class' => 'alert alert-info',
        'data-id' => 123,
    ]) ?>>
        Alert content
    </div>

    <!-- Generate links -->
    <a href="<?= $urlGenerator->generate('home') ?>">
        <?= Html::encode('Go Home') ?>
    </a>
</div>

<?php
// In action, pass data to template:
namespace App\Web\Example;

use Psr\Http\Message\ResponseInterface;
use Yiisoft\Yii\View\Renderer\ViewRenderer;

final readonly class ExampleAction
{
    public function __construct(
        private ViewRenderer $viewRenderer,
    ) {}

    public function __invoke(): ResponseInterface
    {
        return $this->viewRenderer->render(__DIR__ . '/template', [
            'customData' => 'User provided data <script>alert("xss")</script>',
            'items' => ['item1', 'item2', 'item3'],
        ]);
    }
}
?>

```

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

### PHP Dependency Injection Configuration for Yii3

Source: https://context7.com/yiisoft/app/llms.txt

Configures the dependency injection container using PHP arrays for service definitions and their dependencies. It showcases simple class definitions, constructor injection with references to other services (like LoggerInterface), factory definitions using closures, dynamic references for values that change over time, and alias definitions.

```php
<?php

declare(strict_types=1);

use Yiisoft\Definitions\Reference;
use Yiisoft\Definitions\DynamicReference;
use App\Service\UserService;
use App\Repository\UserRepository;
use Psr\Log\LoggerInterface;

return [
    // Simple class definition
    UserService::class => UserService::class,

    // Constructor injection
    UserRepository::class => [
        'class' => UserRepository::class,
        '__construct()' => [
            'tableName' => 'users',
            'logger' => Reference::to(LoggerInterface::class),
        ],
    ],

    // Factory definition
    'cache' => static fn() => new Cache(['driver' => 'redis']),

    // Dynamic reference (evaluated on each retrieval)
    'currentTime' => DynamicReference::to(
        static fn() => new DateTime()
    ),

    // Alias definition
    UserRepositoryInterface::class => Reference::to(UserRepository::class),
];

// Usage in services:
namespace App\Service;

use App\Repository\UserRepository;
use Psr\Log\LoggerInterface;

final readonly class UserService
{
    public function __construct(
        private UserRepository $repository,
        private LoggerInterface $logger,
    ) {}

    public function createUser(string $username, string $email): void
    {
        $this->logger->info('Creating user', ['username' => $username]);
        $this->repository->insert(['username' => $username, 'email' => $email]);
    }
}
```

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

### Implement Yii3 404 Not Found Handler

Source: https://context7.com/yiisoft/app/llms.txt

This snippet shows a custom request handler for 404 errors in a Yii3 application. It utilizes ViewRenderer for rendering a template and sets the appropriate HTTP status code. It also includes an alternative custom error handler for different status codes.

```php
<?php

declare(strict_types=1);

namespace App\Web\NotFound;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Http\Status;
use Yiisoft\Router\CurrentRoute;
use Yiisoft\Router\UrlGeneratorInterface;
use Yiisoft\Yii\View\Renderer\ViewRenderer;

final readonly class NotFoundHandler implements RequestHandlerInterface
{
    public function __construct(
        private UrlGeneratorInterface $urlGenerator,
        private CurrentRoute $currentRoute,
        private ViewRenderer $viewRenderer,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return $this->viewRenderer
            ->render(__DIR__ . '/template', [
                'urlGenerator' => $this->urlGenerator,
                'currentRoute' => $this->currentRoute,
            ])
            ->withStatus(Status::NOT_FOUND);
    }
}

// Alternative: Custom error handler for different status codes
namespace App\Web\Error;

final readonly class ErrorHandler implements RequestHandlerInterface
{
    public function __construct(
        private ViewRenderer $viewRenderer,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $exception = $request->getAttribute('exception');
        $statusCode = $exception->getCode() ?: Status::INTERNAL_SERVER_ERROR;

        return $this->viewRenderer
            ->render(__DIR__ . '/template', [
                'message' => $exception->getMessage(),
                'code' => $statusCode,
            ])
            ->withStatus($statusCode);
    }
}

```

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

### Stop Yii3 Web Application with Docker

Source: https://github.com/yiisoft/app/blob/master/README.md

Command to stop the Yii3 web application when it is running via Docker. This ensures that the application's services are cleanly shut down.

```shell
make down
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.