refactor(validator): rename enum rule and method to in

70b1016 refactor(autoload): remove global exception handler
a534613 refactor(request): propagate validation failures as exceptions
5f3fc16 feat(router): add error boundary with exception callback
9dbfd7d feat: add named parameter injection to resolve()

.htaccess

@@ -1,6 +1,9 @@
 <IfModule mod_rewrite.c>
     RewriteEngine On
 
+    # Bloquear acceso a las carpetas vendor/ y src/
+    RewriteRule ^(vendor|src)/.*$ - [F,L]
+
     # Handle Front Controller...
     RewriteCond %{REQUEST_FILENAME} !-d
     RewriteCond %{REQUEST_FILENAME} !-f

autoload.php

@@ -0,0 +1,14 @@
+<?php
+
+require_once('config.php');
+
+// Autoloader for the core classes
+spl_autoload_register(function ($className) {
+    $fp = str_replace('\\', '/', $className);
+    $name = basename($fp);
+    $dir  = dirname($fp);
+    $file = ROOT_CORE . '/' . $dir . '/' . $name . '.php';
+    if (file_exists($file)) {
+        require_once $file;
+    }
+});

config.php

@@ -1,15 +1,15 @@
 <?php
 
-// Configuración de la base de datos
+// Database configuration
 define('DB_TYPE', 'mysql');
 define('DB_HOST', 'localhost');
 define('DB_NAME', '');
 define('DB_USER', '');
 define('DB_PASS', '');
 
-// Configuración del sitio
+// Site configuration
 define('SITE_URL', '');
 
-// Configuración avanzada
+// Advanced configuration
 define('ROOT_DIR', __DIR__);
 define('ROOT_CORE', ROOT_DIR . '/src');

index.php

@@ -1,23 +1,15 @@
 <?php
 
-require_once('config.php');
+use Libs\Loader;
+use Libs\Router;
 
-// Incluir clases
+require_once('autoload.php');
-spl_autoload_register(function ($className) {
-    $fp = str_replace('\\', '/', $className);
-    $name = basename($fp);
-    $dir  = dirname($fp);
-    $file = ROOT_CORE . '/' . $dir . '/' . $name . '.php';
-    if (file_exists($file)) {
-        require_once $file;
-    }
-});
 
-// Incluir routers
+// Router autoload
-$routers = glob(ROOT_CORE . '/Routers/*.php');
+Loader::load(ROOT_CORE . '/Routers/');
 
-foreach ($routers as $file) {
+// Other autoloads
-    require_once($file);
+Loader::load(ROOT_CORE . '/Autoloads/');
-}
 
-\Libs\Router::apply();
+// Run the routers
+Router::apply();

readme.org

@@ -28,79 +28,91 @@ En la siguiente tabla se encuentra la lista de estados de los gestores de bases
 + *En blanco* como que no ha sido probado aún.
 + *error* como que fue probado, no funciona y no ha sido aún arreglado.
 + *not supported* como no soportado por el gestor de bases de datos.
-+ *fixed* para aquello que no existe en el gestor de DB, pero la librería lo traduce a un equivalente.
++ *fixed* para aquello que no existe en el gestor de BD, pero la librería lo traduce a un equivalente.
 
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
 | method           | MySQL/MariaDB | sqlite3 | postgreSQL |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| db               | ok            | ok            |            |
+| db               | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| query            | ok            | ok            |            |
+| query            | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| resetQuery       | ok            | ok            |            |
+| resetQuery       | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| buildQuery       | ok            | ok            |            |
+| buildQuery       | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| getInstance      | ok            | ok            |            |
+| getInstance      | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| getVars          | ok            | ok            |            |
+| getVars          | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| className        | ok            | ok            |            |
+| className        | ok            | ok      | pk         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| table            | ok            | ok            |            |
+| table            | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| update           | ok            | ok            |            |
+| update           | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| beginTransaction | ok            | ok            |            |
+| beginTransaction | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| rollBack         | ok            | ok            |            |
+| rollBack         | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| commit           | ok            | ok            |            |
+| commit           | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| add              | ok            | ok            |            |
+| add              | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| save             | ok            | ok            |            |
+| save             | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| delete           | ok            | ok            |            |
+| delete           | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| select           | ok            | ok            |            |
+| select           | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| from             | ok            | ok            |            |
+| from             | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| where            | ok            | ok            |            |
+| where            | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| where_in         | ok            | ok            |            |
+| whereIn          | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| leftJoin         | ok            | ok            |            |
+| whereNotIn       | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| rightJoin        | ok            | not supported |            |
+| whereNull        | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| innerJoin        | ok            | ok            |            |
+| whereNotNull     | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| and              | ok            | ok            |            |
+| whereExists      | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| or               | ok            | ok            |            |
+| whereNotExists   | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| groupBy          | ok            | ok            |            |
+| leftJoin         | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| limit            | ok            | ok            |            |
+| rightJoin        | ok            | fixed   | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| orderBy          | ok            | ok            |            |
+| innerJoin        | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| count            | ok            | ok            |            |
+| crossJoin        | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| getById          | ok            | ok            |            |
+| and              | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| search           | ok            | ok            |            |
+| or               | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| get              | ok            | ok            |            |
+| groupBy          | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| getFirst         | ok            | ok            |            |
+| limit            | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| all              | ok            | ok            |            |
+| orderBy          | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
-| setNull          | ok            | ok            |            |
+| count            | ok            | ok      | ok         |
-|------------------+---------------+---------------+------------|
+|------------------+---------------+---------+------------|
+| getById          | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
+| search           | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
+| get              | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
+| getFirst         | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
+| all              | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
+| setNull          | ok            | ok      | ok         |
+|------------------+---------------+---------+------------|
 
 * Contacto
 

src/Libs/Loader.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Libs;
+
+/**
+ * Loader - DuckBrain
+ *
+ * Simple library to bulk load multiple php files inside a folder.
+ *
+ * @author KJ
+ * @website https://kj2.me
+ * @license MIT
+ */
+class Loader
+{
+    /**
+     * Loads all PHP files from a specified directory.
+     * If the directory does not exist or is not a directory, no files will be loaded.
+     *
+     * @param  string $directoryPath The path to the directory containing the PHP files to load.
+     * @return void
+     */
+    public static function load(string $directoryPath): void
+    {
+        if (is_dir($directoryPath)) {
+            foreach (glob(rtrim($directoryPath, '/') . '/*.php') as $file) {
+                require_once($file);
+            }
+        }
+    }
+}

src/Libs/Model.php

@@ -23,46 +23,47 @@ use ReflectionProperty;
 #[AllowDynamicProperties]
 class Model
 {
-    /**
-     * @var array Attributes that should be set to NULL on update.
-     */
-    protected array $toNull = [];
-
     /**
      * @var string The name of the primary key column.
      */
-    protected static string $primaryKey = 'id';
+    protected static string $dbPrimaryKey = 'id';
 
     /**
      * @var array Attributes to ignore when saving to the database.
      */
-    protected static array $ignoreSave = ['id'];
+    protected static array $dbIgnoreSave = [];
 
     /**
      * @var array Attributes that should be explicitly saved, even if private/protected.
      */
-    protected static array $forceSave = [];
+    protected static array $dbForceSave = [];
+
+    /**
+     * @var bool Attribute that persis if is current model is saved into the database
+     */
+    protected bool $dbIsSaved = false;
 
     /**
      * @var string The database table name.
      */
-    protected static string $table;
+    protected static string $dbTableName;
 
     /**
      * @var array Variables for PDO prepared statements.
      */
-    protected static array $queryVars = [];
+    protected static array $dbQueryVariables = [];
 
     /**
      * @var array Current SELECT query components.
      */
-    protected static array $querySelect = [
+    protected static array $dbQuery = [
         'select'              => ['*'],
         'where'               => '',
         'from'                => '',
         'leftJoin'            => '',
         'rightJoin'           => '',
         'innerJoin'           => '',
+        'crossJoin'           => '',
         'orderBy'             => '',
         'groupBy'             => '',
         'limit'               => '',
@@ -155,13 +156,29 @@ class Model
 
         try {
             $prepared = $db->prepare($query);
-            $prepared->execute(static::$queryVars);
+            foreach (static::$dbQueryVariables as $key => $value) {
+                // Detect data type to choose the PDO constant
+                $type = match (gettype($value)) {
+                    'integer' => PDO::PARAM_INT,
+                    'boolean' => PDO::PARAM_BOOL,
+                    'NULL'    => PDO::PARAM_NULL,
+                    default   => PDO::PARAM_STR,
+                };
+
+                $prepared->bindValue($key, $value, $type);
+            }
+
+            $prepared->execute();
         } catch (PDOException $e) {
             if ($db->inTransaction()) {
                 $db->rollBack();
             }
 
-            $vars = json_encode(static::$queryVars);
+            $vars = json_encode(static::$dbQueryVariables);
+
+            if ($resetQuery) {
+                static::resetQuery();
+            }
 
             throw new Exception(
                 "\nError at query to database.\n" .
@@ -186,18 +203,19 @@ class Model
      */
     protected static function resetQuery(): void
     {
-        static::$querySelect = [
+        static::$dbQuery = [
             'select'              => ['*'],
             'where'               => '',
             'from'                => '',
             'leftJoin'            => '',
             'rightJoin'           => '',
             'innerJoin'           => '',
+            'crossJoin'           => '',
             'orderBy'             => '',
             'groupBy'             => '',
             'limit'               => '',
         ];
-        static::$queryVars  = [];
+        static::$dbQueryVariables  = [];
     }
 
     /**
@@ -209,40 +227,44 @@ class Model
      */
     protected static function buildQuery(): string
     {
-        $sql = 'SELECT ' . join(', ', static::$querySelect['select']);
+        $sql = 'SELECT ' . join(', ', static::$dbQuery['select']);
 
-        if (static::$querySelect['from'] != '') {
+        if (static::$dbQuery['from'] != '') {
-            $sql .= ' FROM ' . static::$querySelect['from'];
+            $sql .= ' FROM ' . static::$dbQuery['from'];
         } else {
             $sql .= ' FROM ' . static::table();
         }
 
-        if (static::$querySelect['innerJoin'] != '') {
+        if (static::$dbQuery['crossJoin'] != '') {
-            $sql .= static::$querySelect['innerJoin'];
+            $sql .= static::$dbQuery['crossJoin'];
         }
 
-        if (static::$querySelect['leftJoin'] != '') {
+        if (static::$dbQuery['innerJoin'] != '') {
-            $sql .= static::$querySelect['leftJoin'];
+            $sql .= static::$dbQuery['innerJoin'];
         }
 
-        if (static::$querySelect['rightJoin'] != '') {
+        if (static::$dbQuery['leftJoin'] != '') {
-            $sql .= static::$querySelect['rightJoin'];
+            $sql .= static::$dbQuery['leftJoin'];
         }
 
-        if (static::$querySelect['where'] != '') {
+        if (static::$dbQuery['rightJoin'] != '') {
-            $sql .= ' WHERE ' . static::$querySelect['where'];
+            $sql .= static::$dbQuery['rightJoin'];
         }
 
-        if (static::$querySelect['groupBy'] != '') {
+        if (static::$dbQuery['where'] != '') {
-            $sql .= ' GROUP BY ' . static::$querySelect['groupBy'];
+            $sql .= ' WHERE ' . static::$dbQuery['where'];
         }
 
-        if (static::$querySelect['orderBy'] != '') {
+        if (static::$dbQuery['groupBy'] != '') {
-            $sql .= ' ORDER BY ' . static::$querySelect['orderBy'];
+            $sql .= ' GROUP BY ' . static::$dbQuery['groupBy'];
         }
 
-        if (static::$querySelect['limit'] != '') {
+        if (static::$dbQuery['orderBy'] != '') {
-            $sql .= ' LIMIT ' . static::$querySelect['limit'];
+            $sql .= ' ORDER BY ' . static::$dbQuery['orderBy'];
+        }
+
+        if (static::$dbQuery['limit'] != '') {
+            $sql .= ' LIMIT ' . static::$dbQuery['limit'];
         }
 
         return $sql;
@@ -259,10 +281,10 @@ class Model
      * @return string
      *                Substitution parameter.
      */
-    private static function bindValue(string $value): string
+    public static function bind(string $value): string
     {
-        $index = ':v_' . count(static::$queryVars);
+        $index = ':v_' . count(static::$dbQueryVariables);
-        static::$queryVars[$index] = $value;
+        static::$dbQueryVariables[$index] = $value;
         return $index;
     }
 
@@ -282,26 +304,61 @@ class Model
         $instance   = new $class();
         $reflection = new ReflectionClass($instance);
         $properties = $reflection->getProperties();
-        $propertyNames = array_map(function ($property) {
+
-            return static::camelCaseToSnakeCase($property->name);
+        $map = [];
-        }, $properties);
+        foreach ($properties as $prop) {
+            $map[static::camelCaseToSnakeCase($prop->name)] = $prop;
+        }
 
         foreach ($elem as $key => $value) {
-            $index = array_search($key, $propertyNames);
+            if (isset($map[$key])) {
-            if (is_numeric($index)) {
+                $property = $map[$key];
-                if (enum_exists($properties[$index]->getType()->getName())) {
+                $instance->{$property->name} = static::castValue($property, $value);
-                    $instance->{$properties[$index]->name} = $properties[$index]->getType()->getName()::tryfrom($value);
-                } else {
-                    $instance->{$properties[$index]->name} =  $value;
-                }
             } else {
                 $instance->{static::snakeCaseToCamelCase($key)} = $value;
             }
         }
 
+        $instance->markAsSaved();
+
         return $instance;
     }
 
+    /**
+     * Handles type casting for properties
+     *
+     * @param ReflectionProperty $property
+     * @param mixed              $value
+     *
+     * @return mixed
+     */
+    protected static function castValue(ReflectionProperty $property, mixed $value): mixed
+    {
+        $type = $property->getType();
+        if (!$type) {
+            return $value;
+        }
+
+        $typeName = $type->getName();
+
+        // Enum cast
+        if (enum_exists($typeName)) {
+            if (method_exists($typeName, 'tryFrom')) {
+                return $typeName::tryFrom($value);
+            }
+            if (in_array($value, array_column($typeName::cases(), 'name'))) {
+                return $typeName::{$value};
+            }
+        }
+
+        // DateTime cast
+        if (is_subclass_of($typeName, \DateTimeInterface::class)) {
+            return $value ? new $typeName($value) : null;
+        }
+
+        return $value;
+    }
+
     /**
      * Returns the attributes to be saved for the current class.
      * Attributes will be those that are public and not excluded in static::$ignoreSave,
@@ -317,30 +374,43 @@ class Model
         $result     = [];
 
         foreach ($properties as $property) {
-            if (!in_array($property->name, static::$ignoreSave)) {
+            // Avoid save unset variables
-                $result[$this->camelCaseToSnakeCase($property->name)] = isset($this->{$property->name})
+            if ($property->getType() && !$property->isInitialized($this)) {
-                    ? $this->{$property->name} : null;
+                continue;
+            }
+
+            if (!in_array($property->name, static::$dbIgnoreSave)) {
+                $name = $this->camelCaseToSnakeCase($property->name);
+                $result[$name] = $this->castToDbValue($this->{$property->name});
             }
         }
 
-        foreach (static::$forceSave as $value) {
+        foreach (static::$dbForceSave as $value) {
-            $result[$value] = isset($this->$value)
+            $result[$value] = $this->castToDbValue($this->$value);
-                ? $this->$value : null;
-        }
-
-        foreach ($result as $i => $property) {
-            if (gettype($property) == 'boolean') {
-                $result[$i] = $property ? '1' : '0';
-            }
-
-            if ($property instanceof \UnitEnum) {
-                $result[$i] = $property->value ?? $property->name;
-            }
         }
 
         return $result;
     }
 
+    /**
+     * Converts a PHP value to a database-compatible value.
+     *
+     * @param  mixed $value
+     * @return mixed
+     */
+    protected function castToDbValue(mixed $value): mixed
+    {
+        if ($value instanceof \UnitEnum) {
+            return $value->value ?? $value->name;
+        }
+
+        if ($value instanceof \DateTimeInterface) {
+            return $value->format('Y-m-d H:i:s');
+        }
+
+        return $value;
+    }
+
     /**
      * Returns the name of the current class, even if it's an extended class.
      *
@@ -364,8 +434,8 @@ class Model
      */
     protected static function table(): string
     {
-        if (isset(static::$table)) {
+        if (isset(static::$dbTableName)) {
-            return static::$table;
+            return static::$dbTableName;
         }
 
         return static::camelCaseToSnakeCase(static::className()) . 's';
@@ -410,26 +480,20 @@ class Model
     protected function update(): void
     {
         $atts = $this->getVars();
+        static::$dbQueryVariables = [];
 
+        $set = [];
         foreach ($atts as $key => $value) {
-            if (isset($value)) {
-                if (in_array($key, $this->toNull)) {
-                    $set[] = "$key=NULL";
-                } else {
             $set[] = "$key=:$key";
-                    static::$queryVars[':' . $key] = $value;
+            static::$dbQueryVariables[':' . $key] = $value;
-                }
-            } else {
-                if (in_array($key, $this->toNull)) {
-                    $set[] = "$key=NULL";
-                }
-            }
         }
 
         $table = static::table();
-        $pk = static::$primaryKey;
+        $pk = static::$dbPrimaryKey;
         $pkv = $this->$pk;
-        $sql = "UPDATE $table SET " . join(', ', $set) . " WHERE $pk='$pkv'";
+        $sql = "UPDATE $table SET " . join(', ', $set) . " WHERE $pk=:$pk";
+        static::$dbQueryVariables[":$pk"] = $pkv;
+
         static::query($sql);
     }
 
@@ -444,38 +508,48 @@ class Model
         $atts = $this->getVars();
         $into = [];
         $values = [];
+        static::$dbQueryVariables = [];
 
         foreach ($atts as $key => $value) {
-            if (isset($value)) {
+            $into[] = "$key";
-                $into[] = "`$key`";
             $values[] = ":$key";
-                static::$queryVars[":$key"] = $value;
+            static::$dbQueryVariables[":$key"] = $value;
-            }
         }
 
         $table = static::table();
         $sql = "INSERT INTO $table (" . join(', ', $into) . ") VALUES (" . join(', ', $values) . ")";
         static::query($sql);
 
-        $pk = static::$primaryKey;
+        $pk = static::$dbPrimaryKey;
-        $this->$pk = $db->lastInsertId();
+        $this->$pk ??= $db->lastInsertId();
+        $this->markAsSaved();
     }
 
     /**
      * Checks if the object to be saved is new or not, and based on the result,
      * calls `update` to update an existing row or `add` to insert a new row.
+     *
      * @return void
      */
     public function save(): void
     {
-        $pk = static::$primaryKey;
+        if ($this->dbIsSaved) {
-        if (isset($this->$pk)) {
             $this->update();
         } else {
             $this->add();
         }
     }
 
+    /**
+     * Mark the current instance as already saved
+     *
+     * @return void
+     */
+    public function markAsSaved(): void
+    {
+        $this->dbIsSaved = true;
+    }
+
     /**
      * Deletes the current object from the database.
      * @return void
@@ -483,24 +557,25 @@ class Model
     public function delete(): void
     {
         $table = static::table();
-        $pk = static::$primaryKey;
+        $pk = static::$dbPrimaryKey;
         $sql = "DELETE FROM $table WHERE $pk=:$pk";
 
-        static::$queryVars[":$pk"] = $this->$pk;
+        static::$dbQueryVariables[":$pk"] = $this->$pk;
         static::query($sql);
+        $this->dbIsSaved = false;
     }
 
     /**
      * Defines SELECT in the SQL statement.
      *
-     * @param array $columns
+     * @param array<string> $columns
      *                               Columns to be selected in the SQL query.
      *
      * @return static
      */
-    public static function select(...$columns): static
+    public static function select(string ...$columns): static
     {
-        static::$querySelect['select'] = $columns;
+        static::$dbQuery['select'] = $columns;
 
         return new static();
     }
@@ -515,7 +590,7 @@ class Model
      */
     public static function from(...$tables): static
     {
-        static::$querySelect['from'] = join(', ', $tables);
+        static::$dbQuery['from'] = join(', ', $tables);
 
         return new static();
     }
@@ -582,13 +657,13 @@ class Model
         }
 
         if (!$no_filter) {
-            $value = static::bindValue($value);
+            $value = static::bind($value);
         }
 
-        if (static::$querySelect['where'] == '') {
+        if (static::$dbQuery['where'] == '') {
-            static::$querySelect['where'] = "$column $operatorOrValue $value";
+            static::$dbQuery['where'] = "$column $operatorOrValue $value";
         } else {
-            static::$querySelect['where'] .= " AND $column $operatorOrValue $value";
+            static::$dbQuery['where'] .= " AND $column $operatorOrValue $value";
         }
 
         return new static();
@@ -624,13 +699,13 @@ class Model
         }
 
         if (!$no_filter) {
-            $value = static::bindValue($value);
+            $value = static::bind($value);
         }
 
-        if (static::$querySelect['where'] == '') {
+        if (static::$dbQuery['where'] == '') {
-            static::$querySelect['where'] = "$column $operatorOrValue $value";
+            static::$dbQuery['where'] = "$column $operatorOrValue $value";
         } else {
-            static::$querySelect['where'] .= " OR $column $operatorOrValue $value";
+            static::$dbQuery['where'] .= " OR $column $operatorOrValue $value";
         }
 
         return new static();
@@ -645,36 +720,113 @@ class Model
      * @param array $arr
      *                   Array with all values to compare against the column.
      *
-     * @param bool $in
-     *                 Defines whether to check positively (IN) or negatively (NOT IN).
-     *
      * @return static
      */
     public static function whereIn(
         string $column,
         array $arr,
-        bool $in = true
     ): static {
         $arrIn = [];
         foreach ($arr as $value) {
-            $arrIn[] = static::bindValue($value);
+            $arrIn[] = static::bind($value);
         }
 
-        if ($in) {
+        $where = "$column IN (" . join(', ', $arrIn) . ")";
-            $where_in = "$column IN (" . join(', ', $arrIn) . ")";
+        if (static::$dbQuery['where'] == '') {
+            static::$dbQuery['where'] = $where;
         } else {
-            $where_in = "$column NOT IN (" . join(', ', $arrIn) . ")";
+            static::$dbQuery['where'] .= " AND $where";
         }
 
-        if (static::$querySelect['where'] == '') {
+        return new static();
-            static::$querySelect['where'] = $where_in;
+    }
+
+    /**
+     * Defines WHERE using NOT IN in the SQL statement.
+     *
+     * @param string $column
+     *                       The column to compare.
+     *
+     * @param array $arr
+     *                   Array with all values to compare against the column.
+     *
+     * @return static
+     */
+    public static function whereNotIn(
+        string $column,
+        array $arr,
+    ): static {
+        $arrIn = [];
+        foreach ($arr as $value) {
+            $arrIn[] = static::bind($value);
+        }
+
+        $where = "$column NOT IN (" . join(', ', $arrIn) . ")";
+        if (static::$dbQuery['where'] == '') {
+            static::$dbQuery['where'] = $where;
         } else {
-            static::$querySelect['where'] .= " AND $where_in";
+            static::$dbQuery['where'] .= " AND $where";
         }
 
         return new static();
     }
 
+    /**
+     * Defines WHERE using IS NULL in the SQL statement.
+     *
+     * @param string $column
+     *                       The column to compare.
+     *
+     * @return static
+     */
+    public static function whereNull(string $column): static
+    {
+        static::where($column, 'IS', 'NULL', true);
+        return new static();
+    }
+
+    /**
+     * Defines WHERE using IS NOT NULL in the SQL statement.
+     *
+     * @param string $column
+     *                       The column to compare.
+     *
+     * @return static
+     */
+    public static function whereNotNull(string $column): static
+    {
+        static::where($column, 'IS NOT', 'NULL', true);
+        return new static();
+    }
+
+    /**
+     * Defines WHERE using EXISTS in the SQL statement.
+     *
+     * @param string $query
+     *                      SQL query.
+     *
+     * @return static
+     */
+    public static function whereExists(string $query): static
+    {
+        static::where('', 'EXISTS', "($query)", true);
+        return new static();
+    }
+
+    /**
+     * Defines WHERE using NOT EXISTS in the SQL statement.
+     *
+     * @param string $query
+     *                      SQL query.
+     *
+     * @return static
+     */
+    public static function whereNotExists(string $query): static
+    {
+        static::where('', 'NOT EXISTS', "($query)", true);
+        return new static();
+    }
+
     /**
      * Defines LEFT JOIN in the SQL statement.
      *
@@ -704,7 +856,7 @@ class Model
             $operatorOrColumnB = '=';
         }
 
-        static::$querySelect['leftJoin'] .= ' LEFT JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
+        static::$dbQuery['leftJoin'] .= ' LEFT JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
 
         return new static();
     }
@@ -738,7 +890,14 @@ class Model
             $operatorOrColumnB = '=';
         }
 
-        static::$querySelect['rightJoin'] .= ' RIGHT JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
+        if (static::db()->getAttribute(PDO::ATTR_DRIVER_NAME) == 'sqlite') {
+            $currentTable = empty(static::$dbQuery['from']) ?
+                static::table() : static::$dbQuery['from'];
+            static::$dbQuery['from'] = $table;
+            return static::leftJoin($currentTable, $columnB, $operatorOrColumnB, $columnA);
+        }
+
+        static::$dbQuery['rightJoin'] .= ' RIGHT JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
 
         return new static();
     }
@@ -772,22 +931,47 @@ class Model
             $operatorOrColumnB = '=';
         }
 
-        static::$querySelect['innerJoin'] .= ' INNER JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
+        static::$dbQuery['innerJoin'] .= ' INNER JOIN ' . $table . ' ON ' . "$columnA$operatorOrColumnB$columnB";
 
         return new static();
     }
 
+    /**
+     * Defines CROSS JOIN in the SQL statement.
+     *
+     * @param string $table
+     *                      Table to join with the current object's table.
+     *
+     * @param string $columnA
+     *                        Column to compare for the join.
+     *
+     * @param string $operatorOrColumnB
+     *                                  Operator or column to compare as equal for the join
+     *                                  if $columnB is not defined.
+     *
+     * @param string|null $columnB
+     *                             (Optional) Column to compare for the join.
+     *
+     * @return static
+     */
+    public static function crossJoin(
+        string $table,
+    ): static {
+        static::$dbQuery['crossJoin'] .= ' CROSS JOIN ' . $table;
+        return new static();
+    }
+
     /**
      * Defines GROUP BY in the SQL statement.
      *
-     * @param array $arr
+     * @param array $columns
      *                       Columns to group by.
      *
      * @return static
      */
-    public static function groupBy(array $arr): static
+    public static function groupBy(string ...$columns): static
     {
-        static::$querySelect['groupBy'] = join(', ', $arr);
+        static::$dbQuery['groupBy'] = join(', ', $columns);
         return new static();
     }
 
@@ -805,9 +989,9 @@ class Model
     public static function limit(int $offsetOrQuantity, ?int $quantity = null): static
     {
         if (is_null($quantity)) {
-            static::$querySelect['limit'] = $offsetOrQuantity;
+            static::$dbQuery['limit'] = $offsetOrQuantity;
         } else {
-            static::$querySelect['limit'] = $offsetOrQuantity . ', ' . $quantity;
+            static::$dbQuery['limit'] = $quantity . ' OFFSET ' . $offsetOrQuantity;
         }
 
         return new static();
@@ -828,7 +1012,9 @@ class Model
     public static function orderBy(string $value, string $order = 'ASC'): static
     {
         if ($value == "RAND") {
-            static::$querySelect['orderBy'] = 'RAND()';
+            $random = static::db()->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql' ? 'RAND()' : 'RANDOM()';
+            static::$dbQuery['orderBy'] = $random;
+
             return new static();
         }
 
@@ -836,7 +1022,7 @@ class Model
             $order = 'ASC';
         }
 
-        static::$querySelect['orderBy'] = $value . ' ' . $order;
+        static::$dbQuery['orderBy'] = $value . ' ' . $order;
 
         return new static();
     }
@@ -857,25 +1043,25 @@ class Model
     {
         if (!$resetQuery) {
             $backup = [
-                'select'              => static::$querySelect['select'],
+                'select'              => static::$dbQuery['select'],
-                'limit'               => static::$querySelect['limit'],
+                'limit'               => static::$dbQuery['limit'],
-                'orderBy'             => static::$querySelect['orderBy'],
+                'orderBy'             => static::$dbQuery['orderBy'],
             ];
         }
 
-        if ($useLimit && static::$querySelect['limit'] != '') {
+        if ($useLimit && static::$dbQuery['limit'] != '') {
-            static::$querySelect['select']  = ['1'];
+            static::$dbQuery['select']  = ['1'];
-            static::$querySelect['orderBy'] = '';
+            static::$dbQuery['orderBy'] = '';
 
             $sql         = 'SELECT COUNT(1) AS quantity FROM (' . static::buildQuery() . ') AS counted';
             $queryResult = static::query($sql, $resetQuery);
             $result      = $queryResult[0]['quantity'];
         } else {
-            static::$querySelect['select']  = [
+            static::$dbQuery['select']  = [
-                "COUNT(" . static::table() . "." . static::$primaryKey . ") as quantity",
+                "COUNT(" . static::table() . "." . static::$dbPrimaryKey . ") as quantity",
             ];
-            static::$querySelect['limit']   = '1';
+            static::$dbQuery['limit']   = '1';
-            static::$querySelect['orderBy'] = '';
+            static::$dbQuery['orderBy'] = '';
 
             $sql = static::buildQuery();
             $queryResult = static::query($sql, $resetQuery);
@@ -883,9 +1069,9 @@ class Model
         }
 
         if (!$resetQuery) {
-            static::$querySelect['select']  = $backup['select'];
+            static::$dbQuery['select']  = $backup['select'];
-            static::$querySelect['limit']   = $backup['limit'];
+            static::$dbQuery['limit']   = $backup['limit'];
-            static::$querySelect['orderBy'] = $backup['orderBy'];
+            static::$dbQuery['orderBy'] = $backup['orderBy'];
         }
 
         return (int)$result;
@@ -901,7 +1087,7 @@ class Model
      */
     public static function getById(mixed $id): ?static
     {
-        return static::where(static::$primaryKey, $id)->getFirst();
+        return static::where(static::$dbPrimaryKey, $id)->getFirst();
     }
 
     /**
@@ -918,28 +1104,37 @@ class Model
     public static function search(string $search, ?array $in = null): static
     {
         if ($in == null) {
-            $className = get_called_class();
+            $in         = [];
-            $in = array_keys((new $className())->getVars());
+            $reflection = new \ReflectionClass(get_called_class());
+
+            foreach ($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
+                if (!in_array($property->getName(), static::$dbIgnoreSave)) {
+                    $in[] = static::camelCaseToSnakeCase($property->getName());
+                }
+            }
         }
 
-        $search = static::bindValue($search);
+        if (empty($in)) {
+            return new static();
+        }
+
+        $search = static::bind($search);
         $where  = [];
 
-        if (DB_TYPE == 'sqlite') {
+        if (static::db()->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
-            foreach ($in as $row) {
-                $where[] = "$row LIKE '%' || $search || '%'";
-            }
-        } else {
             foreach ($in as $row) {
                 $where[] = "$row LIKE CONCAT('%', $search, '%')";
             }
+        } else {
+            foreach ($in as $row) {
+                $where[] = "CAST($row AS TEXT) LIKE '%' || $search || '%'";
+            }
         }
 
-
+        if (static::$dbQuery['where'] == '') {
-        if (static::$querySelect['where'] == '') {
+            static::$dbQuery['where'] = join(' OR ', $where);
-            static::$querySelect['where'] = join(' OR ', $where);
         } else {
-            static::$querySelect['where'] = static::$querySelect['where'] . ' AND (' . join(' OR ', $where) . ')';
+            static::$dbQuery['where'] = static::$dbQuery['where'] . ' AND (' . join(' OR ', $where) . ')';
         }
 
         return new static();
@@ -1003,22 +1198,4 @@ class Model
 
         return $instances;
     }
-
-    /**
-     * Allows defining an attribute's value as null.
-     * Only works for updating an element in the DB, not for inserting.
-     *
-     * @param array $attributes
-     *                          Attribute or array of attributes that will be set to null.
-     *
-     * @return void
-     */
-    public function setNull(string ...$attributes): void
-    {
-        foreach ($attributes as $att) {
-            if (!in_array($att, $this->toNull)) {
-                $this->toNull[] = $att;
-            }
-        }
-    }
 }

src/Libs/Neuron.php

@@ -52,7 +52,7 @@ class Neuron
      * @param  string $index The name of the property being accessed.
      * @return null   Always returns null for undefined properties.
      */
-    public function __get(string $index): null
+    public function __get(string $index)
     {
         return null;
     }

src/Libs/Request.php

@@ -2,6 +2,8 @@
 
 namespace Libs;
 
+use Exception;
+
 /**
  * Request - DuckBrain
  *
@@ -27,8 +29,6 @@ class Request extends Neuron
 
     /**
      * __construct
-     *
-     * @param string $path Current path, taking the DuckBrain installation as root.
      */
     public function __construct()
     {
@@ -38,7 +38,7 @@ class Request extends Neuron
         $this->put    = new Neuron();
         $this->patch  = new Neuron();
         $this->delete = new Neuron();
-        $this->params = new Neuron(Router::$currentParams);
+        $this->params = Router::$params ?? new Neuron();
         $this->body   = file_get_contents("php://input");
 
         $contentType = isset($_SERVER["CONTENT_TYPE"]) ? trim($_SERVER["CONTENT_TYPE"]) : '';
@@ -61,39 +61,48 @@ class Request extends Neuron
         }
 
         // Run configured validations
-        if (!$this->validate()) {
+        $this->validate();
-            exit();
-        }
     }
 
     /**
      * Starts the configured validation.
      *
-     * @return bool
+     * On failure the single error message is built with Validator::message()
+     * and handed to onInvalid(), which throws by default: failures travel up
+     * as exceptions instead of answering HTTP here.
+     *
+     * @return void
+     * @throws Exception When a configured rule fails.
      */
-    public function validate(): bool
+    public function validate(): void
     {
         $actual = match ($_SERVER['REQUEST_METHOD']) {
             'POST', 'PUT', 'PATCH', 'DELETE' => $this->{strtolower($_SERVER['REQUEST_METHOD'])},
             default => $this->get
         };
 
+        // Merge uploaded files ($_FILES) into the body data set so the file rules
+        // (file/image/mimes and the routed min/max/required...) can validate
+        // uploads through a Request. $this->post is left untouched.
+        $body = empty($_FILES)
+            ? $actual
+            : new Neuron(array_merge(get_object_vars($actual), $_FILES));
+
         if (
             Validator::validateList(static::paramRules(), $this->params) &&
             Validator::validateList(static::getRules(), $this->get) &&
-            Validator::validateList(static::rules(), $actual)
+            Validator::validateList(static::rules(), $body)
         ) {
-            return true;
+            return;
         }
 
-        if (isset(static::messages()[Validator::$lastFailed])) {
+        $error = Validator::message(
-            $error =  static::messages()[Validator::$lastFailed];
+            Validator::$lastFailed,
-        } else {
+            static::messages(),
-            $error = 'Error: validation failed of ' . preg_replace('/\./', ' as ', Validator::$lastFailed, 1);
+            static::attributes()
-        }
+        );
 
         static::onInvalid($error);
-        return false;
     }
 
     /**
@@ -136,16 +145,36 @@ class Request extends Neuron
         return [];
     }
 
+    /**
+     * Human-readable names for the fields.
+     *
+     * Forwarded to Validator::message() so the :attribute marker in the error
+     * text can be replaced with a friendlier name (e.g. "edad" => "la edad").
+     *
+     * @return array
+     */
+    public function attributes(): array
+    {
+        return [];
+    }
+
     /**
      * Function to execute when an invalid value has been detected.
      *
+     * The default implementation always throws a generic \Exception carrying
+     * the single error message and HTTP 422 as its code; the framework's
+     * exception boundary (Router::apply) renders the response. Override it to
+     * throw a more specific exception type instead. The never return type is
+     * the contract: an override that returned would let the request continue
+     * with invalid data, so PHP rejects such an override at compile time.
+     *
      * @param string $error
      *
-     * @return void
+     * @return never
+     * @throws Exception
      */
-    public function onInvalid(string $error): void
+    public function onInvalid(string $error): never
     {
-        http_response_code(422);
+        throw new Exception($error, 422);
-        print($error);
     }
 }

src/Libs/Router.php

@@ -15,28 +15,40 @@ namespace Libs;
  */
 class Router
 {
-    private static $get    = [];
+    private static array $get    = [];
-    private static $post   = [];
+    private static array $post   = [];
-    private static $put    = [];
+    private static array $put    = [];
-    private static $patch  = [];
+    private static array $patch  = [];
-    private static $delete = [];
+    private static array $delete = [];
+
+    /**
+     * Stores a temporary stack of middlewares to be applied to routes defined
+     * within a specific scope, typically configured by `withMiddleware()`.
+     * These middlewares are active only during the execution of the scope's callback.
+     *
+     * @var array $withMiddlewares<callable>
+     */
+    private static array $withMiddlewares = [];
+
     /**
      * Stores the method and index of the last configured route, e.g., ['get', 0].
      * Used for chaining methods like middleware() or reconfigure().
      *
-     * @var array|null
+     * @var array $last
      */
-    private static $last;
+    private static array $last;
+
     /**
      * Stores the parameters extracted from the current matching route.
      *
-     * @var array
+     * @var Neuron $params
      */
-    public static $currentParams = [];
+    public static Neuron $params;
+
     /**
      * The callback function to be executed when no route matches.
      *
-     * @var callable|string
+     * @var callable $notFoundCallback
      */
     public static $notFoundCallback =  'Libs\Router::defaultNotFound';
 
@@ -52,6 +64,54 @@ class Router
         echo '<h2 style="text-align: center;margin: 25px 0px;">Error 404 - Page Not Found</h2>';
     }
 
+    /**
+     * The callback function to be executed when the router's boundary
+     * catches an exception thrown anywhere in the matched route chain.
+     * It receives the exception as a named argument: the handler must
+     * declare its parameter as $exception (typeable as \Throwable).
+     *
+     * @var callable $exceptionCallback
+     */
+    public static $exceptionCallback = 'Libs\Router::defaultException';
+
+    /**
+     * Default callback function for exception responses.
+     *
+     * The HTTP status comes from the exception's code only when it is an
+     * integer in the 400-599 range; anything else (0, arbitrary codes, the
+     * SQLSTATE string carried by PDOException) answers 500. The body is
+     * negotiated from the request's Accept header: JSON when the client asks
+     * for application/json, plain text otherwise. The trace is serialized
+     * from getTraceAsString() because json_encode() of a Throwable yields an
+     * empty object: its properties are protected.
+     *
+     * @param \Throwable $exception
+     *
+     * @return void
+     */
+    public static function defaultException(\Throwable $exception): void
+    {
+        $code = $exception->getCode();
+        http_response_code(is_int($code) && $code >= 400 && $code <= 599 ? $code : 500);
+
+        $accept = $_SERVER['HTTP_ACCEPT'] ?? '';
+
+        if (str_contains($accept, 'application/json')) {
+            header('Content-Type: application/json');
+            print(json_encode([
+                'error'     => $exception->getMessage(),
+                'exception' => get_class($exception),
+                'file'      => $exception->getFile(),
+                'line'      => $exception->getLine(),
+                'trace'     => explode(PHP_EOL, $exception->getTraceAsString()),
+            ]));
+
+            return;
+        }
+
+        print($exception->getMessage() . PHP_EOL . $exception->getTraceAsString());
+    }
+
     /**
      * __construct
      */
@@ -124,7 +184,6 @@ class Router
     public static function redirect(string $path): void
     {
         header('Location: ' . static::basePath() . ltrim($path, '/'));
-        exit;
     }
 
     /**
@@ -132,7 +191,7 @@ class Router
      * Only one middleware can be added at a time.
      *
      * @param callable $callback
-     * @param int      $priority Optional priority for the middleware execution order.
+     * @param int|null $priority Optional priority for the middleware execution order.
      *
      * @return static
      *                Returns the current instance.
@@ -163,6 +222,28 @@ class Router
         return new static();
     }
 
+    /**
+     * Temporarily applies a set of middlewares to routes defined within a given callback.
+     * The middlewares are only active for the duration of the callback execution
+     * and are reset afterwards.
+     *
+     * @param callable $middleware
+     * @param callable $callback
+     *
+     * @return static
+     */
+    public static function withMiddleware(callable $middleware, callable $callback): static
+    {
+        $currentMiddlewares = static::$withMiddlewares;
+        array_unshift(static::$withMiddlewares, $middleware);
+
+        $callback();
+
+        static::$withMiddlewares = $currentMiddlewares; // Restore withMiddleware
+
+        return new static();
+    }
+
     /**
      * Reconfigures the final callback of the last route.
      *
@@ -222,6 +303,11 @@ class Router
 
         static::$$method[] = static::parse($path, $callback);
         static::$last = [$method, count(static::$$method) - 1];
+
+        foreach (static::$withMiddlewares as $middleware) {
+            static::middleware($middleware);
+        }
+
         return new static();
     }
 
@@ -324,12 +410,19 @@ class Router
     /**
      * Applies the route configuration.
      *
+     * This method is the framework's error boundary: any \Throwable thrown
+     * while running the matched route's callback chain, while printing the
+     * returned data, or while resolving the not-found callback is caught
+     * here and rendered through $exceptionCallback. A failing handler is
+     * deliberately left uncaught (double failure falls back to PHP itself).
+     *
      * @param string|null $path (optional) Path to use. If not defined, it detects the current path.
      *
      * @return void
      */
     public static function apply(?string $path = null): void
     {
+        try {
             $path    = $path ?? static::currentPath();
             $routers = match ($_SERVER['REQUEST_METHOD']) { // Selects an array of routers based on the method
                 'POST'   => static::$post,
@@ -345,9 +438,10 @@ class Router
 
                     // Checking and storing the variable parameters of the route
                     if (isset($matches[1])) {
+                        static::$params = new Neuron();
                         foreach ($matches as $index => $match) {
                             $paramName = $router['paramNames'][$index - 1];
-                        static::$currentParams[$paramName] = urldecode($match[0]);
+                            static::$params->{$paramName} = urldecode($match[0]);
                         }
                     }
 
@@ -368,5 +462,8 @@ class Router
 
             // If no router matches, call $notFoundCallBack
             Synapsis::resolve(static::$notFoundCallback);
+        } catch (\Throwable $exception) {
+            Synapsis::resolve(static::$exceptionCallback, ['exception' => $exception]);
+        }
     }
 }

src/Libs/Synapsis.php

@@ -66,11 +66,13 @@ class Synapsis
      * Resolves and injects dependencies for a callable and returns its result.
      *
      * @param callable             $action
+     * @param array<string, mixed> $named  Associative array of values injected into the callable's
+     *                                     parameters by exact name match. Consumed in resolveParameterValues().
      *
      * @return mixed
      * @throws Exception If an unhandled callable type is provided.
      */
-    public static function resolve(callable $action): mixed
+    public static function resolve(callable $action, array $named = []): mixed
     {
         if ($action instanceof Closure) { // If it's an anonymous function
             $reflectionCallback = new ReflectionFunction($action);
@@ -90,7 +92,7 @@ class Synapsis
         // Get the parameters
         return call_user_func_array(
             $action,
-            static::resolveParameterValues($reflectionCallback->getParameters())
+            static::resolveParameterValues($reflectionCallback->getParameters(), $named)
         );
     }
 
@@ -132,14 +134,27 @@ class Synapsis
      * Resolves parameter values by injecting dependencies.
      *
      * @param array<ReflectionParameter> $parameters
+     * @param array<string, mixed> $named
+     *                                   Values injected into parameters whose name matches the key,
+     *                                   taking precedence over optional defaults and DI resolution.
+     *                                   Keys matching no parameter are ignored.
      *
      * @return array<mixed>
      * @throws Exception    If a primitive parameter does not have a default value.
      */
-    public static function resolveParameterValues(array $parameters): array
+    public static function resolveParameterValues(array $parameters, array $named = []): array
     {
         $values = [];
         foreach ($parameters as $parameter) {
+            if ($parameter->isVariadic()) { // Skip variatic parameters
+                continue;
+            }
+
+            if (array_key_exists($parameter->getName(), $named)) { // Named values win over defaults and DI
+                $values[] = $named[$parameter->getName()];
+                continue;
+            }
+
             if ($parameter->isOptional()) { // Always use the default value first
                 $values[] = $parameter->getDefaultValue();
                 continue;
@@ -148,7 +163,9 @@ class Synapsis
             $paramType = $parameter->getType();
             if ($paramType === null) {
                 // If no type is declared, and it's not optional, we cannot resolve it.
-                throw new Exception('Untyped parameters expect at least a default value or must be optional.');
+                throw new Exception(
+                    "Untyped parameter '{$parameter}' expect at least a default value or must be optional."
+                );
             }
 
             if ($paramType->isBuiltin()) {