@zyno-io/dk-server-foundation 26.412.2137 → 26.509.2227

package/src/database/migration/MigrationResetCommand.ts

@@ -3,14 +3,11 @@ import { SQLDatabaseAdapter } from '@deepkit/sql';
 import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
 
-import { getAppConfig } from '../../app/resolver';
 import { DBProvider } from '../../app/state';
 import { createLogger } from '../../services';
 import { getDialect } from '../dialect';
-import { generateDDL } from './create/ddl-generator';
+import { generateBuilderMigrationFile } from './create/builder-regenerator';
 import { readEntitiesSchema } from './create/entity-reader';
-import { buildFileContent } from './create/file-generator';
-import { SchemaDiff } from './create/schema-model';
 import { getSourceMigrationsDir } from './helpers';
 
 @cli.controller('migration:reset')
@@ -21,13 +18,11 @@ export class MigrationResetCommand {
     constructor(private dbProvider: DBProvider) {}
 
     async execute() {
-        // Step 1: Ensure migrations directory exists
         if (!existsSync(this.migrationsDir)) {
             this.logger.info(`Creating migrations directory: ${this.migrationsDir}`);
             mkdirSync(this.migrationsDir, { recursive: true });
         }
 
-        // Step 2: Remove all .ts files from migrations directory
         const files = readdirSync(this.migrationsDir).filter(f => f.endsWith('.ts'));
         this.logger.info(`Removing ${files.length} migration file(s)`);
         for (const file of files) {
@@ -36,33 +31,22 @@ export class MigrationResetCommand {
             this.logger.info(`Removed ${file}`);
         }
 
-        // Step 3: Read entity schema from code definitions
         const db = this.dbProvider.db;
         const dialect = getDialect(db.adapter as SQLDatabaseAdapter);
-        const pgSchema = dialect === 'postgres' ? (getAppConfig().PG_SCHEMA ?? 'public') : 'public';
 
-        this.logger.info('Reading entity definitions...');
+        // Reset reads entities in the active dialect's canonical form. The generated migration uses
+        // dialect-portable builder calls, but cross-dialect parity isn't perfect — see docs.
+        this.logger.info(`Reading entity definitions (dialect: ${dialect})...`);
         const entitySchema = readEntitiesSchema(db, dialect);
         const tables = Array.from(entitySchema.values());
         this.logger.info(`Found ${tables.length} entity table(s)`);
 
-        // Step 4: Generate DDL by treating all entity tables as "added"
-        const diff: SchemaDiff = {
-            dialect,
-            pgSchema: dialect === 'postgres' ? pgSchema : undefined,
-            addedTables: tables,
-            removedTables: [],
-            modifiedTables: []
-        };
-        const statements = generateDDL(diff);
-
-        if (statements.length === 0) {
+        if (tables.length === 0) {
             this.logger.info('No tables found to generate base migration.');
             return;
         }
 
-        // Step 6: Write migration file
-        const migrationContent = buildFileContent(statements);
+        const migrationContent = generateBuilderMigrationFile(tables);
         const migrationPath = path.join(this.migrationsDir, '00000000_000000_base.ts');
 
         writeFileSync(migrationPath, migrationContent, 'utf8');

package/src/database/migration/MigrationRunCommand.ts

@@ -110,6 +110,8 @@ export class MigrationRunCommand {
 
         try {
             await migrationModule.default(this.dbProvider.db);
+            // Apply deferred schema-builder statements (FKs) and reset per-migration state.
+            await this.dbProvider.db.schema.flush();
         } catch (err) {
             this.logger.error('Migration function failed to execute', err, { file });
             throw err;

package/src/database/migration/create/MigrationCreateCommand.ts

@@ -5,11 +5,12 @@ import { getAppConfig } from '../../../app/resolver';
 import { DBProvider } from '../../../app/state';
 import { createLogger, pinoLogger } from '../../../services';
 import { getDialect } from '../../dialect';
+import { generateBuilderMigrationFromDiff } from './builder-regenerator';
 import { compareSchemas } from './comparator';
 import { readAllTableNames, readDatabaseSchema } from './db-reader';
 import { generateDDL } from './ddl-generator';
 import { readEntitiesSchema } from './entity-reader';
-import { generateMigrationFile } from './file-generator';
+import { generateMigrationFile, writeMigrationFile } from './file-generator';
 import { promptMigrationDescription, setNonInteractive } from './prompt';
 import { INTERNAL_TABLES } from './schema-model';
 
@@ -19,7 +20,10 @@ export class MigrationCreateCommand {
 
     constructor(private dbProvider: DBProvider) {}
 
-    async execute(nonInteractive: boolean & Flag<{ description: 'Skip interactive prompts' }> = false) {
+    async execute(
+        nonInteractive: boolean & Flag<{ description: 'Skip interactive prompts' }> = false,
+        raw: boolean & Flag<{ description: 'Emit raw dialect-specific SQL instead of dialect-portable schema-builder calls' }> = false
+    ) {
         if (nonInteractive) {
             setNonInteractive(true);
         }
@@ -50,10 +54,27 @@ export class MigrationCreateCommand {
             this.logger.info('Comparing schemas...');
             const diff = await compareSchemas(entitySchema, dbSchema, dialect, !nonInteractive, pgSchema);
 
-            // Step 5: Generate DDL
-            const statements = generateDDL(diff);
+            // Step 5: Decide if there are any changes
+            const hasChanges =
+                diff.addedTables.length > 0 ||
+                diff.removedTables.length > 0 ||
+                diff.modifiedTables.some(
+                    t =>
+                        t.addedColumns.length > 0 ||
+                        t.removedColumns.length > 0 ||
+                        t.modifiedColumns.length > 0 ||
+                        t.renamedColumns.length > 0 ||
+                        t.addedIndexes.length > 0 ||
+                        t.removedIndexes.length > 0 ||
+                        t.addedForeignKeys.length > 0 ||
+                        t.removedForeignKeys.length > 0 ||
+                        t.primaryKeyChanged ||
+                        t.addedEnumTypes.length > 0 ||
+                        t.removedEnumTypes.length > 0 ||
+                        t.modifiedEnumTypes.length > 0
+                );
 
-            if (statements.length === 0) {
+            if (!hasChanges) {
                 this.logger.info('No schema changes detected.');
                 return;
             }
@@ -78,16 +99,23 @@ export class MigrationCreateCommand {
                 this.logger.info(`  ${table.tableName}: ${changes.join(', ')}`);
             }
 
-            this.logger.info(`\nDDL statements (${statements.length}):`);
-            for (const stmt of statements) {
-                this.logger.info(`  ${stmt}`);
-            }
-
-            // Step 7: Prompt for description and generate file
+            // Step 7: Render migration content (builder by default; --raw for legacy SQL)
+            let filePath: string;
             pinoLogger.flush();
             await new Promise(resolve => setTimeout(resolve, 100));
             const description = await promptMigrationDescription();
-            const filePath = generateMigrationFile(statements, description);
+
+            if (raw) {
+                const statements = generateDDL(diff);
+                this.logger.info(`\nDDL statements (${statements.length}):`);
+                for (const stmt of statements) this.logger.info(`  ${stmt}`);
+                filePath = generateMigrationFile(statements, description);
+            } else {
+                const content = generateBuilderMigrationFromDiff(diff);
+                this.logger.info(`\nGenerated builder migration (${content.split('\n').length} lines)`);
+                filePath = writeMigrationFile(content, description);
+            }
+
             this.logger.info(`\nMigration file created: ${filePath}`);
         } finally {
             setNonInteractive(false);

package/src/database/migration/create/builder-regenerator.ts

@@ -0,0 +1,287 @@
+import { ColumnSchema, Dialect, ForeignKeySchema, IndexSchema, SchemaDiff, TableDiff, TableSchema } from './schema-model';
+
+const FILE_HEADER = `import { createMigration } from '@zyno-io/dk-server-foundation';\n\nexport default createMigration(async db => {\n`;
+const FILE_FOOTER = `\n});\n`;
+
+/** Render a TypeScript migration file that uses db.schema builder to recreate the given tables. */
+export function generateBuilderMigrationFile(tables: TableSchema[]): string {
+    const blocks = tables.map(t => renderTableBlock(t));
+    return `${FILE_HEADER}${blocks.join('\n\n')}${FILE_FOOTER}`;
+}
+
+/**
+ * Render a TypeScript migration file from a SchemaDiff. Used by migration:create to emit
+ * portable builder-based migrations.
+ *
+ * Order: drop removed tables → create added tables → alter modified tables. Within an alter:
+ * Schema.alter() internally orders operations dependency-safe, so emission order doesn't matter.
+ */
+export function generateBuilderMigrationFromDiff(diff: SchemaDiff): string {
+    const blocks: string[] = [];
+
+    for (const table of diff.removedTables) {
+        blocks.push(`    await db.schema.drop(${quoteStr(table.name)});`);
+    }
+
+    for (const table of diff.addedTables) {
+        blocks.push(renderTableBlock(table));
+    }
+
+    for (const tableDiff of diff.modifiedTables) {
+        const block = renderAlterBlock(tableDiff, diff.dialect);
+        if (block) blocks.push(block);
+    }
+
+    if (blocks.length === 0) {
+        return `${FILE_HEADER}    // No schema changes detected.${FILE_FOOTER}`;
+    }
+    return `${FILE_HEADER}${blocks.join('\n\n')}${FILE_FOOTER}`;
+}
+
+function renderAlterBlock(td: TableDiff, dialect: Dialect): string {
+    const preLines: string[] = [];
+    const innerLines: string[] = [];
+    const postLines: string[] = [];
+
+    // PG enum lifecycle (raw SQL — first-class builder support is post-Phase-2)
+    if (dialect === 'postgres') {
+        for (const newType of td.addedEnumTypes) {
+            preLines.push(`    await db.schema.enumType(${quoteStr(newType.typeName)}, [${newType.values.map(quoteStr).join(', ')}]);`);
+        }
+        for (const mod of td.modifiedEnumTypes) {
+            for (const value of mod.added) {
+                preLines.push(
+                    `    await db.schema.raw(${quoteStr(`ALTER TYPE "${mod.typeName}" ADD VALUE IF NOT EXISTS '${value.replace(/'/g, "''")}'`)});`
+                );
+            }
+        }
+        for (const typeName of td.removedEnumTypes) {
+            postLines.push(`    await db.schema.raw(${quoteStr(`DROP CAST IF EXISTS (text AS "${typeName}")`)});`);
+            postLines.push(`    await db.schema.raw(${quoteStr(`DROP TYPE IF EXISTS "${typeName}"`)});`);
+        }
+    }
+
+    // PK changes (drop existing first, replacement comes via .primary())
+    if (td.primaryKeyChanged && td.oldPrimaryKey && td.oldPrimaryKey.length > 0) {
+        innerLines.push(`        t.dropPrimary();`);
+    }
+
+    for (const fk of td.removedForeignKeys) innerLines.push(`        t.dropForeign(${quoteStr(fk.name)});`);
+    for (const idx of td.removedIndexes) innerLines.push(`        t.dropIndex(${quoteStr(idx.name)});`);
+    for (const col of td.removedColumns) innerLines.push(`        t.dropColumn(${quoteStr(col.name)});`);
+    for (const r of td.renamedColumns) innerLines.push(`        t.renameColumn(${quoteStr(r.from)}, ${quoteStr(r.to)});`);
+
+    const stubTable: TableSchema = { name: td.tableName, columns: [], indexes: [], foreignKeys: [] };
+
+    for (const col of td.addedColumns) {
+        let line = renderColumnLine(col, stubTable);
+        // MySQL: if we know the entity-order position, emit .after() / .first() to preserve column layout
+        if (dialect === 'mysql' && td.entityColumns) {
+            const positioning = renderPositioning(col, td.entityColumns, td.addedColumns);
+            if (positioning) line = line.replace(/;$/, `${positioning};`);
+        }
+        innerLines.push(`        ${line}`);
+    }
+    for (const mod of td.modifiedColumns) {
+        // Modified column: render as if adding, append .change()
+        const line = renderColumnLine(mod.newColumn, stubTable);
+        innerLines.push(`        ${line.replace(/;$/, '.change();')}`);
+    }
+
+    if (td.primaryKeyChanged && td.newPrimaryKey && td.newPrimaryKey.length > 0) {
+        innerLines.push(`        t.primary([${td.newPrimaryKey.map(quoteStr).join(', ')}]);`);
+    }
+
+    for (const idx of td.addedIndexes) innerLines.push(`        ${renderIndexLine(idx, stubTable)}`);
+    for (const fk of td.addedForeignKeys) innerLines.push(`        ${renderForeignKeyLine(fk, stubTable)}`);
+
+    if (innerLines.length === 0 && preLines.length === 0 && postLines.length === 0) return '';
+
+    const parts: string[] = [];
+    if (preLines.length > 0) parts.push(preLines.join('\n'));
+    if (innerLines.length > 0) {
+        parts.push(`    await db.schema.alter(${quoteStr(td.tableName)}, t => {\n${innerLines.join('\n')}\n    });`);
+    }
+    if (postLines.length > 0) parts.push(postLines.join('\n'));
+    return parts.join('\n\n');
+}
+
+function renderTableBlock(table: TableSchema): string {
+    const lines: string[] = [];
+
+    for (const col of table.columns) {
+        lines.push(`        ${renderColumnLine(col, table)}`);
+    }
+
+    // Composite PK — single-column PK is emitted via .primary() on the column line
+    const pkCols = table.columns.filter(c => c.isPrimaryKey).map(c => c.name);
+    if (pkCols.length > 1) {
+        lines.push(`        t.primary([${pkCols.map(quoteStr).join(', ')}]);`);
+    }
+
+    for (const idx of table.indexes) {
+        lines.push(`        ${renderIndexLine(idx, table)}`);
+    }
+
+    for (const fk of table.foreignKeys) {
+        lines.push(`        ${renderForeignKeyLine(fk, table)}`);
+    }
+
+    return `    await db.schema.create(${quoteStr(table.name)}, t => {\n${lines.join('\n')}\n    });`;
+}
+
+/** Emit `.after('x')` / `.first()` based on entity-order position of an added column. */
+function renderPositioning(col: ColumnSchema, entityColumns: ColumnSchema[], addedColumns: ColumnSchema[]): string {
+    const idx = entityColumns.findIndex(c => c.name === col.name);
+    if (idx < 0) return '';
+    const addedNames = new Set(addedColumns.map(c => c.name));
+    // Walk backwards to find the previous column that already exists in the DB (not in the same add batch)
+    for (let i = idx - 1; i >= 0; i--) {
+        const prev = entityColumns[i];
+        if (!addedNames.has(prev.name)) return `.after(${quoteStr(prev.name)})`;
+    }
+    return '.first()';
+}
+
+function renderColumnLine(col: ColumnSchema, table: TableSchema): string {
+    let line = `t.${pickBuilderMethod(col)}`;
+
+    // Modifier order chosen to read naturally
+    if (col.unsigned) line += '.unsigned()';
+    if (col.nullable) line += '.nullable()';
+    if (col.autoIncrement) line += '.autoIncrement()';
+
+    const pkCount = table.columns.filter(c => c.isPrimaryKey).length;
+    if (col.isPrimaryKey && pkCount === 1) line += '.primary()';
+
+    if (col.defaultExpression) {
+        line += `.defaultRaw(${quoteStr(col.defaultExpression)})`;
+    } else if (col.defaultValue !== undefined) {
+        line += `.default(${renderJsValue(col.defaultValue)})`;
+    }
+
+    if (col.onUpdateExpression) {
+        line += `.onUpdate(${quoteStr(col.onUpdateExpression)})`;
+    }
+
+    return line + ';';
+}
+
+function pickBuilderMethod(col: ColumnSchema): string {
+    const n = quoteStr(col.name);
+    switch (col.type) {
+        case 'varchar':
+            return `string(${n}, ${col.size ?? 255})`;
+        case 'char':
+            // CHAR(36) is the canonical string-form UUID storage (dksf:uuid annotation)
+            if (col.size === 36) return `uuidString(${n})`;
+            return `char(${n}, ${col.size ?? 1})`;
+        case 'text':
+            return `text(${n})`;
+        case 'tinyint':
+            // tinyint(1) is the canonical MySQL boolean storage; map back to .boolean()
+            if (col.size === 1) return `boolean(${n})`;
+            return `tinyint(${n})`;
+        case 'smallint':
+            return `smallint(${n})`;
+        case 'int':
+        case 'integer':
+            return `integer(${n})`;
+        case 'bigint':
+            return `bigInteger(${n})`;
+        case 'boolean':
+            return `boolean(${n})`;
+        case 'float':
+        case 'real':
+            return `float(${n})`;
+        case 'double':
+        case 'double precision':
+            return `double(${n})`;
+        case 'decimal':
+        case 'numeric': {
+            const args = [n];
+            if (col.size !== undefined) {
+                args.push(String(col.size));
+                if (col.scale !== undefined) args.push(String(col.scale));
+            }
+            return `decimal(${args.join(', ')})`;
+        }
+        case 'date':
+            return `date(${n})`;
+        case 'datetime':
+        case 'timestamp':
+            return `dateTime(${n})`;
+        case 'timestamptz':
+            return `timestamptz(${n})`;
+        case 'binary':
+            // BINARY(16) is the canonical UUID storage on MySQL (Deepkit's UUIDv4 annotation)
+            if (col.size === 16) return `uuid(${n})`;
+            return `binary(${n}, ${col.size ?? 16})`;
+        case 'blob':
+        case 'bytea':
+            return `blob(${n})`;
+        case 'json':
+            return `json(${n})`;
+        case 'jsonb':
+            return `jsonb(${n})`;
+        case 'uuid':
+            return `uuid(${n})`;
+        case 'point':
+            return `point(${n})`;
+        case 'enum': {
+            const values = col.enumValues ?? [];
+            const valuesArg = `[${values.map(v => quoteStr(v)).join(', ')}]`;
+            const typeName = col.enumTypeName;
+            const args = typeName ? [n, valuesArg, quoteStr(typeName)] : [n, valuesArg];
+            return `enum(${args.join(', ')})`;
+        }
+        default:
+            throw new Error(`Unsupported column type for builder regeneration: '${col.type}' (column ${col.name})`);
+    }
+}
+
+function renderIndexLine(idx: IndexSchema, table: TableSchema): string {
+    const colsArg = renderColumnsArg(idx.columns);
+
+    const suffix = idx.spatial ? 'spatial' : idx.unique ? 'unique' : 'index';
+    const expectedName = `${table.name}_${idx.columns.join('_')}_${suffix}`;
+    const nameArg = idx.name === expectedName ? '' : `, ${quoteStr(idx.name)}`;
+
+    if (idx.spatial) return `t.spatialIndex(${colsArg}${nameArg});`;
+    if (idx.unique) return `t.unique(${colsArg}${nameArg});`;
+    return `t.index(${colsArg}${nameArg});`;
+}
+
+function renderForeignKeyLine(fk: ForeignKeySchema, table: TableSchema): string {
+    const colsArg = renderColumnsArg(fk.columns);
+    const expectedName = `${table.name}_${fk.columns.join('_')}_foreign`;
+    const nameArg = fk.name === expectedName ? '' : `, ${quoteStr(fk.name)}`;
+
+    let line = `t.foreign(${colsArg}${nameArg})`;
+    if (fk.referencedColumns.length === 1) {
+        line += `.references(${quoteStr(fk.referencedColumns[0])})`;
+    } else {
+        line += `.referencesAll([${fk.referencedColumns.map(quoteStr).join(', ')}])`;
+    }
+    line += `.on(${quoteStr(fk.referencedTable)})`;
+    if (fk.onDelete && fk.onDelete.toUpperCase() !== 'RESTRICT') line += `.onDelete(${quoteStr(fk.onDelete)})`;
+    if (fk.onUpdate && fk.onUpdate.toUpperCase() !== 'RESTRICT') line += `.onUpdate(${quoteStr(fk.onUpdate)})`;
+    return line + ';';
+}
+
+function renderColumnsArg(columns: string[]): string {
+    if (columns.length === 1) return quoteStr(columns[0]);
+    return `[${columns.map(quoteStr).join(', ')}]`;
+}
+
+function quoteStr(s: string): string {
+    return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function renderJsValue(value: unknown): string {
+    if (value === null) return 'null';
+    if (typeof value === 'boolean') return value ? 'true' : 'false';
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'string') return quoteStr(value);
+    return JSON.stringify(value);
+}

package/src/database/migration/create/db-reader.ts

@@ -47,9 +47,14 @@ async function readMySQLTable(db: BaseDatabase, tableName: string): Promise<Tabl
     const columns = await readMySQLColumns(db, tableName);
     if (columns.length === 0) return null;
 
-    const indexes = await readMySQLIndexes(db, tableName);
+    const allIndexes = await readMySQLIndexes(db, tableName);
     const foreignKeys = await readMySQLForeignKeys(db, tableName);
 
+    // MySQL auto-creates an index for FK columns (same name as the FK) if no covering index exists.
+    // Filter those out so they don't show up as spurious added/removed-index diffs.
+    const fkNames = new Set(foreignKeys.map(fk => fk.name));
+    const indexes = allIndexes.filter(idx => !fkNames.has(idx.name));
+
     return { name: tableName, columns, indexes, foreignKeys };
 }
 
@@ -74,7 +79,9 @@ async function readMySQLColumns(db: BaseDatabase, tableName: string): Promise<Co
             name: row.COLUMN_NAME,
             type: normalizeMySQLType(dataType, columnType),
             size: inferMySQLSize(dataType, columnType, row.CHARACTER_MAXIMUM_LENGTH, row.NUMERIC_PRECISION),
-            scale: row.NUMERIC_SCALE != null ? Number(row.NUMERIC_SCALE) : undefined,
+            // Scale is only meaningful for decimal/numeric. MySQL reports NUMERIC_SCALE=0
+            // for ints, which would cause spurious typeChanged diffs against entity-reader output.
+            scale: (dataType === 'decimal' || dataType === 'numeric') && row.NUMERIC_SCALE != null ? Number(row.NUMERIC_SCALE) : undefined,
             unsigned: columnType.includes('unsigned'),
             nullable: row.IS_NULLABLE === 'YES',
             autoIncrement: extra.includes('auto_increment'),
@@ -230,7 +237,7 @@ async function readPostgresColumns(db: BaseDatabase, tableName: string, pgSchema
             name: row.column_name,
             type: dataType,
             size: inferPostgresSize(dataType, row.character_maximum_length, row.numeric_precision),
-            scale: row.numeric_scale != null ? Number(row.numeric_scale) : undefined,
+            scale: (dataType === 'decimal' || dataType === 'numeric') && row.numeric_scale != null ? Number(row.numeric_scale) : undefined,
             unsigned: false,
             nullable: row.is_nullable === 'YES',
             autoIncrement: isSerial,
@@ -331,12 +338,42 @@ async function readPostgresIndexes(db: BaseDatabase, tableName: string, pgSchema
 
     return rows.map(row => ({
         name: row.index_name,
-        columns: Array.isArray(row.columns) ? row.columns : [row.columns],
+        columns: parsePgTextArray(row.columns),
         unique: row.is_unique,
         spatial: false
     }));
 }
 
+/** Parse a Postgres text array literal like `{a,b,"c d"}` into a JS string array.
+ *  Accepts already-parsed arrays unchanged. */
+function parsePgTextArray(value: unknown): string[] {
+    if (Array.isArray(value)) return value as string[];
+    if (typeof value !== 'string') return [];
+    const s = value.trim();
+    if (!s.startsWith('{') || !s.endsWith('}')) return [s];
+    const inner = s.slice(1, -1);
+    if (inner === '') return [];
+    // Split on commas not inside quotes; strip surrounding double quotes if present
+    const out: string[] = [];
+    let cur = '';
+    let inQuote = false;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '"' && inner[i - 1] !== '\\') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (ch === ',' && !inQuote) {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.length > 0 || out.length > 0) out.push(cur);
+    return out;
+}
+
 async function readPostgresForeignKeys(db: BaseDatabase, tableName: string, pgSchema: string = 'public'): Promise<ForeignKeySchema[]> {
     // Use pg_constraint to correctly pair multi-column FK columns via conkey/confkey arrays
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -371,9 +408,9 @@ async function readPostgresForeignKeys(db: BaseDatabase, tableName: string, pgSc
 
     return rows.map(row => ({
         name: row.constraint_name,
-        columns: Array.isArray(row.columns) ? row.columns : [row.columns],
+        columns: parsePgTextArray(row.columns),
         referencedTable: row.referenced_table,
-        referencedColumns: Array.isArray(row.referenced_columns) ? row.referenced_columns : [row.referenced_columns],
+        referencedColumns: parsePgTextArray(row.referenced_columns),
         onDelete: (row.delete_rule || 'RESTRICT').toUpperCase(),
         onUpdate: (row.update_rule || 'RESTRICT').toUpperCase()
     }));