@javalabs/prisma-client 1.0.18 → 1.0.20

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

package/dist/scripts/data-migration/schema-utils.js

@@ -11,28 +11,28 @@ class SchemaUtils {
         const pool = dbType === "source"
             ? this.connections.sourcePool
             : this.connections.targetPool;
-        const query = `
-      SELECT 
-        c.table_name,
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.character_maximum_length,
-        c.is_nullable,
-        c.column_default,
-        tc.constraint_type
-      FROM 
-        information_schema.columns c
-      LEFT JOIN information_schema.constraint_column_usage ccu 
-        ON c.column_name = ccu.column_name 
-        AND c.table_name = ccu.table_name
-      LEFT JOIN information_schema.table_constraints tc 
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE 
-        c.table_schema = $1 
-        AND c.table_name = $2
-      ORDER BY 
-        c.ordinal_position
+        const query = `
+      SELECT 
+        c.table_name,
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.character_maximum_length,
+        c.is_nullable,
+        c.column_default,
+        tc.constraint_type
+      FROM 
+        information_schema.columns c
+      LEFT JOIN information_schema.constraint_column_usage ccu 
+        ON c.column_name = ccu.column_name 
+        AND c.table_name = ccu.table_name
+      LEFT JOIN information_schema.table_constraints tc 
+        ON ccu.constraint_name = tc.constraint_name
+      WHERE 
+        c.table_schema = $1 
+        AND c.table_name = $2
+      ORDER BY 
+        c.ordinal_position
     `;
         try {
             const result = await pool.query(query, [schema, tableName]);
@@ -45,10 +45,10 @@ class SchemaUtils {
     }
     async checkSchemaExists(schemaName) {
         try {
-            const query = `
-        SELECT schema_name 
-        FROM information_schema.schemata 
-        WHERE schema_name = $1
+            const query = `
+        SELECT schema_name 
+        FROM information_schema.schemata 
+        WHERE schema_name = $1
       `;
             const result = await this.connections.targetPool.query(query, [
                 schemaName,
@@ -62,11 +62,11 @@ class SchemaUtils {
     }
     async getTargetTables(schemaName) {
         try {
-            const query = `
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = $1
-        AND table_type = 'BASE TABLE'
+            const query = `
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
       `;
             const result = await this.connections.targetPool.query(query, [
                 schemaName,
@@ -84,13 +84,13 @@ class SchemaUtils {
     }
     async getEnumValues(schemaName, enumName) {
         try {
-            const query = `
-        SELECT e.enumlabel
-        FROM pg_type t 
-        JOIN pg_enum e ON t.oid = e.enumtypid  
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typname = $1
-        AND n.nspname = $2
+            const query = `
+        SELECT e.enumlabel
+        FROM pg_type t 
+        JOIN pg_enum e ON t.oid = e.enumtypid  
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typname = $1
+        AND n.nspname = $2
       `;
             const result = await this.connections.targetPool.query(query, [
                 enumName,
@@ -112,25 +112,25 @@ class SchemaUtils {
     async createMissingColumns(tableName, schema, columns) {
         for (const column of columns) {
             try {
-                const query = `
-          ALTER TABLE "${schema}"."${tableName}"
-          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
-          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
-          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
+                const query = `
+          ALTER TABLE "${schema}"."${tableName}"
+          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
+          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
+          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
         `;
                 await this.connections.targetPool.query(query);
                 if (column.constraint_type === "UNIQUE") {
                     const constraintName = `${tableName}_${column.column_name}_unique`;
-                    const uniqueQuery = `
-            DO $$
-            BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
-              ) THEN
-                ALTER TABLE "${schema}"."${tableName}"
-                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
-              END IF;
-            END $$;
+                    const uniqueQuery = `
+            DO $$
+            BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
+              ) THEN
+                ALTER TABLE "${schema}"."${tableName}"
+                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
+              END IF;
+            END $$;
           `;
                     await this.connections.targetPool.query(uniqueQuery);
                 }
@@ -146,10 +146,10 @@ class SchemaUtils {
             await this.connections.targetPool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
             const tables = await this.getPublicTables();
             for (const table of tables) {
-                await this.connections.targetPool.query(`
-          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
-            LIKE public."${table}" INCLUDING ALL
-          );
+                await this.connections.targetPool.query(`
+          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
+            LIKE public."${table}" INCLUDING ALL
+          );
         `);
             }
             this.logger.log(`Created schema ${schemaName} with all tables`);
@@ -160,27 +160,27 @@ class SchemaUtils {
         }
     }
     async getPublicTables() {
-        const result = await this.connections.targetPool.query(`
-      SELECT tablename 
-      FROM pg_tables 
-      WHERE schemaname = 'public'
+        const result = await this.connections.targetPool.query(`
+      SELECT tablename 
+      FROM pg_tables 
+      WHERE schemaname = 'public'
     `);
         return result.rows.map((row) => row.tablename);
     }
     async getTableColumns(schema, table) {
-        const query = `
-      SELECT 
-        column_name,
-        data_type,
-        is_nullable,
-        column_default,
-        character_maximum_length,
-        numeric_precision,
-        numeric_scale
-      FROM information_schema.columns
-      WHERE table_schema = $1
-        AND table_name = $2
-      ORDER BY ordinal_position;
+        const query = `
+      SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale
+      FROM information_schema.columns
+      WHERE table_schema = $1
+        AND table_name = $2
+      ORDER BY ordinal_position;
     `;
         try {
             const result = await this.connections.sourcePool.query(query, [

package/dist/scripts/data-migration/typecast-manager.js

@@ -56,10 +56,10 @@ class TypecastManager {
         return tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.get(columnName);
     }
     async loadTableSchema(tableName) {
-        const columns = await this.prisma.$queryRawUnsafe(`
-      SELECT column_name, data_type, udt_name, is_nullable
-      FROM information_schema.columns
-      WHERE table_name = '${tableName}'
+        const columns = await this.prisma.$queryRawUnsafe(`
+      SELECT column_name, data_type, udt_name, is_nullable
+      FROM information_schema.columns
+      WHERE table_name = '${tableName}'
     `);
         const tableSchema = new Map();
         for (const column of columns) {

package/dist/scripts/database-initializer.js

@@ -14,11 +14,11 @@ class DatabaseInitializer {
             const { Pool } = await Promise.resolve().then(() => require("pg"));
             const pool = new Pool({ connectionString: this.databaseUrl });
             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'
         `);
                 const tableCount = parseInt(result.rows[0].count);
                 if (tableCount === 0) {

package/dist/scripts/drop-database.js

@@ -41,11 +41,11 @@ class DatabaseDropTool {
     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");
         }