@minervajs/helmet 1.0.0

package/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, 2025, Alexander Enrique Escobar O.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,231 @@
+# MinervaJS-Helmet
+
+## 🛡️ Descripción
+
+**MinervaJS-Helmet** es el módulo encargado de la **gestión unificada de conexiones y operaciones de base de datos** dentro del ecosistema **MinervaJS**.
+
+Su función principal es abstraer el motor de base de datos (MySQL, PostgreSQL, Oracle, etc.) y exponer una **API homogénea**, permitiendo que el resto del sistema funcione de forma **JSON-driven**, desacoplada y extensible.
+
+---
+
+## 🎯 Objetivos
+
+* Centralizar la gestión de conexiones a bases de datos
+* Soportar múltiples motores de forma transparente
+* Proveer una API común para:
+
+  * Consultas de lectura (SELECT)
+  * Operaciones de escritura (INSERT / UPDATE / DELETE / DDL)
+  * Procedimientos almacenados
+* Facilitar la construcción de backends genéricos y dinámicos
+
+---
+
+## 🧱 Arquitectura
+
+```
+MinervaJS
+ └── Helmet
+     ├── db_mysql.js
+     ├── db_postgres.js
+     ├── db_oracle.js
+     └── connections (cache interno)
+```
+
+Helmet actúa como un **dispatcher**, delegando la ejecución a proveedores específicos que implementan un contrato estándar.
+
+---
+
+## 🔌 Contrato estándar de proveedores
+
+Cada proveedor de base de datos debe implementar las siguientes funciones:
+
+```js
+connect(config)
+query(connection, sql, params = [])
+execute(connection, sql, params = [])
+call(connection, procedureName, params = {})
+close(connection)
+closeAll(config)
+```
+
+Este contrato garantiza que Helmet pueda operar sin conocer los detalles del motor subyacente.
+
+---
+
+## 📦 Instalación
+
+```bash
+npm install @minervajs/helmet
+```
+⚠️ Previous name: minervajs-helmet (deprecated)
+> *(o incluir el módulo directamente dentro del proyecto MinervaJS)*
+
+---
+
+## ⚙️ Configuración de base de datos
+
+Ejemplo de archivo `database.json`:
+
+```json
+{
+  "mysqlMain": {
+    "type": "mysql",
+    "host": "localhost",
+    "port": 3306,
+    "user": "user",
+    "password": "password",
+    "database": "minerva"
+  }
+}
+```
+
+En la instalacion, puedes hacer uso del archivo muestra que esta en *\node_modules\minervajs-helmet\example\settings.js*
+
+---
+
+## 🚀 Uso básico
+
+```js
+const helmet = require('./helmet');
+const config = require('./database.json');
+```
+
+---
+
+### 🔍 Consultas de lectura (SELECT)
+
+```js
+const rows = await helmet.query(
+  'mysqlMain',
+  'SELECT * FROM pais WHERE iso3 = ?',
+  ['SLV'],
+  config
+);
+```
+
+---
+
+### ✏️ Operaciones de escritura
+
+```js
+const result = await helmet.execute(
+  'mysqlMain',
+  'UPDATE pais SET nombre = ? WHERE iso3 = ?',
+  ['El Salvador', 'SLV'],
+  config
+);
+
+console.log(result.rowsAffected);
+```
+
+---
+
+### 🧠 Procedimientos almacenados
+
+```js
+const result = await helmet.call(
+  'mysqlMain',
+  'sp_pais_insert',
+  {
+    p_iso3: 'SLV',
+    p_nombre: 'El Salvador',
+    p_leyenda: 'Centroamérica',
+    p_iso2: 'SV',
+    p_existe: { out: true }
+  },
+  config
+);
+```
+
+**Resultado estándar:**
+
+```js
+{
+  resultSets: [...],
+  out: {
+    p_existe: 0
+  }
+}
+```
+
+---
+
+## 🔐 Gestión de conexiones
+
+* Una conexión por perfil de base de datos
+* Reutilización automática
+* Cache interno
+* Cierre explícito
+
+```js
+await helmet.close('mysqlMain', config);
+await helmet.closeAll(config);
+```
+
+---
+
+## ⚠️ Manejo de errores
+
+Helmet agrega contexto a los errores:
+
+```
+[Helmet][mysql][execute] Duplicate entry
+```
+
+Esto facilita el logging y el diagnóstico.
+
+---
+
+## 🧩 Integración JSON-driven (MinervaJS)
+
+Helmet está diseñado para ejecutarse a partir de manifiestos JSON:
+
+```json
+{
+  "database": "mysqlMain",
+  "procedure": "sp_pais_insert",
+  "params": {
+    "p_iso3": "$body.iso3",
+    "p_nombre": "$body.nombre",
+    "p_existe": { "out": true }
+  }
+}
+```
+
+La API ejecuta la operación sin conocer SQL ni lógica de negocio.
+
+---
+
+## ✅ Buenas prácticas
+
+* Usar `query()` exclusivamente para SELECT
+* Usar `execute()` para DML / DDL
+* Encapsular lógica compleja en Stored Procedures
+* Cerrar conexiones en shutdown de la aplicación
+* Mantener la configuración desacoplada
+
+
+---
+
+## 🔮 Evolución futura
+
+* Pooling de conexiones
+* Transacciones (`begin / commit / rollback`)
+* Multi-tenant
+* Logging estructurado
+* Métricas
+* Soporte para nuevos motores
+
+---
+
+## 📌 Conclusión
+
+**MinervaJS-Helmet** es el pilar de acceso a datos de MinervaJS.
+
+Su diseño modular, homogéneo y desacoplado permite construir aplicaciones dinámicas, escalables y mantenibles, donde la lógica de negocio puede definirse de forma declarativa y evolucionar sin reescribir el backend.
+
+
+
+
+

package/example/settings.js

@@ -0,0 +1,53 @@
+/**
+ * @module 
+ * @name settings
+ * @description Modulo gestor de la coneccion a la base de datos
+ * Configuracion de la Base de Datos
+ *
+ * Se incluye un ejemplo de uso, segun el tipo de base de datos
+ */
+exports.httpMsgFormat = 'HTML';
+exports.Title = "MinervaJS - Helmet";
+exports.Rights_Reserved = "2023-2025 © A&C Consultoría Informática";
+
+module.exports = {
+/*
+ * 'mi_postgres': 
+ * {
+ *   type: 'postgres',
+ *   host: 'localhost o IP',
+ *   port: 5432,
+ *   user: 'usuario',
+ *   password: 'contraseña',
+ *   database: 'nombre_db'
+ * },
+  */
+  'my_mysql': 
+  {
+    type: 'mysql',
+    host: 'sql3.freesqldatabase.com',	// 'localhost',
+    port: 3306,							// 'puerto',
+    user: 'sql3772729',					// 'usuario',
+    password: 'esUA3qpGKD',				// 'contraseña',
+    database: 'sql3772729'				// 'nombre_db'
+  },
+/*  'my_oracle':  {
+ *   type: 'oracle',
+ *   user: 'usuario',
+ *   password: 'contraseña',
+ *	connectString : '(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=namehostoip)(PORT=port))(CONNECT_DATA=(SERVICE_NAME=servicename)))'
+ * },
+ *  'mi_mongodb': {
+ *   type: 'mongodb',
+ *   url: 'mongodb://localhost:27017/nombre_db'
+ * },
+ * 'mi_mariadb': {
+ *   type: 'mariadb',
+ *   host: 'localhost',
+ *   port: 3306,
+ *   user: 'mi_usuario',
+ *   password: 'mi_contraseña',
+ *   database: 'nombre_db'
+ * }
+ */
+};

package/js/db_mariadb.js

@@ -0,0 +1,69 @@
+/**
+ * @module lib/mariadb
+ * @description Módulo para la conexión y operaciones de MariaDB.
+ */
+ 
+ /**
+ * @constant
+ * @type {string}
+ * @default
+ */
+const mariadb = require('mariadb/promise');
+
+/**
+ * Establece una conexión a la base de datos MariaDB.
+ *
+ * @async
+ * @function connect
+ * @param {object} config - Configuración de la conexión.
+ * @returns {Promise<mariadb.Connection>} Objeto de conexión de MariaDB.
+ */
+async function connect(config) {
+  try {
+    const connection = await mariadb.createConnection(config);
+    return connection;
+  } catch (error) {
+    console.error('Error al conectar a MariaDB:', error);
+    throw error;
+  }
+}
+
+/**
+ * Ejecuta una consulta SQL en la base de datos MariaDB.
+ *
+ * @async
+ * @function query
+ * @param {mariadb.Connection} connection - Objeto de conexión de MariaDB.
+ * @param {string} sql - Consulta SQL.
+ * @param {Array} [values] - Parámetros para la consulta.
+ * @returns {Promise<Array>} Filas resultantes de la consulta.
+ */
+async function query(connection, sql, values = []) {
+  try {
+    const rows = await connection.query(sql, values);
+    return rows;
+  } catch (error) {
+    console.error('Error al ejecutar la consulta MariaDB:', error);
+    throw error;
+  }
+}
+
+/**
+ * Cierra la conexión a la base de datos MariaDB.
+ *
+ * @async
+ * @function close
+ * @param {mariadb.Connection} connection - Objeto de conexión de MariaDB.
+ * @returns {Promise<void>}
+ */
+async function close(connection) {
+  try {
+    await connection.end();
+  } catch (error) {
+    console.error('Error al cerrar la conexión MariaDB:', error);
+    throw error;
+  }
+}
+
+module.exports = { connect, query, close };
+

package/js/db_mongodb.js

@@ -0,0 +1,49 @@
+const { MongoClient } = require('mongodb');
+
+/**
+ * @module lib/mongodb
+ * @description Módulo para la conexión y operaciones de MongoDB. Comando: npm install mongodb
+ */
+
+/**
+ * Establece una conexión a la base de datos MongoDB.
+ *
+ * @async
+ * @function connect
+ * @param {object} config - Configuración de la conexión.
+ * @returns {Promise<MongoClient>} Objeto de cliente de MongoDB.
+ */
+async function connect(config) {
+  try {
+    const client = new MongoClient(config.url);
+    await client.connect();
+    return client;
+  } catch (error) {
+    console.error('Error al conectar a MongoDB:', error);
+    throw error;
+  }
+}
+
+
+// query
+// logica
+
+
+/**
+ * Cierra la conexión a la base de datos MongoDB.
+ *
+ * @async
+ * @function close
+ * @param {MongoClient} client - Objeto de cliente de MongoDB.
+ * @returns {Promise<void>}
+ */
+async function close(client) {
+  try {
+    await client.close();
+  } catch (error) {
+    console.error('Error al cerrar la conexión MongoDB:', error);
+    throw error;
+  }
+}
+
+module.exports = { connect, close };

package/js/db_mysql.js

@@ -0,0 +1,162 @@
+/**
+ * @module js/mysql
+ * @name Provider DB js/mysql
+ * @description Módulo proveedor MySQL para MinervaJS-Helmet.
+ * Implementa operaciones estándar: query, execute y call.
+ * 
+ */
+ 
+ /**
+ * @constant
+ * @type {string}
+ * @default
+ */
+const mysql = require('mysql2/promise'); // Usamos mysql2/promise para async/await
+
+/**
+ * Establece una conexión a la base de datos MySQL.
+ *
+ * @async
+ * @function connect
+ * @param {object} config - Configuración de la conexión.
+ * @returns {Promise<mysql.Connection>} Objeto de conexión de MySQL.
+ */
+async function connect(config) 
+{
+  try 
+  {
+    const connection = await mysql.createConnection({
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+    });
+    return connection;
+  } 
+  catch (error) 
+  {
+    console.error('[MySQL][connect]', error.message);
+    throw error; // Re-lanzamos el error para que sea manejado por el llamador
+  }
+}
+
+/**
+ * Ejecuta una consulta SQL en la base de datos MySQL.
+ *
+ * @async
+ * @function query
+ * @param {mysql.Connection} connection - Objeto de conexión de MySQL.
+ * @param {string} sql - Consulta SQL.
+ * @param {Array} [params] - Parámetros para la consulta.
+ * @returns {Promise<Array>} Filas resultantes de la consulta.
+ */
+async function query(connection, sql, params = []) 
+{
+  try 
+  {
+    const [rows, fields] = await connection.execute(sql, params);
+    return rows;
+  } 
+  catch (error) 
+  {
+    console.error('[MySQL][query]', error.message);
+    throw error;
+  }
+}
+
+
+
+/**
+ * Ejecuta una sentencia de escritura (INSERT, UPDATE, DELETE, DDL).
+ */
+async function execute(connection, sql, params = []) 
+{
+  try {
+    const [result] = await connection.execute(sql, params);
+
+    return {
+      rowsAffected: result.affectedRows,
+      insertId: result.insertId || null
+    };
+  } 
+  catch (error) 
+  {
+    console.error('[MySQL][execute]', error.message);
+    throw error;
+  }
+}
+
+
+/**
+ * Ejecuta un procedimiento almacenado.
+ *
+ * Nota:
+ * MySQL maneja OUT params mediante variables de sesión (@var).
+ */
+async function call(connection, procedureName, params = {}) {
+  try {
+    const keys = Object.keys(params);
+    const values = [];
+
+    const placeholders = keys.map(key => {
+      if (params[key]?.out) {
+        return `@${key}`;
+      }
+      values.push(params[key]);
+      return '?';
+    }).join(',');
+
+    // 1️ - Ejecutar CALL
+    const callSQL = `CALL ${procedureName}(${placeholders})`;
+    const [resultSets] = await connection.query(callSQL, values);
+
+    // 2️ - Recuperar OUT params
+    const outParams = keys.filter(k => params[k]?.out);
+    let out = {};
+
+    if (outParams.length > 0) {
+      const selectOut = `SELECT ${outParams.map(k => `@${k} AS ${k}`).join(',')}`;
+      const [rows] = await connection.query(selectOut);
+      out = rows[0];
+    }
+
+    return {
+      resultSets,
+      out
+    };
+  } catch (error) {
+    console.error('[MySQL][call]', error.message);
+    throw error;
+  }
+}
+
+
+
+/**
+ * Cierra la conexión a la base de datos MySQL.
+ *
+ * @async
+ * @function close
+ * @param {mysql.Connection} connection - Objeto de conexión de MySQL.
+ * @returns {Promise<void>}
+ */
+async function close(connection) 
+{
+  try 
+  { await connection.end(); }
+  catch (error) 
+  {
+    console.error('[MySQL][close]', error.message);
+    throw error;
+  }
+}
+
+module.exports = 
+{
+  connect,
+  query,
+  execute,
+  call,
+  close
+};

package/js/db_oracle.js

@@ -0,0 +1,76 @@
+/**
+ * @module js/oracle
+  * @name Provider DB js/oracle
+ * @description Módulo para la conexión y operaciones de Oracle.
+ */
+ 
+ /**
+ * @constant
+ * @type {string}
+ * @default
+ */
+const oracledb = require('oracledb');
+
+
+/**
+ * Establece una conexión a la base de datos Oracle.
+ *
+ * @async
+ * @function connect
+ * @param {object} config - Configuración de la conexión.
+ * @returns {Promise<oracledb.Connection>} Objeto de conexión de Oracle.
+ */
+async function connect(config) {
+  try {
+    oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT; // Para obtener resultados como objetos
+
+    const connection = await oracledb.getConnection({
+      user: config.user,
+      password: config.password,
+      connectString: config.connectString, // Ejemplo: 'localhost/XE' o una cadena de conexión TNS
+    });
+    return connection;
+  } catch (error) {
+    console.error('Error al conectar a Oracle:', error);
+    throw error;
+  }
+}
+
+/**
+ * Ejecuta una consulta SQL en la base de datos Oracle.
+ *
+ * @async
+ * @function query
+ * @param {oracledb.Connection} connection - Objeto de conexión de Oracle.
+ * @param {string} sql - Consulta SQL.
+ * @param {Array} [binds] - Parámetros para la consulta (bind variables).
+ * @returns {Promise<Array>} Filas resultantes de la consulta.
+ */
+async function query(connection, sql, binds = []) {
+  try {
+    const result = await connection.execute(sql, binds);
+    return result.rows;
+  } catch (error) {
+    console.error('Error al ejecutar la consulta Oracle:', error);
+    throw error;
+  }
+}
+
+/**
+ * Cierra la conexión a la base de datos Oracle.
+ *
+ * @async
+ * @function close
+ * @param {oracledb.Connection} connection - Objeto de conexión de Oracle.
+ * @returns {Promise<void>}
+ */
+async function close(connection) {
+  try {
+    await connection.close();
+  } catch (error) {
+    console.error('Error al cerrar la conexión Oracle:', error);
+    throw error;
+  }
+}
+
+module.exports = { connect, query, close };

package/js/db_postgres.js

@@ -0,0 +1,60 @@
+/**
+ * @module js/postgres
+ * @name Provider DB js/postgres
+ * @description Módulo para la conexión y operaciones del Proveedor PostgreSQL.
+ */
+
+/**
+ * @constant
+ * @type {string}
+ * @default
+ */
+const { Client } = require('pg');
+
+/**
+ * Establece una conexión a la base de datos PostgreSQL.
+ *
+ * @async
+ * @function connect
+ * @name connect
+ * @param {object} config - Configuración de la conexión.
+ * @returns {Promise<Client>} Objeto de cliente de PostgreSQL.
+ */
+async function connect(config) 
+{
+  const client = new Client(config);
+  await client.connect();
+  return client;
+}
+
+/**
+ * Ejecuta una consulta SQL en la base de datos PostgreSQL.
+ *
+ * @async
+ * @function query
+ * @name query
+ * @param {Client} client - Objeto de cliente de PostgreSQL.
+ * @param {string} sql - Consulta SQL.
+ * @returns {Promise<Array>} Filas resultantes de la consulta.
+ */
+async function query(client, sql) 
+{
+  const result = await client.query(sql);
+  return result.rows;
+}
+
+/**
+ * Cierra la conexión a la base de datos PostgreSQL.
+ *
+ * @async
+ * @function close
+ * @name close
+ * @param {Client} client - Objeto de cliente de PostgreSQL.
+ * @returns {Promise<void>}
+ */
+async function close(client) 
+{
+  await client.end();
+}
+
+module.exports = { connect, query, close };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@minervajs/helmet",
+  "version": "1.0.0",
+  "main": "src/db.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "DB",
+    "Multi DataBase",
+    "connect",
+    "MySQL",
+    "Oracle Client",
+    "PostGres",
+    "MinervaJS"
+  ],
+  "author": "alexander.enrique.escobar@gmail.com",
+  "license": "BSD-2-Clause",
+  "description": "Modulo para la gestion de coneccion a la base de datos, de diferentes tipos mediante el uso de sobre Carga y Herencia de clases",
+  "dependencies": {
+    "mysql2": "^3.14.0",
+    "oracledb": "^6.6.0",
+    "pg": "^8.14.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Alexander-Escobar/MinervaJS.Helmet.git"
+  },
+  "bug": {
+    "url": "https://github.com/Alexander-Escobar/MinervaJS.Helmet.git/issues"
+  },
+  "homepage": "https://github.com/Alexander-Escobar/MinervaJS.Helmet.git#readme"
+}

package/src/db.js

@@ -0,0 +1,246 @@
+/**
+ * 
+ * @name MinervaJS-Helmet
+ * @module MinervaJS-Helmet
+ * @description Gestor unificado de conexiones y ejecución de operaciones en múltiples motores de bases de datos.
+ */
+
+const postgres = require('../js/db_postgres');
+const mysql = require('../js/db_mysql');
+const oracle = require('../js/db_oracle');
+// const mongodb = require('./lib/mongodb');
+// const mariadb = require('./lib/mariadb');
+
+const connections = {};
+
+/**
+ * Establece una conexión a la base de datos especificada.
+ *
+ * @async
+ * @function connect
+ * @name connect
+ * @param {string} databaseName - Perfil de la base de datos  (clave de configuración)
+ * @returns {Promise<object>} Objeto de conexión.
+ * @throws {Error} Si la configuración no se encuentra o el tipo de base de datos no es soportado.
+ * @description Toma la configuracion y Establece una conexión a la base de datos especificada
+ */
+async function connect(databaseName, config) 
+{
+	const dbConfig = config[databaseName];
+
+	if (!dbConfig) 
+	{ throw new Error(`Configuración de base de datos '${databaseName}' no encontrada.`); }
+
+	// Ya existe una conexión 
+	if (connections[databaseName]) 
+	{ return connections[databaseName]; }
+
+	switch (dbConfig.type) 
+	{
+		case 'postgres':
+			connections[databaseName] = await postgres.connect(dbConfig);
+			break;
+		case 'mysql':
+			connections[databaseName] = await mysql.connect(dbConfig);
+			break;
+		// case 'mariadb':
+		//   connections[databaseName] = await mariadb.connect(dbConfig);
+		//   break;
+		case 'oracle':
+			connections[databaseName] = await oracle.connect(dbConfig);
+			break;
+		// case 'mongodb':
+		//  connections[databaseName] = await mongodb.connect(dbConfig);
+		//  break;
+		default:
+			throw new Error(`Tipo de base de datos '${dbConfig.type}' no soportado.`);
+	}
+
+	return connections[databaseName];
+}
+
+
+/**
+ * Dispatcher interno para query / execute / call
+ */
+async function run(databaseName, target, params, config, mode) 
+{
+  const connection = await connect(databaseName, config);
+  const dbConfig = config[databaseName];
+
+  try {
+    switch (dbConfig.type) {
+      case 'postgres':
+        return await postgres[mode](connection, target, params);
+
+      case 'mysql':
+        return await mysql[mode](connection, target, params);
+
+      case 'oracle':
+        return await oracle[mode](connection, target, params);
+
+      default:
+        throw new Error(`Tipo de base de datos '${dbConfig.type}' no soportado.`);
+    }
+  } 
+  catch (err) 
+  {
+    throw new Error(`[Helmet][${dbConfig.type}][${mode}] ${err.message}`);
+  }
+}
+
+
+
+/**
+ * Ejecuta una consulta en la base de datos especificada.
+ *
+ * @async
+ * @function query
+ * @name query
+ * @param {string} databaseName - Perfil de la base de datos  (clave de configuración)
+ * @param {string} sql - Consulta SQL, Sentencia SQL a ejecutar
+ * @param {Array} [binds] - Parámetros para la consulta (bind variables).
+ * @returns {Promise<Array>} Filas resultantes de la consulta.
+ * @throws {Error} Si el tipo de base de datos no es soportado para la operación 'query'.
+ * @description Ejecuta una sentencia SQL en la base de datos especificada y devuelve un objeto en un set de datos
+ */
+// async function query(databaseName, sql, values = [], config) 
+// {
+  // const connection = await connect(databaseName, config);
+  // const dbConfig = config[databaseName];
+
+  // switch (dbConfig.type) 
+  // {
+    // case 'postgres':
+      // return postgres.query(connection, sql);
+    // case 'mysql':
+      // return mysql.query(connection, sql, values);
+    // // case 'mariadb': // agregamos el caso MariaDB
+    // //   return mariadb.query(connection, sql, binds);
+    // //   break;
+    // case 'oracle':
+      // return oracle.query(connection, sql);
+    // // case 'mongodb':
+    // //  // Adaptar la consulta SQL a la sintaxis de MongoDB
+    // //  console.warn("La función 'query' no es directamente aplicable a MongoDB con sintaxis SQL.");
+    // //  return null; // O lanzar un error
+    // default:
+      // throw new Error(`Tipo de base de datos '${dbConfig.type}' no soportado para la operación 'query'.`);
+  // }
+// }
+
+/**
+ * Ejecuta consultas de lectura (SELECT).
+ */
+async function query(databaseName, sql, params = [], config) 
+{
+  return run(databaseName, sql, params, config, 'query');
+}
+
+/**
+ * Ejecuta sentencias de escritura (INSERT, UPDATE, DELETE, DDL).
+ */
+async function execute(databaseName, sql, params = [], config) 
+{
+  return run(databaseName, sql, params, config, 'execute');
+}
+
+
+/**
+ * Ejecuta procedimientos almacenados o funciones.
+ */
+async function call(databaseName, procedureName, params = {}, config) 
+{
+  return run(databaseName, procedureName, params, config, 'call');
+}
+
+/**
+ * Cierra la conexión a la base de datos especificada.
+ *
+ * @async
+ * @function close
+ * @name close
+ * @param {string} databaseName - Perfil de la base de datos (clave de configuración).
+ * @returns {Promise<void>}
+ * @description Cierra la conexion del Perfil de la base de datos especificada.
+ */
+async function close(databaseName, config) 
+{
+  if (!connections[databaseName]) return;
+  
+  const dbConfig = config[databaseName];
+  switch (dbConfig.type) {
+  case 'postgres':
+	await postgres.close(connections[databaseName]);
+	break;
+  case 'mysql':
+	await mysql.close(connections[databaseName]);
+	break;
+//  case 'mariadb': // agregamos el caso MariaDB
+//    await mariadb.close(connections[databaseName]);
+//    break;
+  case 'oracle':
+	await oracle.close(connections[databaseName]);
+	break;
+//  case 'mongodb':
+//    await mongodb.close(connections[databaseName]);
+//    break;
+  }
+    delete connections[databaseName];
+
+}
+
+
+
+/**
+ * @function 
+ * @name execute
+ * @param {string} sql - Sentencia SQL a ejecutar
+ * @param {Promise<callback>} callback - objeto, para retornar la promesa
+ * @returns {result} result/err - Devuelve un objeto con el set de datos o un objeto err con la respuesta del error
+ * @description Ejecuta una sentencia SQL y devuelve un objeto en un set de datos
+ */
+// async function execute(databaseName, sql, values = [], config) 
+// {
+	// const connection = await connect(databaseName, config);
+	// const dbConfig = config[databaseName];
+	
+	// switch (dbConfig.type) 
+	// {
+		// case 'postgres':
+			// return postgres.query(connection, sql);
+		// case 'mysql':
+			// return mysql.query(connection, sql, values);
+	// // case 'mariadb': // agregamos el caso MariaDB
+	// //   return mariadb.query(connection, sql, binds);
+	// //   break;
+		// case 'oracle':
+			// return oracle.query(connection, sql);
+	// // case 'mongodb':
+	// //  // Adaptar la consulta SQL a la sintaxis de MongoDB
+	// //  console.warn("La función 'query' no es directamente aplicable a MongoDB con sintaxis SQL.");
+	// //  return null; // O lanzar un error
+		// default:
+			// throw new Error(`Tipo de base de datos '${dbConfig.type}' no soportado para la operación 'query'.`);
+	// }
+// }
+
+/**
+ * Cierra todas las conexiones activas.
+ */
+async function closeAll(config) 
+{
+  for (const dbName of Object.keys(connections)) 
+  { await close(dbName, config); }
+}
+
+module.exports = 
+{
+  connect,
+  query,
+  execute,
+  call,
+  close,
+  closeAll
+  // ... otras funciones comunes
+};