relq 1.0.0

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

@@ -0,0 +1,446 @@
+"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.generateChangeId = generateChangeId;
+exports.generateChangeSQL = generateChangeSQL;
+exports.createChange = createChange;
+exports.getChangeDisplayName = getChangeDisplayName;
+exports.sortChangesByDependency = sortChangesByDependency;
+exports.generateCombinedSQL = generateCombinedSQL;
+const crypto = __importStar(require("crypto"));
+function generateChangeId(type, objectType, objectName, parentName) {
+    const input = `${type}:${objectType}:${parentName || ''}:${objectName}:${Date.now()}`;
+    return crypto.createHash('sha1').update(input).digest('hex').substring(0, 12);
+}
+function generateChangeSQL(change) {
+    switch (change.objectType) {
+        case 'EXTENSION':
+            return generateExtensionSQL(change);
+        case 'ENUM':
+            return generateEnumSQL(change);
+        case 'ENUM_VALUE':
+            return generateEnumValueSQL(change);
+        case 'DOMAIN':
+            return generateDomainSQL(change);
+        case 'COMPOSITE_TYPE':
+            return generateCompositeTypeSQL(change);
+        case 'SEQUENCE':
+            return generateSequenceSQL(change);
+        case 'TABLE':
+            return generateTableSQL(change);
+        case 'COLUMN':
+            return generateColumnSQL(change);
+        case 'INDEX':
+            return generateIndexSQL(change);
+        case 'CONSTRAINT':
+        case 'PRIMARY_KEY':
+        case 'FOREIGN_KEY':
+        case 'CHECK':
+        case 'EXCLUSION':
+            return generateConstraintSQL(change);
+        case 'PARTITION':
+            return generatePartitionSQL(change);
+        case 'VIEW':
+            return generateViewSQL(change);
+        case 'MATERIALIZED_VIEW':
+            return generateMaterializedViewSQL(change);
+        case 'FUNCTION':
+        case 'PROCEDURE':
+            return generateFunctionSQL(change);
+        case 'TRIGGER':
+            return generateTriggerSQL(change);
+        case 'FOREIGN_SERVER':
+            return generateForeignServerSQL(change);
+        case 'FOREIGN_TABLE':
+            return generateForeignTableSQL(change);
+        default:
+            return `-- Unsupported object type: ${change.objectType}`;
+    }
+}
+function generateExtensionSQL(change) {
+    if (change.type === 'CREATE') {
+        return `CREATE EXTENSION IF NOT EXISTS "${change.objectName}";`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP EXTENSION IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateEnumSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const values = data.values.map(v => `'${v}'`).join(', ');
+        return `CREATE TYPE "${data.name}" AS ENUM (${values});`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TYPE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateEnumValueSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const afterClause = data.after ? ` AFTER '${data.after}'` : '';
+        return `ALTER TYPE "${data.enumName}" ADD VALUE IF NOT EXISTS '${data.value}'${afterClause};`;
+    }
+    return '';
+}
+function generateDomainSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE DOMAIN "${data.name}" AS ${data.baseType}`;
+        if (data.default)
+            sql += ` DEFAULT ${data.default}`;
+        if (data.notNull)
+            sql += ' NOT NULL';
+        if (data.check)
+            sql += ` CHECK (${data.check})`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP DOMAIN IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateCompositeTypeSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const attrs = data.attributes.map(a => `    "${a.name}" ${a.type}`).join(',\n');
+        return `CREATE TYPE "${data.name}" AS (\n${attrs}\n);`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TYPE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateSequenceSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE SEQUENCE IF NOT EXISTS "${data.name}"`;
+        if (data.startWith)
+            sql += ` START WITH ${data.startWith}`;
+        if (data.incrementBy)
+            sql += ` INCREMENT BY ${data.incrementBy}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP SEQUENCE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateTableSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const colDefs = [];
+        const constraintDefs = [];
+        for (const col of data.columns) {
+            let def = `    "${col.name}" ${col.dataType}`;
+            if (col.isPrimaryKey)
+                def += ' PRIMARY KEY';
+            if (!col.isNullable && !col.isPrimaryKey)
+                def += ' NOT NULL';
+            if (col.isUnique && !col.isPrimaryKey)
+                def += ' UNIQUE';
+            if (col.defaultValue)
+                def += ` DEFAULT ${col.defaultValue}`;
+            if (col.references) {
+                def += ` REFERENCES "${col.references.table}"("${col.references.column}")`;
+            }
+            colDefs.push(def);
+        }
+        for (const con of data.constraints || []) {
+            constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
+        }
+        const allDefs = [...colDefs, ...constraintDefs].join(',\n');
+        let sql = `CREATE TABLE "${data.name}" (\n${allDefs}\n)`;
+        if (data.isPartitioned && data.partitionType && data.partitionKey?.length) {
+            sql += ` PARTITION BY ${data.partitionType} (${data.partitionKey.join(', ')})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TABLE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateColumnSQL(change) {
+    const tableName = change.parentName;
+    if (!tableName)
+        return '';
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `ALTER TABLE "${tableName}" ADD COLUMN "${data.name}" ${data.dataType}`;
+        if (!data.isNullable)
+            sql += ' NOT NULL';
+        if (data.defaultValue)
+            sql += ` DEFAULT ${data.defaultValue}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    else if (change.type === 'ALTER' && data) {
+        const before = change.before;
+        const lines = [];
+        if (before?.dataType !== data.dataType) {
+            lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" TYPE ${data.dataType};`);
+        }
+        if (before?.isNullable !== data.isNullable) {
+            if (data.isNullable) {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" DROP NOT NULL;`);
+            }
+            else {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" SET NOT NULL;`);
+            }
+        }
+        if (before?.defaultValue !== data.defaultValue) {
+            if (data.defaultValue) {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" SET DEFAULT ${data.defaultValue};`);
+            }
+            else {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" DROP DEFAULT;`);
+            }
+        }
+        return lines.join('\n');
+    }
+    return '';
+}
+function generateIndexSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const unique = data.isUnique ? 'UNIQUE ' : '';
+        const using = data.type && data.type !== 'btree' ? ` USING ${data.type}` : '';
+        const cols = data.columns.map(c => `"${c}"`).join(', ');
+        let sql = `CREATE ${unique}INDEX IF NOT EXISTS "${data.name}" ON "${data.tableName}"${using} (${cols})`;
+        if (data.where)
+            sql += ` WHERE ${data.where}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP INDEX IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateConstraintSQL(change) {
+    const tableName = change.parentName;
+    if (!tableName)
+        return '';
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${data.name}" ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generatePartitionSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE TABLE "${data.name}" PARTITION OF "${data.parentTable}" ${data.bound};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TABLE IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateViewSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE OR REPLACE VIEW "${data.name}" AS ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP VIEW IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateMaterializedViewSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE MATERIALIZED VIEW IF NOT EXISTS "${data.name}" AS ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP MATERIALIZED VIEW IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateFunctionSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const args = data.args || '';
+        const volatility = data.volatility || 'VOLATILE';
+        return `CREATE OR REPLACE FUNCTION "${data.name}"(${args})
+RETURNS ${data.returns}
+LANGUAGE ${data.language}
+${volatility}
+AS $$
+${data.body}
+$$;`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP FUNCTION IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateTriggerSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE TRIGGER "${data.name}"
+    ${data.timing} ${data.event} ON "${data.tableName}"
+    FOR EACH ROW EXECUTE FUNCTION ${data.functionName}();`;
+    }
+    else if (change.type === 'DROP' && change.parentName) {
+        return `DROP TRIGGER IF EXISTS "${change.objectName}" ON "${change.parentName}";`;
+    }
+    return '';
+}
+function generateForeignServerSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE SERVER IF NOT EXISTS "${data.name}" FOREIGN DATA WRAPPER ${data.fdw}`;
+        if (data.options && Object.keys(data.options).length > 0) {
+            const opts = Object.entries(data.options)
+                .map(([k, v]) => `${k} '${v}'`)
+                .join(', ');
+            sql += ` OPTIONS (${opts})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP SERVER IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateForeignTableSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const cols = data.columns.map(c => `    "${c.name}" ${c.type}`).join(',\n');
+        let sql = `CREATE FOREIGN TABLE IF NOT EXISTS "${data.name}" (\n${cols}\n) SERVER "${data.serverName}"`;
+        if (data.options && Object.keys(data.options).length > 0) {
+            const opts = Object.entries(data.options)
+                .map(([k, v]) => `${k} '${v}'`)
+                .join(', ');
+            sql += ` OPTIONS (${opts})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP FOREIGN TABLE IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function createChange(type, objectType, objectName, before, after, parentName) {
+    const id = generateChangeId(type, objectType, objectName, parentName);
+    const change = {
+        id,
+        type,
+        objectType,
+        objectName,
+        parentName,
+        before,
+        after,
+        sql: '',
+        detectedAt: new Date().toISOString(),
+    };
+    change.sql = generateChangeSQL(change);
+    return change;
+}
+function getChangeDisplayName(change) {
+    const prefix = change.type === 'CREATE' ? '+' :
+        change.type === 'DROP' ? '-' :
+            change.type === 'ALTER' ? '~' :
+                '>';
+    if (change.parentName) {
+        return `${prefix} ${change.objectType} ${change.parentName}.${change.objectName}`;
+    }
+    return `${prefix} ${change.objectType} ${change.objectName}`;
+}
+function sortChangesByDependency(changes) {
+    const order = {
+        'EXTENSION': 1,
+        'SCHEMA': 2,
+        'ENUM': 3,
+        'DOMAIN': 4,
+        'COMPOSITE_TYPE': 5,
+        'SEQUENCE': 6,
+        'FOREIGN_SERVER': 7,
+        'TABLE': 10,
+        'PARTITION': 11,
+        'COLUMN': 12,
+        'INDEX': 13,
+        'CONSTRAINT': 14,
+        'PRIMARY_KEY': 14,
+        'FOREIGN_KEY': 15,
+        'CHECK': 14,
+        'EXCLUSION': 14,
+        'VIEW': 20,
+        'MATERIALIZED_VIEW': 21,
+        'FUNCTION': 30,
+        'PROCEDURE': 31,
+        'TRIGGER': 40,
+        'ENUM_VALUE': 3,
+        'FOREIGN_TABLE': 8,
+    };
+    return [...changes].sort((a, b) => {
+        if (a.type === 'CREATE' && b.type === 'DROP')
+            return -1;
+        if (a.type === 'DROP' && b.type === 'CREATE')
+            return 1;
+        return (order[a.objectType] || 50) - (order[b.objectType] || 50);
+    });
+}
+function generateCombinedSQL(changes) {
+    const sorted = sortChangesByDependency(changes);
+    const lines = [
+        '--',
+        '-- Generated by Relq CLI',
+        `-- Generated at: ${new Date().toISOString()}`,
+        '--',
+        '',
+    ];
+    let currentSection = '';
+    for (const change of sorted) {
+        const section = change.objectType;
+        if (section !== currentSection) {
+            lines.push(`-- ${section}s`);
+            currentSection = section;
+        }
+        if (change.sql) {
+            lines.push(change.sql);
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}

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

@@ -0,0 +1,239 @@
+"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.ensureRelqDir = ensureRelqDir;
+exports.getLocalCommits = getLocalCommits;
+exports.saveLocalCommits = saveLocalCommits;
+exports.getLocalHead = getLocalHead;
+exports.setLocalHead = setLocalHead;
+exports.addLocalCommit = addLocalCommit;
+exports.getLatestLocalCommit = getLatestLocalCommit;
+exports.ensureCommitsTable = ensureCommitsTable;
+exports.getRemoteCommits = getRemoteCommits;
+exports.getLatestRemoteCommit = getLatestRemoteCommit;
+exports.addRemoteCommit = addRemoteCommit;
+exports.createCommit = createCommit;
+exports.checkSyncStatus = checkSyncStatus;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const schema_hash_1 = require("./schema-hash.cjs");
+const RELQ_DIR = '.relq';
+const COMMITS_FILE = 'commits.json';
+const HEAD_FILE = 'HEAD';
+function ensureRelqDir(baseDir = process.cwd()) {
+    const relqPath = path.join(baseDir, RELQ_DIR);
+    if (!fs.existsSync(relqPath)) {
+        fs.mkdirSync(relqPath, { recursive: true });
+    }
+    return relqPath;
+}
+function getLocalCommits(baseDir = process.cwd()) {
+    const filePath = path.join(baseDir, RELQ_DIR, COMMITS_FILE);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const data = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+function saveLocalCommits(commits, baseDir = process.cwd()) {
+    ensureRelqDir(baseDir);
+    const filePath = path.join(baseDir, RELQ_DIR, COMMITS_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(commits, null, 2), 'utf-8');
+}
+function getLocalHead(baseDir = process.cwd()) {
+    const filePath = path.join(baseDir, RELQ_DIR, HEAD_FILE);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, 'utf-8').trim() || null;
+}
+function setLocalHead(hash, baseDir = process.cwd()) {
+    ensureRelqDir(baseDir);
+    const filePath = path.join(baseDir, RELQ_DIR, HEAD_FILE);
+    fs.writeFileSync(filePath, hash, 'utf-8');
+}
+function addLocalCommit(commit, limit = 1000, baseDir = process.cwd()) {
+    const commits = getLocalCommits(baseDir);
+    commits.push(commit);
+    while (commits.length > limit) {
+        commits.shift();
+    }
+    saveLocalCommits(commits, baseDir);
+    setLocalHead(commit.hash, baseDir);
+}
+function getLatestLocalCommit(baseDir = process.cwd()) {
+    const commits = getLocalCommits(baseDir);
+    return commits.length > 0 ? commits[commits.length - 1] : null;
+}
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _relq_commits (
+    id SERIAL PRIMARY KEY,
+    hash VARCHAR(40) UNIQUE NOT NULL,
+    parent_hash VARCHAR(40),
+    schema_snapshot JSONB NOT NULL,
+    author VARCHAR(255) NOT NULL,
+    message TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_relq_commits_created 
+    ON _relq_commits(created_at DESC);
+`;
+async function ensureCommitsTable(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_SQL);
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function getRemoteCommits(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 {
+        await ensureCommitsTable(connection);
+        const result = await pool.query(`
+            SELECT id, hash, parent_hash, schema_snapshot, author, message, created_at
+            FROM _relq_commits
+            ORDER BY created_at DESC
+            LIMIT $1
+        `, [limit]);
+        return result.rows.map((row) => ({
+            id: row.id,
+            hash: row.hash,
+            parentHash: row.parent_hash,
+            schemaSnapshot: row.schema_snapshot,
+            author: row.author,
+            message: row.message,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function getLatestRemoteCommit(connection) {
+    const commits = await getRemoteCommits(connection, 1);
+    return commits.length > 0 ? commits[0] : null;
+}
+async function addRemoteCommit(connection, commit, limit = 1000) {
+    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 ensureCommitsTable(connection);
+        await pool.query(`
+            INSERT INTO _relq_commits (hash, parent_hash, schema_snapshot, author, message)
+            VALUES ($1, $2, $3, $4, $5)
+            ON CONFLICT (hash) DO NOTHING
+        `, [
+            commit.hash,
+            commit.parentHash || null,
+            JSON.stringify(commit.schemaSnapshot),
+            commit.author,
+            commit.message || null,
+        ]);
+        await pool.query(`
+            DELETE FROM _relq_commits
+            WHERE id NOT IN (
+                SELECT id FROM _relq_commits
+                ORDER BY created_at DESC
+                LIMIT $1
+            )
+        `, [limit]);
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function createCommit(connection, schema, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const hash = (0, schema_hash_1.generateSchemaHash)(schema);
+    const normalized = (0, schema_hash_1.normalizeSchema)(schema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: normalized,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    await addRemoteCommit(connection, commit, commitLimit);
+    return commit;
+}
+async function checkSyncStatus(connection, baseDir = process.cwd()) {
+    const localHead = getLocalHead(baseDir);
+    const remoteCommit = await getLatestRemoteCommit(connection);
+    const remoteHead = remoteCommit?.hash || null;
+    const localCommits = getLocalCommits(baseDir);
+    const remoteCommits = await getRemoteCommits(connection, 100);
+    const inSync = localHead === remoteHead;
+    const localHashes = new Set(localCommits.map(c => c.hash));
+    const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+    const localAhead = [...localHashes].filter(h => !remoteHashes.has(h)).length;
+    const remoteAhead = [...remoteHashes].filter(h => !localHashes.has(h)).length;
+    return { inSync, localHead, remoteHead, localAhead, remoteAhead };
+}