utn-cli 2.0.49 → 2.0.51

package/commands/backend.js

@@ -149,7 +149,7 @@ export async function initBackend() {
   closeReadLine();
 }
 
-export async function updateBackend() {
+export async function updateBackend(opciones = { cerrarAlFinalizar: true }) {
   console.log('Actualizando el proyecto de backend...');
   const archivosAExcluir = ['InformacionDelModulo.json', 'rutas.js', 'Monitoreo.js', 'API.js', 'NOMBRE_DEL_CANONICO_DEL_PROYECTO.rest'];
   const directoriodePlantillas = path.join(__dirname, '../templates/backend');
@@ -166,11 +166,16 @@ export async function updateBackend() {
   fs.renameSync('gitignore', '.gitignore');
   await inicializarProyectoBackend();
   console.log('Proyecto de backend actualizado exitosamente.');
-  closeReadLine();
+  if (opciones.cerrarAlFinalizar) {
+    closeReadLine();
+  }
 }
 
-export async function addServiceBackend() {
-  let Servicio = await hacerPreguntaTrim('¿Cuál es el nombre del servicio?: ');
+export async function addServiceBackend(nombreServicio = null, opciones = { cerrarAlFinalizar: true }, tituloServicio = null, tableInfo = null) {
+  let Servicio = nombreServicio;
+  if (!Servicio) {
+    Servicio = await hacerPreguntaTrim('¿Cuál es el nombre del servicio?: ');
+  }
   Servicio = Servicio.replace(/\s/g, '');
   const rutaServicioDir = path.join(process.cwd(), 'servicios');
   const rutaRutaDir = path.join(process.cwd(), 'rutas');
@@ -182,7 +187,7 @@ export async function addServiceBackend() {
     fs.copyFileSync(templateServicioPath, newServicioPath);
   } else {
     console.error(`Error: Template Servicio1.js not found in ${rutaServicioDir}`);
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
@@ -192,7 +197,7 @@ export async function addServiceBackend() {
     fs.copyFileSync(templateRutaPath, newRutaPath);
   } else {
     console.error(`Error: Template Servicio1.js not found in ${rutaRutaDir}`);
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
@@ -201,86 +206,190 @@ export async function addServiceBackend() {
   if (fs.existsSync(rutaRutasJs)) {
     let contenidoRutasJs = fs.readFileSync(rutaRutasJs, 'utf-8');
     const nuevaRutaRequire = `const rutasDel${Servicio} = require('./${Servicio}.js');`;
-    contenidoRutasJs = contenidoRutasJs.replace(/\s*function asignarRutasAExpress\(app\) {/, `
-${nuevaRutaRequire}
+    
+    // Agregar require si no existe
+    if (!contenidoRutasJs.includes(nuevaRutaRequire)) {
+      contenidoRutasJs = contenidoRutasJs.replace(/function asignarRutasAExpress\(app\) \{/, `${nuevaRutaRequire}\n\nfunction asignarRutasAExpress(app) {`);
+    }
 
-function asignarRutasAExpress(app) {`);
-    contenidoRutasJs = contenidoRutasJs.replace(/app\.use\('\/Servicio1', rutasDelServicio1\);/, `app.use('/Servicio1', rutasDelServicio1);
-  app.use('/${Servicio}', rutasDel${Servicio});`);
+    // Agregar app.use al final de la función
+    const lineaAppUse = `  app.use('/${Servicio}', rutasDel${Servicio});`;
+    if (!contenidoRutasJs.includes(lineaAppUse)) {
+      // Buscamos el final de la función asignarRutasAExpress
+      contenidoRutasJs = contenidoRutasJs.replace(/(function asignarRutasAExpress\(app\) \{[\s\S]*?)(\n\})/, `$1\n${lineaAppUse}$2`);
+    }
+    
     fs.writeFileSync(rutaRutasJs, contenidoRutasJs);
   } else {
     console.error(`Error: rutas.js not found in ${rutaRutaDir}`);
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
+  // Si tenemos información de la tabla, generamos el CRUD
+  if (tableInfo) {
+    generarCRUDBackend(newServicioPath, newRutaPath, Servicio, tableInfo);
+  }
+
+  // Reemplazar el título amigable si se proporciona
+  if (tituloServicio) {
+    reemplazarContenidoEnArchivo(newServicioPath, "const NombreDelServicio = 'Servicio1';", `const NombreDelServicio = '${tituloServicio}';`);
+  }
+
   reemplazarContenidoEnArchivo(newServicioPath, 'Servicio1', Servicio);
   reemplazarContenidoEnArchivo(newRutaPath, 'Servicio1', Servicio);
 
-  // Cross-module interaction with Frontend - this needs a different approach in a unified CLI
-  // For now, I'll comment out the frontend-related logic as it breaks modularity and
-  // assumes frontend project structure relative to backend, which might not be true in a monorepo.
-  // This should be handled by a dedicated 'utn frontend add-service' command or similar.
-  /*
-  const rutaArchivoJson = path.join(process.cwd(), 'InformacionDelModulo.json');
-  const contenidoJson = fs.readFileSync(rutaArchivoJson, 'utf8');
-  const informacion = JSON.parse(contenidoJson);
-  const nombreDelFrontend = informacion.NOMBRE_DEL_REPOSITORIO_DE_FRONTEND;
-  const rutaDelFrontEnd = path.join(process.cwd(), '..', nombreDelFrontend, '/src/app/Paginas'); // This path is problematic
-  const servicioEnMinuscula = Servicio.toLowerCase();
-  const rutaOrigen = path.join(rutaDelFrontEnd, '/gestion-tabla');
-  const nombreCarpetaDestino = `/gestion-tabla-${servicioEnMinuscula}`;
-  const rutaDestino = path.join(rutaDelFrontEnd, nombreCarpetaDestino);
+  console.log(`Servicio ${Servicio} agregado exitosamente.`);
+  if (opciones.cerrarAlFinalizar) {
+    closeReadLine();
+  }
+}
+
+function generarCRUDBackend(servicioPath, rutaPath, nombreServicio, tableInfo) {
+  const { dbName, tableName, columns, primaryKey } = tableInfo;
+  const dbNameSinDB = dbName.endsWith('-db') ? dbName.slice(0, -3) : dbName;
+  
+  // 1. Generar funciones en el Servicio
+  let contenidoServicio = fs.readFileSync(servicioPath, 'utf-8');
+  
+  const colNames = columns.map(c => `\`${c.name}\``).join(', ');
+  const colPlaceholders = columns.map(() => '?').join(', ');
+  const colUpdates = columns.filter(c => c.name !== primaryKey).map(c => `\`${c.name}\` = ?`).join(', ');
+  const colUpdateParams = columns.filter(c => c.name !== primaryKey).map(c => `Datos.${c.name}`).join(', ');
+  const colInsertParams = columns.map(c => `Datos.${c.name}`).join(', ');
+
+  const crudFunciones = `
+  async listar() {
+    return await ejecutarConsulta("SELECT ${colNames} FROM \`${dbNameSinDB}\`.\`${tableName}\` COLLATE utf8mb4_spanish_ci");
+  }
+
+  async agregar(Datos) {
+    return ejecutarConsulta("INSERT INTO \`${dbNameSinDB}\`.\`${tableName}\` (${colNames}, \`LastUpdate\`, \`LastUser\`) VALUES (${colPlaceholders}, NOW(4), ?)"
+      , [${colInsertParams}, Datos.LastUser]);
+  }
+
+  async borrar(Datos) {
+    return ejecutarConsulta("DELETE FROM \`${dbNameSinDB}\`.\`${tableName}\` WHERE \`${primaryKey}\` = ?"
+      , [Datos.${primaryKey}]);
+  }
+
+  async actualizar(Datos) {
+    return ejecutarConsulta("UPDATE \`${dbNameSinDB}\`.\`${tableName}\` SET ${colUpdates}, \`LastUpdate\` = NOW(4), \`LastUser\` = ? WHERE \`${primaryKey}\` = ?"
+      , [${colUpdateParams}, Datos.LastUser, Datos.${primaryKey}]);
+  }
+
+  async detalle(${primaryKey}) {
+    return await ejecutarConsulta("SELECT ${colNames} FROM \`${dbNameSinDB}\`.\`${tableName}\` WHERE \`${primaryKey}\` = ?"
+      , [${primaryKey}]);
+  }
+
+  async reporte() {
+    return await Miscelaneas.convertirACSV(await this.listar());
+  }
+`;
+
+  // Insertar antes del último cierre de llave
+  contenidoServicio = contenidoServicio.replace(/\n\}\s*\nmodule\.exports/, crudFunciones + '\n}\n\nmodule.exports');
+  fs.writeFileSync(servicioPath, contenidoServicio);
+
+  // 2. Generar rutas
+  let contenidoRutas = fs.readFileSync(rutaPath, 'utf-8');
+  
+  const crudRutas = `
+Router.get('/listar', async (solicitud, respuesta, next) => {
   try {
-    fs.cpSync(rutaOrigen, rutaDestino, { recursive: true });
+    if (await Miscelaneo.validarTokenV2(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await ${nombreServicio}.listar(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible listar los registros';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, \`Dirección IP: \${solicitud.ip}\`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
   } catch (error) {
-    console.error('Hubo un error al copiar la carpeta:', error);
+    next(error);
   }
-  const archivos = fs.readdirSync(rutaDestino);
-  archivos.forEach(archivo => {
-    if (archivo.startsWith('gestion-tabla.component')) {
-      const nuevoNombre = archivo.replace('gestion-tabla', `gestion-tabla-${servicioEnMinuscula}`);
-      const rutaArchivoViejo = path.join(rutaDestino, archivo);
-      const rutaArchivoNuevo = path.join(rutaDestino, nuevoNombre);
-      fs.renameSync(rutaArchivoViejo, rutaArchivoNuevo);
+});
+
+Router.post('/agregar', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarTokenV2(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = solicitud.body;
+        Datos.LastUser = await Miscelaneo.generarLastUser(solicitud);
+        return respuesta.json({ body: await ${nombreServicio}.agregar(Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible agregar el registro';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, \`Dirección IP: \${solicitud.ip}\`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
     }
-  });
-  const rutaArchivoTs = path.join(rutaDestino, `/gestion-tabla-${servicioEnMinuscula}.component.ts`);
-  let contenidoTs = fs.readFileSync(rutaArchivoTs, 'utf8');
-  contenidoTs = contenidoTs.replace(
-    /gestion-tabla\.component/g,
-    `gestion-tabla-${servicioEnMinuscula}.component`
-  );
-  const servicioCapitalizado = Servicio.charAt(0).toUpperCase() + Servicio.slice(1);
-  contenidoTs = contenidoTs.replace(
-    /export class GestionTablaComponent/,
-    `export class GestionTabla${servicioCapitalizado}Component`
-  );
-  fs.writeFileSync(rutaArchivoTs, contenidoTs, 'utf8');
-  const rutaAppRoutes = path.join(rutaDelFrontEnd, '../app.routes.ts');
-  const nombreComponente = `GestionTabla${servicioCapitalizado}Component`;
-  const rutaComponente = `./Paginas/gestion-tabla-${servicioEnMinuscula}/gestion-tabla-${servicioEnMinuscula}.component`;
-  const nuevaLineaImport = `import { ${nombreComponente} } from '${rutaComponente}';`;
-  const nuevaLineaRuta = `,
-  { path: '${servicioEnMinuscula}', component: ${nombreComponente} }`;
-  let contenidoRoutes = fs.readFileSync(rutaAppRoutes, 'utf8');
-  contenidoRoutes = contenidoRoutes.replace(
-    /\s*export const routes: Routes = \[/,
-    `
-${nuevaLineaImport}
-
-export const routes: Routes = [`
-  );
-  contenidoRoutes = contenidoRoutes.replace(
-    /\s*];/,
-    `${nuevaLineaRuta}
-];`
-  );
-  fs.writeFileSync(rutaAppRoutes, contenidoRoutes, 'utf8');
-  */
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
 
-  console.log(`Servicio ${Servicio} agregado exitosamente.`);
-  closeReadLine();
+Router.post('/actualizar', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarTokenV2(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = solicitud.body;
+        Datos.LastUser = await Miscelaneo.generarLastUser(solicitud);
+        return respuesta.json({ body: await ${nombreServicio}.actualizar(Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible actualizar el registro';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, \`Dirección IP: \${solicitud.ip}\`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/borrar', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarTokenV2(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await ${nombreServicio}.borrar(solicitud.body), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible borrar el registro';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, \`Dirección IP: \${solicitud.ip}\`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/reporte', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarTokenV2(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        respuesta.header('Content-Type', 'text/csv; charset=utf-8');
+        respuesta.attachment('Datos.csv');
+        return respuesta.send(encodeURI(await ${nombreServicio}.reporte()));
+      } catch (error) {
+        const MensajeDeError = 'No fue posible generar el reporte';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, \`Dirección IP: \${solicitud.ip}\`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+`;
+
+  contenidoRutas = contenidoRutas.replace(/module\.exports = Router;/, crudRutas + '\nmodule.exports = Router;');
+  fs.writeFileSync(rutaPath, contenidoRutas);
 }
 
 export function showBackendVersion() {

package/commands/createComponent.js

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+import { addServiceBackend } from './backend.js';
+import { cloneFrontendComponent } from './frontend.js';
+import { closeReadLine, hacerPreguntaTrim } from '../utils/index.js';
+
+export async function createComponent() {
+  const currentDir = process.cwd();
+  
+  const nombreServicio = await hacerPreguntaTrim('¿Cuál es el nombre del nuevo servicio/componente? (Nombre técnico, ej: Incapacidades): ');
+  if (!nombreServicio) {
+    console.error('El nombre es requerido.');
+    closeReadLine();
+    return;
+  }
+
+  const tituloCard = await hacerPreguntaTrim('Ingrese el título para la tarjeta del frontend (ej: Gestión de Incapacidades): ');
+  const descripcionCard = await hacerPreguntaTrim('Ingrese la descripción para la tarjeta del frontend: ');
+
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  const directories = entries.filter(entry => entry.isDirectory());
+
+  // Buscar información de la tabla en la base de datos
+  let tableInfo = null;
+  const dbDir = directories.find(d => d.name.toLowerCase().includes('bd') || d.name.toLowerCase().includes('db'));
+  
+  if (dbDir) {
+    const sqlPath = path.join(currentDir, dbDir.name, 'docker-scripts/1-crear estructura.sql');
+    if (fs.existsSync(sqlPath)) {
+      console.log(`Buscando tabla para el servicio "${tituloCard}" en ${sqlPath}...`);
+      tableInfo = findTableByComment(sqlPath, tituloCard);
+      if (tableInfo) {
+        console.log(`Tabla encontrada: ${tableInfo.tableName} en la base de datos ${tableInfo.dbName}`);
+      } else {
+        console.log('No se encontró una tabla con un comentario que coincida con el título del servicio.');
+      }
+    }
+  }
+
+  let foundBackend = false;
+  let foundFrontend = false;
+
+  for (const dir of directories) {
+    const dirName = dir.name.toLowerCase();
+    const fullPath = path.join(currentDir, dir.name);
+
+    if (dirName.includes('back')) {
+      console.log(`\nAgregando servicio a Backend en: ${dir.name}`);
+      process.chdir(fullPath);
+      try {
+        await addServiceBackend(nombreServicio, { cerrarAlFinalizar: false }, tituloCard, tableInfo);
+        foundBackend = true;
+      } catch (error) {
+        console.error(`Error al agregar servicio en ${dir.name}:`, error);
+      }
+      process.chdir(currentDir);
+    } else if (dirName.includes('front')) {
+      console.log(`\nAgregando componente a Frontend en: ${dir.name}`);
+      process.chdir(fullPath);
+      try {
+        await cloneFrontendComponent(nombreServicio, tituloCard, descripcionCard, { cerrarAlFinalizar: false }, tableInfo);
+        foundFrontend = true;
+      } catch (error) {
+        console.error(`Error al clonar componente en ${dir.name}:`, error);
+      }
+      process.chdir(currentDir);
+    }
+  }
+
+  if (!foundBackend && !foundFrontend) {
+    console.log('No se encontraron carpetas con "back" o "front" para procesar.');
+  } else {
+    console.log('\nProceso de creación de componente finalizado.');
+  }
+  
+  closeReadLine();
+}
+
+function findTableByComment(sqlPath, serviceTitle) {
+  const content = fs.readFileSync(sqlPath, 'utf-8');
+  
+  // Regex para encontrar tablas y sus comentarios
+  // Buscamos CREATE OR REPLACE TABLE `db`.`table` ... COMMENT = '...serviceTitle...'
+  const tableRegex = /CREATE OR REPLACE TABLE `(.+?)`\.`(.+?)` \(([\s\S]+?)\) ENGINE = InnoDB.+?COMMENT = '.*?(?:servicio de |almacena los datos del servicio de |almacena los datos del servicio de: )?([\s\S]+?)';/gi;
+  
+  let match;
+  while ((match = tableRegex.exec(content)) !== null) {
+    const dbName = match[1];
+    const tableName = match[2];
+    const tableBody = match[3];
+    const tableComment = match[4].trim();
+
+    // Si el comentario coincide con el título del servicio
+    if (tableComment.toLowerCase().includes(serviceTitle.toLowerCase()) || serviceTitle.toLowerCase().includes(tableComment.toLowerCase())) {
+      const columns = [];
+      let primaryKey = '';
+
+      // Extraer columnas
+      const colRegex = /`(.+?)` (.+?)(?: COMMENT '(.+?)')?,/g;
+      let colMatch;
+      while ((colMatch = colRegex.exec(tableBody)) !== null) {
+        const colName = colMatch[1];
+        if (colName !== 'LastUpdate' && colName !== 'LastUser') {
+          columns.push({
+            name: colName,
+            type: colMatch[2],
+            alias: colMatch[3] || colName
+          });
+        }
+      }
+
+      // Extraer Primary Key
+      const pkMatch = tableBody.match(/PRIMARY KEY \(`(.+?)`\)/);
+      if (pkMatch) {
+        primaryKey = pkMatch[1];
+      }
+
+      return {
+        dbName,
+        tableName,
+        columns,
+        primaryKey,
+        serviceTitle
+      };
+    }
+  }
+  return null;
+}

package/commands/db.js

@@ -43,6 +43,43 @@ export async function initDb() {
   closeReadLine();
 }
 
+export async function addTableDb() {
+  const rutaEstructura = path.join(process.cwd(), 'docker-scripts/1-crear estructura.sql');
+  
+  if (!fs.existsSync(rutaEstructura)) {
+    console.error(`No se encontró el archivo de estructura en: ${rutaEstructura}. Asegúrese de estar en la carpeta raíz del proyecto de base de datos.`);
+    closeReadLine();
+    process.exit(1);
+  }
+
+  const nombreTabla = await hacerPregunta('¿Cuál es el nombre de la tabla?: ');
+  const nombreServicio = await hacerPregunta('¿Cuál es el nombre del servicio que almacenará los datos?: ');
+
+  const contenidoEstructura = fs.readFileSync(rutaEstructura, 'utf-8');
+  
+  // Intentar extraer el nombre del repositorio de la base de datos
+  const matchDb = contenidoEstructura.match(/CREATE DATABASE `(.+?)`/);
+  let nombreDb = 'NOMBRE_DEL_REPOSITORIO_DE_BASE_DE_DATOS';
+  
+  if (matchDb && matchDb[1]) {
+    nombreDb = matchDb[1];
+  } else {
+    console.warn('No se pudo detectar el nombre de la base de datos en el archivo de estructura. Se usará el marcador por defecto.');
+  }
+
+  const machote = `
+CREATE OR REPLACE TABLE \`${nombreDb}\`.\`${nombreTabla}\` (
+  \`LastUpdate\` DATETIME(4) NOT NULL DEFAULT CURRENT_TIMESTAMP(4) ON UPDATE CURRENT_TIMESTAMP(4) COMMENT 'Fecha de la última actualización de la fila',
+  \`LastUser\` VARCHAR(1000) COLLATE utf8mb4_spanish_ci NOT NULL DEFAULT '-' COMMENT 'Último usuario que modificó la fila',
+  PRIMARY KEY (\`\`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_spanish_ci COMMENT = 'Almacena los datos del servicio de ${nombreServicio}';
+`;
+
+  fs.appendFileSync(rutaEstructura, machote);
+  console.log(`Tabla \`${nombreTabla}\` agregada exitosamente a ${rutaEstructura}`);
+  closeReadLine();
+}
+
 export function showDbVersion() {
   // Assuming the version for 'db' command comes from the main utn-cli package.json
   mostrarVersion(path.join(__dirname, '../package.json'));

package/commands/frontend.js

@@ -40,7 +40,7 @@ export async function initFrontend() {
   closeReadLine();
 }
 
-export async function updateFrontend() {
+export async function updateFrontend(opciones = { cerrarAlFinalizar: true }) {
   console.log('Actualizando el proyecto de frontend...');
   const archivosAExcluir = ['app.routes.ts', 'contenedor-principal.component.css', 'contenedor-principal.component.html', 'contenedor-principal.component.ts', '.vscode', 'dist'];
   const directoriodePlantillas = path.join(__dirname, '../templates/frontend');
@@ -57,19 +57,30 @@ export async function updateFrontend() {
   fs.renameSync('gitignore', '.gitignore');
   fs.renameSync('editorconfig', '.editorconfig');
   console.log('Proyecto de frontend actualizado exitosamente.');
-  closeReadLine();
+  if (opciones.cerrarAlFinalizar) {
+    closeReadLine();
+  }
 }
 
-export async function cloneFrontendComponent() {
-  const nombre = await hacerPreguntaTrim('Ingrese el nombre del nuevo componente (se reemplazará XYZ): ');
+export async function cloneFrontendComponent(nombreComponente = null, tituloCard = null, descripcionCard = null, opciones = { cerrarAlFinalizar: true }, tableInfo = null) {
+  let nombre = nombreComponente;
+  if (!nombre) {
+    nombre = await hacerPreguntaTrim('Ingrese el nombre del nuevo componente (se reemplazará XYZ): ');
+  }
   if (!nombre) {
     console.error('El nombre es requerido.');
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
-  const titulo = await hacerPreguntaTrim('Ingrese el título para la tarjeta: ');
-  const descripcion = await hacerPreguntaTrim('Ingrese la descripción para la tarjeta: ');
+  let titulo = tituloCard;
+  if (!titulo) {
+    titulo = await hacerPreguntaTrim('Ingrese el título para la tarjeta: ');
+  }
+  let descripcion = descripcionCard;
+  if (!descripcion) {
+    descripcion = await hacerPreguntaTrim('Ingrese la descripción para la tarjeta: ');
+  }
 
   const nombreLower = nombre.toLowerCase();
   const nombreCapitalizado = nombre.charAt(0).toUpperCase() + nombre.slice(1);
@@ -81,13 +92,13 @@ export async function cloneFrontendComponent() {
 
   if (!fs.existsSync(rutaFuente)) {
     console.error(`No se encontró la carpeta plantilla en: ${rutaFuente}`);
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
   if (fs.existsSync(rutaDestino)) {
     console.error(`La carpeta destino ya existe: ${rutaDestino}`);
-    closeReadLine();
+    if (opciones.cerrarAlFinalizar) closeReadLine();
     process.exit(1);
   }
 
@@ -108,8 +119,16 @@ export async function cloneFrontendComponent() {
         copiarYReemplazar(rutaFuente, rutaDestino);
       } else if (entrada.isFile()) {
         let contenido = fs.readFileSync(rutaFuente, 'utf-8');
+        
+        // Reemplazos base
         contenido = contenido.replace(/GestionTablaXYZComponent/g, nombreClase);
         contenido = contenido.replace(/XYZ/g, nombreLower);
+
+        // Si tenemos información de la tabla, personalizamos el componente
+        if (tableInfo && entrada.name.endsWith('.ts')) {
+          contenido = personalizarComponenteFrontend(contenido, tableInfo, nombreLower);
+        }
+
         fs.writeFileSync(rutaDestino, contenido);
       }
     });
@@ -174,7 +193,42 @@ export async function cloneFrontendComponent() {
   } else {
     console.error(`No se encontró el archivo HTML en: ${rutaHtml}`);
   }
-  closeReadLine();
+  if (opciones.cerrarAlFinalizar) {
+    closeReadLine();
+  }
+}
+
+function personalizarComponenteFrontend(contenido, tableInfo, nombreServicioLower) {
+  const { columns, primaryKey } = tableInfo;
+
+  // 1. Reemplazar columnas
+  const nuevasColumnas = columns.map(col => {
+    return `    { Llave: '${col.name}', Alias: '${col.alias}', TipoDeFiltro: 'Tabla' }`;
+  }).join(',\n');
+  
+  contenido = contenido.replace(/public columnas = \[\s*[\s\S]*?\];/, `public columnas = [\n${nuevasColumnas}\n  ];`);
+
+  // 2. Reemplazar LicenciaId (la PK de la plantilla) por la PK real
+  const pkRegex = new RegExp('LicenciaId', 'g');
+  contenido = contenido.replace(pkRegex, primaryKey);
+
+  // 3. Reemplazar endpoints (ej: licencias/listar por servicio/listar)
+  const endpointRegex = new RegExp('licencias/', 'g');
+  contenido = contenido.replace(endpointRegex, `${nombreServicioLower}/`);
+
+  return contenido;
+}
+
+      console.log('Tarjeta agregada exitosamente.');
+    } else {
+      console.error('No se encontró un </div> de cierre en el HTML del contenedor principal.');
+    }
+  } else {
+    console.error(`No se encontró el archivo HTML en: ${rutaHtml}`);
+  }
+  if (opciones.cerrarAlFinalizar) {
+    closeReadLine();
+  }
 }
 
 export function showFrontendVersion() {

package/commands/update.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+import { updateBackend } from './backend.js';
+import { updateFrontend } from './frontend.js';
+import { closeReadLine } from '../utils/index.js';
+import { execSync } from 'child_process';
+
+export async function runGlobalUpdate() {
+  const currentDir = process.cwd();
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+  const directories = entries.filter(entry => entry.isDirectory());
+
+  if (directories.length === 0) {
+    console.log('No se encontraron directorios en la carpeta actual.');
+    closeReadLine();
+    return;
+  }
+
+  let foundSomething = false;
+
+  for (const dir of directories) {
+    const dirName = dir.name.toLowerCase();
+    const fullPath = path.join(currentDir, dir.name);
+
+    if (dirName.includes('back') || dirName.includes('front')) {
+      const type = dirName.includes('back') ? 'Backend' : 'Frontend';
+      console.log(`\n=========================================`);
+      console.log(`Procesando ${type} en: ${dir.name}`);
+      console.log(`=========================================\n`);
+      
+      process.chdir(fullPath);
+
+      // Execute git pull if it's a git repository
+      if (fs.existsSync(path.join(fullPath, '.git'))) {
+        console.log(`Ejecutando git pull en ${dir.name}...`);
+        try {
+          execSync('git pull', { stdio: 'inherit' });
+        } catch (error) {
+          console.error(`Error al ejecutar git pull en ${dir.name}. Continuando con la actualización...`);
+        }
+      }
+
+      try {
+        if (dirName.includes('back')) {
+          await updateBackend({ cerrarAlFinalizar: false });
+        } else if (dirName.includes('front')) {
+          await updateFrontend({ cerrarAlFinalizar: false });
+          
+          // Execute build for frontend if package.json exists
+          if (fs.existsSync(path.join(process.cwd(), 'package.json'))) {
+            console.log(`\nEjecutando sudo npm run build en ${dir.name}...`);
+            try {
+              execSync('sudo npm run build', { stdio: 'inherit' });
+            } catch (error) {
+              console.error(`Error al ejecutar build en ${dir.name}. Continuando...`);
+            }
+          }
+        }
+        foundSomething = true;
+      } catch (error) {
+        console.error(`Error actualizando ${type} en ${dir.name}:`, error);
+      }
+      
+      process.chdir(currentDir);
+    }
+  }
+
+  if (!foundSomething) {
+    console.log('No se encontraron carpetas con "back" o "front" en el nombre.');
+  } else {
+    console.log('\nProceso de actualización global finalizado.');
+  }
+  
+  closeReadLine();
+}

package/index.js

@@ -4,9 +4,11 @@ import { Command } from 'commander';
 import { mostrarVersion, getPackageInfo, closeReadLine } from './utils/index.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { initDb, showDbVersion } from './commands/db.js';
+import { initDb, addTableDb, showDbVersion } from './commands/db.js';
 import { initBackend, updateBackend, addServiceBackend, showBackendVersion } from './commands/backend.js';
 import { initFrontend, updateFrontend, cloneFrontendComponent, showFrontendVersion } from './commands/frontend.js';
+import { runGlobalUpdate } from './commands/update.js';
+import { createComponent } from './commands/createComponent.js';
 import { runCommit } from './commands/commit.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -30,16 +32,20 @@ if (packageInfo) {
 
 // Define 'db' command
 program.command('db')
+  .alias('bd')
   .description('Comandos para la gestión de plantillas de base de datos.')
   .option('--init', 'Inicializa un nuevo proyecto de base de datos.')
+  .option('--add-table', 'Agrega una nueva tabla al archivo de estructura.')
   .option('--version', 'Muestra la versión del módulo de base de datos.')
   .action(async (options) => {
     if (options.init) {
       await initDb();
+    } else if (options.addTable) {
+      await addTableDb();
     } else if (options.version) {
       showDbVersion();
     } else {
-      console.log('Uso: utn db [--init | --version]');
+      console.log('Uso: utn db [--init | --add-table | --version]');
       closeReadLine();
     }
   });
@@ -88,6 +94,20 @@ program.command('frontend')
     }
   });
 
+// Define 'update' command
+program.command('update')
+  .description('Recorre los directorios y actualiza proyectos de backend (si el nombre contiene "back") y frontend (si el nombre contiene "front").')
+  .action(async () => {
+    await runGlobalUpdate();
+  });
+
+// Define 'create-component' command
+program.command('create-component')
+  .description('Crea un nuevo servicio en el backend y un componente en el frontend simultáneamente.')
+  .action(async () => {
+    await createComponent();
+  });
+
 // Define 'commit' command
 program.command('commit')
   .description('Realiza un commit siguiendo el flujo de trabajo predefinido.')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-cli",
-  "version": "2.0.49",
+  "version": "2.0.51",
   "description": "Herramienta CLI unificada para la gestión de plantillas en SIGU.",
   "main": "index.js",
   "type": "module",

package/templates/frontend/src/app/Paginas/gestion-tabla-XYZ/gestion-tabla-XYZ.component.html

@@ -19,7 +19,7 @@
 [subAccionesSiempreClickeable] = "subAccionesSiempreClickeable"
 [subAccionesDinamicas] = "subAccionesDinamicas"
 [desplegable] = "false"
-[atributoDesplegable] = ""
+[atributoDesplegable] = "''"
 [mostrarElBotonDeGuardado] = "true"
 [mostrarElBotonDeDescargar] = "true"
 [mostrarElBotonDeFiltro] = "true"