utn-cli 2.0.50 → 2.0.52

package/commands/backend.js

@@ -171,7 +171,7 @@ export async function updateBackend(opciones = { cerrarAlFinalizar: true }) {
   }
 }
 
-export async function addServiceBackend(nombreServicio = null, opciones = { cerrarAlFinalizar: true }, tituloServicio = null) {
+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?: ');
@@ -206,12 +206,19 @@ export async function addServiceBackend(nombreServicio = null, opciones = { cerr
   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}`);
@@ -219,6 +226,11 @@ function asignarRutasAExpress(app) {`);
     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}';`);
@@ -227,72 +239,157 @@ function asignarRutasAExpress(app) {`);
   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.`);
-  if (opciones.cerrarAlFinalizar) {
-    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

@@ -7,19 +7,36 @@ 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?: ');
+  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: ');
+  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;
 
@@ -31,7 +48,7 @@ export async function createComponent() {
       console.log(`\nAgregando servicio a Backend en: ${dir.name}`);
       process.chdir(fullPath);
       try {
-        await addServiceBackend(nombreServicio, { cerrarAlFinalizar: false }, tituloCard);
+        await addServiceBackend(nombreServicio, { cerrarAlFinalizar: false }, tituloCard, tableInfo);
         foundBackend = true;
       } catch (error) {
         console.error(`Error al agregar servicio en ${dir.name}:`, error);
@@ -41,7 +58,7 @@ export async function createComponent() {
       console.log(`\nAgregando componente a Frontend en: ${dir.name}`);
       process.chdir(fullPath);
       try {
-        await cloneFrontendComponent(nombreServicio, tituloCard, descripcionCard, { cerrarAlFinalizar: false });
+        await cloneFrontendComponent(nombreServicio, tituloCard, descripcionCard, { cerrarAlFinalizar: false }, tableInfo);
         foundFrontend = true;
       } catch (error) {
         console.error(`Error al clonar componente en ${dir.name}:`, error);
@@ -58,3 +75,54 @@ export async function createComponent() {
   
   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

@@ -62,7 +62,7 @@ export async function updateFrontend(opciones = { cerrarAlFinalizar: true }) {
   }
 }
 
-export async function cloneFrontendComponent(nombreComponente = null, tituloCard = null, descripcionCard = null, opciones = { cerrarAlFinalizar: true }) {
+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): ');
@@ -119,8 +119,16 @@ export async function cloneFrontendComponent(nombreComponente = null, tituloCard
         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);
       }
     });
@@ -190,6 +198,27 @@ export async function cloneFrontendComponent(nombreComponente = null, tituloCard
   }
 }
 
+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;
+}
+
 export function showFrontendVersion() {
   mostrarVersion(path.join(__dirname, '../package.json'));
   closeReadLine();

package/index.js

@@ -4,7 +4,7 @@ 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';
@@ -35,14 +35,17 @@ 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();
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utn-cli",
-  "version": "2.0.50",
+  "version": "2.0.52",
   "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"