Run HTTP

App handles the internet Hypertext Transfer Protocol in a very easy-to-use way.

Let's see an example creating a little application:

We will need to autoload classes, so we will set default configs for the Autoloader Service.

This app will respond to two origins. One is the web front end. Another is the REST API.

The default Router Service will load one file for each origin.

This is the public/index.php file:

use Framework\MVC\App;

(new App([
    'autoloader' => [
        'default' => [
            'namespaces' => [
                'Api' => __DIR__ . '/../api',
            ],
        ],
    ],
    'router' => [
        'default' => [
            'files' => [
                __DIR__ . '/../routes/front.php',
                __DIR__ . '/../routes/api.php',
            ],
        ],
    ],
]))->runHttp(); // void

And now, let's create the router files:

The routes/front.php file is for the front end. The origin will be https://domain.tld. Change if you want:

use Framework\MVC\App;
use Framework\Routing\RouteCollection;

App::router()->serve('https://domain.tld', function (RouteCollection $routes) {
    $routes->get('/', fn () => '<h1>Homepage</h1>');
}); // static

The routes/api.php is for the REST API. The origin will be https://api.domain.tld. Change if you need:

use Framework\MVC\App;
use Framework\Routing\RouteCollection;

App::router()->serve('https://api.domain.tld', function (RouteCollection $routes) {
    $routes->get('/', fn () => App::router()->getMatchedCollection());
    $routes->post('/users', 'Api\UsersController::create');
    $routes->get('/users/{int}', 'Api\UsersController::show/0', 'users.show');
}, 'api'); // static

This is the api/UsersController.php example:

namespace Api;

use Framework\HTTP\Response;
use Framework\HTTP\ResponseHeader;
use Framework\HTTP\Status;
use Framework\MVC\App;
use Framework\MVC\Controller;

class UsersController extends Controller
{
    public function create() : Response
    {
        $data = $this->request->getPost();
        $errors = $this->validate($data, [
            'name' => 'minLength:5|maxLength:64',
            'email' => 'email',
        ]);
        if ($errors) {
            return $this->response
                ->setStatus(Status::BAD_REQUEST)
                ->setJson([
                    'errors' => $errors,
                ]);
        }
        // TODO: Create the UsersModel to insert the new user
        // ...
        $user = [
            'id' => rand(1, 1000000),
            'name' => $data['name'],
            'email' => $data['email'],
        ];
        return $this->response
            ->setStatus(Status::CREATED)
            ->setHeader(
                ResponseHeader::LOCATION,
                App::router()->getNamedRoute('api.users.show')
                    ->getUrl(pathArgs: [$user['id']])
            )->setJson($user);
    }
}

After that, the application will have the following files:

• public/index.php
• routes/front.php
• routes/api.php
• api/UsersController.php

Put you server to run and access the URLs https://domain.tld and https://api.domain.tld.

You can make a POST request with curl to https://api.domain.tld/users:

curl -i -X POST https://api.domain.tld/users \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "name=John&[email protected]"

That's it. The basic HTTP application structure is created and working.

You can improve it with Models, Views and Controllers.

Run CLI

App handles Command-Line Interface with the Console Service.

Let's create the console.php file:

use Framework\MVC\App;

$app = new App();
$app::config()->set('console', [
    'directories' => [
        __DIR__ . '/commands',
    ]
]);
$app->runCli(); // void

Now, let's add a command in the commands/Meet.php file:

use Framework\CLI\CLI;
use Framework\CLI\Command;

class Meet extends Command
{
    public function run() : void
    {
        $name = CLI::prompt('What is your name?', 'Tadandan');
        CLI::write("Nice to meet you, $name. I'm Aplus.");
    }
}

Go to the terminal and run:

php console.php

The console will output meet as an available command.

To execute it, run:

php console.php meet

That's it.

Anti-CSRF Service

Gets an instance of Framework\HTTP\AntiCSRF.

App::antiCsrf()

[
    'antiCsrf' => [
        'default' => [
            'enabled' => true,
            'token_name' => 'csrf_token',
            'token_bytes_length' => 8,
            'generate_token_function' => 'base64_encode',
            'session_instance' => 'default',
            'request_instance' => 'default',
        ],
    ],
]

Autoloader Service

Gets an instance of Framework\Autoload\Autoloader.

App::autoloader()

[
    'autoloader' => [
        'default' => [
            'register' => true,
            'extensions' => '.php',
            'namespaces' => null,
            'classes' => null,
        ],
    ],
]

Cache Service

Gets an instance of Framework\Cache\Cache.

App::cache()

[
    'cache' => [
        'default' => [
            'class' => ???, // Must be set
            'configs' => [],
            'prefix' => null,
            'serializer' => Framework\Cache\Serializer::PHP,
            'default_ttl' => null,
            'logger_instance' => 'default',
        ],
    ],
]

Console Service

Gets an instance of Framework\CLI\Console.

App::console()

[
    'console' => [
        'default' => [
            'directories' => null,
            'find_in_namespaces' => false,
            'language_instance' => 'default',
            'locator_instance' => 'default',
        ],
    ],
]

Database Service

Gets an instance of Framework\Database\Database.

App::database()

[
    'database' => [
        'default' => [
            'config' => ???, // Must be set
            'logger_instance' => 'default',
        ],
    ],
]

Debugger Service

Gets an instance of Framework\Debug\Debugger.

App::debugger()

[
    'debugger' => [
        'default' => [
            'debugbar_view' => null,
            'options' => null,
        ],
    ],
]

Exception Handler Service

Gets an instance of Framework\Debug\ExceptionHandler.

App::exceptionHandler()

[
    'exceptionHandler' => [
        'default' => [
            'environment' => Framework\Debug\ExceptionHandler::PRODUCTION,
            'logger_instance' => 'default',
            'language_instance' => 'default',
            'development_view' => null,
            'production_view' => null,
            'initialize' => true,
            'search_engine' => 'google',
            'handle_errors' => true,
        ],
    ],
]

Language Service

Gets an instance of Framework\Language\Language.

App::language()

[
    'language' => [
        'default' => [
            'default' => 'en',
            'current' => 'en',
            'supported' => null,
            'negotiate' => false,
            'request_instance' => 'default',
            'fallback_level' => Framework\Language\FallbackLevel::none,
            'directories' => [],
            'find_in_namespaces' => false,
            'autoloader_instance' => 'default',
        ],
    ],
]

Locator Service

Gets an instance of Framework\Autoload\Locator.

App::locator()

[
    'locator' => [
        'default' => [
            'autoloader_instance' => 'default',
        ],
    ],
]

Logger Service

Gets an instance of Framework\Log\Logger.

App::logger()

[
    'logger' => [
        'default' => [
            'class' => Framework\Log\Logger\MultiFileLogger::class,
            'destination' => ???, // Must be set
            'level' => Framework\Log\LogLevel::DEBUG,
            'config' => [],
        ],
    ],
]

Mailer Service

Gets an instance of Framework\Email\Mailer.

App::mailer()

[
    'mailer' => [
        'default' => [
            'host' => 'localhost',
            'port' => 587,
            'tls' => true,
            'username' => null,
            'password' => null,
            'charset' => 'utf-8',
            'crlf' => "\r\n",
            'keep_alive' => false,
        ],
    ],
]

Migrator Config Options

[
    'migrator' => [
        'default' => [
            'database_instance' => 'default',
            'directories' => ???, // Must be set
            'table' => 'Migrations',
        ],
    ],
]

Request Config Options

[
    'request' => [
        'default' => [
            'server_vars' => [],
            'allowed_hosts' => [],
            'force_https' => false,
            'json_flags' => null,
        ],
    ],
]

Response Config Options

[
    'response' => [
        'default' => [
            'headers' => [],
            'auto_etag' => false,
            'auto_language' => false,
            'language_instance' => 'default',
            'cache' => null,
            'csp' => [],
            'csp_report_only' => [],
            'json_flags' => null,
            'request_instance' => 'default',
        ],
    ],
]

Router Config Options

[
    'router' => [
        'default' => [
            'files' => [],
            'placeholders' => [],
            'auto_options' => null,
            'auto_methods' => null,
            'response_instance' => 'default',
            'language_instance' => 'default',
        ],
    ],
]

Session Config Options

[
    'session' => [
        'default' => [
            'save_handler' => [
                'class' => null,
                'config' => [],
            ],
            'options' => [],
            'auto_start' => null,
            'logger_instance' => 'default',
        ],
    ],
]

Validation Config Options

[
    'validation' => [
        'default' => [
            'validators' => [
                Framework\MVC\Validator::class,
                Framework\Validation\FilesValidator::class,
            ],
            'language_instance' => 'default',
        ],
    ],
]

View Config Options

[
    'view' => [
        'default' => [
            'base_dir' => ???, // Must be set
            'extension' => '.php',
            'layout_prefix' => null,
            'include_prefix' => null,
            'show_debug_comments' => true,
        ],
    ],
]

Create

The create method inserts a new row and returns the LAST_INSERT_ID() on success or false if validation fails:

$data = [
    'name' => 'John Doe',
    'email' => '[email protected]',
];
$id = $model->create($data); // Insert ID or false

If it returns false, it is possible to get the errors through the getErrors method:

if ($id === false) {
    $errors = $model->getErrors();
}

Read

The read method reads a row based on the Primary Key and returns the row with the type set in the $returnType property or null if the row is not found.

$id = 1;
$row = $model->read($id);

It is also possible to read all rows, with limit and offset, by returning an array with items in the $returnType.

$limit = 10;
$offset = 20;
$rows = $model->list($limit, $offset); // array

Update

The update method updates based on the Primary Key and returns the number of rows affected or false if validation fails.

$id = 1;
$data = [
    'name' => 'Johnny Doe',
];
$affectedRows = $model->update($id, $data); // int, string or false

Delete

The delete method deletes based on the Primary Key and returns the number of affected rows:

$id = 1;
$affectedRows = $model->delete($id); // int, string or false

Extra

The Model has some extra methods for doing common operations:

$count = $model->count(); // int

$where = [
    ['id', '<', 100], // WHERE `id` < 100
    ['name', 'like', 'Pa%'], // AND `name` LIKE 'Pa%'
];
$count = $model->count($where); // int

$id = 1;
$data = [
    'name' => 'John Morgan',
    'email' => '[email protected]',
];
$affectedRows = $model->replace($id, $data); // int, string or false

$data = [
    'id' => 1,
    'email' => '[email protected]',
];
$result = $model->save($data); // int, string or false

Populate

The array keys will be set as the property name with their respective values in the populate method.

If a setter method exists for the property, it will be called. For example, if there is a setId method, it will be called to set the id property. If the setId method does not exist, it will try to set the property, if it exists, otherwise it will throw an exception saying that the property is not defined. If set, it will attempt to set the value to the property's type, casting type with the Type Hints methods.

Init

The init method is used to initialize settings, set custom properties, etc. Called in the constructor just after the properties are populated.

protected URL $url;
protected string $name;

protected function init() : void
{
    $this->name = $this->firstname . ' ' . $this->lastname;
    $this->url = new URL('https://domain.tld/users/' . $this->id);        
}

Magic Isset and Unset

To check if a property is set:

$isSet = isset($user->id); // bool

To remove a property:

unset($user->id);

Magic Getters

Properties can be called directly. But first, it is always checked if there is a getter for it and if there is, it will be used:

$id = $user->id; // 1
$id = $user->getId(); // 1

Magic Setters

Properties can be set directly. But before that, it is always checked if there is a setter for it and if there is, the value will be set through it:

$user->id = 3;
$user->setId(3);

To Model

Through the toModel method, the object is transformed into an associative array ready to be written to the database.

Conversion to array can be done directly, as below:

$data = $user->toModel(); // Associative array

Or passed directly to one of a model's methods.

Let's see how to create a row using the variable $user, which is an entity:

$id = $model->create($user); // Insert ID or false

use Framework\Date\Date;
use Framework\MVC\Entity;

class User extends Entity
{
    public string $_timezone = '+00:00'; // Default value
    protected Date $createdAt;
}

date_default_timezone_set('America/Sao_Paulo');

$user = new User([
    'createdAt' => '2024-08-02 10:30:00',
]);

echo $user->createdAt->format('Y-m-d H:i:s'); // '2024-08-02 10:30:00'

$data = $user->toModel();
echo $data['createdAt']; // '2024-08-02 13:30:00'

$user->_timezone = '+05:00';
$data = $user->toModel();
echo $data['createdAt']; // '2024-08-02 18:30:00'

JSON Vars

When working with APIs, it may be necessary to convert an Entity to a JSON object.

To set which properties will be JSON-encoded just list them in the property $_jsonVars:

use Framework\Date\Date;
use Framework\HTTP\URL;
use Framework\MVC\Entity;

class User extends Entity
{
    public array $_jsonVars = [
        'id',
        'name',
        'url',
        'createdAt',
        'updatedAt',
        'bio',
    ];
    protected int $id;
    protected string $name;
    protected ?string $bio = null;
    protected string $email;
    protected string $passwordHash;
    protected URL $url;
    protected Date $createdAt;
    protected Date $updatedAt;
}

$user = new User([
    'id' => 1,
    'name' => 'John Doe',
    'url' => 'https://domain.tld/users/1',
    'createdAt' => 'now',
]);

Or set whenever you want:

$user->_jsonVars = [
    'id',
    'name',
    'url',
    'createdAt',
    'updatedAt',
    'bio',
];

Once this is done, the entity can be encoded. Let's see in the following example:

echo json_encode($user, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);

And then the JSON object:

{
    "id": 1,
    "name": "John Doe",
    "url": "https://domain.tld/users/1",
    "createdAt": "2024-08-02T10:30:00-03:00",
    "bio": null
}

Note that the url and createdAt property objects have been json-serialized.

And, only properties with defined values will appear in the result. Note that bio has the default value of null and appears in the result. On the other hand, the updatedAt property does not have a defined value and therefore does not appear in the result.

JSON Flags

Through the $_jsonFlags property, the flags to encode and decode JSON internally in the Entity class are set.

The example below shows the flags with the default value:

class User extends Entity
{
    public int $_jsonFlags = JSON_UNESCAPED_SLASHES
        | JSON_UNESCAPED_UNICODE
        | JSON_PRESERVE_ZERO_FRACTION
        | JSON_THROW_ON_ERROR;
}

You can find more details on the JSON Constants page.

Below is an example showing what can happen:

class People extends Entity
{
    protected string $name;
    protected float $height;
    protected string $status;
    protected URL $link;
    protected array $config;
}

$people = new People([
    'name' => 'John Doe',
    'height' => 1,
    'status' => 'Happy! ❤️ ⚡⚡',
    'link' => 'https://domain.tld/john-doe',
    'config' => [
        'theme' => [
            'color' => 'magenta',
            'background' => 'black',
        ],
    ],
]);

echo (string) $people;

This is the result when the People entity is encoded without flags:

{"name":"John Doe","height":1,"status":"Happy! \u2764\ufe0f \u26a1\u26a1","link":"https:\/\/domain.tld\/john-doe","config":{"theme":{"color":"magenta","background":"black"}}}

And, this is the result with the default flags:

{"name":"John Doe","height":1.0,"status":"Happy! ❤️ ⚡⚡","link":"https://domain.tld/john-doe","config":{"theme":{"color":"magenta","background":"black"}}}

Note that height has a float value, the unicode in status is not escaped and link has no backslashes.

exist

Requires that a value exists in the database.

exist:$tableColumn
exist:$tableColumn,$connection

The rule has two parameters: $tableColumn and $connection.

$tableColumn is the table name and, optionally, the column name separated by a dot. If the column is not defined, the field name will be used as the column name.

$connection is the name of the database connection. The default is default.

existMany

Requires that many values exists in the database.

existMany:$tableColumn
existMany:$tableColumn,$connection

This rule is similar to exist. Except it is able to check if many values are present in a database table.

It can validate many values from a select HTML element:

<select name="fruits[]" multiple>
    <option value="1">Apple</option>
    <option value="2">Orange</option>
    <option value="3">Pear</option>
    <option value="5">Banana</option>
    <option value="9">Strawberry</option>
</select>

The following example will validate if the ids sent in the fruits field are present in the Fruits table:

existMany:Fruits.id

If any value does not exist, validation will fail.

unique

Requires that a value is not registered in the database.

unique:$tableColumn
unique:$tableColumn,$ignoreColumn,$ignoreValue
unique:$tableColumn,$ignoreColumn,$ignoreValue,$connection

The rule has four parameters: $tableColumn, $ignoreColumn, $ignoreValue and $connection.

$tableColumn is the table name and, optionally, the column name separated by a dot. If the column is not defined, the field name will be used as the column name.

$ignoreColumn is the name of the column to ignore if the value is already registered. Usually when updating data.

$ignoreValue is the value to be ignored in the $ignoreColumn.

$connection is the name of the database connection. The default is default.

Extending Layouts

The View has a basic layout system that other view files can extend.

Let's see the layout file views/_layouts/default.php below:

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title><?= $title ?></title>
</head>
<body>
<?= $view->renderBlock('contents') // string or null ?>
</body>
</html>

Then, in the view that will be rendered by the render method, the file _layouts/default sets the content inside the contents block:

views/home/index.php

<?php
$view->extends('_layouts/default'); // static
$view->block('contents'); // static
?>
<h1><?= $title ?></h1>
<p><?= $description ?></p>
<?php
$view->endBlock(); // static

If you want to extend views always from the same directory, you can set the layout prefix:

$view->setLayoutPrefix('_layouts'); // static

This will make it unnecessary to type the entire path. See the example below:

- $view->extends('_layout/default');
+ $view->extends('default');

When working with only one file that extends a layout, it is possible to set the default block name in the second argument of extends.

Let's see how to extend the default layout and capture the content in the file views/home/index.php:

<?php
$view->extends('default', 'contents'); // static
?>
<h1><?= $title ?></h1>
<p><?= $description ?></p>

So the rendered HTML file will look like this:

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Welcome!</title>
</head>
<body>
<h1>Welcome!</h1>
<p>Welcome to Aplus MVC.</p>
</body>
</html>

View Includes

It is often common to have parts of the layout that are repeated. Like for example, a header, a footer, a sidebar.

These files are called includes.

Let's see an example of include with a navigation bar in the file views/_includes/navbar.php:

<div class="navbar">
<ul>
    <li<?= $active === 'home' ? ' class="active"' : ''?>>
        <a href="/">Home</a>
    </li>
    <li<?= $active === 'contact' ? ' class="active"' : ''?>>
        <a href="/contact">Contact</a>
    </li>
</ul>
</div>

This navbar will appear in several layouts, including the default one.

Let's see below how to make it appear in views that extend the layout views/_layouts/default.php:

<body>
<?= $view->include('_includes/navbar') // string ?>
<h1><?= $title ?></h1>

As with layouts, you can set the includes path prefix:

$view->setIncludePrefix('_includes');

Once the includes path is set, it is no longer necessary to include it in the include method call:

- $view->include('_includes/navbar');
+ $view->include('navbar');

The call in the default layout will be like this:

<body>
<?= $view->include('navbar') // string ?>
<h1><?= $title ?></h1>

When necessary, you can pass an array of data to the include.

Let's see how to pass the variable active with the value home:

<body>
<?= $view->include('navbar', ['active' => 'home']) // string ?>
<h1><?= $title ?></h1>

When rendered, the include will show the active class on the Home line in the navbar:

<div class="navbar">
<ul>
    <li class="active">
        <a href="/">Home</a>
    </li>
    <li>
        <a href="/contact">Contact</a>
    </li>
</ul>
</div>

View Blocks

Below we will see how to create a block called contents and another called scripts in the views/home/index.php file:

<?php
$view->extends('default'); // static

$view->block('contents'); // static
?>
<h1><?= $title ?></h1>
<p><?= $description ?></p>
<?php
$view->endBlock(); // static

$view->block('scripts'); // static
?>
<script>
    console.log('Hello!');
</script>
<?php
$view->endBlock(); // static

In the views/_layouts/default.php file we can render the two blocks:

<body>
<?= $view->renderBlock('contents') // string or null ?>
<?= $view->renderBlock('scripts') // string or null ?>
</body>

And the output will be like this:

<body>
<h1>Welcome!</h1>
<p>Welcome to Aplus MVC.</p>
<script>
    console.log('Hello!');
</script>
</body>

Render Views

Instead of building all the page content inside the index method, you can use the render method, with the name of the file that will be rendered, building the HTML page as a view.

In this case, we render the home/index view:

use Framework\MVC\Controller;

class Home extends Controller
{
    public function index() : string
    {
        return $this->render('home/index');
    }
}

Validate Data

When necessary, you can validate data using the validate method.

In it, it is possible to put the data that will be validated, the rules, and, optionally, the labels, the messages and the name of the validation service instance, which by default is default.

In the example below we highlight the create method, which can be called by the HTTP POST method to create a contact message.

Note that the rules are set and then the POST data is validated, returning an array with the errors and showing them on the screen in a list or an empty array, showing that no validation errors occurred and the message that was created successfully:

use Framework\MVC\Controller;

class Contact extends Controller
{
    public function index() : string
    {
        return $this->render('contact/index');
    }

    public function create() : void
    {
        $rules = [
            'name' => 'minLength:5|maxLength:32',
            'email' => 'email',
            'message' => 'minLength:10|maxLength:1000',
        ];
        $errors = $this->validate($this->request->getPost(), $rules);
        if ($errors) {
            echo '<h2>Validation Errors</h2>';
            echo '<ul>';
            foreach($errors as $error) {
                echo '<li>' . $error . '</li>';
            }
            echo '</ul>';
            return;
        }
        echo '<h2>Contact Successful Created</h2>';
    }
}

HTTP Request and Response

The Controller has instances of the two HTTP messages, the Request and the Response, accessible through properties that can be called directly.

Let's see below how to use Request to get the current URL as a string and put it in the Response body:

use Framework\HTTP\Response;
use Framework\MVC\Controller;

class Home extends Controller
{
    public function index() : Response
    {
        $url = (string) $this->request->getUrl();
        return $this->response->setBody(
            'Current URL is: ' . $url
        );
    }
}

The example above is simple, but $request and $response are powerful, having numerous useful methods for working on HTTP interactions.

Model Instances

Each controller can have model instances in properties, which will be automatically instantiated in the class constructor.

The properties must be child classes of the Framework\MVC\Model class.

Let's see below that $users receives the type name of the App\Models\UsersModel class and in the show method the direct call to the $users property is used, which has the instance of App\Models\UsersModel:

use App\Models\UsersModel;
use Framework\MVC\Controller;

class Users extends Controller
{
    protected UsersModel $users;

    public function show(int $id) : string
    {
        $user = $this->users->read($id);
        return $this->render('users/show', [
            'user' => $user,
        ]);
    }
}

JSON Responses

As with the Framework\Routing\RouteActions class, the controller action methods can return an array, stdClass, or JsonSerializable instance so that the Response is automatically set with the JSON Content-Type and the message body as well.

In the example below, we see how to get the users of a page, with an array returned from the model's paginate method, and then returned to be JSON-encoded and added to the Response body:

use App\Models\UsersModel;
use Framework\MVC\Controller;

class Users extends Controller
{
    protected UsersModel $users;

    public function index() : array
    {
        $page = $this->request->getGet('page')
        $users = $this->users->paginate($page);
        return $users;
    }
}

Before and After Actions

Every controller has two methods inherited from Framework\Routing\RouteActions that can be used to prepare configurations, filter input data, and also to finalize configurations and filter output data.

They are beforeAction and afterAction.

Let's look at a simple example to validate a user's access to a dashboard's pages.

We create the AdminController class and put a check in it to see if the user_id is set in the session. If not, the page will be redirected to the location /login. Otherwise, access to the action method is released and the user can access the admin area:

use Framework\MVC\App;
use Framework\MVC\Controller;

abstract class AdminController extends Controller
{
    protected function beforeAction(string $method, array $arguments) : mixed
    {
        if (!App::session()->has('user_id')) {
            return $this->response->redirect('/login');
        }
        return null;
    }
}

Below, the Dashboard methods will only be executed if beforeAction returns null in the parent class, AdminController:

final class Dashboard extends AdminController
{
    public function index() : string
    {
        return 'You are in Admin Area!';
    }
}