@javalabs/prisma-client 1.0.4 → 1.0.6

package/src/scripts/data-migration/foreign-key-manager.ts

@@ -4,6 +4,7 @@ import { DatabaseConnections } from "./types";
 
 export class ForeignKeyManager {
   private readonly logger = new Logger("ForeignKeyManager");
+  private readonly dependencyCache: Map<string, any[]> = new Map();
 
   constructor(private readonly connections: DatabaseConnections) {}
 
@@ -13,7 +14,15 @@ export class ForeignKeyManager {
   ): Promise<
     Array<{ column: string; foreignTable: string; foreignColumn: string }>
   > {
+    const cacheKey = `${schemaName}.${tableName}`;
+    if (this.dependencyCache.has(cacheKey)) {
+      return this.dependencyCache.get(cacheKey);
+    }
+
     try {
+      this.logger.log(
+        `Obteniendo dependencias de llaves foráneas para ${schemaName}.${tableName}`
+      );
       const query = `
         SELECT
           kcu.column_name,
@@ -37,14 +46,29 @@ export class ForeignKeyManager {
         schemaName,
         tableName,
       ]);
-      return rows.map((row) => ({
+
+      const dependencies = rows.map((row) => ({
         column: row.column_name,
         foreignTable: row.foreign_table_name,
         foreignColumn: row.foreign_column_name,
       }));
+
+      this.logger.log(
+        `Encontradas ${
+          dependencies.length
+        } dependencias para ${schemaName}.${tableName}:
+        ${dependencies
+          .map(
+            (d) => `\n  - ${d.column} -> ${d.foreignTable}.${d.foreignColumn}`
+          )
+          .join("")}`
+      );
+
+      this.dependencyCache.set(cacheKey, dependencies);
+      return dependencies;
     } catch (error) {
       this.logger.error(
-        `Error getting foreign key dependencies for ${tableName}: ${error.message}`
+        `Error obteniendo dependencias de ${schemaName}.${tableName}: ${error.message}`
       );
       return [];
     }
@@ -52,44 +76,202 @@ export class ForeignKeyManager {
 
   async checkForeignKeyDependencies(
     prisma: PrismaClient,
-    schemaName: string,
-    row: any,
-    dependencies: Array<{
-      column: string;
-      foreignTable: string;
-      foreignColumn: string;
-    }>
+    tenantId: string,
+    record: any,
+    dependencies: any[]
   ): Promise<string[]> {
     const missingDependencies: string[] = [];
+    const recordId = record.id || "unknown";
+
+    this.logger.debug(
+      `Verificando dependencias para registro ${recordId} en tenant ${tenantId}`
+    );
 
     for (const dep of dependencies) {
-      if (row[dep.column] !== null) {
-        const query = `
-          SELECT 1 FROM "${schemaName}"."${dep.foreignTable}" 
-          WHERE "${dep.foreignColumn}" = $1 
-          LIMIT 1
-        `;
-
-        try {
-          const result = await prisma.$queryRawUnsafe(query, row[dep.column]);
-          if (!result || (Array.isArray(result) && result.length === 0)) {
-            missingDependencies.push(
-              `${dep.foreignTable}.${dep.foreignColumn}=${row[dep.column]}`
-            );
-          }
-        } catch (error) {
-          this.logger.error(
-            `Error checking dependency ${dep.foreignTable}.${dep.foreignColumn}: ${error.message}`
+      const { table, column, references } = dep;
+      const foreignKeyValue = record[column];
+
+      if (foreignKeyValue === null) {
+        this.logger.debug(
+          `Dependencia ${table}.${references} es nula para registro ${recordId}, continuando`
+        );
+        continue;
+      }
+
+      // Verificar en origen
+      const sourceExists = await this.checkSourceDependency(
+        table,
+        references,
+        foreignKeyValue
+      );
+
+      if (!sourceExists) {
+        this.logger.debug(
+          `Registro ${recordId}: Dependencia ${table}.${references}=${foreignKeyValue} no existe en origen, ignorando`
+        );
+        continue;
+      }
+
+      // Verificar en destino
+      const exists = await this.checkDependencyExists(
+        prisma,
+        tenantId,
+        table,
+        references,
+        foreignKeyValue
+      );
+
+      if (!exists) {
+        const depString = `${table}.${references}=${foreignKeyValue}`;
+        this.logger.debug(
+          `Registro ${recordId}: Dependencia ${depString} existe en origen pero falta en destino`
+        );
+        missingDependencies.push(depString);
+      } else {
+        this.logger.debug(
+          `Registro ${recordId}: Dependencia ${table}.${references}=${foreignKeyValue} verificada OK`
+        );
+      }
+    }
+
+    if (missingDependencies.length > 0) {
+      this.logger.debug(
+        `Registro ${recordId}: Faltan ${
+          missingDependencies.length
+        } dependencias:
+        ${missingDependencies.map((dep) => `\n  - ${dep}`).join("")}`
+      );
+    } else {
+      this.logger.debug(`Registro ${recordId}: Todas las dependencias OK`);
+    }
+
+    return missingDependencies;
+  }
+
+  private async checkSourceDependency(
+    table: string,
+    column: string,
+    value: any
+  ): Promise<boolean> {
+    try {
+      const result = await this.connections.sourcePool.query(
+        `SELECT 1 FROM "${table}" WHERE "${column}" = $1 LIMIT 1`,
+        [value]
+      );
+      const exists = result.rows.length > 0;
+      this.logger.debug(
+        `Verificación en origen ${table}.${column}=${value}: ${
+          exists ? "EXISTE" : "NO EXISTE"
+        }`
+      );
+      return exists;
+    } catch (error) {
+      this.logger.error(
+        `Error verificando en origen ${table}.${column}=${value}: ${error.message}`
+      );
+      return false;
+    }
+  }
+
+  private async checkDependencyExists(
+    prisma: PrismaClient,
+    tenantId: string,
+    table: string,
+    column: string,
+    value: any
+  ): Promise<boolean> {
+    try {
+      const result = await prisma.$queryRawUnsafe(
+        `SELECT 1 FROM "${tenantId}"."${table}" WHERE "${column}" = $1 LIMIT 1`,
+        value
+      );
+      const exists = Array.isArray(result) && result.length > 0;
+      this.logger.debug(
+        `Verificación en destino ${tenantId}.${table}.${column}=${value}: ${
+          exists ? "EXISTE" : "NO EXISTE"
+        }`
+      );
+      return exists;
+    } catch (error) {
+      this.logger.error(
+        `Error verificando en destino ${tenantId}.${table}.${column}=${value}: ${error.message}`
+      );
+      return false;
+    }
+  }
+
+  async verifyDependencies(
+    tableName: string,
+    record: any,
+    tenantId: string
+  ): Promise<boolean> {
+    try {
+      const dependencies = await this.getForeignKeyDependencies(
+        tableName,
+        tableName
+      );
+
+      for (const dep of dependencies) {
+        const { foreignTable, foreignColumn } = dep;
+
+        // Verificar si la tabla existe antes de hacer la consulta
+        const tableExists = await this.checkTableExists(foreignTable);
+        if (!tableExists) {
+          this.logger.warn(
+            `Table ${foreignTable} does not exist, skipping dependency check`
           );
-          missingDependencies.push(
-            `${dep.foreignTable}.${dep.foreignColumn}=${
-              row[dep.column]
-            } (error)`
+          continue;
+        }
+
+        // Verificar el valor de la dependencia
+        const foreignKeyValue = record[foreignColumn];
+        if (foreignKeyValue) {
+          const exists = await this.checkDependencyExists(
+            this.connections.targetPrisma,
+            tenantId,
+            foreignTable,
+            foreignColumn,
+            foreignKeyValue
           );
+
+          if (!exists) {
+            this.logger.warn(
+              `Valor ${foreignKeyValue} no existe en ${foreignTable}.${foreignColumn}`
+            );
+            return false;
+          }
         }
       }
+
+      return true;
+    } catch (error) {
+      this.logger.error(`Error verifying dependencies: ${error.message}`);
+      return false;
     }
+  }
 
-    return missingDependencies;
+  private async checkTableExists(tableName: string): Promise<boolean> {
+    try {
+      const result = await this.connections.sourcePool.query(
+        `SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        )`,
+        [tableName]
+      );
+      const exists = result.rows[0].exists;
+      this.logger.debug(
+        `Verificación de existencia de tabla ${tableName}: ${
+          exists ? "EXISTE" : "NO EXISTE"
+        }`
+      );
+      return exists;
+    } catch (error) {
+      this.logger.error(
+        `Error verificando existencia de tabla ${tableName}: ${error.message}`
+      );
+      return false;
+    }
   }
-}
+}

package/src/scripts/data-migration/migration-config.json

@@ -0,0 +1,63 @@
+{
+  "commonSchema": "public",
+  "tenantInfo": {
+    "sourceTable": "users",
+    "tenantIdColumn": "user_id",
+    "providerIdColumn": "provider_id"
+  },
+  "migrationPriorities": {
+    "high": ["countries", "providers", "users", "api_keys"],
+    "medium": ["transactions", "charges", "balances"],
+    "low": ["invoices", "api_request_logs"]
+  },
+  "tables": {
+    "countries": {
+      "type": "public",
+      "idField": "id"
+    },
+    "providers": {
+      "type": "public",
+      "idField": "provider_id",
+      "dependencies": ["countries"]
+    },
+    "users": {
+      "type": "public",
+      "idField": "user_id",
+      "dependencies": ["providers"]
+    },
+    "api_keys": {
+      "type": "public",
+      "idField": "id",
+      "dependencies": ["users"]
+    },
+    "transactions": {
+      "type": "filteredPublic",
+      "idField": "id",
+      "filterColumn": "provider_id",
+      "dependencies": ["users", "providers"]
+    },
+    "charges": {
+      "type": "filteredPublic",
+      "idField": "id",
+      "filterColumn": "provider_id",
+      "dependencies": ["transactions"]
+    },
+    "invoices": {
+      "type": "filteredPublic",
+      "idField": "id",
+      "filterColumn": "provider_id",
+      "dependencies": ["transactions", "charges"]
+    },
+    "balances": {
+      "type": "filteredPublic",
+      "idField": "id",
+      "filterColumn": "provider_id",
+      "dependencies": ["users"]
+    },
+    "api_request_logs": {
+      "type": "filteredPublic",
+      "idField": "id",
+      "dependencies": ["api_keys"]
+    }
+  }
+}