@javalabs/prisma-client 1.0.18 → 1.0.20

package/src/scripts/data-migration/tenant-migrator.ts

@@ -1,201 +1,201 @@
-import { Logger } from "@nestjs/common";
-import { PrismaClient } from "@prisma/client";
-import { SchemaUtils } from "./schema-utils";
-import { EntityDiscovery } from "./entity-discovery";
-import { BatchMigrator } from "./batch-migrator";
-import { DatabaseConnections } from "./types";
-import { DependencyResolver } from "./dependency-resolver";
-
-export class TenantMigrator {
-  private readonly logger = new Logger("TenantMigrator");
-  private readonly dependencyResolver: DependencyResolver;
-
-  constructor(
-    private readonly schemaUtils: SchemaUtils,
-    private readonly entityDiscovery: EntityDiscovery,
-    private readonly batchMigrator: BatchMigrator,
-    private readonly connections: DatabaseConnections
-  ) {
-    this.dependencyResolver = new DependencyResolver(
-      connections.sourcePool,
-      connections.targetPool
-    );
-  }
-
-  // Método para verificar dependencias de fase
-  async verifyPhaseDependencies(
-    tenantId: string,
-    tables: string[]
-  ): Promise<boolean> {
-    try {
-      for (const table of tables) {
-        const count = await this.connections.targetPrisma.$queryRawUnsafe(
-          `SELECT COUNT(*) FROM "${tenantId}"."${table}"`
-        );
-
-        if (!count || count[0].count === "0") {
-          this.logger.warn(
-            `No data found in required table ${table} for tenant ${tenantId}`
-          );
-          return false;
-        }
-      }
-      return true;
-    } catch (error) {
-      this.logger.error(`Error verifying phase dependencies: ${error.message}`);
-      return false;
-    }
-  }
-
-  async migrateDataForTenant(
-    tenantId: string,
-    providerId: number,
-    includeTables?: string[] | null,
-    excludeTables?: string[] | null
-  ) {
-    this.logger.log(
-      `Migrating data for tenant: ${tenantId} (Provider ID: ${
-        providerId || "N/A"
-      })`
-    );
-
-    // Verificar que el tenant existe y pertenece al provider (o no tiene provider)
-    try {
-      let tenantExists = false;
-
-      try {
-        // Modificar la consulta para incluir casos donde provider_id es nulo
-        const result = await this.connections.sourcePrisma.api_keys.findFirst({
-          where: {
-            api_key: tenantId,
-            OR: [{ provider_id: providerId }, { provider_id: null }],
-          },
-        });
-
-        tenantExists = !!result;
-      } catch (error) {
-        this.logger.warn(
-          `Error checking tenant existence, will assume using public schema: ${error.message}`
-        );
-        tenantExists = true; // Asumir que estamos usando el esquema público
-      }
-
-      if (!tenantExists) {
-        this.logger.warn(
-          `Tenant ${tenantId} does not exist or does not belong to provider ${
-            providerId || "N/A"
-          }. Using public schema as source.`
-        );
-        // Continuamos de todos modos, asumiendo que usaremos el esquema público
-      }
-
-      // Log para depuración
-      this.logger.log(`Proceeding with migration for tenant ${tenantId}`);
-    } catch (error) {
-      this.logger.error(
-        `Error verifying tenant ${tenantId} for provider ${
-          providerId || "N/A"
-        }: ${error.message}`
-      );
-      // Log más detallado del error
-      this.logger.error(`Error details: ${JSON.stringify(error)}`);
-      // Continuamos de todos modos
-    }
-
-    // Create a client for this specific tenant schema with increased timeout
-    const tenantPrisma = new PrismaClient({
-      datasources: {
-        db: {
-          url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
-        },
-      },
-      // Increase transaction timeout to 5 minutes (was 2 minutes)
-      transactionOptions: {
-        maxWait: 300000, // 5 minutes max wait time
-        timeout: 300000, // 5 minutes timeout
-      },
-      log: ["query", "error", "warn"], // Añadir logging para depuración
-    });
-
-    try {
-      // Validate that the schema exists in the target database
-      const schemaExists = await this.schemaUtils.checkSchemaExists(tenantId);
-      if (!schemaExists) {
-        this.logger.error(
-          `Schema ${tenantId} does not exist in target database. Skipping migration.`
-        );
-        return;
-      }
-
-      // Get all tables from the target schema
-      const targetTables = await this.schemaUtils.getTargetTables(tenantId);
-
-      // Discover entity types and their relationships automatically
-      let entityTypes = await this.entityDiscovery.discoverEntityTypes(
-        tenantId,
-        targetTables
-      );
-
-      // Filtrar entidades según los parámetros includeTables y excludeTables
-      if (includeTables) {
-        entityTypes = entityTypes.filter((entity) =>
-          includeTables.includes(entity.name)
-        );
-        this.logger.log(
-          `Filtered to include only: ${includeTables.join(", ")}`
-        );
-      }
-
-      if (excludeTables) {
-        entityTypes = entityTypes.filter(
-          (entity) => !excludeTables.includes(entity.name)
-        );
-        this.logger.log(`Filtered to exclude: ${excludeTables.join(", ")}`);
-      }
-
-      // Ordenar entidades basadas en dependencias
-      // Replace dependencyManager with dependencyResolver for ordering
-      const sortedTables = await this.dependencyResolver.analyzeDependencies();
-      const orderedEntities = entityTypes
-        .sort((a, b) => {
-          const aIndex = sortedTables.indexOf(a.name);
-          const bIndex = sortedTables.indexOf(b.name);
-          return aIndex - bIndex;
-        })
-        .filter((entity) => sortedTables.includes(entity.name));
-
-      this.logger.log(
-        `Migration order: ${orderedEntities.map((e) => e.name).join(" -> ")}`
-      );
-
-      this.logger.log(
-        `Discovered ${entityTypes.length} entity types for migration`
-      );
-
-      // Migrate each entity type separately to avoid transaction timeouts
-      for (const entity of orderedEntities) {
-        await this.batchMigrator.migrateEntityDataInBatches(
-          "public", // esquema fuente
-          tenantId, // esquema destino
-          {
-            type: "tenant",
-            idField: entity.idField,
-            sourceTable: entity.name,
-            targetTable: entity.name,
-            filterColumn: entity.filterColumn,
-            via: entity.filterVia,
-          },
-          providerId?.toString()
-        );
-      }
-
-      this.logger.log(`Completed migration for tenant ${tenantId}`);
-    } catch (error) {
-      this.logger.error(
-        `Error migrating data for tenant ${tenantId}: ${error.message}`
-      );
-    } finally {
-      await tenantPrisma.$disconnect();
-    }
-  }
-}
+import { Logger } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+import { SchemaUtils } from "./schema-utils";
+import { EntityDiscovery } from "./entity-discovery";
+import { BatchMigrator } from "./batch-migrator";
+import { DatabaseConnections } from "./types";
+import { DependencyResolver } from "./dependency-resolver";
+
+export class TenantMigrator {
+  private readonly logger = new Logger("TenantMigrator");
+  private readonly dependencyResolver: DependencyResolver;
+
+  constructor(
+    private readonly schemaUtils: SchemaUtils,
+    private readonly entityDiscovery: EntityDiscovery,
+    private readonly batchMigrator: BatchMigrator,
+    private readonly connections: DatabaseConnections
+  ) {
+    this.dependencyResolver = new DependencyResolver(
+      connections.sourcePool,
+      connections.targetPool
+    );
+  }
+
+  // Método para verificar dependencias de fase
+  async verifyPhaseDependencies(
+    tenantId: string,
+    tables: string[]
+  ): Promise<boolean> {
+    try {
+      for (const table of tables) {
+        const count = await this.connections.targetPrisma.$queryRawUnsafe(
+          `SELECT COUNT(*) FROM "${tenantId}"."${table}"`
+        );
+
+        if (!count || count[0].count === "0") {
+          this.logger.warn(
+            `No data found in required table ${table} for tenant ${tenantId}`
+          );
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      this.logger.error(`Error verifying phase dependencies: ${error.message}`);
+      return false;
+    }
+  }
+
+  async migrateDataForTenant(
+    tenantId: string,
+    providerId: number,
+    includeTables?: string[] | null,
+    excludeTables?: string[] | null
+  ) {
+    this.logger.log(
+      `Migrating data for tenant: ${tenantId} (Provider ID: ${
+        providerId || "N/A"
+      })`
+    );
+
+    // Verificar que el tenant existe y pertenece al provider (o no tiene provider)
+    try {
+      let tenantExists = false;
+
+      try {
+        // Modificar la consulta para incluir casos donde provider_id es nulo
+        const result = await this.connections.sourcePrisma.api_keys.findFirst({
+          where: {
+            api_key: tenantId,
+            OR: [{ provider_id: providerId }, { provider_id: null }],
+          },
+        });
+
+        tenantExists = !!result;
+      } catch (error) {
+        this.logger.warn(
+          `Error checking tenant existence, will assume using public schema: ${error.message}`
+        );
+        tenantExists = true; // Asumir que estamos usando el esquema público
+      }
+
+      if (!tenantExists) {
+        this.logger.warn(
+          `Tenant ${tenantId} does not exist or does not belong to provider ${
+            providerId || "N/A"
+          }. Using public schema as source.`
+        );
+        // Continuamos de todos modos, asumiendo que usaremos el esquema público
+      }
+
+      // Log para depuración
+      this.logger.log(`Proceeding with migration for tenant ${tenantId}`);
+    } catch (error) {
+      this.logger.error(
+        `Error verifying tenant ${tenantId} for provider ${
+          providerId || "N/A"
+        }: ${error.message}`
+      );
+      // Log más detallado del error
+      this.logger.error(`Error details: ${JSON.stringify(error)}`);
+      // Continuamos de todos modos
+    }
+
+    // Create a client for this specific tenant schema with increased timeout
+    const tenantPrisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
+        },
+      },
+      // Increase transaction timeout to 5 minutes (was 2 minutes)
+      transactionOptions: {
+        maxWait: 300000, // 5 minutes max wait time
+        timeout: 300000, // 5 minutes timeout
+      },
+      log: ["query", "error", "warn"], // Añadir logging para depuración
+    });
+
+    try {
+      // Validate that the schema exists in the target database
+      const schemaExists = await this.schemaUtils.checkSchemaExists(tenantId);
+      if (!schemaExists) {
+        this.logger.error(
+          `Schema ${tenantId} does not exist in target database. Skipping migration.`
+        );
+        return;
+      }
+
+      // Get all tables from the target schema
+      const targetTables = await this.schemaUtils.getTargetTables(tenantId);
+
+      // Discover entity types and their relationships automatically
+      let entityTypes = await this.entityDiscovery.discoverEntityTypes(
+        tenantId,
+        targetTables
+      );
+
+      // Filtrar entidades según los parámetros includeTables y excludeTables
+      if (includeTables) {
+        entityTypes = entityTypes.filter((entity) =>
+          includeTables.includes(entity.name)
+        );
+        this.logger.log(
+          `Filtered to include only: ${includeTables.join(", ")}`
+        );
+      }
+
+      if (excludeTables) {
+        entityTypes = entityTypes.filter(
+          (entity) => !excludeTables.includes(entity.name)
+        );
+        this.logger.log(`Filtered to exclude: ${excludeTables.join(", ")}`);
+      }
+
+      // Ordenar entidades basadas en dependencias
+      // Replace dependencyManager with dependencyResolver for ordering
+      const sortedTables = await this.dependencyResolver.analyzeDependencies();
+      const orderedEntities = entityTypes
+        .sort((a, b) => {
+          const aIndex = sortedTables.indexOf(a.name);
+          const bIndex = sortedTables.indexOf(b.name);
+          return aIndex - bIndex;
+        })
+        .filter((entity) => sortedTables.includes(entity.name));
+
+      this.logger.log(
+        `Migration order: ${orderedEntities.map((e) => e.name).join(" -> ")}`
+      );
+
+      this.logger.log(
+        `Discovered ${entityTypes.length} entity types for migration`
+      );
+
+      // Migrate each entity type separately to avoid transaction timeouts
+      for (const entity of orderedEntities) {
+        await this.batchMigrator.migrateEntityDataInBatches(
+          "public", // esquema fuente
+          tenantId, // esquema destino
+          {
+            type: "tenant",
+            idField: entity.idField,
+            sourceTable: entity.name,
+            targetTable: entity.name,
+            filterColumn: entity.filterColumn,
+            via: entity.filterVia,
+          },
+          providerId?.toString()
+        );
+      }
+
+      this.logger.log(`Completed migration for tenant ${tenantId}`);
+    } catch (error) {
+      this.logger.error(
+        `Error migrating data for tenant ${tenantId}: ${error.message}`
+      );
+    } finally {
+      await tenantPrisma.$disconnect();
+    }
+  }
+}