@javalabs/prisma-client 1.0.16 → 1.0.19

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

@@ -1,426 +1,426 @@
-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 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(
-    tableName: string,
-    columnName: string,
-    value: string | null,
-    isNullable: boolean = true
-  ): Promise<string | null> {
-    try {
-      if (value === null) {
-        return isNullable
-          ? null
-          : await this.getDefaultEnumValue(tableName, columnName);
-      }
-
-      const enumTypeName = await this.getEnumTypeName(tableName, columnName);
-      const normalizedValue = value.toString().trim().toLowerCase();
-
-      // 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);
-
-      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();
-      }
-
-      // Verificar coincidencia parcial
-      const partialMatch = enumValues.find(
-        (enumValue) =>
-          enumValue.includes(normalizedValue) ||
-          normalizedValue.includes(enumValue)
-      );
-
-      if (partialMatch) {
-        this.logger.debug(
-          `Valor enum corregido: ${value} -> ${partialMatch} para ${tableName}.${columnName}`
-        );
-        return partialMatch;
-      }
-
-      // 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;
-      }
-
-      if (!isNullable) {
-        throw new Error(
-          `No se pudo encontrar un valor válido para el enum ${enumTypeName}`
-        );
-      }
-
-      return null;
-    } catch (error) {
-      this.logger.error(
-        `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;
-    }
-
-    const numericValue = parseFloat(value);
-    if (isNaN(numericValue)) {
-      return null;
-    }
-
-    return numericValue;
-  }
-
-  private async getDefaultEnumValue(
-    enumType: string,
-    tenantId: string = "public"
-  ): Promise<string | null> {
-    try {
-      // 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
-      `;
-
-      const result = await this.schemaUtils.queryTargetDb(query, [
-        enumType,
-        tenantId,
-      ]);
-
-      if (result.rows.length > 0) {
-        return result.rows[0].enumlabel;
-      }
-
-      return null;
-    } catch (error) {
-      this.logger.error(
-        `Error getting default enum value for ${enumType}: ${error.message}`
-      );
-      return null;
-    }
-  }
-
-  async prepareEnumValue(
-    tenantId: string,
-    enumType: string,
-    value: string
-  ): Promise<EnumCastValue | null> {
-    if (value === null || value === undefined || value === "") {
-      return null;
-    }
-
-    const validatedValue = await this.validateEnumValue(
-      tenantId,
-      enumType,
-      value
-    );
-
-    if (validatedValue === null) {
-      // Obtener valor por defecto dinámicamente
-      const defaultValue = await this.getDefaultEnumValue(enumType, tenantId);
-      if (defaultValue) {
-        this.logger.warn(
-          `Using first enum value '${defaultValue}' as default for invalid value '${value}' of type ${enumType}`
-        );
-        return {
-          needsEnumCast: true,
-          value: defaultValue,
-          enumType,
-        };
-      }
-      return null;
-    }
-
-    return {
-      needsEnumCast: true,
-      value: validatedValue,
-      enumType,
-    };
-  }
-
-  async transformColumnValue(
-    value: any,
-    columnName: string,
-    targetColumn: ColumnSchema & { source_type?: string },
-    tenantId: string
-  ): Promise<any> {
-    if (value === null || value === undefined) {
-      return targetColumn.is_nullable === "YES"
-        ? null
-        : this.getDefaultValue(targetColumn);
-    }
-
-    try {
-      // Si tenemos el tipo de origen, usar el TypecastManager
-      if (targetColumn.source_type) {
-        return this.typecastManager.castValue(
-          value,
-          targetColumn.source_type,
-          targetColumn.data_type
-        );
-      }
-
-      // 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 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;
-      }
-    } catch (error) {
-      this.logger.warn(
-        `Error transformando valor para columna ${columnName}: ${error.message}`
-      );
-      return targetColumn.is_nullable === "YES"
-        ? null
-        : this.getDefaultValue(targetColumn);
-    }
-  }
-
-  private getDefaultValue(column: ColumnSchema): any {
-    switch (column.data_type.toLowerCase()) {
-      case "integer":
-      case "bigint":
-      case "smallint":
-        return 0;
-      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 "json":
-      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:
-        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[],
-    targetSchema: ColumnSchema[],
-    tenantId: string
-  ): Promise<any> {
-    const transformedData: any = {};
-
-    for (const [key, value] of Object.entries(record)) {
-      // Primero intentar encontrar una coincidencia exacta
-      let targetColumn = targetSchema.find((col) => col.column_name === key);
-
-      // Si no se encuentra coincidencia exacta, intentar case-insensitive
-      if (!targetColumn) {
-        targetColumn = targetSchema.find(
-          (col) => col.column_name.toLowerCase() === key.toLowerCase()
-        );
-      }
-
-      if (!targetColumn) {
-        this.logger.warn(`Column ${key} not found in target schema, skipping`);
-        continue;
-      }
-
-      // Usar el nombre exacto de la columna del schema destino
-      const columnName = targetColumn.column_name;
-
-      const transformedValue = await this.transformColumnValue(
-        value,
-        columnName,
-        targetColumn,
-        tenantId
-      );
-
-      transformedData[columnName] = transformedValue;
-    }
-
-    return transformedData;
-  }
-}
+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 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(
+    tableName: string,
+    columnName: string,
+    value: string | null,
+    isNullable: boolean = true
+  ): Promise<string | null> {
+    try {
+      if (value === null) {
+        return isNullable
+          ? null
+          : await this.getDefaultEnumValue(tableName, columnName);
+      }
+
+      const enumTypeName = await this.getEnumTypeName(tableName, columnName);
+      const normalizedValue = value.toString().trim().toLowerCase();
+
+      // 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);
+
+      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();
+      }
+
+      // Verificar coincidencia parcial
+      const partialMatch = enumValues.find(
+        (enumValue) =>
+          enumValue.includes(normalizedValue) ||
+          normalizedValue.includes(enumValue)
+      );
+
+      if (partialMatch) {
+        this.logger.debug(
+          `Valor enum corregido: ${value} -> ${partialMatch} para ${tableName}.${columnName}`
+        );
+        return partialMatch;
+      }
+
+      // 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;
+      }
+
+      if (!isNullable) {
+        throw new Error(
+          `No se pudo encontrar un valor válido para el enum ${enumTypeName}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      this.logger.error(
+        `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;
+    }
+
+    const numericValue = parseFloat(value);
+    if (isNaN(numericValue)) {
+      return null;
+    }
+
+    return numericValue;
+  }
+
+  private async getDefaultEnumValue(
+    enumType: string,
+    tenantId: string = "public"
+  ): Promise<string | null> {
+    try {
+      // 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
+      `;
+
+      const result = await this.schemaUtils.queryTargetDb(query, [
+        enumType,
+        tenantId,
+      ]);
+
+      if (result.rows.length > 0) {
+        return result.rows[0].enumlabel;
+      }
+
+      return null;
+    } catch (error) {
+      this.logger.error(
+        `Error getting default enum value for ${enumType}: ${error.message}`
+      );
+      return null;
+    }
+  }
+
+  async prepareEnumValue(
+    tenantId: string,
+    enumType: string,
+    value: string
+  ): Promise<EnumCastValue | null> {
+    if (value === null || value === undefined || value === "") {
+      return null;
+    }
+
+    const validatedValue = await this.validateEnumValue(
+      tenantId,
+      enumType,
+      value
+    );
+
+    if (validatedValue === null) {
+      // Obtener valor por defecto dinámicamente
+      const defaultValue = await this.getDefaultEnumValue(enumType, tenantId);
+      if (defaultValue) {
+        this.logger.warn(
+          `Using first enum value '${defaultValue}' as default for invalid value '${value}' of type ${enumType}`
+        );
+        return {
+          needsEnumCast: true,
+          value: defaultValue,
+          enumType,
+        };
+      }
+      return null;
+    }
+
+    return {
+      needsEnumCast: true,
+      value: validatedValue,
+      enumType,
+    };
+  }
+
+  async transformColumnValue(
+    value: any,
+    columnName: string,
+    targetColumn: ColumnSchema & { source_type?: string },
+    tenantId: string
+  ): Promise<any> {
+    if (value === null || value === undefined) {
+      return targetColumn.is_nullable === "YES"
+        ? null
+        : this.getDefaultValue(targetColumn);
+    }
+
+    try {
+      // Si tenemos el tipo de origen, usar el TypecastManager
+      if (targetColumn.source_type) {
+        return this.typecastManager.castValue(
+          value,
+          targetColumn.source_type,
+          targetColumn.data_type
+        );
+      }
+
+      // 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 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;
+      }
+    } catch (error) {
+      this.logger.warn(
+        `Error transformando valor para columna ${columnName}: ${error.message}`
+      );
+      return targetColumn.is_nullable === "YES"
+        ? null
+        : this.getDefaultValue(targetColumn);
+    }
+  }
+
+  private getDefaultValue(column: ColumnSchema): any {
+    switch (column.data_type.toLowerCase()) {
+      case "integer":
+      case "bigint":
+      case "smallint":
+        return 0;
+      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 "json":
+      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:
+        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[],
+    targetSchema: ColumnSchema[],
+    tenantId: string
+  ): Promise<any> {
+    const transformedData: any = {};
+
+    for (const [key, value] of Object.entries(record)) {
+      // Primero intentar encontrar una coincidencia exacta
+      let targetColumn = targetSchema.find((col) => col.column_name === key);
+
+      // Si no se encuentra coincidencia exacta, intentar case-insensitive
+      if (!targetColumn) {
+        targetColumn = targetSchema.find(
+          (col) => col.column_name.toLowerCase() === key.toLowerCase()
+        );
+      }
+
+      if (!targetColumn) {
+        this.logger.warn(`Column ${key} not found in target schema, skipping`);
+        continue;
+      }
+
+      // Usar el nombre exacto de la columna del schema destino
+      const columnName = targetColumn.column_name;
+
+      const transformedValue = await this.transformColumnValue(
+        value,
+        columnName,
+        targetColumn,
+        tenantId
+      );
+
+      transformedData[columnName] = transformedValue;
+    }
+
+    return transformedData;
+  }
+}