relq 1.0.0

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

@@ -0,0 +1,444 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+const RELQ_DIR = '.relq';
+const HEAD_FILE = 'HEAD';
+const FETCH_HEAD_FILE = 'FETCH_HEAD';
+const STAGED_FILE = 'staged.json';
+const WORKING_FILE = 'working.json';
+const SNAPSHOT_FILE = 'snapshot.json';
+const COMMITS_DIR = 'commits';
+export function isInitialized(projectRoot = process.cwd()) {
+    const relqPath = path.join(projectRoot, RELQ_DIR);
+    const headPath = path.join(relqPath, HEAD_FILE);
+    return fs.existsSync(relqPath) && fs.existsSync(headPath);
+}
+export function initRepository(projectRoot = process.cwd()) {
+    const relqPath = path.join(projectRoot, RELQ_DIR);
+    const commitsPath = path.join(relqPath, COMMITS_DIR);
+    if (!fs.existsSync(relqPath)) {
+        fs.mkdirSync(relqPath, { recursive: true });
+    }
+    if (!fs.existsSync(commitsPath)) {
+        fs.mkdirSync(commitsPath, { recursive: true });
+    }
+    const headPath = path.join(relqPath, HEAD_FILE);
+    if (!fs.existsSync(headPath)) {
+        fs.writeFileSync(headPath, '', 'utf-8');
+    }
+    const workingPath = path.join(relqPath, WORKING_FILE);
+    if (!fs.existsSync(workingPath)) {
+        const initialState = {
+            timestamp: new Date().toISOString(),
+            staged: [],
+            unstaged: [],
+        };
+        fs.writeFileSync(workingPath, JSON.stringify(initialState, null, 2), 'utf-8');
+    }
+}
+export function getHead(projectRoot = process.cwd()) {
+    const headPath = path.join(projectRoot, RELQ_DIR, HEAD_FILE);
+    if (!fs.existsSync(headPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(headPath, 'utf-8').trim();
+    return content || null;
+}
+export function setHead(hash, projectRoot = process.cwd()) {
+    const headPath = path.join(projectRoot, RELQ_DIR, HEAD_FILE);
+    fs.writeFileSync(headPath, hash, 'utf-8');
+}
+export function getFetchHead(projectRoot = process.cwd()) {
+    const fetchPath = path.join(projectRoot, RELQ_DIR, FETCH_HEAD_FILE);
+    if (!fs.existsSync(fetchPath)) {
+        return null;
+    }
+    return fs.readFileSync(fetchPath, 'utf-8').trim() || null;
+}
+export function setFetchHead(hash, projectRoot = process.cwd()) {
+    const fetchPath = path.join(projectRoot, RELQ_DIR, FETCH_HEAD_FILE);
+    fs.writeFileSync(fetchPath, hash, 'utf-8');
+}
+export function generateHash(schema) {
+    const normalized = JSON.stringify(schema, Object.keys(schema).sort());
+    return crypto.createHash('sha1').update(normalized).digest('hex');
+}
+export function shortHash(hash) {
+    return hash.substring(0, 7);
+}
+export function saveCommit(commit, projectRoot = process.cwd()) {
+    const commitsPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR);
+    const commitPath = path.join(commitsPath, `${commit.hash}.json`);
+    fs.writeFileSync(commitPath, JSON.stringify(commit, null, 2), 'utf-8');
+}
+export function loadCommit(hash, projectRoot = process.cwd()) {
+    const commitPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR, `${hash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+}
+export function getAllCommits(projectRoot = process.cwd()) {
+    const commitsPath = path.join(projectRoot, RELQ_DIR, COMMITS_DIR);
+    if (!fs.existsSync(commitsPath)) {
+        return [];
+    }
+    const files = fs.readdirSync(commitsPath).filter(f => f.endsWith('.json'));
+    const commits = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(commitsPath, file), 'utf-8');
+        commits.push(JSON.parse(content));
+    }
+    commits.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    return commits;
+}
+export function getCommitHistory(limit = 20, projectRoot = process.cwd()) {
+    const head = getHead(projectRoot);
+    if (!head)
+        return [];
+    const history = [];
+    let currentHash = head;
+    while (currentHash && history.length < limit) {
+        const commit = loadCommit(currentHash, projectRoot);
+        if (!commit)
+            break;
+        history.push(commit);
+        currentHash = commit.parentHash;
+    }
+    return history;
+}
+export function createCommit(schema, author, message, projectRoot = process.cwd()) {
+    const hash = generateHash(schema);
+    const parentHash = getHead(projectRoot);
+    const commit = {
+        hash,
+        parentHash,
+        author,
+        message,
+        timestamp: new Date().toISOString(),
+        schema,
+        stats: {
+            tables: schema.tables.length,
+            columns: schema.tables.reduce((acc, t) => acc + t.columns.length, 0),
+            indexes: schema.tables.reduce((acc, t) => acc + t.indexes.length, 0),
+            enums: schema.enums?.length || 0,
+            domains: schema.domains?.length || 0,
+            compositeTypes: schema.compositeTypes?.length || 0,
+            sequences: schema.sequences?.length || 0,
+            functions: schema.functions?.length || 0,
+            triggers: schema.triggers?.length || 0,
+        },
+    };
+    saveCommit(commit, projectRoot);
+    setHead(hash, projectRoot);
+    clearStaged(projectRoot);
+    return commit;
+}
+export function getStaged(projectRoot = process.cwd()) {
+    const stagedPath = path.join(projectRoot, RELQ_DIR, STAGED_FILE);
+    if (!fs.existsSync(stagedPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(stagedPath, 'utf-8');
+    return content === 'null' ? null : JSON.parse(content);
+}
+export function setStaged(staged, projectRoot = process.cwd()) {
+    const stagedPath = path.join(projectRoot, RELQ_DIR, STAGED_FILE);
+    fs.writeFileSync(stagedPath, staged ? JSON.stringify(staged, null, 2) : 'null', 'utf-8');
+}
+export function clearStaged(projectRoot = process.cwd()) {
+    setStaged(null, projectRoot);
+}
+export function hasStaged(projectRoot = process.cwd()) {
+    const staged = getStaged(projectRoot);
+    if (!staged)
+        return false;
+    return (staged.tables.added.length > 0 ||
+        staged.tables.modified.length > 0 ||
+        staged.tables.removed.length > 0 ||
+        staged.functions.added.length > 0 ||
+        staged.functions.modified.length > 0 ||
+        staged.functions.removed.length > 0);
+}
+export function loadSnapshot(projectRoot = process.cwd()) {
+    const snapshotPath = path.join(projectRoot, RELQ_DIR, SNAPSHOT_FILE);
+    if (!fs.existsSync(snapshotPath)) {
+        return null;
+    }
+    const raw = JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
+    return migrateSnapshot(raw);
+}
+export function saveSnapshot(schema, projectRoot = process.cwd()) {
+    const snapshotPath = path.join(projectRoot, RELQ_DIR, SNAPSHOT_FILE);
+    fs.writeFileSync(snapshotPath, JSON.stringify(schema, null, 2), 'utf-8');
+}
+export function loadWorkingState(projectRoot = process.cwd()) {
+    const workingPath = path.join(projectRoot, RELQ_DIR, WORKING_FILE);
+    if (!fs.existsSync(workingPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(workingPath, 'utf-8');
+    return content === 'null' ? null : JSON.parse(content);
+}
+export function saveWorkingState(state, projectRoot = process.cwd()) {
+    const workingPath = path.join(projectRoot, RELQ_DIR, WORKING_FILE);
+    fs.writeFileSync(workingPath, JSON.stringify(state, null, 2), 'utf-8');
+}
+export function getOrCreateWorkingState(projectRoot = process.cwd()) {
+    const existing = loadWorkingState(projectRoot);
+    if (existing)
+        return existing;
+    return {
+        timestamp: new Date().toISOString(),
+        staged: [],
+        unstaged: [],
+    };
+}
+export function addUnstagedChanges(changes, projectRoot = process.cwd()) {
+    const state = getOrCreateWorkingState(projectRoot);
+    const existingIds = new Set(state.unstaged.map(c => c.id));
+    for (const change of changes) {
+        if (!existingIds.has(change.id)) {
+            state.unstaged.push(change);
+            existingIds.add(change.id);
+        }
+    }
+    state.timestamp = new Date().toISOString();
+    saveWorkingState(state, projectRoot);
+}
+export function stageChanges(patterns, projectRoot = process.cwd()) {
+    const state = getOrCreateWorkingState(projectRoot);
+    const staged = [];
+    const remaining = [];
+    const isAll = patterns.includes('*') || patterns.includes('.');
+    for (const change of state.unstaged) {
+        const matchesPattern = isAll || patterns.some(p => {
+            const fullName = change.parentName
+                ? `${change.parentName}.${change.objectName}`
+                : change.objectName;
+            return fullName.includes(p) ||
+                change.objectName === p ||
+                change.objectType.toLowerCase() === p.toLowerCase();
+        });
+        if (matchesPattern) {
+            staged.push(change);
+        }
+        else {
+            remaining.push(change);
+        }
+    }
+    state.staged.push(...staged);
+    state.unstaged = remaining;
+    state.timestamp = new Date().toISOString();
+    saveWorkingState(state, projectRoot);
+    return staged;
+}
+export function unstageChanges(patterns, projectRoot = process.cwd()) {
+    const state = getOrCreateWorkingState(projectRoot);
+    const unstaged = [];
+    const remaining = [];
+    const isAll = patterns.includes('*') || patterns.includes('.');
+    for (const change of state.staged) {
+        const matchesPattern = isAll || patterns.some(p => {
+            const fullName = change.parentName
+                ? `${change.parentName}.${change.objectName}`
+                : change.objectName;
+            return fullName.includes(p) || change.objectName === p;
+        });
+        if (matchesPattern) {
+            unstaged.push(change);
+        }
+        else {
+            remaining.push(change);
+        }
+    }
+    state.unstaged.push(...unstaged);
+    state.staged = remaining;
+    state.timestamp = new Date().toISOString();
+    saveWorkingState(state, projectRoot);
+    return unstaged;
+}
+export function clearWorkingState(projectRoot = process.cwd()) {
+    const workingPath = path.join(projectRoot, RELQ_DIR, WORKING_FILE);
+    if (fs.existsSync(workingPath)) {
+        fs.unlinkSync(workingPath);
+    }
+}
+export function getStagedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    return state?.staged || [];
+}
+export function getUnstagedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    return state?.unstaged || [];
+}
+export function hasUncommittedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    if (!state)
+        return false;
+    return state.staged.length > 0 || state.unstaged.length > 0;
+}
+export async function ensureRemoteTable(connection) {
+    const { Pool } = await import("../../addon/pg.js");
+    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 {
+        await pool.query(`
+            CREATE TABLE IF NOT EXISTS _relq_commits (
+                id SERIAL PRIMARY KEY,
+                hash VARCHAR(40) UNIQUE NOT NULL,
+                parent_hash VARCHAR(40),
+                author VARCHAR(255) NOT NULL,
+                message TEXT,
+                schema_snapshot JSONB NOT NULL,
+                stats JSONB,
+                created_at TIMESTAMPTZ DEFAULT NOW()
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_relq_commits_hash ON _relq_commits(hash);
+            CREATE INDEX IF NOT EXISTS idx_relq_commits_created ON _relq_commits(created_at DESC);
+        `);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function fetchRemoteCommits(connection, limit = 100) {
+    const { Pool } = await import("../../addon/pg.js");
+    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, parent_hash, author, message, schema_snapshot, stats, created_at
+            FROM _relq_commits
+            ORDER BY created_at DESC
+            LIMIT $1
+        `, [limit]);
+        return result.rows.map(row => ({
+            hash: row.hash,
+            parentHash: row.parent_hash,
+            author: row.author,
+            message: row.message || '',
+            timestamp: row.created_at.toISOString(),
+            schema: row.schema_snapshot,
+            stats: row.stats || { tables: 0, columns: 0, indexes: 0, functions: 0, triggers: 0 },
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+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) {
+    const { Pool } = await import("../../addon/pg.js");
+    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 {
+        await pool.query(`
+            INSERT INTO _relq_commits (hash, parent_hash, author, message, schema_snapshot, stats)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            ON CONFLICT (hash) DO NOTHING
+        `, [
+            commit.hash,
+            commit.parentHash,
+            commit.author,
+            commit.message,
+            JSON.stringify(commit.schema),
+            JSON.stringify(commit.stats),
+        ]);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function getRepoStatus(connection, projectRoot = process.cwd()) {
+    const initialized = isInitialized(projectRoot);
+    const head = getHead(projectRoot);
+    const staged = getStaged(projectRoot);
+    const localCommits = getAllCommits(projectRoot).length;
+    let aheadBy = 0;
+    let behindBy = 0;
+    if (initialized && head) {
+        try {
+            const remoteHead = await getRemoteHead(connection);
+            const localHashes = new Set(getAllCommits(projectRoot).map(c => c.hash));
+            const remoteCommits = await fetchRemoteCommits(connection, 100);
+            const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+            aheadBy = [...localHashes].filter(h => !remoteHashes.has(h)).length;
+            behindBy = [...remoteHashes].filter(h => !localHashes.has(h)).length;
+        }
+        catch {
+        }
+    }
+    return {
+        initialized,
+        head,
+        staged,
+        localCommits,
+        aheadBy,
+        behindBy,
+    };
+}
+export function createEmptySchema() {
+    return {
+        extensions: [],
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        tables: [],
+        functions: [],
+        triggers: [],
+        views: [],
+        materializedViews: [],
+        foreignTables: [],
+    };
+}
+export function migrateSnapshot(snapshot) {
+    const extensions = (snapshot.extensions || []).map(ext => typeof ext === 'string' ? { name: ext } : ext);
+    const triggers = (snapshot.triggers || []).map((t) => ({
+        ...t,
+        events: t.events || (t.event ? [t.event] : []),
+        forEach: t.forEach || 'STATEMENT',
+        functionName: t.functionName || '',
+    }));
+    return {
+        extensions,
+        enums: snapshot.enums || [],
+        domains: snapshot.domains || [],
+        compositeTypes: snapshot.compositeTypes || [],
+        sequences: snapshot.sequences || [],
+        collations: snapshot.collations || [],
+        tables: snapshot.tables || [],
+        functions: snapshot.functions || [],
+        triggers,
+        views: snapshot.views || [],
+        materializedViews: snapshot.materializedViews || [],
+        foreignTables: snapshot.foreignTables || [],
+    };
+}