relq 1.0.48 → 1.0.50

package/dist/cjs/cli/commands/add.cjs

@@ -271,31 +271,33 @@ function parseSchemaFileForComparison(schemaPath) {
                 definition: tableCheckMatch[2].trim(),
             });
         }
-        const checkRegexNew = /check\.constraint\s*\(\s*['"]([^'"]+)['"]/g;
+        const checkRegexNew = /check\.constraint\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:sql`([^`]*)`|([^)]+\)))/g;
         let newCheckMatch;
         while ((newCheckMatch = checkRegexNew.exec(optionsBlock)) !== null) {
             const constraintName = newCheckMatch[1];
+            const expression = (newCheckMatch[2] || newCheckMatch[3] || '').trim();
             if (!constraints.some(c => c.name === constraintName)) {
                 constraints.push({
                     name: constraintName,
                     type: 'CHECK',
                     columns: [],
-                    definition: '',
+                    definition: expression ? `CHECK (${expression})` : '',
                 });
             }
         }
         const checkConstraintsBlockMatch = optionsBlock.match(/checkConstraints:\s*\([^)]+\)\s*=>\s*\[([^\]]+)\]/s);
         if (checkConstraintsBlockMatch) {
             const checkBlock = checkConstraintsBlockMatch[1];
-            const constraintNameMatches = checkBlock.matchAll(/check\.constraint\s*\(\s*['"]([^'"]+)['"]/g);
-            for (const match of constraintNameMatches) {
+            const constraintMatches = checkBlock.matchAll(/check\.constraint\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:sql`([^`]*)`|([^)]+\)))/g);
+            for (const match of constraintMatches) {
                 const constraintName = match[1];
+                const expression = (match[2] || match[3] || '').trim();
                 if (!constraints.some(c => c.name === constraintName)) {
                     constraints.push({
                         name: constraintName,
                         type: 'CHECK',
                         columns: [],
-                        definition: '',
+                        definition: expression ? `CHECK (${expression})` : '',
                     });
                 }
             }
@@ -867,7 +869,7 @@ async function addCommand(context) {
         const snapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
         if (currentSchema && snapshot) {
             const snapshotAsDbSchema = snapshotToDatabaseSchema(snapshot);
-            const schemaChanges = (0, schema_comparator_1.compareSchemas)(snapshotAsDbSchema, currentSchema);
+            const schemaChanges = await (0, schema_comparator_1.compareSchemas)(snapshotAsDbSchema, currentSchema);
             (0, repo_manager_1.cleanupStagedChanges)(schemaChanges, projectRoot);
             if (schemaChanges.length > 0) {
                 (0, repo_manager_1.clearUnstagedChanges)(projectRoot);

package/dist/cjs/cli/commands/import.cjs

@@ -278,7 +278,7 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
         mergedSchema = mergeSchemas(existingSnapshot, incomingSchema, replaceAll);
         const beforeSchema = snapshotToDbSchema(existingSnapshot);
         const afterSchema = snapshotToDbSchema(mergedSchema);
-        changes = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
+        changes = await (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
         spinner.stop();
         if (changes.length > 0) {
             console.log('');

package/dist/cjs/cli/commands/pull.cjs

@@ -180,7 +180,12 @@ async function pullCommand(context) {
     const merge = flags['merge'] === true;
     const autoCommit = flags['commit'] === true;
     const dryRun = flags['dry-run'] === true;
+    const theirs = flags['theirs'] === true;
+    const ours = flags['ours'] === true;
     const author = config.author || 'Relq CLI';
+    if (theirs && ours) {
+        (0, cli_utils_1.fatal)('Cannot use both --theirs and --ours', 'Choose one conflict resolution strategy.');
+    }
     const schemaPathRaw = (0, config_loader_1.getSchemaPath)(config);
     const schemaPath = path.resolve(projectRoot, schemaPathRaw);
     const includeFunctions = config.includeFunctions ?? true;
@@ -239,6 +244,14 @@ async function pullCommand(context) {
         if (remoteHead) {
             (0, repo_manager_1.setFetchHead)(remoteHead, projectRoot);
         }
+        const localCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
+        const localHashes = new Set(localCommits.map(c => c.hash));
+        const missingCommits = remoteCommits.filter(c => !localHashes.has(c.hash));
+        if (missingCommits.length > 0) {
+            for (const commit of missingCommits.reverse()) {
+                (0, repo_manager_1.saveCommit)(commit, projectRoot);
+            }
+        }
         spinner.succeed(`Fetched ${remoteCommits.length} remote commits`);
         console.log('');
         console.log(cli_utils_1.colors.bold('Introspecting database...'));
@@ -418,7 +431,16 @@ async function pullCommand(context) {
                     comment: t.comment,
                 })),
                 functions: localSnapshot.functions || [],
-                triggers: localSnapshot.triggers || [],
+                triggers: (localSnapshot.triggers || []).map(t => ({
+                    name: t.name,
+                    tableName: t.table,
+                    event: t.events?.[0] || 'UPDATE',
+                    timing: t.timing,
+                    forEach: t.forEach || 'STATEMENT',
+                    functionName: t.functionName,
+                    definition: '',
+                    isEnabled: true,
+                })),
             };
             const remoteForCompare = {
                 extensions: dbSchema.extensions || [],
@@ -460,7 +482,7 @@ async function pullCommand(context) {
                 functions: filteredFunctions || [],
                 triggers: filteredTriggers || [],
             };
-            const allChanges = (0, schema_comparator_1.compareSchemas)(localForCompare, remoteForCompare);
+            const allChanges = await (0, schema_comparator_1.compareSchemas)(localForCompare, remoteForCompare);
             const changeDisplays = [];
             for (const change of allChanges) {
                 const objType = change.objectType;
@@ -642,11 +664,44 @@ async function pullCommand(context) {
             console.log(`   ${cli_utils_1.colors.cyan(schemaPath)}`);
             console.log('');
             if (!dryRun) {
-                const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.bold('Overwrite local schema?')}`, false);
-                if (!proceed) {
-                    (0, cli_utils_1.fatal)('Operation cancelled by user', `Run ${cli_utils_1.colors.cyan('relq status')} to see current state.`);
+                if (theirs) {
+                    console.log(`${cli_utils_1.colors.green('Using --theirs:')} Overwriting local schema with database version`);
+                    console.log('');
+                }
+                else if (ours) {
+                    console.log(`${cli_utils_1.colors.yellow('Using --ours:')} Keeping local schema, syncing snapshot from database`);
+                    console.log('');
+                    (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
+                    console.log(`Snapshot synced from database`);
+                    console.log('');
+                    console.log(`hint: run ${cli_utils_1.colors.cyan("'relq add .'")} to detect differences between local schema and database`);
+                    console.log('');
+                    return;
+                }
+                else {
+                    console.log('How would you like to handle this?');
+                    console.log('');
+                    console.log(`  ${cli_utils_1.colors.cyan('--theirs')}  Use database version (overwrite local schema)`);
+                    console.log(`  ${cli_utils_1.colors.cyan('--ours')}    Keep local schema (sync snapshot only)`);
+                    console.log('');
+                    const choiceIndex = await (0, cli_utils_1.select)('Choose resolution strategy:', [
+                        'Use database version (--theirs)',
+                        'Keep local schema (--ours)',
+                        'Cancel',
+                    ]);
+                    if (choiceIndex === 2) {
+                        (0, cli_utils_1.fatal)('Operation cancelled by user', `Run ${cli_utils_1.colors.cyan('relq status')} to see current state.`);
+                    }
+                    else if (choiceIndex === 1) {
+                        (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
+                        console.log('');
+                        console.log(`Snapshot synced from database`);
+                        console.log(`hint: run ${cli_utils_1.colors.cyan("'relq add .'")} to detect differences between local schema and database`);
+                        console.log('');
+                        return;
+                    }
+                    console.log('');
                 }
-                console.log('');
             }
         }
         else if (!schemaExists) {
@@ -788,6 +843,7 @@ async function pullCommand(context) {
             }
         }
         const oldSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        const hadPreviousSnapshot = oldSnapshot !== null;
         const beforeSchema = oldSnapshot ? {
             extensions: oldSnapshot.extensions?.map(e => e.name) || [],
             enums: oldSnapshot.enums || [],
@@ -825,7 +881,16 @@ async function pullCommand(context) {
                 comment: t.comment,
             })),
             functions: oldSnapshot.functions || [],
-            triggers: oldSnapshot.triggers || [],
+            triggers: (oldSnapshot.triggers || []).map(t => ({
+                name: t.name,
+                tableName: t.table,
+                event: t.events?.[0] || 'UPDATE',
+                timing: t.timing,
+                forEach: t.forEach || 'STATEMENT',
+                functionName: t.functionName,
+                definition: '',
+                isEnabled: true,
+            })),
         } : {
             extensions: [],
             enums: [],
@@ -876,22 +941,28 @@ async function pullCommand(context) {
             functions: filteredFunctions || [],
             triggers: filteredTriggers || [],
         };
-        const schemaChanges = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
+        const schemaChanges = await (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
         (0, ast_codegen_1.copyTrackingIdsToNormalized)(parsedSchema, currentSchema);
         (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (!autoCommit) {
-            if (schemaChanges.length > 0) {
+            if (remoteHead) {
+                (0, repo_manager_1.setHead)(remoteHead, projectRoot);
+            }
+            if (hadPreviousSnapshot && schemaChanges.length > 0) {
                 (0, repo_manager_1.addUnstagedChanges)(schemaChanges, projectRoot);
                 spinner.succeed(`Detected ${schemaChanges.length} schema change(s)`);
             }
             console.log('');
             console.log(`Pull completed in ${(0, cli_utils_1.formatDuration)(duration)}`);
-            if (schemaChanges.length > 0) {
+            if (hadPreviousSnapshot && schemaChanges.length > 0) {
                 console.log('');
                 console.log(`${cli_utils_1.colors.green(String(schemaChanges.length))} change(s) ready to stage`);
                 console.log(`hint: run ${cli_utils_1.colors.cyan("'relq add .'")} to stage all changes`);
             }
+            else if (!hadPreviousSnapshot) {
+                console.log('Schema synced from database');
+            }
             else {
                 console.log('Already up to date');
             }

package/dist/cjs/cli/commands/push.cjs

@@ -328,14 +328,32 @@ async function pushCommand(context) {
                         }
                     }
                 }
+                let statementIndex = 0;
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
                     if (fs.existsSync(commitPath)) {
                         const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
                         if (enhancedCommit.sql && enhancedCommit.sql.trim()) {
-                            await client.query(enhancedCommit.sql);
+                            const statements = enhancedCommit.sql
+                                .split(';')
+                                .map(s => s.trim())
+                                .filter(s => s.length > 0);
+                            for (const stmt of statements) {
+                                statementIndex++;
+                                try {
+                                    await client.query(stmt);
+                                    statementsRun++;
+                                }
+                                catch (stmtError) {
+                                    const err = new Error(stmtError.message);
+                                    err.failedStatement = stmt;
+                                    err.commitHash = commit.hash;
+                                    err.commitMessage = commit.message;
+                                    err.statementIndex = statementIndex;
+                                    throw err;
+                                }
+                            }
                             sqlExecuted++;
-                            statementsRun += enhancedCommit.sql.split(';').filter(s => s.trim()).length;
                         }
                     }
                 }
@@ -375,23 +393,29 @@ async function pushCommand(context) {
             catch (error) {
                 try {
                     await client.query('ROLLBACK');
-                    spinner.fail('SQL execution failed - rolled back. No commits pushed.');
                 }
                 catch {
-                    spinner.fail('SQL execution failed');
                 }
                 const dbError = error?.message || String(error);
-                const enhancedError = new Error(`${dbError}\n\n` +
-                    `${cli_utils_1.colors.muted('This usually means:')}\n` +
-                    `  • The SQL statements were generated in the wrong order\n` +
-                    `  • A column/table is referenced before it's created\n` +
-                    `  • The schema is out of sync with the database\n\n` +
-                    `${cli_utils_1.colors.muted('To fix:')}\n` +
-                    `  1. Run ${cli_utils_1.colors.cyan('relq reset --hard HEAD~1')} to undo the commit\n` +
-                    `  2. Run ${cli_utils_1.colors.cyan('relq pull')} to sync with database\n` +
-                    `  3. Run ${cli_utils_1.colors.cyan('relq add')} and ${cli_utils_1.colors.cyan('relq commit')} again\n\n` +
-                    `${cli_utils_1.colors.muted('To debug, run:')} ${cli_utils_1.colors.cyan('relq push --dry-run')} ${cli_utils_1.colors.muted('to see the SQL')}`);
-                throw enhancedError;
+                let errorMsg = `${cli_utils_1.colors.red('SQL Error:')} ${dbError}\n`;
+                if (error.failedStatement) {
+                    errorMsg += `\n${cli_utils_1.colors.yellow('Failed Statement:')}\n`;
+                    errorMsg += `  ${error.failedStatement}\n`;
+                }
+                if (error.commitHash) {
+                    errorMsg += `\n${cli_utils_1.colors.yellow('In Commit:')} ${(0, repo_manager_1.shortHash)(error.commitHash)}`;
+                    if (error.commitMessage) {
+                        errorMsg += ` - ${error.commitMessage}`;
+                    }
+                    errorMsg += `\n`;
+                }
+                if (error.statementIndex) {
+                    errorMsg += `${cli_utils_1.colors.yellow('Statement #:')} ${error.statementIndex}\n`;
+                }
+                errorMsg += `\n${cli_utils_1.colors.muted('All changes rolled back. No commits pushed.')}\n`;
+                errorMsg += `\n${cli_utils_1.colors.cyan('To fix:')} Run ${cli_utils_1.colors.yellow('relq reset --hard HEAD~1')} then ${cli_utils_1.colors.yellow('relq pull')} to resync`;
+                spinner.fail('SQL execution failed');
+                throw new Error(errorMsg);
             }
             finally {
                 await client.end();
@@ -407,6 +431,20 @@ async function pushCommand(context) {
                 spinner.succeed(`Pushed ${toPush.length} commit(s) to ${(0, repo_manager_1.getConnectionLabel)(connection)}`);
             }
         }
+        if (sqlApplied && !dryRun) {
+            const latestCommitPath = path.join(projectRoot, '.relq', 'commits', `${localHead}.json`);
+            if (fs.existsSync(latestCommitPath)) {
+                const latestCommit = JSON.parse(fs.readFileSync(latestCommitPath, 'utf-8'));
+                const newSnapshot = latestCommit.schema || latestCommit.snapshot;
+                if (newSnapshot) {
+                    const snapshotPath = path.join(projectRoot, '.relq', 'snapshot.json');
+                    fs.writeFileSync(snapshotPath, JSON.stringify(newSnapshot, null, 2));
+                }
+            }
+            const { saveFileHash, hashFileContent } = await Promise.resolve().then(() => __importStar(require("../utils/repo-manager.cjs")));
+            const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+            saveFileHash(hashFileContent(schemaContent), projectRoot);
+        }
         const oldHash = remoteHead ? (0, repo_manager_1.shortHash)(remoteHead) : '(none)';
         const newHash = (0, repo_manager_1.shortHash)(localHead);
         console.log(`   ${oldHash}..${newHash}  ${cli_utils_1.colors.muted('main -> main')}`);

package/dist/cjs/cli/utils/ast-codegen.cjs

@@ -12,6 +12,7 @@ const builder_1 = require("./ast/codegen/builder.cjs");
 const type_map_1 = require("./ast/codegen/type-map.cjs");
 const defaults_1 = require("./ast/codegen/defaults.cjs");
 const constraints_1 = require("./ast/codegen/constraints.cjs");
+const pg_parser_1 = require("./pg-parser.cjs");
 let needsDefaultImport = false;
 let needsSqlImport = false;
 let trackingIdCounter = 0;
@@ -459,14 +460,14 @@ function generateTableCode(table, useCamelCase, enumNames, domainNames, columnTy
     const columnChecks = new Map();
     for (const c of table.constraints) {
         if (c.type === 'CHECK' && c.expression) {
-            for (const col of table.columns) {
-                const colPattern = new RegExp(`\\(${col.name}\\)|\\b${col.name}\\b`, 'i');
-                if (colPattern.test(c.expression)) {
+            const extractedCol = (0, pg_parser_1.extractColumnFromCheck)(c.expression);
+            if (extractedCol) {
+                const matchingCol = table.columns.find(col => col.name.toLowerCase() === extractedCol);
+                if (matchingCol) {
                     const values = (0, constraints_1.extractEnumValues)(c.expression);
                     if (values && values.length > 0) {
-                        columnChecks.set(col.name, { name: c.name, values });
+                        columnChecks.set(matchingCol.name, { name: c.name, values });
                     }
-                    break;
                 }
             }
         }

package/dist/cjs/cli/utils/ast-transformer.cjs

@@ -137,8 +137,10 @@ async function deparseNode(node) {
 }
 async function parseColumnDef(colDef) {
     const typeInfo = extractTypeName(colDef.typeName);
+    const colName = colDef.colname || '';
     const column = {
-        name: colDef.colname || '',
+        name: colName,
+        tsName: colName,
         type: typeInfo.name,
         typeParams: typeInfo.params,
         isNullable: true,
@@ -597,6 +599,7 @@ async function introspectedToParsedSchema(schema) {
         for (const c of t.columns) {
             const col = {
                 name: c.name,
+                tsName: c.name,
                 type: normalizeTypeName(c.dataType, c.udtName),
                 typeParams: extractTypeParams(c),
                 isNullable: c.isNullable,
@@ -857,6 +860,7 @@ function normalizedToParsedSchema(schema) {
                 const baseType = isArray ? c.type.slice(0, -2) : c.type;
                 return {
                     name: c.name,
+                    tsName: c.name,
                     type: baseType,
                     isNullable: c.nullable ?? true,
                     isPrimaryKey: c.primaryKey ?? false,

package/dist/cjs/cli/utils/change-tracker.cjs

@@ -296,8 +296,24 @@ function generateConstraintSQL(change) {
         return '';
     const data = change.after;
     if (change.type === 'CREATE' && data) {
+        if (!data.definition || data.definition.trim() === '') {
+            if (data.name.endsWith('_key')) {
+                return `-- Skipping ${data.name}: UNIQUE constraint already defined on column`;
+            }
+            return `-- Skipping ${data.name}: empty constraint definition`;
+        }
         return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${data.name}" ${data.definition};`;
     }
+    else if (change.type === 'ALTER' && data) {
+        const beforeData = change.before;
+        const oldName = beforeData?.name || change.objectName;
+        if (!data.definition || data.definition.trim() === '') {
+            return `-- Skipping ALTER ${data.name}: empty constraint definition`;
+        }
+        const dropSQL = `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${oldName}";`;
+        const addSQL = `ALTER TABLE "${tableName}" ADD CONSTRAINT "${data.name}" ${data.definition};`;
+        return `${dropSQL}\n${addSQL}`;
+    }
     else if (change.type === 'DROP') {
         return `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${change.objectName}";`;
     }

package/dist/cjs/cli/utils/pg-parser.cjs

@@ -1 +1,258 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSQL = parseSQL;
+exports.normalizeSQL = normalizeSQL;
+exports.compareSQLByAST = compareSQLByAST;
+exports.normalizeCheckConstraint = normalizeCheckConstraint;
+exports.compareCheckConstraintsAsync = compareCheckConstraintsAsync;
+exports.compareCheckConstraints = compareCheckConstraints;
+exports.normalizeFunctionBodyAST = normalizeFunctionBodyAST;
+exports.compareFunctionBodiesAsync = compareFunctionBodiesAsync;
+exports.compareFunctionBodies = compareFunctionBodies;
+exports.normalizeCreateTable = normalizeCreateTable;
+exports.extractColumnFromCheck = extractColumnFromCheck;
+exports.compareTriggers = compareTriggers;
+const pgsql_parser_1 = require("pgsql-parser");
+const pgsql_deparser_1 = require("pgsql-deparser");
+async function parseSQL(sql) {
+    try {
+        const result = await (0, pgsql_parser_1.parse)(sql);
+        return result;
+    }
+    catch (err) {
+        return null;
+    }
+}
+async function normalizeSQL(sql) {
+    try {
+        const ast = await (0, pgsql_parser_1.parse)(sql);
+        if (!ast || ast.length === 0)
+            return null;
+        return await (0, pgsql_deparser_1.deparse)(ast);
+    }
+    catch (err) {
+        return null;
+    }
+}
+async function compareSQLByAST(sql1, sql2) {
+    try {
+        const [ast1, ast2] = await Promise.all([(0, pgsql_parser_1.parse)(sql1), (0, pgsql_parser_1.parse)(sql2)]);
+        if (!ast1 || !ast2)
+            return false;
+        const [normalized1, normalized2] = await Promise.all([(0, pgsql_deparser_1.deparse)(ast1), (0, pgsql_deparser_1.deparse)(ast2)]);
+        return normalized1 === normalized2;
+    }
+    catch (err) {
+        return false;
+    }
+}
+async function normalizeCheckConstraint(definition) {
+    if (!definition)
+        return null;
+    let sqlToparse = definition.trim();
+    if (sqlToparse.toUpperCase().startsWith('CHECK')) {
+        sqlToparse = sqlToparse.slice(5).trim();
+    }
+    while (sqlToparse.startsWith('(') && sqlToparse.endsWith(')')) {
+        let depth = 0;
+        let innerIsSame = true;
+        for (let i = 0; i < sqlToparse.length - 1; i++) {
+            if (sqlToparse[i] === '(')
+                depth++;
+            else if (sqlToparse[i] === ')') {
+                depth--;
+                if (depth === 0 && i < sqlToparse.length - 1) {
+                    innerIsSame = false;
+                    break;
+                }
+            }
+        }
+        if (innerIsSame) {
+            sqlToparse = sqlToparse.slice(1, -1).trim();
+        }
+        else {
+            break;
+        }
+    }
+    try {
+        const wrappedSQL = `SELECT * FROM t WHERE ${sqlToparse}`;
+        const ast = await (0, pgsql_parser_1.parse)(wrappedSQL);
+        if (ast && ast.length > 0) {
+            const normalized = await (0, pgsql_deparser_1.deparse)(ast);
+            const whereIdx = normalized.toUpperCase().indexOf('WHERE ');
+            if (whereIdx >= 0) {
+                return normalized.slice(whereIdx + 6).trim();
+            }
+        }
+    }
+    catch (err) {
+    }
+    const wrapStrategies = [
+        `SELECT CASE WHEN ${sqlToparse} THEN 1 END`,
+        `CREATE TABLE t (x INT CHECK (${sqlToparse}))`,
+    ];
+    for (const wrapped of wrapStrategies) {
+        try {
+            const ast = await (0, pgsql_parser_1.parse)(wrapped);
+            if (ast && ast.length > 0) {
+                return await (0, pgsql_deparser_1.deparse)(ast);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function compareCheckConstraintsAsync(def1, def2) {
+    if (!def1 && !def2)
+        return true;
+    if (!def1 || !def2)
+        return false;
+    const [norm1, norm2] = await Promise.all([
+        normalizeCheckConstraint(def1),
+        normalizeCheckConstraint(def2)
+    ]);
+    if (norm1 && norm2) {
+        return norm1 === norm2;
+    }
+    return compareCheckValues(def1, def2);
+}
+async function compareCheckConstraints(def1, def2) {
+    if (!def1 && !def2)
+        return true;
+    if (!def1 || !def2)
+        return false;
+    const [norm1, norm2] = await Promise.all([
+        normalizeCheckConstraint(def1),
+        normalizeCheckConstraint(def2)
+    ]);
+    if (norm1 && norm2) {
+        return norm1 === norm2;
+    }
+    return compareCheckValues(def1, def2);
+}
+function compareCheckValues(def1, def2) {
+    const values1 = extractCheckValues(def1);
+    const values2 = extractCheckValues(def2);
+    if (values1.length !== values2.length)
+        return false;
+    const sorted1 = [...values1].sort();
+    const sorted2 = [...values2].sort();
+    return sorted1.every((v, i) => v === sorted2[i]);
+}
+function extractCheckValues(definition) {
+    if (!definition)
+        return [];
+    const arrayMatch = definition.match(/ARRAY\[([^\]]+)\]/i);
+    if (arrayMatch) {
+        const valuesStr = arrayMatch[1];
+        const values = valuesStr.match(/'([^']+)'/g)?.map(v => v.replace(/'/g, '').toLowerCase()) || [];
+        return values;
+    }
+    const inMatch = definition.match(/IN\s*\(([^)]+)\)/i);
+    if (inMatch) {
+        const valuesStr = inMatch[1];
+        const values = valuesStr.match(/'([^']+)'/g)?.map(v => v.replace(/'/g, '').toLowerCase()) || [];
+        return values;
+    }
+    return [];
+}
+async function normalizeFunctionBodyAST(body) {
+    if (!body)
+        return null;
+    try {
+        const asBlock = `DO $$ ${body} $$`;
+        const ast = await (0, pgsql_parser_1.parse)(asBlock);
+        if (ast && ast.length > 0) {
+            return await (0, pgsql_deparser_1.deparse)(ast);
+        }
+    }
+    catch {
+    }
+    try {
+        const ast = await (0, pgsql_parser_1.parse)(body);
+        if (ast && ast.length > 0) {
+            return await (0, pgsql_deparser_1.deparse)(ast);
+        }
+    }
+    catch {
+    }
+    try {
+        const asFunc = `CREATE FUNCTION _tmp() RETURNS void AS $$ ${body} $$ LANGUAGE plpgsql`;
+        const ast = await (0, pgsql_parser_1.parse)(asFunc);
+        if (ast && ast.length > 0) {
+            return await (0, pgsql_deparser_1.deparse)(ast);
+        }
+    }
+    catch {
+    }
+    return null;
+}
+async function compareFunctionBodiesAsync(body1, body2) {
+    if (!body1 && !body2)
+        return true;
+    if (!body1 || !body2)
+        return false;
+    const [norm1, norm2] = await Promise.all([
+        normalizeFunctionBodyAST(body1),
+        normalizeFunctionBodyAST(body2)
+    ]);
+    if (norm1 && norm2) {
+        return norm1 === norm2;
+    }
+    return normalizeString(body1) === normalizeString(body2);
+}
+async function compareFunctionBodies(body1, body2) {
+    if (!body1 && !body2)
+        return true;
+    if (!body1 || !body2)
+        return false;
+    const [norm1, norm2] = await Promise.all([
+        normalizeFunctionBodyAST(body1),
+        normalizeFunctionBodyAST(body2)
+    ]);
+    if (norm1 && norm2) {
+        return norm1 === norm2;
+    }
+    return normalizeString(body1) === normalizeString(body2);
+}
+function normalizeString(str) {
+    if (!str)
+        return '';
+    return str.trim().replace(/\s+/g, ' ').toLowerCase();
+}
+async function normalizeCreateTable(sql) {
+    try {
+        const ast = await (0, pgsql_parser_1.parse)(sql);
+        if (ast && ast.length > 0) {
+            return await (0, pgsql_deparser_1.deparse)(ast);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function extractColumnFromCheck(definition) {
+    if (!definition)
+        return null;
+    const enumMatch = definition.match(/\((\w+)\)::text\s*=\s*ANY/i);
+    if (enumMatch)
+        return enumMatch[1].toLowerCase();
+    const inMatch = definition.match(/["\(](\w+)["]\s+IN\s*\(/i);
+    if (inMatch)
+        return inMatch[1].toLowerCase();
+    const compMatch = definition.match(/\(\(?(\w+)\s*(?:>=?|<=?|<>|!=|=)/i);
+    if (compMatch)
+        return compMatch[1].toLowerCase();
+    return null;
+}
+function compareTriggers(trigger1, trigger2) {
+    if (!trigger1 || !trigger2)
+        return false;
+    return (normalizeString(trigger1.timing) === normalizeString(trigger2.timing) &&
+        normalizeString(trigger1.event) === normalizeString(trigger2.event) &&
+        normalizeString(trigger1.functionName) === normalizeString(trigger2.functionName) &&
+        normalizeString(trigger1.tableName) === normalizeString(trigger2.tableName));
+}