Em vez de fazer o bind, poderia fazer a conection receber o close ?

Teria sim. Você estaria voltado o método original para connection.close e o programador poderia fechar sua aplicação através da conexão. É tudo o que não queremos :)

No caso, logo em seguida a conexão receberia "null". Posteriormente, quando o usuário pedisse uma nova conexão, ela seria recriada, e o método close novamente sobrecarregado.

Não seria o suficiente para evitar as chamadas diretas ao close ?

Faça um teste :) Mas você consegue perceber que esta executando uma série de instruções sem necessidade?

E o close? Você precisará limpá-lo também.

No seu código você já fez

close = connection.close.bind(connection);

Seu close já esta ligado ao connection.

Então, quando você propõe

connection.close = close;

É um código redundante. Pegou a ideia? Para que você quer voltar o close que já esta ligado a connection para o próprio connection.close. Eu teria dificuldade em entender a sua intenção.

E no seu exemplo:

static closeConnection() {

    if(connection) {
        connection.close = close;
    connection.close();
        connection = null;
    }
}

O close continua na memória. Nada impede de alguém tentar acessá-lo indevidamente.

Professor, colo o meu código todo. Pra mim funcionou.

A minha dúvida é em relação a quebra de algum padrão. No caso, dessa forma que eu fiz, seria possível mesmo assim chamar o método close indevidamente?

Att

var ConnectionFactory = (function () {

    const stores = ['negociacoes'];
    const version = 4;
    const dbName = 'aluraframe';

    var connection = null;

    var close = null;

    return class ConnectionFactory {

        constructor() {

            throw new Error('Não é possível criar instâncias de ConnectionFactory');
        }

        static getConnection() {

            return new Promise((resolve, reject) => {

                let openRequest = window.indexedDB.open(dbName, version);

                openRequest.onupgradeneeded = e => {

                    ConnectionFactory._createStores(e.target.result);

                };

                openRequest.onsuccess = e => {

                    if(!connection) {
                        connection = e.target.result;
                        //close = connection.close.bind(connection);
                        close = connection.close;
                        connection.close = function() {
                            throw new Error('Você não pode fechar diretamente a conexão');
                        };
                    }
                    resolve(connection);

                };

                openRequest.onerror = e => {

                    console.log(e.target.error);

                    reject(e.target.error.name);
                };

            });
        }

        static _createStores(connection) {

            stores.forEach(store => {

                if (connection.objectStoreNames.contains(store)) connection.deleteObjectStore(store);
                connection.createObjectStore(store, { autoIncrement: true});

            });

        }

        static closeConnection() {

            if(connection) {
                connection.close = close;
                connection.close();
                //close();
                connection = null;
                close = null;
            }
        }
    }


})();

Seu código funciona mas confunde quem lê. Veja...vc está voltando o close para um objeto connection para depois fazer close. Não faz sentido porque o close já fecha a connection. Está redundante e quem lê o código fica se perguntando o motivo pelo qual você fez connection.close = close. Pegou a ideia?