relq 1.0.0

package/dist/cjs/cli/utils/relqignore.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRelqignore = loadRelqignore;
+exports.createDefaultRelqignore = createDefaultRelqignore;
+exports.isIgnored = isIgnored;
+exports.filterIgnored = filterIgnored;
+exports.getIgnorePatterns = getIgnorePatterns;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DEFAULT_PATTERNS = [
+    '_relq_*',
+    'pg_*',
+    '_temp_*',
+    'tmp_*',
+];
+function loadRelqignore(projectRoot = process.cwd()) {
+    const ignorePath = path.join(projectRoot, '.relqignore');
+    const patterns = [...DEFAULT_PATTERNS];
+    if (fs.existsSync(ignorePath)) {
+        const content = fs.readFileSync(ignorePath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            patterns.push(trimmed);
+        }
+    }
+    return patterns;
+}
+function createDefaultRelqignore(projectRoot = process.cwd()) {
+    const ignorePath = path.join(projectRoot, '.relqignore');
+    if (fs.existsSync(ignorePath)) {
+        return;
+    }
+    const content = `# Relq Ignore File
+# Tables and functions matching these patterns will be ignored
+
+# Relq internal tables (always ignored)
+_relq_*
+
+# PostgreSQL system tables
+pg_*
+
+# Temporary tables
+_temp_*
+tmp_*
+
+# Add your tables/functions to ignore below:
+# analytics_raw
+# debug_*
+# test_*
+`;
+    fs.writeFileSync(ignorePath, content, 'utf-8');
+}
+function isIgnored(name, patterns) {
+    for (const pattern of patterns) {
+        if (matchPattern(name, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function filterIgnored(items, patterns) {
+    return items.filter(item => !isIgnored(item.name, patterns));
+}
+function matchPattern(name, pattern) {
+    if (pattern.startsWith('!')) {
+        return !matchPattern(name, pattern.slice(1));
+    }
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(`^${regexPattern}$`, 'i');
+    return regex.test(name);
+}
+function getIgnorePatterns(projectRoot = process.cwd()) {
+    return loadRelqignore(projectRoot);
+}

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

@@ -0,0 +1,515 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInitialized = isInitialized;
+exports.initRepository = initRepository;
+exports.getHead = getHead;
+exports.setHead = setHead;
+exports.getFetchHead = getFetchHead;
+exports.setFetchHead = setFetchHead;
+exports.generateHash = generateHash;
+exports.shortHash = shortHash;
+exports.saveCommit = saveCommit;
+exports.loadCommit = loadCommit;
+exports.getAllCommits = getAllCommits;
+exports.getCommitHistory = getCommitHistory;
+exports.createCommit = createCommit;
+exports.getStaged = getStaged;
+exports.setStaged = setStaged;
+exports.clearStaged = clearStaged;
+exports.hasStaged = hasStaged;
+exports.loadSnapshot = loadSnapshot;
+exports.saveSnapshot = saveSnapshot;
+exports.loadWorkingState = loadWorkingState;
+exports.saveWorkingState = saveWorkingState;
+exports.getOrCreateWorkingState = getOrCreateWorkingState;
+exports.addUnstagedChanges = addUnstagedChanges;
+exports.stageChanges = stageChanges;
+exports.unstageChanges = unstageChanges;
+exports.clearWorkingState = clearWorkingState;
+exports.getStagedChanges = getStagedChanges;
+exports.getUnstagedChanges = getUnstagedChanges;
+exports.hasUncommittedChanges = hasUncommittedChanges;
+exports.ensureRemoteTable = ensureRemoteTable;
+exports.fetchRemoteCommits = fetchRemoteCommits;
+exports.getRemoteHead = getRemoteHead;
+exports.pushCommit = pushCommit;
+exports.getRepoStatus = getRepoStatus;
+exports.createEmptySchema = createEmptySchema;
+exports.migrateSnapshot = migrateSnapshot;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("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';
+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);
+}
+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');
+    }
+}
+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;
+}
+function setHead(hash, projectRoot = process.cwd()) {
+    const headPath = path.join(projectRoot, RELQ_DIR, HEAD_FILE);
+    fs.writeFileSync(headPath, hash, 'utf-8');
+}
+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;
+}
+function setFetchHead(hash, projectRoot = process.cwd()) {
+    const fetchPath = path.join(projectRoot, RELQ_DIR, FETCH_HEAD_FILE);
+    fs.writeFileSync(fetchPath, hash, 'utf-8');
+}
+function generateHash(schema) {
+    const normalized = JSON.stringify(schema, Object.keys(schema).sort());
+    return crypto.createHash('sha1').update(normalized).digest('hex');
+}
+function shortHash(hash) {
+    return hash.substring(0, 7);
+}
+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');
+}
+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'));
+}
+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;
+}
+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;
+}
+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;
+}
+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);
+}
+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');
+}
+function clearStaged(projectRoot = process.cwd()) {
+    setStaged(null, projectRoot);
+}
+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);
+}
+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);
+}
+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');
+}
+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);
+}
+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');
+}
+function getOrCreateWorkingState(projectRoot = process.cwd()) {
+    const existing = loadWorkingState(projectRoot);
+    if (existing)
+        return existing;
+    return {
+        timestamp: new Date().toISOString(),
+        staged: [],
+        unstaged: [],
+    };
+}
+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);
+}
+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;
+}
+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;
+}
+function clearWorkingState(projectRoot = process.cwd()) {
+    const workingPath = path.join(projectRoot, RELQ_DIR, WORKING_FILE);
+    if (fs.existsSync(workingPath)) {
+        fs.unlinkSync(workingPath);
+    }
+}
+function getStagedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    return state?.staged || [];
+}
+function getUnstagedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    return state?.unstaged || [];
+}
+function hasUncommittedChanges(projectRoot = process.cwd()) {
+    const state = loadWorkingState(projectRoot);
+    if (!state)
+        return false;
+    return state.staged.length > 0 || state.unstaged.length > 0;
+}
+async function ensureRemoteTable(connection) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/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();
+    }
+}
+async function fetchRemoteCommits(connection, limit = 100) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/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();
+    }
+}
+async function getRemoteHead(connection) {
+    const commits = await fetchRemoteCommits(connection, 1);
+    return commits.length > 0 ? commits[0].hash : null;
+}
+async function pushCommit(connection, commit) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/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();
+    }
+}
+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,
+    };
+}
+function createEmptySchema() {
+    return {
+        extensions: [],
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        tables: [],
+        functions: [],
+        triggers: [],
+        views: [],
+        materializedViews: [],
+        foreignTables: [],
+    };
+}
+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 || [],
+    };
+}