@javalabs/prisma-client 1.0.18 → 1.0.19

package/dist/scripts/fix-table-indexes.js

@@ -44,11 +44,11 @@ class TableIndexFixer {
         }
     }
     async getSchemas() {
-        const result = await this.targetPool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
+        const result = await this.targetPool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
     `);
         return result.rows.map(row => row.schema_name);
     }
@@ -66,11 +66,11 @@ class TableIndexFixer {
         }
     }
     async getTablesForSchema(schema) {
-        const result = await this.targetPool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = $1
-      AND table_type = 'BASE TABLE'
+        const result = await this.targetPool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = $1
+      AND table_type = 'BASE TABLE'
     `, [schema]);
         return result.rows.map(row => row.table_name);
     }
@@ -126,24 +126,24 @@ class TableIndexFixer {
     async fixUserTableSequences(schema, table) {
         var _a;
         try {
-            const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+            const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
       `;
             const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
             const identityColumns = columnsResult.rows.map(row => row.column_name);
             for (const column of identityColumns) {
-                const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+                const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
         `;
                 const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
                 const sequenceName = (_a = sequenceResult.rows[0]) === null || _a === void 0 ? void 0 : _a.sequence_name;
                 if (sequenceName) {
-                    const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+                    const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
           `;
                     await this.targetPool.query(resetQuery, [sequenceName]);
                     this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table} (tabla de usuarios)`);
@@ -210,24 +210,24 @@ class TableIndexFixer {
     async fixSequences(schema, table) {
         var _a;
         try {
-            const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+            const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
       `;
             const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
             const identityColumns = columnsResult.rows.map(row => row.column_name);
             for (const column of identityColumns) {
-                const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+                const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
         `;
                 const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
                 const sequenceName = (_a = sequenceResult.rows[0]) === null || _a === void 0 ? void 0 : _a.sequence_name;
                 if (sequenceName) {
-                    const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+                    const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
           `;
                     await this.targetPool.query(resetQuery, [sequenceName]);
                     this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table}`);
@@ -249,14 +249,14 @@ class TableIndexFixer {
     async getTableInfo(schema, table) {
         var _a;
         try {
-            const identityQuery = `
-        SELECT EXISTS (
-          SELECT 1
-          FROM information_schema.columns
-          WHERE table_schema = $1
-          AND table_name = $2
-          AND is_identity = 'YES'
-        ) AS has_identity_column;
+            const identityQuery = `
+        SELECT EXISTS (
+          SELECT 1
+          FROM information_schema.columns
+          WHERE table_schema = $1
+          AND table_name = $2
+          AND is_identity = 'YES'
+        ) AS has_identity_column;
       `;
             const result = await this.targetPool.query(identityQuery, [schema, table]);
             return {
@@ -269,26 +269,26 @@ class TableIndexFixer {
         }
     }
     async getTableIndexes(pool, schema, table) {
-        const query = `
-      SELECT
-        i.relname AS index_name,
-        array_agg(a.attname) AS column_names,
-        ix.indisunique AS is_unique,
-        ix.indisprimary AS is_primary,
-        pg_get_indexdef(ix.indexrelid) AS definition
-      FROM
-        pg_index ix
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_class t ON t.oid = ix.indrelid
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-      WHERE
-        n.nspname = $1
-        AND t.relname = $2
-      GROUP BY
-        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
-      ORDER BY
-        i.relname;
+        const query = `
+      SELECT
+        i.relname AS index_name,
+        array_agg(a.attname) AS column_names,
+        ix.indisunique AS is_unique,
+        ix.indisprimary AS is_primary,
+        pg_get_indexdef(ix.indexrelid) AS definition
+      FROM
+        pg_index ix
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+      WHERE
+        n.nspname = $1
+        AND t.relname = $2
+      GROUP BY
+        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
+      ORDER BY
+        i.relname;
     `;
         try {
             const result = await pool.query(query, [schema, table]);
@@ -367,35 +367,35 @@ class TableIndexFixer {
         }
     }
     async getTableColumns(schema, table) {
-        const query = `
-      SELECT column_name, data_type, is_nullable
-      FROM information_schema.columns
-      WHERE table_schema = $1
-      AND table_name = $2
+        const query = `
+      SELECT column_name, data_type, is_nullable
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      AND table_name = $2
     `;
         const result = await this.targetPool.query(query, [schema, table]);
         return result.rows;
     }
     async fixForeignKeyIndexes(schema, table) {
         try {
-            const fkQuery = `
-        SELECT
-          kcu.column_name,
-          ccu.table_schema AS foreign_table_schema,
-          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 = $1
-          AND tc.table_name = $2;
+            const fkQuery = `
+        SELECT
+          kcu.column_name,
+          ccu.table_schema AS foreign_table_schema,
+          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 = $1
+          AND tc.table_name = $2;
       `;
             const fkResult = await this.targetPool.query(fkQuery, [schema, table]);
             const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);

package/dist/scripts/migrate-schema-structure.js

@@ -57,10 +57,10 @@ async function migrateSchemaStructure() {
 async function checkSchemaExists(schemaName) {
     const prisma = new client_1.PrismaClient();
     try {
-        const result = await prisma.$queryRaw `
-      SELECT schema_name 
-      FROM information_schema.schemata 
-      WHERE schema_name = ${schemaName}
+        const result = await prisma.$queryRaw `
+      SELECT schema_name 
+      FROM information_schema.schemata 
+      WHERE schema_name = ${schemaName}
     `;
         return Array.isArray(result) && result.length > 0;
     }

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({