@javalabs/prisma-client 1.0.18 → 1.0.20

package/dist/scripts/run-migration.js

@@ -139,11 +139,11 @@ program
                 const pool = new Pool({ connectionString: process.env.DATABASE_URL });
                 async function checkIfTablesExist(pool) {
                     try {
-                        const result = await pool.query(`
-                SELECT COUNT(*) 
-                FROM information_schema.tables 
-                WHERE table_schema = 'public'
-                AND table_type = 'BASE TABLE'
+                        const result = await pool.query(`
+                SELECT COUNT(*) 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public'
+                AND table_type = 'BASE TABLE'
               `);
                         return parseInt(result.rows[0].count) > 0;
                     }

package/dist/scripts/schema-sync.js

@@ -28,11 +28,11 @@ async function main() {
     }
 }
 async function getTablesFromDatabase(pool) {
-    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 pool.query(query);
     return result.rows.map(row => row.table_name);
@@ -61,19 +61,19 @@ async function generateSyncScript(sourcePool, targetPool, sourceTables, targetTa
     return script;
 }
 async function getTableColumns(pool, table) {
-    const query = `
-    SELECT 
-      column_name, 
-      data_type, 
-      is_nullable,
-      column_default
-    FROM 
-      information_schema.columns
-    WHERE 
-      table_schema = 'public' 
-      AND table_name = $1
-    ORDER BY 
-      ordinal_position
+    const query = `
+    SELECT 
+      column_name, 
+      data_type, 
+      is_nullable,
+      column_default
+    FROM 
+      information_schema.columns
+    WHERE 
+      table_schema = 'public' 
+      AND table_name = $1
+    ORDER BY 
+      ordinal_position
   `;
     const result = await pool.query(query, [table]);
     return result.rows;

package/dist/scripts/sequence-sync-cli.js

@@ -36,18 +36,18 @@ catch (error) {
 }
 async function findExistingSequence(pool, tableName, columnName) {
     try {
-        const query = `
-      SELECT 
-        s.relname as sequence_name
-      FROM pg_class s
-      JOIN pg_depend d ON d.objid = s.oid
-      JOIN pg_class t ON d.refobjid = t.oid
-      JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)
-      JOIN pg_namespace n ON n.oid = s.relnamespace
-      WHERE s.relkind = 'S'
-        AND n.nspname = 'public'
-        AND t.relname = $1
-        AND a.attname = $2;
+        const query = `
+      SELECT 
+        s.relname as sequence_name
+      FROM pg_class s
+      JOIN pg_depend d ON d.objid = s.oid
+      JOIN pg_class t ON d.refobjid = t.oid
+      JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)
+      JOIN pg_namespace n ON n.oid = s.relnamespace
+      WHERE s.relkind = 'S'
+        AND n.nspname = 'public'
+        AND t.relname = $1
+        AND a.attname = $2;
     `;
         const result = await pool.query(query, [tableName, columnName]);
         if (result.rows.length > 0) {
@@ -81,14 +81,14 @@ async function findOrCreateSequence(pool, tableName, columnName) {
             `${tableName}_seq`,
         ];
         for (const name of possibleNames) {
-            const exists = await pool.query(`
-        SELECT EXISTS (
-          SELECT 1 FROM pg_class c
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE n.nspname = 'public'
-          AND c.relname = $1
-          AND c.relkind = 'S'
-        );
+            const exists = await pool.query(`
+        SELECT EXISTS (
+          SELECT 1 FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = 'public'
+          AND c.relname = $1
+          AND c.relkind = 'S'
+        );
       `, [name]);
             if (exists.rows[0].exists) {
                 sequenceName = name;
@@ -100,25 +100,25 @@ async function findOrCreateSequence(pool, tableName, columnName) {
             if (options.verbose) {
                 logger.log(`Creating new sequence: ${sequenceName}`);
             }
-            const maxValQuery = `
-        SELECT COALESCE(MAX("${columnName}"), 0) as max_val 
-        FROM "${tableName}";
+            const maxValQuery = `
+        SELECT COALESCE(MAX("${columnName}"), 0) as max_val 
+        FROM "${tableName}";
       `;
             const maxValResult = await pool.query(maxValQuery);
             const maxVal = parseInt(maxValResult.rows[0].max_val);
             if (!options.dryRun) {
-                await pool.query(`
-          CREATE SEQUENCE IF NOT EXISTS "${sequenceName}"
-          START WITH ${maxVal + 1}
-          INCREMENT BY 1
-          NO MINVALUE
-          NO MAXVALUE
-          CACHE 1;
+                await pool.query(`
+          CREATE SEQUENCE IF NOT EXISTS "${sequenceName}"
+          START WITH ${maxVal + 1}
+          INCREMENT BY 1
+          NO MINVALUE
+          NO MAXVALUE
+          CACHE 1;
         `);
-                await pool.query(`
-          ALTER TABLE "${tableName}" 
-          ALTER COLUMN "${columnName}" 
-          SET DEFAULT nextval('${sequenceName}'::regclass);
+                await pool.query(`
+          ALTER TABLE "${tableName}" 
+          ALTER COLUMN "${columnName}" 
+          SET DEFAULT nextval('${sequenceName}'::regclass);
         `);
                 logger.log(`✅ Sequence created and associated: ${sequenceName}`);
             }
@@ -135,13 +135,13 @@ async function findOrCreateSequence(pool, tableName, columnName) {
 }
 async function getTableInfo(pool, tableName, idField) {
     try {
-        const tableExistsQuery = `
-      SELECT EXISTS (
-        SELECT 1 
-        FROM information_schema.tables 
-        WHERE table_schema = $1 
-        AND table_name = $2
-      );
+        const tableExistsQuery = `
+      SELECT EXISTS (
+        SELECT 1 
+        FROM information_schema.tables 
+        WHERE table_schema = $1 
+        AND table_name = $2
+      );
     `;
         const tableExists = await pool.query(tableExistsQuery, [
             migrationConfig.commonSchema,
@@ -152,14 +152,14 @@ async function getTableInfo(pool, tableName, idField) {
             return null;
         }
         const sequenceName = await findOrCreateSequence(pool, tableName, idField);
-        const columnQuery = `
-      SELECT EXISTS (
-        SELECT 1 FROM pg_attrdef ad 
-        JOIN pg_attribute a ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
-        WHERE a.attrelid = $1::regclass 
-        AND a.attname = $2
-        AND (pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval%' OR $3::text IS NOT NULL)
-      ) as is_auto_increment;
+        const columnQuery = `
+      SELECT EXISTS (
+        SELECT 1 FROM pg_attrdef ad 
+        JOIN pg_attribute a ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
+        WHERE a.attrelid = $1::regclass 
+        AND a.attname = $2
+        AND (pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval%' OR $3::text IS NOT NULL)
+      ) as is_auto_increment;
     `;
         const columnResult = await pool.query(columnQuery, [
             tableName,
@@ -202,14 +202,14 @@ async function checkTableSequence(pool, tableName) {
             logger.log(`- Primary key column: ${tableInfo.primaryKeyColumn}`);
             logger.log(`- Sequence: ${tableInfo.sequenceName}`);
         }
-        const maxIdResult = await pool.query(`
-      SELECT COALESCE(MAX("${tableInfo.primaryKeyColumn}"), 0) as max_id 
-      FROM "${tableInfo.tableName}";
+        const maxIdResult = await pool.query(`
+      SELECT COALESCE(MAX("${tableInfo.primaryKeyColumn}"), 0) as max_id 
+      FROM "${tableInfo.tableName}";
     `);
         const maxId = parseInt(maxIdResult.rows[0].max_id);
-        const seqResult = await pool.query(`
-      SELECT last_value, is_called 
-      FROM "${tableInfo.sequenceName}";
+        const seqResult = await pool.query(`
+      SELECT last_value, is_called 
+      FROM "${tableInfo.sequenceName}";
     `);
         const currentSeqValue = parseInt(seqResult.rows[0].last_value);
         const isCalled = seqResult.rows[0].is_called;

package/dist/scripts/sequence-synchronizer.js

@@ -29,49 +29,49 @@ class SequenceSynchronizer {
         }
     }
     async getTables() {
-        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.pool.query(query);
         return result.rows.map((row) => row.table_name);
     }
     async synchronizeTableSequences(tableName) {
         try {
-            const columns = await this.pool.query(`
-        SELECT column_name 
-        FROM information_schema.columns 
-        WHERE table_name = $1 
-        AND column_name = 'id'
+            const columns = await this.pool.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 
+        AND column_name = 'id'
       `, [tableName]);
             if (columns.rows.length === 0) {
                 this.logger.debug(`La tabla ${tableName} no tiene columna id, omitiendo`);
                 return;
             }
             const sequenceName = `${tableName}_id_seq`;
-            const sequences = await this.pool.query(`
-        SELECT sequence_name 
-        FROM information_schema.sequences 
-        WHERE sequence_name = $1
+            const sequences = await this.pool.query(`
+        SELECT sequence_name 
+        FROM information_schema.sequences 
+        WHERE sequence_name = $1
       `, [sequenceName]);
             if (sequences.rows.length === 0) {
                 this.logger.debug(`No se encontró secuencia para la tabla ${tableName}, omitiendo`);
                 return;
             }
-            const maxResult = await this.pool.query(`
-        SELECT COALESCE(MAX(id), 0) as max_id FROM "${tableName}"
+            const maxResult = await this.pool.query(`
+        SELECT COALESCE(MAX(id), 0) as max_id FROM "${tableName}"
       `);
             const maxId = maxResult.rows[0].max_id;
-            const currValResult = await this.pool.query(`
-        SELECT last_value FROM "${sequenceName}"
+            const currValResult = await this.pool.query(`
+        SELECT last_value FROM "${sequenceName}"
       `);
             const currVal = currValResult.rows[0].last_value;
             this.logger.log(`Tabla ${tableName}: ID Máximo = ${maxId}, Valor Actual de Secuencia = ${currVal}`);
             if (currVal <= maxId) {
-                await this.pool.query(`
-          SELECT setval($1, $2, true)
+                await this.pool.query(`
+          SELECT setval($1, $2, true)
         `, [sequenceName, maxId]);
                 this.logger.log(`Actualizada secuencia para tabla ${tableName} a ${maxId}`);
             }

package/dist/scripts/sync-enum-types.js

@@ -20,12 +20,12 @@ class EnumSynchronizer {
     async synchronizeEnums() {
         try {
             this.logger.log('Starting enum synchronization');
-            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'
       `);
             this.logger.log(`Found ${sourceEnumsResult.rows.length} enum types in source database`);
             for (const enumRow of sourceEnumsResult.rows) {
@@ -44,23 +44,23 @@ class EnumSynchronizer {
     async synchronizeEnumType(enumName) {
         this.logger.log(`Synchronizing enum type: ${enumName}`);
         try {
-            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);
             this.logger.log(`Source enum ${enumName} has values: ${sourceEnumValues.join(', ')}`);
-            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) {
                 await this.createEnumType(enumName, sourceEnumValues);
@@ -77,8 +77,8 @@ class EnumSynchronizer {
         this.logger.log(`Creating enum type ${enumName} in target database`);
         try {
             const escapedValues = values.map(value => `'${value.replace(/'/g, "''")}'`).join(', ');
-            await this.targetPool.query(`
-        CREATE TYPE ${enumName} AS ENUM (${escapedValues})
+            await this.targetPool.query(`
+        CREATE TYPE ${enumName} AS ENUM (${escapedValues})
       `);
             this.logger.log(`Successfully created enum type ${enumName} with values: ${values.join(', ')}`);
         }
@@ -89,12 +89,12 @@ class EnumSynchronizer {
     async updateEnumValues(enumName, sourceValues) {
         this.logger.log(`Updating enum type ${enumName} in target database`);
         try {
-            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);
             this.logger.log(`Target enum ${enumName} has values: ${targetEnumValues.join(', ')}`);
@@ -105,8 +105,8 @@ class EnumSynchronizer {
             }
             this.logger.log(`Adding ${missingValues.length} new values to enum ${enumName}: ${missingValues.join(', ')}`);
             for (const value of missingValues) {
-                await this.targetPool.query(`
-          ALTER TYPE ${enumName} ADD VALUE '${value.replace(/'/g, "''")}'
+                await this.targetPool.query(`
+          ALTER TYPE ${enumName} ADD VALUE '${value.replace(/'/g, "''")}'
         `);
             }
             this.logger.log(`Successfully updated enum type ${enumName}`);

package/dist/scripts/sync-enum-values.js

@@ -93,13 +93,13 @@ class EnumValueSynchronizer {
             if (!fs.existsSync(logsDir)) {
                 fs.mkdirSync(logsDir, { recursive: true });
             }
-            const enumsResult = await this.pool.query(`
-        SELECT t.typname AS enum_name
-        FROM pg_type t
-        JOIN pg_namespace n ON t.typnamespace = n.oid
-        WHERE t.typtype = 'e' -- enum types
-        AND n.nspname = 'public'
-        ORDER BY t.typname
+            const enumsResult = await this.pool.query(`
+        SELECT t.typname AS enum_name
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'e' -- enum types
+        AND n.nspname = 'public'
+        ORDER BY t.typname
       `);
             this.logger.log(`Encontrados ${enumsResult.rows.length} tipos enum en la base de datos`);
             for (const [specificEnum, consolidatedEnum] of Object.entries(this.enumMappings)) {
@@ -145,33 +145,33 @@ class EnumValueSynchronizer {
         }
     }
     async enumExists(enumName) {
-        const result = await this.pool.query(`
-      SELECT 1
-      FROM pg_type t
-      JOIN pg_namespace n ON t.typnamespace = n.oid
-      WHERE t.typname = $1
-      AND t.typtype = 'e' -- enum types
-      AND n.nspname = 'public'
+        const result = await this.pool.query(`
+      SELECT 1
+      FROM pg_type t
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      WHERE t.typname = $1
+      AND t.typtype = 'e' -- enum types
+      AND n.nspname = 'public'
     `, [enumName]);
         return result.rows.length > 0;
     }
     async getEnumValues(enumName) {
-        const result = await this.pool.query(`
-      SELECT e.enumlabel
-      FROM pg_enum e
-      JOIN pg_type t ON e.enumtypid = t.oid
-      JOIN pg_namespace n ON t.typnamespace = n.oid
-      WHERE t.typname = $1
-      AND n.nspname = 'public'
-      ORDER BY e.enumsortorder
+        const result = await this.pool.query(`
+      SELECT e.enumlabel
+      FROM pg_enum e
+      JOIN pg_type t ON e.enumtypid = t.oid
+      JOIN pg_namespace n ON t.typnamespace = n.oid
+      WHERE t.typname = $1
+      AND n.nspname = 'public'
+      ORDER BY e.enumsortorder
     `, [enumName]);
         return result.rows.map((row) => row.enumlabel);
     }
     async addValueToEnum(enumName, value) {
         try {
             const escapedValue = value.replace(/'/g, "''");
-            await this.pool.query(`
-        ALTER TYPE ${enumName} ADD VALUE IF NOT EXISTS '${escapedValue}'
+            await this.pool.query(`
+        ALTER TYPE ${enumName} ADD VALUE IF NOT EXISTS '${escapedValue}'
       `);
             if (this.enumValuesCache[enumName]) {
                 if (!this.enumValuesCache[enumName].includes(value)) {
@@ -200,28 +200,28 @@ class EnumValueSynchronizer {
         }
     }
     async getSchemas() {
-        const result = await this.pool.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.pool.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);
     }
     async normalizeEnumValuesInSchema(schema) {
         this.logger.log(`Procesando valores de enum en schema: ${schema}`);
         try {
-            const enumColumnsQuery = `
-        SELECT 
-          c.table_name, 
-          c.column_name,
-          c.udt_name
-        FROM 
-          information_schema.columns c
-        WHERE 
-          c.table_schema = $1
-          AND c.data_type = 'USER-DEFINED'
-          AND c.udt_name LIKE 'enum_%'
+            const enumColumnsQuery = `
+        SELECT 
+          c.table_name, 
+          c.column_name,
+          c.udt_name
+        FROM 
+          information_schema.columns c
+        WHERE 
+          c.table_schema = $1
+          AND c.data_type = 'USER-DEFINED'
+          AND c.udt_name LIKE 'enum_%'
       `;
             const enumColumnsResult = await this.pool.query(enumColumnsQuery, [
                 schema,
@@ -254,10 +254,10 @@ class EnumValueSynchronizer {
                 this.logger.warn(`No se encontraron valores para el enum ${enumTypeName}. Omitiendo.`);
                 return;
             }
-            const currentValuesQuery = `
-        SELECT DISTINCT "${columnName}" 
-        FROM "${schema}"."${tableName}" 
-        WHERE "${columnName}" IS NOT NULL
+            const currentValuesQuery = `
+        SELECT DISTINCT "${columnName}" 
+        FROM "${schema}"."${tableName}" 
+        WHERE "${columnName}" IS NOT NULL
       `;
             const currentValuesResult = await this.pool.query(currentValuesQuery);
             const currentValues = currentValuesResult.rows.map((r) => r[columnName]);
@@ -270,10 +270,10 @@ class EnumValueSynchronizer {
             for (const invalidValue of invalidValues) {
                 const normalizedValue = this.getNormalizedEnumValue(enumTypeName, invalidValue);
                 if (normalizedValue && normalizedValue !== invalidValue) {
-                    const updateQuery = `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = $1
-            WHERE "${columnName}" = $2
+                    const updateQuery = `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = $1
+            WHERE "${columnName}" = $2
           `;
                     const result = await this.pool.query(updateQuery, [
                         normalizedValue,
@@ -285,10 +285,10 @@ class EnumValueSynchronizer {
                     }
                 }
                 else if (!normalizedValue) {
-                    const updateQuery = `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = NULL
-            WHERE "${columnName}" = $1
+                    const updateQuery = `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = NULL
+            WHERE "${columnName}" = $1
           `;
                     const result = await this.pool.query(updateQuery, [invalidValue]);
                     this.logger.log(`Establecido valor '${invalidValue}' a NULL en ${result.rowCount} filas de ${schema}.${tableName}.${columnName}`);

package/dist/scripts/truncate-database.js

@@ -32,22 +32,22 @@ class DatabaseTruncateTool {
         }
     }
     async getSchemas() {
-        const result = await this.pool.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.pool.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);
     }
     async truncateSchema(schemaName) {
         this.logger.log(`Processing schema: ${schemaName}`);
         try {
-            const tablesResult = await this.pool.query(`
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = $1
-        AND table_type = 'BASE TABLE'
+            const tablesResult = await this.pool.query(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
       `, [schemaName]);
             const tables = tablesResult.rows.map(row => row.table_name);
             if (tables.length === 0) {

package/dist/scripts/verify-migration-setup.js

@@ -56,11 +56,11 @@ class MigrationSetupVerifier {
     async verifyTenants() {
         this.logger.log('Verifying tenants in source database...');
         try {
-            const result = await this.sourcePool.query(`
-        SELECT api_key, provider_id 
-        FROM api_keys 
-        WHERE api_key != '' 
-        AND provider_id IS NOT NULL
+            const result = await this.sourcePool.query(`
+        SELECT api_key, provider_id 
+        FROM api_keys 
+        WHERE api_key != '' 
+        AND provider_id IS NOT NULL
       `);
             this.logger.log(`Found ${result.rows.length} valid tenants in source database`);
             if (result.rows.length === 0) {
@@ -80,11 +80,11 @@ class MigrationSetupVerifier {
     async verifySchemas() {
         this.logger.log('Verifying schemas in target database...');
         try {
-            const result = await this.targetPool.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.targetPool.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_%'
       `);
             this.logger.log(`Found ${result.rows.length} schemas in target database`);
             if (result.rows.length === 0) {