querymongo 1.1.0 → 1.1.1

package/README.md

@@ -45,32 +45,35 @@ src/
 - **Dependency Inversion**: Se depende de la interface `IConverter`, no de implementaciones
 - **Single Responsibility**: Cada conversor tiene un propósito único
 
-## 🚀 Instalación
+## 💻 Uso
+
+### 🚀 Instalación Global - CLI
+
+Para instalar QueryMongo globalmente en tu máquina:
 
 ```bash
-npm install
-npm run build
+npm i querymongo -g
 ```
 
-## 💻 Uso
-
-### Modo CLI - Interactivo
+Luego ejecuta desde cualquier directorio:
 
 ```bash
-npm run dev -- interactive
+querymongo
 ```
 
-Ingresa queries SQL y recibe instantáneamente el equivalente en MongoDB.
+### 🛠️ Desarrollo Local
 
-### Usar como librería
+Para trabajar en el desarrollo del proyecto:
 
-```typescript
-import { mongoConverter } from "./src/application/MongoConverter.ts";
-
-const result = mongoConverter.convert("SELECT name FROM users WHERE age > 18");
-console.log(result);
+```bash
+git clone https://github.com/rubsuadav/querymongo
+cd querymongo
+npm install
+npm run dev interactive
 ```
 
+Esto abrirá la CLI interactiva donde puedes ingresar queries SQL y recibir instantáneamente el equivalente en MongoDB.
+
 ## 📚 Ejemplos de Conversión
 
 ### SELECT con proyección
@@ -141,36 +144,6 @@ npm test
 
 Cobertura: **100%** en líneas y funciones.
 
-## 📖 API Reference
-
-### `MongoConverter`
-
-Clase principal para conversiones.
-
-```typescript
-class MongoConverter {
-  convert(sql: string): Record<string, any>;
-}
-```
-
-**Parámetros:**
-
-- `sql` (string): Query SQL a convertir
-
-**Retorna:** Objeto con estructura MongoDB
-
-**Lanza:** Error si el query SQL no es soportado
-
-### Exports Públicos
-
-```typescript
-export {
-  MongoConverter,
-  mongoConverter,
-} from "./src/application/MongoConverter.ts";
-export type { IConverter } from "./src/domain/interfaces/Converter.ts";
-```
-
 ## 🔧 Operadores Soportados
 
 | SQL         | MongoDB  |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "querymongo",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "SQL to MongoDB Query Converter CLI",
   "main": "dist/cli/main.js",
   "bin": "dist/cli/main.js",

package/.github/workflows/ci.yml

@@ -1,61 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: ["master"]
-  pull_request:
-    branches: ["master"]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v5
-        with:
-          node-version: 22
-          cache: "npm"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build --if-present
-
-      - name: Test
-        run: npm test
-
-  release:
-    needs: build
-    if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      issues: write
-      pull-requests: write
-      id-token: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v5
-        with:
-          node-version: 22
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
-        run: npm audit signatures
-
-      - name: Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npx semantic-release

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "js/ts.tsdk.path": "node_modules\\typescript\\lib"
-}

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"));