refactor(model): Use match expression for PDO type detection

src/Libs/Model.php

@@ -23,11 +23,6 @@ use ReflectionProperty;
 #[AllowDynamicProperties]
 class Model
 {
-    /**
-     * @var array Attributes that should be set to NULL on update.
-     */
-    protected array $dbSetToNull = [];
-
     /**
      * @var string The name of the primary key column.
      */
@@ -161,7 +156,19 @@ class Model
 
         try {
             $prepared = $db->prepare($query);
-            $prepared->execute(static::$dbQueryVariables);
+            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();
@@ -293,25 +300,16 @@ class Model
         $instance   = new $class();
         $reflection = new ReflectionClass($instance);
         $properties = $reflection->getProperties();
-        $propertyNames = array_map(function ($property) {
-            return static::camelCaseToSnakeCase($property->name);
-        }, $properties);
+
+        $map = [];
+        foreach ($properties as $prop) {
+            $map[static::camelCaseToSnakeCase($prop->name)] = $prop;
+        }
 
         foreach ($elem as $key => $value) {
-            $index = array_search($key, $propertyNames);
-            if (is_numeric($index)) {
-                $type = $properties[$index]->getType();
-                if (enum_exists($type->getName())) {
-                    if (method_exists($type->getName(), 'tryFrom')) {
-                        $instance->{$properties[$index]->name} = $type->getName()::tryfrom($value);
-                    } elseif (
-                        in_array($value, array_column($type->getName()::cases(), 'name'))
-                    ) {
-                        $instance->{$properties[$index]->name} = $type->getName()::{$value};
-                    }
-                } else {
-                    $instance->{$properties[$index]->name} =  $value;
-                }
+            if (isset($map[$key])) {
+                $property = $map[$key];
+                $instance->{$property->name} = static::castValue($property, $value);
             } else {
                 $instance->{static::snakeCaseToCamelCase($key)} = $value;
             }
@@ -322,6 +320,32 @@ class Model
         return $instance;
     }
 
+    /**
+     * Handles type casting for properties, especially for Enums.
+     *
+     * @param ReflectionProperty $property
+     * @param mixed              $value
+     *
+     * @return mixed
+     */
+    protected static function castValue(ReflectionProperty $property, mixed $value): mixed
+    {
+        $type = $property->getType();
+        if (!$type || !enum_exists($typeName = $type->getName())) {
+            return $value;
+        }
+
+        if (method_exists($typeName, 'tryFrom')) {
+            return $typeName::tryFrom($value);
+        }
+
+        if (in_array($value, array_column($typeName::cases(), 'name'))) {
+            return $typeName::{$value};
+        }
+
+        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,
@@ -337,30 +361,39 @@ class Model
         $result     = [];
 
         foreach ($properties as $property) {
+            // Avoid save unset variables
+            if ($property->getType() && !$property->isInitialized($this)) {
+                continue;
+            }
+
             if (!in_array($property->name, static::$dbIgnoreSave)) {
-                $result[$this->camelCaseToSnakeCase($property->name)] = isset($this->{$property->name})
-                    ? $this->{$property->name} : null;
+                $name = $this->camelCaseToSnakeCase($property->name);
+                $result[$name] = $this->castToDbValue($this->{$property->name});
             }
         }
 
         foreach (static::$dbForceSave as $value) {
-            $result[$value] = isset($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;
-            }
+            $result[$value] = $this->castToDbValue($this->$value);
         }
 
         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;
+        }
+
+        return $value;
+    }
+
     /**
      * Returns the name of the current class, even if it's an extended class.
      *
@@ -432,25 +465,22 @@ class Model
         $atts = $this->getVars();
         static::$dbQueryVariables = [];
 
+        $set = [];
         foreach ($atts as $key => $value) {
-            if (isset($value)) {
-                if (in_array($key, $this->dbSetToNull)) {
-                    $set[] = "$key=NULL";
-                } else {
+            if ($value !== null) {
                 $set[] = "$key=:$key";
                 static::$dbQueryVariables[':' . $key] = $value;
-                }
             } else {
-                if (in_array($key, $this->dbSetToNull)) {
                 $set[] = "$key=NULL";
             }
         }
-        }
 
         $table = static::table();
         $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);
     }
 
@@ -1145,22 +1175,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->dbSetToNull)) {
-                $this->dbSetToNull[] = $att;
-            }
-        }
-    }
 }