@dbcube/cli 1.0.1

package/src/utils/ConfigFileUtils.js

@@ -0,0 +1,295 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Clase para manejar operaciones sobre el archivo de configuración
+ */
+class ConfigFileUtils {
+    /**
+     * Obtiene la ruta al archivo de configuración
+     * @returns {string} - Ruta al archivo de configuración
+     */
+    static getConfigPath() {
+        // Usar la ruta raíz del proyecto
+        const rootPath = path.resolve(process.cwd());
+        const configPath = path.join(rootPath, 'dbcube.config.js');
+        return configPath;
+    }
+
+    /**
+     * Obtiene los nombres de las bases de datos configuradas en dbcube.config.js
+     * @returns {Promise<Array<string>>} - Array con los nombres de las bases de datos
+     */
+    static async getConfiguredDatabases() {
+        try {
+            // Ruta al archivo de configuración
+            const configPath = this.getConfigPath();
+            
+            // Comprobar si el archivo existe
+            if (!fs.existsSync(configPath)) {
+                ConfigFileUtils.crearArchivoConfig(configPath);
+            }
+            
+            return this.loadDatabasesFromPath(configPath);
+        } catch (error) {
+            throw new Error('Error al obtener las bases de datos configuradas:', error);
+        }
+    }
+    
+    /**
+     * Carga las bases de datos desde una ruta específica
+     * @param {string} configPath - Ruta al archivo de configuración
+     * @returns {Array<string>} - Nombres de las bases de datos
+     */
+    static loadDatabasesFromPath(configPath) {
+        try {
+            // Borrar la caché del módulo para asegurarnos de cargar la versión más reciente
+            delete require.cache[require.resolve(configPath)];
+            
+            // Cargar el archivo de configuración
+            const config = require(configPath);
+            
+            // Crear una instancia temporal de Config para obtener los datos
+            const tempConfig = {
+                databases: {},
+                data: {},
+                set: function(configData) {
+                    this.data = configData;
+                    if (configData.databases) {
+                        this.databases = configData.databases;
+                    }
+                },
+                getAllDatabases: function() {
+                    return this.databases;
+                }
+            };
+            
+            // Ejecutar la función de configuración
+            config(tempConfig);
+            
+            // Obtener los nombres de las bases de datos
+            const databaseNames = Object.keys(tempConfig.getAllDatabases());
+            const arrayDatabases = [];
+            for (const database of databaseNames) {
+                arrayDatabases.push({
+                    name: database,
+                    type: tempConfig.getAllDatabases()[database].type
+                });
+            }
+            return arrayDatabases;
+        } catch (error) {
+            console.error('Error al cargar las bases de datos desde ' + configPath, error);
+            return ['test1']; // Valor por defecto
+        }
+    }
+
+    /**
+     * Agrega una nueva configuración de base de datos al archivo de configuración
+     * @param {string} databaseName - Nombre de la base de datos
+     * @param {string} databaseType - Tipo de la base de datos (mysql, postgresql, etc.)
+     * @param {Object} databaseConfig - Configuración de la base de datos
+     * @returns {Promise<boolean>} - Retorna true si se agregó correctamente
+     */
+    static async addDatabaseConfig(databaseName, databaseType, databaseConfig) {
+        try {
+            // Ruta al archivo de configuración
+            const configPath = this.getConfigPath();
+            
+            // Verificar si el archivo existe
+            if (!fs.existsSync(configPath)) {
+                ConfigFileUtils.crearArchivoConfig(configPath);
+            }
+            
+            // Leer el archivo de configuración
+            let configContent = fs.readFileSync(configPath, 'utf8');
+            
+            // Convertir los valores de PORT a número si es necesario
+            if (databaseConfig.PORT && typeof databaseConfig.PORT === 'string') {
+                databaseConfig.PORT = parseInt(databaseConfig.PORT, 10);
+            }
+            
+            // Crear el texto de la nueva configuración
+            const newDatabaseConfigText = this.createDatabaseConfigText(databaseName, databaseType, databaseConfig);
+            
+            // Buscar la posición donde insertar la nueva configuración
+            const insertPosition = configContent.indexOf('databases: {') + 'databases: {'.length;
+            if (insertPosition === -1 + 'databases: {'.length) {
+                throw new Error('No se encontró la sección de bases de datos en el archivo de configuración');
+            }
+            
+            // Insertar la nueva configuración
+            configContent = configContent.slice(0, insertPosition) + 
+                            newDatabaseConfigText + 
+                            configContent.slice(insertPosition);
+            
+            // Escribir el archivo actualizado
+            fs.writeFileSync(configPath, configContent, 'utf8');
+            
+            return true;
+        } catch (error) {
+            console.error('\nError al agregar la configuración de la base de datos:', error);
+            return false;
+        }
+    }
+    
+    /**
+     * Crea el texto de configuración para una base de datos
+     * @param {string} databaseName - Nombre de la base de datos
+     * @param {string} databaseType - Tipo de la base de datos
+     * @param {Object} databaseConfig - Configuración de la base de datos
+     * @returns {string} - Texto de configuración formateado
+     */
+    static createDatabaseConfigText(databaseName, databaseType, databaseConfig) {
+        if(databaseType=="sqlite"){
+            const arrayDataEnv = [
+                "DBCUBE_"+databaseName.toUpperCase()+"_DATABASE"+"="+databaseConfig.DATABASE
+            ];
+            ConfigFileUtils.updateDotenv(arrayDataEnv)
+            return `
+                ${databaseName}: {
+                    type: "${databaseType}",
+                    config:{
+                        DATABASE: process.env.${arrayDataEnv[0].split("=")[0]}
+                    }
+                },`;
+        }else{
+            const arrayDataEnv = [
+                "DBCUBE_"+databaseName.toUpperCase()+"_HOST"+"="+databaseConfig.HOST,
+                "DBCUBE_"+databaseName.toUpperCase()+"_PORT"+"="+databaseConfig.PORT,
+                "DBCUBE_"+databaseName.toUpperCase()+"_DATABASE"+"="+databaseConfig.DATABASE,
+                "DBCUBE_"+databaseName.toUpperCase()+"_USER"+"="+databaseConfig.USER,
+                "DBCUBE_"+databaseName.toUpperCase()+"_PASSWORD"+"="+databaseConfig.PASSWORD,
+            ];
+            ConfigFileUtils.updateDotenv(arrayDataEnv)
+            return `
+                ${databaseName}: {
+                    type: "${databaseType}",
+                    config:{
+                        HOST: process.env.${arrayDataEnv[0].split("=")[0]},
+                        USER: process.env.${arrayDataEnv[3].split("=")[0]},
+                        PASSWORD: process.env.${arrayDataEnv[4].split("=")[0]},
+                        DATABASE: process.env.${arrayDataEnv[2].split("=")[0]},
+                        PORT: parseInt(process.env.${arrayDataEnv[1].split("=")[0]}, 10)
+                    }
+                },`;
+        }
+    }
+
+    /**
+     * Crea o actualiza un archivo .env con un array de strings tipo "KEY=VALUE"
+     * @param {string} ruta - Ruta donde se creará o modificará el archivo `.env`
+     * @param {string[]} entries - Array de strings tipo "KEY=VALUE"
+     */
+    static updateDotenv(entries) {
+        const rutaAbsoluta = path.resolve(process.cwd(), '.env');
+        let contenidoExistente = '';
+    
+        try {
+            // Verificar si la ruta existe y qué tipo de archivo es
+            if (fs.existsSync(rutaAbsoluta)) {
+                const stats = fs.statSync(rutaAbsoluta);
+                
+                if (stats.isDirectory()) {
+                    // Si .env es un directorio, elimínalo y crea el archivo
+                    console.warn(`⚠️  Se encontró un directorio llamado .env, eliminándolo para crear el archivo`);
+                    fs.rmSync(rutaAbsoluta, { recursive: true, force: true });
+                } else if (stats.isFile()) {
+                    // Si es un archivo, leer su contenido
+                    contenidoExistente = fs.readFileSync(rutaAbsoluta, 'utf8');
+                }
+            }
+        } catch (error) {
+            if (error.code === 'EISDIR') {
+                console.warn(`⚠️  Conflicto detectado: .env existe como directorio, eliminándolo`);
+                try {
+                    fs.rmSync(rutaAbsoluta, { recursive: true, force: true });
+                } catch (removeError) {
+                    console.error(`❌ Error al eliminar directorio .env:`, removeError.message);
+                    throw removeError;
+                }
+            } else {
+                console.error(`❌ Error al leer .env:`, error.message);
+                throw error;
+            }
+        }
+    
+        // Procesar contenido existente
+        const lineas = contenidoExistente ? contenidoExistente.split('\n') : [];
+        const mapaEnv = {};
+    
+        // Construir mapa de claves actuales
+        for (let linea of lineas) {
+            const match = linea.match(/^([\w.-]+)=(.*)$/);
+            if (match) {
+                const [, key, value] = match;
+                mapaEnv[key] = value;
+            }
+        }
+    
+        // Procesar nuevas entradas
+        for (const entry of entries) {
+            const [key, ...valueParts] = entry.split('=');
+            const value = valueParts.join('='); // En caso de que el valor contenga '='
+            
+            if (!key || value === undefined) {
+                console.warn(`⚠️  Entrada inválida ignorada: ${entry}`);
+                continue;
+            }
+    
+            if (!mapaEnv.hasOwnProperty(key)) {
+                // Agregar nueva línea si no existe
+                lineas.push(`${key}=${value}`);
+                console.log(`➕ Agregando nueva variable: ${key}`);
+            } else if (mapaEnv[key] !== value) {
+                // Actualizar línea existente
+                const index = lineas.findIndex(line => line.startsWith(`${key}=`));
+                if (index !== -1) {
+                    lineas[index] = `${key}=${value}`;
+                    console.log(`🔄 Actualizando variable: ${key}`);
+                }
+            }
+            // Si existe y tiene el mismo valor, no se hace nada
+        }
+    
+        try {
+            // Filtrar líneas vacías al final y asegurar que termine con salto de línea
+            const contenidoFinal = lineas.filter(linea => linea.trim() !== '').join('\n');
+            
+            // Escribir de nuevo el archivo .env
+            fs.writeFileSync(rutaAbsoluta, contenidoFinal + '\n', 'utf8');
+            console.log(`✅ .env actualizado en: ${rutaAbsoluta}`);
+            
+        } catch (error) {
+            console.error(`❌ Error al escribir .env:`, error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Crea un archivo de configuración base para dbcube en la ruta especificada.
+     * @param {string} rutaDestino - Ruta completa donde se debe crear el archivo.
+     */
+    static crearArchivoConfig(rutaDestino) {
+        const contenido = `require('dotenv').config({ quiet: true });
+
+    module.exports = function (config) {
+        config.set({
+            databases: {
+            }
+        });  
+    };
+    `;
+
+        // Asegurarse de que el directorio existe
+        const dir = path.dirname(rutaDestino);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        // Escribir archivo
+        fs.writeFileSync(rutaDestino, contenido, 'utf8');
+        //console.log(`\n✅ Archivo creado en: ${rutaDestino}`);
+    }
+}
+
+module.exports = ConfigFileUtils; 

package/src/utils/FileUtils.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+
+class FileUtils {
+  /**
+   * Verifica si un archivo existe (asincrónico).
+   * @param {string} filePath - Ruta del archivo.
+   * @returns {Promise<boolean>} - True si el archivo existe, false si no.
+   */
+  static async fileExists(filePath) {
+    return new Promise((resolve) => {
+      fs.access(path.resolve(filePath), fs.constants.F_OK, (err) => {
+        resolve(!err);
+      });
+    });
+  }
+
+  /**
+   * Verifica si un archivo existe (sincrónico).
+   * @param {string} filePath - Ruta del archivo.
+   * @returns {boolean} - True si el archivo existe, false si no.
+   */
+  static fileExistsSync(filePath) {
+    try {
+      fs.accessSync(path.resolve(filePath), fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static extractDatabaseName(input) {
+    const match = input.match(/@database\(["']?([\w-]+)["']?\)/);
+    return match ? match[1] : null;
+  }
+
+   /**
+   * Lee recursivamente archivos que terminan en un sufijo dado y los ordena numéricamente.
+   * @param {string} dir - Directorio base (relativo o absoluto).
+   * @param {string} suffix - Sufijo de archivo (como 'table.cube').
+   * @returns {string[]} - Rutas absolutas de los archivos encontrados y ordenados.
+   */
+   static getCubeFilesRecursively(dir, suffix) {
+    const baseDir = path.resolve(dir); // ✅ Asegura que sea absoluto
+    const cubeFiles = [];
+
+    function recurse(currentDir) {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          recurse(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith(suffix)) {
+          cubeFiles.push(fullPath); // Ya es absoluta
+        }
+      }
+    }
+
+    recurse(baseDir);
+
+    // Ordenar por número si los archivos comienzan con un número
+    cubeFiles.sort((a, b) => {
+      const aNum = parseInt(path.basename(a));
+      const bNum = parseInt(path.basename(b));
+      return (isNaN(aNum) ? 0 : aNum) - (isNaN(bNum) ? 0 : bNum);
+    });
+
+    return cubeFiles;
+  }
+}
+
+module.exports = FileUtils;