@javalabs/prisma-client 1.0.18 → 1.0.20

package/dist/scripts/migrate-uuid.js

@@ -9,37 +9,37 @@ async function migrateUuid() {
         console.log("\n📦 Habilitando extensión uuid-ossp...");
         await prisma.$executeRaw `CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`;
         console.log("\n🔍 Verificando registros sin UUID...");
-        const nullUuids = await prisma.$queryRaw `
-      SELECT COUNT(*) as count 
-      FROM transactions 
-      WHERE uuid IS NULL;
+        const nullUuids = await prisma.$queryRaw `
+      SELECT COUNT(*) as count 
+      FROM transactions 
+      WHERE uuid IS NULL;
     `;
         if (nullUuids[0].count > 0) {
             console.log(`\n📝 Actualizando ${nullUuids[0].count} registros sin UUID...`);
-            await prisma.$executeRaw `
-        UPDATE transactions 
-        SET uuid = uuid_generate_v4() 
-        WHERE uuid IS NULL;
+            await prisma.$executeRaw `
+        UPDATE transactions 
+        SET uuid = uuid_generate_v4() 
+        WHERE uuid IS NULL;
       `;
         }
         console.log("\n🔍 Verificando registros después de la actualización...");
-        const remainingNullUuids = await prisma.$queryRaw `
-      SELECT COUNT(*) as count 
-      FROM transactions 
-      WHERE uuid IS NULL;
+        const remainingNullUuids = await prisma.$queryRaw `
+      SELECT COUNT(*) as count 
+      FROM transactions 
+      WHERE uuid IS NULL;
     `;
         if (remainingNullUuids[0].count > 0) {
             throw new Error(`Aún hay ${remainingNullUuids[0].count} registros sin UUID después de la actualización`);
         }
         console.log("\n📝 Haciendo UUID requerido y añadiendo valor por defecto...");
-        await prisma.$executeRaw `
-      ALTER TABLE transactions 
-      ALTER COLUMN uuid SET NOT NULL;
+        await prisma.$executeRaw `
+      ALTER TABLE transactions 
+      ALTER COLUMN uuid SET NOT NULL;
     `;
-        await prisma.$executeRaw `
-      ALTER TABLE transactions 
-      ALTER COLUMN uuid 
-      SET DEFAULT uuid_generate_v4();
+        await prisma.$executeRaw `
+      ALTER TABLE transactions 
+      ALTER COLUMN uuid 
+      SET DEFAULT uuid_generate_v4();
     `;
         console.log("\n✅ Migración completada exitosamente");
     }

package/dist/scripts/post-migration-validator.js

@@ -45,9 +45,9 @@ class PostMigrationValidator {
                 };
             }
             this.logger.log("Starting post-migration validation");
-            const apiKeysResult = await this.sourcePool.query(`
-        SELECT api_key, provider_id
-        FROM api_keys
+            const apiKeysResult = await this.sourcePool.query(`
+        SELECT api_key, provider_id
+        FROM api_keys
       `);
             this.logger.log(`Found ${apiKeysResult.rows.length} API keys to validate`);
             for (const apiKey of apiKeysResult.rows) {
@@ -101,11 +101,11 @@ class PostMigrationValidator {
     async validateTenantData(tenantId, providerId) {
         this.logger.log(`Validating data for tenant: ${tenantId} (Provider ID: ${providerId})`);
         try {
-            const schemaExistsResult = await this.targetPool.query(`
-        SELECT 1
-        FROM information_schema.schemata
-        WHERE schema_name = $1
-        LIMIT 1
+            const schemaExistsResult = await this.targetPool.query(`
+        SELECT 1
+        FROM information_schema.schemata
+        WHERE schema_name = $1
+        LIMIT 1
       `, [tenantId]);
             if (schemaExistsResult.rows.length === 0) {
                 this.logger.warn(`Schema ${tenantId} does not exist in target database`);
@@ -117,12 +117,12 @@ class PostMigrationValidator {
                 });
                 return;
             }
-            const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
-        AND table_name NOT IN ('_prisma_migrations', 'api_keys')
+            const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
+        AND table_name NOT IN ('_prisma_migrations', 'api_keys')
       `);
             for (const tableRow of tablesResult.rows) {
                 const tableName = tableRow.table_name;
@@ -142,13 +142,13 @@ class PostMigrationValidator {
     async validateTableData(tenantId, tableName, providerId) {
         try {
             let sourceCountQuery = `SELECT COUNT(*) as count FROM ${tableName}`;
-            const hasProviderIdResult = await this.sourcePool.query(`
-        SELECT 1
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-        AND table_name = $1
-        AND column_name = 'provider_id'
-        LIMIT 1
+            const hasProviderIdResult = await this.sourcePool.query(`
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        AND table_name = $1
+        AND column_name = 'provider_id'
+        LIMIT 1
       `, [tableName]);
             if (hasProviderIdResult.rows.length > 0) {
                 sourceCountQuery += ` WHERE provider_id = ${providerId}`;
@@ -197,49 +197,49 @@ class PostMigrationValidator {
     }
     async validateRandomRecords(tenantId, tableName, providerId) {
         try {
-            const primaryKeyResult = await this.sourcePool.query(`
-        SELECT kcu.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
-        WHERE tc.constraint_type = 'PRIMARY KEY'
-        AND tc.table_schema = 'public'
-        AND tc.table_name = $1
-        LIMIT 1
+            const primaryKeyResult = await this.sourcePool.query(`
+        SELECT kcu.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
+        WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = 'public'
+        AND tc.table_name = $1
+        LIMIT 1
       `, [tableName]);
             if (primaryKeyResult.rows.length === 0) {
                 this.logger.warn(`No primary key found for table ${tableName}`);
                 return;
             }
             const primaryKeyColumn = primaryKeyResult.rows[0].column_name;
-            let randomRecordsQuery = `
-        SELECT *
-        FROM ${tableName}
+            let randomRecordsQuery = `
+        SELECT *
+        FROM ${tableName}
       `;
-            const hasProviderIdResult = await this.sourcePool.query(`
-        SELECT 1
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-        AND table_name = $1
-        AND column_name = 'provider_id'
-        LIMIT 1
+            const hasProviderIdResult = await this.sourcePool.query(`
+        SELECT 1
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+        AND table_name = $1
+        AND column_name = 'provider_id'
+        LIMIT 1
       `, [tableName]);
             if (hasProviderIdResult.rows.length > 0) {
                 randomRecordsQuery += ` WHERE provider_id = ${providerId}`;
             }
-            randomRecordsQuery += `
-        ORDER BY RANDOM()
-        LIMIT 5
+            randomRecordsQuery += `
+        ORDER BY RANDOM()
+        LIMIT 5
       `;
             const randomRecordsResult = await this.sourcePool.query(randomRecordsQuery);
             for (const sourceRecord of randomRecordsResult.rows) {
                 const primaryKeyValue = sourceRecord[primaryKeyColumn];
-                const targetRecordResult = await this.targetPool.query(`
-          SELECT *
-          FROM "${tenantId}"."${tableName}"
-          WHERE "${primaryKeyColumn}" = $1
-          LIMIT 1
+                const targetRecordResult = await this.targetPool.query(`
+          SELECT *
+          FROM "${tenantId}"."${tableName}"
+          WHERE "${primaryKeyColumn}" = $1
+          LIMIT 1
         `, [primaryKeyValue]);
                 if (targetRecordResult.rows.length === 0) {
                     this.issues.push({

package/dist/scripts/pre-migration-validator.js

@@ -103,8 +103,8 @@ class PreMigrationValidator {
     async validateApiKeys() {
         this.logger.log('Validating API keys');
         try {
-            const result = await this.sourcePool.query(`
-        SELECT COUNT(*) as count FROM api_keys
+            const result = await this.sourcePool.query(`
+        SELECT COUNT(*) as count FROM api_keys
       `);
             const count = parseInt(result.rows[0].count);
             if (count === 0) {
@@ -129,35 +129,35 @@ class PreMigrationValidator {
     async validateDataTypeCompatibility() {
         this.logger.log('Validating data type compatibility');
         try {
-            const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
+            const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
       `);
             for (const tableRow of tablesResult.rows) {
                 const tableName = tableRow.table_name;
-                const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
+                const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
         `, [tableName]);
-                const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
+                const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
         `, [tableName]);
                 if (targetTableExists.rows.length === 0) {
                     continue;
                 }
-                const targetColumnsResult = await this.targetPool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
+                const targetColumnsResult = await this.targetPool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
         `, [tableName]);
                 const sourceColumns = sourceColumnsResult.rows.reduce((map, col) => {
                     map[col.column_name] = col;
@@ -217,28 +217,28 @@ class PreMigrationValidator {
     async validateColumnSizes() {
         this.logger.log('Validating column sizes');
         try {
-            const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
+            const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
       `);
             for (const tableRow of tablesResult.rows) {
                 const tableName = tableRow.table_name;
-                const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, character_maximum_length
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          AND data_type IN ('character varying', 'character', 'varchar', 'char')
-          AND character_maximum_length IS NOT NULL
+                const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, character_maximum_length
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          AND data_type IN ('character varying', 'character', 'varchar', 'char')
+          AND character_maximum_length IS NOT NULL
         `, [tableName]);
-                const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
+                const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
         `, [tableName]);
                 if (targetTableExists.rows.length === 0) {
                     continue;
@@ -246,13 +246,13 @@ class PreMigrationValidator {
                 for (const sourceColumn of sourceColumnsResult.rows) {
                     const columnName = sourceColumn.column_name;
                     const sourceMaxLength = sourceColumn.character_maximum_length;
-                    const targetColumnResult = await this.targetPool.query(`
-            SELECT character_maximum_length
-            FROM information_schema.columns
-            WHERE table_schema = 'public'
-            AND table_name = $1
-            AND column_name = $2
-            AND data_type IN ('character varying', 'character', 'varchar', 'char')
+                    const targetColumnResult = await this.targetPool.query(`
+            SELECT character_maximum_length
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+            AND table_name = $1
+            AND column_name = $2
+            AND data_type IN ('character varying', 'character', 'varchar', 'char')
           `, [tableName, columnName]);
                     if (targetColumnResult.rows.length > 0) {
                         const targetMaxLength = targetColumnResult.rows[0].character_maximum_length;
@@ -282,41 +282,41 @@ class PreMigrationValidator {
     async validateEnumValues() {
         this.logger.log('Validating enum values');
         try {
-            const sourceEnumsResult = await this.sourcePool.query(`
-        SELECT t.typname AS enum_name
-        FROM pg_type t
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typtype = 'e'
-        AND n.nspname = 'public'
+            const sourceEnumsResult = await this.sourcePool.query(`
+        SELECT t.typname AS enum_name
+        FROM pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typtype = 'e'
+        AND n.nspname = 'public'
       `);
             for (const enumRow of sourceEnumsResult.rows) {
                 const enumName = enumRow.enum_name;
-                const sourceEnumValuesResult = await this.sourcePool.query(`
-          SELECT e.enumlabel
-          FROM pg_enum e
-          JOIN pg_type t ON e.enumtypid = t.oid
-          WHERE t.typname = $1
-          ORDER BY e.enumsortorder
+                const sourceEnumValuesResult = await this.sourcePool.query(`
+          SELECT e.enumlabel
+          FROM pg_enum e
+          JOIN pg_type t ON e.enumtypid = t.oid
+          WHERE t.typname = $1
+          ORDER BY e.enumsortorder
         `, [enumName]);
                 const sourceEnumValues = sourceEnumValuesResult.rows.map(row => row.enumlabel);
-                const targetEnumExistsResult = await this.targetPool.query(`
-          SELECT 1
-          FROM pg_type t
-          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-          WHERE t.typtype = 'e'
-          AND t.typname = $1
-          AND n.nspname = 'public'
-          LIMIT 1
+                const targetEnumExistsResult = await this.targetPool.query(`
+          SELECT 1
+          FROM pg_type t
+          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          WHERE t.typtype = 'e'
+          AND t.typname = $1
+          AND n.nspname = 'public'
+          LIMIT 1
         `, [enumName]);
                 if (targetEnumExistsResult.rows.length === 0) {
                     continue;
                 }
-                const targetEnumValuesResult = await this.targetPool.query(`
-          SELECT e.enumlabel
-          FROM pg_enum e
-          JOIN pg_type t ON e.enumtypid = t.oid
-          WHERE t.typname = $1
-          ORDER BY e.enumsortorder
+                const targetEnumValuesResult = await this.targetPool.query(`
+          SELECT e.enumlabel
+          FROM pg_enum e
+          JOIN pg_type t ON e.enumtypid = t.oid
+          WHERE t.typname = $1
+          ORDER BY e.enumsortorder
         `, [enumName]);
                 const targetEnumValues = targetEnumValuesResult.rows.map(row => row.enumlabel);
                 for (const sourceValue of sourceEnumValues) {
@@ -343,22 +343,22 @@ class PreMigrationValidator {
     async validateForeignKeyConstraints() {
         this.logger.log('Validating foreign key constraints');
         try {
-            const foreignKeysResult = await this.sourcePool.query(`
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints AS tc
-          JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage AS 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 = 'public'
+            const foreignKeysResult = await this.sourcePool.query(`
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS 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 = 'public'
       `);
             this.logger.log(`Found ${foreignKeysResult.rows.length} foreign key constraints in source database`);
         }
@@ -373,28 +373,28 @@ class PreMigrationValidator {
     async validateUniqueConstraints() {
         this.logger.log('Validating unique constraints...');
         try {
-            const sourceConstraintsQuery = `
-        SELECT 
-          tc.table_name, 
-          kcu.column_name 
-        FROM 
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-        WHERE 
-          tc.constraint_type = 'UNIQUE'
-          AND tc.table_schema = 'public'
+            const sourceConstraintsQuery = `
+        SELECT 
+          tc.table_name, 
+          kcu.column_name 
+        FROM 
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE 
+          tc.constraint_type = 'UNIQUE'
+          AND tc.table_schema = 'public'
       `;
             const sourceConstraints = await this.sourcePool.query(sourceConstraintsQuery);
             for (const constraint of sourceConstraints.rows) {
                 const { table_name, column_name } = constraint;
                 try {
-                    const columnExistsQuery = `
-            SELECT column_name 
-            FROM information_schema.columns 
-            WHERE table_name = $1 
-              AND column_name = $2
-              AND table_schema = 'public'
+                    const columnExistsQuery = `
+            SELECT column_name 
+            FROM information_schema.columns 
+            WHERE table_name = $1 
+              AND column_name = $2
+              AND table_schema = 'public'
           `;
                     const columnExists = await this.targetPool.query(columnExistsQuery, [table_name, column_name]);
                     if (columnExists.rows.length === 0) {

package/dist/scripts/reset-database.js

@@ -105,12 +105,12 @@ class DatabaseResetTool {
     async dropAllCustomTypes() {
         this.logger.log("Dropping all custom types (enums, domains, etc.)");
         try {
-            const typesQuery = `
-        SELECT t.typname AS name
-        FROM pg_type t 
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE n.nspname = 'public'
-        AND t.typtype = 'e' -- enum types
+            const typesQuery = `
+        SELECT t.typname AS name
+        FROM pg_type t 
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE n.nspname = 'public'
+        AND t.typtype = 'e' -- enum types
       `;
             const typesResult = await this.pool.query(typesQuery);
             const types = typesResult.rows.map(row => row.name);
@@ -130,20 +130,20 @@ class DatabaseResetTool {
         }
     }
     async getCustomSchemas() {
-        const result = await this.pool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
+        const result = await this.pool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
     `);
         return result.rows.map(row => row.schema_name);
     }
     async getPublicTables() {
-        const result = await this.pool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-      AND table_type = 'BASE TABLE'
+        const result = await this.pool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      AND table_type = 'BASE TABLE'
     `);
         return result.rows.map(row => row.table_name);
     }
@@ -154,11 +154,11 @@ class DatabaseResetTool {
     async terminateConnections(dbName) {
         this.logger.log(`Terminating all connections to database: ${dbName}`);
         try {
-            await this.adminPool.query(`
-        SELECT pg_terminate_backend(pg_stat_activity.pid)
-        FROM pg_stat_activity
-        WHERE pg_stat_activity.datname = $1
-        AND pid <> pg_backend_pid()
+            await this.adminPool.query(`
+        SELECT pg_terminate_backend(pg_stat_activity.pid)
+        FROM pg_stat_activity
+        WHERE pg_stat_activity.datname = $1
+        AND pid <> pg_backend_pid()
       `, [dbName]);
             this.logger.log("All connections terminated successfully");
         }

package/dist/scripts/retry-failed-migrations.js

@@ -131,10 +131,10 @@ class FailedMigrationRetry {
                         if (columnNames.includes(recordId)) {
                             createData[recordId] = data[recordId];
                         }
-                        const checkExistQuery = `
-              SELECT 1 FROM "${tenantId}"."${entity}" 
-              WHERE "${recordId}" = $1
-              LIMIT 1
+                        const checkExistQuery = `
+              SELECT 1 FROM "${tenantId}"."${entity}" 
+              WHERE "${recordId}" = $1
+              LIMIT 1
             `;
                         const existResult = await this.targetPool.query(checkExistQuery, [
                             data[recordId],
@@ -150,10 +150,10 @@ class FailedMigrationRetry {
                                 return `"${key}" = $${index + 2}`;
                             });
                             if (updateFields.length > 0) {
-                                const updateQuery = `
-                  UPDATE "${tenantId}"."${entity}"
-                  SET ${updateFields.join(", ")}
-                  WHERE "${recordId}" = $1
+                                const updateQuery = `
+                  UPDATE "${tenantId}"."${entity}"
+                  SET ${updateFields.join(", ")}
+                  WHERE "${recordId}" = $1
                 `;
                                 const updateValues = [
                                     data[recordId],
@@ -176,9 +176,9 @@ class FailedMigrationRetry {
                                 }
                                 return `$${index + 1}`;
                             });
-                            const insertQuery = `
-                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
-                VALUES (${insertPlaceholders.join(", ")})
+                            const insertQuery = `
+                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
+                VALUES (${insertPlaceholders.join(", ")})
               `;
                             const insertValues = Object.keys(createData)
                                 .filter(key => key !== '_enumTypes')
@@ -196,11 +196,11 @@ class FailedMigrationRetry {
                 }
                 await tenantPrisma.$disconnect();
             }
-            this.logger.log(`
-Retry Summary:
-- Total errors: ${totalErrors}
-- Successfully retried: ${retrySuccessCount}
-- Failed retries: ${retryFailCount}
+            this.logger.log(`
+Retry Summary:
+- Total errors: ${totalErrors}
+- Successfully retried: ${retrySuccessCount}
+- Failed retries: ${retryFailCount}
       `);
             const remainingErrorsReport = this.errorHandler.generateErrorReport();
             this.logger.log("Remaining Errors Report:\n" + remainingErrorsReport);
@@ -214,12 +214,12 @@ Retry Summary:
     }
     async getTableSchema(tableName, schemaName) {
         try {
-            const schemaQuery = `
-        SELECT column_name, data_type, column_default, is_nullable, udt_name
-        FROM information_schema.columns
-        WHERE table_name = $1
-        AND table_schema = $2
-        ORDER BY ordinal_position
+            const schemaQuery = `
+        SELECT column_name, data_type, column_default, is_nullable, udt_name
+        FROM information_schema.columns
+        WHERE table_name = $1
+        AND table_schema = $2
+        ORDER BY ordinal_position
       `;
             const result = await this.targetPool.query(schemaQuery, [
                 tableName,
@@ -234,12 +234,12 @@ Retry Summary:
     }
     async getEnumValues(enumTypeName) {
         try {
-            const enumQuery = `
-        SELECT e.enumlabel
-        FROM pg_enum e
-        JOIN pg_type t ON e.enumtypid = t.oid
-        WHERE t.typname = $1
-        ORDER BY e.enumsortorder
+            const enumQuery = `
+        SELECT e.enumlabel
+        FROM pg_enum e
+        JOIN pg_type t ON e.enumtypid = t.oid
+        WHERE t.typname = $1
+        ORDER BY e.enumsortorder
       `;
             const result = await this.targetPool.query(enumQuery, [enumTypeName]);
             return result.rows.map((row) => row.enumlabel);