Un pool de conexiones es un conjunto limitado de conexiones a una base de datos, que es manejado por un servidor de aplicaciones de forma tal, que dichas conexiones pueden ser reutilizadas por los diferentes usuarios.

¿Cómo se mejora la conexión a PostgreSQL en Node.js?
En el mundo del desarrollo web, gestionar eficientemente las conexiones a la base de datos es crucial para el rendimiento de las aplicaciones. Al trabajar con PostgreSQL en Node.js, es importante optimizar la forma en que las conexiones son manejadas para evitar la creación innecesaria de múltiples conexiones al servidor de base de datos. Esto se puede lograr mediante el uso de un mecanismo conocido como 'pooling', que permite a una aplicación web compartir conexiones existentes, en vez de abrir una nueva para cada solicitud.
¿Qué es el Connection Pooling y por qué es una buena práctica?
El 'Connection Pooling' es una técnica que permite que una aplicación web maneje eficientemente las conexiones a una base de datos, reutilizando una conexión existente en lugar de crear una nueva cada vez que se necesita. Esto es particularmente beneficioso para aplicaciones que reciben muchas solicitudes, ya que:
¿Cómo implementar el Connection Pooling en aplicaciones Node.js?
A continuación se describen los pasos para implementar 'pooling' de conexiones en Node.js utilizando el driver de PostgreSQL:
Instalación del módulo 'pg': Asegúrate de tener instalado el módulo pg, que es el cliente oficial de PostgreSQL para Node.js. Si no está instalado, utiliza:
npm install pg
Configuración del Pool: En el archivo de conexión a PostgreSQL, se debe establecer un pool en lugar de crear una nueva conexión cada vez:
const { Pool } = require('pg'); const pool = new Pool({ user: 'nombre_usuario', host: 'localhost', database: 'nombre_base_datos', password: 'contraseña', port: 5432, }); module.exports = pool;
Uso del Pool en Servicios: En cualquier servicio que necesite conexión a la base de datos, importa el pool de conexiones:
const pool = require('./ruta/al/archivo/de/conexion'); // Ejemplo de consulta a la base de datos async function obtenerDatos() { try { const { rows } = await pool.query('SELECT * FROM tabla'); return rows; } catch (error) { console.error('Error ejecutando query', error); throw error; } }
Manejo de Errores: Es recomendable escuchar eventos de error en las conexiones de pool para manejar cualquier problema que surja:
pool.on('error', (err, client) => { console.error('Error inesperado en idle client', err); process.exit(-1); });
¿Qué beneficios trae aplicar el Connection Pooling a tu proyecto?
Implementar un pool de conexiones a través de Node.js y PostgreSQL ofrece varios beneficios que se reflejan positivamente en el rendimiento de tu aplicación:
Invitamos a los desarrolladores a aplicar este enfoque en sus aplicaciones para mejorar su rendimiento y a experimentar por sí mismos los beneficios de un manejo eficiente de conexiones.
En el mundo del desarrollo web, gestionar eficientemente las conexiones a la base de datos es crucial para el rendimiento de las aplicaciones. Al trabajar con PostgreSQL en Node.js, es importante optimizar la forma en que las conexiones son manejadas para evitar la creación innecesaria de múltiples conexiones al servidor de base de datos. Esto se puede lograr mediante el uso de un mecanismo conocido como 'pooling', que permite a una aplicación web compartir conexiones existentes, en vez de abrir una nueva para cada solicitud.
El 'Connection Pooling' es una técnica que permite que una aplicación web maneje eficientemente las conexiones a una base de datos, reutilizando una conexión existente en lugar de crear una nueva cada vez que se necesita. Esto es particularmente beneficioso para aplicaciones que reciben muchas solicitudes, ya que:
A continuación se describen los pasos para implementar 'pooling' de conexiones en Node.js utilizando el driver de PostgreSQL:
Instalación del módulo 'pg': Asegúrate de tener instalado el módulo pg, que es el cliente oficial de PostgreSQL para Node.js. Si no está instalado, utiliza:
npm install pg
Configuración del Pool: En el archivo de conexión a PostgreSQL, se debe establecer un pool en lugar de crear una nueva conexión cada vez:
const { Pool } = require('pg');
const pool = new Pool({
user: 'nombre_usuario',
host: 'localhost',
database: 'nombre_base_datos',
password: 'contraseña',
port: 5432,
});
module.exports = pool;
Uso del Pool en Servicios: En cualquier servicio que necesite conexión a la base de datos, importa el pool de conexiones:
const pool = require('./ruta/al/archivo/de/conexion');
// Ejemplo de consulta a la base de datos
async function obtenerDatos() {
try {
const { rows } = await pool.query('SELECT * FROM tabla');
return rows;
} catch (error) {
console.error('Error ejecutando query', error);
throw error;
}
}
Manejo de Errores: Es recomendable escuchar eventos de error en las conexiones de pool para manejar cualquier problema que surja:
pool.on('error', (err, client) => {
console.error('Error inesperado en idle client', err);
process.exit(-1);
});
Implementar un pool de conexiones a través de Node.js y PostgreSQL ofrece varios beneficios que se reflejan positivamente en el rendimiento de tu aplicación:
Invitamos a los desarrolladores a aplicar este enfoque en sus aplicaciones para mejorar su rendimiento y a experimentar por sí mismos los beneficios de un manejo eficiente de conexiones.
Un pool de conexiones es un conjunto limitado de conexiones a una base de datos, que es manejado por un servidor de aplicaciones de forma tal, que dichas conexiones pueden ser reutilizadas por los diferentes usuarios.

Manejando un Pool de conexiones
Hay un problema con getConnection. El problema es que cada vez que llamamos a getConnection, lo que hacemos internamente en el codigo es llamar y llamar y llamar, es decir hacer request continuamentes, eso esta mal porque puede sobrecargar el servidor de request. Entonces, esto es un problema porque por cada request se crea una negociacion con la db, se tarda 20ms o mas, y asi vamos saturando el servidor. La solucion es usar pool.
Sin un pool, yo deberia cerrar las conexiones manuelament.e
Que es un pool? Un pool de conexiones es un conjunto limitado de conexiones a una base de datos, que es manejado por un servidor de aplicaciones de forma tal, que dichas conexiones pueden ser reutilizadas por los diferentes usuarios. Un pool optimiza
Lo que hace el pool es sencillamente es ser un mediador entre las bases de datos y el cliente. Entonces a medida que los clientes empiecen a hacer consultas, la aplicacion de manera asincrona conectara con el pool y el pool se encargara tanto de abrir o cerrar conexiones para que la informacion siga trabajando de manera eficiente. Pero un pool es mucho mas inteligente que eso, ya que permite REUTILIZAR DATA QUE OTROS CLIENTES YA ACCEDIERON, CLARO SIEMPRE Y CUANDO LA DATA A REUTILIZAR SEA LA MISMA QUE ESOS CLIENTES NECESITABAN , y a su vez lograremos que los servidores no se saturen y nuestra app en el background trabajara con las consultas, y asi evitara un problema en el proceso.
Comparto mi código para el create, delete y update para las categorías.

Documentación https://node-postgres.com/features/pooling
users.service.js
const boom = require('@hapi/boom');
const pool = require('../libs/postgres.pool');
const getConnection = require('../libs/postgres');
class UserService {
constructor() {
this.users = [];
this.pool = pool;
this.pool.on('error', (err) => console.error(err));
}
async create(data) {
return data;
}
async find() {
const query = 'SELECT * FROM tasks';
const rta = await this.pool.query(query);
return rta.rows;
}
async findOne(id) {
return { id };
}
async update(id, changes) {
return {
id,
changes,
};
}
async delete(id) {
return { id };
}
}
module.exports = UserService;
Ese pool es básicamente un singleton
la verdad en este curso en específico estoy teniendo muchos problemas con el código, estoy recibiendo errores como this.pool.query(query);
Use un patron singleton para asegurarme de solo usar una instancia de la conexion al pool
import { Pool as PostgresClient } from 'pg';
export default class PostgressPool {
private static connection: PostgresClient | null = null;
private constructor() {}
public static getInstance(): PostgresClient {
if (!PostgressPool.connection) {
PostgressPool.connection = new PostgresClient({
host: 'localhost',
port: 5432,
user: 'root',
password: 'root',
database: 'my_store'
});
console.log('Connected successfully');
}
return PostgressPool.connection;
}
public async query(request: string) {
try {
const db = PostgressPool.getInstance();
return await db.query(request);
} catch (error) {
console.log(error);
}
}
}
como se puede tener motor de inyeccion de dependencia en express?
Mi resumen!
Ahora,mostrare como el codigo ha cambiado:
//libs/postgres.pool.js
const { Pool } = require('pg');
const pool = new Pool({
host: 'localhost',
port: 5432,
user: 'nico',
password: 'admin123',
database: 'my_store'
});
//Fijate que el codigo ha cambiado, ahora el trabajar con el driver pg no se basa en ser una funcion, sino mas bien un objeto. y desde aca empezamos a trabajar con pool, fijate las variables... Ahora tambien se puede aprecier que el codigo es mas simple.
module.exports = pool;
// services/product.service.js
//En este archivo elimine unas lineas de codigo para que sea mas facil de entender y asi no ver todo el codigo que no importa
class ProductsService {
constructor(){
this.products = [];
this.generate();
**this.pool = pool
this.pool.on('error', (err) => console.error(err)) //1)**
}
async find() {
const query = 'SELECT * FROM tasks'
const rta = await this.pool.query(query);
return rta.rows; //2) Accedemos a pool y especifcamente le passamos el query que este metodo necesita
}
Por lo tanto, lo que podemos entender es que: la class ProductService crea un canal con el servidor con el mediador pool. Y cada servicio dentro de la clase genera su consulta adecuada. Por lo tanto, Otro archivo como no se... category.service, accedera a pool y abrira otro canal y accedera con su servicios por otro canal.