@javalabs/prisma-client 1.0.0

package/src/scripts/run-migration.ts

@@ -0,0 +1,691 @@
+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";
+
+dotenv.config();
+
+const execAsync = promisify(exec);
+const program = new Command();
+
+// 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
+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")
+  .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)
+  .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 {
+      // Initialize database if empty
+      await initializeDatabase(options);
+
+      // Step 0: Pre-migration validation
+      if (!options.skipValidation) {
+        console.log("Step 0: 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(
+            `Check the full report at: ${validationResult.reportPath}`
+          );
+
+          // 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 1: Migrate schema structure first
+      if (!options.skipSchemaMigration) {
+        console.log("Step 1: 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 });
+          const tablesExist = await checkIfTablesExist(pool);
+          if (!tablesExist) {
+            await execAsync("npx prisma migrate deploy");
+          }
+        }
+      }
+
+      // Step 2: Now synchronize enums
+      if (!options.skipEnumSync) {
+        console.log("Step 2: Synchronizing 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...");
+        const { EnumValueSynchronizer } = await import("./sync-enum-values");
+        const valueSynchronizer = new EnumValueSynchronizer();
+        await valueSynchronizer.synchronizeEnumValues();
+        console.log("Enum values synchronized successfully!");
+      }
+
+      // Step 3: Migrate data with transformation
+      // In the migrate command action
+      if (!options.skipDataMigration) {
+        console.log("Step 3: Migrating data with transformation...");
+        const { DataMigrationTool } = await import(
+          "./data-migration/migration-tool"
+        );
+        const { PrismaClient } = await import("@prisma/client");
+        const { Pool } = await import("pg");
+
+        // 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';"
+          );
+
+          const migrationTool = new DataMigrationTool(connections);
+
+          if (options.mode === "public-only") {
+            await migrationTool.migrateData({
+              publicOnly: true,
+              targetSchema: "public",
+              sourceSchema: "public",
+            });
+          } else {
+            await migrationTool.migrateData({
+              forceSingleTenant: false,
+              multiTenant: true,
+            });
+          }
+        } 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 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...");
+        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(`Check the full report at: ${result.reportPath}`);
+          console.log(
+            "You may need to run 'retry-failed' command to fix these issues."
+          );
+        }
+      }
+
+      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(`Check the full report at: ${result.reportPath}`);
+
+        // 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(`Check the full report at: ${result.reportPath}`);
+      }
+    } 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();