@javalabs/prisma-client 1.0.4 → 1.0.8

package/src/scripts/run-migration.ts

@@ -5,12 +5,37 @@ import { promisify } from "util";
 import { SchemaDiscrepancyFixer } from "./fix-schema-discrepancies";
 import { EnumSynchronizer } from "./sync-enum-types";
 import { PrismaClient } from "@prisma/client";
+import { MigrationConfig } from "./data-migration/types";
+import * as fs from "fs";
+import * as path from "path";
+import { DatabaseInitializer } from "./database-initializer";
+import { SequenceSynchronizer } from "./sequence-synchronizer";
 
 dotenv.config();
 
 const execAsync = promisify(exec);
 const program = new Command();
 
+// Función para cargar la configuración de migración
+async function loadMigrationConfig(
+  configPath?: string
+): Promise<MigrationConfig> {
+  const defaultPath = path.join(
+    __dirname,
+    "data-migration",
+    "migration-config.json"
+  );
+  const filePath = configPath || defaultPath;
+
+  try {
+    const configContent = await fs.promises.readFile(filePath, "utf8");
+    return JSON.parse(configContent);
+  } catch (error) {
+    console.error(`Error loading migration config from ${filePath}:`, error);
+    throw error;
+  }
+}
+
 // Añadir esta función después de las importaciones
 async function testDatabaseConnection(
   url: string,
@@ -36,85 +61,6 @@ async function testDatabaseConnection(
 }
 
 // Modificar la acción del comando migrate para incluir la prueba de conexión
-async function initializeDatabase(options: any) {
-  try {
-    const { Pool } = await import("pg");
-    const pool = new Pool({ connectionString: process.env.DATABASE_URL });
-
-    // Check if database is already initialized
-    const tablesExist = await checkIfTablesExist(pool);
-
-    if (!tablesExist) {
-      // Only create tables if they don't exist
-      console.log("Database empty, creating initial schema...");
-      await execAsync("npx prisma db push --skip-generate");
-    } else {
-      console.log("Database schema already exists, skipping schema creation");
-      // Create baseline if it doesn't exist
-      await execAsync(
-        "npx prisma migrate reset --force --skip-generate --skip-seed"
-      );
-    }
-
-    if (!options.skipEnumSync) {
-      console.log("Synchronizing enum types...");
-      const enumSynchronizer = new EnumSynchronizer(
-        process.env.SOURCE_DATABASE_URL,
-        process.env.DATABASE_URL
-      );
-      await enumSynchronizer.synchronizeEnums();
-    }
-
-    // Proceed with data migration if not skipped
-    if (!options.skipDataMigration) {
-      console.log("Starting data migration...");
-      const { DataMigrationTool } = await import(
-        "./data-migration/migration-tool"
-      );
-      const migrationTool = new DataMigrationTool({
-        sourcePool: new Pool({
-          connectionString: process.env.SOURCE_DATABASE_URL,
-        }),
-        targetPool: pool,
-        sourcePrisma: new PrismaClient({
-          datasources: { db: { url: process.env.SOURCE_DATABASE_URL } },
-        }),
-        targetPrisma: new PrismaClient({
-          datasources: { db: { url: process.env.DATABASE_URL } },
-        }),
-      });
-
-      await migrationTool.migrateData({
-        publicOnly: options.mode === "public-only",
-      });
-    }
-
-    await pool.end();
-    return true;
-  } catch (error) {
-    console.error("Error initializing database:", error);
-    return false;
-  }
-}
-
-// Helper function to check if tables exist
-async function checkIfTablesExist(pool: any): Promise<boolean> {
-  try {
-    const result = await pool.query(`
-      SELECT COUNT(*) 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public'
-      AND table_type = 'BASE TABLE'
-    `);
-
-    return parseInt(result.rows[0].count) > 0;
-  } catch (error) {
-    console.error("Error checking tables:", error);
-    return false;
-  }
-}
-
-// Modify the existing action handler
 program
   .command("migrate")
   .description("Run the data migration process")
@@ -134,6 +80,9 @@ program
   .option("--auto-fix-schema", "Automatically fix schema discrepancies", false)
   .option("--force", "Force migration even if validation fails", false)
   .option("-y, --yes", "Automatically answer yes to all prompts", false)
+  .option("--config-path <path>", "Path to migration config file")
+  .option("--skip-initialization", "Skip database initialization step", false)
+  .option("--skip-sequence-sync", "Skip sequence synchronization step", false)
   .action(async (options) => {
     // Set environment variables for the migration
     if (options.source) {
@@ -182,12 +131,16 @@ program
     }
 
     try {
-      // Initialize database if empty
-      await initializeDatabase(options);
+      // Step 0: Initialize database if needed
+      if (!options.skipInitialization) {
+        console.log("Step 0: Checking database initialization...");
+        const initializer = new DatabaseInitializer(process.env.DATABASE_URL);
+        await initializer.initialize();
+      }
 
-      // Step 0: Pre-migration validation
+      // Step 1: Pre-migration validation
       if (!options.skipValidation) {
-        console.log("Step 0: Running pre-migration validation...");
+        console.log("Step 1: Running pre-migration validation...");
         const { PreMigrationValidator } = await import(
           "./pre-migration-validator"
         );
@@ -198,9 +151,7 @@ program
           console.log(
             `Pre-migration validation found ${validationResult.issueCount} issues.`
           );
-          console.log(
-            `Check the full report at: ${validationResult.reportPath}`
-          );
+          console.log(JSON.stringify(validationResult, null, 2));
 
           // Si la opción --yes o --force está activada, continuar automáticamente
           if (options.yes) {
@@ -245,14 +196,32 @@ program
         }
       }
 
-      // Step 1: Migrate schema structure first
+      // Step 2: Migrate schema structure
       if (!options.skipSchemaMigration) {
-        console.log("Step 1: Migrating schema structure...");
+        console.log("Step 2: Migrating schema structure...");
         if (options.mode === "multi-tenant") {
           await execAsync("node dist/scripts/migrate-schema-structure.js");
         } else {
           const { Pool } = await import("pg");
           const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+          // Helper function to check if tables exist
+          async function checkIfTablesExist(pool: any): Promise<boolean> {
+            try {
+              const result = await pool.query(`
+                SELECT COUNT(*) 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public'
+                AND table_type = 'BASE TABLE'
+              `);
+
+              return parseInt(result.rows[0].count) > 0;
+            } catch (error) {
+              console.error("Error checking tables:", error);
+              return false;
+            }
+          }
+
           const tablesExist = await checkIfTablesExist(pool);
           if (!tablesExist) {
             await execAsync("npx prisma migrate deploy");
@@ -260,31 +229,49 @@ program
         }
       }
 
-      // Step 2: Now synchronize enums
+      // Step 3: Synchronize and fix enum types
       if (!options.skipEnumSync) {
-        console.log("Step 2: Synchronizing enum types...");
+        console.log("Step 3: Synchronizing and fixing enum types...");
+        // Sync enum types
         const { EnumSynchronizer } = await import("./sync-enum-types");
         const synchronizer = new EnumSynchronizer();
         await synchronizer.synchronizeEnums();
         console.log("Enum types synchronized successfully!");
 
-        console.log("Step 2.1: Synchronizing enum values...");
+        // Sync enum values
+        console.log("Step 3.1: Synchronizing enum values...");
         const { EnumValueSynchronizer } = await import("./sync-enum-values");
         const valueSynchronizer = new EnumValueSynchronizer();
         await valueSynchronizer.synchronizeEnumValues();
         console.log("Enum values synchronized successfully!");
+
+        // Fix enum values
+        console.log("Step 3.2: Fixing enum values...");
+        const { EnumFixer } = await import("./fix-enum-values");
+        const enumFixer = new EnumFixer(process.env.DATABASE_URL);
+        await enumFixer.fixEnumValues();
+        console.log("Enum values fixed successfully!");
       }
 
-      // Step 3: Migrate data with transformation
-      // In the migrate command action
+      // Step 4: Fix data types
+      console.log("Step 4: Fixing data type issues...");
+      const { DataTypeFixer } = await import("./fix-data-types");
+      const fixer = new DataTypeFixer();
+      await fixer.fixDataTypes();
+      console.log("Data type fixing completed successfully!");
+
+      // Step 5: Migrate data with transformation
       if (!options.skipDataMigration) {
-        console.log("Step 3: Migrating data with transformation...");
+        console.log("Step 5: Migrating data with transformation...");
         const { DataMigrationTool } = await import(
           "./data-migration/migration-tool"
         );
         const { PrismaClient } = await import("@prisma/client");
         const { Pool } = await import("pg");
 
+        // Cargar la configuración de migración
+        const migrationConfig = await loadMigrationConfig(options.configPath);
+
         // Create connections with increased pool size and timeout
         const connections = {
           sourcePool: new Pool({
@@ -313,20 +300,44 @@ program
             "SET session_replication_role = 'replica';"
           );
 
-          const migrationTool = new DataMigrationTool(connections);
-
+          // Si es public-only, modificar la configuración para solo incluir tablas públicas
           if (options.mode === "public-only") {
-            await migrationTool.migrateData({
-              publicOnly: true,
+            migrationConfig.tables = Object.entries(migrationConfig.tables)
+              .filter(([_, config]) => config.type === "public")
+              .reduce(
+                (acc, [key, value]) => ({
+                  ...acc,
+                  [key]: value,
+                }),
+                {}
+              );
+          }
+
+          const migrationTool = new DataMigrationTool(
+            connections,
+            {
+              ...migrationConfig,
+              tables: Object.entries(migrationConfig.tables).reduce(
+                (acc, [key, value]) => ({
+                  ...acc,
+                  [key]: {
+                    ...value,
+                    sourceTable: value.sourceTable || key,
+                    targetTable: value.targetTable || key,
+                  },
+                }),
+                {}
+              ),
+            },
+            {
+              publicOnly: options.mode === "public-only",
               targetSchema: "public",
               sourceSchema: "public",
-            });
-          } else {
-            await migrationTool.migrateData({
-              forceSingleTenant: false,
-              multiTenant: true,
-            });
-          }
+              multiTenant: options.mode !== "public-only",
+            }
+          );
+
+          await migrationTool.migrate();
         } finally {
           // Re-enable foreign key constraints
           await connections.targetPool.query(
@@ -341,20 +352,6 @@ program
         }
       }
 
-      // Step 4: Fix enum values if needed
-      console.log("Step 4: Fixing enum values...");
-      const { EnumFixer } = await import("./fix-enum-values");
-      const enumFixer = new EnumFixer(process.env.DATABASE_URL);
-      await enumFixer.fixEnumValues();
-      console.log("Enum values fixed successfully!");
-
-      // Step 5: Fix data types if needed
-      console.log("Step 5: Fixing data type issues...");
-      const { DataTypeFixer } = await import("./fix-data-types");
-      const fixer = new DataTypeFixer();
-      await fixer.fixDataTypes();
-      console.log("Data type fixing completed successfully!");
-
       // Step 6: Post-migration validation
       if (!options.skipValidation) {
         console.log("Step 6: Running post-migration validation...");
@@ -362,7 +359,9 @@ program
           "./post-migration-validator"
         );
         const validator = new PostMigrationValidator();
-        const result = await validator.validate();
+        const result = await validator.validate({
+          publicOnly: options.mode === "public-only",
+        });
 
         if (result.success) {
           console.log("Post-migration validation successful!");
@@ -370,13 +369,30 @@ program
           console.log(
             `Post-migration validation found ${result.issueCount} issues.`
           );
-          console.log(`Check the full report at: ${result.reportPath}`);
+          console.log(JSON.stringify(result, null, 2));
+
+          if (!options.force) {
+            console.error(
+              "Migration validation failed. Use --force to continue anyway."
+            );
+            process.exit(1);
+          }
           console.log(
-            "You may need to run 'retry-failed' command to fix these issues."
+            "Continuing with migration despite validation issues (--force flag provided)"
           );
         }
       }
 
+      // Step 7: Synchronize sequences (final step)
+      if (!options.skipSequenceSync) {
+        console.log("Step 7: Synchronizing database sequences...");
+        const sequenceSynchronizer = new SequenceSynchronizer(
+          process.env.DATABASE_URL
+        );
+        await sequenceSynchronizer.synchronizeSequences();
+        console.log("Database sequences synchronized successfully!");
+      }
+
       console.log("Migration process completed successfully!");
     } catch (error) {
       console.error("Error running migration:", error);
@@ -537,7 +553,7 @@ program
         console.log(
           `Pre-migration validation found ${result.issueCount} issues.`
         );
-        console.log(`Check the full report at: ${result.reportPath}`);
+        console.log(JSON.stringify(result, null, 2));
 
         // Si la opción --yes está activada, continuar automáticamente
         if (options.yes) {
@@ -643,7 +659,7 @@ program
         console.log(
           `Post-migration validation found ${result.issueCount} issues.`
         );
-        console.log(`Check the full report at: ${result.reportPath}`);
+        console.log(JSON.stringify(result, null, 2));
       }
     } catch (error) {
       console.error("Error during post-migration validation:", error);

package/src/scripts/sequence-synchronizer.ts

@@ -0,0 +1,127 @@
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+
+export class SequenceSynchronizer {
+  private readonly logger = new Logger("SequenceSynchronizer");
+  private readonly pool: Pool;
+
+  constructor(databaseUrl: string) {
+    this.pool = new Pool({
+      connectionString: databaseUrl,
+    });
+  }
+
+  async synchronizeSequences(): Promise<void> {
+    try {
+      this.logger.log("Iniciando sincronización de secuencias");
+
+      // Obtener todas las tablas en la base de datos
+      const tables = await this.getTables();
+      this.logger.log(`Encontradas ${tables.length} tablas para procesar`);
+
+      // Procesar cada tabla
+      for (const table of tables) {
+        await this.synchronizeTableSequences(table);
+      }
+
+      this.logger.log("Sincronización de secuencias completada con éxito");
+    } catch (error) {
+      this.logger.error(
+        `Error durante la sincronización de secuencias: ${error.message}`,
+        error.stack
+      );
+      throw error;
+    } finally {
+      await this.pool.end();
+    }
+  }
+
+  private async getTables(): Promise<string[]> {
+    const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_type = 'BASE TABLE'
+    `;
+
+    const result = await this.pool.query(query);
+    return result.rows.map((row) => row.table_name);
+  }
+
+  private async synchronizeTableSequences(tableName: string): Promise<void> {
+    try {
+      // Verificar si la tabla tiene una columna id
+      const columns = await this.pool.query(
+        `
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 
+        AND column_name = 'id'
+      `,
+        [tableName]
+      );
+
+      if (columns.rows.length === 0) {
+        this.logger.debug(
+          `La tabla ${tableName} no tiene columna id, omitiendo`
+        );
+        return;
+      }
+
+      // Verificar si existe una secuencia para esta tabla
+      const sequenceName = `${tableName}_id_seq`;
+      const sequences = await this.pool.query(
+        `
+        SELECT sequence_name 
+        FROM information_schema.sequences 
+        WHERE sequence_name = $1
+      `,
+        [sequenceName]
+      );
+
+      if (sequences.rows.length === 0) {
+        this.logger.debug(
+          `No se encontró secuencia para la tabla ${tableName}, omitiendo`
+        );
+        return;
+      }
+
+      // Obtener el máximo ID actual de la tabla
+      const maxResult = await this.pool.query(`
+        SELECT COALESCE(MAX(id), 0) as max_id FROM "${tableName}"
+      `);
+      const maxId = maxResult.rows[0].max_id;
+
+      // Obtener el valor actual de la secuencia
+      const currValResult = await this.pool.query(`
+        SELECT last_value FROM "${sequenceName}"
+      `);
+      const currVal = currValResult.rows[0].last_value;
+
+      this.logger.log(
+        `Tabla ${tableName}: ID Máximo = ${maxId}, Valor Actual de Secuencia = ${currVal}`
+      );
+
+      // Actualizar la secuencia solo si es necesario
+      if (currVal <= maxId) {
+        await this.pool.query(
+          `
+          SELECT setval($1, $2, true)
+        `,
+          [sequenceName, maxId]
+        );
+        this.logger.log(
+          `Actualizada secuencia para tabla ${tableName} a ${maxId}`
+        );
+      } else {
+        this.logger.log(
+          `La secuencia para la tabla ${tableName} ya está adelantada al ID máximo, no se requiere actualización`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Error sincronizando secuencias para tabla ${tableName}: ${error.message}`
+      );
+    }
+  }
+}

package/prisma/migrations/20250422001957_add_bank_account_id_relations/migration.sql

@@ -1,14 +0,0 @@
-/*
-  Warnings:
-
-  - You are about to drop the column `usersUser_id` on the `manual_payments` table. All the data in the column will be lost.
-
-*/
--- DropForeignKey
-ALTER TABLE "manual_payments" DROP CONSTRAINT "manual_payments_usersUser_id_fkey";
-
--- AlterTable
-ALTER TABLE "manual_payments" DROP COLUMN "usersUser_id";
-
--- AddForeignKey
-ALTER TABLE "manual_payments" ADD CONSTRAINT "manual_payments_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("user_id") ON DELETE RESTRICT ON UPDATE CASCADE;