@javalabs/prisma-client 1.0.4 → 1.0.8

package/src/scripts/data-migration/migration-tool.ts

@@ -1,6 +1,6 @@
 import { Logger } from "@nestjs/common";
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "fs";
+import * as path from "path";
 import { SchemaUtils } from "./schema-utils";
 import { DataTransformer } from "./data-transformer";
 import { DatabaseConnections, ColumnSchema, EntityType } from "./types";
@@ -11,19 +11,22 @@ import { DependencyResolver } from "./dependency-resolver";
 interface MigrationOptions {
   publicOnly?: boolean;
   multiTenant?: boolean;
-  sourceSchema?: string; // Potentially deprecated with config
-  targetSchema?: string; // Potentially deprecated with config
+  sourceSchema?: string;
+  targetSchema?: string;
   forceSingleTenant?: boolean; // Alias for publicOnly
   configPath?: string;
 }
 
 interface TableConfig {
-  type: 'public' | 'filteredPublic' | 'tenantInfo' | 'tenant';
+  type: "public" | "filteredPublic" | "tenantInfo" | "tenant";
   idField: string;
   filterColumn?: string;
   via?: string;
   providerLink?: string;
   tenantKey?: string;
+  dependencies?: string[];
+  sourceTable: string;
+  targetTable: string;
 }
 
 interface MigrationConfig {
@@ -40,61 +43,74 @@ export class DataMigrationTool {
   private readonly logger = new Logger("DataMigrationTool");
   private readonly schemaUtils: SchemaUtils;
   private readonly dataTransformer: DataTransformer;
-  private readonly foreignKeyManager: ForeignKeyManager;
   private readonly batchMigrator: BatchMigrator;
+  private readonly foreignKeyManager: ForeignKeyManager;
   private readonly dependencyResolver: DependencyResolver;
-  private migrationConfig: MigrationConfig;
-
-  private schemaCache: Record<string, ColumnSchema[]> = {};
-  private targetSchemaCache: Record<string, ColumnSchema[]> = {};
 
+  constructor(
+    private readonly connections: DatabaseConnections,
+    private migrationConfig: MigrationConfig,
+    private readonly options: MigrationOptions = {}
+  ) {
+    this.schemaUtils = new SchemaUtils(connections);
 
-  constructor(private readonly connections: DatabaseConnections) {
-    this.schemaUtils = new SchemaUtils(
+    this.dataTransformer = new DataTransformer(
+      this.schemaUtils,
       connections.sourcePool,
-      connections.targetPool
+      connections
     );
-    this.dataTransformer = new DataTransformer(this.schemaUtils);
+
     this.foreignKeyManager = new ForeignKeyManager(connections);
-    this.dependencyResolver = new DependencyResolver(
-      connections.sourcePool,
-      connections.targetPool
-    );
+
     this.batchMigrator = new BatchMigrator(
-      this.dataTransformer,
       this.schemaUtils,
+      this.dataTransformer,
       connections,
-      this.dependencyResolver,
-      this.schemaCache,
-      this.targetSchemaCache
+      this.options
+    );
+
+    this.dependencyResolver = new DependencyResolver(
+      connections.sourcePool,
+      connections.targetPool
     );
   }
 
-  private loadConfig(configPath: string = 'migration-config.json'): void {
+  private loadConfig(configPath: string = "migration-config.json"): void {
     const fullPath = path.resolve(process.cwd(), configPath);
     if (!fs.existsSync(fullPath)) {
       throw new Error(`Migration config file not found at: ${fullPath}`);
     }
     try {
-      const fileContent = fs.readFileSync(fullPath, 'utf-8');
+      const fileContent = fs.readFileSync(fullPath, "utf-8");
       this.migrationConfig = JSON.parse(fileContent);
       this.logger.log(`Loaded migration config from: ${fullPath}`);
+
+      // Pasar la configuración al DependencyResolver
+      this.dependencyResolver.setConfig(this.migrationConfig);
     } catch (error) {
-      throw new Error(`Error reading or parsing migration config file: ${error.message}`);
+      throw new Error(
+        `Error reading or parsing migration config file: ${error.message}`
+      );
     }
-    if (!this.migrationConfig.commonSchema || !this.migrationConfig.tables || !this.migrationConfig.tenantInfo) {
-        throw new Error('Invalid migration config structure.');
+    if (
+      !this.migrationConfig.commonSchema ||
+      !this.migrationConfig.tables ||
+      !this.migrationConfig.tenantInfo
+    ) {
+      throw new Error("Invalid migration config structure.");
     }
   }
 
-  async migrateData(options: MigrationOptions = {}) {
+  async migrate(): Promise<void> {
     try {
       this.logger.log("Starting data migration process");
-      this.loadConfig(options.configPath);
+      this.loadConfig(this.options.configPath);
 
       // Check the publicOnly/forceSingleTenant flag AFTER loading config
-      if (options.forceSingleTenant || options.publicOnly) {
-        this.logger.log("Public-only migration requested. Migrating only 'public' type tables...");
+      if (this.options.forceSingleTenant || this.options.publicOnly) {
+        this.logger.log(
+          "Public-only migration requested. Migrating only 'public' type tables..."
+        );
         await this.migratePublicTablesOnly(); // Call the dedicated function
       } else {
         this.logger.log("Multi-tenant migration requested based on config...");
@@ -107,251 +123,387 @@ export class DataMigrationTool {
     }
   }
 
-  // --- Function for Public-Only Migration --- 
+  // --- Function for Public-Only Migration ---
   private async migratePublicTablesOnly() {
-      const { commonSchema, tables: tablesConfig } = this.migrationConfig;
-      const allTablesInOrder = await this.dependencyResolver.analyzeDependencies();
+    const { commonSchema, tables: tablesConfig } = this.migrationConfig;
+    const allTablesInOrder =
+      await this.dependencyResolver.analyzeDependencies();
 
-      // Filter only the tables marked as 'public' in the config
-      const publicTablesToMigrate = allTablesInOrder.filter(t => tablesConfig[t]?.type === 'public');
+    // Filter only the tables marked as 'public' in the config
+    const publicTablesToMigrate = allTablesInOrder.filter(
+      (t) => tablesConfig[t]?.type === "public"
+    );
 
-      this.logger.log(`Migrating public tables to '${commonSchema}' schema: ${publicTablesToMigrate.join(", ")}`);
-      if (publicTablesToMigrate.length === 0) {
-          this.logger.warn("No tables configured as 'public'. Public-only migration will not process any tables.");
-          return;
-      }
+    this.logger.log(
+      `Migrating public tables to '${commonSchema}' schema: ${publicTablesToMigrate.join(
+        ", "
+      )}`
+    );
+    if (publicTablesToMigrate.length === 0) {
+      this.logger.warn(
+        "No tables configured as 'public'. Public-only migration will not process any tables."
+      );
+      return;
+    }
 
-      await this.connections.targetPool.query(`SET session_replication_role = 'replica';`);
+    await this.connections.targetPool.query(
+      `SET session_replication_role = 'replica';`
+    );
 
-      for (const tableName of publicTablesToMigrate) {
-          const config = tablesConfig[tableName];
-          if (!config) {
-              this.logger.warn(`Config not found for public table ${tableName}, skipping.`); // Should not happen if filter worked
-              continue;
-          }
-          try {
-              await this.batchMigrator.migrateEntityDataInBatches(
-                  this.connections.targetPrisma,
-                  { name: tableName, idField: config.idField },
-                  null, // No provider filter for public-only migration
-                  commonSchema // Target is the common schema
-              );
-          } catch (error) {
-              this.logger.error(`Error migrating public table ${tableName}: ${error.message}`);
-              // Decide whether to stop or continue on error for public-only
-              throw error; 
-          }
+    for (const tableName of publicTablesToMigrate) {
+      const config = tablesConfig[tableName];
+      if (!config) {
+        this.logger.warn(
+          `Config not found for public table ${tableName}, skipping.`
+        ); // Should not happen if filter worked
+        continue;
       }
+      try {
+        await this.batchMigrator.migrateEntityDataInBatches(
+          this.migrationConfig.commonSchema,
+          commonSchema,
+          {
+            type: "public",
+            idField: config.idField,
+            sourceTable: tableName,
+            targetTable: tableName,
+          },
+          null // No provider filter for public-only migration
+        );
+      } catch (error) {
+        this.logger.error(
+          `Error migrating public table ${tableName}: ${error.message}`
+        );
+        // Decide whether to stop or continue on error for public-only
+        throw error;
+      }
+    }
 
-      await this.connections.targetPool.query(`SET session_replication_role = 'origin';`);
-      this.logger.log("Finished migrating public tables.");
+    await this.connections.targetPool.query(
+      `SET session_replication_role = 'origin';`
+    );
+    this.logger.log("Finished migrating public tables.");
   }
 
-
   // Keep validateSourceData (potentially enhanced)
   private async validateSourceData() {
-     this.logger.log("Validating source data...");
-       try {
-          const { sourceTable, providerIdColumn } = this.migrationConfig.tenantInfo;
-          const tablesConfig = this.migrationConfig.tables;
-          
-          // Find the config for the transaction-like table and the provider table
-          let transactionTableKey = 'transactions'; // Default or find dynamically
-          let providerTableKey = 'providers'; // Default or find dynamically
-          let transactionProviderFk = providerIdColumn; // Default
-
-          for (const key in tablesConfig) {
-              if (tablesConfig[key].type === 'filteredPublic' && tablesConfig[key].filterColumn === providerIdColumn && !tablesConfig[key].via) {
-                  transactionTableKey = key;
-                  transactionProviderFk = tablesConfig[key].filterColumn;
-              }
-              if (tablesConfig[key].type === 'public' && tablesConfig[key].idField === providerIdColumn) {
-                  providerTableKey = key;
-              }
-          }
-           this.logger.debug(`Validation check: Using ${transactionTableKey}.${transactionProviderFk} referencing ${providerTableKey}.${providerIdColumn}`);
+    this.logger.log("Validating source data...");
+    try {
+      const { sourceTable, providerIdColumn } = this.migrationConfig.tenantInfo;
+      const tablesConfig = this.migrationConfig.tables;
+
+      // Find the config for the transaction-like table and the provider table
+      let transactionTableKey = "transactions"; // Default or find dynamically
+      let providerTableKey = "providers"; // Default or find dynamically
+      let transactionProviderFk = providerIdColumn; // Default
+
+      for (const key in tablesConfig) {
+        if (
+          tablesConfig[key].type === "filteredPublic" &&
+          tablesConfig[key].filterColumn === providerIdColumn &&
+          !tablesConfig[key].via
+        ) {
+          transactionTableKey = key;
+          transactionProviderFk = tablesConfig[key].filterColumn;
+        }
+        if (
+          tablesConfig[key].type === "public" &&
+          tablesConfig[key].idField === providerIdColumn
+        ) {
+          providerTableKey = key;
+        }
+      }
+      this.logger.debug(
+        `Validation check: Using ${transactionTableKey}.${transactionProviderFk} referencing ${providerTableKey}.${providerIdColumn}`
+      );
 
-          // Dynamically build the query
-          // IMPORTANT: Ensure proper SQL identifier quoting if names contain special chars/are reserved words
-          const query = `
+      // Dynamically build the query
+      // IMPORTANT: Ensure proper SQL identifier quoting if names contain special chars/are reserved words
+      const query = `
             SELECT t."${tablesConfig[transactionTableKey].idField}" AS transaction_id, t."${transactionProviderFk}"
             FROM "${transactionTableKey}" t
             LEFT JOIN "${providerTableKey}" p ON t."${transactionProviderFk}" = p."${providerIdColumn}"
             WHERE t."${transactionProviderFk}" IS NOT NULL AND p."${providerIdColumn}" IS NULL;
           `;
 
-          const invalidTransactions = (await this.connections.sourcePrisma.$queryRawUnsafe(query)) as any[];
-
-          if (invalidTransactions.length > 0) {
-            this.logger.error(`${invalidTransactions.length} records found in ${transactionTableKey} with invalid foreign key reference to ${providerTableKey}.${providerIdColumn}`);
-            console.error("Invalid records (limit 10):", invalidTransactions.slice(0, 10)); 
-            throw new Error("Source data validation failed: Invalid foreign key references found. Please check the configuration or fix the source data.");
-          } else {
-            this.logger.log(`Source data validation passed: All ${transactionTableKey}.${transactionProviderFk} references are valid.`);
-          }
-        } catch (error) {
-          this.logger.error("Error during source data validation:");
-          console.error(error);
-          throw error;
-        }
+      const invalidTransactions =
+        (await this.connections.sourcePrisma.$queryRawUnsafe(query)) as any[];
+
+      if (invalidTransactions.length > 0) {
+        this.logger.error(
+          `${invalidTransactions.length} records found in ${transactionTableKey} with invalid foreign key reference to ${providerTableKey}.${providerIdColumn}`
+        );
+        console.error(
+          "Invalid records (limit 10):",
+          invalidTransactions.slice(0, 10)
+        );
+        throw new Error(
+          "Source data validation failed: Invalid foreign key references found. Please check the configuration or fix the source data."
+        );
+      } else {
+        this.logger.log(
+          `Source data validation passed: All ${transactionTableKey}.${transactionProviderFk} references are valid.`
+        );
+      }
+    } catch (error) {
+      this.logger.error("Error during source data validation:");
+      console.error(error);
+      throw error;
+    }
   }
 
-
   // Renamed from migrateToTenantSchemas to reflect its purpose
   private async migrateMultiTenantWithConfig() {
-    await this.validateSourceData(); // Validate first
+    await this.validateSourceData();
+
+    const {
+      commonSchema,
+      tables: tablesConfig,
+      tenantInfo,
+    } = this.migrationConfig;
+
+    // Obtener orden de tablas basado en dependencias
+    const allTablesInOrder =
+      await this.dependencyResolver.analyzeDependencies();
+    this.logger.log(`Orden de migración: ${allTablesInOrder.join(" -> ")}`);
+
+    // Validar dependencias antes de comenzar
+    for (const tableName of allTablesInOrder) {
+      const config = tablesConfig[tableName];
+      if (config?.dependencies) {
+        const valid = await this.dependencyResolver.validateDependencies(
+          tableName,
+          config.dependencies
+        );
+        if (!valid) {
+          this.logger.warn(
+            `Advertencia: Algunas dependencias para ${tableName} no están disponibles`
+          );
+        }
+      }
+    }
 
-    const { commonSchema, tables: tablesConfig, tenantInfo } = this.migrationConfig;
-    const allTablesInOrder = await this.dependencyResolver.analyzeDependencies();
+    // --- PASADA 0: Migrar tablas públicas ---
+    this.logger.log(`Migrando tablas públicas al esquema '${commonSchema}'...`);
+    await this.connections.targetPool.query(
+      `SET session_replication_role = 'replica';`
+    );
 
-    // --- PASADA 0: Migrar tablas públicas --- 
-    this.logger.log(`Migrating public tables to '${commonSchema}' schema...`);
-    await this.connections.targetPool.query(`SET session_replication_role = 'replica';`);
-    const publicTables = allTablesInOrder.filter(t => tablesConfig[t]?.type === 'public');
+    const publicTables = allTablesInOrder.filter(
+      (t) => tablesConfig[t]?.type === "public"
+    );
 
     for (const tableName of publicTables) {
-        const config = tablesConfig[tableName];
-        if (!config) {
-             this.logger.warn(`Skipping migration for table ${tableName}: Not found in config.`);
-             continue;
-        }
-        try {
-            await this.batchMigrator.migrateEntityDataInBatches(
-                this.connections.targetPrisma,
-                { name: tableName, idField: config.idField }, // Pass config details
-                null, // No provider filter for public tables
-                commonSchema
-            );
-        } catch (error) {
-            this.logger.error(`Error migrating public table ${tableName}: ${error.message}`);
-            throw error; // Stop if essential public table fails
-        }
+      const config = tablesConfig[tableName];
+      if (!config) {
+        this.logger.warn(
+          `Saltando migración de tabla ${tableName}: No encontrada en configuración`
+        );
+        continue;
+      }
+
+      try {
+        await this.batchMigrator.migrateEntityDataInBatches(
+          this.migrationConfig.commonSchema,
+          commonSchema,
+          {
+            type: "public",
+            idField: config.idField,
+            sourceTable: tableName,
+            targetTable: tableName,
+          },
+          null
+        );
+      } catch (error) {
+        this.logger.error(
+          `Error migrando tabla pública ${tableName}: ${error.message}`
+        );
+        throw error;
+      }
     }
-    await this.connections.targetPool.query(`SET session_replication_role = 'origin';`);
+    await this.connections.targetPool.query(
+      `SET session_replication_role = 'origin';`
+    );
     this.logger.log("Finished migrating public tables.");
 
-    // --- Obtener Inquilinos --- 
-    this.logger.log(`Fetching tenant info from source table '${tenantInfo.sourceTable}'...`);
-    const tenants = await this.connections.sourcePrisma[tenantInfo.sourceTable].findMany({
-        select: {
-            [tenantInfo.tenantIdColumn]: true,
-            [tenantInfo.providerIdColumn]: true,
-        }
+    // --- Obtener Inquilinos ---
+    this.logger.log(
+      `Fetching tenant info from source table '${tenantInfo.sourceTable}'...`
+    );
+    const tenants = await this.connections.sourcePrisma[
+      tenantInfo.sourceTable
+    ].findMany({
+      select: {
+        [tenantInfo.tenantIdColumn]: true,
+        [tenantInfo.providerIdColumn]: true,
+      },
     });
     this.logger.log(`Found ${tenants.length} potential tenants.`);
 
-    // --- Crear Esquemas y Preparar Migración por Inquilino --- 
+    // --- Crear Esquemas y Preparar Migración por Inquilino ---
     const validTenants = new Map<string, number | null>(); // Map tenantId -> providerId
-    this.logger.log("Ensuring tenant schemas exist (if strategy requires them)...");
-    let requiresTenantSchemas = Object.values(tablesConfig).some(t => t.type === 'tenant');
-    if(requiresTenantSchemas) {
-        this.logger.log('Tenant-specific schemas are required by config.');
-        for (const tenant of tenants) {
-            const tenantId = tenant[tenantInfo.tenantIdColumn];
-            const providerId = tenant[tenantInfo.providerIdColumn] ?? null;
-            if (tenantId && typeof tenantId === 'string' && tenantId !== commonSchema) {
-                await this.schemaUtils.createSchema(tenantId);
-                validTenants.set(tenantId, providerId);
-                this.logger.log(`Ensured schema exists for tenant: ${tenantId}`);
-            } else {
-                this.logger.warn(`Skipping invalid/public tenant ID: ${tenantId}`);
-            }
+    this.logger.log(
+      "Ensuring tenant schemas exist (if strategy requires them)..."
+    );
+    let requiresTenantSchemas = Object.values(tablesConfig).some(
+      (t) => t.type === "tenant"
+    );
+    if (requiresTenantSchemas) {
+      this.logger.log("Tenant-specific schemas are required by config.");
+      for (const tenant of tenants) {
+        const tenantId = tenant[tenantInfo.tenantIdColumn];
+        const providerId = tenant[tenantInfo.providerIdColumn] ?? null;
+        if (
+          tenantId &&
+          typeof tenantId === "string" &&
+          tenantId !== commonSchema
+        ) {
+          await this.schemaUtils.createSchema(tenantId);
+          validTenants.set(tenantId, providerId);
+          this.logger.log(`Ensured schema exists for tenant: ${tenantId}`);
+        } else {
+          this.logger.warn(`Skipping invalid/public tenant ID: ${tenantId}`);
         }
+      }
     } else {
-         this.logger.log('No tables configured with type "tenant". Tenant schema creation skipped.');
-         // Still populate validTenants map for filteredPublic logic
-         for (const tenant of tenants) {
-            const tenantId = tenant[tenantInfo.tenantIdColumn];
-            const providerId = tenant[tenantInfo.providerIdColumn] ?? null;
-            // Use tenantId as key even if schemas aren't created, it represents the logical tenant
-             if (tenantId && typeof tenantId === 'string') { 
-                validTenants.set(tenantId, providerId);
-             }
-         }
+      this.logger.log(
+        'No tables configured with type "tenant". Tenant schema creation skipped.'
+      );
+      // Still populate validTenants map for filteredPublic logic
+      for (const tenant of tenants) {
+        const tenantId = tenant[tenantInfo.tenantIdColumn];
+        const providerId = tenant[tenantInfo.providerIdColumn] ?? null;
+        // Use tenantId as key even if schemas aren't created, it represents the logical tenant
+        if (tenantId && typeof tenantId === "string") {
+          validTenants.set(tenantId, providerId);
+        }
+      }
     }
-    this.logger.log(`Prepared ${validTenants.size} valid tenants for migration.`);
+    this.logger.log(
+      `Prepared ${validTenants.size} valid tenants for migration.`
+    );
 
-    // --- PASADAS POR INQUILINO (para tablas filteredPublic y tenant) --- 
-    const tablesToMigratePerTenant = allTablesInOrder.filter(t =>
-        tablesConfig[t]?.type === 'filteredPublic' || tablesConfig[t]?.type === 'tenant'
+    // --- PASADAS POR INQUILINO (para tablas filteredPublic y tenant) ---
+    const tablesToMigratePerTenant = allTablesInOrder.filter(
+      (t) =>
+        tablesConfig[t]?.type === "filteredPublic" ||
+        tablesConfig[t]?.type === "tenant"
+    );
+    this.logger.log(
+      `Migrating filtered/tenant tables: ${tablesToMigratePerTenant.join(", ")}`
     );
-    this.logger.log(`Migrating filtered/tenant tables: ${tablesToMigratePerTenant.join(", ")}`);
 
     for (const [tenantId, providerId] of validTenants.entries()) {
-        // Note: tenantId here might just be logical identifier if not creating schemas
-        this.logger.log(`Starting migration pass related to tenant: ${tenantId} (Filtering by Provider ID: ${providerId ?? 'N/A'})`);
-        await this.connections.targetPool.query(`SET session_replication_role = 'replica';`);
-
-        for (const tableName of tablesToMigratePerTenant) {
-            const config = tablesConfig[tableName];
-            if (!config) {
-                this.logger.warn(`Skipping migration for table ${tableName} for tenant ${tenantId}: Not found in config.`);
-                continue;
-            }
-
-            // Determine schema destino basado en config.type
-            const targetSchemaForTable = config.type === 'tenant' ? tenantId : commonSchema;
-
-            try {
-                const entity: EntityType = {
-                    name: tableName,
-                    idField: config.idField,
-                    filterColumn: config.filterColumn,
-                    filterVia: config.via
-                };
-
-                await this.batchMigrator.migrateEntityDataInBatches(
-                    this.connections.targetPrisma,
-                    entity,
-                    providerId, // providerId para FILTRAR origen
-                    targetSchemaForTable // esquema donde INSERTAR
-                );
-            } catch (error) {
-                this.logger.error(`Error migrating table ${tableName} into schema ${targetSchemaForTable} (related to tenant ${tenantId}): ${error.message}`);
-            }
+      // Note: tenantId here might just be logical identifier if not creating schemas
+      this.logger.log(
+        `Starting migration pass related to tenant: ${tenantId} (Filtering by Provider ID: ${
+          providerId ?? "N/A"
+        })`
+      );
+      await this.connections.targetPool.query(
+        `SET session_replication_role = 'replica';`
+      );
+
+      for (const tableName of tablesToMigratePerTenant) {
+        const config = tablesConfig[tableName];
+        if (!config) {
+          this.logger.warn(
+            `Skipping migration for table ${tableName} for tenant ${tenantId}: Not found in config.`
+          );
+          continue;
         }
-        await this.connections.targetPool.query(`SET session_replication_role = 'origin';`);
-        this.logger.log(`Finished migration pass related to tenant: ${tenantId}`);
+
+        // Determine schema destino basado en config.type
+        const targetSchemaForTable =
+          config.type === "tenant" ? tenantId : commonSchema;
+
+        try {
+          const entity: EntityType = {
+            name: tableName,
+            idField: config.idField,
+            filterColumn: config.filterColumn,
+            filterVia: config.via,
+          };
+
+          const tableConfig: TableConfig = {
+            type: entity.filterVia ? "filteredPublic" : "tenant",
+            idField: entity.idField,
+            filterColumn: entity.filterColumn,
+            via: entity.filterVia,
+            sourceTable: entity.name,
+            targetTable: entity.name,
+          };
+
+          await this.batchMigrator.migrateEntityDataInBatches(
+            this.migrationConfig.commonSchema,
+            targetSchemaForTable,
+            tableConfig,
+            providerId?.toString() // Convertir providerId a string
+          );
+        } catch (error) {
+          this.logger.error(
+            `Error migrating table ${tableName} into schema ${targetSchemaForTable} (related to tenant ${tenantId}): ${error.message}`
+          );
+        }
+      }
+      await this.connections.targetPool.query(
+        `SET session_replication_role = 'origin';`
+      );
+      this.logger.log(`Finished migration pass related to tenant: ${tenantId}`);
     }
 
     this.logger.log("Data migration process completed.");
     // await this.verifyMigration(Array.from(validTenants.keys()));
   }
 
-   private async verifyMigration(tenantIds: string[]) {
-       this.logger.log("Verifying migrated data...");
-        // Verificar commonSchema
+  private async verifyMigration(tenantIds: string[]) {
+    this.logger.log("Verifying migrated data...");
+    // Verificar commonSchema
+    try {
+      const publicResult = await this.connections.targetPool.query(
+        `SELECT tablename, n_live_tup FROM pg_stat_user_tables WHERE schemaname = $1`,
+        [this.migrationConfig.commonSchema]
+      );
+      this.logger.log(
+        `Verification for schema '${this.migrationConfig.commonSchema}':`
+      );
+      publicResult.rows.forEach((row) =>
+        this.logger.log(`  Table: ${row.tablename}, Rows: ${row.n_live_tup}`)
+      );
+    } catch (err) {
+      this.logger.error(`Error verifying public schema: ${err.message}`);
+    }
+
+    // Verificar schemas de inquilinos (only if they were supposed to be created)
+    let requiresTenantSchemas = Object.values(this.migrationConfig.tables).some(
+      (t) => t.type === "tenant"
+    );
+    if (requiresTenantSchemas) {
+      for (const tenantId of tenantIds) {
         try {
-            const publicResult = await this.connections.targetPool.query(
+          const tenantResult = await this.connections.targetPool.query(
             `SELECT tablename, n_live_tup FROM pg_stat_user_tables WHERE schemaname = $1`,
-            [this.migrationConfig.commonSchema]
+            [tenantId]
+          );
+          this.logger.log(`Verification for tenant schema '${tenantId}':`);
+          if (tenantResult.rows.length === 0) {
+            this.logger.warn(
+              `  Schema ${tenantId} has no tables (or pg_stat_user_tables is empty).`
+            );
+          } else {
+            tenantResult.rows.forEach((row) =>
+              this.logger.log(
+                `  Table: ${row.tablename}, Rows: ${row.n_live_tup}`
+              )
             );
-            this.logger.log(`Verification for schema '${this.migrationConfig.commonSchema}':`);
-            publicResult.rows.forEach(row => this.logger.log(`  Table: ${row.tablename}, Rows: ${row.n_live_tup}`));
+          }
         } catch (err) {
-            this.logger.error(`Error verifying public schema: ${err.message}`);
-        }
-
-        // Verificar schemas de inquilinos (only if they were supposed to be created)
-        let requiresTenantSchemas = Object.values(this.migrationConfig.tables).some(t => t.type === 'tenant');
-        if (requiresTenantSchemas) {
-            for (const tenantId of tenantIds) {
-                try {
-                    const tenantResult = await this.connections.targetPool.query(
-                    `SELECT tablename, n_live_tup FROM pg_stat_user_tables WHERE schemaname = $1`,
-                    [tenantId]
-                    );
-                    this.logger.log(`Verification for tenant schema '${tenantId}':`);
-                    if (tenantResult.rows.length === 0) {
-                        this.logger.warn(`  Schema ${tenantId} has no tables (or pg_stat_user_tables is empty).`);
-                    } else {
-                        tenantResult.rows.forEach(row => this.logger.log(`  Table: ${row.tablename}, Rows: ${row.n_live_tup}`));
-                    }
-                } catch (err) {
-                    this.logger.error(`Error verifying tenant schema ${tenantId}: ${err.message}`);
-                }
-            }
+          this.logger.error(
+            `Error verifying tenant schema ${tenantId}: ${err.message}`
+          );
         }
-        this.logger.log("Verification finished.");
+      }
     }
+    this.logger.log("Verification finished.");
+  }
 }