@javalabs/prisma-client 1.0.4 → 1.0.8

package/src/scripts/data-migration/schema-utils.ts

@@ -4,7 +4,7 @@ import { ColumnSchema } from "./types";
 export class SchemaUtils {
   private readonly logger = new Logger("SchemaUtils");
 
-  constructor(private readonly sourcePool: any, private readonly targetPool: any) {}
+  constructor(private readonly connections: any) {}
 
   // En el método getTableSchema de SchemaUtils
   async getTableSchema(
@@ -12,8 +12,11 @@ export class SchemaUtils {
     dbType: "source" | "target",
     schema: string = "public"
   ): Promise<ColumnSchema[]> {
-    const pool = dbType === "source" ? this.sourcePool : this.targetPool;
-    
+    const pool =
+      dbType === "source"
+        ? this.connections.sourcePool
+        : this.connections.targetPool;
+
     const query = `
       SELECT 
         c.table_name,
@@ -37,13 +40,15 @@ export class SchemaUtils {
       ORDER BY 
         c.ordinal_position
     `;
-    
+
     try {
       const result = await pool.query(query, [schema, tableName]);
       // No transformar los nombres de las columnas, mantener el case original
       return result.rows;
     } catch (error) {
-      this.logger.error(`Error getting schema for ${schema}.${tableName}: ${error.message}`);
+      this.logger.error(
+        `Error getting schema for ${schema}.${tableName}: ${error.message}`
+      );
       return [];
     }
   }
@@ -55,7 +60,9 @@ export class SchemaUtils {
         FROM information_schema.schemata 
         WHERE schema_name = $1
       `;
-      const result = await this.targetPool.query(query, [schemaName]);
+      const result = await this.connections.targetPool.query(query, [
+        schemaName,
+      ]);
       return result.rows.length > 0;
     } catch (error) {
       this.logger.error(`Error checking if schema exists: ${error.message}`);
@@ -71,14 +78,18 @@ export class SchemaUtils {
         WHERE table_schema = $1
         AND table_type = 'BASE TABLE'
       `;
-      const result = await this.targetPool.query(query, [schemaName]);
-      
+      const result = await this.connections.targetPool.query(query, [
+        schemaName,
+      ]);
+
       // Log para depuración
-      this.logger.log(`Found ${result.rows.length} tables in schema ${schemaName}`);
-      result.rows.forEach(row => {
+      this.logger.log(
+        `Found ${result.rows.length} tables in schema ${schemaName}`
+      );
+      result.rows.forEach((row) => {
         this.logger.log(`Table in schema ${schemaName}: ${row.table_name}`);
       });
-      
+
       return result.rows.map((row) => row.table_name);
     } catch (error) {
       this.logger.error(`Error getting target tables: ${error.message}`);
@@ -86,10 +97,7 @@ export class SchemaUtils {
     }
   }
 
-  async getEnumValues(
-    schemaName: string,
-    enumName: string
-  ): Promise<string[]> {
+  async getEnumValues(schemaName: string, enumName: string): Promise<string[]> {
     try {
       // Consulta para obtener los valores posibles de un enum
       const query = `
@@ -100,7 +108,10 @@ export class SchemaUtils {
         WHERE t.typname = $1
         AND n.nspname = $2
       `;
-      const result = await this.targetPool.query(query, [enumName, schemaName]);
+      const result = await this.connections.targetPool.query(query, [
+        enumName,
+        schemaName,
+      ]);
       return result.rows.map((row) => row.enumlabel);
     } catch (error) {
       this.logger.error(
@@ -111,26 +122,30 @@ export class SchemaUtils {
   }
 
   async executeQuery(query: string, params: any[] = []): Promise<any> {
-    return this.targetPool.query(query, params);
+    return this.connections.targetPool.query(query, params);
   }
 
   async queryTargetDb(query: string, params: any[]): Promise<{ rows: any[] }> {
-    return this.targetPool.query(query, params);
+    return this.connections.targetPool.query(query, params);
   }
 
-  async createMissingColumns(tableName: string, schema: string, columns: ColumnSchema[]) {
+  async createMissingColumns(
+    tableName: string,
+    schema: string,
+    columns: ColumnSchema[]
+  ) {
     for (const column of columns) {
       try {
         const query = `
           ALTER TABLE "${schema}"."${tableName}"
           ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
-          ${column.is_nullable === 'NO' ? 'NOT NULL' : ''}
-          ${column.column_default ? `DEFAULT ${column.column_default}` : ''}
+          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
+          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
         `;
-        await this.targetPool.query(query);
+        await this.connections.targetPool.query(query);
 
         // Add unique constraint if needed
-        if (column.constraint_type === 'UNIQUE') {
+        if (column.constraint_type === "UNIQUE") {
           const constraintName = `${tableName}_${column.column_name}_unique`;
           const uniqueQuery = `
             DO $$
@@ -143,10 +158,12 @@ export class SchemaUtils {
               END IF;
             END $$;
           `;
-          await this.targetPool.query(uniqueQuery);
+          await this.connections.targetPool.query(uniqueQuery);
         }
       } catch (error) {
-        this.logger.error(`Error creating column ${column.column_name}: ${error.message}`);
+        this.logger.error(
+          `Error creating column ${column.column_name}: ${error.message}`
+        );
         throw error;
       }
     }
@@ -155,13 +172,15 @@ export class SchemaUtils {
   async createSchema(schemaName: string): Promise<void> {
     try {
       // Create schema
-      await this.targetPool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
+      await this.connections.targetPool.query(
+        `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`
+      );
 
       // Copy table structure from public schema
       const tables = await this.getPublicTables();
-      
+
       for (const table of tables) {
-        await this.targetPool.query(`
+        await this.connections.targetPool.query(`
           CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
             LIKE public."${table}" INCLUDING ALL
           );
@@ -170,17 +189,60 @@ export class SchemaUtils {
 
       this.logger.log(`Created schema ${schemaName} with all tables`);
     } catch (error) {
-      this.logger.error(`Error creating schema ${schemaName}: ${error.message}`);
+      this.logger.error(
+        `Error creating schema ${schemaName}: ${error.message}`
+      );
       throw error;
     }
   }
 
   private async getPublicTables(): Promise<string[]> {
-    const result = await this.targetPool.query(`
+    const result = await this.connections.targetPool.query(`
       SELECT tablename 
       FROM pg_tables 
       WHERE schemaname = 'public'
     `);
-    return result.rows.map(row => row.tablename);
+    return result.rows.map((row) => row.tablename);
+  }
+
+  async getTableColumns(
+    schema: string,
+    table: string
+  ): Promise<ColumnSchema[]> {
+    const query = `
+      SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale
+      FROM information_schema.columns
+      WHERE table_schema = $1
+        AND table_name = $2
+      ORDER BY ordinal_position;
+    `;
+
+    try {
+      const result = await this.connections.sourcePool.query(query, [
+        schema,
+        table,
+      ]);
+      return result.rows.map((row: any) => ({
+        column_name: row.column_name,
+        data_type: row.data_type,
+        is_nullable: row.is_nullable,
+        column_default: row.column_default,
+        character_maximum_length: row.character_maximum_length,
+        numeric_precision: row.numeric_precision,
+        numeric_scale: row.numeric_scale,
+      }));
+    } catch (error) {
+      this.logger.error(
+        `Error obteniendo columnas para ${schema}.${table}: ${error.message}`
+      );
+      throw error;
+    }
   }
-}
+}

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

@@ -162,7 +162,7 @@ export class TenantMigrator {
           const bIndex = sortedTables.indexOf(b.name);
           return aIndex - bIndex;
         })
-        .filter(entity => sortedTables.includes(entity.name));
+        .filter((entity) => sortedTables.includes(entity.name));
 
       this.logger.log(
         `Migration order: ${orderedEntities.map((e) => e.name).join(" -> ")}`
@@ -175,10 +175,17 @@ export class TenantMigrator {
       // Migrate each entity type separately to avoid transaction timeouts
       for (const entity of orderedEntities) {
         await this.batchMigrator.migrateEntityDataInBatches(
-          tenantPrisma,
-          entity,
-          providerId,
-          tenantId
+          "public", // esquema fuente
+          tenantId, // esquema destino
+          {
+            type: "tenant",
+            idField: entity.idField,
+            sourceTable: entity.name,
+            targetTable: entity.name,
+            filterColumn: entity.filterColumn,
+            via: entity.filterVia,
+          },
+          providerId?.toString()
         );
       }
 

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

@@ -1,38 +1,193 @@
-import { ColumnSchema } from "./types";
+import { PrismaClient } from "@prisma/client";
 
 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 "";
+  private readonly prisma = new PrismaClient();
+  private readonly cache = new Map<string, Map<string, string>>(); // cache tabla -> columna -> typecast
+
+  private readonly compatibilityMap: Record<string, string[]> = {
+    integer: ["bigint", "smallint", "numeric", "decimal"],
+    bigint: ["integer", "numeric", "decimal"],
+    smallint: ["integer", "bigint", "numeric", "decimal"],
+    numeric: [
+      "integer",
+      "bigint",
+      "smallint",
+      "decimal",
+      "real",
+      "double precision",
+    ],
+    decimal: [
+      "numeric",
+      "integer",
+      "bigint",
+      "smallint",
+      "real",
+      "double precision",
+    ],
+    real: ["numeric", "decimal", "double precision"],
+    "double precision": ["numeric", "decimal", "real"],
+    "character varying": ["text", "char", "varchar"],
+    varchar: ["text", "character varying", "char"],
+    char: ["text", "character varying", "varchar"],
+    text: ["character varying", "varchar", "char"],
+    timestamp: [
+      "timestamptz",
+      "timestamp without time zone",
+      "timestamp with time zone",
+    ],
+    timestamptz: [
+      "timestamp",
+      "timestamp without time zone",
+      "timestamp with time zone",
+    ],
+    date: ["timestamp", "timestamptz"],
+    boolean: ["bool"],
+    json: ["jsonb"],
+    jsonb: ["json"],
+  };
+
+  async getTypecastForColumn(
+    tableName: string,
+    columnName: string
+  ): Promise<string | undefined> {
+    if (!this.cache.has(tableName)) {
+      await this.loadTableSchema(tableName);
+    }
+    const tableSchema = this.cache.get(tableName);
+    return tableSchema?.get(columnName);
+  }
+
+  private async loadTableSchema(tableName: string) {
+    const columns = await this.prisma.$queryRawUnsafe<any[]>(`
+      SELECT column_name, data_type, udt_name, is_nullable
+      FROM information_schema.columns
+      WHERE table_name = '${tableName}'
+    `);
+
+    const tableSchema = new Map<string, string>();
+
+    for (const column of columns) {
+      const { column_name, data_type, udt_name, is_nullable } = column;
+
+      let typecast: string | undefined;
+
+      switch (data_type.toLowerCase()) {
+        case "timestamp with time zone":
+        case "timestamp without time zone":
+        case "timestamptz":
+          typecast = "::timestamp with time zone";
+          break;
+        case "timestamp":
+          typecast = "::timestamp";
+          break;
+        case "integer":
+          typecast = "::integer";
+          break;
+        case "bigint":
+          typecast = "::bigint";
+          break;
+        case "boolean":
+          typecast = "::boolean";
+          break;
+        case "numeric":
+        case "decimal":
+          typecast = "::numeric";
+          break;
+        case "double precision":
+          typecast = "::double precision";
+          break;
+        case "text":
+        case "character varying":
+        case "varchar":
+          typecast = "::text";
+          break;
+        case "date":
+          typecast = "::date";
+          break;
+        case "time":
+        case "time without time zone":
+          typecast = "::time";
+          break;
+        case "time with time zone":
+          typecast = "::timetz";
+          break;
+        case "json":
+          typecast = "::json";
+          break;
+        case "jsonb":
+          typecast = "::jsonb";
+          break;
+        case "uuid":
+          typecast = "::uuid";
+          break;
+        default:
+          if (udt_name.startsWith("_")) {
+            // Arrays
+            typecast = `::${udt_name.substring(1)}[]`;
+          } else if (udt_name.startsWith("enum_")) {
+            // Enums
+            typecast = `::${udt_name}`;
+          } else {
+            typecast = undefined;
+          }
+      }
+
+      tableSchema.set(column_name, typecast);
     }
+
+    this.cache.set(tableName, tableSchema);
   }
 
-  // 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})`;
+  areTypesCompatible(sourceType: string, targetType: string): boolean {
+    // Si los tipos son iguales, son compatibles
+    if (sourceType.toLowerCase() === targetType.toLowerCase()) {
+      return true;
+    }
+
+    // Verificar si el tipo fuente puede convertirse al tipo destino
+    const compatibleTypes =
+      this.compatibilityMap[sourceType.toLowerCase()] || [];
+    return compatibleTypes.includes(targetType.toLowerCase());
+  }
+
+  castValue(value: any, sourceType: string, targetType: string): any {
+    if (value === null || value === undefined) {
+      return null;
+    }
+
+    try {
+      switch (targetType.toLowerCase()) {
+        case "integer":
+        case "bigint":
+        case "smallint":
+          return parseInt(value, 10);
+        case "numeric":
+        case "decimal":
+        case "real":
+        case "double precision":
+          return parseFloat(value);
+        case "boolean":
+          return Boolean(value);
+        case "json":
+        case "jsonb":
+          return typeof value === "string" ? JSON.parse(value) : value;
+        case "timestamp":
+        case "timestamptz":
+          return new Date(value).toISOString();
+        case "date":
+          return new Date(value).toISOString().split("T")[0];
+        case "text":
+        case "character varying":
+        case "varchar":
+        case "char":
+          return String(value);
+        default:
+          return value;
+      }
+    } catch (error) {
+      throw new Error(
+        `Error al convertir valor "${value}" de ${sourceType} a ${targetType}: ${error.message}`
+      );
+    }
   }
 }

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

@@ -1,11 +1,19 @@
 import { Pool } from "pg";
 import { PrismaClient } from "@prisma/client";
 
+export interface DatabaseConnection {
+  pool?: Pool;
+  prisma?: PrismaClient;
+  query: (sql: string, params?: any[]) => Promise<any>;
+  sourceId: string; // Identificador único para la fuente (ej: "colombia", "rd", "guatemala")
+}
+
 export interface DatabaseConnections {
-  sourcePool: Pool;
+  sourceConnections?: DatabaseConnection[];
+  sourcePool?: Pool;
   targetPool: Pool;
-  sourcePrisma: PrismaClient;
   targetPrisma: PrismaClient;
+  sourcePrisma?: PrismaClient;
 }
 
 export interface ColumnSchema {
@@ -21,10 +29,10 @@ export interface ColumnSchema {
 
 // Updated EntityType to include filter configuration
 export interface EntityType {
-  name: string;          // Table name
-  idField: string;        // Primary key column name
+  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)
+  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;
@@ -38,3 +46,68 @@ export interface EnumCastValue {
   value: any;
   enumType: string;
 }
+
+export interface MigrationOptions {
+  publicOnly?: boolean;
+  multiTenant?: boolean;
+  sourceSchema?: string;
+  targetSchema?: string;
+  forceSingleTenant?: boolean;
+  configPath?: string;
+  batchSize?: number;
+  retryAttempts?: number;
+  validateData?: boolean;
+  logLevel?: "debug" | "info" | "warn" | "error";
+}
+
+export interface ColumnConfig {
+  sourceColumn?: string;
+  targetColumn?: string;
+  type?: string;
+  nullable?: boolean;
+  defaultValue?: any;
+  transform?: (value: any) => any;
+}
+
+export interface TableConfig {
+  type: "public" | "filteredPublic" | "tenantInfo" | "tenant";
+  idField: string;
+  filterColumn?: string;
+  via?: string;
+  providerLink?: string;
+  tenantKey?: string;
+  dependencies?: string[];
+  sourceTable?: string;
+  targetTable?: string;
+  columns?: Record<string, ColumnConfig>;
+  skipIfExists?: boolean;
+  batchSize?: number;
+}
+
+export interface ExtendedTableConfig extends TableConfig {
+  processed?: boolean;
+  retryCount?: number;
+  lastError?: Error;
+}
+
+export interface ExtendedMigrationConfig {
+  tables: Record<string, ExtendedTableConfig>;
+  version: string;
+  sourceSchema?: string;
+  targetSchema?: string;
+}
+
+export interface MigrationConfig {
+  commonSchema: string;
+  tables: Record<string, TableConfig>;
+  tenantInfo: {
+    sourceTable: string;
+    tenantIdColumn: string;
+    providerIdColumn: string;
+  };
+  migrationPriorities?: {
+    high?: string[];
+    medium?: string[];
+    low?: string[];
+  };
+}

package/src/scripts/database-initializer.ts

@@ -0,0 +1,49 @@
+import { PrismaClient } from "@prisma/client";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+export class DatabaseInitializer {
+  constructor(private readonly databaseUrl: string) {}
+
+  async initialize(): Promise<void> {
+    try {
+      console.log("Checking if database needs initialization...");
+
+      const { Pool } = await import("pg");
+      const pool = new Pool({ connectionString: this.databaseUrl });
+
+      try {
+        // Verificar si existen tablas en la base de datos
+        const result = await pool.query(`
+          SELECT COUNT(*) 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public'
+          AND table_type = 'BASE TABLE'
+        `);
+
+        const tableCount = parseInt(result.rows[0].count);
+
+        if (tableCount === 0) {
+          console.log(
+            "No tables found in database. Running initial migration..."
+          );
+          // Ejecutar migración inicial usando Prisma
+          await execAsync("npx prisma migrate deploy");
+          await execAsync("npx prisma db push");
+          console.log("Initial database migration completed successfully.");
+        } else {
+          console.log(
+            `Database already contains ${tableCount} tables. Skipping initialization.`
+          );
+        }
+      } finally {
+        await pool.end();
+      }
+    } catch (error) {
+      console.error("Error initializing database:", error);
+      throw error;
+    }
+  }
+}