Simple wrapper for PHP mysqli connection

Error reporting

This is much better than your initial attempt, but somehow it become more verbose and I'll tell you why: you are, so to say, abused the error reporting. mysqli_sql_exception is not intended to be thrown manually. Like it's said in the article I gave you link to, mysqli can throw exceptions by itself - so just let mysqli to do it. And therefore there is no reason to check for errors manually, and it will greatly reduce the amount of repeated code.

Automatic binding

Your automated binding function is rather confusing. Apparently you didn't have any clear idea what this code is intended to do:

                else
                {
                    $types .= 'b';
                }

And I'll tell you - there is no good scenario for it.
Don't write a code just in case, when you just don't know what to write. In such circumstances just don't write any code at all.

Besides, I am scared by functions like this that sniff a type off a variable automatically. If you will have a query that will compare a string stored in a database to a number, the consequences would be fatal. And PHP is known for converting strings to numbers on its own will. So, although quite small, but there is still a possibility that your binding function will ruin your database.

That's why I prefer either a manual explicit type setting or just blunt setting a string type for all variables. At least it won't harm anyone.

In practice it means that I recommend to use string type for all parameters by default, with a possibility of a fallback with manual type setting. So, taken from ny other article, the mysqli binding function would be like

public function execute(string $sql, $params = [], $types = '') : mysqli_stmt
{
    if (!$params) {
        return $this->connection->query($sql);
    }
    $types = $types ?: str_repeat("s", count($params));
    $statement = $this->connection->prepare($sql);
    $statement->bind_param($types, ...$params);
    $stmt->execute();
    return $stmt;
}

this function does a lot of good stuff:

• it lets you to run a query that doesn't support prepared statements

• it does no harm automatically sniffing the variable's type

• at the same time it lets you to provide a type string manually, like

    $conn->execute('INSERT INTO songs VALUES (?, ?, ?)', ['foo', 'bar', 1], "ssi");
  

I also removed an argument unpacking operator from the function definition as it makes no sense. Trust me, it takes no effort to add two square brackets around parameters, but it makes your code WAY cleaner and more maintainable.

Closing statements

PHP is incredibly programmer-friendly. Resources don't have to be closed manually, they will be closed automatically when no longer needed.

The code

<?php

final class MySQLiConnection
{
    public $connection;

    public function __construct($config)
    {
        mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);
        try {
            $this->connection = new mysqli('localhost', 'id', 'password', 'database');
            $this->connection->set_charset('utf8');
        } catch (\mysqli_sql_exception $e) {
            throw new \mysqli_sql_exception($e->getMessage(), $e->getCode());
        }
    }

    public function execute(string $sql, $params = [], $types = '') : mysqli_stmt
    {
        if (!$params) {
            return $this->connection->query($sql);
        }
        $types = $types ?: str_repeat("s", count($params));
        $statement = $this->connection->prepare($sql);
        $statement->bind_param($types, ...$params);
        $statement->execute();
        return $statement;
    }

    public function getResult(string $sql, $params = [], $types = '') : mysqli_result
    {
        return $this->execute($sql, $params, $types)->get_result();
    }
}

As you can see, the final code is much more concise, thanks to code reuse and proper error reporting.

I also made $connection variable public, as there is no more getConnection() function but you will need to access it from outside for sure.

An exception is caught in the constructor because of security concerns. A stack trace for the exception thrown in case of a connection error would contain the database credentials that will end up either in the server logs or - the worst case - displayed on the screen. Once re-thrown this way, credentials are no more exposed. So although as a rule you don't catch an Exception right in place, here it's a special case to take care of.