linkgress-orm 0.4.9 → 0.4.11

package/dist/migration/db-schema-manager.js

@@ -46,6 +46,7 @@ class DbSchemaManager {
         this.schemaRegistry = schemaRegistry;
         this.rl = null;
         this.logQueries = options?.logQueries ?? false;
+        this.logger = options?.logger ?? console.log;
         this.postMigrationHook = options?.postMigrationHook;
         this.sequenceRegistry = options?.sequenceRegistry ?? new Map();
     }
@@ -90,16 +91,16 @@ class DbSchemaManager {
         if (schemas.size === 0)
             return;
         if (this.logQueries) {
-            console.log('Creating schemas...\n');
+            this.logger('Creating schemas...\n');
         }
         for (const schemaName of schemas) {
             const createSchemaSQL = `CREATE SCHEMA IF NOT EXISTS "${schemaName}"`;
             if (this.logQueries) {
-                console.log(`  Creating schema "${schemaName}"...`);
+                this.logger(`  Creating schema "${schemaName}"...`);
             }
             await this.client.query(createSchemaSQL);
             if (this.logQueries) {
-                console.log(`  ✓ Schema "${schemaName}" created\n`);
+                this.logger(`  ✓ Schema "${schemaName}" created\n`);
             }
         }
     }
@@ -111,7 +112,7 @@ class DbSchemaManager {
         if (enums.size === 0)
             return;
         if (this.logQueries) {
-            console.log('Creating ENUM types...\n');
+            this.logger('Creating ENUM types...\n');
         }
         for (const [enumName, enumDef] of enums.entries()) {
             // Check if enum already exists
@@ -126,15 +127,15 @@ class DbSchemaManager {
                 const values = enumDef.values.map(v => `'${v}'`).join(', ');
                 const createEnumSQL = `CREATE TYPE "${enumName}" AS ENUM (${values})`;
                 if (this.logQueries) {
-                    console.log(`  Creating ENUM type "${enumName}"...`);
+                    this.logger(`  Creating ENUM type "${enumName}"...`);
                 }
                 await this.client.query(createEnumSQL);
                 if (this.logQueries) {
-                    console.log(`  ✓ ENUM type "${enumName}" created\n`);
+                    this.logger(`  ✓ ENUM type "${enumName}" created\n`);
                 }
             }
             else if (this.logQueries) {
-                console.log(`  ENUM type "${enumName}" already exists, skipping\n`);
+                this.logger(`  ENUM type "${enumName}" already exists, skipping\n`);
             }
         }
     }
@@ -145,7 +146,7 @@ class DbSchemaManager {
         if (this.sequenceRegistry.size === 0)
             return;
         if (this.logQueries) {
-            console.log('Creating sequences...\n');
+            this.logger('Creating sequences...\n');
         }
         for (const [_, config] of this.sequenceRegistry.entries()) {
             const qualifiedName = config.schema
@@ -190,15 +191,15 @@ class DbSchemaManager {
                     createSQL += ` ${options.join(' ')}`;
                 }
                 if (this.logQueries) {
-                    console.log(`  Creating sequence ${qualifiedName}...`);
+                    this.logger(`  Creating sequence ${qualifiedName}...`);
                 }
                 await this.client.query(createSQL);
                 if (this.logQueries) {
-                    console.log(`  ✓ Sequence ${qualifiedName} created\n`);
+                    this.logger(`  ✓ Sequence ${qualifiedName} created\n`);
                 }
             }
             else if (this.logQueries) {
-                console.log(`  Sequence ${qualifiedName} already exists, skipping\n`);
+                this.logger(`  Sequence ${qualifiedName} already exists, skipping\n`);
             }
         }
     }
@@ -294,11 +295,11 @@ class DbSchemaManager {
       )
     `;
         if (this.logQueries) {
-            console.log(`  Creating table ${qualifiedTableName}...`);
+            this.logger(`  Creating table ${qualifiedTableName}...`);
         }
         await this.client.query(createTableSQL);
         if (this.logQueries) {
-            console.log(`  ✓ Table ${qualifiedTableName} created\n`);
+            this.logger(`  ✓ Table ${qualifiedTableName} created\n`);
         }
     }
     /**
@@ -322,11 +323,11 @@ class DbSchemaManager {
                 alterSQL += ` ON UPDATE ${fk.onUpdate.toUpperCase()}`;
             }
             if (this.logQueries) {
-                console.log(`  Adding foreign key ${fk.name} to ${qualifiedTableName}...`);
+                this.logger(`  Adding foreign key ${fk.name} to ${qualifiedTableName}...`);
             }
             await this.client.query(alterSQL);
             if (this.logQueries) {
-                console.log(`  ✓ Foreign key ${fk.name} added\n`);
+                this.logger(`  ✓ Foreign key ${fk.name} added\n`);
             }
         }
         // Fallback: Add foreign key constraints from column references (for backward compatibility)
@@ -337,11 +338,11 @@ class DbSchemaManager {
                 const fkName = `fk_${tableName}_${config.name}`;
                 const alterSQL = `ALTER TABLE ${qualifiedTableName} ADD CONSTRAINT "${fkName}" FOREIGN KEY ("${config.name}") REFERENCES "${config.references.table}"("${config.references.column}")`;
                 if (this.logQueries) {
-                    console.log(`  Adding foreign key ${fkName} to ${qualifiedTableName}...`);
+                    this.logger(`  Adding foreign key ${fkName} to ${qualifiedTableName}...`);
                 }
                 await this.client.query(alterSQL);
                 if (this.logQueries) {
-                    console.log(`  ✓ Foreign key ${fkName} added\n`);
+                    this.logger(`  ✓ Foreign key ${fkName} added\n`);
                 }
             }
         }
@@ -407,7 +408,7 @@ class DbSchemaManager {
         // Fall back to original order and let the database handle it
         if (sorted.length !== tables.length) {
             if (this.logQueries) {
-                console.log('Warning: Circular dependency detected in table foreign keys, using original order\n');
+                this.logger('Warning: Circular dependency detected in table foreign keys, using original order\n', 'warn');
             }
             return tables;
         }
@@ -418,7 +419,7 @@ class DbSchemaManager {
      */
     async ensureCreated() {
         if (this.logQueries) {
-            console.log('Creating database schema...\n');
+            this.logger('Creating database schema...\n');
         }
         // Create schemas first
         await this.createSchemas();
@@ -436,16 +437,16 @@ class DbSchemaManager {
             await this.createIndexes(tableName, tableSchema);
         }
         if (this.logQueries) {
-            console.log('✓ Database schema created successfully\n');
+            this.logger('✓ Database schema created successfully\n');
         }
         // Execute post-migration hook if provided
         if (this.postMigrationHook) {
             if (this.logQueries) {
-                console.log('Executing post-migration scripts...\n');
+                this.logger('Executing post-migration scripts...\n');
             }
             await this.postMigrationHook(this.client);
             if (this.logQueries) {
-                console.log('✓ Post-migration scripts completed\n');
+                this.logger('✓ Post-migration scripts completed\n');
             }
         }
     }
@@ -463,46 +464,46 @@ class DbSchemaManager {
      */
     async ensureDeleted() {
         if (this.logQueries) {
-            console.log('Dropping database schema...\n');
+            this.logger('Dropping database schema...\n');
         }
         for (const [tableName, tableSchema] of this.schemaRegistry.entries()) {
             const qualifiedTableName = this.getQualifiedTableName(tableName, tableSchema.schema);
             if (this.logQueries) {
-                console.log(`  Dropping table ${qualifiedTableName}...`);
+                this.logger(`  Dropping table ${qualifiedTableName}...`);
             }
             await this.client.query(`DROP TABLE IF EXISTS ${qualifiedTableName} CASCADE`);
             if (this.logQueries) {
-                console.log(`  ✓ Table ${qualifiedTableName} dropped\n`);
+                this.logger(`  ✓ Table ${qualifiedTableName} dropped\n`);
             }
         }
         // Drop sequences
         if (this.sequenceRegistry.size > 0 && this.logQueries) {
-            console.log('Dropping sequences...\n');
+            this.logger('Dropping sequences...\n');
         }
         for (const [_, config] of this.sequenceRegistry.entries()) {
             const qualifiedName = config.schema
                 ? `"${config.schema}"."${config.name}"`
                 : `"${config.name}"`;
             if (this.logQueries) {
-                console.log(`  Dropping sequence ${qualifiedName}...`);
+                this.logger(`  Dropping sequence ${qualifiedName}...`);
             }
             await this.client.query(`DROP SEQUENCE IF EXISTS ${qualifiedName} CASCADE`);
             if (this.logQueries) {
-                console.log(`  ✓ Sequence ${qualifiedName} dropped\n`);
+                this.logger(`  ✓ Sequence ${qualifiedName} dropped\n`);
             }
         }
         // Drop enum types
         const enums = enum_builder_1.EnumTypeRegistry.getAll();
         if (enums.size > 0 && this.logQueries) {
-            console.log('Dropping ENUM types...\n');
+            this.logger('Dropping ENUM types...\n');
         }
         for (const [enumName, _] of enums.entries()) {
             if (this.logQueries) {
-                console.log(`  Dropping ENUM type "${enumName}"...`);
+                this.logger(`  Dropping ENUM type "${enumName}"...`);
             }
             await this.client.query(`DROP TYPE IF EXISTS "${enumName}" CASCADE`);
             if (this.logQueries) {
-                console.log(`  ✓ ENUM type "${enumName}" dropped\n`);
+                this.logger(`  ✓ ENUM type "${enumName}" dropped\n`);
             }
         }
         // Drop schemas (note: CASCADE will drop all objects in the schema)
@@ -513,26 +514,26 @@ class DbSchemaManager {
             }
         }
         if (schemas.size > 0 && this.logQueries) {
-            console.log('Dropping schemas...\n');
+            this.logger('Dropping schemas...\n');
         }
         for (const schemaName of schemas) {
             if (this.logQueries) {
-                console.log(`  Dropping schema "${schemaName}"...`);
+                this.logger(`  Dropping schema "${schemaName}"...`);
             }
             await this.client.query(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`);
             if (this.logQueries) {
-                console.log(`  ✓ Schema "${schemaName}" dropped\n`);
+                this.logger(`  ✓ Schema "${schemaName}" dropped\n`);
             }
         }
         if (this.logQueries) {
-            console.log('✓ Database schema dropped successfully\n');
+            this.logger('✓ Database schema dropped successfully\n');
         }
     }
     /**
      * Analyze differences between current DB and model schema
      */
     async analyze() {
-        console.log('🔍 Analyzing database schema...\n');
+        this.logger('🔍 Analyzing database schema...\n');
         const operations = [];
         // Check schemas
         const modelSchemas = new Set();
@@ -662,7 +663,7 @@ class DbSchemaManager {
         try {
             const operations = await this.analyze();
             if (operations.length === 0) {
-                console.log('✓ Database schema is already in sync with model\n');
+                this.logger('✓ Database schema is already in sync with model\n');
                 return;
             }
             // Separate operations into phases:
@@ -744,43 +745,43 @@ class DbSchemaManager {
                 }
             }
             const totalOps = phase1Ops.length + phase2Ops.length + phase3Ops.length;
-            console.log(`📋 Found ${totalOps} operations to perform:\n`);
+            this.logger(`📋 Found ${totalOps} operations to perform:\n`);
             // Show all operations
             let opNum = 1;
             for (const op of [...phase1Ops, ...phase2Ops, ...phase3Ops]) {
-                console.log(`${opNum++}. ${this.describeOperation(op)}`);
+                this.logger(`${opNum++}. ${this.describeOperation(op)}`);
             }
-            console.log('');
+            this.logger('');
             // Phase 1: Create schemas, enums, tables (without FKs), column changes
             if (phase1Ops.length > 0) {
-                console.log('📦 Phase 1: Creating schemas, enums, and tables...\n');
+                this.logger('📦 Phase 1: Creating schemas, enums, and tables...\n');
                 for (const operation of phase1Ops) {
                     await this.executeOperation(operation, { skipForeignKeys: tablesToCreate.has(operation.tableName) });
                 }
             }
             // Phase 2: Add foreign key constraints
             if (phase2Ops.length > 0) {
-                console.log('🔗 Phase 2: Adding foreign key constraints...\n');
+                this.logger('🔗 Phase 2: Adding foreign key constraints...\n');
                 for (const operation of phase2Ops) {
                     await this.executeOperation(operation);
                 }
             }
             // Phase 3: Create indexes and other operations
             if (phase3Ops.length > 0) {
-                console.log('📇 Phase 3: Creating indexes...\n');
+                this.logger('📇 Phase 3: Creating indexes...\n');
                 for (const operation of phase3Ops) {
                     await this.executeOperation(operation);
                 }
             }
-            console.log('\n✓ Migration completed successfully\n');
+            this.logger('\n✓ Migration completed successfully\n');
             // Execute post-migration hook if provided
             if (this.postMigrationHook) {
                 if (this.logQueries) {
-                    console.log('Executing post-migration scripts...\n');
+                    this.logger('Executing post-migration scripts...\n');
                 }
                 await this.postMigrationHook(this.client);
                 if (this.logQueries) {
-                    console.log('✓ Post-migration scripts completed\n');
+                    this.logger('✓ Post-migration scripts completed\n');
                 }
             }
         }
@@ -810,7 +811,7 @@ class DbSchemaManager {
                     await this.executeDropTable(operation.tableName);
                 }
                 else {
-                    console.log(`  ⊘ Skipped dropping table "${operation.tableName}"\n`);
+                    this.logger(`  ⊘ Skipped dropping table "${operation.tableName}"\n`, 'warn');
                 }
                 break;
             case 'add_column':
@@ -821,7 +822,7 @@ class DbSchemaManager {
                     await this.executeDropColumn(operation.tableName, operation.columnName, operation.schema);
                 }
                 else {
-                    console.log(`  ⊘ Skipped dropping column "${operation.tableName}"."${operation.columnName}"\n`);
+                    this.logger(`  ⊘ Skipped dropping column "${operation.tableName}"."${operation.columnName}"\n`, 'warn');
                 }
                 break;
             case 'alter_column':
@@ -835,7 +836,7 @@ class DbSchemaManager {
                     await this.executeDropIndex(operation.indexName, operation.schema);
                 }
                 else {
-                    console.log(`  ⊘ Skipped dropping index "${operation.indexName}"\n`);
+                    this.logger(`  ⊘ Skipped dropping index "${operation.indexName}"\n`, 'warn');
                 }
                 break;
             case 'create_foreign_key':
@@ -846,7 +847,7 @@ class DbSchemaManager {
                     await this.executeDropForeignKey(operation.tableName, operation.constraintName, operation.schema);
                 }
                 else {
-                    console.log(`  ⊘ Skipped dropping foreign key "${operation.constraintName}"\n`);
+                    this.logger(`  ⊘ Skipped dropping foreign key "${operation.constraintName}"\n`, 'warn');
                 }
                 break;
         }
@@ -855,18 +856,18 @@ class DbSchemaManager {
      * Execute create schema
      */
     async executeCreateSchema(schemaName) {
-        console.log(`  Creating schema "${schemaName}"...`);
+        this.logger(`  Creating schema "${schemaName}"...`);
         await this.client.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
-        console.log(`  ✓ Schema "${schemaName}" created\n`);
+        this.logger(`  ✓ Schema "${schemaName}" created\n`);
     }
     /**
      * Execute create enum
      */
     async executeCreateEnum(enumName, values) {
-        console.log(`  Creating ENUM type "${enumName}"...`);
+        this.logger(`  Creating ENUM type "${enumName}"...`);
         const valueList = values.map(v => `'${v}'`).join(', ');
         await this.client.query(`CREATE TYPE "${enumName}" AS ENUM (${valueList})`);
-        console.log(`  ✓ ENUM type "${enumName}" created\n`);
+        this.logger(`  ✓ ENUM type "${enumName}" created\n`);
     }
     /**
      * Execute create sequence
@@ -875,7 +876,7 @@ class DbSchemaManager {
         const qualifiedName = config.schema
             ? `"${config.schema}"."${config.name}"`
             : `"${config.name}"`;
-        console.log(`  Creating sequence ${qualifiedName}...`);
+        this.logger(`  Creating sequence ${qualifiedName}...`);
         // Build CREATE SEQUENCE statement
         let createSQL = `CREATE SEQUENCE ${qualifiedName}`;
         const options = [];
@@ -901,22 +902,22 @@ class DbSchemaManager {
             createSQL += ` ${options.join(' ')}`;
         }
         await this.client.query(createSQL);
-        console.log(`  ✓ Sequence ${qualifiedName} created\n`);
+        this.logger(`  ✓ Sequence ${qualifiedName} created\n`);
     }
     /**
      * Execute drop table
      */
     async executeDropTable(tableName) {
-        console.log(`  Dropping table "${tableName}"...`);
+        this.logger(`  Dropping table "${tableName}"...`);
         await this.client.query(`DROP TABLE "${tableName}" CASCADE`);
-        console.log(`  ✓ Table "${tableName}" dropped\n`);
+        this.logger(`  ✓ Table "${tableName}" dropped\n`);
     }
     /**
      * Execute add column
      */
     async executeAddColumn(tableName, columnName, config, schema) {
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
-        console.log(`  Adding column ${qualifiedTableName}."${columnName}"...`);
+        this.logger(`  Adding column ${qualifiedTableName}."${columnName}"...`);
         let def = `${config.type}`;
         if (config.length) {
             def += `(${config.length})`;
@@ -938,25 +939,25 @@ class DbSchemaManager {
         }
         const sql = `ALTER TABLE ${qualifiedTableName} ADD COLUMN "${columnName}" ${def}`;
         await this.client.query(sql);
-        console.log(`  ✓ Column ${qualifiedTableName}."${columnName}" added\n`);
+        this.logger(`  ✓ Column ${qualifiedTableName}."${columnName}" added\n`);
     }
     /**
      * Execute drop column
      */
     async executeDropColumn(tableName, columnName, schema) {
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
-        console.log(`  Dropping column ${qualifiedTableName}."${columnName}"...`);
+        this.logger(`  Dropping column ${qualifiedTableName}."${columnName}"...`);
         await this.client.query(`ALTER TABLE ${qualifiedTableName} DROP COLUMN "${columnName}"`);
-        console.log(`  ✓ Column ${qualifiedTableName}."${columnName}" dropped\n`);
+        this.logger(`  ✓ Column ${qualifiedTableName}."${columnName}" dropped\n`);
     }
     /**
      * Execute alter column
      */
     async executeAlterColumn(tableName, columnName, from, to, schema) {
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
-        console.log(`  Altering column ${qualifiedTableName}."${columnName}"...`);
-        console.log(`    From: ${this.describeDbColumn(from)}`);
-        console.log(`    To:   ${this.describeModelColumn(to)}`);
+        this.logger(`  Altering column ${qualifiedTableName}."${columnName}"...`);
+        this.logger(`    From: ${this.describeDbColumn(from)}`);
+        this.logger(`    To:   ${this.describeModelColumn(to)}`);
         // PostgreSQL requires separate ALTER COLUMN commands for different changes
         // Change type if needed - resolve ARRAY/USER-DEFINED via udt_name before normalizing
         const fromType = this.normalizeType(this.resolveDbType(from));
@@ -964,7 +965,7 @@ class DbSchemaManager {
         if (fromType !== toType) {
             const typeDef = this.buildTypeDefinition(to);
             await this.client.query(`ALTER TABLE ${qualifiedTableName} ALTER COLUMN "${columnName}" TYPE ${typeDef} USING "${columnName}"::${typeDef}`);
-            console.log(`    ✓ Type changed from ${fromType} to ${toType}`);
+            this.logger(`    ✓ Type changed from ${fromType} to ${toType}`);
         }
         // Change nullability if needed
         const fromNullable = from.is_nullable === 'YES';
@@ -972,11 +973,11 @@ class DbSchemaManager {
         if (fromNullable !== toNullable) {
             if (toNullable) {
                 await this.client.query(`ALTER TABLE ${qualifiedTableName} ALTER COLUMN "${columnName}" DROP NOT NULL`);
-                console.log(`    ✓ Nullability changed to NULLABLE`);
+                this.logger(`    ✓ Nullability changed to NULLABLE`);
             }
             else {
                 await this.client.query(`ALTER TABLE ${qualifiedTableName} ALTER COLUMN "${columnName}" SET NOT NULL`);
-                console.log(`    ✓ Nullability changed to NOT NULL`);
+                this.logger(`    ✓ Nullability changed to NOT NULL`);
             }
         }
         // Change default if needed
@@ -985,14 +986,14 @@ class DbSchemaManager {
         if (fromDefault !== toDefault) {
             if (toDefault !== null) {
                 await this.client.query(`ALTER TABLE ${qualifiedTableName} ALTER COLUMN "${columnName}" SET DEFAULT ${toDefault}`);
-                console.log(`    ✓ Default changed to ${toDefault}`);
+                this.logger(`    ✓ Default changed to ${toDefault}`);
             }
             else {
                 await this.client.query(`ALTER TABLE ${qualifiedTableName} ALTER COLUMN "${columnName}" DROP DEFAULT`);
-                console.log(`    ✓ Default removed`);
+                this.logger(`    ✓ Default removed`);
             }
         }
-        console.log(`  ✓ Column ${qualifiedTableName}."${columnName}" altered\n`);
+        this.logger(`  ✓ Column ${qualifiedTableName}."${columnName}" altered\n`);
     }
     /**
      * Execute create index
@@ -1000,20 +1001,20 @@ class DbSchemaManager {
     async executeCreateIndex(tableName, indexName, columns, isUnique, schema) {
         const uniqueStr = isUnique ? 'UNIQUE ' : '';
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
-        console.log(`  Creating ${uniqueStr}index "${indexName}" on ${qualifiedTableName}...`);
+        this.logger(`  Creating ${uniqueStr}index "${indexName}" on ${qualifiedTableName}...`);
         const columnList = columns.map(col => `"${col}"`).join(', ');
         const sql = `CREATE ${uniqueStr}INDEX IF NOT EXISTS "${indexName}" ON ${qualifiedTableName} (${columnList})`;
         await this.client.query(sql);
-        console.log(`  ✓ ${uniqueStr}Index "${indexName}" created\n`);
+        this.logger(`  ✓ ${uniqueStr}Index "${indexName}" created\n`);
     }
     /**
      * Execute drop index
      */
     async executeDropIndex(indexName, schema) {
         const qualifiedIndexName = schema ? `"${schema}"."${indexName}"` : `"${indexName}"`;
-        console.log(`  Dropping index ${qualifiedIndexName}...`);
+        this.logger(`  Dropping index ${qualifiedIndexName}...`);
         await this.client.query(`DROP INDEX ${qualifiedIndexName}`);
-        console.log(`  ✓ Index ${qualifiedIndexName} dropped\n`);
+        this.logger(`  ✓ Index ${qualifiedIndexName} dropped\n`);
     }
     /**
      * Execute create foreign key
@@ -1022,7 +1023,7 @@ class DbSchemaManager {
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
         const referencedTableSchema = this.schemaRegistry?.get(constraint.referencedTable);
         const qualifiedReferencedTable = this.getQualifiedTableName(constraint.referencedTable, referencedTableSchema?.schema);
-        console.log(`  Creating foreign key constraint "${constraint.name}" on ${qualifiedTableName}...`);
+        this.logger(`  Creating foreign key constraint "${constraint.name}" on ${qualifiedTableName}...`);
         const columnList = constraint.columns.map((col) => `"${col}"`).join(', ');
         const refColumnList = constraint.referencedColumns.map((col) => `"${col}"`).join(', ');
         let sql = `ALTER TABLE ${qualifiedTableName} ADD CONSTRAINT "${constraint.name}" `;
@@ -1035,16 +1036,16 @@ class DbSchemaManager {
             sql += ` ON UPDATE ${constraint.onUpdate.toUpperCase()}`;
         }
         await this.client.query(sql);
-        console.log(`  ✓ Foreign key constraint "${constraint.name}" created\n`);
+        this.logger(`  ✓ Foreign key constraint "${constraint.name}" created\n`);
     }
     /**
      * Execute drop foreign key
      */
     async executeDropForeignKey(tableName, constraintName, schema) {
         const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
-        console.log(`  Dropping foreign key constraint "${constraintName}" from ${qualifiedTableName}...`);
+        this.logger(`  Dropping foreign key constraint "${constraintName}" from ${qualifiedTableName}...`);
         await this.client.query(`ALTER TABLE ${qualifiedTableName} DROP CONSTRAINT "${constraintName}"`);
-        console.log(`  ✓ Foreign key constraint "${constraintName}" dropped\n`);
+        this.logger(`  ✓ Foreign key constraint "${constraintName}" dropped\n`);
     }
     /**
      * Get all existing tables in the database across all schemas used by the model
@@ -1376,7 +1377,7 @@ class DbSchemaManager {
     async confirm(question) {
         // If not running in a TTY (like in tests), default to NO for destructive operations
         if (!process.stdin.isTTY) {
-            console.log(`\n⚠️  ${question} [y/N]: N (non-interactive mode, defaulting to NO)`);
+            this.logger(`\n⚠️  ${question} [y/N]: N (non-interactive mode, defaulting to NO)`, 'warn');
             return false;
         }
         const rl = this.getReadlineInterface();