relq 1.0.41 → 1.0.42

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

@@ -149,7 +149,7 @@ function parseSchemaFileForComparison(schemaPath) {
                 else {
                     const strDefaultMatch = colDef.match(/\.default\(\s*(['"])([^'"]*)\1\s*\)/);
                     if (strDefaultMatch) {
-                        defaultValue = strDefaultMatch[2];
+                        defaultValue = `'${strDefaultMatch[2]}'`;
                     }
                     else {
                         const boolDefaultMatch = colDef.match(/\.default\(\s*(true|false)\s*\)/);
@@ -178,17 +178,19 @@ function parseSchemaFileForComparison(schemaPath) {
                     }
                 }
                 if (colDef.includes('.check(')) {
-                    const checkValuesMatch = colDef.match(/\.check\(([^)]+)\)/);
-                    if (checkValuesMatch) {
-                        const valuesStr = checkValuesMatch[1];
+                    const checkMatch = colDef.match(/\.check\(\s*['"]([^'"]+)['"]\s*,\s*\[([^\]]+)\]\s*\)/);
+                    if (checkMatch) {
+                        const constraintName = checkMatch[1];
+                        const valuesStr = checkMatch[2];
                         const values = valuesStr.match(/['"]([^'"]+)['"]/g)?.map(v => v.replace(/['"]/g, '')) || [];
                         if (values.length > 0) {
-                            const constraintName = `${tableName}_${dbColName}_check`;
+                            const valuesQuoted = values.map(v => `'${v}'`).join(', ');
+                            const definition = `CHECK ("${dbColName}" IN (${valuesQuoted}))`;
                             constraints.push({
                                 name: constraintName,
                                 type: 'CHECK',
                                 columns: [dbColName],
-                                definition: '',
+                                definition,
                             });
                         }
                     }
@@ -322,7 +324,6 @@ function parseSchemaFileForComparison(schemaPath) {
         for (const col of columns) {
             if (col.isUnique && !col.isPrimaryKey) {
                 const uniqueName = `${tableName}_${col.name}_key`;
-                col.isUnique = false;
                 if (!constraints.some(c => c.name === uniqueName)) {
                     constraints.push({
                         name: uniqueName,
@@ -331,6 +332,7 @@ function parseSchemaFileForComparison(schemaPath) {
                         definition: '',
                     });
                 }
+                col.isUnique = false;
             }
         }
         const uniqueConstraintRegex = /constraint\.unique\s*\(\s*\{\s*name:\s*['"]([^'"]+)['"]\s*,\s*columns:\s*\[([^\]]+)\]/g;
@@ -441,7 +443,7 @@ function parseSchemaFileForComparison(schemaPath) {
         }
     }
     if (relationsBlock) {
-        const tableEntryRegex = /(\w+):\s*tables\.\1\s*\(\s*\([^)]*\)\s*=>\s*\(\{/g;
+        const tableEntryRegex = /(\w+):\s*tables\.\1\s*\(\s*\([^)]*\)\s*=>\s*\[/g;
         let tableMatch;
         while ((tableMatch = tableEntryRegex.exec(relationsBlock)) !== null) {
             const tableTsName = tableMatch[1];
@@ -450,9 +452,9 @@ function parseSchemaFileForComparison(schemaPath) {
             let depth = 1;
             let j = entryStart;
             while (j < relationsBlock.length && depth > 0) {
-                if (relationsBlock[j] === '{')
+                if (relationsBlock[j] === '[')
                     depth++;
-                else if (relationsBlock[j] === '}')
+                else if (relationsBlock[j] === ']')
                     depth--;
                 j++;
             }
@@ -460,35 +462,110 @@ function parseSchemaFileForComparison(schemaPath) {
             const table = tables.find(t => t.name === tableDbName);
             if (!table)
                 continue;
-            const fkRegex = /(\w+):\s*r\.referenceTo\.(\w+)\s*\(\s*\w*\s*=>\s*\(\{([^}]*)\}\)/g;
+            const fkRegex = /r\.referenceTo\.(\w+)\s*\(\s*\w*\s*=>\s*\(\{([^}]*(?:\{[^}]*\}[^}]*)*)\}\)/g;
             let fkMatch;
             while ((fkMatch = fkRegex.exec(tableRelationsContent)) !== null) {
-                const colTsName = fkMatch[1];
-                const refTableTsName = fkMatch[2];
-                const fkOptionsStr = fkMatch[3];
-                const colDbName = toSnakeCase(colTsName);
+                const refTableTsName = fkMatch[1];
+                const fkOptionsStr = fkMatch[2];
                 const refTableDbName = toSnakeCase(refTableTsName);
-                let onDelete;
-                let onUpdate;
+                const singleColMatch = fkOptionsStr.match(/columns:\s*['"](\w+)['"]/);
+                const compositeColMatch = fkOptionsStr.match(/columns:\s*\[([^\]]+)\]/);
+                let sourceColumns = [];
+                let isComposite = false;
+                if (compositeColMatch) {
+                    isComposite = true;
+                    const colsStr = compositeColMatch[1];
+                    const colMatches = colsStr.matchAll(/['"](\w+)['"]/g);
+                    for (const m of colMatches) {
+                        sourceColumns.push(toSnakeCase(m[1]));
+                    }
+                }
+                else if (singleColMatch) {
+                    sourceColumns = [toSnakeCase(singleColMatch[1])];
+                }
+                else {
+                    continue;
+                }
+                let refColumns;
+                const singleRefMatch = fkOptionsStr.match(/references:\s*t\.(\w+)(?![.\[])/);
+                const compositeRefMatch = fkOptionsStr.match(/references:\s*\[([^\]]+)\]/);
+                if (compositeRefMatch) {
+                    refColumns = [];
+                    const refsStr = compositeRefMatch[1];
+                    const refMatches = refsStr.matchAll(/t\.(\w+)/g);
+                    for (const m of refMatches) {
+                        refColumns.push(toSnakeCase(m[1]));
+                    }
+                }
+                else if (singleRefMatch) {
+                    refColumns = [toSnakeCase(singleRefMatch[1])];
+                }
                 const nameMatch = fkOptionsStr.match(/name:\s*['"]([^'"]+)['"]/);
                 const onDeleteMatch = fkOptionsStr.match(/onDelete:\s*['"]([^'"]+)['"]/);
                 const onUpdateMatch = fkOptionsStr.match(/onUpdate:\s*['"]([^'"]+)['"]/);
-                if (onDeleteMatch)
-                    onDelete = onDeleteMatch[1];
-                if (onUpdateMatch)
-                    onUpdate = onUpdateMatch[1];
-                const fkName = nameMatch ? nameMatch[1] : `${tableDbName}_${colDbName}_fkey`;
-                if (!table.constraints.some(c => c.name === fkName || (c.type === 'FOREIGN KEY' && c.columns?.includes(colDbName)))) {
-                    table.constraints.push({
-                        name: fkName,
-                        type: 'FOREIGN KEY',
-                        columns: [colDbName],
-                        definition: '',
-                        referencedTable: refTableDbName,
-                        referencedColumns: ['id'],
-                        onDelete,
-                        onUpdate,
-                    });
+                const matchMatch = fkOptionsStr.match(/match:\s*['"]([^'"]+)['"]/);
+                const deferrableMatch = fkOptionsStr.match(/deferrable:\s*(true|false)/);
+                const initiallyDeferredMatch = fkOptionsStr.match(/initiallyDeferred:\s*(true|false)/);
+                const onDelete = onDeleteMatch ? onDeleteMatch[1] : undefined;
+                const onUpdate = onUpdateMatch ? onUpdateMatch[1] : undefined;
+                const match = matchMatch ? matchMatch[1] : undefined;
+                const deferrable = deferrableMatch ? deferrableMatch[1] === 'true' : undefined;
+                const initiallyDeferred = initiallyDeferredMatch ? initiallyDeferredMatch[1] === 'true' : undefined;
+                if (isComposite) {
+                    const fkName = nameMatch
+                        ? nameMatch[1]
+                        : `${tableDbName}_${sourceColumns.join('_')}_fkey`;
+                    const colsQuoted = sourceColumns.map(c => `"${c}"`).join(', ');
+                    let definition = `FOREIGN KEY (${colsQuoted}) REFERENCES "${refTableDbName}"`;
+                    if (refColumns && refColumns.length > 0) {
+                        definition += `(${refColumns.map(c => `"${c}"`).join(', ')})`;
+                    }
+                    if (onDelete)
+                        definition += ` ON DELETE ${onDelete.toUpperCase()}`;
+                    if (onUpdate)
+                        definition += ` ON UPDATE ${onUpdate.toUpperCase()}`;
+                    if (match)
+                        definition += ` MATCH ${match.toUpperCase()}`;
+                    if (deferrable) {
+                        definition += ' DEFERRABLE';
+                        if (initiallyDeferred)
+                            definition += ' INITIALLY DEFERRED';
+                    }
+                    const alreadyExists = table.constraints.some(c => c.name === fkName ||
+                        (c.type === 'FOREIGN KEY' && c.columns?.join(',') === sourceColumns.join(',')));
+                    if (!alreadyExists) {
+                        table.constraints.push({
+                            name: fkName,
+                            type: 'FOREIGN KEY',
+                            columns: sourceColumns,
+                            definition,
+                        });
+                    }
+                }
+                else {
+                    const colDbName = sourceColumns[0];
+                    const fkName = nameMatch
+                        ? nameMatch[1]
+                        : `${tableDbName}_${colDbName}_fkey`;
+                    const column = table.columns.find((c) => c.name === colDbName);
+                    if (column && !column.references) {
+                        column.references = {
+                            table: refTableDbName,
+                            column: refColumns?.[0] || '',
+                            onDelete,
+                            onUpdate,
+                        };
+                    }
+                    const alreadyExists = table.constraints.some(c => c.name === fkName ||
+                        (c.type === 'FOREIGN KEY' && c.columns?.join(',') === sourceColumns.join(',')));
+                    if (!alreadyExists) {
+                        table.constraints.push({
+                            name: fkName,
+                            type: 'FOREIGN KEY',
+                            columns: sourceColumns,
+                            definition: '',
+                        });
+                    }
                 }
             }
         }
@@ -849,7 +926,25 @@ async function addCommand(context) {
         console.log('');
         return;
     }
-    console.log(`Staged ${stagedNow.length} change(s):`);
+    let totalCount = stagedNow.length;
+    for (const change of stagedNow) {
+        if (change.type === 'CREATE' && change.objectType === 'TABLE') {
+            const tableData = change.after;
+            if (tableData?.columns) {
+                for (const col of tableData.columns) {
+                    if (col.references?.table)
+                        totalCount++;
+                }
+            }
+            if (tableData?.constraints) {
+                for (const con of tableData.constraints) {
+                    if (con.definition && con.definition.startsWith('CHECK'))
+                        totalCount++;
+                }
+            }
+        }
+    }
+    console.log(`Staged ${totalCount} change(s):`);
     console.log('');
     for (const change of stagedNow) {
         const display = (0, change_tracker_1.getChangeDisplayName)(change);
@@ -857,6 +952,26 @@ async function addCommand(context) {
             change.type === 'DROP' ? spinner_1.colors.red :
                 spinner_1.colors.yellow;
         console.log(`   ${color(display)}`);
+        if (change.type === 'CREATE' && change.objectType === 'TABLE') {
+            const tableData = change.after;
+            if (tableData?.columns) {
+                for (const col of tableData.columns) {
+                    if (col.references?.table) {
+                        let fkDisplay = `+ FK ${tableData.name}.${col.name} → ${col.references.table}`;
+                        if (col.references.onDelete)
+                            fkDisplay += ` ON DELETE ${col.references.onDelete.toUpperCase()}`;
+                        console.log(`   ${spinner_1.colors.green(fkDisplay)}`);
+                    }
+                }
+            }
+            if (tableData?.constraints) {
+                for (const con of tableData.constraints) {
+                    if (con.definition && con.definition.startsWith('CHECK')) {
+                        console.log(`   ${spinner_1.colors.green(`+ CHECK ${con.name} on ${tableData.name}`)}`);
+                    }
+                }
+            }
+        }
     }
     console.log('');
     const remainingUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);

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

@@ -192,7 +192,52 @@ async function pushCommand(context) {
                 spinner.succeed('Types in sync');
             }
         }
-        if (toPush.length === 0 && !hasObjectsToDrop) {
+        const pushedButNotApplied = await (0, repo_manager_1.getPushedButNotAppliedCommits)(connection, [...localHashes]);
+        if (pushedButNotApplied.length > 0 && !metadataOnly && !dryRun) {
+            spinner.start(`Recovering ${pushedButNotApplied.length} commit(s) with pending SQL...`);
+            const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+            const client = new pg.Client({
+                host: connection.host,
+                port: connection.port,
+                database: connection.database,
+                user: connection.user,
+                password: connection.password,
+            });
+            try {
+                await client.connect();
+                await client.query('BEGIN');
+                let sqlExecuted = 0;
+                for (const hash of pushedButNotApplied) {
+                    const commitPath = path.join(projectRoot, '.relq', 'commits', `${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);
+                            sqlExecuted++;
+                        }
+                    }
+                }
+                await client.query('COMMIT');
+                spinner.succeed(`Applied pending SQL from ${sqlExecuted} commit(s)`);
+                for (const hash of pushedButNotApplied) {
+                    await (0, repo_manager_1.markCommitAsApplied)(connection, hash);
+                }
+            }
+            catch (error) {
+                try {
+                    await client.query('ROLLBACK');
+                    spinner.fail('SQL recovery failed - rolled back');
+                }
+                catch {
+                    spinner.fail('SQL recovery failed');
+                }
+                throw error;
+            }
+            finally {
+                await client.end();
+            }
+        }
+        if (toPush.length === 0 && !hasObjectsToDrop && pushedButNotApplied.length === 0) {
             if (!typesSynced) {
                 console.log('Everything up-to-date');
             }
@@ -256,16 +301,10 @@ async function pushCommand(context) {
             console.log('');
             return;
         }
-        if (toPush.length > 0) {
-            const commitsToProcess = [...toPush].reverse();
-            spinner.start(`Pushing ${toPush.length} commit(s)...`);
-            for (const commit of commitsToProcess) {
-                await (0, repo_manager_1.pushCommit)(connection, commit, projectRoot);
-                (0, repo_manager_1.markCommitAsPushed)(commit.hash, connection, projectRoot);
-            }
-            spinner.succeed(`Pushed ${toPush.length} commit(s) to ${(0, repo_manager_1.getConnectionLabel)(connection)}`);
-        }
-        if (!metadataOnly && !dryRun) {
+        let sqlApplied = false;
+        let commitsToProcess = [];
+        if (!metadataOnly && !dryRun && (toPush.length > 0 || (hasObjectsToDrop && force))) {
+            commitsToProcess = [...toPush].reverse();
             spinner.start('Applying schema changes...');
             const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
             const client = new pg.Client({
@@ -289,7 +328,6 @@ async function pushCommand(context) {
                         }
                     }
                 }
-                const commitsToProcess = [...toPush].reverse();
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
                     if (fs.existsSync(commitPath)) {
@@ -303,6 +341,7 @@ async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                sqlApplied = true;
                 for (const commit of commitsToProcess) {
                     await (0, repo_manager_1.markCommitAsApplied)(connection, commit.hash);
                 }
@@ -336,7 +375,7 @@ async function pushCommand(context) {
             catch (error) {
                 try {
                     await client.query('ROLLBACK');
-                    spinner.fail('SQL execution failed - rolled back');
+                    spinner.fail('SQL execution failed - rolled back. No commits pushed.');
                 }
                 catch {
                     spinner.fail('SQL execution failed');
@@ -347,6 +386,16 @@ async function pushCommand(context) {
                 await client.end();
             }
         }
+        if (toPush.length > 0) {
+            if (sqlApplied || metadataOnly || dryRun) {
+                spinner.start(`Pushing ${toPush.length} commit(s)...`);
+                for (const commit of commitsToProcess.length > 0 ? commitsToProcess : [...toPush].reverse()) {
+                    await (0, repo_manager_1.pushCommit)(connection, commit, projectRoot);
+                    (0, repo_manager_1.markCommitAsPushed)(commit.hash, connection, projectRoot);
+                }
+                spinner.succeed(`Pushed ${toPush.length} commit(s) to ${(0, repo_manager_1.getConnectionLabel)(connection)}`);
+            }
+        }
         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

@@ -1021,41 +1021,42 @@ function generateRelationsCode(schema, camelCase) {
         }
         usedNames.add(finalRelationName);
         const options = [];
-        if (fk.constraintName) {
-            options.push(`name: '${fk.constraintName}'`);
-        }
-        const isValidColumn = fk.toColumn &&
-            fk.toColumn.length > 0 &&
-            /^[a-zA-Z_]/.test(fk.toColumn) &&
-            fk.toColumn.toLowerCase() !== 'id';
-        if (isValidColumn) {
-            options.push(`references: t.${toColName}`);
-        }
-        if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
-            options.push(`onDelete: '${fk.onDelete}'`);
-        }
-        if (fk.onUpdate && fk.onUpdate !== 'NO ACTION') {
-            options.push(`onUpdate: '${fk.onUpdate}'`);
-        }
-        if (fk.match && fk.match !== 'SIMPLE') {
-            options.push(`match: '${fk.match}'`);
-        }
-        if (fk.deferrable) {
-            options.push(`deferrable: true`);
-        }
-        if (fk.initiallyDeferred) {
-            options.push(`initiallyDeferred: true`);
-        }
         if (fk.isComposite && fk.fromColumns && fk.toColumns) {
-            const fromCols = fk.fromColumns.map(c => `r.${fromTableName}.${camelCase ? (0, utils_1.toCamelCase)(c) : c}`).join(', ');
+            const fromCols = fk.fromColumns.map(c => `'${camelCase ? (0, utils_1.toCamelCase)(c) : c}'`).join(', ');
             const toCols = fk.toColumns.map(c => `t.${camelCase ? (0, utils_1.toCamelCase)(c) : c}`).join(', ');
-            const hasName = fk.constraintName;
-            options.length = 0;
-            if (hasName) {
-                options.push(`name: '${fk.constraintName}'`);
-            }
             options.push(`columns: [${fromCols}]`);
             options.push(`references: [${toCols}]`);
+            if (fk.constraintName) {
+                options.push(`name: '${fk.constraintName}'`);
+            }
+            if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
+                options.push(`onDelete: '${fk.onDelete}'`);
+            }
+            if (fk.onUpdate && fk.onUpdate !== 'NO ACTION') {
+                options.push(`onUpdate: '${fk.onUpdate}'`);
+            }
+            if (fk.match && fk.match !== 'SIMPLE') {
+                options.push(`match: '${fk.match}'`);
+            }
+            if (fk.deferrable) {
+                options.push(`deferrable: true`);
+            }
+            if (fk.initiallyDeferred) {
+                options.push(`initiallyDeferred: true`);
+            }
+        }
+        else {
+            options.push(`columns: '${fromColName}'`);
+            if (fk.constraintName) {
+                options.push(`name: '${fk.constraintName}'`);
+            }
+            const isValidColumn = fk.toColumn &&
+                fk.toColumn.length > 0 &&
+                /^[a-zA-Z_]/.test(fk.toColumn) &&
+                fk.toColumn.toLowerCase() !== 'id';
+            if (isValidColumn) {
+                options.push(`references: t.${toColName}`);
+            }
             if (fk.onDelete && fk.onDelete !== 'NO ACTION') {
                 options.push(`onDelete: '${fk.onDelete}'`);
             }
@@ -1078,16 +1079,10 @@ function generateRelationsCode(schema, camelCase) {
         if (sqlComment) {
             options.push(`comment: '${(0, utils_1.escapeString)(sqlComment)}'`);
         }
-        let code;
-        if (options.length === 0) {
-            code = `${finalRelationName}: r.referenceTo.${toTableName}(t => ({}))`;
-        }
-        else {
-            const optionsStr = options.join(',\n            ');
-            code = `${finalRelationName}: r.referenceTo.${toTableName}(t => ({
+        const optionsStr = options.join(',\n            ');
+        const code = `r.referenceTo.${toTableName}(t => ({
             ${optionsStr},
         }))`;
-        }
         if (!relationsByTable.has(fromTableName)) {
             relationsByTable.set(fromTableName, []);
         }
@@ -1111,16 +1106,16 @@ function generateRelationsCode(schema, camelCase) {
     const sortedTables = [...relationsByTable.keys()].sort();
     for (const tableName of sortedTables) {
         const tableRelations = relationsByTable.get(tableName);
-        lines.push(`    ${tableName}: tables.${tableName}((r) => ({`);
+        lines.push(`    ${tableName}: tables.${tableName}((r) => [`);
         for (const rel of tableRelations) {
             lines.push(`        ${rel.code},`);
         }
-        lines.push('    })),');
+        lines.push('    ]),');
     }
     lines.push('}));');
     return lines.join('\n');
 }
-function generateFKSQLComment(fk, camelCase) {
+function generateFKSQLComment(fk, _camelCase) {
     const parts = [];
     const isValidCol = (col) => col && col.length > 0 && /^[a-zA-Z_]/.test(col);
     if (fk.isComposite && fk.fromColumns) {

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

@@ -187,11 +187,20 @@ function generateTableSQL(change) {
             if (col.defaultValue)
                 def += ` DEFAULT ${col.defaultValue}`;
             if (col.references) {
-                def += ` REFERENCES "${col.references.table}"("${col.references.column}")`;
+                def += ` REFERENCES "${col.references.table}"`;
+                if (col.references.column) {
+                    def += `("${col.references.column}")`;
+                }
+                if (col.references.onDelete)
+                    def += ` ON DELETE ${col.references.onDelete.toUpperCase()}`;
+                if (col.references.onUpdate)
+                    def += ` ON UPDATE ${col.references.onUpdate.toUpperCase()}`;
             }
             colDefs.push(def);
         }
         for (const con of data.constraints || []) {
+            if (!con.definition || !con.definition.trim())
+                continue;
             constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
         }
         const allDefs = [...colDefs, ...constraintDefs].join(',\n');

package/dist/cjs/cli/utils/repo-manager.cjs

@@ -78,6 +78,7 @@ exports.hasUncommittedChanges = hasUncommittedChanges;
 exports.ensureRemoteTable = ensureRemoteTable;
 exports.markCommitAsApplied = markCommitAsApplied;
 exports.markCommitAsRolledBack = markCommitAsRolledBack;
+exports.getPushedButNotAppliedCommits = getPushedButNotAppliedCommits;
 exports.fetchRemoteCommits = fetchRemoteCommits;
 exports.getRemoteHead = getRemoteHead;
 exports.pushCommit = pushCommit;
@@ -624,6 +625,33 @@ async function markCommitAsRolledBack(connection, commitHash) {
         await pool.end();
     }
 }
+async function getPushedButNotAppliedCommits(connection, localHashes) {
+    if (localHashes.length === 0)
+        return [];
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        const result = await pool.query(`
+            SELECT hash FROM _relq_commits 
+            WHERE hash = ANY($1::varchar[]) 
+            AND applied_at IS NULL 
+            AND (rolled_back_at IS NULL OR rolled_back_at < NOW() - INTERVAL '1 hour')
+            ORDER BY created_at ASC
+        `, [localHashes]);
+        return result.rows.map(row => row.hash);
+    }
+    finally {
+        await pool.end();
+    }
+}
 async function fetchRemoteCommits(connection, limit = 100) {
     const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     const pool = new Pool({

package/dist/cjs/cli/utils/schema-comparator.cjs

@@ -454,6 +454,9 @@ function compareConstraints(before, after, tableName) {
         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();