@javalabs/prisma-client 1.0.3 → 1.0.6

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

@@ -1,89 +1,136 @@
 import { Logger } from "@nestjs/common";
 import { ColumnSchema, EnumCastValue } from "./types";
 import { SchemaUtils } from "./schema-utils";
+import {
+  DatabaseConnections,
+  MigrationConfig,
+  MigrationOptions,
+} from "./types";
+import { ForeignKeyManager } from "./foreign-key-manager";
+import { TypecastManager } from "./typecast-manager";
 
 export class DataTransformer {
   private readonly logger = new Logger("DataTransformer");
-  private enumValuesCache: Map<string, any> = new Map();
-  private columnValuesCache: Map<string, Map<string, any>> = new Map();
-
-  constructor(public readonly schemaUtils: SchemaUtils) {}
+  private readonly schemaUtils: SchemaUtils;
+  private readonly sourceConnection: any;
+  private connections: DatabaseConnections;
+  private migrationConfig: MigrationConfig;
+  private options: MigrationOptions;
+  private foreignKeyManager: ForeignKeyManager;
+  private readonly typecastManager: TypecastManager;
+
+  constructor(
+    schemaUtils: SchemaUtils,
+    sourceConnection: any,
+    connections: DatabaseConnections
+  ) {
+    this.schemaUtils = schemaUtils;
+    this.sourceConnection = sourceConnection;
+    this.connections = connections;
+    this.typecastManager = new TypecastManager();
+  }
 
   async validateEnumValue(
-    schemaName: string,
-    enumType: string,
-    value: string
+    tableName: string,
+    columnName: string,
+    value: string | null,
+    isNullable: boolean = true
   ): Promise<string | null> {
     try {
-      const cacheKey = `${schemaName}.${enumType}`;
-      if (!this.enumValuesCache.has(cacheKey)) {
-        const query = `
-          SELECT e.enumlabel
-          FROM pg_type t
-          JOIN pg_enum e ON t.oid = e.enumtypid
-          JOIN pg_namespace n ON n.oid = t.typnamespace
-          WHERE t.typname = $1 AND n.nspname = $2
-        `;
-
-        const result = await this.schemaUtils.queryTargetDb(query, [
-          enumType,
-          schemaName,
-        ]);
-        const uniqueValues: Set<string> = new Set(
-          result.rows.map((row): string => String(row.enumlabel))
-        );
+      if (value === null) {
+        return isNullable
+          ? null
+          : await this.getDefaultEnumValue(tableName, columnName);
+      }
 
-        // También almacenar un mapa de valores normalizados a valores originales
-        const normalizedMap = new Map<string, string>();
-        result.rows.forEach((row) => {
-          const original = String(row.enumlabel);
-          const normalized = original.toLowerCase().trim();
-          normalizedMap.set(normalized, original);
-        });
+      const enumTypeName = await this.getEnumTypeName(tableName, columnName);
+      const normalizedValue = value.toString().trim().toLowerCase();
 
-        this.enumValuesCache.set(cacheKey, uniqueValues);
-        this.enumValuesCache.set(`${cacheKey}_normalized`, normalizedMap);
+      // Obtener valores válidos del enum desde la base de datos
+      const query = `SELECT unnest(enum_range(NULL::${enumTypeName})) as enum_value`;
+      const validValues = await this.connections.sourcePool.query(query);
 
-        this.logger.log(
-          `Valid values for ${enumType}: ${[...uniqueValues].join(", ")}`
+      if (!validValues || !validValues.rows) {
+        this.logger.warn(
+          `No se pudieron obtener valores válidos para el enum ${enumTypeName}`
         );
+        return await this.getDefaultEnumValue(enumTypeName);
+      }
+
+      const enumValues = validValues.rows.map((row: any) =>
+        row.enum_value.toLowerCase()
+      );
+
+      // Verificar coincidencia exacta
+      if (enumValues.includes(normalizedValue)) {
+        return value.toString().trim();
       }
 
-      const validValues = this.enumValuesCache.get(cacheKey);
-      const normalizedMap = this.enumValuesCache.get(
-        `${cacheKey}_normalized`
-      ) as unknown as Map<string, string>;
+      // Verificar coincidencia parcial
+      const partialMatch = enumValues.find(
+        (enumValue) =>
+          enumValue.includes(normalizedValue) ||
+          normalizedValue.includes(enumValue)
+      );
 
-      if (!validValues || !normalizedMap) {
-        throw new Error(`No valid values found for enum ${enumType}`);
+      if (partialMatch) {
+        this.logger.debug(
+          `Valor enum corregido: ${value} -> ${partialMatch} para ${tableName}.${columnName}`
+        );
+        return partialMatch;
       }
 
-      // Verificar coincidencia exacta primero
-      if (validValues.has(value)) {
-        return value;
+      // Si no se encuentra coincidencia, usar valor por defecto
+      const defaultValue = await this.getDefaultEnumValue(enumTypeName);
+      if (defaultValue) {
+        this.logger.warn(
+          `Usando valor por defecto ${defaultValue} para ${tableName}.${columnName}`
+        );
+        return defaultValue;
       }
 
-      // Luego intentar con valor normalizado
-      const normalizedValue = value.toLowerCase().trim();
-      if (normalizedMap.has(normalizedValue)) {
-        // Devolver el valor original correcto, no el normalizado
-        return normalizedMap.get(normalizedValue);
+      if (!isNullable) {
+        throw new Error(
+          `No se pudo encontrar un valor válido para el enum ${enumTypeName}`
+        );
       }
 
-      this.logger.warn(
-        `Invalid enum value "${value}" for type ${enumType}. Valid values are: ${[
-          ...validValues,
-        ].join(", ")}`
-      );
       return null;
     } catch (error) {
       this.logger.error(
-        `Error validating enum value "${value}" for type ${enumType}: ${error.message}`
+        `Error validating enum value for ${tableName}.${columnName}: ${error.message}`
       );
+      if (!isNullable) {
+        return await this.getDefaultEnumValue(tableName, columnName);
+      }
       return null;
     }
   }
 
+  private async getEnumTypeName(
+    tableName: string,
+    columnName: string
+  ): Promise<string> {
+    const result = await this.connections.sourcePool.query(
+      `
+      SELECT udt_name 
+      FROM information_schema.columns 
+      WHERE table_name = $1 
+      AND column_name = $2
+      AND table_schema = 'public'
+    `,
+      [tableName.replace(/^public\./, ""), columnName]
+    );
+
+    if (result.rows.length === 0) {
+      throw new Error(
+        `No se encontró el tipo de enum para ${tableName}.${columnName}`
+      );
+    }
+
+    return result.rows[0].udt_name;
+  }
+
   transformToNumeric(value: any): number | null {
     if (value === null || value === "") {
       return null;
@@ -102,23 +149,34 @@ export class DataTransformer {
     tenantId: string = "public"
   ): Promise<string | null> {
     try {
-      // Obtener todos los valores posibles del enum desde la base de datos
+      // Mapeo específico para tipos de enum conocidos
+      const enumDefaults = {
+        enum_users_role: "user",
+        enum_account_type: "savings",
+        enum_transaction_type: "payin",
+        enum_transaction_status: "pending",
+      };
+
+      if (enumDefaults[enumType]) {
+        return enumDefaults[enumType];
+      }
+
+      // Si no hay un valor por defecto específico, obtener el primer valor del enum
       const query = `
-              SELECT e.enumlabel
-              FROM pg_type t
-              JOIN pg_enum e ON t.oid = e.enumtypid
-              JOIN pg_namespace n ON n.oid = t.typnamespace
-              WHERE t.typname = $1 AND n.nspname = $2
-              ORDER BY e.enumsortorder
-              LIMIT 1
-          `;
+        SELECT e.enumlabel
+        FROM pg_type t
+        JOIN pg_enum e ON t.oid = e.enumtypid
+        JOIN pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typname = $1 AND n.nspname = $2
+        ORDER BY e.enumsortorder
+        LIMIT 1
+      `;
 
       const result = await this.schemaUtils.queryTargetDb(query, [
         enumType,
         tenantId,
       ]);
 
-      // Retornar el primer valor del enum como valor por defecto
       if (result.rows.length > 0) {
         return result.rows[0].enumlabel;
       }
@@ -173,166 +231,159 @@ export class DataTransformer {
   async transformColumnValue(
     value: any,
     columnName: string,
-    targetColumn: ColumnSchema,
+    targetColumn: ColumnSchema & { source_type?: string },
     tenantId: string
   ): Promise<any> {
-    // Log input values for debugging
-    this.logger.debug(
-      `Transforming column ${columnName}, value: ${JSON.stringify(
-        value
-      )}, type: ${targetColumn.udt_name}`
-    );
-
-    if (value === null && targetColumn.is_nullable === "YES") {
-      return null;
+    if (value === null || value === undefined) {
+      return targetColumn.is_nullable === "YES"
+        ? null
+        : this.getDefaultValue(targetColumn);
     }
 
     try {
-      // Handle enum types
-      if (targetColumn.udt_name.startsWith("enum_")) {
-        // Handle JSONB/object to enum conversion
-        if (typeof value === "object" && value !== null) {
-          const stringValue = this.extractEnumValueFromObject(value);
-          if (stringValue) {
-            return await this.prepareEnumValue(
-              tenantId,
-              targetColumn.udt_name,
-              stringValue
-            );
-          }
-        }
-
-        // Handle direct string values
-        if (typeof value === "string") {
-          return await this.prepareEnumValue(
-            tenantId,
-            targetColumn.udt_name,
-            value
-          );
-        }
-
-        // If no valid value found, get default
-        const defaultValue = await this.getDefaultEnumValue(
-          targetColumn.udt_name,
-          tenantId
+      // Si tenemos el tipo de origen, usar el TypecastManager
+      if (targetColumn.source_type) {
+        return this.typecastManager.castValue(
+          value,
+          targetColumn.source_type,
+          targetColumn.data_type
         );
-        if (defaultValue) {
-          this.logger.warn(
-            `Using default enum value '${defaultValue}' for column ${columnName}`
-          );
-          return {
-            needsEnumCast: true,
-            value: defaultValue,
-            enumType: targetColumn.udt_name,
-          };
-        }
       }
 
-      // Handle numeric types
-      if (
-        targetColumn.udt_name === "numeric" ||
-        targetColumn.data_type === "decimal"
-      ) {
-        const numericValue = this.transformToNumeric(value);
-        if (numericValue !== null || targetColumn.is_nullable === "YES") {
-          return numericValue;
-        }
-        return 0; // Default value for non-nullable numeric fields
-      }
-
-      // Handle boolean types
-      if (
-        targetColumn.udt_name === "bool" ||
-        targetColumn.data_type === "boolean"
-      ) {
-        if (typeof value === "string") {
-          return value.toLowerCase() === "true" || value === "1";
-        }
-        return Boolean(value);
-      }
-
-      // Handle date/timestamp types
-      if (
-        targetColumn.data_type.includes("timestamp") ||
-        targetColumn.data_type.includes("date")
-      ) {
-        if (!value) return null;
-        const date = new Date(value);
-        return isNaN(date.getTime()) ? null : date.toISOString();
-      }
-
-      // Handle JSON/JSONB types
-      if (
-        targetColumn.data_type === "json" ||
-        targetColumn.data_type === "jsonb"
-      ) {
-        if (typeof value === "string") {
-          try {
-            return JSON.parse(value);
-          } catch {
-            return value;
+      // Si no tenemos el tipo de origen, intentar convertir basado en el tipo destino
+      switch (targetColumn.data_type.toLowerCase()) {
+        case "integer":
+        case "bigint":
+        case "smallint":
+          return typeof value === "string" ? parseInt(value, 10) : value;
+        case "numeric":
+        case "decimal":
+        case "real":
+        case "double precision":
+          return typeof value === "string" ? parseFloat(value) : value;
+        case "boolean":
+          if (typeof value === "string") {
+            return value.toLowerCase() === "true" || value === "1";
           }
-        }
-        return value;
+          return Boolean(value);
+        case "json":
+        case "jsonb":
+          if (typeof value === "string") {
+            try {
+              return JSON.parse(value);
+            } catch {
+              return value;
+            }
+          }
+          return value;
+        case "timestamp":
+        case "timestamptz":
+        case "timestamp with time zone":
+        case "timestamp without time zone":
+          if (value instanceof Date) {
+            return value.toISOString();
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            return new Date(value).toISOString();
+          }
+          return value;
+        case "date":
+          if (value instanceof Date) {
+            return value.toISOString().split("T")[0];
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            return new Date(value).toISOString().split("T")[0];
+          }
+          return value;
+        case "text":
+        case "character varying":
+        case "varchar":
+        case "char":
+          return String(value);
+        default:
+          return value;
       }
-
-      // Default case: return value as-is
-      return value;
     } catch (error) {
-      this.logger.error(
-        `Error transforming value for column ${columnName}: ${error.message}`
+      this.logger.warn(
+        `Error transformando valor para columna ${columnName}: ${error.message}`
       );
-
-      // Return appropriate default values based on column type
-      if (targetColumn.is_nullable === "YES") {
-        return null;
-      }
-
-      return this.getDefaultValueForType(targetColumn.udt_name);
-    }
-  }
-
-  private extractEnumValueFromObject(value: any): string | null {
-    const possibleKeys = ["type", "value", "document_type", "status", "state"];
-
-    for (const key of possibleKeys) {
-      if (value[key] && typeof value[key] === "string") {
-        return value[key];
-      }
-    }
-
-    // Try to find any string value in the object
-    for (const val of Object.values(value)) {
-      if (typeof val === "string") {
-        return val;
-      }
+      return targetColumn.is_nullable === "YES"
+        ? null
+        : this.getDefaultValue(targetColumn);
     }
-
-    return null;
   }
 
-  private getDefaultValueForType(udtName: string): any {
-    switch (udtName) {
-      case "int4":
-      case "int8":
-      case "numeric":
+  private getDefaultValue(column: ColumnSchema): any {
+    switch (column.data_type.toLowerCase()) {
+      case "integer":
+      case "bigint":
+      case "smallint":
         return 0;
-      case "bool":
+      case "numeric":
+      case "decimal":
+      case "real":
+      case "double precision":
+        return 0.0;
+      case "boolean":
         return false;
       case "text":
+      case "character varying":
       case "varchar":
+      case "char":
         return "";
-      case "jsonb":
       case "json":
-        return {};
+      case "jsonb":
+        return "{}";
+      case "timestamp":
+      case "timestamptz":
+      case "timestamp with time zone":
+      case "timestamp without time zone":
+        return new Date().toISOString();
+      case "date":
+        return new Date().toISOString().split("T")[0];
       default:
-        if (udtName.startsWith("enum_")) {
-          return null; // Enums should be handled by prepareEnumValue
-        }
         return null;
     }
   }
 
+  private extractEnumValueFromObject(value: any): string | null {
+    if (typeof value === "object" && value !== null) {
+      // Intentar extraer el valor de propiedades comunes que podrían contener el valor enum
+      const possibleProperties = ["value", "type", "name", "code"];
+      for (const prop of possibleProperties) {
+        if (value[prop] && typeof value[prop] === "string") {
+          return value[prop].trim();
+        }
+      }
+    }
+    return null;
+  }
+
+  private async handleEnumType(
+    value: any,
+    columnName: string,
+    targetColumn: ColumnSchema,
+    tenantId: string
+  ): Promise<string | null> {
+    // Si el valor es null y la columna permite null
+    if (value === null && targetColumn.is_nullable === "YES") {
+      return null;
+    }
+
+    // Obtener el tipo específico de enum
+    const enumType = targetColumn.udt_name;
+
+    // Validar el valor según el tipo específico de enum
+    const validatedValue = await this.validateEnumValue(
+      tenantId,
+      columnName,
+      value,
+      targetColumn.is_nullable === "YES"
+    );
+
+    return validatedValue;
+  }
+
   async transformRecord(
     record: any,
     sourceSchema: ColumnSchema[],
@@ -343,9 +394,7 @@ export class DataTransformer {
 
     for (const [key, value] of Object.entries(record)) {
       // Primero intentar encontrar una coincidencia exacta
-      let targetColumn = targetSchema.find(
-        (col) => col.column_name === key
-      );
+      let targetColumn = targetSchema.find((col) => col.column_name === key);
 
       // Si no se encuentra coincidencia exacta, intentar case-insensitive
       if (!targetColumn) {
@@ -361,7 +410,7 @@ export class DataTransformer {
 
       // Usar el nombre exacto de la columna del schema destino
       const columnName = targetColumn.column_name;
-      
+
       const transformedValue = await this.transformColumnValue(
         value,
         columnName,

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

@@ -1,20 +1,54 @@
 import { PrismaClient } from "@prisma/client";
 import * as pg from "pg";
 import * as dotenv from "dotenv";
-import { DatabaseConnections } from "./types";
+import { DatabaseConnections, DatabaseConnection } from "./types";
 
 dotenv.config();
 
+export interface SourceDatabase {
+  id: string;
+  url: string;
+  name: string;
+}
+
 export class DatabaseConnector {
-  static createConnections(): DatabaseConnections {
-    // Source database connection (the one we're migrating from)
+  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,
-    });
-
-    // Target database connection (our multi-tenant database)
-    const targetPool = new pg.Pool({
-      connectionString: process.env.DATABASE_URL,
+      max: 20,
+      idleTimeoutMillis: 30000,
     });
 
     // Source Prisma client
@@ -26,6 +60,13 @@ export class DatabaseConnector {
       },
     });
 
+    // 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: {
@@ -36,10 +77,11 @@ export class DatabaseConnector {
     });
 
     return {
-      sourcePrisma,
+      sourceConnections,
       targetPrisma,
-      sourcePool,
       targetPool,
+      sourcePool,
+      sourcePrisma,
     };
   }
 
@@ -59,9 +101,20 @@ export class DatabaseConnector {
   }
 
   static async cleanup(connections: DatabaseConnections): Promise<void> {
-    await connections.sourcePrisma.$disconnect();
+    // 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.sourcePool.end();
     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();
   }
-}
+}