@javalabs/prisma-client 1.0.27 → 1.0.29

package/src/scripts/run-migration.ts

@@ -1,707 +1,707 @@
-import { Command } from "commander";
-import * as dotenv from "dotenv";
-import { exec } from "child_process";
-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,
-  name: string
-): Promise<boolean> {
-  const { Pool } = await import("pg");
-  const pool = new Pool({ connectionString: url });
-
-  try {
-    console.log(`Testing connection to ${name} database...`);
-    const client = await pool.connect();
-    const result = await client.query("SELECT NOW()");
-    client.release();
-
-    console.log(`Successfully connected to ${name} database`);
-    return true;
-  } catch (error) {
-    console.error(`Failed to connect to ${name} database: ${error.message}`);
-    return false;
-  } finally {
-    await pool.end();
-  }
-}
-
-// Modificar la acción del comando migrate para incluir la prueba de conexión
-program
-  .command("migrate")
-  .description("Run the data migration process")
-  .option("-s, --source <url>", "Source database connection URL")
-  .option("-t, --target <url>", "Target database connection URL")
-  .option(
-    "-m, --mode <mode>",
-    "Migration mode: 'multi-tenant' or 'public-only'",
-    "multi-tenant"
-  )
-  .option("-d, --dry-run", "Perform a dry run without making changes", false)
-  .option("--skip-schema-creation", "Skip the schema creation step", false)
-  .option("--skip-schema-migration", "Skip the schema migration step", false)
-  .option("--skip-data-migration", "Skip the data migration step", false)
-  .option("--skip-validation", "Skip pre and post validation steps", false)
-  .option("--skip-enum-sync", "Skip enum synchronization step", false)
-  .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) {
-      process.env.SOURCE_DATABASE_URL = options.source;
-    }
-
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.SOURCE_DATABASE_URL) {
-      console.error(
-        "Source database URL is required. Use --source or set SOURCE_DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    if (!process.env.DATABASE_URL) {
-      console.error(
-        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    if (options.dryRun) {
-      console.log(
-        "Performing dry run - no changes will be made to the database"
-      );
-      process.env.DRY_RUN = "true";
-    }
-
-    const sourceConnected = await testDatabaseConnection(
-      process.env.SOURCE_DATABASE_URL,
-      "source"
-    );
-    const targetConnected = await testDatabaseConnection(
-      process.env.DATABASE_URL,
-      "target"
-    );
-
-    if (!sourceConnected || !targetConnected) {
-      console.error(
-        "Database connection test failed. Please check your connection strings and try again."
-      );
-      process.exit(1);
-    }
-
-    try {
-      // 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 1: Pre-migration validation
-      if (!options.skipValidation) {
-        console.log("Step 1: Running pre-migration validation...");
-        const { PreMigrationValidator } = await import(
-          "./pre-migration-validator"
-        );
-        const validator = new PreMigrationValidator();
-        const validationResult = await validator.validate();
-
-        if (!validationResult.success && !options.force) {
-          console.log(
-            `Pre-migration validation found ${validationResult.issueCount} issues.`
-          );
-          console.log(JSON.stringify(validationResult, null, 2));
-
-          // Si la opción --yes o --force está activada, continuar automáticamente
-          if (options.yes) {
-            console.log(
-              "Continuing with migration despite issues (--yes flag provided)"
-            );
-          } else if (!options.force) {
-            // Preguntar al usuario si desea continuar a pesar de los problemas
-            const readline = require("readline").createInterface({
-              input: process.stdin,
-              output: process.stdout,
-            });
-
-            const answer = await new Promise<string>((resolve) => {
-              readline.question(
-                "Continue with migration despite issues? (y/N) ",
-                (ans: string) => {
-                  resolve(ans);
-                  readline.close();
-                }
-              );
-            });
-
-            if (answer.toLowerCase() !== "y") {
-              console.log("Migration aborted by user.");
-              process.exit(1);
-            }
-          }
-        } else {
-          console.log("Pre-migration validation successful!");
-        }
-
-        // Corregir automáticamente las discrepancias del esquema si se solicita
-        if (options.autoFixSchema && validationResult.reportPath) {
-          console.log("Automatically fixing schema discrepancies...");
-          const fixer = new SchemaDiscrepancyFixer(
-            process.env.SOURCE_DATABASE_URL,
-            process.env.DATABASE_URL,
-            validationResult.reportPath
-          );
-          await fixer.fixDiscrepancies();
-        }
-      }
-
-      // Step 2: Migrate schema structure
-      if (!options.skipSchemaMigration) {
-        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");
-          }
-        }
-      }
-
-      // Step 3: Synchronize and fix enum types
-      if (!options.skipEnumSync) {
-        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!");
-
-        // 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 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 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({
-            connectionString: process.env.SOURCE_DATABASE_URL,
-            max: 20,
-            idleTimeoutMillis: 30000,
-          }),
-          targetPool: new Pool({
-            connectionString: process.env.DATABASE_URL,
-            max: 20,
-            idleTimeoutMillis: 30000,
-          }),
-          sourcePrisma: new PrismaClient({
-            datasources: { db: { url: process.env.SOURCE_DATABASE_URL } },
-            log: ["error", "warn"],
-          }),
-          targetPrisma: new PrismaClient({
-            datasources: { db: { url: process.env.DATABASE_URL } },
-            log: ["error", "warn"],
-          }),
-        };
-
-        try {
-          // Disable foreign key constraints before migration
-          await connections.targetPool.query(
-            "SET session_replication_role = 'replica';"
-          );
-
-          // Si es public-only, modificar la configuración para solo incluir tablas públicas
-          if (options.mode === "public-only") {
-            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",
-              multiTenant: options.mode !== "public-only",
-            }
-          );
-
-          await migrationTool.migrate();
-        } finally {
-          // Re-enable foreign key constraints
-          await connections.targetPool.query(
-            "SET session_replication_role = 'origin';"
-          );
-
-          // Close connections
-          await connections.sourcePool.end();
-          await connections.targetPool.end();
-          await connections.sourcePrisma.$disconnect();
-          await connections.targetPrisma.$disconnect();
-        }
-      }
-
-      // Step 6: Post-migration validation
-      if (!options.skipValidation) {
-        console.log("Step 6: Running post-migration validation...");
-        const { PostMigrationValidator } = await import(
-          "./post-migration-validator"
-        );
-        const validator = new PostMigrationValidator();
-        const result = await validator.validate({
-          publicOnly: options.mode === "public-only",
-        });
-
-        if (result.success) {
-          console.log("Post-migration validation successful!");
-        } else {
-          console.log(
-            `Post-migration validation found ${result.issueCount} issues.`
-          );
-          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(
-            "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);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("fix-data-types")
-  .description("Fix data type issues in the migrated data")
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (options) => {
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.DATABASE_URL) {
-      console.error(
-        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("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!");
-    } catch (error) {
-      console.error("Error fixing data types:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("truncate-database")
-  .description(
-    "Truncate (empty) all tables in the database without dropping the database"
-  )
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (options) => {
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.DATABASE_URL) {
-      console.error(
-        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("Truncating database...");
-      const { DatabaseTruncateTool } = await import("./truncate-database");
-      const truncateTool = new DatabaseTruncateTool(process.env.DATABASE_URL);
-      await truncateTool.truncateDatabase();
-      console.log("Database truncation completed successfully!");
-    } catch (error) {
-      console.error("Error truncating database:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("retry-failed")
-  .description("Retry failed migrations from an error log file")
-  .argument("<error-log-path>", "Path to the error log file")
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (errorLogPath, options) => {
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.DATABASE_URL) {
-      console.error(
-        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log(`Retrying failed migrations from log: ${errorLogPath}`);
-      const { FailedMigrationRetry } = await import(
-        "./retry-failed-migrations"
-      );
-      const retryTool = new FailedMigrationRetry(errorLogPath);
-      await retryTool.retryFailedMigrations();
-      console.log("Retry process completed!");
-    } catch (error) {
-      console.error("Error retrying failed migrations:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("fix-enum-values")
-  .description("Fix invalid enum values in the database")
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (options) => {
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.DATABASE_URL) {
-      console.error(
-        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("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!");
-    } catch (error) {
-      console.error("Error fixing enum values:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("pre-validate")
-  .description("Validate database before migration")
-  .option("-s, --source <url>", "Source database connection URL")
-  .option("-t, --target <url>", "Target database connection URL")
-  .option("-y, --yes", "Automatically answer yes to all prompts", false)
-  .action(async (options) => {
-    if (options.source) {
-      process.env.SOURCE_DATABASE_URL = options.source;
-    }
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
-      console.error(
-        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("Validating database before migration...");
-      const { PreMigrationValidator } = await import(
-        "./pre-migration-validator"
-      );
-      const validator = new PreMigrationValidator();
-      const result = await validator.validate();
-
-      if (result.success) {
-        console.log("Pre-migration validation successful!");
-        process.exit(0);
-      } else {
-        console.log(
-          `Pre-migration validation found ${result.issueCount} issues.`
-        );
-        console.log(JSON.stringify(result, null, 2));
-
-        // Si la opción --yes está activada, continuar automáticamente
-        if (options.yes) {
-          console.log(
-            "Continuing with migration despite issues (--yes flag provided)"
-          );
-          process.exit(0);
-        }
-
-        // Arreglar el problema con readline usando una promesa
-        const readline = require("readline").createInterface({
-          input: process.stdin,
-          output: process.stdout,
-        });
-
-        const answer = await new Promise<string>((resolve) => {
-          readline.question(
-            "Continue with migration despite issues? (y/N) ",
-            (ans: string) => {
-              resolve(ans);
-              readline.close();
-            }
-          );
-        });
-
-        if (answer.toLowerCase() === "y") {
-          console.log("Continuing with migration despite issues.");
-          process.exit(0);
-        } else {
-          console.log("Migration aborted by user.");
-          process.exit(1);
-        }
-      }
-    } catch (error) {
-      console.error("Error during pre-migration validation:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("sync-enums")
-  .description("Synchronize enum types between databases")
-  .option("-s, --source <url>", "Source database connection URL")
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (options) => {
-    if (options.source) {
-      process.env.SOURCE_DATABASE_URL = options.source;
-    }
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
-      console.error(
-        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("Synchronizing enum types...");
-      const { EnumSynchronizer } = await import("./sync-enum-types");
-      const synchronizer = new EnumSynchronizer();
-      await synchronizer.synchronizeEnums();
-      console.log("Enum types synchronized successfully!");
-    } catch (error) {
-      console.error("Error synchronizing enum types:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("post-validate")
-  .description("Validate database after migration")
-  .option("-s, --source <url>", "Source database connection URL")
-  .option("-t, --target <url>", "Target database connection URL")
-  .action(async (options) => {
-    if (options.source) {
-      process.env.SOURCE_DATABASE_URL = options.source;
-    }
-    if (options.target) {
-      process.env.DATABASE_URL = options.target;
-    }
-
-    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
-      console.error(
-        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
-      );
-      process.exit(1);
-    }
-
-    try {
-      console.log("Validating database after migration...");
-      const { PostMigrationValidator } = await import(
-        "./post-migration-validator"
-      );
-      const validator = new PostMigrationValidator();
-      const result = await validator.validate();
-
-      if (result.success) {
-        console.log("Post-migration validation successful!");
-      } else {
-        console.log(
-          `Post-migration validation found ${result.issueCount} issues.`
-        );
-        console.log(JSON.stringify(result, null, 2));
-      }
-    } catch (error) {
-      console.error("Error during post-migration validation:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("verify")
-  .description("Verify migration setup and connections")
-  .action(async () => {
-    try {
-      const { MigrationSetupVerifier } = await import(
-        "./verify-migration-setup"
-      );
-      const verifier = new MigrationSetupVerifier();
-      await verifier.verifySetup();
-    } catch (error) {
-      console.error("Verification failed:", error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("fix-schema")
-  .description("Fix schema discrepancies between source and target databases")
-  .option("-r, --report <path>", "Path to pre-migration report file")
-  .action(async (options) => {
-    try {
-      const fixer = new SchemaDiscrepancyFixer(
-        process.env.SOURCE_DATABASE_URL,
-        process.env.DATABASE_URL,
-        options.report
-      );
-
-      await fixer.fixDiscrepancies();
-      console.log("Schema discrepancies fixed successfully");
-    } catch (error) {
-      console.error("Error fixing schema discrepancies:", error.message);
-      process.exit(1);
-    }
-  });
-
-// Remove the unused run() function or call it if needed
-program.parse();
+import { Command } from "commander";
+import * as dotenv from "dotenv";
+import { exec } from "child_process";
+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,
+  name: string
+): Promise<boolean> {
+  const { Pool } = await import("pg");
+  const pool = new Pool({ connectionString: url });
+
+  try {
+    console.log(`Testing connection to ${name} database...`);
+    const client = await pool.connect();
+    const result = await client.query("SELECT NOW()");
+    client.release();
+
+    console.log(`Successfully connected to ${name} database`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to connect to ${name} database: ${error.message}`);
+    return false;
+  } finally {
+    await pool.end();
+  }
+}
+
+// Modificar la acción del comando migrate para incluir la prueba de conexión
+program
+  .command("migrate")
+  .description("Run the data migration process")
+  .option("-s, --source <url>", "Source database connection URL")
+  .option("-t, --target <url>", "Target database connection URL")
+  .option(
+    "-m, --mode <mode>",
+    "Migration mode: 'multi-tenant' or 'public-only'",
+    "multi-tenant"
+  )
+  .option("-d, --dry-run", "Perform a dry run without making changes", false)
+  .option("--skip-schema-creation", "Skip the schema creation step", false)
+  .option("--skip-schema-migration", "Skip the schema migration step", false)
+  .option("--skip-data-migration", "Skip the data migration step", false)
+  .option("--skip-validation", "Skip pre and post validation steps", false)
+  .option("--skip-enum-sync", "Skip enum synchronization step", false)
+  .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) {
+      process.env.SOURCE_DATABASE_URL = options.source;
+    }
+
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.SOURCE_DATABASE_URL) {
+      console.error(
+        "Source database URL is required. Use --source or set SOURCE_DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    if (!process.env.DATABASE_URL) {
+      console.error(
+        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    if (options.dryRun) {
+      console.log(
+        "Performing dry run - no changes will be made to the database"
+      );
+      process.env.DRY_RUN = "true";
+    }
+
+    const sourceConnected = await testDatabaseConnection(
+      process.env.SOURCE_DATABASE_URL,
+      "source"
+    );
+    const targetConnected = await testDatabaseConnection(
+      process.env.DATABASE_URL,
+      "target"
+    );
+
+    if (!sourceConnected || !targetConnected) {
+      console.error(
+        "Database connection test failed. Please check your connection strings and try again."
+      );
+      process.exit(1);
+    }
+
+    try {
+      // 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 1: Pre-migration validation
+      if (!options.skipValidation) {
+        console.log("Step 1: Running pre-migration validation...");
+        const { PreMigrationValidator } = await import(
+          "./pre-migration-validator"
+        );
+        const validator = new PreMigrationValidator();
+        const validationResult = await validator.validate();
+
+        if (!validationResult.success && !options.force) {
+          console.log(
+            `Pre-migration validation found ${validationResult.issueCount} issues.`
+          );
+          console.log(JSON.stringify(validationResult, null, 2));
+
+          // Si la opción --yes o --force está activada, continuar automáticamente
+          if (options.yes) {
+            console.log(
+              "Continuing with migration despite issues (--yes flag provided)"
+            );
+          } else if (!options.force) {
+            // Preguntar al usuario si desea continuar a pesar de los problemas
+            const readline = require("readline").createInterface({
+              input: process.stdin,
+              output: process.stdout,
+            });
+
+            const answer = await new Promise<string>((resolve) => {
+              readline.question(
+                "Continue with migration despite issues? (y/N) ",
+                (ans: string) => {
+                  resolve(ans);
+                  readline.close();
+                }
+              );
+            });
+
+            if (answer.toLowerCase() !== "y") {
+              console.log("Migration aborted by user.");
+              process.exit(1);
+            }
+          }
+        } else {
+          console.log("Pre-migration validation successful!");
+        }
+
+        // Corregir automáticamente las discrepancias del esquema si se solicita
+        if (options.autoFixSchema && validationResult.reportPath) {
+          console.log("Automatically fixing schema discrepancies...");
+          const fixer = new SchemaDiscrepancyFixer(
+            process.env.SOURCE_DATABASE_URL,
+            process.env.DATABASE_URL,
+            validationResult.reportPath
+          );
+          await fixer.fixDiscrepancies();
+        }
+      }
+
+      // Step 2: Migrate schema structure
+      if (!options.skipSchemaMigration) {
+        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");
+          }
+        }
+      }
+
+      // Step 3: Synchronize and fix enum types
+      if (!options.skipEnumSync) {
+        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!");
+
+        // 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 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 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({
+            connectionString: process.env.SOURCE_DATABASE_URL,
+            max: 20,
+            idleTimeoutMillis: 30000,
+          }),
+          targetPool: new Pool({
+            connectionString: process.env.DATABASE_URL,
+            max: 20,
+            idleTimeoutMillis: 30000,
+          }),
+          sourcePrisma: new PrismaClient({
+            datasources: { db: { url: process.env.SOURCE_DATABASE_URL } },
+            log: ["error", "warn"],
+          }),
+          targetPrisma: new PrismaClient({
+            datasources: { db: { url: process.env.DATABASE_URL } },
+            log: ["error", "warn"],
+          }),
+        };
+
+        try {
+          // Disable foreign key constraints before migration
+          await connections.targetPool.query(
+            "SET session_replication_role = 'replica';"
+          );
+
+          // Si es public-only, modificar la configuración para solo incluir tablas públicas
+          if (options.mode === "public-only") {
+            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",
+              multiTenant: options.mode !== "public-only",
+            }
+          );
+
+          await migrationTool.migrate();
+        } finally {
+          // Re-enable foreign key constraints
+          await connections.targetPool.query(
+            "SET session_replication_role = 'origin';"
+          );
+
+          // Close connections
+          await connections.sourcePool.end();
+          await connections.targetPool.end();
+          await connections.sourcePrisma.$disconnect();
+          await connections.targetPrisma.$disconnect();
+        }
+      }
+
+      // Step 6: Post-migration validation
+      if (!options.skipValidation) {
+        console.log("Step 6: Running post-migration validation...");
+        const { PostMigrationValidator } = await import(
+          "./post-migration-validator"
+        );
+        const validator = new PostMigrationValidator();
+        const result = await validator.validate({
+          publicOnly: options.mode === "public-only",
+        });
+
+        if (result.success) {
+          console.log("Post-migration validation successful!");
+        } else {
+          console.log(
+            `Post-migration validation found ${result.issueCount} issues.`
+          );
+          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(
+            "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);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("fix-data-types")
+  .description("Fix data type issues in the migrated data")
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (options) => {
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.DATABASE_URL) {
+      console.error(
+        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("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!");
+    } catch (error) {
+      console.error("Error fixing data types:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("truncate-database")
+  .description(
+    "Truncate (empty) all tables in the database without dropping the database"
+  )
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (options) => {
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.DATABASE_URL) {
+      console.error(
+        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("Truncating database...");
+      const { DatabaseTruncateTool } = await import("./truncate-database");
+      const truncateTool = new DatabaseTruncateTool(process.env.DATABASE_URL);
+      await truncateTool.truncateDatabase();
+      console.log("Database truncation completed successfully!");
+    } catch (error) {
+      console.error("Error truncating database:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("retry-failed")
+  .description("Retry failed migrations from an error log file")
+  .argument("<error-log-path>", "Path to the error log file")
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (errorLogPath, options) => {
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.DATABASE_URL) {
+      console.error(
+        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log(`Retrying failed migrations from log: ${errorLogPath}`);
+      const { FailedMigrationRetry } = await import(
+        "./retry-failed-migrations"
+      );
+      const retryTool = new FailedMigrationRetry(errorLogPath);
+      await retryTool.retryFailedMigrations();
+      console.log("Retry process completed!");
+    } catch (error) {
+      console.error("Error retrying failed migrations:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("fix-enum-values")
+  .description("Fix invalid enum values in the database")
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (options) => {
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.DATABASE_URL) {
+      console.error(
+        "Target database URL is required. Use --target or set DATABASE_URL environment variable."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("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!");
+    } catch (error) {
+      console.error("Error fixing enum values:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("pre-validate")
+  .description("Validate database before migration")
+  .option("-s, --source <url>", "Source database connection URL")
+  .option("-t, --target <url>", "Target database connection URL")
+  .option("-y, --yes", "Automatically answer yes to all prompts", false)
+  .action(async (options) => {
+    if (options.source) {
+      process.env.SOURCE_DATABASE_URL = options.source;
+    }
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
+      console.error(
+        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("Validating database before migration...");
+      const { PreMigrationValidator } = await import(
+        "./pre-migration-validator"
+      );
+      const validator = new PreMigrationValidator();
+      const result = await validator.validate();
+
+      if (result.success) {
+        console.log("Pre-migration validation successful!");
+        process.exit(0);
+      } else {
+        console.log(
+          `Pre-migration validation found ${result.issueCount} issues.`
+        );
+        console.log(JSON.stringify(result, null, 2));
+
+        // Si la opción --yes está activada, continuar automáticamente
+        if (options.yes) {
+          console.log(
+            "Continuing with migration despite issues (--yes flag provided)"
+          );
+          process.exit(0);
+        }
+
+        // Arreglar el problema con readline usando una promesa
+        const readline = require("readline").createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        const answer = await new Promise<string>((resolve) => {
+          readline.question(
+            "Continue with migration despite issues? (y/N) ",
+            (ans: string) => {
+              resolve(ans);
+              readline.close();
+            }
+          );
+        });
+
+        if (answer.toLowerCase() === "y") {
+          console.log("Continuing with migration despite issues.");
+          process.exit(0);
+        } else {
+          console.log("Migration aborted by user.");
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      console.error("Error during pre-migration validation:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("sync-enums")
+  .description("Synchronize enum types between databases")
+  .option("-s, --source <url>", "Source database connection URL")
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (options) => {
+    if (options.source) {
+      process.env.SOURCE_DATABASE_URL = options.source;
+    }
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
+      console.error(
+        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("Synchronizing enum types...");
+      const { EnumSynchronizer } = await import("./sync-enum-types");
+      const synchronizer = new EnumSynchronizer();
+      await synchronizer.synchronizeEnums();
+      console.log("Enum types synchronized successfully!");
+    } catch (error) {
+      console.error("Error synchronizing enum types:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("post-validate")
+  .description("Validate database after migration")
+  .option("-s, --source <url>", "Source database connection URL")
+  .option("-t, --target <url>", "Target database connection URL")
+  .action(async (options) => {
+    if (options.source) {
+      process.env.SOURCE_DATABASE_URL = options.source;
+    }
+    if (options.target) {
+      process.env.DATABASE_URL = options.target;
+    }
+
+    if (!process.env.SOURCE_DATABASE_URL || !process.env.DATABASE_URL) {
+      console.error(
+        "Source and target database URLs are required. Use --source and --target or set SOURCE_DATABASE_URL and DATABASE_URL environment variables."
+      );
+      process.exit(1);
+    }
+
+    try {
+      console.log("Validating database after migration...");
+      const { PostMigrationValidator } = await import(
+        "./post-migration-validator"
+      );
+      const validator = new PostMigrationValidator();
+      const result = await validator.validate();
+
+      if (result.success) {
+        console.log("Post-migration validation successful!");
+      } else {
+        console.log(
+          `Post-migration validation found ${result.issueCount} issues.`
+        );
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (error) {
+      console.error("Error during post-migration validation:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("verify")
+  .description("Verify migration setup and connections")
+  .action(async () => {
+    try {
+      const { MigrationSetupVerifier } = await import(
+        "./verify-migration-setup"
+      );
+      const verifier = new MigrationSetupVerifier();
+      await verifier.verifySetup();
+    } catch (error) {
+      console.error("Verification failed:", error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("fix-schema")
+  .description("Fix schema discrepancies between source and target databases")
+  .option("-r, --report <path>", "Path to pre-migration report file")
+  .action(async (options) => {
+    try {
+      const fixer = new SchemaDiscrepancyFixer(
+        process.env.SOURCE_DATABASE_URL,
+        process.env.DATABASE_URL,
+        options.report
+      );
+
+      await fixer.fixDiscrepancies();
+      console.log("Schema discrepancies fixed successfully");
+    } catch (error) {
+      console.error("Error fixing schema discrepancies:", error.message);
+      process.exit(1);
+    }
+  });
+
+// Remove the unused run() function or call it if needed
+program.parse();