@javalabs/prisma-client 1.0.16 → 1.0.19

package/dist/scripts/add-uuid-to-table.js

@@ -9,21 +9,21 @@ const prisma = new client_1.PrismaClient();
 async function addUuidToTable({ tableName, columnName = "uuid", makeRequired = false, addDefault = false, }) {
     try {
         console.log(`🚀 Iniciando proceso de añadir UUID a la tabla ${tableName}...`);
-        const tableExists = await prisma.$queryRaw `
-      SELECT EXISTS (
-        SELECT FROM information_schema.tables 
-        WHERE table_name = ${tableName}
-      );
+        const tableExists = await prisma.$queryRaw `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = ${tableName}
+      );
     `;
         if (!tableExists[0].exists) {
             throw new Error(`La tabla ${tableName} no existe`);
         }
-        const columnExists = await prisma.$queryRaw `
-      SELECT EXISTS (
-        SELECT FROM information_schema.columns 
-        WHERE table_name = ${tableName} 
-        AND column_name = ${columnName}
-      );
+        const columnExists = await prisma.$queryRaw `
+      SELECT EXISTS (
+        SELECT FROM information_schema.columns 
+        WHERE table_name = ${tableName} 
+        AND column_name = ${columnName}
+      );
     `;
         if (columnExists[0].exists) {
             console.log(`⚠️ La columna ${columnName} ya existe en la tabla ${tableName}`);
@@ -32,40 +32,40 @@ async function addUuidToTable({ tableName, columnName = "uuid", makeRequired = f
         console.log("📦 Habilitando extensión uuid-ossp...");
         await prisma.$executeRaw `CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`;
         console.log(`📝 Añadiendo columna ${columnName}...`);
-        await prisma.$executeRaw `
-      ALTER TABLE ${tableName} 
-      ADD COLUMN ${columnName} VARCHAR(255);
+        await prisma.$executeRaw `
+      ALTER TABLE ${tableName} 
+      ADD COLUMN ${columnName} VARCHAR(255);
     `;
         console.log("🔄 Actualizando registros existentes con UUIDs...");
-        await prisma.$executeRaw `
-      UPDATE ${tableName} 
-      SET ${columnName} = uuid_generate_v4() 
-      WHERE ${columnName} IS NULL;
+        await prisma.$executeRaw `
+      UPDATE ${tableName} 
+      SET ${columnName} = uuid_generate_v4() 
+      WHERE ${columnName} IS NULL;
     `;
         console.log("📊 Creando índice...");
-        await prisma.$executeRaw `
-      CREATE INDEX idx_${tableName}_${columnName} 
-      ON ${tableName}(${columnName});
+        await prisma.$executeRaw `
+      CREATE INDEX idx_${tableName}_${columnName} 
+      ON ${tableName}(${columnName});
     `;
         console.log("🔒 Añadiendo restricción unique...");
-        await prisma.$executeRaw `
-      ALTER TABLE ${tableName} 
-      ADD CONSTRAINT ${tableName}_${columnName}_key 
-      UNIQUE (${columnName});
+        await prisma.$executeRaw `
+      ALTER TABLE ${tableName} 
+      ADD CONSTRAINT ${tableName}_${columnName}_key 
+      UNIQUE (${columnName});
     `;
         if (makeRequired) {
             console.log("⚠️ Haciendo la columna NOT NULL...");
-            await prisma.$executeRaw `
-        ALTER TABLE ${tableName} 
-        ALTER COLUMN ${columnName} SET NOT NULL;
+            await prisma.$executeRaw `
+        ALTER TABLE ${tableName} 
+        ALTER COLUMN ${columnName} SET NOT NULL;
       `;
         }
         if (addDefault) {
             console.log("⚡ Añadiendo valor por defecto...");
-            await prisma.$executeRaw `
-        ALTER TABLE ${tableName} 
-        ALTER COLUMN ${columnName} 
-        SET DEFAULT uuid_generate_v4();
+            await prisma.$executeRaw `
+        ALTER TABLE ${tableName} 
+        ALTER COLUMN ${columnName} 
+        SET DEFAULT uuid_generate_v4();
       `;
         }
         console.log(`✅ Proceso completado exitosamente para la tabla ${tableName}`);

package/dist/scripts/data-migration/batch-migrator.js

@@ -64,13 +64,13 @@ class BatchMigrator {
         }
     }
     async fetchBatch(sourceSchema, tableConfig, offset, limit) {
-        const query = `
-      SELECT *
-      FROM "${sourceSchema}"."${tableConfig.sourceTable}"
-      ${this.buildWhereClause(tableConfig)}
-      ORDER BY "${tableConfig.idField}"
-      LIMIT ${limit}
-      OFFSET ${offset}
+        const query = `
+      SELECT *
+      FROM "${sourceSchema}"."${tableConfig.sourceTable}"
+      ${this.buildWhereClause(tableConfig)}
+      ORDER BY "${tableConfig.idField}"
+      LIMIT ${limit}
+      OFFSET ${offset}
     `;
         const result = await this.connections.sourcePool.query(query);
         return result.rows;
@@ -121,11 +121,11 @@ class BatchMigrator {
         const columns = Object.keys(record);
         const values = Object.values(record);
         const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
-        const query = `
-      INSERT INTO "${schema}"."${table}"
-      (${columns.map((col) => `"${col}"`).join(", ")})
-      VALUES (${placeholders})
-      ON CONFLICT DO NOTHING
+        const query = `
+      INSERT INTO "${schema}"."${table}"
+      (${columns.map((col) => `"${col}"`).join(", ")})
+      VALUES (${placeholders})
+      ON CONFLICT DO NOTHING
     `;
         await client.query(query, values);
     }

package/dist/scripts/data-migration/data-transformer.js

@@ -55,12 +55,12 @@ class DataTransformer {
         }
     }
     async getEnumTypeName(tableName, columnName) {
-        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'
+        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}`);
@@ -88,14 +88,14 @@ class DataTransformer {
             if (enumDefaults[enumType]) {
                 return enumDefaults[enumType];
             }
-            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 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,

package/dist/scripts/data-migration/dependency-resolver.js

@@ -74,11 +74,11 @@ class DependencyResolver {
         this.tableOrder.push(table);
     }
     async getAllTables() {
-        const query = `
-      SELECT table_name 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public' 
-      AND table_type = 'BASE TABLE'
+        const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_type = 'BASE TABLE'
     `;
         const result = await this.sourcePool.query(query);
         return result.rows.map((row) => row.table_name);
@@ -88,17 +88,17 @@ class DependencyResolver {
         const dependencies = new Set();
         const configDeps = ((_c = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.tables) === null || _b === void 0 ? void 0 : _b[table]) === null || _c === void 0 ? void 0 : _c.dependencies) || [];
         configDeps.forEach((dep) => dependencies.add(dep));
-        const query = `
-      SELECT
-        ccu.table_name AS foreign_table
-      FROM
-        information_schema.table_constraints tc
-        JOIN information_schema.constraint_column_usage ccu
-          ON ccu.constraint_name = tc.constraint_name
-      WHERE
-        tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = $1
-        AND tc.table_schema = 'public'
+        const query = `
+      SELECT
+        ccu.table_name AS foreign_table
+      FROM
+        information_schema.table_constraints tc
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
     `;
         try {
             const result = await this.sourcePool.query(query, [table]);
@@ -111,13 +111,13 @@ class DependencyResolver {
     }
     async validateDependencies(table, dependencies) {
         for (const dep of dependencies) {
-            const query = `
-        SELECT EXISTS (
-          SELECT 1 
-          FROM information_schema.tables 
-          WHERE table_schema = 'public' 
-          AND table_name = $1
-        )
+            const query = `
+        SELECT EXISTS (
+          SELECT 1 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
+        )
       `;
             const result = await this.sourcePool.query(query, [dep]);
             if (!result.rows[0].exists) {

package/dist/scripts/data-migration/entity-discovery.js

@@ -43,13 +43,13 @@ class EntityDiscovery {
         }
     }
     async getPrimaryKey(schemaName, tableName) {
-        const query = `
-      SELECT a.attname
-      FROM   pg_index i
-      JOIN   pg_attribute a ON a.attrelid = i.indrelid
-                           AND a.attnum = ANY(i.indkey)
-      WHERE  i.indrelid = '"${schemaName}"."${tableName}"'::regclass
-      AND    i.indisprimary;
+        const query = `
+      SELECT a.attname
+      FROM   pg_index i
+      JOIN   pg_attribute a ON a.attrelid = i.indrelid
+                           AND a.attnum = ANY(i.indkey)
+      WHERE  i.indrelid = '"${schemaName}"."${tableName}"'::regclass
+      AND    i.indisprimary;
     `;
         try {
             const { rows } = await this.targetPool.query(query);
@@ -61,23 +61,23 @@ class EntityDiscovery {
         }
     }
     async getForeignKeys(schemaName, tableName) {
-        const query = `
-      SELECT
-        kcu.column_name,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name
-      FROM
-        information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        JOIN information_schema.constraint_column_usage ccu
-          ON ccu.constraint_name = tc.constraint_name
-          AND ccu.table_schema = tc.table_schema
-      WHERE
-        tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = $1
-        AND tc.table_name = $2;
+        const query = `
+      SELECT
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM
+        information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+      WHERE
+        tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = $1
+        AND tc.table_name = $2;
     `;
         try {
             const { rows } = await this.targetPool.query(query, [schemaName, tableName]);
@@ -89,50 +89,50 @@ class EntityDiscovery {
         }
     }
     async findJoinTables(schemaName, sourceTable, targetTable) {
-        const query = `
-      WITH source_fks AS (
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS referenced_table
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND ccu.table_name = $2
-      ),
-      target_fks AS (
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS referenced_table
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND ccu.table_name = $3
-      )
-      SELECT
-        s.table_name AS join_table,
-        s.column_name AS source_column,
-        t.column_name AS target_column
-      FROM
-        source_fks s
-        JOIN target_fks t ON s.table_name = t.table_name
+        const query = `
+      WITH source_fks AS (
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS referenced_table
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND ccu.table_name = $2
+      ),
+      target_fks AS (
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS referenced_table
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND ccu.table_name = $3
+      )
+      SELECT
+        s.table_name AS join_table,
+        s.column_name AS source_column,
+        t.column_name AS target_column
+      FROM
+        source_fks s
+        JOIN target_fks t ON s.table_name = t.table_name
     `;
         try {
             const { rows } = await this.targetPool.query(query, [

package/dist/scripts/data-migration/foreign-key-manager.js

@@ -15,23 +15,23 @@ class ForeignKeyManager {
         }
         try {
             this.logger.log(`Obteniendo dependencias de llaves foráneas para ${schemaName}.${tableName}`);
-            const query = `
-        SELECT
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE
-          tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_schema = $1
-          AND tc.table_name = $2;
+            const query = `
+        SELECT
+          kcu.column_name,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE
+          tc.constraint_type = 'FOREIGN KEY'
+          AND tc.table_schema = $1
+          AND tc.table_name = $2;
       `;
             const { rows } = await this.connections.targetPool.query(query, [
                 schemaName,
@@ -42,7 +42,7 @@ class ForeignKeyManager {
                 foreignTable: row.foreign_table_name,
                 foreignColumn: row.foreign_column_name,
             }));
-            this.logger.log(`Encontradas ${dependencies.length} dependencias para ${schemaName}.${tableName}:
+            this.logger.log(`Encontradas ${dependencies.length} dependencias para ${schemaName}.${tableName}:
         ${dependencies
                 .map((d) => `\n  - ${d.column} -> ${d.foreignTable}.${d.foreignColumn}`)
                 .join("")}`);
@@ -81,7 +81,7 @@ class ForeignKeyManager {
             }
         }
         if (missingDependencies.length > 0) {
-            this.logger.debug(`Registro ${recordId}: Faltan ${missingDependencies.length} dependencias:
+            this.logger.debug(`Registro ${recordId}: Faltan ${missingDependencies.length} dependencias:
         ${missingDependencies.map((dep) => `\n  - ${dep}`).join("")}`);
         }
         else {
@@ -141,10 +141,10 @@ class ForeignKeyManager {
     }
     async checkTableExists(tableName) {
         try {
-            const result = await this.connections.sourcePool.query(`SELECT EXISTS (
-          SELECT FROM information_schema.tables 
-          WHERE table_schema = 'public' 
-          AND table_name = $1
+            const result = await this.connections.sourcePool.query(`SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_schema = 'public' 
+          AND table_name = $1
         )`, [tableName]);
             const exists = result.rows[0].exists;
             this.logger.debug(`Verificación de existencia de tabla ${tableName}: ${exists ? "EXISTE" : "NO EXISTE"}`);

package/dist/scripts/data-migration/migration-tool.js

@@ -113,11 +113,11 @@ class DataMigrationTool {
                 }
             }
             this.logger.debug(`Validation check: Using ${transactionTableKey}.${transactionProviderFk} referencing ${providerTableKey}.${providerIdColumn}`);
-            const query = `
-            SELECT t."${tablesConfig[transactionTableKey].idField}" AS transaction_id, t."${transactionProviderFk}"
-            FROM "${transactionTableKey}" t
-            LEFT JOIN "${providerTableKey}" p ON t."${transactionProviderFk}" = p."${providerIdColumn}"
-            WHERE t."${transactionProviderFk}" IS NOT NULL AND p."${providerIdColumn}" IS NULL;
+            const query = `
+            SELECT t."${tablesConfig[transactionTableKey].idField}" AS transaction_id, t."${transactionProviderFk}"
+            FROM "${transactionTableKey}" t
+            LEFT JOIN "${providerTableKey}" p ON t."${transactionProviderFk}" = p."${providerIdColumn}"
+            WHERE t."${transactionProviderFk}" IS NOT NULL AND p."${providerIdColumn}" IS NULL;
           `;
             const invalidTransactions = (await this.connections.sourcePrisma.$queryRawUnsafe(query));
             if (invalidTransactions.length > 0) {