@javalabs/prisma-client 1.0.18 → 1.0.20

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

@@ -1,509 +1,509 @@
-import { Logger } from "@nestjs/common";
-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";
-import { BatchMigrator } from "./batch-migrator";
-import { ForeignKeyManager } from "./foreign-key-manager";
-import { DependencyResolver } from "./dependency-resolver";
-
-interface MigrationOptions {
-  publicOnly?: boolean;
-  multiTenant?: boolean;
-  sourceSchema?: string;
-  targetSchema?: string;
-  forceSingleTenant?: boolean; // Alias for publicOnly
-  configPath?: string;
-}
-
-interface TableConfig {
-  type: "public" | "filteredPublic" | "tenantInfo" | "tenant";
-  idField: string;
-  filterColumn?: string;
-  via?: string;
-  providerLink?: string;
-  tenantKey?: string;
-  dependencies?: string[];
-  sourceTable: string;
-  targetTable: string;
-}
-
-interface MigrationConfig {
-  commonSchema: string;
-  tenantInfo: {
-    sourceTable: string;
-    tenantIdColumn: string;
-    providerIdColumn: string;
-  };
-  tables: Record<string, TableConfig>;
-}
-
-export class DataMigrationTool {
-  private readonly logger = new Logger("DataMigrationTool");
-  private readonly schemaUtils: SchemaUtils;
-  private readonly dataTransformer: DataTransformer;
-  private readonly batchMigrator: BatchMigrator;
-  private readonly foreignKeyManager: ForeignKeyManager;
-  private readonly dependencyResolver: DependencyResolver;
-
-  constructor(
-    private readonly connections: DatabaseConnections,
-    private migrationConfig: MigrationConfig,
-    private readonly options: MigrationOptions = {}
-  ) {
-    this.schemaUtils = new SchemaUtils(connections);
-
-    this.dataTransformer = new DataTransformer(
-      this.schemaUtils,
-      connections.sourcePool,
-      connections
-    );
-
-    this.foreignKeyManager = new ForeignKeyManager(connections);
-
-    this.batchMigrator = new BatchMigrator(
-      this.schemaUtils,
-      this.dataTransformer,
-      connections,
-      this.options
-    );
-
-    this.dependencyResolver = new DependencyResolver(
-      connections.sourcePool,
-      connections.targetPool
-    );
-  }
-
-  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");
-      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}`
-      );
-    }
-    if (
-      !this.migrationConfig.commonSchema ||
-      !this.migrationConfig.tables ||
-      !this.migrationConfig.tenantInfo
-    ) {
-      throw new Error("Invalid migration config structure.");
-    }
-  }
-
-  async migrate(): Promise<void> {
-    try {
-      this.logger.log("Starting data migration process");
-      this.loadConfig(this.options.configPath);
-
-      // Check the publicOnly/forceSingleTenant flag AFTER loading config
-      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...");
-        await this.migrateMultiTenantWithConfig();
-      }
-    } catch (error) {
-      this.logger.error(`Migration failed: ${error.message}`);
-      console.error(error);
-      throw error;
-    }
-  }
-
-  // --- Function for Public-Only Migration ---
-  private async migratePublicTablesOnly() {
-    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"
-    );
-
-    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';`
-    );
-
-    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.");
-  }
-
-  // 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}`
-      );
-
-      // 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;
-    }
-  }
-
-  // Renamed from migrateToTenantSchemas to reflect its purpose
-  private async migrateMultiTenantWithConfig() {
-    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`
-          );
-        }
-      }
-    }
-
-    // --- 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';`
-    );
-
-    const publicTables = allTablesInOrder.filter(
-      (t) => tablesConfig[t]?.type === "public"
-    );
-
-    for (const tableName of publicTables) {
-      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';`
-    );
-    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,
-      },
-    });
-    this.logger.log(`Found ${tenants.length} potential tenants.`);
-
-    // --- 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}`);
-        }
-      }
-    } 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(
-      `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"
-    );
-    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,
-          };
-
-          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
-    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 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.log("Verification finished.");
-  }
-}
+import { Logger } from "@nestjs/common";
+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";
+import { BatchMigrator } from "./batch-migrator";
+import { ForeignKeyManager } from "./foreign-key-manager";
+import { DependencyResolver } from "./dependency-resolver";
+
+interface MigrationOptions {
+  publicOnly?: boolean;
+  multiTenant?: boolean;
+  sourceSchema?: string;
+  targetSchema?: string;
+  forceSingleTenant?: boolean; // Alias for publicOnly
+  configPath?: string;
+}
+
+interface TableConfig {
+  type: "public" | "filteredPublic" | "tenantInfo" | "tenant";
+  idField: string;
+  filterColumn?: string;
+  via?: string;
+  providerLink?: string;
+  tenantKey?: string;
+  dependencies?: string[];
+  sourceTable: string;
+  targetTable: string;
+}
+
+interface MigrationConfig {
+  commonSchema: string;
+  tenantInfo: {
+    sourceTable: string;
+    tenantIdColumn: string;
+    providerIdColumn: string;
+  };
+  tables: Record<string, TableConfig>;
+}
+
+export class DataMigrationTool {
+  private readonly logger = new Logger("DataMigrationTool");
+  private readonly schemaUtils: SchemaUtils;
+  private readonly dataTransformer: DataTransformer;
+  private readonly batchMigrator: BatchMigrator;
+  private readonly foreignKeyManager: ForeignKeyManager;
+  private readonly dependencyResolver: DependencyResolver;
+
+  constructor(
+    private readonly connections: DatabaseConnections,
+    private migrationConfig: MigrationConfig,
+    private readonly options: MigrationOptions = {}
+  ) {
+    this.schemaUtils = new SchemaUtils(connections);
+
+    this.dataTransformer = new DataTransformer(
+      this.schemaUtils,
+      connections.sourcePool,
+      connections
+    );
+
+    this.foreignKeyManager = new ForeignKeyManager(connections);
+
+    this.batchMigrator = new BatchMigrator(
+      this.schemaUtils,
+      this.dataTransformer,
+      connections,
+      this.options
+    );
+
+    this.dependencyResolver = new DependencyResolver(
+      connections.sourcePool,
+      connections.targetPool
+    );
+  }
+
+  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");
+      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}`
+      );
+    }
+    if (
+      !this.migrationConfig.commonSchema ||
+      !this.migrationConfig.tables ||
+      !this.migrationConfig.tenantInfo
+    ) {
+      throw new Error("Invalid migration config structure.");
+    }
+  }
+
+  async migrate(): Promise<void> {
+    try {
+      this.logger.log("Starting data migration process");
+      this.loadConfig(this.options.configPath);
+
+      // Check the publicOnly/forceSingleTenant flag AFTER loading config
+      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...");
+        await this.migrateMultiTenantWithConfig();
+      }
+    } catch (error) {
+      this.logger.error(`Migration failed: ${error.message}`);
+      console.error(error);
+      throw error;
+    }
+  }
+
+  // --- Function for Public-Only Migration ---
+  private async migratePublicTablesOnly() {
+    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"
+    );
+
+    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';`
+    );
+
+    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.");
+  }
+
+  // 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}`
+      );
+
+      // 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;
+    }
+  }
+
+  // Renamed from migrateToTenantSchemas to reflect its purpose
+  private async migrateMultiTenantWithConfig() {
+    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`
+          );
+        }
+      }
+    }
+
+    // --- 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';`
+    );
+
+    const publicTables = allTablesInOrder.filter(
+      (t) => tablesConfig[t]?.type === "public"
+    );
+
+    for (const tableName of publicTables) {
+      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';`
+    );
+    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,
+      },
+    });
+    this.logger.log(`Found ${tenants.length} potential tenants.`);
+
+    // --- 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}`);
+        }
+      }
+    } 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(
+      `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"
+    );
+    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,
+          };
+
+          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
+    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 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.log("Verification finished.");
+  }
+}