@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/fix-table-indexes.ts

@@ -1,602 +1,602 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as pg from 'pg';
-import { Logger } from '@nestjs/common';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-interface IndexInfo {
-  schema: string;
-  table: string;
-  index_name: string;
-  column_names: string[];
-  is_unique: boolean;
-  is_primary: boolean;
-  definition: string;
-}
-
-export class TableIndexFixer {
-  private readonly logger = new Logger('TableIndexFixer');
-  private readonly targetPool: pg.Pool;
-  private readonly logDir: string;
-  private readonly logPath: string;
-  private fixedIndexes: any[] = [];
-
-  constructor(
-    private readonly targetUrl: string = process.env.DATABASE_URL
-  ) {
-    if (!this.targetUrl) {
-      throw new Error('DATABASE_URL environment variable is required');
-    }
-
-    this.targetPool = new pg.Pool({
-      connectionString: this.targetUrl,
-    });
-
-    // Crear directorio para logs si no existe
-    this.logDir = path.join(process.cwd(), 'migration-logs');
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-
-    // Crear archivo de log con timestamp
-    const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
-    this.logPath = path.join(this.logDir, `index-fixes-${timestamp}.json`);
-  }
-
-  async fixIndexes(): Promise<void> {
-    try {
-      this.logger.log('Iniciando proceso de corrección de índices');
-
-      // Obtener todos los esquemas excepto los del sistema
-      const schemas = await this.getSchemas();
-      this.logger.log(`Encontrados ${schemas.length} esquemas para procesar`);
- 
-      // Para cada esquema, procesar sus índices
-      for (const schema of schemas) {
-        await this.fixIndexesForSchema(schema);
-      }
-
-      // Guardar el log de correcciones
-      this.saveFixLog();
-      this.logger.log(`Proceso de corrección de índices completado. Log guardado en: ${this.logPath}`);
-    } catch (error) {
-      this.logger.error(`Error durante la corrección de índices: ${error.message}`, error.stack);
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async getSchemas(): Promise<string[]> {
-    const result = await this.targetPool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
-    `);
-
-    return result.rows.map(row => row.schema_name);
-  }
-
-  private async fixIndexesForSchema(schema: string): Promise<void> {
-    this.logger.log(`Procesando índices para el esquema: ${schema}`);
-
-    try {
-      // Obtener todas las tablas del esquema
-      const tables = await this.getTablesForSchema(schema);
-      this.logger.log(`Encontradas ${tables.length} tablas en el esquema ${schema}`);
-
-      // Procesar cada tabla
-      for (const table of tables) {
-        await this.fixIndexesForTable(schema, table);
-      }
-    } catch (error) {
-      this.logger.error(`Error procesando índices para el esquema ${schema}: ${error.message}`);
-    }
-  }
-
-  private async getTablesForSchema(schema: string): Promise<string[]> {
-    const result = await this.targetPool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = $1
-      AND table_type = 'BASE TABLE'
-    `, [schema]);
-
-    return result.rows.map(row => row.table_name);
-  }
-
-  private async fixIndexesForTable(schema: string, table: string): Promise<void> {
-    this.logger.log(`Procesando índices para la tabla ${schema}.${table}`);
-
-    try {
-      // 1. Obtener información de la tabla
-      const tableInfo = await this.getTableInfo(schema, table);
-      
-      // 2. Obtener índices existentes
-      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
-      this.logger.log(`Encontrados ${existingIndexes.length} índices en la tabla ${schema}.${table}`);
-      
-      // 3. Verificar y corregir secuencias si es necesario
-      if (tableInfo.has_identity_column) {
-        await this.fixSequences(schema, table);
-      }
-      
-      // 4. Verificar y corregir problemas comunes de índices
-      await this.fixCommonIndexIssues(schema, table);
-      
-      // 5. Verificar y corregir índices faltantes para claves foráneas
-      await this.fixForeignKeyIndexes(schema, table);
-      
-      // 6. Verificar y corregir índices duplicados o redundantes
-      // Movido al final para evitar eliminar índices recién creados
-      await this.removeRedundantIndexes(schema, table, await this.getTableIndexes(this.targetPool, schema, table));
-      
-      // 7. Verificación adicional para tablas críticas (usuarios)
-      if (table === 'users' || table === 'user' || table.includes('user')) {
-        await this.ensureCriticalUserTableIndexes(schema, table);
-      }
-
-    } catch (error) {
-      this.logger.error(`Error procesando índices para la tabla ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  // Nuevo método para asegurar índices críticos en tablas de usuarios
-  private async ensureCriticalUserTableIndexes(schema: string, table: string): Promise<void> {
-    try {
-      const columns = await this.getTableColumns(schema, table);
-      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
-      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
-      
-      // Columnas críticas que DEBEN tener índices en tablas de usuarios
-      const criticalColumns = ['email', 'username', 'phone', 'id', 'uuid'];
-      
-      for (const criticalCol of criticalColumns) {
-        const column = columns.find(col => col.column_name === criticalCol);
-        
-        if (column && !indexedColumns.has(column.column_name)) {
-          // Determinar si debe ser un índice único
-          const shouldBeUnique = ['email', 'username', 'phone', 'uuid'].includes(column.column_name);
-          
-          const indexInfo: IndexInfo = {
-            schema,
-            table,
-            index_name: `idx_${table}_${column.column_name}`,
-            column_names: [column.column_name],
-            is_unique: shouldBeUnique,
-            is_primary: false,
-            definition: ''
-          };
-          
-          this.logger.log(`Creando índice crítico para ${column.column_name} en tabla de usuarios ${schema}.${table}`);
-          await this.createIndex(schema, table, indexInfo);
-        }
-      }
-      
-      // Verificar y corregir secuencias específicamente para tablas de usuarios
-      await this.fixUserTableSequences(schema, table);
-      
-    } catch (error) {
-      this.logger.error(`Error asegurando índices críticos para tabla de usuarios ${schema}.${table}: ${error.message}`);
-    }
-  }
-  
-  // Nuevo método para corregir secuencias en tablas de usuarios
-  private async fixUserTableSequences(schema: string, table: string): Promise<void> {
-    try {
-      // Obtener todas las columnas de identidad de la tabla
-      const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
-      `;
-      
-      const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
-      const identityColumns = columnsResult.rows.map(row => row.column_name);
-      
-      for (const column of identityColumns) {
-        // Obtener el nombre de la secuencia
-        const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
-        `;
-        
-        const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
-        const sequenceName = sequenceResult.rows[0]?.sequence_name;
-        
-        if (sequenceName) {
-          // Restablecer la secuencia al valor máximo actual + 1 con is_called=true para asegurar que el próximo valor sea correcto
-          const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
-          `;
-          
-          await this.targetPool.query(resetQuery, [sequenceName]);
-          
-          this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table} (tabla de usuarios)`);
-          
-          // Registrar la corrección
-          this.fixedIndexes.push({
-            schema,
-            table,
-            column,
-            sequence_name: sequenceName,
-            action: 'reset_sequence_user_table',
-            timestamp: new Date().toISOString()
-          });
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error restableciendo secuencias para tabla de usuarios ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  private async removeRedundantIndexes(schema: string, table: string, indexes: IndexInfo[]): Promise<void> {
-    // Identificar índices redundantes (un índice es redundante si existe otro que cubre las mismas columnas)
-    const redundantIndexes: IndexInfo[] = [];
-    
-    // Lista de nombres de índices críticos que nunca deben eliminarse
-    const criticalIndexPatterns = [
-      'email', 'username', 'phone', 'uuid', 'pkey', 'primary', 
-      'unique', 'user_id', 'auth', 'session', 'token'
-    ];
-    
-    for (let i = 0; i < indexes.length; i++) {
-      for (let j = 0; j < indexes.length; j++) {
-        if (i !== j && !indexes[i].is_primary && !indexes[j].is_primary) {
-          const index1 = indexes[i];
-          const index2 = indexes[j];
-          
-          // Verificar que column_names sea un array en ambos índices
-          if (!Array.isArray(index1.column_names) || !Array.isArray(index2.column_names)) {
-            this.logger.warn(`Índice con formato incorrecto en ${schema}.${table}: ${index1.index_name} o ${index2.index_name}`);
-            continue;
-          }
-          
-          // Verificar si el índice es crítico (nunca debe eliminarse)
-          const isIndex1Critical = criticalIndexPatterns.some(pattern => 
-            index1.index_name.toLowerCase().includes(pattern)
-          );
-          
-          if (isIndex1Critical) {
-            // No eliminar índices críticos
-            continue;
-          }
-          
-          // Si todas las columnas de index1 están en index2 y index2 tiene más columnas, index1 es redundante
-          if (index1.column_names.every(col => index2.column_names.includes(col)) && 
-              index2.column_names.length > index1.column_names.length) {
-            redundantIndexes.push(index1);
-            break;
-          }
-        }
-      }
-    }
-    
-    // Eliminar índices redundantes
-    for (const index of redundantIndexes) {
-      try {
-        const query = `DROP INDEX IF EXISTS "${schema}"."${index.index_name}"`;
-        await this.targetPool.query(query);
-        
-        this.logger.log(`Eliminado índice redundante ${index.index_name} en ${schema}.${table}`);
-        
-        // Registrar la corrección
-        this.fixedIndexes.push({
-          schema,
-          table,
-          index_name: index.index_name,
-          action: 'removed_redundant',
-          timestamp: new Date().toISOString()
-        });
-      } catch (error) {
-        this.logger.error(`Error eliminando índice redundante ${index.index_name} en ${schema}.${table}: ${error.message}`);
-      }
-    }
-  }
-
-  private async fixSequences(schema: string, table: string): Promise<void> {
-    try {
-      // 1. Obtener todas las columnas de identidad de la tabla
-      const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
-      `;
-      
-      const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
-      const identityColumns = columnsResult.rows.map(row => row.column_name);
-      
-      // 2. Para cada columna de identidad, restablecer la secuencia
-      for (const column of identityColumns) {
-        // Obtener el nombre de la secuencia
-        const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
-        `;
-        
-        const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
-        const sequenceName = sequenceResult.rows[0]?.sequence_name;
-        
-        if (sequenceName) {
-          // Restablecer la secuencia al valor máximo actual + 1
-          const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
-          `;
-          
-          await this.targetPool.query(resetQuery, [sequenceName]);
-          
-          this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table}`);
-          
-          // Registrar la corrección
-          this.fixedIndexes.push({
-            schema,
-            table,
-            column,
-            sequence_name: sequenceName,
-            action: 'reset_sequence',
-            timestamp: new Date().toISOString()
-          });
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error restableciendo secuencias para ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  private async getTableInfo(schema: string, table: string): Promise<any> {
-    try {
-      // Verificar si la tabla tiene columnas de identidad (serial, bigserial, etc.)
-      const identityQuery = `
-        SELECT EXISTS (
-          SELECT 1
-          FROM information_schema.columns
-          WHERE table_schema = $1
-          AND table_name = $2
-          AND is_identity = 'YES'
-        ) AS has_identity_column;
-      `;
-      
-      const result = await this.targetPool.query(identityQuery, [schema, table]);
-      return {
-        has_identity_column: result.rows[0]?.has_identity_column || false
-      };
-    } catch (error) {
-      this.logger.error(`Error obteniendo información de la tabla ${schema}.${table}: ${error.message}`);
-      return { has_identity_column: false };
-    }
-  }
-
-  private async getTableIndexes(pool: pg.Pool, schema: string, table: string): Promise<IndexInfo[]> {
-    // Esta consulta obtiene información detallada sobre los índices de una tabla
-    const query = `
-      SELECT
-        i.relname AS index_name,
-        array_agg(a.attname) AS column_names,
-        ix.indisunique AS is_unique,
-        ix.indisprimary AS is_primary,
-        pg_get_indexdef(ix.indexrelid) AS definition
-      FROM
-        pg_index ix
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_class t ON t.oid = ix.indrelid
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-      WHERE
-        n.nspname = $1
-        AND t.relname = $2
-      GROUP BY
-        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
-      ORDER BY
-        i.relname;
-    `;
-
-    try {
-      const result = await pool.query(query, [schema, table]);
-      return result.rows.map(row => ({
-        schema,
-        table,
-        index_name: row.index_name,
-        column_names: row.column_names,
-        is_unique: row.is_unique,
-        is_primary: row.is_primary,
-        definition: row.definition
-      }));
-    } catch (error) {
-      this.logger.error(`Error obteniendo índices para ${schema}.${table}: ${error.message}`);
-      return [];
-    }
-  }
-
-  private async createIndex(schema: string, table: string, indexInfo: IndexInfo): Promise<void> {
-    try {
-      // Generar un nombre único para el índice
-      const columnList = indexInfo.column_names.join('_');
-      const indexName = `idx_${table}_${columnList}`.substring(0, 63); // Limitar longitud a 63 caracteres
-      
-      // Construir la consulta SQL para crear el índice
-      let query = `CREATE`;
-      if (indexInfo.is_unique) {
-        query += ` UNIQUE`;
-      }
-      query += ` INDEX IF NOT EXISTS "${indexName}" ON "${schema}"."${table}" (${indexInfo.column_names.map(col => `"${col}"`).join(', ')})`;
-      
-      // Ejecutar la consulta
-      await this.targetPool.query(query);
-      
-      this.logger.log(`Creado índice ${indexName} en ${schema}.${table}`);
-      
-      // Registrar la corrección
-      this.fixedIndexes.push({
-        schema,
-        table,
-        index_name: indexName,
-        columns: indexInfo.column_names,
-        is_unique: indexInfo.is_unique,
-        timestamp: new Date().toISOString()
-      });
-    } catch (error) {
-      this.logger.error(`Error creando índice en ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  private async fixCommonIndexIssues(schema: string, table: string): Promise<void> {
-    try {
-      // 1. Verificar columnas que deberían tener índices basados en convenciones de nombres
-      const columns = await this.getTableColumns(schema, table);
-      
-      // Columnas que probablemente deberían tener índices
-      const potentialIndexColumns = columns.filter(col => 
-        col.column_name.endsWith('_id') || // Claves foráneas
-        col.column_name === 'id' ||        // Clave primaria
-        col.column_name === 'uuid' ||      // UUID
-        col.column_name === 'slug' ||      // Slugs
-        col.column_name === 'email' ||     // Emails
-        col.column_name === 'username' ||  // Nombres de usuario
-        col.column_name.includes('code') || // Códigos
-        col.column_name === 'user_id' ||   // ID de usuario (común en muchas tablas)
-        col.column_name === 'created_at' || // Campos de fecha (útiles para ordenar)
-        col.column_name === 'updated_at'    // Campos de fecha (útiles para ordenar)
-      );
-      
-      // Obtener índices existentes
-      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
-      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
-      
-      // Crear índices para columnas que deberían tenerlos pero no los tienen
-      for (const column of potentialIndexColumns) {
-        if (!indexedColumns.has(column.column_name)) {
-          // Determinar si debería ser un índice único
-          const shouldBeUnique = ['email', 'username', 'slug', 'uuid'].includes(column.column_name);
-          
-          // Crear un objeto IndexInfo para la columna
-          const indexInfo: IndexInfo = {
-            schema,
-            table,
-            index_name: `idx_${table}_${column.column_name}`,
-            column_names: [column.column_name],
-            is_unique: shouldBeUnique,
-            is_primary: false,
-            definition: ''
-          };
-          
-          // Crear el índice
-          await this.createIndex(schema, table, indexInfo);
-        }
-      }
-      
-    } catch (error) {
-      this.logger.error(`Error corrigiendo problemas comunes de índices en ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  private async getTableColumns(schema: string, table: string): Promise<any[]> {
-    const query = `
-      SELECT column_name, data_type, is_nullable
-      FROM information_schema.columns
-      WHERE table_schema = $1
-      AND table_name = $2
-    `;
-    
-    const result = await this.targetPool.query(query, [schema, table]);
-    return result.rows;
-  }
-
-  private async fixForeignKeyIndexes(schema: string, table: string): Promise<void> {
-    try {
-      // Obtener todas las claves foráneas de la tabla
-      const fkQuery = `
-        SELECT
-          kcu.column_name,
-          ccu.table_schema AS foreign_table_schema,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints AS tc
-          JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage AS ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND tc.table_name = $2;
-      `;
-      
-      const fkResult = await this.targetPool.query(fkQuery, [schema, table]);
-      
-      // Obtener índices existentes
-      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
-      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
-      
-      // Crear índices para columnas de clave foránea que no tienen índice
-      for (const fk of fkResult.rows) {
-        if (!indexedColumns.has(fk.column_name)) {
-          // Crear un objeto IndexInfo para la columna de clave foránea
-          const indexInfo: IndexInfo = {
-            schema,
-            table,
-            index_name: `idx_${table}_${fk.column_name}`,
-            column_names: [fk.column_name],
-            is_unique: false,
-            is_primary: false,
-            definition: ''
-          };
-          
-          // Crear el índice
-          await this.createIndex(schema, table, indexInfo);
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error creando índices para claves foráneas en ${schema}.${table}: ${error.message}`);
-    }
-  }
-
-  private saveFixLog(): void {
-    try {
-      const logData = {
-        timestamp: new Date().toISOString(),
-        targetDatabase: this.targetUrl,
-        fixCount: this.fixedIndexes.length,
-        fixes: this.fixedIndexes
-      };
-      
-      fs.writeFileSync(
-        this.logPath,
-        JSON.stringify(logData, null, 2),
-        'utf8'
-      );
-    } catch (error) {
-      this.logger.error(`Error guardando log de correcciones: ${error.message}`);
-    }
-  }
-
-  private async cleanup(): Promise<void> {
-    try {
-      await this.targetPool.end();
-    } catch (error) {
-      this.logger.error(`Error durante la limpieza: ${error.message}`);
-    }
-  }
-}
-
-// Script para ejecutar desde línea de comandos
-if (require.main === module) {
-  const run = async () => {
-    try {
-      const indexFixer = new TableIndexFixer();
-      await indexFixer.fixIndexes();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error.message);
-      process.exit(1);
-    }
-  };
-
-  run();
+import * as fs from 'fs';
+import * as path from 'path';
+import * as pg from 'pg';
+import { Logger } from '@nestjs/common';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+interface IndexInfo {
+  schema: string;
+  table: string;
+  index_name: string;
+  column_names: string[];
+  is_unique: boolean;
+  is_primary: boolean;
+  definition: string;
+}
+
+export class TableIndexFixer {
+  private readonly logger = new Logger('TableIndexFixer');
+  private readonly targetPool: pg.Pool;
+  private readonly logDir: string;
+  private readonly logPath: string;
+  private fixedIndexes: any[] = [];
+
+  constructor(
+    private readonly targetUrl: string = process.env.DATABASE_URL
+  ) {
+    if (!this.targetUrl) {
+      throw new Error('DATABASE_URL environment variable is required');
+    }
+
+    this.targetPool = new pg.Pool({
+      connectionString: this.targetUrl,
+    });
+
+    // Crear directorio para logs si no existe
+    this.logDir = path.join(process.cwd(), 'migration-logs');
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+
+    // Crear archivo de log con timestamp
+    const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
+    this.logPath = path.join(this.logDir, `index-fixes-${timestamp}.json`);
+  }
+
+  async fixIndexes(): Promise<void> {
+    try {
+      this.logger.log('Iniciando proceso de corrección de índices');
+
+      // Obtener todos los esquemas excepto los del sistema
+      const schemas = await this.getSchemas();
+      this.logger.log(`Encontrados ${schemas.length} esquemas para procesar`);
+ 
+      // Para cada esquema, procesar sus índices
+      for (const schema of schemas) {
+        await this.fixIndexesForSchema(schema);
+      }
+
+      // Guardar el log de correcciones
+      this.saveFixLog();
+      this.logger.log(`Proceso de corrección de índices completado. Log guardado en: ${this.logPath}`);
+    } catch (error) {
+      this.logger.error(`Error durante la corrección de índices: ${error.message}`, error.stack);
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async getSchemas(): Promise<string[]> {
+    const result = await this.targetPool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
+    `);
+
+    return result.rows.map(row => row.schema_name);
+  }
+
+  private async fixIndexesForSchema(schema: string): Promise<void> {
+    this.logger.log(`Procesando índices para el esquema: ${schema}`);
+
+    try {
+      // Obtener todas las tablas del esquema
+      const tables = await this.getTablesForSchema(schema);
+      this.logger.log(`Encontradas ${tables.length} tablas en el esquema ${schema}`);
+
+      // Procesar cada tabla
+      for (const table of tables) {
+        await this.fixIndexesForTable(schema, table);
+      }
+    } catch (error) {
+      this.logger.error(`Error procesando índices para el esquema ${schema}: ${error.message}`);
+    }
+  }
+
+  private async getTablesForSchema(schema: string): Promise<string[]> {
+    const result = await this.targetPool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = $1
+      AND table_type = 'BASE TABLE'
+    `, [schema]);
+
+    return result.rows.map(row => row.table_name);
+  }
+
+  private async fixIndexesForTable(schema: string, table: string): Promise<void> {
+    this.logger.log(`Procesando índices para la tabla ${schema}.${table}`);
+
+    try {
+      // 1. Obtener información de la tabla
+      const tableInfo = await this.getTableInfo(schema, table);
+      
+      // 2. Obtener índices existentes
+      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
+      this.logger.log(`Encontrados ${existingIndexes.length} índices en la tabla ${schema}.${table}`);
+      
+      // 3. Verificar y corregir secuencias si es necesario
+      if (tableInfo.has_identity_column) {
+        await this.fixSequences(schema, table);
+      }
+      
+      // 4. Verificar y corregir problemas comunes de índices
+      await this.fixCommonIndexIssues(schema, table);
+      
+      // 5. Verificar y corregir índices faltantes para claves foráneas
+      await this.fixForeignKeyIndexes(schema, table);
+      
+      // 6. Verificar y corregir índices duplicados o redundantes
+      // Movido al final para evitar eliminar índices recién creados
+      await this.removeRedundantIndexes(schema, table, await this.getTableIndexes(this.targetPool, schema, table));
+      
+      // 7. Verificación adicional para tablas críticas (usuarios)
+      if (table === 'users' || table === 'user' || table.includes('user')) {
+        await this.ensureCriticalUserTableIndexes(schema, table);
+      }
+
+    } catch (error) {
+      this.logger.error(`Error procesando índices para la tabla ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  // Nuevo método para asegurar índices críticos en tablas de usuarios
+  private async ensureCriticalUserTableIndexes(schema: string, table: string): Promise<void> {
+    try {
+      const columns = await this.getTableColumns(schema, table);
+      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
+      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
+      
+      // Columnas críticas que DEBEN tener índices en tablas de usuarios
+      const criticalColumns = ['email', 'username', 'phone', 'id', 'uuid'];
+      
+      for (const criticalCol of criticalColumns) {
+        const column = columns.find(col => col.column_name === criticalCol);
+        
+        if (column && !indexedColumns.has(column.column_name)) {
+          // Determinar si debe ser un índice único
+          const shouldBeUnique = ['email', 'username', 'phone', 'uuid'].includes(column.column_name);
+          
+          const indexInfo: IndexInfo = {
+            schema,
+            table,
+            index_name: `idx_${table}_${column.column_name}`,
+            column_names: [column.column_name],
+            is_unique: shouldBeUnique,
+            is_primary: false,
+            definition: ''
+          };
+          
+          this.logger.log(`Creando índice crítico para ${column.column_name} en tabla de usuarios ${schema}.${table}`);
+          await this.createIndex(schema, table, indexInfo);
+        }
+      }
+      
+      // Verificar y corregir secuencias específicamente para tablas de usuarios
+      await this.fixUserTableSequences(schema, table);
+      
+    } catch (error) {
+      this.logger.error(`Error asegurando índices críticos para tabla de usuarios ${schema}.${table}: ${error.message}`);
+    }
+  }
+  
+  // Nuevo método para corregir secuencias en tablas de usuarios
+  private async fixUserTableSequences(schema: string, table: string): Promise<void> {
+    try {
+      // Obtener todas las columnas de identidad de la tabla
+      const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+      `;
+      
+      const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
+      const identityColumns = columnsResult.rows.map(row => row.column_name);
+      
+      for (const column of identityColumns) {
+        // Obtener el nombre de la secuencia
+        const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+        `;
+        
+        const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
+        const sequenceName = sequenceResult.rows[0]?.sequence_name;
+        
+        if (sequenceName) {
+          // Restablecer la secuencia al valor máximo actual + 1 con is_called=true para asegurar que el próximo valor sea correcto
+          const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+          `;
+          
+          await this.targetPool.query(resetQuery, [sequenceName]);
+          
+          this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table} (tabla de usuarios)`);
+          
+          // Registrar la corrección
+          this.fixedIndexes.push({
+            schema,
+            table,
+            column,
+            sequence_name: sequenceName,
+            action: 'reset_sequence_user_table',
+            timestamp: new Date().toISOString()
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error restableciendo secuencias para tabla de usuarios ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  private async removeRedundantIndexes(schema: string, table: string, indexes: IndexInfo[]): Promise<void> {
+    // Identificar índices redundantes (un índice es redundante si existe otro que cubre las mismas columnas)
+    const redundantIndexes: IndexInfo[] = [];
+    
+    // Lista de nombres de índices críticos que nunca deben eliminarse
+    const criticalIndexPatterns = [
+      'email', 'username', 'phone', 'uuid', 'pkey', 'primary', 
+      'unique', 'user_id', 'auth', 'session', 'token'
+    ];
+    
+    for (let i = 0; i < indexes.length; i++) {
+      for (let j = 0; j < indexes.length; j++) {
+        if (i !== j && !indexes[i].is_primary && !indexes[j].is_primary) {
+          const index1 = indexes[i];
+          const index2 = indexes[j];
+          
+          // Verificar que column_names sea un array en ambos índices
+          if (!Array.isArray(index1.column_names) || !Array.isArray(index2.column_names)) {
+            this.logger.warn(`Índice con formato incorrecto en ${schema}.${table}: ${index1.index_name} o ${index2.index_name}`);
+            continue;
+          }
+          
+          // Verificar si el índice es crítico (nunca debe eliminarse)
+          const isIndex1Critical = criticalIndexPatterns.some(pattern => 
+            index1.index_name.toLowerCase().includes(pattern)
+          );
+          
+          if (isIndex1Critical) {
+            // No eliminar índices críticos
+            continue;
+          }
+          
+          // Si todas las columnas de index1 están en index2 y index2 tiene más columnas, index1 es redundante
+          if (index1.column_names.every(col => index2.column_names.includes(col)) && 
+              index2.column_names.length > index1.column_names.length) {
+            redundantIndexes.push(index1);
+            break;
+          }
+        }
+      }
+    }
+    
+    // Eliminar índices redundantes
+    for (const index of redundantIndexes) {
+      try {
+        const query = `DROP INDEX IF EXISTS "${schema}"."${index.index_name}"`;
+        await this.targetPool.query(query);
+        
+        this.logger.log(`Eliminado índice redundante ${index.index_name} en ${schema}.${table}`);
+        
+        // Registrar la corrección
+        this.fixedIndexes.push({
+          schema,
+          table,
+          index_name: index.index_name,
+          action: 'removed_redundant',
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        this.logger.error(`Error eliminando índice redundante ${index.index_name} en ${schema}.${table}: ${error.message}`);
+      }
+    }
+  }
+
+  private async fixSequences(schema: string, table: string): Promise<void> {
+    try {
+      // 1. Obtener todas las columnas de identidad de la tabla
+      const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+      `;
+      
+      const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
+      const identityColumns = columnsResult.rows.map(row => row.column_name);
+      
+      // 2. Para cada columna de identidad, restablecer la secuencia
+      for (const column of identityColumns) {
+        // Obtener el nombre de la secuencia
+        const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+        `;
+        
+        const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
+        const sequenceName = sequenceResult.rows[0]?.sequence_name;
+        
+        if (sequenceName) {
+          // Restablecer la secuencia al valor máximo actual + 1
+          const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+          `;
+          
+          await this.targetPool.query(resetQuery, [sequenceName]);
+          
+          this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table}`);
+          
+          // Registrar la corrección
+          this.fixedIndexes.push({
+            schema,
+            table,
+            column,
+            sequence_name: sequenceName,
+            action: 'reset_sequence',
+            timestamp: new Date().toISOString()
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error restableciendo secuencias para ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  private async getTableInfo(schema: string, table: string): Promise<any> {
+    try {
+      // Verificar si la tabla tiene columnas de identidad (serial, bigserial, etc.)
+      const identityQuery = `
+        SELECT EXISTS (
+          SELECT 1
+          FROM information_schema.columns
+          WHERE table_schema = $1
+          AND table_name = $2
+          AND is_identity = 'YES'
+        ) AS has_identity_column;
+      `;
+      
+      const result = await this.targetPool.query(identityQuery, [schema, table]);
+      return {
+        has_identity_column: result.rows[0]?.has_identity_column || false
+      };
+    } catch (error) {
+      this.logger.error(`Error obteniendo información de la tabla ${schema}.${table}: ${error.message}`);
+      return { has_identity_column: false };
+    }
+  }
+
+  private async getTableIndexes(pool: pg.Pool, schema: string, table: string): Promise<IndexInfo[]> {
+    // Esta consulta obtiene información detallada sobre los índices de una tabla
+    const query = `
+      SELECT
+        i.relname AS index_name,
+        array_agg(a.attname) AS column_names,
+        ix.indisunique AS is_unique,
+        ix.indisprimary AS is_primary,
+        pg_get_indexdef(ix.indexrelid) AS definition
+      FROM
+        pg_index ix
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+      WHERE
+        n.nspname = $1
+        AND t.relname = $2
+      GROUP BY
+        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
+      ORDER BY
+        i.relname;
+    `;
+
+    try {
+      const result = await pool.query(query, [schema, table]);
+      return result.rows.map(row => ({
+        schema,
+        table,
+        index_name: row.index_name,
+        column_names: row.column_names,
+        is_unique: row.is_unique,
+        is_primary: row.is_primary,
+        definition: row.definition
+      }));
+    } catch (error) {
+      this.logger.error(`Error obteniendo índices para ${schema}.${table}: ${error.message}`);
+      return [];
+    }
+  }
+
+  private async createIndex(schema: string, table: string, indexInfo: IndexInfo): Promise<void> {
+    try {
+      // Generar un nombre único para el índice
+      const columnList = indexInfo.column_names.join('_');
+      const indexName = `idx_${table}_${columnList}`.substring(0, 63); // Limitar longitud a 63 caracteres
+      
+      // Construir la consulta SQL para crear el índice
+      let query = `CREATE`;
+      if (indexInfo.is_unique) {
+        query += ` UNIQUE`;
+      }
+      query += ` INDEX IF NOT EXISTS "${indexName}" ON "${schema}"."${table}" (${indexInfo.column_names.map(col => `"${col}"`).join(', ')})`;
+      
+      // Ejecutar la consulta
+      await this.targetPool.query(query);
+      
+      this.logger.log(`Creado índice ${indexName} en ${schema}.${table}`);
+      
+      // Registrar la corrección
+      this.fixedIndexes.push({
+        schema,
+        table,
+        index_name: indexName,
+        columns: indexInfo.column_names,
+        is_unique: indexInfo.is_unique,
+        timestamp: new Date().toISOString()
+      });
+    } catch (error) {
+      this.logger.error(`Error creando índice en ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  private async fixCommonIndexIssues(schema: string, table: string): Promise<void> {
+    try {
+      // 1. Verificar columnas que deberían tener índices basados en convenciones de nombres
+      const columns = await this.getTableColumns(schema, table);
+      
+      // Columnas que probablemente deberían tener índices
+      const potentialIndexColumns = columns.filter(col => 
+        col.column_name.endsWith('_id') || // Claves foráneas
+        col.column_name === 'id' ||        // Clave primaria
+        col.column_name === 'uuid' ||      // UUID
+        col.column_name === 'slug' ||      // Slugs
+        col.column_name === 'email' ||     // Emails
+        col.column_name === 'username' ||  // Nombres de usuario
+        col.column_name.includes('code') || // Códigos
+        col.column_name === 'user_id' ||   // ID de usuario (común en muchas tablas)
+        col.column_name === 'created_at' || // Campos de fecha (útiles para ordenar)
+        col.column_name === 'updated_at'    // Campos de fecha (útiles para ordenar)
+      );
+      
+      // Obtener índices existentes
+      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
+      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
+      
+      // Crear índices para columnas que deberían tenerlos pero no los tienen
+      for (const column of potentialIndexColumns) {
+        if (!indexedColumns.has(column.column_name)) {
+          // Determinar si debería ser un índice único
+          const shouldBeUnique = ['email', 'username', 'slug', 'uuid'].includes(column.column_name);
+          
+          // Crear un objeto IndexInfo para la columna
+          const indexInfo: IndexInfo = {
+            schema,
+            table,
+            index_name: `idx_${table}_${column.column_name}`,
+            column_names: [column.column_name],
+            is_unique: shouldBeUnique,
+            is_primary: false,
+            definition: ''
+          };
+          
+          // Crear el índice
+          await this.createIndex(schema, table, indexInfo);
+        }
+      }
+      
+    } catch (error) {
+      this.logger.error(`Error corrigiendo problemas comunes de índices en ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  private async getTableColumns(schema: string, table: string): Promise<any[]> {
+    const query = `
+      SELECT column_name, data_type, is_nullable
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      AND table_name = $2
+    `;
+    
+    const result = await this.targetPool.query(query, [schema, table]);
+    return result.rows;
+  }
+
+  private async fixForeignKeyIndexes(schema: string, table: string): Promise<void> {
+    try {
+      // Obtener todas las claves foráneas de la tabla
+      const fkQuery = `
+        SELECT
+          kcu.column_name,
+          ccu.table_schema AS foreign_table_schema,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND tc.table_name = $2;
+      `;
+      
+      const fkResult = await this.targetPool.query(fkQuery, [schema, table]);
+      
+      // Obtener índices existentes
+      const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);
+      const indexedColumns = new Set(existingIndexes.flatMap(idx => idx.column_names));
+      
+      // Crear índices para columnas de clave foránea que no tienen índice
+      for (const fk of fkResult.rows) {
+        if (!indexedColumns.has(fk.column_name)) {
+          // Crear un objeto IndexInfo para la columna de clave foránea
+          const indexInfo: IndexInfo = {
+            schema,
+            table,
+            index_name: `idx_${table}_${fk.column_name}`,
+            column_names: [fk.column_name],
+            is_unique: false,
+            is_primary: false,
+            definition: ''
+          };
+          
+          // Crear el índice
+          await this.createIndex(schema, table, indexInfo);
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error creando índices para claves foráneas en ${schema}.${table}: ${error.message}`);
+    }
+  }
+
+  private saveFixLog(): void {
+    try {
+      const logData = {
+        timestamp: new Date().toISOString(),
+        targetDatabase: this.targetUrl,
+        fixCount: this.fixedIndexes.length,
+        fixes: this.fixedIndexes
+      };
+      
+      fs.writeFileSync(
+        this.logPath,
+        JSON.stringify(logData, null, 2),
+        'utf8'
+      );
+    } catch (error) {
+      this.logger.error(`Error guardando log de correcciones: ${error.message}`);
+    }
+  }
+
+  private async cleanup(): Promise<void> {
+    try {
+      await this.targetPool.end();
+    } catch (error) {
+      this.logger.error(`Error durante la limpieza: ${error.message}`);
+    }
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      const indexFixer = new TableIndexFixer();
+      await indexFixer.fixIndexes();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
 }