@javalabs/prisma-client 1.0.30 → 1.0.31

package/src/scripts/data-migration/db-connector.ts

@@ -1,120 +1,120 @@
-import { PrismaClient } from "@prisma/client";
-import * as pg from "pg";
-import * as dotenv from "dotenv";
-import { DatabaseConnections, DatabaseConnection } from "./types";
-
-dotenv.config();
-
-export interface SourceDatabase {
-  id: string;
-  url: string;
-  name: string;
-}
-
-export class DatabaseConnector {
-  static createConnections(
-    sourceDatabases?: SourceDatabase[]
-  ): DatabaseConnections {
-    // Crear conexiones para cada base de datos de origen
-    const sourceConnections: DatabaseConnection[] = (sourceDatabases || []).map(
-      (source): DatabaseConnection => {
-        // Conexión de pool para la base de datos de origen
-        const pool = new pg.Pool({
-          connectionString: source.url,
-        });
-
-        // Cliente Prisma para la base de datos de origen
-        const prisma = new PrismaClient({
-          datasources: {
-            db: {
-              url: source.url,
-            },
-          },
-        });
-
-        const connection: DatabaseConnection = {
-          pool,
-          prisma,
-          sourceId: source.id,
-          async query(sql: string, params?: any[]) {
-            return pool.query(sql, params);
-          },
-        };
-
-        return connection;
-      }
-    );
-
-    const sourcePool = new pg.Pool({
-      connectionString: process.env.SOURCE_DATABASE_URL,
-      max: 20,
-      idleTimeoutMillis: 30000,
-    });
-
-    // Source Prisma client
-    const sourcePrisma = new PrismaClient({
-      datasources: {
-        db: {
-          url: process.env.SOURCE_DATABASE_URL,
-        },
-      },
-    });
-
-    // Target database connection (our multi-tenant database)
-    const targetPool = new pg.Pool({
-      connectionString: process.env.DATABASE_URL,
-      max: 20,
-      idleTimeoutMillis: 30000,
-    });
-
-    // Target Prisma client
-    const targetPrisma = new PrismaClient({
-      datasources: {
-        db: {
-          url: process.env.DATABASE_URL,
-        },
-      },
-    });
-
-    return {
-      sourceConnections,
-      targetPrisma,
-      targetPool,
-      sourcePool,
-      sourcePrisma,
-    };
-  }
-
-  static createTenantPrismaClient(tenantId: string): PrismaClient {
-    return new PrismaClient({
-      datasources: {
-        db: {
-          url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
-        },
-      },
-      // Increase transaction timeout to 2 minutes
-      transactionOptions: {
-        maxWait: 120000, // 2 minutes max wait time
-        timeout: 120000, // 2 minutes timeout
-      },
-    });
-  }
-
-  static async cleanup(connections: DatabaseConnections): Promise<void> {
-    // Desconectar todas las conexiones de origen
-    if (connections.sourceConnections) {
-      for (const sourceConn of connections.sourceConnections) {
-        if (sourceConn.pool) await sourceConn.pool.end();
-        if (sourceConn.prisma) await sourceConn.prisma.$disconnect();
-      }
-    }
-
-    // Desconectar conexiones de destino
-    await connections.targetPrisma.$disconnect();
-    await connections.targetPool.end();
-
-    // Desconectar conexiones principales de origen si existen
-    if (connections.sourcePrisma) await connections.sourcePrisma.$disconnect();
-    if (connections.sourcePool) await connections.sourcePool.end();
-  }
-}
+import { PrismaClient } from "@prisma/client";
+import * as pg from "pg";
+import * as dotenv from "dotenv";
+import { DatabaseConnections, DatabaseConnection } from "./types";
+
+dotenv.config();
+
+export interface SourceDatabase {
+  id: string;
+  url: string;
+  name: string;
+}
+
+export class DatabaseConnector {
+  static createConnections(
+    sourceDatabases?: SourceDatabase[]
+  ): DatabaseConnections {
+    // Crear conexiones para cada base de datos de origen
+    const sourceConnections: DatabaseConnection[] = (sourceDatabases || []).map(
+      (source): DatabaseConnection => {
+        // Conexión de pool para la base de datos de origen
+        const pool = new pg.Pool({
+          connectionString: source.url,
+        });
+
+        // Cliente Prisma para la base de datos de origen
+        const prisma = new PrismaClient({
+          datasources: {
+            db: {
+              url: source.url,
+            },
+          },
+        });
+
+        const connection: DatabaseConnection = {
+          pool,
+          prisma,
+          sourceId: source.id,
+          async query(sql: string, params?: any[]) {
+            return pool.query(sql, params);
+          },
+        };
+
+        return connection;
+      }
+    );
+
+    const sourcePool = new pg.Pool({
+      connectionString: process.env.SOURCE_DATABASE_URL,
+      max: 20,
+      idleTimeoutMillis: 30000,
+    });
+
+    // Source Prisma client
+    const sourcePrisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: process.env.SOURCE_DATABASE_URL,
+        },
+      },
+    });
+
+    // Target database connection (our multi-tenant database)
+    const targetPool = new pg.Pool({
+      connectionString: process.env.DATABASE_URL,
+      max: 20,
+      idleTimeoutMillis: 30000,
+    });
+
+    // Target Prisma client
+    const targetPrisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: process.env.DATABASE_URL,
+        },
+      },
+    });
+
+    return {
+      sourceConnections,
+      targetPrisma,
+      targetPool,
+      sourcePool,
+      sourcePrisma,
+    };
+  }
+
+  static createTenantPrismaClient(tenantId: string): PrismaClient {
+    return new PrismaClient({
+      datasources: {
+        db: {
+          url: `${process.env.DATABASE_URL}?schema=${tenantId}`,
+        },
+      },
+      // Increase transaction timeout to 2 minutes
+      transactionOptions: {
+        maxWait: 120000, // 2 minutes max wait time
+        timeout: 120000, // 2 minutes timeout
+      },
+    });
+  }
+
+  static async cleanup(connections: DatabaseConnections): Promise<void> {
+    // Desconectar todas las conexiones de origen
+    if (connections.sourceConnections) {
+      for (const sourceConn of connections.sourceConnections) {
+        if (sourceConn.pool) await sourceConn.pool.end();
+        if (sourceConn.prisma) await sourceConn.prisma.$disconnect();
+      }
+    }
+
+    // Desconectar conexiones de destino
+    await connections.targetPrisma.$disconnect();
+    await connections.targetPool.end();
+
+    // Desconectar conexiones principales de origen si existen
+    if (connections.sourcePrisma) await connections.sourcePrisma.$disconnect();
+    if (connections.sourcePool) await connections.sourcePool.end();
+  }
+}

package/src/scripts/data-migration/dependency-resolver.ts

@@ -1,174 +1,174 @@
-import { Logger } from "@nestjs/common";
-import { Pool } from "pg";
-
-export class DependencyResolver {
-  private readonly logger = new Logger("DependencyResolver");
-  private readonly visitedTables = new Set<string>();
-  private readonly temporaryMark = new Set<string>();
-  private readonly tableOrder: string[] = [];
-  private config: any;
-
-  constructor(
-    private readonly sourcePool: Pool,
-    private readonly targetPool: Pool
-  ) {}
-
-  setConfig(config: any) {
-    this.config = config;
-  }
-
-  async analyzeDependencies(): Promise<string[]> {
-    try {
-      this.logger.log("Iniciando análisis de dependencias...");
-
-      // Obtener todas las tablas del esquema
-      const tables = await this.getAllTables();
-
-      // Resetear estado
-      this.visitedTables.clear();
-      this.temporaryMark.clear();
-      this.tableOrder.length = 0;
-
-      // Ordenar tablas por prioridad primero
-      const priorityOrder = this.getPriorityOrder(tables);
-
-      // Realizar ordenamiento topológico para cada grupo de prioridad
-      for (const priorityGroup of priorityOrder) {
-        for (const table of priorityGroup) {
-          if (!this.visitedTables.has(table)) {
-            await this.visit(table);
-          }
-        }
-      }
-
-      this.logger.log(
-        `Orden de migración determinado: ${this.tableOrder.join(" -> ")}`
-      );
-      return this.tableOrder;
-    } catch (error) {
-      this.logger.error(`Error analizando dependencias: ${error.message}`);
-      throw error;
-    }
-  }
-
-  private getPriorityOrder(tables: string[]): string[][] {
-    const priorities = {
-      high: new Set(this.config?.migrationPriorities?.high || []),
-      medium: new Set(this.config?.migrationPriorities?.medium || []),
-      low: new Set(this.config?.migrationPriorities?.low || []),
-    };
-
-    // Agrupar tablas por prioridad
-    const highPriority = tables.filter((t) => priorities.high.has(t));
-    const mediumPriority = tables.filter((t) => priorities.medium.has(t));
-    const lowPriority = tables.filter((t) => priorities.low.has(t));
-    const noPriority = tables.filter(
-      (t) =>
-        !priorities.high.has(t) &&
-        !priorities.medium.has(t) &&
-        !priorities.low.has(t)
-    );
-
-    return [highPriority, mediumPriority, noPriority, lowPriority];
-  }
-
-  private async visit(table: string, path: string[] = []): Promise<void> {
-    // Detectar ciclos
-    if (this.temporaryMark.has(table)) {
-      const cycle = [...path, table].join(" -> ");
-      this.logger.warn(`Detectado ciclo de dependencias: ${cycle}`);
-      return;
-    }
-
-    if (this.visitedTables.has(table)) {
-      return;
-    }
-
-    this.temporaryMark.add(table);
-    path.push(table);
-
-    // Obtener dependencias tanto de la configuración como de la base de datos
-    const dependencies = await this.getTableDependencies(table);
-
-    for (const dep of dependencies) {
-      if (!this.visitedTables.has(dep)) {
-        await this.visit(dep, [...path]);
-      }
-    }
-
-    this.temporaryMark.delete(table);
-    this.visitedTables.add(table);
-    this.tableOrder.push(table);
-  }
-
-  private async getAllTables(): Promise<string[]> {
-    const query = `
-      SELECT table_name 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public' 
-      AND table_type = 'BASE TABLE'
-    `;
-
-    const result = await this.sourcePool.query(query);
-    return result.rows.map((row) => row.table_name);
-  }
-
-  private async getTableDependencies(table: string): Promise<string[]> {
-    const dependencies = new Set<string>();
-
-    // Obtener dependencias de la configuración
-    const configDeps = this.config?.tables?.[table]?.dependencies || [];
-    configDeps.forEach((dep) => dependencies.add(dep));
-
-    // Obtener dependencias de la base de datos
-    const query = `
-      SELECT
-        ccu.table_name AS foreign_table
-      FROM
-        information_schema.table_constraints tc
-        JOIN information_schema.constraint_column_usage ccu
-          ON ccu.constraint_name = tc.constraint_name
-      WHERE
-        tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = $1
-        AND tc.table_schema = 'public'
-    `;
-
-    try {
-      const result = await this.sourcePool.query(query, [table]);
-      result.rows.forEach((row) => dependencies.add(row.foreign_table));
-    } catch (error) {
-      this.logger.warn(
-        `Error obteniendo dependencias para ${table}: ${error.message}`
-      );
-    }
-
-    return Array.from(dependencies);
-  }
-
-  async validateDependencies(
-    table: string,
-    dependencies: string[]
-  ): Promise<boolean> {
-    for (const dep of dependencies) {
-      const query = `
-        SELECT EXISTS (
-          SELECT 1 
-          FROM information_schema.tables 
-          WHERE table_schema = 'public' 
-          AND table_name = $1
-        )
-      `;
-
-      const result = await this.sourcePool.query(query, [dep]);
-      if (!result.rows[0].exists) {
-        this.logger.warn(
-          `Dependencia ${dep} no encontrada para tabla ${table}`
-        );
-        return false;
-      }
-    }
-
-    return true;
-  }
-}
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+
+export class DependencyResolver {
+  private readonly logger = new Logger("DependencyResolver");
+  private readonly visitedTables = new Set<string>();
+  private readonly temporaryMark = new Set<string>();
+  private readonly tableOrder: string[] = [];
+  private config: any;
+
+  constructor(
+    private readonly sourcePool: Pool,
+    private readonly targetPool: Pool
+  ) {}
+
+  setConfig(config: any) {
+    this.config = config;
+  }
+
+  async analyzeDependencies(): Promise<string[]> {
+    try {
+      this.logger.log("Iniciando análisis de dependencias...");
+
+      // Obtener todas las tablas del esquema
+      const tables = await this.getAllTables();
+
+      // Resetear estado
+      this.visitedTables.clear();
+      this.temporaryMark.clear();
+      this.tableOrder.length = 0;
+
+      // Ordenar tablas por prioridad primero
+      const priorityOrder = this.getPriorityOrder(tables);
+
+      // Realizar ordenamiento topológico para cada grupo de prioridad
+      for (const priorityGroup of priorityOrder) {
+        for (const table of priorityGroup) {
+          if (!this.visitedTables.has(table)) {
+            await this.visit(table);
+          }
+        }
+      }
+
+      this.logger.log(
+        `Orden de migración determinado: ${this.tableOrder.join(" -> ")}`
+      );
+      return this.tableOrder;
+    } catch (error) {
+      this.logger.error(`Error analizando dependencias: ${error.message}`);
+      throw error;
+    }
+  }
+
+  private getPriorityOrder(tables: string[]): string[][] {
+    const priorities = {
+      high: new Set(this.config?.migrationPriorities?.high || []),
+      medium: new Set(this.config?.migrationPriorities?.medium || []),
+      low: new Set(this.config?.migrationPriorities?.low || []),
+    };
+
+    // Agrupar tablas por prioridad
+    const highPriority = tables.filter((t) => priorities.high.has(t));
+    const mediumPriority = tables.filter((t) => priorities.medium.has(t));
+    const lowPriority = tables.filter((t) => priorities.low.has(t));
+    const noPriority = tables.filter(
+      (t) =>
+        !priorities.high.has(t) &&
+        !priorities.medium.has(t) &&
+        !priorities.low.has(t)
+    );
+
+    return [highPriority, mediumPriority, noPriority, lowPriority];
+  }
+
+  private async visit(table: string, path: string[] = []): Promise<void> {
+    // Detectar ciclos
+    if (this.temporaryMark.has(table)) {
+      const cycle = [...path, table].join(" -> ");
+      this.logger.warn(`Detectado ciclo de dependencias: ${cycle}`);
+      return;
+    }
+
+    if (this.visitedTables.has(table)) {
+      return;
+    }
+
+    this.temporaryMark.add(table);
+    path.push(table);
+
+    // Obtener dependencias tanto de la configuración como de la base de datos
+    const dependencies = await this.getTableDependencies(table);
+
+    for (const dep of dependencies) {
+      if (!this.visitedTables.has(dep)) {
+        await this.visit(dep, [...path]);
+      }
+    }
+
+    this.temporaryMark.delete(table);
+    this.visitedTables.add(table);
+    this.tableOrder.push(table);
+  }
+
+  private async getAllTables(): Promise<string[]> {
+    const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_type = 'BASE TABLE'
+    `;
+
+    const result = await this.sourcePool.query(query);
+    return result.rows.map((row) => row.table_name);
+  }
+
+  private async getTableDependencies(table: string): Promise<string[]> {
+    const dependencies = new Set<string>();
+
+    // Obtener dependencias de la configuración
+    const configDeps = this.config?.tables?.[table]?.dependencies || [];
+    configDeps.forEach((dep) => dependencies.add(dep));
+
+    // Obtener dependencias de la base de datos
+    const query = `
+      SELECT
+        ccu.table_name AS foreign_table
+      FROM
+        information_schema.table_constraints tc
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+    `;
+
+    try {
+      const result = await this.sourcePool.query(query, [table]);
+      result.rows.forEach((row) => dependencies.add(row.foreign_table));
+    } catch (error) {
+      this.logger.warn(
+        `Error obteniendo dependencias para ${table}: ${error.message}`
+      );
+    }
+
+    return Array.from(dependencies);
+  }
+
+  async validateDependencies(
+    table: string,
+    dependencies: string[]
+  ): Promise<boolean> {
+    for (const dep of dependencies) {
+      const query = `
+        SELECT EXISTS (
+          SELECT 1 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        )
+      `;
+
+      const result = await this.sourcePool.query(query, [dep]);
+      if (!result.rows[0].exists) {
+        this.logger.warn(
+          `Dependencia ${dep} no encontrada para tabla ${table}`
+        );
+        return false;
+      }
+    }
+
+    return true;
+  }
+}