relq 1.0.5 → 1.0.7

package/dist/esm/cli/utils/repo-manager.js

@@ -67,6 +67,81 @@ export function generateHash(schema) {
 export function shortHash(hash) {
     return hash.substring(0, 7);
 }
+export function getConnectionId(connection) {
+    const parts = [
+        connection.host || 'localhost',
+        String(connection.port || 5432),
+        connection.database || 'postgres',
+        connection.user || 'postgres',
+    ];
+    return crypto.createHash('sha256').update(parts.join('/')).digest('hex').substring(0, 12);
+}
+export function getConnectionLabel(connection) {
+    const user = connection.user || 'postgres';
+    const host = connection.host || 'localhost';
+    const db = connection.database || 'postgres';
+    return `${user}@${host}/${db}`;
+}
+export function getRemoteRef(connection) {
+    return {
+        id: getConnectionId(connection),
+        label: getConnectionLabel(connection),
+    };
+}
+export function isCommitSyncedWith(commit, connection) {
+    const connectionId = getConnectionId(connection);
+    if (commit.remotes?.pushed?.some((r) => r.id === connectionId)) {
+        return { synced: true, type: 'pushed' };
+    }
+    if (commit.remotes?.pulled?.some((r) => r.id === connectionId)) {
+        return { synced: true, type: 'pulled' };
+    }
+    if (commit.message?.startsWith('pull: sync from ')) {
+        const pullTarget = commit.message.replace('pull: sync from ', '');
+        const currentLabel = getConnectionLabel(connection);
+        const legacyLabel = `${connection.user}@${connection.host}:${connection.port || 5432}/${connection.database}`;
+        if (pullTarget === currentLabel || pullTarget === legacyLabel) {
+            return { synced: true, type: 'pulled' };
+        }
+    }
+    return { synced: false, type: null };
+}
+export function markCommitAsPushed(commitHash, connection, projectRoot = process.cwd()) {
+    const commitPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR, `${commitHash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        return;
+    }
+    const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+    const remoteRef = getRemoteRef(connection);
+    if (!commit.remotes) {
+        commit.remotes = {};
+    }
+    if (!commit.remotes.pushed) {
+        commit.remotes.pushed = [];
+    }
+    if (!commit.remotes.pushed.some((r) => r.id === remoteRef.id)) {
+        commit.remotes.pushed.push(remoteRef);
+    }
+    fs.writeFileSync(commitPath, JSON.stringify(commit, null, 2), 'utf-8');
+}
+export function markCommitAsPulled(commitHash, connection, projectRoot = process.cwd()) {
+    const commitPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR, `${commitHash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        return;
+    }
+    const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+    const remoteRef = getRemoteRef(connection);
+    if (!commit.remotes) {
+        commit.remotes = {};
+    }
+    if (!commit.remotes.pulled) {
+        commit.remotes.pulled = [];
+    }
+    if (!commit.remotes.pulled.some((r) => r.id === remoteRef.id)) {
+        commit.remotes.pulled.push(remoteRef);
+    }
+    fs.writeFileSync(commitPath, JSON.stringify(commit, null, 2), 'utf-8');
+}
 export function saveCommit(commit, projectRoot = process.cwd()) {
     const commitsPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR);
     const commitPath = path.join(commitsPath, `${commit.hash}.json`);
@@ -269,7 +344,9 @@ export function stageChanges(patterns, projectRoot = process.cwd()) {
             remaining.push(change);
         }
     }
-    state.staged.push(...staged);
+    const newKeys = new Set(staged.map(c => `${c.objectType}:${c.objectName}:${c.parentName || ''}`));
+    const keptStaged = state.staged.filter(c => !newKeys.has(`${c.objectType}:${c.objectName}:${c.parentName || ''}`));
+    state.staged = [...keptStaged, ...staged];
     state.unstaged = remaining;
     state.timestamp = new Date().toISOString();
     saveWorkingState(state, projectRoot);
@@ -310,6 +387,18 @@ export function getStagedChanges(projectRoot = process.cwd()) {
     const state = loadWorkingState(projectRoot);
     return state?.staged || [];
 }
+export function cleanupStagedChanges(validChanges, projectRoot = process.cwd()) {
+    const state = getOrCreateWorkingState(projectRoot);
+    const validKeys = new Set(validChanges.map(c => `${c.objectType}:${c.objectName}:${c.parentName || ''}`));
+    const originalCount = state.staged.length;
+    state.staged = state.staged.filter(c => validKeys.has(`${c.objectType}:${c.objectName}:${c.parentName || ''}`));
+    const removedCount = originalCount - state.staged.length;
+    if (removedCount > 0) {
+        state.timestamp = new Date().toISOString();
+        saveWorkingState(state, projectRoot);
+    }
+    return removedCount;
+}
 export function getUnstagedChanges(projectRoot = process.cwd()) {
     const state = loadWorkingState(projectRoot);
     return state?.unstaged || [];
@@ -388,7 +477,7 @@ export async function getRemoteHead(connection) {
     const commits = await fetchRemoteCommits(connection, 1);
     return commits.length > 0 ? commits[0].hash : null;
 }
-export async function pushCommit(connection, commit) {
+export async function pushCommit(connection, commit, projectRoot = process.cwd()) {
     const { Pool } = await import("../../addon/pg/index.js");
     const pool = new Pool({
         host: connection.host,
@@ -400,6 +489,27 @@ export async function pushCommit(connection, commit) {
         ssl: connection.ssl,
     });
     try {
+        let schemaSnapshot = null;
+        if (commit.schema) {
+            schemaSnapshot = commit.schema;
+        }
+        else {
+            schemaSnapshot = loadSnapshot(projectRoot);
+        }
+        if (!schemaSnapshot) {
+            throw new Error(`Cannot push commit ${commit.hash}: No schema snapshot available. Run 'relq pull' first.`);
+        }
+        const stats = commit.stats || {
+            tables: 0,
+            columns: 0,
+            indexes: 0,
+            enums: 0,
+            domains: 0,
+            compositeTypes: 0,
+            sequences: 0,
+            functions: 0,
+            triggers: 0,
+        };
         await pool.query(`
             INSERT INTO _relq_commits (hash, parent_hash, author, message, schema_snapshot, stats)
             VALUES ($1, $2, $3, $4, $5, $6)
@@ -409,8 +519,8 @@ export async function pushCommit(connection, commit) {
             commit.parentHash,
             commit.author,
             commit.message,
-            JSON.stringify(commit.schema),
-            JSON.stringify(commit.stats),
+            JSON.stringify(schemaSnapshot),
+            JSON.stringify(stats),
         ]);
     }
     finally {

package/dist/esm/cli/utils/schema-comparator.js

@@ -191,6 +191,7 @@ function compareTables(before, after) {
             changes.push(...compareConstraints(beforeTable.constraints || [], table.constraints || [], name));
             changes.push(...compareTableComments(beforeTable, table, name));
             changes.push(...compareColumnComments(beforeTable.columns, table.columns, name));
+            changes.push(...compareIndexComments(beforeTable.indexes || [], table.indexes || [], name));
             changes.push(...comparePartitions(beforeTable, table, name));
         }
     }
@@ -224,21 +225,46 @@ function tableToChangeData(table) {
 }
 function compareColumns(before, after, tableName) {
     const changes = [];
-    const beforeMap = new Map(before.map(c => [c.name, c]));
-    const afterMap = new Map(after.map(c => [c.name, c]));
-    for (const [name, col] of afterMap) {
-        if (!beforeMap.has(name)) {
+    const beforeByName = new Map(before.map(c => [c.name, c]));
+    const afterByName = new Map(after.map(c => [c.name, c]));
+    const beforeByTrackingId = new Map(before.filter(c => c.trackingId).map(c => [c.trackingId, c]));
+    const afterByTrackingId = new Map(after.filter(c => c.trackingId).map(c => [c.trackingId, c]));
+    const processedBefore = new Set();
+    const processedAfter = new Set();
+    for (const [trackingId, afterCol] of afterByTrackingId) {
+        const beforeCol = beforeByTrackingId.get(trackingId);
+        if (beforeCol && beforeCol.name !== afterCol.name) {
+            changes.push(createChange('RENAME', 'COLUMN', afterCol.name, columnToChangeData(beforeCol), columnToChangeData(afterCol), tableName));
+            processedBefore.add(beforeCol.name);
+            processedAfter.add(afterCol.name);
+        }
+        else if (beforeCol && beforeCol.name === afterCol.name) {
+            if (hasColumnChanged(beforeCol, afterCol)) {
+                changes.push(createChange('ALTER', 'COLUMN', afterCol.name, columnToChangeData(beforeCol), columnToChangeData(afterCol), tableName));
+            }
+            processedBefore.add(beforeCol.name);
+            processedAfter.add(afterCol.name);
+        }
+    }
+    for (const [name, col] of afterByName) {
+        if (processedAfter.has(name))
+            continue;
+        if (!beforeByName.has(name)) {
             changes.push(createChange('CREATE', 'COLUMN', name, null, columnToChangeData(col), tableName));
         }
         else {
-            const beforeCol = beforeMap.get(name);
-            if (hasColumnChanged(beforeCol, col)) {
+            const beforeCol = beforeByName.get(name);
+            if (!processedBefore.has(name) && hasColumnChanged(beforeCol, col)) {
                 changes.push(createChange('ALTER', 'COLUMN', name, columnToChangeData(beforeCol), columnToChangeData(col), tableName));
             }
+            processedBefore.add(name);
         }
+        processedAfter.add(name);
     }
-    for (const [name, col] of beforeMap) {
-        if (!afterMap.has(name)) {
+    for (const [name, col] of beforeByName) {
+        if (processedBefore.has(name))
+            continue;
+        if (!afterByName.has(name)) {
             changes.push(createChange('DROP', 'COLUMN', name, columnToChangeData(col), null, tableName));
         }
     }
@@ -255,6 +281,7 @@ function columnToChangeData(col) {
         maxLength: col.maxLength,
         precision: col.precision,
         scale: col.scale,
+        trackingId: col.trackingId,
     };
 }
 function normalizeDataType(type) {
@@ -321,10 +348,28 @@ function hasColumnChanged(before, after) {
 }
 function compareIndexes(before, after, tableName) {
     const changes = [];
-    const beforeMap = new Map(before.map(i => [i.name, i]));
-    const afterMap = new Map(after.map(i => [i.name, i]));
-    for (const [name, idx] of afterMap) {
-        if (!beforeMap.has(name) && !idx.isPrimary) {
+    const beforeByName = new Map(before.map(i => [i.name, i]));
+    const afterByName = new Map(after.map(i => [i.name, i]));
+    const beforeByTrackingId = new Map(before.filter(i => i.trackingId).map(i => [i.trackingId, i]));
+    const afterByTrackingId = new Map(after.filter(i => i.trackingId).map(i => [i.trackingId, i]));
+    const processedBefore = new Set();
+    const processedAfter = new Set();
+    for (const [trackingId, afterIdx] of afterByTrackingId) {
+        const beforeIdx = beforeByTrackingId.get(trackingId);
+        if (beforeIdx && beforeIdx.name !== afterIdx.name && !beforeIdx.isPrimary && !afterIdx.isPrimary) {
+            changes.push(createChange('RENAME', 'INDEX', afterIdx.name, { name: beforeIdx.name, tableName, columns: beforeIdx.columns }, { name: afterIdx.name, tableName, columns: afterIdx.columns, isUnique: afterIdx.isUnique, type: afterIdx.type }));
+            processedBefore.add(beforeIdx.name);
+            processedAfter.add(afterIdx.name);
+        }
+        else if (beforeIdx && beforeIdx.name === afterIdx.name) {
+            processedBefore.add(beforeIdx.name);
+            processedAfter.add(afterIdx.name);
+        }
+    }
+    for (const [name, idx] of afterByName) {
+        if (processedAfter.has(name) || idx.isPrimary)
+            continue;
+        if (!beforeByName.has(name)) {
             changes.push(createChange('CREATE', 'INDEX', name, null, {
                 name: idx.name,
                 tableName,
@@ -333,9 +378,12 @@ function compareIndexes(before, after, tableName) {
                 type: idx.type,
             }));
         }
+        processedAfter.add(name);
     }
-    for (const [name, idx] of beforeMap) {
-        if (!afterMap.has(name) && !idx.isPrimary) {
+    for (const [name, idx] of beforeByName) {
+        if (processedBefore.has(name) || idx.isPrimary)
+            continue;
+        if (!afterByName.has(name)) {
             changes.push(createChange('DROP', 'INDEX', name, {
                 name: idx.name,
                 tableName,
@@ -501,6 +549,42 @@ function compareColumnComments(before, after, tableName) {
     }
     return changes;
 }
+function compareIndexComments(before, after, tableName) {
+    const changes = [];
+    const beforeMap = new Map(before.map(i => [i.name, i]));
+    const afterMap = new Map(after.map(i => [i.name, i]));
+    for (const [name, afterIdx] of afterMap) {
+        const beforeIdx = beforeMap.get(name);
+        const afterComment = afterIdx.comment || null;
+        const beforeComment = beforeIdx ? beforeIdx.comment || null : null;
+        if (afterComment && !beforeComment) {
+            changes.push(createChange('CREATE', 'INDEX_COMMENT', name, null, {
+                tableName,
+                indexName: name,
+                comment: afterComment,
+            }, tableName));
+        }
+        else if (!afterComment && beforeComment) {
+            changes.push(createChange('DROP', 'INDEX_COMMENT', name, {
+                tableName,
+                indexName: name,
+                comment: beforeComment,
+            }, null, tableName));
+        }
+        else if (afterComment && beforeComment && afterComment !== beforeComment) {
+            changes.push(createChange('ALTER', 'INDEX_COMMENT', name, {
+                tableName,
+                indexName: name,
+                comment: beforeComment,
+            }, {
+                tableName,
+                indexName: name,
+                comment: afterComment,
+            }, tableName));
+        }
+    }
+    return changes;
+}
 function comparePartitions(before, after, tableName) {
     const changes = [];
     const beforePartitioned = before.isPartitioned;

package/dist/esm/cli/utils/schema-introspect.js

@@ -1,3 +1,19 @@
+function mapInternalToFriendlyType(internalType) {
+    const typeMap = {
+        'int2': 'smallint',
+        'int4': 'integer',
+        'int8': 'bigint',
+        'float4': 'real',
+        'float8': 'double precision',
+        'bool': 'boolean',
+        'timestamptz': 'timestamp with time zone',
+        'timetz': 'time with time zone',
+        'varchar': 'character varying',
+        'bpchar': 'character',
+        'varbit': 'bit varying',
+    };
+    return typeMap[internalType] || internalType;
+}
 export async function introspectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
     const { Pool } = await import("../../addon/pg/index.js");
@@ -17,7 +33,8 @@ export async function introspectDatabase(connection, onProgress, options) {
             SELECT 
                 t.table_name,
                 t.table_schema,
-                (SELECT reltuples::bigint FROM pg_class WHERE relname = t.table_name) as row_count
+                (SELECT reltuples::bigint FROM pg_class WHERE relname = t.table_name) as row_count,
+                obj_description((quote_ident(t.table_schema) || '.' || quote_ident(t.table_name))::regclass, 'pg_class') as table_comment
             FROM information_schema.tables t
             WHERE t.table_schema = 'public'
                 AND t.table_type = 'BASE TABLE'
@@ -74,11 +91,17 @@ export async function introspectDatabase(connection, onProgress, options) {
                     WHERE tc.table_name = $1 AND tc.constraint_type = 'PRIMARY KEY'
                 ) pk ON pk.column_name = c.column_name
                 LEFT JOIN (
+                    -- Only mark as unique if column is the ONLY column in the unique constraint
+                    -- (not part of a composite unique constraint)
                     SELECT kcu.column_name, true as is_unique
                     FROM information_schema.table_constraints tc
                     JOIN information_schema.key_column_usage kcu 
                         ON tc.constraint_name = kcu.constraint_name
                     WHERE tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+                    AND (
+                        SELECT COUNT(*) FROM information_schema.key_column_usage kcu2
+                        WHERE kcu2.constraint_name = tc.constraint_name
+                    ) = 1
                 ) uq ON uq.column_name = c.column_name
                 LEFT JOIN (
                     SELECT 
@@ -95,29 +118,41 @@ export async function introspectDatabase(connection, onProgress, options) {
                 WHERE c.table_name = $1 AND c.table_schema = $2
                 ORDER BY c.ordinal_position;
             `, [tableName, tableSchema]);
-            const columns = columnsResult.rows.map(col => ({
-                name: col.column_name,
-                dataType: col.udt_name || col.data_type,
-                isNullable: col.is_nullable === 'YES',
-                defaultValue: col.column_default,
-                isPrimaryKey: col.is_primary_key,
-                isUnique: col.is_unique,
-                maxLength: col.character_maximum_length,
-                precision: col.numeric_precision,
-                scale: col.numeric_scale,
-                references: col.foreign_table ? {
-                    table: col.foreign_table,
-                    column: col.foreign_column,
-                } : null,
-                comment: col.column_comment || undefined,
-            }));
+            const columns = columnsResult.rows.map(col => {
+                let dataType = col.data_type;
+                if (dataType === 'ARRAY' && col.udt_name) {
+                    const baseType = col.udt_name.startsWith('_') ? col.udt_name.slice(1) : col.udt_name;
+                    const friendlyBase = mapInternalToFriendlyType(baseType);
+                    dataType = `${friendlyBase}[]`;
+                }
+                else if (dataType === 'USER-DEFINED' && col.udt_name) {
+                    dataType = col.udt_name;
+                }
+                return {
+                    name: col.column_name,
+                    dataType,
+                    isNullable: col.is_nullable === 'YES',
+                    defaultValue: col.column_default,
+                    isPrimaryKey: col.is_primary_key,
+                    isUnique: col.is_unique,
+                    maxLength: col.character_maximum_length,
+                    precision: col.numeric_precision,
+                    scale: col.numeric_scale,
+                    references: col.foreign_table ? {
+                        table: col.foreign_table,
+                        column: col.foreign_column,
+                    } : null,
+                    comment: col.column_comment || undefined,
+                };
+            });
             const indexesResult = await pool.query(`
                 SELECT 
                     i.relname as index_name,
                     array_agg(a.attname ORDER BY k.n) as columns,
                     ix.indisunique as is_unique,
                     ix.indisprimary as is_primary,
-                    am.amname as index_type
+                    am.amname as index_type,
+                    obj_description(i.oid, 'pg_class') as index_comment
                 FROM pg_index ix
                 JOIN pg_class t ON t.oid = ix.indrelid
                 JOIN pg_class i ON i.oid = ix.indexrelid
@@ -125,7 +160,7 @@ export async function introspectDatabase(connection, onProgress, options) {
                 JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true
                 JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
                 WHERE t.relname = $1
-                GROUP BY i.relname, ix.indisunique, ix.indisprimary, am.amname
+                GROUP BY i.relname, i.oid, ix.indisunique, ix.indisprimary, am.amname
                 ORDER BY i.relname;
             `, [tableName]);
             const indexes = indexesResult.rows.map(idx => ({
@@ -134,6 +169,7 @@ export async function introspectDatabase(connection, onProgress, options) {
                 isUnique: idx.is_unique,
                 isPrimary: idx.is_primary,
                 type: idx.index_type,
+                comment: idx.index_comment || null,
             }));
             const constraintsResult = await pool.query(`
                 SELECT 
@@ -201,6 +237,7 @@ export async function introspectDatabase(connection, onProgress, options) {
                 isPartitioned: partitionInfo.is_partitioned || false,
                 partitionType: partitionInfo.partition_type,
                 partitionKey,
+                comment: row.table_comment || null,
             });
         }
         onProgress?.('fetching_extensions');

package/dist/esm/cli/utils/snapshot-manager.js

@@ -58,7 +58,6 @@ function tableToSnapshot(table) {
             maxLength: col.maxLength,
             precision: col.precision,
             scale: col.scale,
-            references: col.references,
         };
     }
     for (const idx of table.indexes || []) {