@javalabs/prisma-client 1.0.27 → 1.0.29

package/src/scripts/reset-database.ts

@@ -1,264 +1,264 @@
-import * as pg from "pg";
-import * as dotenv from "dotenv";
-import { Logger } from "@nestjs/common";
-import { execSync } from "child_process";
-import { PrismaClient } from "@prisma/client";
-
-dotenv.config();
-
-export class DatabaseResetTool {
-  private readonly logger = new Logger("DatabaseResetTool");
-  private readonly pool: pg.Pool;
-  private readonly adminPool: pg.Pool;
-  private readonly prisma: PrismaClient;
-
-  constructor(private readonly databaseUrl: string) {
-    // Conexión a la base de datos específica
-    this.pool = new pg.Pool({
-      connectionString: this.databaseUrl,
-    });
-
-    // Conexión a la base de datos postgres (admin)
-    const adminUrl = this.databaseUrl.replace(/\/[^/]+$/, "/postgres");
-    this.adminPool = new pg.Pool({
-      connectionString: adminUrl,
-    });
-
-    // Cliente Prisma
-    this.prisma = new PrismaClient({
-      datasources: {
-        db: {
-          url: this.databaseUrl,
-        },
-      },
-    });
-  }
-
-  async resetDatabase(recreateDb = false) {
-    try {
-      this.logger.log("Starting complete database reset process");
-
-      // Extraer el nombre de la base de datos de la URL
-      const dbName = this.extractDatabaseName(this.databaseUrl);
-      
-      if (!dbName) {
-        throw new Error("Could not extract database name from connection URL");
-      }
-
-      // 1. Eliminar todos los schemas personalizados y sus contenidos
-      await this.dropAllSchemas();
-
-      // 2. Eliminar todas las tablas del schema public
-      await this.dropAllPublicTables();
-
-      // 3. Eliminar todos los tipos personalizados (enums, etc.)
-      await this.dropAllCustomTypes();
-
-      if (recreateDb) {
-        // 4. Terminar todas las conexiones y eliminar la base de datos
-        await this.terminateConnections(dbName);
-        await this.adminPool.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-        
-        // 5. Recrear la base de datos
-        this.logger.log(`Recreating database: ${dbName}`);
-        await this.adminPool.query(`CREATE DATABASE "${dbName}"`);
-        
-        // 6. Ejecutar prisma migrate para recrear el esquema base
-        this.logger.log("Running prisma migrate to recreate base schema");
-        try {
-          execSync(`DATABASE_URL="${this.databaseUrl}" npx prisma migrate deploy`, {
-            stdio: 'inherit'
-          });
-        } catch (migrationError) {
-          this.logger.error(`Error running prisma migrate: ${migrationError.message}`);
-        }
-      }
-
-      this.logger.log("Database has been completely reset");
-      return true;
-    } catch (error) {
-      this.logger.error(
-        `Error resetting database: ${error.message}`,
-        error.stack
-      );
-      return false;
-    } finally {
-      await this.cleanup();
-    }
-  }
-
-  private async dropAllSchemas() {
-    this.logger.log("Dropping all custom schemas");
-    
-    try {
-      // Obtener todos los schemas excepto los del sistema
-      const schemas = await this.getCustomSchemas();
-      this.logger.log(`Found ${schemas.length} custom schemas to drop`);
-      
-      // Desactivar restricciones de clave foránea temporalmente
-      await this.pool.query(`SET session_replication_role = 'replica'`);
-      
-      // Eliminar cada schema y su contenido
-      for (const schema of schemas) {
-        try {
-          await this.pool.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
-          this.logger.log(`Dropped schema: ${schema}`);
-        } catch (error) {
-          this.logger.error(`Error dropping schema ${schema}: ${error.message}`);
-        }
-      }
-      
-      // Reactivar restricciones de clave foránea
-      await this.pool.query(`SET session_replication_role = 'origin'`);
-    } catch (error) {
-      this.logger.error(`Error dropping schemas: ${error.message}`);
-    }
-  }
-
-  private async dropAllPublicTables() {
-    this.logger.log("Dropping all tables in public schema");
-    
-    try {
-      // Obtener todas las tablas del schema public
-      const tables = await this.getPublicTables();
-      this.logger.log(`Found ${tables.length} tables in public schema to drop`);
-      
-      if (tables.length > 0) {
-        // Desactivar restricciones de clave foránea temporalmente
-        await this.pool.query(`SET session_replication_role = 'replica'`);
-        
-        // Eliminar todas las tablas en una sola operación
-        const tableList = tables.map(table => `"${table}"`).join(", ");
-        if (tableList) {
-          await this.pool.query(`DROP TABLE IF EXISTS ${tableList} CASCADE`);
-          this.logger.log("Dropped all tables in public schema");
-        }
-        
-        // Reactivar restricciones de clave foránea
-        await this.pool.query(`SET session_replication_role = 'origin'`);
-      }
-    } catch (error) {
-      this.logger.error(`Error dropping public tables: ${error.message}`);
-    }
-  }
-
-  private async dropAllCustomTypes() {
-    this.logger.log("Dropping all custom types (enums, domains, etc.)");
-    
-    try {
-      // Obtener todos los tipos personalizados
-      const typesQuery = `
-        SELECT t.typname AS name
-        FROM pg_type t 
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE n.nspname = 'public'
-        AND t.typtype = 'e' -- enum types
-      `;
-      
-      const typesResult = await this.pool.query(typesQuery);
-      const types = typesResult.rows.map(row => row.name);
-      
-      this.logger.log(`Found ${types.length} custom types to drop`);
-      
-      // Eliminar cada tipo
-      for (const type of types) {
-        try {
-          await this.pool.query(`DROP TYPE IF EXISTS "${type}" CASCADE`);
-          this.logger.log(`Dropped type: ${type}`);
-        } catch (error) {
-          this.logger.error(`Error dropping type ${type}: ${error.message}`);
-        }
-      }
-    } catch (error) {
-      this.logger.error(`Error dropping custom types: ${error.message}`);
-    }
-  }
-
-  private async getCustomSchemas(): Promise<string[]> {
-    const result = await this.pool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
-    `);
-    
-    return result.rows.map(row => row.schema_name);
-  }
-
-  private async getPublicTables(): Promise<string[]> {
-    const result = await this.pool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-      AND table_type = 'BASE TABLE'
-    `);
-    
-    return result.rows.map(row => row.table_name);
-  }
-
-  private extractDatabaseName(url: string): string | null {
-    // Extraer el nombre de la base de datos de la URL de conexión
-    const matches = url.match(/\/([^/?]+)($|\?)/);
-    return matches ? matches[1] : null;
-  }
-
-  private async terminateConnections(dbName: string) {
-    this.logger.log(`Terminating all connections to database: ${dbName}`);
-    
-    try {
-      await this.adminPool.query(`
-        SELECT pg_terminate_backend(pg_stat_activity.pid)
-        FROM pg_stat_activity
-        WHERE pg_stat_activity.datname = $1
-        AND pid <> pg_backend_pid()
-      `, [dbName]);
-      
-      this.logger.log("All connections terminated successfully");
-    } catch (error) {
-      this.logger.error(`Error terminating connections: ${error.message}`);
-    }
-  }
-
-  private async cleanup() {
-    this.logger.log("Cleaning up database connections");
-    await this.prisma.$disconnect();
-    await this.pool.end();
-    await this.adminPool.end();
-  }
-}
-
-// Script para ejecutar desde línea de comandos
-if (require.main === module) {
-  const run = async () => {
-    try {
-      // Load environment variables first
-      dotenv.config();
-      
-      // Get database URL from command line args or .env
-      const databaseUrl = process.argv[2] || process.env.DATABASE_URL;
-      
-      if (!databaseUrl) {
-        console.error("Error: DATABASE_URL not found in environment variables or command line arguments");
-        process.exit(1);
-      }
-      
-      // Check for recreate flag
-      const recreateFlag = process.argv.includes('--recreate') || process.argv.includes('-r');
-      
-      const resetTool = new DatabaseResetTool(databaseUrl);
-      const success = await resetTool.resetDatabase(recreateFlag);
-      
-      if (!success) {
-        console.error("Database reset failed");
-        process.exit(1);
-      }
-      
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error.message);
-      process.exit(1);
-    }
-  };
-
-  run();
+import * as pg from "pg";
+import * as dotenv from "dotenv";
+import { Logger } from "@nestjs/common";
+import { execSync } from "child_process";
+import { PrismaClient } from "@prisma/client";
+
+dotenv.config();
+
+export class DatabaseResetTool {
+  private readonly logger = new Logger("DatabaseResetTool");
+  private readonly pool: pg.Pool;
+  private readonly adminPool: pg.Pool;
+  private readonly prisma: PrismaClient;
+
+  constructor(private readonly databaseUrl: string) {
+    // Conexión a la base de datos específica
+    this.pool = new pg.Pool({
+      connectionString: this.databaseUrl,
+    });
+
+    // Conexión a la base de datos postgres (admin)
+    const adminUrl = this.databaseUrl.replace(/\/[^/]+$/, "/postgres");
+    this.adminPool = new pg.Pool({
+      connectionString: adminUrl,
+    });
+
+    // Cliente Prisma
+    this.prisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: this.databaseUrl,
+        },
+      },
+    });
+  }
+
+  async resetDatabase(recreateDb = false) {
+    try {
+      this.logger.log("Starting complete database reset process");
+
+      // Extraer el nombre de la base de datos de la URL
+      const dbName = this.extractDatabaseName(this.databaseUrl);
+      
+      if (!dbName) {
+        throw new Error("Could not extract database name from connection URL");
+      }
+
+      // 1. Eliminar todos los schemas personalizados y sus contenidos
+      await this.dropAllSchemas();
+
+      // 2. Eliminar todas las tablas del schema public
+      await this.dropAllPublicTables();
+
+      // 3. Eliminar todos los tipos personalizados (enums, etc.)
+      await this.dropAllCustomTypes();
+
+      if (recreateDb) {
+        // 4. Terminar todas las conexiones y eliminar la base de datos
+        await this.terminateConnections(dbName);
+        await this.adminPool.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+        
+        // 5. Recrear la base de datos
+        this.logger.log(`Recreating database: ${dbName}`);
+        await this.adminPool.query(`CREATE DATABASE "${dbName}"`);
+        
+        // 6. Ejecutar prisma migrate para recrear el esquema base
+        this.logger.log("Running prisma migrate to recreate base schema");
+        try {
+          execSync(`DATABASE_URL="${this.databaseUrl}" npx prisma migrate deploy`, {
+            stdio: 'inherit'
+          });
+        } catch (migrationError) {
+          this.logger.error(`Error running prisma migrate: ${migrationError.message}`);
+        }
+      }
+
+      this.logger.log("Database has been completely reset");
+      return true;
+    } catch (error) {
+      this.logger.error(
+        `Error resetting database: ${error.message}`,
+        error.stack
+      );
+      return false;
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private async dropAllSchemas() {
+    this.logger.log("Dropping all custom schemas");
+    
+    try {
+      // Obtener todos los schemas excepto los del sistema
+      const schemas = await this.getCustomSchemas();
+      this.logger.log(`Found ${schemas.length} custom schemas to drop`);
+      
+      // Desactivar restricciones de clave foránea temporalmente
+      await this.pool.query(`SET session_replication_role = 'replica'`);
+      
+      // Eliminar cada schema y su contenido
+      for (const schema of schemas) {
+        try {
+          await this.pool.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+          this.logger.log(`Dropped schema: ${schema}`);
+        } catch (error) {
+          this.logger.error(`Error dropping schema ${schema}: ${error.message}`);
+        }
+      }
+      
+      // Reactivar restricciones de clave foránea
+      await this.pool.query(`SET session_replication_role = 'origin'`);
+    } catch (error) {
+      this.logger.error(`Error dropping schemas: ${error.message}`);
+    }
+  }
+
+  private async dropAllPublicTables() {
+    this.logger.log("Dropping all tables in public schema");
+    
+    try {
+      // Obtener todas las tablas del schema public
+      const tables = await this.getPublicTables();
+      this.logger.log(`Found ${tables.length} tables in public schema to drop`);
+      
+      if (tables.length > 0) {
+        // Desactivar restricciones de clave foránea temporalmente
+        await this.pool.query(`SET session_replication_role = 'replica'`);
+        
+        // Eliminar todas las tablas en una sola operación
+        const tableList = tables.map(table => `"${table}"`).join(", ");
+        if (tableList) {
+          await this.pool.query(`DROP TABLE IF EXISTS ${tableList} CASCADE`);
+          this.logger.log("Dropped all tables in public schema");
+        }
+        
+        // Reactivar restricciones de clave foránea
+        await this.pool.query(`SET session_replication_role = 'origin'`);
+      }
+    } catch (error) {
+      this.logger.error(`Error dropping public tables: ${error.message}`);
+    }
+  }
+
+  private async dropAllCustomTypes() {
+    this.logger.log("Dropping all custom types (enums, domains, etc.)");
+    
+    try {
+      // Obtener todos los tipos personalizados
+      const typesQuery = `
+        SELECT t.typname AS name
+        FROM pg_type t 
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE n.nspname = 'public'
+        AND t.typtype = 'e' -- enum types
+      `;
+      
+      const typesResult = await this.pool.query(typesQuery);
+      const types = typesResult.rows.map(row => row.name);
+      
+      this.logger.log(`Found ${types.length} custom types to drop`);
+      
+      // Eliminar cada tipo
+      for (const type of types) {
+        try {
+          await this.pool.query(`DROP TYPE IF EXISTS "${type}" CASCADE`);
+          this.logger.log(`Dropped type: ${type}`);
+        } catch (error) {
+          this.logger.error(`Error dropping type ${type}: ${error.message}`);
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Error dropping custom types: ${error.message}`);
+    }
+  }
+
+  private async getCustomSchemas(): Promise<string[]> {
+    const result = await this.pool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
+    `);
+    
+    return result.rows.map(row => row.schema_name);
+  }
+
+  private async getPublicTables(): Promise<string[]> {
+    const result = await this.pool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      AND table_type = 'BASE TABLE'
+    `);
+    
+    return result.rows.map(row => row.table_name);
+  }
+
+  private extractDatabaseName(url: string): string | null {
+    // Extraer el nombre de la base de datos de la URL de conexión
+    const matches = url.match(/\/([^/?]+)($|\?)/);
+    return matches ? matches[1] : null;
+  }
+
+  private async terminateConnections(dbName: string) {
+    this.logger.log(`Terminating all connections to database: ${dbName}`);
+    
+    try {
+      await this.adminPool.query(`
+        SELECT pg_terminate_backend(pg_stat_activity.pid)
+        FROM pg_stat_activity
+        WHERE pg_stat_activity.datname = $1
+        AND pid <> pg_backend_pid()
+      `, [dbName]);
+      
+      this.logger.log("All connections terminated successfully");
+    } catch (error) {
+      this.logger.error(`Error terminating connections: ${error.message}`);
+    }
+  }
+
+  private async cleanup() {
+    this.logger.log("Cleaning up database connections");
+    await this.prisma.$disconnect();
+    await this.pool.end();
+    await this.adminPool.end();
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      // Load environment variables first
+      dotenv.config();
+      
+      // Get database URL from command line args or .env
+      const databaseUrl = process.argv[2] || process.env.DATABASE_URL;
+      
+      if (!databaseUrl) {
+        console.error("Error: DATABASE_URL not found in environment variables or command line arguments");
+        process.exit(1);
+      }
+      
+      // Check for recreate flag
+      const recreateFlag = process.argv.includes('--recreate') || process.argv.includes('-r');
+      
+      const resetTool = new DatabaseResetTool(databaseUrl);
+      const success = await resetTool.resetDatabase(recreateFlag);
+      
+      if (!success) {
+        console.error("Database reset failed");
+        process.exit(1);
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
 }