Sequelize not closing connections when using AWS Lambdas - aws-lambda

Question

I'm having an issue where despite replicating the pattern for using Sequelize in AWS Lambdas as described in the docs here: https://sequelize.org/docs/v6/other-topics/aws-lambda/ - the connections are still kept for 10+ minutes even though they are idle.
Here's my Sequelize class, that lives inside the DB package in a private CodeArtifact repo.
const { Sequelize, DataTypes } = require("sequelize");
const fs = require('fs');
const path = require('path');
const basename = path.basename(__filename);
let modelsMap = new Map();
let sequelize = null;
module.exports = class SequelizeClient {
constructor() {}
static async getSequelize(configuration, options){
if(!sequelize){
console.log('load sequelize');
sequelize = await SequelizeClient.#loadSequelize(configuration, options)
} else {
sequelize.connectionManager.initPools();
// restore `getConnection()` if it has been overwritten by `close()`
if (sequelize.connectionManager.hasOwnProperty("getConnection")) {
delete sequelize.connectionManager.getConnection;
}
}
return sequelize;
}
static #initSequelize(options) {
return new Sequelize(
options.database,
options.user,
options.password,
{
host: options.host,
port: parseInt(options.port) || 5432,
logging: console.log,
dialect: "postgres",
pool: {
max: 2,
min: 0,
idle: 1000,
acquire: 3000,
evict: 1000
}
},
);
}
static async #loadSequelize(configuration) {
sequelize = SequelizeClient.#initSequelize(configuration);
await sequelize.authenticate();
return sequelize;
}
static async getModels(sequelize) {
const databaseName = sequelize.config.database;
let models = modelsMap.get(databaseName);
if(models){
return models;
}
models = {};
console.log('load models');
fs
.readdirSync(`${__dirname}/models`)
.filter((file) => file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js')
.forEach((file) => {
const model = require(path.join(`${__dirname}/models`, file))(sequelize, DataTypes);
const name = model.name.charAt(0).toUpperCase() + model.name.slice(1);
models[name] = model;
});
Object.keys(models).forEach((modelName) => {
if (models[modelName].associate) {
models[modelName].associate(models);
}
});
modelsMap.set(databaseName, models);
return models;
}
async static closeConnections(){
await sequelize.connectionManager.close();
}
}
And here's how I use this code inside a Lambda.
const { SequelizeClient } = require("#myPrivatePackage/database");
exports.handler = async (event) => {
try {
const sequelize = await SequelizeClient.getSequelize(someDbParams);
const { MyModel } = await SequelizeClient.getModels(sequelize);
return await MyModel.findOne(whereObj);
} finally {
SequelizeClient.closeConnections();
}
};
Obviously, I cleaned up the code to remove things that are not directly impacting the issue, such as specific queries, code that I'd like to avoid being public etc.
Based on the info I gathered online I'd assume that the connections would be closed once the query is done, but checking pgsql with this
SELECT pid, now() - query_start as duration, query
FROM pg_stat_activity
WHERE pid <> pg_backend_pid()
AND datname = 'db_name'
order by duration desc;
Shows a lot of queries that have duration in excess of 5-10min. Eventually, after around 15min the connections go away.
Any idea as to what I'm doing wrong? Or missing? Or fundamently not understanding when it comes to these concepts? I've been scratching my head for a few days now.