Sequelize with Singleton - node.js

Question

I'm working with Sequelize in node.js and the idea is to use the Singleton pattern.
Reading about how node works with the modules caching and some singleton examples
My file in this moment is:
const DBManager = (function () {
// Instance stores a reference to the Singleton
let instance: any;
let db: string = null;
let user: string;
let password: string;
let host: string;
let sequelize: Sequelize.Sequelize;
function init(bdName: string) {
db = bdName;
user = process.env.MYSQL_DB_USERNAME || 'root';
password = process.env.MYSQL_DB_PASSWORD || 'root';
host = process.env.MYSQL_DB_HOST || 'localhost';
return {
open: () => {
sequelize = new Sequelize(db, user, password, {
host: host,
dialect: 'mysql',
pool: {
max: 5,
min: 0,
acquire: 30000,
idle: 10000
},
operatorsAliases: false,
logging: !process.env.HIDE_LOGS
});
},
testConnection: () => {
return sequelize.authenticate();
},
getManagerObject: () => {
return sequelize;
},
close: () => {
sequelize.close();
}
};
}
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: (bd?: string) => {
if (!instance) {
instance = init(bd);
}
return instance;
}
};
})();
export default DBManager;
So, as expected when i require this file anywhere in my project the references are the same and works as expected.
I'm not sure if this is the right way to implement the Singleton pattern, or if there is a defined and documented one, because the oficial documentation does not say anything about this.

Answer 1

There's usually no need for explicit singleton implementation. JS modules (CommonJS and ES modules in particular) are evaluated only once under normal circumstances, exported class instance is efficiently a singleton.
There's no need for IIFE as well because modules have their own scopes. Since init function isn't reused, there's possibly no need for it either. It can be simplified to:
export default {
open: ...
testConnection: ...
...
};
This abstraction isn't practical. There's already sequelize instance, creating wrapper methods for its own methods doesn't serve a good purpose.
Since a connection is usable after it's established, it makes sense to just export a promise of a connection, similarly to the one that is shown in this answer.
If the configuration (database name) is available in database manager module, it's preferable to just use it in-place:
// db.js
const dbName = someConfig.db;
const sequelize = new Sequelize(dbName, ...);
export default sequelize.authenticate().then(() => sequelize);
Which is used like:
import dbConnection from './db';
dbConnection.then(sequelize => { /* all code that depends on the connection */ });
If there may be several connections, or the configuration isn't available on import, factory function is exported instead:
// db.js
export default dbName => {
const sequelize = new Sequelize(dbName, ...);
sequelize.authenticate().then(() => sequelize);
}
Singleton instances are naturally handled with modules:
// foo-db.js
import getDbConnection from './db';
export default getFooDbName().then(dbName => getDbConnection(dbName));
And used like:
import dbConnection from './foo-db';
dbConnection.then(sequelize => { /* all code that depends on the connection */ });