@javalabs/prisma-client 1.0.18 → 1.0.20

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

@@ -1,277 +1,277 @@
-import { Logger } from "@nestjs/common";
-import { PrismaClient } from "@prisma/client";
-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) {}
-
-  async getForeignKeyDependencies(
-    schemaName: string,
-    tableName: string
-  ): 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,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND tc.table_name = $2;
-      `;
-
-      const { rows } = await this.connections.targetPool.query(query, [
-        schemaName,
-        tableName,
-      ]);
-
-      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 obteniendo dependencias de ${schemaName}.${tableName}: ${error.message}`
-      );
-      return [];
-    }
-  }
-
-  async checkForeignKeyDependencies(
-    prisma: PrismaClient,
-    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) {
-      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`
-          );
-          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;
-    }
-  }
-
-  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;
-    }
-  }
-}
+import { Logger } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+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) {}
+
+  async getForeignKeyDependencies(
+    schemaName: string,
+    tableName: string
+  ): 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,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND tc.table_name = $2;
+      `;
+
+      const { rows } = await this.connections.targetPool.query(query, [
+        schemaName,
+        tableName,
+      ]);
+
+      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 obteniendo dependencias de ${schemaName}.${tableName}: ${error.message}`
+      );
+      return [];
+    }
+  }
+
+  async checkForeignKeyDependencies(
+    prisma: PrismaClient,
+    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) {
+      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`
+          );
+          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;
+    }
+  }
+
+  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

@@ -1,63 +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"]
-    }
-  }
-}
+{
+  "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"]
+    }
+  }
+}