querymongo 1.1.0 → 1.3.0

package/ARCHITECTURE.md

@@ -1,286 +0,0 @@
-# 🏗️ Arquitectura y Principios SOLID
-
-## Resumen Ejecutivo
-
-QueryMongo está diseñado siguiendo los 5 principios SOLID, Clean Code y DRY (Don't Repeat Yourself). El código es modular, escalable y fácil de mantener.
-
-## 📐 Principios SOLID Aplicados
-
-### 1. **S - Single Responsibility Principle**
-
-Cada clase/función tiene una única responsabilidad:
-
-```typescript
-// ✅ BIEN: SelectConverter solo convierte SELECT
-export const SelectConverter: IConverter = {
-  can: (statement) => statement.toLowerCase().startsWith("select"),
-  convert: (query) => {
-    /* lógica solo para SELECT */
-  },
-};
-
-// ✅ BIEN: buildProjection solo construye proyecciones
-export const buildProjection = (fields: string[]): Record<string, 1 | 0> => {
-  // lógica única
-};
-```
-
-### 2. **O - Open/Closed Principle**
-
-El código está abierto a extensión pero cerrado a modificación:
-
-```typescript
-// Agregar un nuevo tipo de query (ej: TRUNCATE) es solo:
-export const TruncateConverter: IConverter = {
-  can: (statement) => statement.toLowerCase().startsWith("truncate"),
-  convert: (query) => {
-    /* implementación */
-  },
-};
-
-// Y registrarlo en ConverterFactory sin tocar código existente:
-const CONVERTERS: IConverter[] = [
-  SelectConverter,
-  CreateConverter,
-  UpdateConverter,
-  DeleteConverter,
-  TruncateConverter, // ← Nueva línea solamente
-];
-```
-
-### 3. **L - Liskov Substitution Principle**
-
-Todos los conversores implementan la interface `IConverter`:
-
-```typescript
-interface IConverter {
-  can(statement: string): boolean;
-  convert(query: any): Record<string, any>;
-}
-
-// SelectConverter, CreateConverter, UpdateConverter, DeleteConverter
-// pueden usarse indistintamente donde se espera IConverter
-```
-
-### 4. **I - Interface Segregation Principle**
-
-Las interfaces son mínimas y específicas:
-
-```typescript
-// Interface pequeña y enfocada
-interface IConverter {
-  can(statement: string): boolean;
-  convert(query: any): Record<string, any>;
-}
-
-// No hay métodos innecesarios, solo lo que se necesita
-```
-
-### 5. **D - Dependency Inversion Principle**
-
-Dependemos de abstracciones, no de implementaciones concretas:
-
-```typescript
-// MongoConverter depende de la interface, no de las implementaciones
-const converter = getConverter(sql); // Retorna IConverter, no una clase específica
-
-// Si el parser cambia, solo cambio sqlParser.ts
-// Si un conversor cambia, los otros no se ven afectados
-```
-
-## 🏛️ Arquitectura en Capas
-
-```
-┌─────────────────────────────────────┐
-│         CLI Layer (main.ts)         │
-│  - Commander para argumentos        │
-│  - Interfaz interactiva             │
-└─────────────────────────────────────┘
-           ↓
-┌─────────────────────────────────────┐
-│    Application Layer                │
-│    (MongoConverter.ts)              │
-│  - Orquestación del flujo           │
-│  - Error handling                   │
-└─────────────────────────────────────┘
-           ↓
-┌─────────────────────────────────────┐
-│    Infrastructure Layer             │
-│  - Parsers (sqlParser.ts)           │
-│  - Conversores (SelectConverter...) │
-│  - Utilidades (queryUtils.ts)       │
-└─────────────────────────────────────┘
-           ↓
-┌─────────────────────────────────────┐
-│    Domain Layer                     │
-│  - Interfaces (IConverter)          │
-│  - Tipos y contratos                │
-└─────────────────────────────────────┘
-           ↓
-┌─────────────────────────────────────┐
-│    External Dependencies            │
-│  - node-sql-parser                  │
-│  - lodash                           │
-│  - chalk, commander                 │
-└─────────────────────────────────────┘
-```
-
-## 🎯 Patrones de Diseño
-
-### Strategy Pattern
-
-Cada tipo de SQL es una estrategia diferente:
-
-```typescript
-// SelectConverter es una estrategia
-const SelectConverter: IConverter = {
-  can: (stmt) => stmt.startsWith("select"),
-  convert: (query) => {
-    /* convertir SELECT */
-  },
-};
-
-// UpdateConverter es una estrategia diferente
-const UpdateConverter: IConverter = {
-  can: (stmt) => stmt.startsWith("update"),
-  convert: (query) => {
-    /* convertir UPDATE */
-  },
-};
-
-// Factory selecciona la estrategia correcta
-const converter = CONVERTERS.find((c) => c.can(sql));
-```
-
-### Factory Pattern
-
-`ConverterFactory` determina qué conversor usar:
-
-```typescript
-export const getConverter = (statement: string): IConverter | null => {
-  return CONVERTERS.find((converter) => converter.can(statement)) || null;
-};
-```
-
-### Adapter Pattern
-
-`sqlParser.ts` adapta `node-sql-parser` a una interfaz limpia:
-
-```typescript
-// Internamente usa node-sql-parser
-const sqlParser = new Parser();
-
-// Pero expone una interfaz simple
-export const parseSqlQuery = (sql: string) => sqlParser.parse(sql);
-```
-
-## 🧹 DRY - Don't Repeat Yourself
-
-Toda lógica compartida está centralizada:
-
-```typescript
-// queryUtils.ts - Funciones reutilizables
-export const normalizeFieldName = (field: string): string => {
-  return field.trim().replace(/`|"/g, '');
-};
-
-export const buildProjection = (fields: string[]): Record<string, 1 | 0> => {
-  if (fields === '*') return {};
-  return Object.fromEntries(normalizeFieldNames(fields).map(f => [f, 1]));
-};
-
-export const buildFilter = (condition: any): Record<string, any> => {
-  // Lógica única para construir filters
-};
-
-// Los conversores reutilizan estas funciones
-SelectConverter usa buildProjection y buildFilter
-UpdateConverter usa buildFilter
-DeleteConverter usa buildFilter
-```
-
-## 🎓 Beneficios de esta Arquitectura
-
-| Beneficio          | Impacto                                      |
-| ------------------ | -------------------------------------------- |
-| **Mantenibilidad** | Cambios localizados, sin efectos secundarios |
-| **Escalabilidad**  | Agregar nuevos tipos de query es trivial     |
-| **Testabilidad**   | 100% cobertura fácil de lograr               |
-| **Reutilización**  | Utilidades compartidas evitan duplicación    |
-| **Legibilidad**    | Código claro, intenciones obvias             |
-| **Flexibilidad**   | Fácil refactorizar componentes               |
-
-## 📊 Flujo de Conversión
-
-```
-SQL Query
-   ↓
-normalizeQuery()
-   ↓
-parseSqlQuery()
-   ↓
-AST (Abstract Syntax Tree)
-   ↓
-getConverter(statement)
-   ↓
-Estrategia seleccionada
-   ↓
-converter.convert(ast)
-   ↓
-MongoDB Query Object
-```
-
-## 🔌 Extensibilidad
-
-Para agregar soporte para un nuevo tipo de query:
-
-1. **Crear nuevo conversor**:
-
-```typescript
-export const GroupByConverter: IConverter = {
-  can: (stmt) => stmt.includes("GROUP BY"),
-  convert: (query) => {
-    /* implementación */
-  },
-};
-```
-
-2. **Registrar en factory**:
-
-```typescript
-const CONVERTERS: IConverter[] = [
-  SelectConverter,
-  CreateConverter,
-  UpdateConverter,
-  DeleteConverter,
-  GroupByConverter, // ← Agregar aquí
-];
-```
-
-3. **Escribir tests** - El resto funciona automáticamente gracias a la arquitectura.
-
-## 📈 Métricas de Calidad
-
-- **Test Coverage**: 100%
-- **Cyclomatic Complexity**: Bajo (funciones simples y enfocadas)
-- **Lines of Code**: Mínimo (código conciso)
-- **SOLID Score**: 5/5
-- **Code Duplication**: ~0% (todo compartido)
-
-## 🚀 Performance
-
-- **Parsing**: ~1-2ms por query
-- **Conversión**: <1ms
-- **Total**: <3ms por conversión
-- Sin dependencias pesadas, bundle mínimo
-
-## 🔐 Error Handling
-
-```typescript
-try {
-  const result = mongoConverter.convert(sql);
-} catch (error) {
-  // Error descriptivo
-  throw new Error(`Unsupported SQL statement: ${sql}...`);
-}
-```

package/examples.ts

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Ejemplos de uso de QueryMongo
- * Demuestra diferentes formas de usar la librería
- */
-import { mongoConverter } from "./src/application/MongoConverter.ts";
-import chalk from "chalk";
-
-interface Example {
-  title: string;
-  sql: string;
-  description?: string;
-}
-
-const examples: Example[] = [
-  {
-    title: "📌 SELECT Simple",
-    sql: "SELECT name, email FROM users",
-    description: "Selecciona campos específicos",
-  },
-  {
-    title: "🔍 SELECT con WHERE",
-    sql: "SELECT * FROM products WHERE price > 100",
-    description: "Filtra documentos con condición",
-  },
-  {
-    title: "📊 SELECT con WHERE y LIMIT",
-    sql: "SELECT name, age FROM users WHERE age >= 18 LIMIT 10",
-    description: "Proyección, filtro y límite combinados",
-  },
-  {
-    title: "➕ INSERT Simple",
-    sql: "INSERT INTO users (name, email, age) VALUES ('John Doe', 'john@example.com', 30)",
-    description: "Insertar un documento",
-  },
-  {
-    title: "✏️ UPDATE con WHERE",
-    sql: 'UPDATE users SET age = 31 WHERE name = "John Doe"',
-    description: "Actualizar documentos que cumplen condición",
-  },
-  {
-    title: "🗑️ DELETE con WHERE",
-    sql: "DELETE FROM users WHERE age < 18",
-    description: "Eliminar documentos que cumplen condición",
-  },
-];
-
-console.log(chalk.bold.blue("\n🚀 QueryMongo - Ejemplos de Uso\n"));
-console.log(chalk.gray("Convierte queries SQL a MongoDB format\n"));
-
-examples.forEach((example, index) => {
-  console.log(chalk.bold.cyan(`\n${index + 1}. ${example.title}`));
-  if (example.description) {
-    console.log(chalk.gray(`   ${example.description}`));
-  }
-
-  console.log(chalk.yellow("\n   SQL:"));
-  console.log(chalk.white(`   ${example.sql}`));
-
-  try {
-    const result = mongoConverter.convert(example.sql);
-
-    console.log(chalk.green("\n   📋 MongoDB Query:"));
-    const resultStr = JSON.stringify(result, null, 4)
-      .split("\n")
-      .map((line) => `   ${line}`)
-      .join("\n");
-    console.log(resultStr);
-  } catch (error) {
-    console.error(
-      chalk.red(
-        `   ❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`,
-      ),
-    );
-  }
-});
-
-console.log(chalk.bold.green("\n✨ Todos los ejemplos completados\n"));