@javalabs/prisma-client 1.0.0

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

@@ -0,0 +1,194 @@
+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(
+          tenantPrisma,
+          entity,
+          providerId,
+          tenantId
+        );
+      }
+
+      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();
+    }
+  }
+}

package/src/scripts/data-migration/typecast-manager.ts

@@ -0,0 +1,38 @@
+import { ColumnSchema } from "./types";
+
+export class TypecastManager {
+  getTypecastForColumn(column: ColumnSchema): string {
+    switch (column.data_type.toLowerCase()) {
+      case "numeric":
+      case "decimal":
+        return "::numeric";
+      case "integer":
+        return "::integer";
+      case "bigint":
+        return "::bigint";
+      case "boolean":
+        return "::boolean";
+      case "timestamp":
+        return "::timestamp";
+      case "timestamptz":
+        return "::timestamptz";
+      case "user-defined":
+        // Manejar tipos enum
+        if (column.udt_name?.startsWith("enum_")) {
+          return `::${column.udt_name}`;
+        }
+        return "";
+      default:
+        return "";
+    }
+  }
+
+  // Método para generar la expresión de CAST para un tipo enum específico
+  getEnumCastExpression(
+    schemaName: string,
+    enumType: string,
+    paramIndex: number
+  ): string {
+    return `CAST($${paramIndex} AS "${schemaName}".${enumType})`;
+  }
+}

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

@@ -0,0 +1,40 @@
+import { Pool } from "pg";
+import { PrismaClient } from "@prisma/client";
+
+export interface DatabaseConnections {
+  sourcePool: Pool;
+  targetPool: Pool;
+  sourcePrisma: PrismaClient;
+  targetPrisma: PrismaClient;
+}
+
+export interface ColumnSchema {
+  table_name: string;
+  column_name: string;
+  data_type: string;
+  udt_name: string;
+  character_maximum_length?: number;
+  is_nullable: string;
+  column_default?: string;
+  constraint_type?: string;
+}
+
+// Updated EntityType to include filter configuration
+export interface EntityType {
+  name: string;          // Table name
+  idField: string;        // Primary key column name
+  filterColumn?: string; // Column used for filtering (either directly or via join)
+  filterVia?: string;    // Intermediate table for filtering join (if needed)
+  // Keep optional legacy fields for potential backward compatibility or specific use cases
+  foreignKey?: string;
+  joinTable?: string;
+  joinField?: string;
+  joinForeignKey?: string;
+  directQuery?: string;
+}
+
+export interface EnumCastValue {
+  needsEnumCast: boolean;
+  value: any;
+  enumType: string;
+}

package/src/scripts/drop-database.ts

@@ -0,0 +1,105 @@
+import * as pg from "pg";
+import * as dotenv from "dotenv";
+import { Logger } from "@nestjs/common";
+
+dotenv.config();
+
+export class DatabaseDropTool {
+  private readonly logger = new Logger("DatabaseDropTool");
+  private readonly adminPool: pg.Pool;
+
+  constructor(private readonly databaseUrl: string) {
+    // Conexión a la base de datos postgres (admin)
+    // Modificamos la URL para conectarnos a la base de datos postgres en lugar de la base de datos específica
+    const adminUrl = this.databaseUrl.replace(/\/[^/]+$/, "/postgres");
+    
+    this.adminPool = new pg.Pool({
+      connectionString: adminUrl,
+    });
+  }
+
+  async dropDatabase() {
+    try {
+      this.logger.log("Starting database drop process");
+
+      // Extraer el nombre de la base de datos de la URL
+      const dbName = this.extractDatabaseName(this.databaseUrl);
+      
+      if (!dbName) {
+        throw new Error("Could not extract database name from connection URL");
+      }
+
+      this.logger.log(`Attempting to drop database: ${dbName}`);
+
+      // 1. Terminar todas las conexiones activas a la base de datos
+      await this.terminateConnections(dbName);
+
+      // 2. Eliminar la base de datos
+      await this.adminPool.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+
+      this.logger.log(`Database ${dbName} has been successfully dropped`);
+    } catch (error) {
+      this.logger.error(
+        `Error dropping database: ${error.message}`,
+        error.stack
+      );
+      throw error;
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  private extractDatabaseName(url: string): string | null {
+    // Extraer el nombre de la base de datos de la URL de conexión
+    const matches = url.match(/\/([^/?]+)($|\?)/);
+    return matches ? matches[1] : null;
+  }
+
+  private async terminateConnections(dbName: string) {
+    this.logger.log(`Terminating all connections to database: ${dbName}`);
+    
+    try {
+      // PostgreSQL 9.2+
+      await this.adminPool.query(`
+        SELECT pg_terminate_backend(pg_stat_activity.pid)
+        FROM pg_stat_activity
+        WHERE pg_stat_activity.datname = $1
+        AND pid <> pg_backend_pid()
+      `, [dbName]);
+      
+      this.logger.log("All connections terminated successfully");
+    } catch (error) {
+      this.logger.error(`Error terminating connections: ${error.message}`);
+      // Continuamos con el proceso incluso si hay un error aquí
+    }
+  }
+
+  private async cleanup() {
+    this.logger.log("Cleaning up database connections");
+    await this.adminPool.end();
+  }
+}
+
+// Script para ejecutar desde línea de comandos
+if (require.main === module) {
+  const run = async () => {
+    try {
+      // Obtener la URL de la base de datos desde los argumentos o .env
+      const databaseUrl = process.argv[2] || process.env.DATABASE_URL;
+      
+      if (!databaseUrl) {
+        console.error("Error: No database URL provided. Please provide a database URL as an argument or set DATABASE_URL environment variable.");
+        process.exit(1);
+      }
+      
+      const dropTool = new DatabaseDropTool(databaseUrl);
+      await dropTool.dropDatabase();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error.message);
+      process.exit(1);
+    }
+  };
+
+  run();
+}

package/src/scripts/dump-source-db.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+# --- Verificar e instalar pg_dump si es necesario ---
+# Use explicit path to PostgreSQL 16 binaries
+PG16_PATH="/usr/local/opt/postgresql@16/bin"
+if ! command -v "${PG16_PATH}/pg_dump" &> /dev/null; then
+    echo "PostgreSQL 16 no está instalado. Intentando instalar con Homebrew..."
+    if ! command -v brew &> /dev/null; then
+        echo "Error: Homebrew no está instalado."
+        exit 1
+    fi
+    brew install postgresql@16
+fi
+
+# --- Configuración ---
+# Read from environment variables
+# Load environment variables if .env exists
+if [ -f "../../.env" ]; then
+    set -o allexport
+    source "../../.env"
+    set +o allexport
+fi
+
+if [ -z "$SOURCE_DATABASE_URL" ]; then
+    echo "Error: SOURCE_DATABASE_URL environment variable not set"
+    exit 1
+fi
+
+OUTPUT_FILE="dumps/source_dump_$(date +%Y%m%d_%H%M%S).sql"
+
+# --- Version Check ---
+SERVER_VERSION=$(psql "$SOURCE_DATABASE_URL" -t -c "SHOW server_version_num;" | tr -d '[:space:]')
+LOCAL_VERSION=$(pg_dump --version | grep -oE '[0-9]+' | head -1)
+
+if [ "$SERVER_VERSION" -gt "$((LOCAL_VERSION * 10000))" ]; then
+    echo "Warning: Server version ($SERVER_VERSION) is newer than local pg_dump ($LOCAL_VERSION)"
+    echo "Forcing dump with basic compatibility mode..."
+    COMPAT_FLAGS="--no-sync --no-comments"
+else
+    COMPAT_FLAGS=""
+fi
+
+# --- Comando pg_dump ---
+echo "Creando dump de la base de datos desde ($SOURCE_DATABASE_URL)..."
+
+"${PG16_PATH}/pg_dump" $COMPAT_FLAGS \
+  --dbname="$SOURCE_DATABASE_URL" \
+  --schema=public \
+  --data-only \
+  --inserts \
+  --file="$OUTPUT_FILE"
+
+# --- Resultado ---
+if [ $? -eq 0 ]; then
+  echo "Dump creado exitosamente en: $OUTPUT_FILE"
+else
+  echo "Error al crear el dump."
+  exit 1
+fi
+
+exit 0
+