SmoothDB.php

<?php
class Database
{
    private mysqli $conn;

    // Connection variables
    public function __construct(
        string $host,
        string $db,
        string $user,
        string $pass
    ) {
        try {
            // Connection to the database
            $this->conn = new mysqli(
                hostname: $host,
                database: $db,
                username: $user,
                password: $pass
            );

            // Error handle upon failing to connect
            if ($this->conn->connect_error) {
                throw new Exception("Connection failed: " . $this->conn->connect_error);
            }
        } catch (Exception $error) {
            // Catches the exception I threw earlier
            echo $error->getMessage();
            exit();
        }
    }

    // Insertion function to the database
    public function insert(
        string $table,
        array $data

    ): void {
        // Checks if data is empty or not an array, otherwise returns false
        if (empty($data)) {
            echo "Data is empty";
            return;
        }

        // Keys & Values of our db (Btw, in case you're curious: implode joins array elements into a string, like a comma in this case)
        $columns = implode(", ", array_keys($data));
        $placeHolder = implode(", ", array_fill(0, count($data), '?'));
        $values = array_values($data);

        // Since the class has to be dynamic, I have to check 
        // what type each value is and avoid assuming
        $types = "";
        foreach ($values as $i => $value) {
            switch (gettype($value)) {
                case "integer":
                    $types .= "i";
                    break;

                // Will detect and convert both float & double to type 'd'
                case "float":
                case "double":
                    $types .= "d";
                    break;

                case "string":
                    $types .= "s";
                    break;
                case "boolean":
                    $types .= "i";
                    break;
                default:
                    $types .= "s";
                    break;
            }

            // Converts boolean aka "True / False" Into their TINYINT
            if (is_bool($value)) $values[$i] = $value ? 1 : 0;
        }

        try {

            // Base Query
            $query = "INSERT INTO $table ($columns) VALUES ($placeHolder)";

            // Prepared statement
            $stmt = $this->conn->prepare($query);

            // Error checking if the statement failed to prepare
            if (!$stmt) throw new Exception("Failed to prepare insert statement: " . $this->conn->error);

            // bind, execute, and close the statement
            $stmt->bind_param($types, ...$values);

            // Error checking if the statement failed to execute
            if (!$stmt->execute()) throw new Exception("Failed to execute insert statement: " . $stmt->error);

            // Closing connection
            $stmt->close();
        } catch (Exception $error) {
            echo "<h1>Database Insertion Error</h1> " . $error->getMessage();
            exit();
        }
    }

    // Won't re-comment similar code (prepared statements, binding, executing etc)
    public function fetch(
        string $table,
        string $columns = "*",
        string $item = "",
        array $params = []

    ): array {
        try {
            $query = "SELECT $columns FROM $table";

            if (!empty($item)) {
                $query .= " WHERE $item";
            }

            $stmt = $this->conn->prepare($query);
            if (!$stmt) throw new Exception("Failed to prepare fetch statement statement: " . $this->conn->error);

            if (!empty($params)) {
                $types = "";
                foreach ($params as &$param) {
                    switch (gettype($param)) {
                        case "integer":
                            $types .= "i";
                            break;
                        case "float":
                        case "double":
                            $types .= "d";
                            break;
                        case "string":
                            $types .= "s";
                            break;
                        case "boolean":
                            $types .= "i";
                            $param = $param ? 1 : 0;
                            break;
                        default:
                            $types .= "s";
                            break;
                    }
                }
                $stmt->bind_param($types, ...$params);
            }

            if (!$stmt->execute()) throw new Exception("Failed to execute fetch statement: " . $stmt->error);

            // Now to get results
            $result = $stmt->get_result();
            $data = $result->fetch_all(MYSQLI_ASSOC);

            $stmt->close();
            return $data;
        } catch (Exception $error) {
            echo "Fetch Error: " . $error->getMessage();
            return [];
        }
    }

    // Start updating
    public function update(
        string $table,
        array $columns = [],
        string $condition,
        string $param
    ) {
        try {
            // Query of MYSQL to update existing row
            $query = "UPDATE $table SET $columns WHERE $condition";
            $stmt = $this->conn->prepare($query);

            if (!$stmt) throw new Exception("Failed to prepare update statement");

            if (!empty($params)) {
                $types = "";
                foreach ($params as &$param) {
                    switch (gettype($param)) {
                        case "integer":
                            $types .= "i";
                            break;
                        case "float":
                        case "double":
                            $types .= "d";
                            break;
                        case "string":
                            $types .= "s";
                            break;
                        case "boolean":
                            $types .= "i";
                            $param = $param ? 1 : 0;
                            break;
                        default:
                            $types .= "s";
                            break;
                    }
                }
                $stmt->bind_param($types, ...$params);

                if (!$stmt->execute()) throw new Exception("Couldn't exectue update statement");

                $stmt->close();
            }
        } catch (Exception $error) {
            echo "Update Error:" . $error->getMessage();
            exit();
        }   
    }

    public function delete(
        string $table,
        string $item,
        string $operator,
        array $params = []
    ) {
        try {
            $query = "DELETE FROM $table WHERE $item $operator ?";
            $stmt = $this->conn->prepare($query);

            if (!$stmt) throw new Exception("Failed to prepare delete statement" . $this->conn->error);

            if (!empty($params)) {
                $types = str_repeat("s", count($params));
                $stmt->bind_param($types, ...$params);
            }

            if (!$stmt->execute()) throw new Exception("Failed to execute delete statement" . $stmt->error);

            $stmt->close();
        } catch (Exception $error) {
            echo "Deletion Error:" . $error->getMessage();
            exit();
        }
    }
}