Bootstrap

The Bootstrap class in the Bootstrap.php file is a core component of the framework, responsible for initializing and configuring the application. It handles the setup of essential configurations, routing, and middleware processing. Below is an overview of its key functionalities:

Namespace and Imports

?php
namespace System\Core;
use System\Libraries\Logger;
use Exception;

if (!defined('ROOT_PATH')) {
    exit('No direct access allowed.');
}

require_once ROOT_PATH . '/system/Helpers/Core_helper.php';
load_helpers(['uri', 'security']);

• Defines the namespace System\Core.

• Imports the Logger class and the Exception class.

• Checks if ROOT_PATH is defined. If not, it prevents direct access to the file.

• Loads the Core_helper.php file to use the load_helpers function.

• Loads the uri and security helpers.

Class Definition

<?php
class Bootstrap {

    protected $routes;
    protected $uri;

    public function __construct() {
        $appConfig = config('app');
        if (!empty($appConfig['app_timezone'])) {
            date_default_timezone_set($appConfig['app_timezone']);
        }
        if (!empty($appConfig['debug']) && $appConfig['debug']) {
            ini_set('display_startup_errors', 1);
            ini_set('display_errors', 1);
            error_reporting(-1);
        } else {
            ini_set('display_startup_errors', 0);
            ini_set('display_errors', 0);
            error_reporting(E_ALL & ~E_NOTICE);
        }
        $this->init_uri();
        $this->routes = new Router(); // Create an instance for Router
        $this->loadRoutes();          // Load the routes
    }
}

• Defines the Bootstrap class with protected properties $routes and $uri.

• The constructor sets the timezone, configures error reporting based on the debug mode, initializes the URI, creates a Router instance, and loads the routes.

init_uri()

private function init_uri() {
    $originalUri = request_uri();
    $originalQ = $_SERVER['QUERY_STRING'] ?? '';
    $uri = uri_security($originalUri);
    $sanitizedQueryString = '';
    
    if (!empty($originalQ)) {
        $safeGet = sget_security(); 
        $sanitizedQueryString = http_build_query($safeGet); 
    }
    
    $cleanFull = '/' . trim($uri, '/') . '/';  "
    if ($sanitizedQueryString !== '') {
        $cleanFull .= '?' . $sanitizedQueryString;
    }
    
    $cleanFull = '/' . ltrim($cleanFull, '/');
    if ($cleanFull !== $_SERVER['REQUEST_URI'] && $cleanFull !== $_SERVER['REQUEST_URI'] . '/') {
        redirect(base_url($cleanFull));
    }
    
    unset($safeGet, $sanitizedQueryString, $originalUri, $cleanFull);
 
    $this->uri = [
        'uri' => $uri,
        'split' => explode('/', $uri)
    ];
    unset($uri);
    if (!empty($this->uri['split'][0]) && in_array($this->uri['split'][0], LANG_LIST)) {
        array_shift($this->uri['split']); 
        $this->uri['uri'] = implode('/', $this->uri['split']);
    }
    return $this->uri;
}

• Initializes the URI by sanitizing it and redirecting if necessary.

• Splits the URI into parts and handles language prefixes.

run()

public function run() {
        try {
            if (!isset($_SERVER['REQUEST_METHOD'])) $_SERVER['REQUEST_METHOD'] = 'GET';
            $method = $_SERVER['REQUEST_METHOD'];
            $this->dispatch($this->uri['uri'], $method);
        } catch (AppException $e) {
            $e->handle();
        } catch (\Throwable $e) { // Catch all exceptions and errors
            Logger::error($e->getMessage(), $e->getFile(), $e->getLine());
            http_response_code(500);
            if (!empty(config('app')['debug'])) {
                echo $e->getMessage(), $e->getFile(), $e->getLine();
            } else {
                echo "An unknown error has occurred. Lets check file logger.log!";
            }
        }
    }

• Runs the framework.

• Checks the HTTP method of the request (GET, POST, etc.).

• Calls the dispatch() method to route the URI to the corresponding controller and action.

• Catches and handles AppException and other errors, logs the error, and displays an error message.

loadRoutes()

 private function loadRoutes() {
        global $routes;
        $routes = $this->routes;
        if (!empty($this->uri) && !empty($this->uri['split']) && $this->uri['split'][0] == 'api') {
            if (file_exists(ROOT_PATH . '/application/Routes/Api.php')) {
                require_once ROOT_PATH . '/application/Routes/Api.php';
            }
        }
        if (file_exists(ROOT_PATH . '/application/Routes/Web.php')) {
            require_once ROOT_PATH . '/application/Routes/Web.php';
        }
    }

• Loads the routes from the Api.php and Web.php route files.

• Uses the global $routes variable to store the routes.

• Checks and loads the corresponding route files if they exist.

dispatch()

private function dispatch($uri, $method) {
        $route = $this->routes->match($uri, $method);
        if (isset($route['action']) && $route['action'][0] == '_') {
            throw new AppException("404 - Router: /{$uri} ({$method}) can not access!", 404, null, 404);
        }
        
        if (!$route) {
            throw new AppException("404 - Router: /{$uri} ({$method}) not found!", 404, null, 404);
        }
        
        $middleware = new Middleware();
        if (!empty($route['middleware'])) {
            foreach ($route['middleware'] as $mw) {
                $middleware->add($mw);
            }
        }

      
        unset($route['middleware']);
        $route['uri'] = $uri;
        $middleware->handle($route, function () use ($route) {
            $controllerClass = $route['controller'];
            $action = $route['action'];
            $params = $route['params'];
            
            if (!class_exists($controllerClass)) {
                throw new AppException("Controller {$controllerClass} not found.", 404, null, 404);
            }
            
            $controller = new $controllerClass();

            if (!method_exists($controller, $action)) {
                throw new AppException("Action {$action} not found in {$controllerClass} Controller.", 404, null, 404);
            }

            call_user_func_array([$controller, $action], $params);
        });
    }

• Routes the URI to the corresponding controller and action.

• Uses Router to match the URI and HTTP method with the corresponding route.

• Checks and handles middleware before calling the controller.

• Checks the existence of the controller and action, throws an exception if not found.

• Calls the controller and action with the corresponding parameters.

Conclusion

The methods in Bootstrap.php help initialize and route the framework, handle the URI, load the routes, and route the request to the corresponding controller and action. These methods also handle exceptions and log errors to ensure the application runs smoothly.