@hemia/db-connector 0.0.3 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
 # @hemia/db-connector
 
-Conector unificado para bases de datos SQL (MySQL, MSSQL) y NoSQL (MongoDB), diseñado para facilitar operaciones comunes como conexión, transacciones, queries y manipulación de datos. Ideal para aplicaciones Node.js que requieren una interfaz abstracta para distintos motores de base de datos.
+Conector unificado para bases de datos SQL, NoSQL y OLAP, diseñado para facilitar operaciones comunes como conexión, transacciones, queries y manipulación de datos. Ideal para aplicaciones Node.js que requieren una interfaz abstracta para distintos motores de base de datos.
 
 ---
 
@@ -12,10 +12,50 @@ npm install @hemia/db-connector
 
 ---
 
-## Soporta:
+## Bases de Datos Soportadas
 
-* ✅ MongoDB (Mongoose)
-* ✅ MySQL / MSSQL (Sequelize)
+### 🗄️ SQL (OLTP - Online Transaction Processing)
+Bases de datos relacionales optimizadas para transacciones y operaciones CRUD.
+
+* ✅ **MySQL** - Base de datos relacional de código abierto
+* ✅ **PostgreSQL** - Base de datos relacional avanzada con soporte JSON
+* ✅ **Microsoft SQL Server (MSSQL)** - Base de datos empresarial de Microsoft
+
+**Casos de uso:**
+- Sistemas transaccionales (e-commerce, banking)
+- Aplicaciones empresariales (ERP, CRM)
+- Gestión de usuarios y autenticación
+- Aplicaciones que requieren integridad referencial
+
+---
+
+### 📄 NoSQL (Document Store)
+Bases de datos orientadas a documentos para datos no estructurados.
+
+* ✅ **MongoDB** - Base de datos de documentos JSON flexible y escalable
+
+**Casos de uso:**
+- Aplicaciones con esquemas flexibles
+- Gestión de contenido (CMS)
+- Perfiles de usuario complejos
+- Catálogos de productos
+- Logs y eventos en formato JSON
+- Aplicaciones en tiempo real
+
+---
+
+### 📊 OLAP (Online Analytical Processing)
+Bases de datos columnares optimizadas para análisis y consultas agregadas.
+
+* ✅ **ClickHouse** - Base de datos columnar de alta velocidad para análisis en tiempo real
+
+**Casos de uso:**
+- Análisis de logs y trazas (APM, Observability)
+- Métricas y monitoreo en tiempo real
+- Business Intelligence y Data Warehousing
+- Análisis de eventos y comportamiento de usuarios
+- Procesamiento de grandes volúmenes de datos
+- Dashboards analíticos de alto rendimiento
 
 ---
 
@@ -37,12 +77,14 @@ await mongo.connect();
 const docs = await mongo.find(MyModel, { status: 'active' });
 ```
 
-### SQL (MySQL/MSSQL)
+### SQL (MySQL/MSSQL/PostgreSQL)
 
 ```ts
-import { SequelizeSqlConnector } from '@hemia/db-connector';
+import { DBConnector } from '@hemia/db-connector';
+import { DBSQLType } from '@hemia/db-connector/types/DBSQLTypes';
 
-const sql = new SequelizeSqlConnector({
+const dbConnector = DBConnector.getInstance();
+const sql = dbConnector.getEngine(DBSQLType.MySQL, {
   host: 'localhost',
   user: 'root',
   password: 'pass',
@@ -52,25 +94,182 @@ const sql = new SequelizeSqlConnector({
 
 await sql.connect();
 const rows = await sql.select('users', { where: { active: true } });
+
+// Transacciones
+await sql.withTransaction(async (transaction) => {
+  await sql.insert('orders', { userId: 1, total: 100 }, { transaction });
+  await sql.update('users', { id: 1 }, { balance: 500 }, { transaction });
+});
+```
+
+### ClickHouse (OLAP)
+
+```ts
+import { DBConnector } from '@hemia/db-connector';
+import { DBOLAPType } from '@hemia/db-connector/types/OLAPTypes';
+
+const dbConnector = DBConnector.getInstance();
+const clickhouse = dbConnector.getEngine(DBOLAPType.ClickHouse, {
+  host: 'http://localhost:8123',
+  user: 'default',
+  password: '',
+  database: 'analytics',
+});
+
+await clickhouse.connect();
+
+// Insertar datos (JSONEachRow por defecto)
+await clickhouse.insert({
+  table: 'traces',
+  values: [
+    { trace_id: '123', service_name: 'api', duration_ms: 45 },
+    { trace_id: '124', service_name: 'db', duration_ms: 120 }
+  ]
+});
+
+// Insertar con formato CSV
+await clickhouse.insert({
+  table: 'traces',
+  values: '125,"cache",30\n126,"queue",85',
+  format: 'CSV'
+});
+
+// Buscar con filtros
+const traces = await clickhouse.find('traces', { 
+  service_name: 'api',
+  error: false 
+});
+
+// Query personalizada para análisis
+const stats = await clickhouse.query(`
+  SELECT 
+    service_name,
+    count() as total_requests,
+    avg(duration_ms) as avg_duration,
+    max(duration_ms) as max_duration
+  FROM traces
+  WHERE start_time >= now() - INTERVAL 1 HOUR
+  GROUP BY service_name
+  ORDER BY total_requests DESC
+`);
+```
+
+---
+
+## Uso con DBConnector (Recomendado)
+
+El patrón recomendado es usar `DBConnector` como punto de entrada único:
+
+```ts
+import { DBConnector } from '@hemia/db-connector';
+import { DBSQLType, DBNoSQLType, DBOLAPType } from '@hemia/db-connector';
+
+const dbConnector = DBConnector.getInstance();
+
+// Obtener motor SQL
+const mysql = dbConnector.getEngine(DBSQLType.MySQL, credentials);
+
+// Obtener motor NoSQL  
+const mongo = dbConnector.getEngine(DBNoSQLType.MongoDB, credentials);
+
+// Obtener motor OLAP
+const clickhouse = dbConnector.getEngine(DBOLAPType.ClickHouse, credentials);
 ```
 
 ---
 
 ## Características destacadas
 
-### MongoDBConnector
+### MongoDBConnector (NoSQL)
 
 * Conexión y desconexión automáticas
 * Transacciones con rollback (`withTransaction`)
 * CRUD genérico (`create`, `find`, `findOne`, `update`, `delete`, etc.)
-* `aggregate`, `findAllFromMultipleModels`
+* Operaciones avanzadas: `aggregate`, `findAllFromMultipleModels`
+* Soporte para modelos Mongoose
+* Manejo automático de sesiones
 
-### SequelizeSqlConnector
+**Ejemplo de uso avanzado:**
+```ts
+// Aggregate pipeline
+const results = await mongo.aggregate(UserModel, [
+  { $match: { active: true } },
+  { $group: { _id: '$country', total: { $sum: 1 } } }
+]);
+
+// Transacciones
+await mongo.withTransaction(async (session) => {
+  await mongo.create(UserModel, { name: 'John' }, session);
+  await mongo.update(UserModel, { _id: userId }, { status: 'active' }, session);
+});
+```
 
-* `select`, `insert`, `update`, `delete` por entidad (tabla)
-* Transacciones (`withTransaction`)
-* Query SQL libre (`query()`)
+---
+
+### SequelizeSqlConnector (SQL)
+
+* Operaciones CRUD: `select`, `insert`, `update`, `delete`
+* Transacciones con soporte completo de Sequelize (`withTransaction`)
+* Query SQL libre con `query()` para consultas complejas
 * Manejo de errores y mapeo de códigos SQLSTATE (`createDatabaseError`)
+* Soporte para stored procedures
+* Conexión a MySQL, PostgreSQL, MSSQL
+
+**Ejemplo de uso avanzado:**
+```ts
+// Query con stored procedure
+const result = await sql.query('CALL get_user_stats(:userId)', {
+  replacements: { userId: 123 },
+  type: QueryTypes.SELECT
+});
+
+// Transacciones
+await sql.withTransaction(async (transaction) => {
+  await sql.insert('orders', orderData, { transaction });
+  await sql.update('inventory', { productId: 1 }, { stock: 10 }, { transaction });
+});
+```
+
+---
+
+### ClickHouseConnector (OLAP)
+
+* Conexión optimizada para análisis de alto rendimiento
+* Múltiples formatos de inserción: `JSONEachRow`, `CSV`, `TabSeparated`, etc.
+* Método `find()` con filtros para búsquedas rápidas
+* Query SQL libre para análisis complejos
+* Ideal para procesamiento de grandes volúmenes de datos
+* Soporte para columnas calculadas (MATERIALIZED)
+
+**Ejemplo de uso avanzado:**
+```ts
+// Insertar millones de registros eficientemente
+await clickhouse.insert({
+  table: 'events',
+  values: largeDataArray, // Array con millones de registros
+  format: 'JSONEachRow'
+});
+
+// Análisis en tiempo real
+const metrics = await clickhouse.query(`
+  SELECT 
+    toStartOfMinute(timestamp) as minute,
+    countIf(status = 200) as success,
+    countIf(status >= 400) as errors,
+    quantile(0.95)(response_time) as p95_latency
+  FROM http_logs
+  WHERE timestamp >= now() - INTERVAL 1 HOUR
+  GROUP BY minute
+  ORDER BY minute DESC
+`);
+
+// Búsqueda con filtros múltiples
+const errorTraces = await clickhouse.find('traces', {
+  service_name: 'payment-api',
+  error: true,
+  duration_ms: 1000 // Mayor a 1 segundo
+});
+```
 
 ---
 
@@ -83,13 +282,187 @@ interface CredentialsConnection {
   user?: string;
   password?: string;
   database: string;
-  dialect?: 'mysql' | 'mssql';
+  dialect?: 'mysql' | 'mssql' | 'postgres';
   logging?: boolean;
 }
 ```
 
 ---
 
+## Arquitectura y Patrones de Uso
+
+### Lambda Architecture: Combinando SQL, NoSQL y OLAP
+
+Una arquitectura común es usar diferentes bases de datos para diferentes propósitos:
+
+```ts
+// 1. OLTP (MySQL/PostgreSQL) - Transacciones en tiempo real
+const mysql = dbConnector.getEngine(DBSQLType.MySQL, mysqlCredentials);
+await mysql.insert('orders', { userId: 123, amount: 99.99 });
+
+// 2. NoSQL (MongoDB) - Datos flexibles y documentos
+const mongo = dbConnector.getEngine(DBNoSQLType.MongoDB, mongoCredentials);
+await mongo.create(ProductModel, { 
+  name: 'Laptop',
+  specs: { ram: '16GB', cpu: 'i7' } // Esquema flexible
+});
+
+// 3. OLAP (ClickHouse) - Análisis y reportes
+const clickhouse = dbConnector.getEngine(DBOLAPType.ClickHouse, clickhouseCredentials);
+await clickhouse.insert({
+  table: 'order_analytics',
+  values: [{ 
+    order_id: orderId,
+    user_id: 123,
+    amount: 99.99,
+    timestamp: new Date()
+  }]
+});
+```
+
+### Casos de Uso por Tipo de Base de Datos
+
+#### 🗄️ SQL (MySQL/PostgreSQL/MSSQL)
+**Cuándo usar:**
+- Necesitas transacciones ACID
+- Relaciones complejas entre entidades
+- Integridad referencial crítica
+- Consultas con JOINs
+
+**Ejemplos:**
+- Sistema de facturación
+- Gestión de inventario
+- Sistema de usuarios y permisos
+- Carrito de compras
+
+#### 📄 NoSQL (MongoDB)
+**Cuándo usar:**
+- Esquemas variables o en evolución
+- Necesitas escalar horizontalmente
+- Documentos JSON complejos
+- Alto volumen de escrituras
+
+**Ejemplos:**
+- Catálogo de productos con atributos variables
+- Perfiles de usuario con datos personalizados
+- Sistema de logs y auditoría
+- Gestión de contenido (CMS)
+
+#### 📊 OLAP (ClickHouse)
+**Cuándo usar:**
+- Análisis de grandes volúmenes de datos
+- Consultas agregadas complejas
+- Necesitas latencias de milisegundos en análisis
+- Datos de series temporales
+
+**Ejemplos:**
+- Observabilidad y APM (traces, logs, métricas)
+- Análisis de comportamiento de usuarios
+- Dashboards de BI en tiempo real
+- Análisis de eventos y clickstream
+- Monitoreo de infraestructura
+
+---
+
+## Ejemplo Completo: Sistema de E-commerce con Observabilidad
+
+```ts
+import { DBConnector, DBSQLType, DBNoSQLType, DBOLAPType } from '@hemia/db-connector';
+
+const connector = DBConnector.getInstance();
+
+// 1. Base de datos transaccional (MySQL)
+const mysql = connector.getEngine(DBSQLType.MySQL, {
+  host: 'localhost',
+  database: 'ecommerce',
+  user: 'root',
+  password: 'pass'
+});
+
+// 2. Base de datos de documentos (MongoDB)
+const mongo = connector.getEngine(DBNoSQLType.MongoDB, {
+  host: 'localhost',
+  database: 'ecommerce_content'
+});
+
+// 3. Base de datos analítica (ClickHouse)
+const clickhouse = connector.getEngine(DBOLAPType.ClickHouse, {
+  host: 'http://localhost:8123',
+  database: 'analytics'
+});
+
+// Procesar orden
+async function processOrder(orderData) {
+  const startTime = Date.now();
+  
+  try {
+    // 1. Guardar orden en MySQL (transaccional)
+    await mysql.withTransaction(async (tx) => {
+      const order = await mysql.insert('orders', orderData, { transaction: tx });
+      await mysql.update('inventory', 
+        { productId: orderData.productId }, 
+        { stock: { decrement: 1 } },
+        { transaction: tx }
+      );
+    });
+    
+    // 2. Guardar detalles enriquecidos en MongoDB
+    await mongo.create(OrderDetailsModel, {
+      orderId: orderData.id,
+      userPreferences: orderData.preferences,
+      metadata: orderData.metadata
+    });
+    
+    // 3. Registrar evento en ClickHouse para análisis
+    await clickhouse.insert({
+      table: 'order_events',
+      values: [{
+        event_type: 'order_created',
+        order_id: orderData.id,
+        user_id: orderData.userId,
+        amount: orderData.amount,
+        duration_ms: Date.now() - startTime,
+        timestamp: new Date(),
+        success: true
+      }]
+    });
+    
+  } catch (error) {
+    // Registrar error en ClickHouse
+    await clickhouse.insert({
+      table: 'order_events',
+      values: [{
+        event_type: 'order_failed',
+        order_id: orderData.id,
+        error_message: error.message,
+        duration_ms: Date.now() - startTime,
+        timestamp: new Date(),
+        success: false
+      }]
+    });
+    throw error;
+  }
+}
+
+// Análisis de órdenes en tiempo real
+async function getOrderStats() {
+  return await clickhouse.query(`
+    SELECT 
+      toStartOfHour(timestamp) as hour,
+      countIf(success = true) as successful_orders,
+      countIf(success = false) as failed_orders,
+      avg(amount) as avg_order_value,
+      quantile(0.95)(duration_ms) as p95_duration
+    FROM order_events
+    WHERE timestamp >= now() - INTERVAL 24 HOUR
+    GROUP BY hour
+    ORDER BY hour DESC
+  `);
+}
+```
+
+---
+
 ## Licencia
 
 MIT

package/dist/hemia-db-connector.esm.js

@@ -1,3 +1,4 @@
+import { createClient } from '@clickhouse/client';
 import mongoose__default from 'mongoose';
 export * from 'mongoose';
 import { ValidationError, DatabaseError, AccessDeniedError, Sequelize } from 'sequelize';
@@ -45,6 +46,89 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+class OLAPConnector {
+}
+
+class ClickHouseConnector extends OLAPConnector {
+    constructor(credentials) {
+        super();
+        this.credentials = credentials;
+        let url;
+        if (this.credentials.host.match(/^https?:\/\/.+:\d+$/)) {
+            url = this.credentials.host;
+        }
+        else if (this.credentials.host.startsWith('http://') || this.credentials.host.startsWith('https://')) {
+            const port = this.credentials.port || 8123;
+            url = `${this.credentials.host}:${port}`;
+        }
+        else {
+            const port = this.credentials.port || 8123;
+            url = `http://${this.credentials.host}:${port}`;
+        }
+        this.client = createClient({
+            url,
+            username: this.credentials.user,
+            password: this.credentials.password,
+            database: this.credentials.database,
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isConnected = yield this.client.ping();
+            if (!isConnected) {
+                throw new Error('ClickHouse connection failed.');
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.close();
+        });
+    }
+    query(sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resultSet = yield this.client.query({
+                query: sql,
+                format: 'JSONEachRow',
+            });
+            return resultSet.json();
+        });
+    }
+    insert(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { table, values, format = 'JSONEachRow' } = options;
+            yield this.client.insert({
+                table,
+                values: values,
+                format: format,
+            });
+        });
+    }
+    find(table_1) {
+        return __awaiter(this, arguments, void 0, function* (table, filters = {}) {
+            if (Object.keys(filters).length === 0) {
+                const sql = `SELECT * FROM ${table}`;
+                return this.query(sql);
+            }
+            const whereClause = Object.entries(filters)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `${key} = '${value}'`;
+                }
+                else if (typeof value === 'boolean') {
+                    return `${key} = ${value ? '1' : '0'}`;
+                }
+                else {
+                    return `${key} = ${value}`;
+                }
+            })
+                .join(' AND ');
+            const sql = `SELECT * FROM ${table} WHERE ${whereClause}`;
+            return this.query(sql);
+        });
+    }
+}
+
 class NoSQLConnector {
     constructor() {
         this.config = {};
@@ -289,6 +373,86 @@ class MongoDBConnector extends NoSQLConnector {
             }
         });
     }
+    updateMany(model, query, updateData, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.updateMany(query, updateData, { session });
+                return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
+            }
+            catch (error) {
+                console.error('Error al actualizar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    deleteMany(model, query, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.deleteMany(query, { session });
+                return { deletedCount: result.deletedCount };
+            }
+            catch (error) {
+                console.error('Error al eliminar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    countDocuments(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.countDocuments(query);
+            }
+            catch (error) {
+                console.error('Error al contar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    distinct(model, field, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.distinct(field, query);
+            }
+            catch (error) {
+                console.error('Error al obtener valores distintos:', error);
+                throw error;
+            }
+        });
+    }
+    insertMany(model, docs, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.insertMany(docs, { session });
+            }
+            catch (error) {
+                console.error('Error al insertar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    exists(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.exists(query);
+                return result !== null;
+            }
+            catch (error) {
+                console.error('Error al verificar existencia:', error);
+                throw error;
+            }
+        });
+    }
+    bulkWrite(model, operations, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.bulkWrite(operations, { session });
+            }
+            catch (error) {
+                console.error('Error en operación bulk:', error);
+                throw error;
+            }
+        });
+    }
 }
 
 class NoSQLConnectionManager {
@@ -510,6 +674,13 @@ class SQLConnectionManager {
     }
 }
 
+var DBOLAPType;
+(function (DBOLAPType) {
+    DBOLAPType["ClickHouse"] = "ClickHouse";
+    DBOLAPType["Druid"] = "Druid";
+    DBOLAPType["Snowflake"] = "Snowflake";
+})(DBOLAPType || (DBOLAPType = {}));
+
 class DBConnector {
     constructor() {
         this.connection = null;
@@ -537,6 +708,9 @@ class DBConnector {
             else if (Object.values(DBSQLType).includes(type)) {
                 this.connection = SQLConnectionManager.getInstance(type, credentials);
             }
+            else if (Object.values(DBOLAPType).includes(type)) {
+                this.connection = new ClickHouseConnector(credentials);
+            }
             else {
                 throw new Error(`Unsupported database type: ${type}`);
             }
@@ -567,6 +741,9 @@ class DBConnector {
             else if (Object.values(DBSQLType).includes(type)) {
                 this.connection = SQLConnectionManager.getInstance(type, credentials);
             }
+            else if (Object.values(DBOLAPType).includes(type)) {
+                this.connection = new ClickHouseConnector(credentials);
+            }
             else {
                 throw new Error(`Unsupported database type: ${type}`);
             }

package/dist/hemia-db-connector.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var client = require('@clickhouse/client');
 var mongoose = require('mongoose');
 var sequelize = require('sequelize');
 
@@ -45,6 +46,89 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+class OLAPConnector {
+}
+
+class ClickHouseConnector extends OLAPConnector {
+    constructor(credentials) {
+        super();
+        this.credentials = credentials;
+        let url;
+        if (this.credentials.host.match(/^https?:\/\/.+:\d+$/)) {
+            url = this.credentials.host;
+        }
+        else if (this.credentials.host.startsWith('http://') || this.credentials.host.startsWith('https://')) {
+            const port = this.credentials.port || 8123;
+            url = `${this.credentials.host}:${port}`;
+        }
+        else {
+            const port = this.credentials.port || 8123;
+            url = `http://${this.credentials.host}:${port}`;
+        }
+        this.client = client.createClient({
+            url,
+            username: this.credentials.user,
+            password: this.credentials.password,
+            database: this.credentials.database,
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isConnected = yield this.client.ping();
+            if (!isConnected) {
+                throw new Error('ClickHouse connection failed.');
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.close();
+        });
+    }
+    query(sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resultSet = yield this.client.query({
+                query: sql,
+                format: 'JSONEachRow',
+            });
+            return resultSet.json();
+        });
+    }
+    insert(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { table, values, format = 'JSONEachRow' } = options;
+            yield this.client.insert({
+                table,
+                values: values,
+                format: format,
+            });
+        });
+    }
+    find(table_1) {
+        return __awaiter(this, arguments, void 0, function* (table, filters = {}) {
+            if (Object.keys(filters).length === 0) {
+                const sql = `SELECT * FROM ${table}`;
+                return this.query(sql);
+            }
+            const whereClause = Object.entries(filters)
+                .map(([key, value]) => {
+                if (typeof value === 'string') {
+                    return `${key} = '${value}'`;
+                }
+                else if (typeof value === 'boolean') {
+                    return `${key} = ${value ? '1' : '0'}`;
+                }
+                else {
+                    return `${key} = ${value}`;
+                }
+            })
+                .join(' AND ');
+            const sql = `SELECT * FROM ${table} WHERE ${whereClause}`;
+            return this.query(sql);
+        });
+    }
+}
+
 class NoSQLConnector {
     constructor() {
         this.config = {};
@@ -289,6 +373,86 @@ class MongoDBConnector extends NoSQLConnector {
             }
         });
     }
+    updateMany(model, query, updateData, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.updateMany(query, updateData, { session });
+                return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
+            }
+            catch (error) {
+                console.error('Error al actualizar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    deleteMany(model, query, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.deleteMany(query, { session });
+                return { deletedCount: result.deletedCount };
+            }
+            catch (error) {
+                console.error('Error al eliminar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    countDocuments(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.countDocuments(query);
+            }
+            catch (error) {
+                console.error('Error al contar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    distinct(model, field, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.distinct(field, query);
+            }
+            catch (error) {
+                console.error('Error al obtener valores distintos:', error);
+                throw error;
+            }
+        });
+    }
+    insertMany(model, docs, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.insertMany(docs, { session });
+            }
+            catch (error) {
+                console.error('Error al insertar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    exists(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.exists(query);
+                return result !== null;
+            }
+            catch (error) {
+                console.error('Error al verificar existencia:', error);
+                throw error;
+            }
+        });
+    }
+    bulkWrite(model, operations, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.bulkWrite(operations, { session });
+            }
+            catch (error) {
+                console.error('Error en operación bulk:', error);
+                throw error;
+            }
+        });
+    }
 }
 
 class NoSQLConnectionManager {
@@ -510,6 +674,13 @@ class SQLConnectionManager {
     }
 }
 
+var DBOLAPType;
+(function (DBOLAPType) {
+    DBOLAPType["ClickHouse"] = "ClickHouse";
+    DBOLAPType["Druid"] = "Druid";
+    DBOLAPType["Snowflake"] = "Snowflake";
+})(DBOLAPType || (DBOLAPType = {}));
+
 class DBConnector {
     constructor() {
         this.connection = null;
@@ -537,6 +708,9 @@ class DBConnector {
             else if (Object.values(exports.DBSQLType).includes(type)) {
                 this.connection = SQLConnectionManager.getInstance(type, credentials);
             }
+            else if (Object.values(DBOLAPType).includes(type)) {
+                this.connection = new ClickHouseConnector(credentials);
+            }
             else {
                 throw new Error(`Unsupported database type: ${type}`);
             }
@@ -567,6 +741,9 @@ class DBConnector {
             else if (Object.values(exports.DBSQLType).includes(type)) {
                 this.connection = SQLConnectionManager.getInstance(type, credentials);
             }
+            else if (Object.values(DBOLAPType).includes(type)) {
+                this.connection = new ClickHouseConnector(credentials);
+            }
             else {
                 throw new Error(`Unsupported database type: ${type}`);
             }

package/dist/types/Core/ClickHouseConnector.d.ts

@@ -0,0 +1,12 @@
+import { CredentialsConnection } from '../types/CredentialsConnection';
+import { OLAPConnector, InsertOptions, ClickHouseInsertFormat } from '../abstract/OLAPConnector';
+export declare class ClickHouseConnector extends OLAPConnector {
+    private client;
+    private credentials;
+    constructor(credentials: CredentialsConnection);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = unknown>(sql: string): Promise<T[]>;
+    insert<F extends ClickHouseInsertFormat = 'JSONEachRow'>(options: InsertOptions<F>): Promise<void>;
+    find<T = unknown>(table: string, filters?: Record<string, any>): Promise<T[]>;
+}

package/dist/types/Core/MongoDBConnector.d.ts

@@ -28,4 +28,16 @@ export declare class MongoDBConnector extends NoSQLConnector {
     findAllFromMultipleModels<U extends Document>(models: Array<Model<U>>, filter: object): Promise<U[]>;
     aggregate<T extends Document>(model: Model<T>, pipeline: mongoose.PipelineStage[], options?: AggregateOptions): Promise<any[]>;
     executeWithModel<T extends Document, R>(model: Model<T>, operation: (model: Model<T>, session?: ClientSession) => Promise<R>, session?: ClientSession): Promise<R>;
+    updateMany<T extends Document>(model: Model<T>, query: object, updateData: object, session?: ClientSession): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    deleteMany<T extends Document>(model: Model<T>, query: object, session?: ClientSession): Promise<{
+        deletedCount: number;
+    }>;
+    countDocuments<T extends Document>(model: Model<T>, query: object): Promise<number>;
+    distinct<T extends Document>(model: Model<T>, field: string, query?: object): Promise<any[]>;
+    insertMany<T extends Document>(model: Model<T>, docs: Partial<T>[], session?: ClientSession): Promise<T[]>;
+    exists<T extends Document>(model: Model<T>, query: object): Promise<boolean>;
+    bulkWrite<T extends Document>(model: Model<T>, operations: any[], session?: ClientSession): Promise<any>;
 }

package/dist/types/DBConnector.d.ts

@@ -1,8 +1,10 @@
 import { NoSQLConnector } from "./abstract/NoSQLConnector";
+import { OLAPConnector } from "./abstract/OLAPConnector";
 import { SqlConnector } from "./abstract/SQLConnector";
 import { CredentialsConnection } from "./types/CredentialsConnection";
 import { DBNoSQLType } from "./types/DBNoSQLTypes";
 import { DBSQLType } from "./types/DBSQLTypes";
+import { DBOLAPType } from "./types/OLAPTypes";
 export declare class DBConnector {
     private static instance;
     private connection;
@@ -11,8 +13,8 @@ export declare class DBConnector {
     private dbType;
     constructor();
     static getInstance(): DBConnector;
-    createConnection<T extends SqlConnector | NoSQLConnector>(type: DBSQLType | DBNoSQLType, credentials: CredentialsConnection): Promise<T>;
-    getConnection<T extends NoSQLConnector | SqlConnector>(): T | null;
+    createConnection<T extends SqlConnector | NoSQLConnector | OLAPConnector>(type: DBSQLType | DBNoSQLType | DBOLAPType, credentials: CredentialsConnection): Promise<T>;
+    getConnection<T extends NoSQLConnector | SqlConnector | OLAPConnector>(): T | null;
     closeConnection(): Promise<void>;
-    getEngine<T extends NoSQLConnector | SqlConnector>(type: DBNoSQLType | DBSQLType, credentials: CredentialsConnection): T;
+    getEngine<T extends NoSQLConnector | SqlConnector | OLAPConnector>(type: DBNoSQLType | DBSQLType | DBOLAPType, credentials: CredentialsConnection): T;
 }

package/dist/types/abstract/NoSQLConnector.d.ts

@@ -38,4 +38,16 @@ export declare abstract class NoSQLConnector {
     abstract aggregate<T>(model: any, pipeline: PipelineStage[]): Promise<any[]>;
     abstract aggregate<T extends Document>(model: Model<T>, pipeline: PipelineStage[], options?: AggregateOptions): Promise<any[]>;
     abstract executeWithModel<T extends Document, R>(model: Model<T>, operation: (model: Model<T>, session?: ClientSession) => Promise<R>, session?: ClientSession): Promise<R>;
+    abstract exists<T extends Document>(model: Model<T>, query: object): Promise<boolean>;
+    abstract updateMany<T extends Document>(model: Model<T>, query: object, updateData: object, session?: ClientSession): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    abstract deleteMany<T extends Document>(model: Model<T>, query: object, session?: ClientSession): Promise<{
+        deletedCount: number;
+    }>;
+    abstract countDocuments<T extends Document>(model: Model<T>, query: object): Promise<number>;
+    abstract distinct<T extends Document>(model: Model<T>, field: string, query?: object): Promise<any[]>;
+    abstract insertMany<T extends Document>(model: Model<T>, docs: Partial<T>[], session?: ClientSession): Promise<T[]>;
+    abstract bulkWrite<T extends Document>(model: Model<T>, operations: any[], session?: ClientSession): Promise<any>;
 }

package/dist/types/abstract/OLAPConnector.d.ts

@@ -0,0 +1,14 @@
+export type ClickHouseInsertFormat = 'JSONEachRow' | 'JSON' | 'JSONCompactEachRow' | 'CSV' | 'TabSeparated' | 'TabSeparatedWithNames' | 'Values';
+export type ClickHouseInsertValues<T> = T extends 'JSONEachRow' | 'JSONCompactEachRow' | 'JSON' ? Record<string, any>[] : string;
+export interface InsertOptions<F extends ClickHouseInsertFormat = 'JSONEachRow'> {
+    table: string;
+    values: ClickHouseInsertValues<F>;
+    format?: F;
+}
+export declare abstract class OLAPConnector {
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract query<T = unknown>(sql: string): Promise<T[]>;
+    abstract insert<F extends ClickHouseInsertFormat = 'JSONEachRow'>(options: InsertOptions<F>): Promise<void>;
+    abstract find<T = unknown>(table: string, filters: Record<string, any>): Promise<T[]>;
+}

package/dist/types/managers/OLAPConnectionManager.d.ts

@@ -0,0 +1,6 @@
+import { OLAPConnector } from "../abstract/OLAPConnector";
+import { CredentialsConnection } from "../types/CredentialsConnection";
+import { DBOLAPType } from "../types/OLAPTypes";
+export declare class OLAPConnectionManager {
+    static getInstance(type: DBOLAPType, credentials: CredentialsConnection): OLAPConnector;
+}

package/dist/types/types/OLAPTypes.d.ts

@@ -0,0 +1,5 @@
+export declare enum DBOLAPType {
+    ClickHouse = "ClickHouse",
+    Druid = "Druid",
+    Snowflake = "Snowflake"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hemia/db-connector",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Hemia Database Conector",
   "main": "dist/hemia-db-connector.js",
   "module": "dist/hemia-db-connector.esm.js",
@@ -40,6 +40,7 @@
   "author": "Hemia Technologies",
   "license": "MIT",
   "dependencies": {
+    "@clickhouse/client": "^1.14.0",
     "eslint": "^9.21.0",
     "mongoose": "^8.8.2"
   },
@@ -48,15 +49,14 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/chai": "^4.3.17",
+    "@types/jest": "^29.5.14",
     "@types/mocha": "^10.0.7",
     "@types/mssql": "^9.1.5",
     "@types/node": "^22.3.0",
     "@typescript-eslint/eslint-plugin": "^8.5.0",
-    "@types/jest": "^29.5.14",
     "chai": "^4.2.0",
     "events": "^3.3.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
     "mocha": "^10.7.3",
     "mssql": "^11.0.1",
     "mysql2": "^3.11.0",
@@ -64,6 +64,7 @@
     "rollup": "^4.20.0",
     "rollup-plugin-typescript2": "^0.36.0",
     "sequelize": "^6.37.3",
+    "ts-jest": "^29.2.5",
     "ts-node": "^8.9.0",
     "typescript": "^5.5.4"
   },