@javalabs/prisma-client 1.0.30 → 1.0.31

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

@@ -1,193 +1,193 @@
-import { PrismaClient } from "@prisma/client";
-
-export class TypecastManager {
-  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);
-  }
-
-  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}`
-      );
-    }
-  }
-}
+import { PrismaClient } from "@prisma/client";
+
+export class TypecastManager {
+  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);
+  }
+
+  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,113 +1,113 @@
-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 {
-  sourceConnections?: DatabaseConnection[];
-  sourcePool?: Pool;
-  targetPool: Pool;
-  targetPrisma: PrismaClient;
-  sourcePrisma?: 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;
-}
-
-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[];
-  };
-}
+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 {
+  sourceConnections?: DatabaseConnection[];
+  sourcePool?: Pool;
+  targetPool: Pool;
+  targetPrisma: PrismaClient;
+  sourcePrisma?: 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;
+}
+
+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[];
+  };
+}